/*
 * Copyright 2002 Ove Kaaven
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
 */

import "objidl.idl";

interface IDispatch;
interface ITypeInfo;
interface ITypeLib;
interface IRecordInfo;

[
  version(1.0),
  pointer_default(unique)
]
interface IOleAutomationTypes
{

typedef CY CURRENCY;

/* Safe Array */

typedef struct tagSAFEARRAYBOUND {
  ULONG cElements;
  LONG lLbound;
} SAFEARRAYBOUND, *LPSAFEARRAYBOUND;

typedef [unique] struct _wireVARIANT *wireVARIANT;
typedef [unique] struct _wireBRECORD *wireBRECORD;

typedef struct _wireSAFEARR_BSTR {
  ULONG Size;
  [size_is(Size), ref] wireBSTR *aBstr;
} SAFEARR_BSTR;

typedef struct _wireSAFEARR_UNKNOWN {
  ULONG Size;
  [size_is(Size), ref] IUnknown **apUnknown;
} SAFEARR_UNKNOWN;

typedef struct _wireSAFEARR_DISPATCH {
  ULONG Size;
  [size_is(Size), ref] IDispatch **apDispatch;
} SAFEARR_DISPATCH;

typedef struct _wireSAFEARR_VARIANT {
  ULONG Size;
  [size_is(Size), ref] wireVARIANT *aVariant;
} SAFEARR_VARIANT;

typedef struct _wireSAFEARR_BRECORD {
  ULONG Size;
  [size_is(Size), ref] wireBRECORD *aRecord;
} SAFEARR_BRECORD;

typedef struct _wireSAFEARR_HAVEIID {
  ULONG Size;
  [size_is(Size), ref] IUnknown **apUnknown;
  IID iid;
} SAFEARR_HAVEIID;

typedef [v1_enum] enum tagSF_TYPE {
  SF_ERROR    = VT_ERROR,
  SF_I1       = VT_I1,
  SF_I2       = VT_I2,
  SF_I4       = VT_I4,
  SF_I8       = VT_I8,
  SF_BSTR     = VT_BSTR,
  SF_UNKNOWN  = VT_UNKNOWN,
  SF_DISPATCH = VT_DISPATCH,
  SF_VARIANT  = VT_VARIANT,
  SF_RECORD   = VT_RECORD,
  SF_HAVEIID  = VT_UNKNOWN|VT_RESERVED,
} SF_TYPE;

typedef union _wireSAFEARRAY_UNION switch(ULONG sfType) u {
  case SF_BSTR:     SAFEARR_BSTR BstrStr;
  case SF_UNKNOWN:  SAFEARR_UNKNOWN UnknownStr;
  case SF_DISPATCH: SAFEARR_DISPATCH DispatchStr;
  case SF_VARIANT:  SAFEARR_VARIANT VariantStr;
  case SF_RECORD:   SAFEARR_BRECORD RecordStr;
  case SF_HAVEIID:  SAFEARR_HAVEIID HaveIidStr;
  case SF_I1:       BYTE_SIZEDARR ByteStr;
  case SF_I2:       WORD_SIZEDARR WordStr;
  case SF_I4:       DWORD_SIZEDARR LongStr;
  case SF_I8:       HYPER_SIZEDARR HyperStr;
} SAFEARRAYUNION;

typedef [unique] struct _wireSAFEARRAY {
  USHORT cDims;
  USHORT fFeatures;
  ULONG cbElements;
  ULONG cLocks;
  SAFEARRAYUNION uArrayStructs;
  [size_is(cDims)] SAFEARRAYBOUND rgsabound[];
} *wireSAFEARRAY;

typedef [unique] wireSAFEARRAY *wirePSAFEARRAY;

typedef struct tagSAFEARRAY {
  USHORT cDims;
  USHORT fFeatures;
  ULONG cbElements;
  ULONG cLocks;
  PVOID pvData;
  SAFEARRAYBOUND rgsabound[];
} SAFEARRAY;

typedef [wire_marshal(wirePSAFEARRAY)] SAFEARRAY *LPSAFEARRAY;

const USHORT FADF_AUTO        = 0x0001;
const USHORT FADF_STATIC      = 0x0002;
const USHORT FADF_EMBEDDED    = 0x0004;
const USHORT FADF_FIXEDSIZE   = 0x0010;
const USHORT FADF_RECORD      = 0x0020;
const USHORT FADF_HAVEIID     = 0x0040;
const USHORT FADF_HAVEVARTYPE = 0x0080;
const USHORT FADF_BSTR        = 0x0100;
const USHORT FADF_UNKNOWN     = 0x0200;
const USHORT FADF_DISPATCH    = 0x0400;
const USHORT FADF_VARIANT     = 0x0800;
const USHORT FADF_RESERVED    = 0xF008;
/* Undocumented flags */
const USHORT FADF_DATADELETED  = 0x1000; /* Data in a vector has been deleted */
const USHORT FADF_CREATEVECTOR = 0x2000; /* This array is a vector */

/* Variant */

cpp_quote("#if (__STDC__ && !defined(_FORCENAMELESSUNION)) || defined(NONAMELESSUNION)")
cpp_quote("#define __VARIANT_NAME_1 n1")
cpp_quote("#define __VARIANT_NAME_2 n2")
cpp_quote("#define __VARIANT_NAME_3 n3")
cpp_quote("#define __VARIANT_NAME_4 brecVal")
cpp_quote("#else")
cpp_quote("#define __tagVARIANT")
cpp_quote("#define __VARIANT_NAME_1")
cpp_quote("#define __VARIANT_NAME_2")
cpp_quote("#define __VARIANT_NAME_3")
cpp_quote("#define __tagBRECORD")
cpp_quote("#define __VARIANT_NAME_4")
cpp_quote("#endif")

typedef [wire_marshal(wireVARIANT)] struct tagVARIANT VARIANT;

struct tagVARIANT {
  union {
    struct __tagVARIANT {
      VARTYPE vt;
      WORD wReserved1;
      WORD wReserved2;
      WORD wReserved3;
      union {
        signed char cVal;
        USHORT uiVal;
        ULONG ulVal;
        INT intVal;
        UINT uintVal;
        BYTE bVal;
        SHORT iVal;
        LONG lVal;
        FLOAT fltVal;
        DOUBLE dblVal;
        VARIANT_BOOL boolVal;
#if 0 /* illegal in C++ */
        _VARIANT_BOOL bool;
#endif
        SCODE scode;
        DATE date;
        BSTR bstrVal;
        CY cyVal;
        IUnknown *punkVal;
        IDispatch *pdispVal;
        SAFEARRAY *parray;
        LONGLONG llVal;
        ULONGLONG ullVal;
        signed char *pcVal;
        USHORT *puiVal;
        ULONG *pulVal;
        INT *pintVal;
        UINT *puintVal;
        BYTE *pbVal;
        SHORT *piVal;
        LONG *plVal;
        FLOAT *pfltVal;
        DOUBLE *pdblVal;
        VARIANT_BOOL *pboolVal;
#if 0
        _VARIANT_BOOL *pbool;
#endif
        SCODE *pscode;
        DATE *pdate;
        BSTR *pbstrVal;
        VARIANT *pvarVal;
        PVOID byref;
        CY *pcyVal;
        DECIMAL *pdecVal;
        IUnknown **ppunkVal;
        IDispatch **ppdispVal;
        SAFEARRAY **pparray;
        LONGLONG *pllVal;
        ULONGLONG *pullVal;
        struct __tagBRECORD {
          PVOID pvRecord;
          IRecordInfo *pRecInfo;
        } __VARIANT_NAME_4;
      } __VARIANT_NAME_3;
    } __VARIANT_NAME_2;

    DECIMAL decVal;
  } __VARIANT_NAME_1;
};

typedef VARIANT *LPVARIANT;
typedef VARIANT VARIANTARG;
typedef VARIANTARG *LPVARIANTARG;

struct _wireBRECORD {
  ULONG fFlags;
  ULONG clSize;
  IRecordInfo *pRecInfo;
  [size_is(clSize)] byte *pRecord;
};

struct _wireVARIANT {
  DWORD clSize;
  DWORD rpcReserved;
  USHORT vt;
  USHORT wReserved1;
  USHORT wReserved2;
  USHORT wReserved3;
  [switch_is(vt)] union {
  [case(VT_EMPTY, VT_NULL)]    ;
  [case(VT_I1)]                signed char cVal;
  [case(VT_UI2)]               USHORT uiVal;
  [case(VT_UI4)]               ULONG ulVal;
  [case(VT_INT)]               INT intVal;
  [case(VT_UINT)]              UINT uintVal;
  [case(VT_UI1)]               BYTE bVal;
  [case(VT_I2)]                SHORT iVal;
  [case(VT_I4)]                LONG lVal;
  [case(VT_R4)]                FLOAT fltVal;
  [case(VT_R8)]                DOUBLE dblVal;
  [case(VT_BOOL)]              VARIANT_BOOL boolVal;
  [case(VT_ERROR)]             SCODE scode;
  [case(VT_DATE)]              DATE date;
  [case(VT_BSTR)]              wireBSTR bstrVal;
  [case(VT_CY)]                CY cyVal;
  [case(VT_DECIMAL)]           DECIMAL decVal;
  [case(VT_UNKNOWN)]           IUnknown *punkVal;
  [case(VT_DISPATCH)]          IDispatch *pdispVal;
  [case(VT_ARRAY)]             wireSAFEARRAY parray;
  [case(VT_I1|VT_BYREF)]       signed char *pcVal;
  [case(VT_UI2|VT_BYREF)]      USHORT *puiVal;
  [case(VT_UI4|VT_BYREF)]      ULONG *pulVal;
  [case(VT_INT|VT_BYREF)]      INT *pintVal;
  [case(VT_UINT|VT_BYREF)]     UINT *puintVal;
  [case(VT_UI1|VT_BYREF)]      BYTE *pbVal;
  [case(VT_I2|VT_BYREF)]       SHORT *piVal;
  [case(VT_I4|VT_BYREF)]       LONG *plVal;
  [case(VT_R4|VT_BYREF)]       FLOAT *pfltVal;
  [case(VT_R8|VT_BYREF)]       DOUBLE *pdblVal;
  [case(VT_BOOL|VT_BYREF)]     VARIANT_BOOL *pboolVal;
  [case(VT_ERROR|VT_BYREF)]    SCODE *pscode;
  [case(VT_DATE|VT_BYREF)]     DATE *pdate;
  [case(VT_BSTR|VT_BYREF)]     wireBSTR *pbstrVal;
  [case(VT_VARIANT|VT_BYREF)]  wireVARIANT *pvarVal;
  [case(VT_CY|VT_BYREF)]       CY *pcyVal;
  [case(VT_DECIMAL|VT_BYREF)]  DECIMAL *pdecVal;
  [case(VT_UNKNOWN|VT_BYREF)]  IUnknown **ppunkVal;
  [case(VT_DISPATCH|VT_BYREF)] IDispatch **ppdispVal;
  [case(VT_ARRAY|VT_BYREF)]    wireSAFEARRAY *pparray;
  [case(VT_RECORD, VT_RECORD|VT_BYREF)] wireBRECORD brecVal;
  };
};

/* Dispatch */

typedef LONG DISPID;
typedef DWORD HREFTYPE;
typedef DISPID MEMBERID;

typedef [v1_enum] enum tagTYPEKIND {
  TKIND_ENUM = 0,
  TKIND_RECORD,
  TKIND_MODULE,
  TKIND_INTERFACE,
  TKIND_DISPATCH,
  TKIND_COCLASS,
  TKIND_ALIAS,
  TKIND_UNION,
  TKIND_MAX
} TYPEKIND;

typedef struct tagTYPEDESC {
  [switch_is(vt)] union {
  [case(VT_PTR, VT_SAFEARRAY)] struct tagTYPEDESC *lptdesc;
  [case(VT_CARRAY)]            struct tagARRAYDESC *lpadesc;
  [case(VT_USERDEFINED)]       HREFTYPE hreftype;
  [default]                    ;
  };
  VARTYPE vt;
} TYPEDESC;

typedef struct tagARRAYDESC {
  TYPEDESC tdescElem;
  USHORT cDims;
  [size_is(cDims)] SAFEARRAYBOUND rgbounds[];
} ARRAYDESC;

typedef struct tagPARAMDESCEX {
  ULONG cBytes;
  VARIANTARG varDefaultValue;
} PARAMDESCEX, *LPPARAMDESCEX;

typedef struct tagPARAMDESC {
  LPPARAMDESCEX pparamdescex;
  USHORT wParamFlags;
} PARAMDESC, *LPPARAMDESC;

const USHORT PARAMFLAG_NONE         = 0x00;
const USHORT PARAMFLAG_FIN          = 0x01;
const USHORT PARAMFLAG_FOUT         = 0x02;
const USHORT PARAMFLAG_FLCID        = 0x04;
const USHORT PARAMFLAG_FRETVAL      = 0x08;
const USHORT PARAMFLAG_FOPT         = 0x10;
const USHORT PARAMFLAG_FHASDEFAULT  = 0x20;
const USHORT PARAMFLAG_FHASCUSTDATA = 0x40;

typedef struct tagIDLDESC {
  ULONG dwReserved;
  USHORT wIDLFlags;
} IDLDESC, *LPIDLDESC;

const USHORT IDLFLAG_NONE    = PARAMFLAG_NONE;
const USHORT IDLFLAG_FIN     = PARAMFLAG_FIN;
const USHORT IDLFLAG_FOUT    = PARAMFLAG_FOUT;
const USHORT IDLFLAG_FLCID   = PARAMFLAG_FLCID;
const USHORT IDLFLAG_FRETVAL = PARAMFLAG_FRETVAL;

cpp_quote("#if 0") /* for IDL only */
typedef struct tagELEMDESC {
  TYPEDESC tdesc;
  PARAMDESC paramdesc;
} ELEMDESC;
cpp_quote("#else") /* C/C++ defs */
cpp_quote("typedef struct tagELEMDESC {")
cpp_quote("  TYPEDESC tdesc;")
cpp_quote("  union {")
cpp_quote("    IDLDESC idldesc;")
cpp_quote("    PARAMDESC paramdesc;")
cpp_quote("  } DUMMYUNIONNAME;")
cpp_quote("} ELEMDESC, *LPELEMDESC;")
cpp_quote("#endif")

typedef struct tagTYPEATTR {
  GUID guid;
  LCID lcid;
  DWORD dwReserved;
  MEMBERID memidConstructor;
  MEMBERID memidDestructor;
  LPOLESTR lpstrSchema;
  ULONG cbSizeInstance;
  TYPEKIND typekind;
  WORD cFuncs;
  WORD cVars;
  WORD cImplTypes;
  WORD cbSizeVft;
  WORD cbAlignment;
  WORD wTypeFlags;
  WORD wMajorVerNum;
  WORD wMinorVerNum;
  TYPEDESC tdescAlias;
  IDLDESC idldescType;
} TYPEATTR, *LPTYPEATTR;

typedef struct tagDISPPARAMS {
  [size_is(cArgs)] VARIANTARG *rgvarg;
  [size_is(cNamedArgs)] DISPID *rgdispidNamedArgs;
  UINT cArgs;
  UINT cNamedArgs;
} DISPPARAMS;

cpp_quote("#if 0") /* for IDL only */
typedef struct tagEXCEPINFO {
  WORD wCode;
  WORD wReserved;
  BSTR bstrSource;
  BSTR bstrDescription;
  BSTR bstrHelpFile;
  DWORD dwHelpContext;
  ULONG pvReserved;
  ULONG pfnDeferredFillIn;
  SCODE scode;
} EXCEPINFO;
cpp_quote("#else")
cpp_quote("typedef struct tagEXCEPINFO {")
cpp_quote("  WORD wCode;")
cpp_quote("  WORD wReserved;")
cpp_quote("  BSTR bstrSource;")
cpp_quote("  BSTR bstrDescription;")
cpp_quote("  BSTR bstrHelpFile;")
cpp_quote("  DWORD dwHelpContext;")
cpp_quote("  PVOID pvReserved;")
cpp_quote("  HRESULT (__stdcall *pfnDeferredFillIn)(struct tagEXCEPINFO *);")
cpp_quote("  SCODE scode;")
cpp_quote("} EXCEPINFO, *LPEXCEPINFO;")
cpp_quote("#endif")

typedef [v1_enum] enum tagCALLCONV {
  CC_FASTCALL = 0,
  CC_CDECL = 1,
  CC_MSCPASCAL,
  CC_PASCAL = CC_MSCPASCAL,
  CC_MACPASCAL,
  CC_STDCALL,
  CC_FPFASTCALL,
  CC_SYSCALL,
  CC_MPWCDECL,
  CC_MPWPASCAL,
  CC_MAX
} CALLCONV;

typedef [v1_enum] enum tagFUNCKIND {
  FUNC_VIRTUAL,
  FUNC_PUREVIRTUAL,
  FUNC_NONVIRTUAL,
  FUNC_STATIC,
  FUNC_DISPATCH
} FUNCKIND;

typedef [v1_enum] enum tagINVOKEKIND {
  INVOKE_FUNC = 1,
  INVOKE_PROPERTYGET = 2,
  INVOKE_PROPERTYPUT = 4,
  INVOKE_PROPERTYPUTREF = 8
} INVOKEKIND;

typedef struct tagFUNCDESC {
  MEMBERID memid;
  [size_is(cScodes)] SCODE *lprgscode;
  [size_is(cParams)] ELEMDESC *lprgelemdescParam;
  FUNCKIND funckind;
  INVOKEKIND invkind;
  CALLCONV callconv;
  SHORT cParams;
  SHORT cParamsOpt;
  SHORT oVft;
  SHORT cScodes;
  ELEMDESC elemdescFunc;
  WORD wFuncFlags;
} FUNCDESC, *LPFUNCDESC;

typedef [v1_enum] enum tagVARKIND {
  VAR_PERINSTANCE,
  VAR_STATIC,
  VAR_CONST,
  VAR_DISPATCH
} VARKIND;

const USHORT IMPLTYPEFLAG_FDEFAULT       = 0x1;
const USHORT IMPLTYPEFLAG_FSOURCE        = 0x2;
const USHORT IMPLTYPEFLAG_FRESTRICTED    = 0x4;
const USHORT IMPLTYPEFLAG_FDEFAULTVTABLE = 0x8;

typedef struct tagVARDESC {
  MEMBERID memid;
  LPOLESTR lpstrSchema;
  [switch_is(varkind)] union {
  [case(VAR_PERINSTANCE, VAR_DISPATCH, VAR_STATIC)] ULONG oInst;
  [case(VAR_CONST)] VARIANT *lpvarValue;
  };
  ELEMDESC elemdescVar;
  WORD wVarFlags;
  VARKIND varkind;
} VARDESC, *LPVARDESC;

typedef enum tagTYPEFLAGS {
  TYPEFLAG_FAPPOBJECT     = 0x0001,
  TYPEFLAG_FCANCREATE     = 0x0002,
  TYPEFLAG_FLICENSED      = 0x0004,
  TYPEFLAG_FPREDECLID     = 0x0008,
  TYPEFLAG_FHIDDEN        = 0x0010,
  TYPEFLAG_FCONTROL       = 0x0020,
  TYPEFLAG_FDUAL          = 0x0040,
  TYPEFLAG_FNONEXTENSIBLE = 0x0080,
  TYPEFLAG_FOLEAUTOMATION = 0x0100,
  TYPEFLAG_FRESTRICTED    = 0x0200,
  TYPEFLAG_FAGGREGATABLE  = 0x0400,
  TYPEFLAG_FREPLACEABLE   = 0x0800,
  TYPEFLAG_FDISPATCHABLE  = 0x1000,
  TYPEFLAG_FREVERSEBIND   = 0x2000,
  TYPEFLAG_FPROXY         = 0x4000
} TYPEFLAGS;

typedef enum tagFUNCFLAGS {
  FUNCFLAG_FRESTRICTED       = 0x0001,
  FUNCFLAG_FSOURCE           = 0x0002,
  FUNCFLAG_FBINDABLE         = 0x0004,
  FUNCFLAG_FREQUESTEDIT      = 0x0008,
  FUNCFLAG_FDISPLAYBIND      = 0x0010,
  FUNCFLAG_FDEFAULTBIND      = 0x0020,
  FUNCFLAG_FHIDDEN           = 0x0040,
  FUNCFLAG_FUSESGETLASTERROR = 0x0080,
  FUNCFLAG_FDEFAULTCOLLELEM  = 0x0100,
  FUNCFLAG_FUIDEFAULT        = 0x0200,
  FUNCFLAG_FNONBROWSABLE     = 0x0400,
  FUNCFLAG_FREPLACEABLE      = 0x0800,
  FUNCFLAG_FIMMEDIATEBIND    = 0x1000
} FUNCFLAGS;

typedef enum tagVARFLAGS {
  VARFLAG_FREADONLY        = 0x0001,
  VARFLAG_FSOURCE          = 0x0002,
  VARFLAG_FBINDABLE        = 0x0004,
  VARFLAG_FREQUESTEDIT     = 0x0008,
  VARFLAG_FDISPLAYBIND     = 0x0010,
  VARFLAG_FDEFAULTBIND     = 0x0020,
  VARFLAG_FHIDDEN          = 0x0040,
  VARFLAG_FRESTRICTED      = 0x0080,
  VARFLAG_FDEFAULTCOLLELEM = 0x0100,
  VARFLAG_FUIDEFAULT       = 0x0200,
  VARFLAG_FNONBROWSABLE    = 0x0400,
  VARFLAG_FREPLACEABLE     = 0x0800,
  VARFLAG_FIMMEDIATEBIND   = 0x1000
} VARFLAGS;

typedef [wire_marshal(DWORD)] struct tagCLEANLOCALSTORAGE {
  IUnknown *pInterface;
  PVOID pStorage;
  DWORD flags;
} CLEANLOCALSTORAGE;

typedef struct tagCUSTDATAITEM {
  GUID guid;
  VARIANTARG varValue;
} CUSTDATAITEM, *LPCUSTDATAITEM;

typedef struct tagCUSTDATA {
  DWORD cCustData;
  [size_is(cCustData)] LPCUSTDATAITEM prgCustData;
} CUSTDATA, *LPCUSTDATA;

} /* interface IOleAutomationTypes */

/******************** INTERFACES ********************/

[
  object,
  uuid(00020400-0000-0000-C000-000000000046),
  pointer_default(unique)
]
interface IDispatch : IUnknown
{
  typedef [unique] IDispatch *LPDISPATCH;

  const DISPID DISPID_UNKNOWN     = -1;
  const DISPID DISPID_VALUE       =  0;
  const DISPID DISPID_PROPERTYPUT = -3;
  const DISPID DISPID_NEWENUM     = -4;
  const DISPID DISPID_EVALUATE    = -5;
  const DISPID DISPID_CONSTRUCTOR = -6;
  const DISPID DISPID_DESTRUCTOR  = -7;
  const DISPID DISPID_COLLECT     = -8;

  HRESULT GetTypeInfoCount(
    [out] UINT *pctinfo);

  HRESULT GetTypeInfo(
    [in] UINT iTInfo,
    [in] LCID lcid,
    [out] ITypeInfo **ppTInfo);

  HRESULT GetIDsOfNames(
    [in] REFIID riid,
    [in, size_is(cNames)] LPOLESTR *rgszNames,
    [in] UINT cNames,
    [in] LCID lcid,
    [out, size_is(cNames)] DISPID *rgDispId);

  [local]
  HRESULT Invoke(
    [in] DISPID dispIdMember,
    [in] REFIID riid,
    [in] LCID lcid,
    [in] WORD wFlags,
    [in, out] DISPPARAMS *pDispParams,
    [out] VARIANT *pVarResult,
    [out] EXCEPINFO *pExcepInfo,
    [out] UINT *puArgErr);

  [call_as(Invoke)]
  HRESULT RemoteInvoke(
    [in] DISPID dispIdMember,
    [in] REFIID riid,
    [in] LCID lcid,
    [in] DWORD dwFlags,
    [in] DISPPARAMS *pDispParams,
    [out] VARIANT *pVarResult,
    [out] EXCEPINFO *pExcepInfo,
    [out] UINT *pArgErr,
    [in] UINT cVarRef,
    [in, size_is(cVarRef)] UINT *rgVarRefIdx,
    [in, out, size_is(cVarRef)] VARIANTARG *rgVarRef);
}

[
  object,
  uuid(00020404-0000-0000-C000-000000000046),
  pointer_default(unique)
]
interface IEnumVARIANT : IUnknown
{
  typedef [unique] IEnumVARIANT *LPENUMVARIANT;

  [local]
  HRESULT Next(
    [in] ULONG celt,
    [out] VARIANT *rgVar,
    [out] ULONG *pCeltFetched);

  [call_as(Next)]
  HRESULT RemoteNext(
    [in] ULONG celt,
    [out, size_is(celt), length_is(*pCeltFetched)]
    VARIANT *rgVar,
    [out] ULONG *pCeltFetched);

  HRESULT Skip(
    [in] ULONG celt);

  HRESULT Reset();

  HRESULT Clone(
    [out] IEnumVARIANT **ppEnum);
}

[
  object,
  uuid(00020403-0000-0000-C000-000000000046),
  pointer_default(unique)
]
interface ITypeComp : IUnknown
{
  typedef [unique] ITypeComp *LPTYPECOMP;

  typedef [v1_enum] enum tagDESCKIND {
    DESCKIND_NONE = 0,
    DESCKIND_FUNCDESC,
    DESCKIND_VARDESC,
    DESCKIND_TYPECOMP,
    DESCKIND_IMPLICITAPPOBJ,
    DESCKIND_MAX
  } DESCKIND;

  typedef union tagBINDPTR {
    FUNCDESC *lpfuncdesc;
    VARDESC *lpvardesc;
    ITypeComp *lptcomp;
  } BINDPTR, *LPBINDPTR;

  [local]
  HRESULT Bind(
    [in] LPOLESTR szName,
    [in] ULONG lHashVal,
    [in] WORD wFlags,
    [out] ITypeInfo **ppTInfo,
    [out] DESCKIND *pDescKind,
    [out] BINDPTR *pBindPtr);

  [call_as(Bind)]
  HRESULT RemoteBind(
    [in] LPOLESTR szName,
    [in] ULONG lHashVal,
    [in] WORD wFlags,
    [out] ITypeInfo **ppTInfo,
    [out] DESCKIND *pDescKind,
    [out] LPFUNCDESC *ppFuncDesc,
    [out] LPVARDESC *ppVarDesc,
    [out] ITypeComp **ppTypeComp,
    [out] CLEANLOCALSTORAGE *pDummy);

  [local]
  HRESULT BindType(
    [in] LPOLESTR szName,
    [in] ULONG lHashVal,
    [out] ITypeInfo **ppTInfo,
    [out] ITypeComp **ppTComp);

  [call_as(BindType)]
  HRESULT RemoteBindType(
    [in] LPOLESTR szName,
    [in] ULONG lHashVal,
    [out] ITypeInfo **ppTInfo);
}

[
  object,
  uuid(00020401-0000-0000-C000-000000000046),
  pointer_default(unique)
]
interface ITypeInfo : IUnknown
{
  typedef [unique] ITypeInfo *LPTYPEINFO;

  [local]
  HRESULT GetTypeAttr(
    [out] TYPEATTR **ppTypeAttr);

  [call_as(GetTypeAttr)]
  HRESULT RemoteGetTypeAttr(
    [out] LPTYPEATTR *ppTypeAttr,
    [out] CLEANLOCALSTORAGE *pDummy);

  HRESULT GetTypeComp(
    [out] ITypeComp **ppTComp);

  [local]
  HRESULT GetFuncDesc(
    [in] UINT index,
    [out] FUNCDESC **ppFuncDesc);

  [call_as(GetFuncDesc)]
  HRESULT RemoteGetFuncDesc(
    [in] UINT index,
    [out] LPFUNCDESC *ppFuncDesc,
    [out] CLEANLOCALSTORAGE *pDummy);

  [local]
  HRESULT GetVarDesc(
    [in] UINT index,
    [out] VARDESC **ppVarDesc);

  [call_as(GetVarDesc)]
  HRESULT RemoteGetVarDesc(
    [in] UINT index,
    [out] LPVARDESC *ppVarDesc,
    [out] CLEANLOCALSTORAGE *pDummy);

  [local]
  HRESULT GetNames(
    [in] MEMBERID memid,
    [out, size_is(cMaxNames), length_is(*pcNames)] BSTR *rgBstrNames,
    [in] UINT cMaxNames,
    [out] UINT *pcNames);

  [call_as(GetNames)]
  HRESULT RemoteGetNames(
    [in] MEMBERID memid,
    [out, size_is(cMaxNames), length_is(*pcNames)] BSTR *rgBstrNames,
    [in] UINT cMaxNames,
    [out] UINT *pcNames);

  HRESULT GetRefTypeOfImplType(
    [in] UINT index,
    [out] HREFTYPE *pRefType);

  HRESULT GetImplTypeFlags(
    [in] UINT index,
    [out] INT *pImplTypeFlags);

  [local]
  HRESULT GetIDsOfNames(
    [in, size_is(cNames)] LPOLESTR *rgszNames,
    [in] UINT cNames,
    [out, size_is(cNames)] MEMBERID *pMemId);

  [call_as(GetIDsOfNames)]
  HRESULT LocalGetIDsOfNames();

  [local]
  HRESULT Invoke(
    [in] PVOID pvInstance,
    [in] MEMBERID memid,
    [in] WORD wFlags,
    [in, out] DISPPARAMS *pDispParams,
    [out] VARIANT *pVarResult,
    [out] EXCEPINFO *pExcepInfo,
    [out] UINT *puArgErr);

  [call_as(Invoke)]
  HRESULT LocalInvoke();

  [local]
  HRESULT GetDocumentation(
    [in] MEMBERID memid,
    [out] BSTR *pBstrName,
    [out] BSTR *pBstrDocString,
    [out] DWORD *pdwHelpContext,
    [out] BSTR *pBstrHelpFile);

  [call_as(GetDocumentation)]
  HRESULT RemoteGetDocumentation(
    [in] MEMBERID memid,
    [in] DWORD refPtrFlags,
    [out] BSTR *pBstrName,
    [out] BSTR *pBstrDocString,
    [out] DWORD *pdwHelpContext,
    [out] BSTR *pBstrHelpFile);

  [local]
  HRESULT GetDllEntry(
    [in] MEMBERID memid,
    [in] INVOKEKIND invKind,
    [out] BSTR *pBstrDllName,
    [out] BSTR *pBstrName,
    [out] WORD *pwOrdinal);

  [call_as(GetDllEntry)]
  HRESULT RemoteGetDllEntry(
    [in] MEMBERID memid,
    [in] INVOKEKIND invKind,
    [in] DWORD refPtrFlags,
    [out] BSTR *pBstrDllName,
    [out] BSTR *pBstrName,
    [out] WORD *pwOrdinal);

  HRESULT GetRefTypeInfo(
    [in] HREFTYPE hRefType,
    [out] ITypeInfo **ppTInfo);

  [local]
  HRESULT AddressOfMember(
    [in] MEMBERID memid,
    [in] INVOKEKIND invKind,
    [out] PVOID *ppv);

  [call_as(AddressOfMember)]
  HRESULT LocalAddressOfMember();

  [local]
  HRESULT CreateInstance(
    [in] IUnknown *pUnkOuter,
    [in] REFIID riid,
    [out, iid_is(riid)] PVOID *ppvObj);

  [call_as(CreateInstance)]
  HRESULT RemoteCreateInstance(
    [in] REFIID riid,
    [out, iid_is(riid)] IUnknown **ppvObj);

  HRESULT GetMops(
    [in] MEMBERID memid,
    [out] BSTR *pBstrMops);

  [local]
  HRESULT GetContainingTypeLib(
    [out] ITypeLib **ppTLib,
    [out] UINT *pIndex);

  [call_as(GetContainingTypeLib)]
  HRESULT RemoteGetContainingTypeLib(
    [out] ITypeLib **ppTLib,
    [out] UINT *pIndex);

  [local]
  void ReleaseTypeAttr(
    [in] TYPEATTR *pTypeAttr);

  [call_as(ReleaseTypeAttr)]
  HRESULT LocalReleaseTypeAttr();

  [local]
  void ReleaseFuncDesc(
    [in] FUNCDESC *pFuncDesc);

  [call_as(ReleaseFuncDesc)]
  HRESULT LocalReleaseFuncDesc();

  [local]
  void ReleaseVarDesc(
    [in] VARDESC *pVarDesc);

  [call_as(ReleaseVarDesc)]
  HRESULT LocalReleaseVarDesc();
}

[
  object,
  uuid(00020412-0000-0000-C000-000000000046),
  pointer_default(unique)
]
interface ITypeInfo2 : ITypeInfo
{
  typedef [unique] ITypeInfo2 *LPTYPEINFO2;

  HRESULT GetTypeKind(
    [out] TYPEKIND *pTypeKind);

  HRESULT GetTypeFlags(
    [out] ULONG *pTypeFlags);

  HRESULT GetFuncIndexOfMemId(
    [in] MEMBERID memid,
    [in] INVOKEKIND invKind,
    [out] UINT *pFuncIndex);

  HRESULT GetVarIndexOfMemId(
    [in] MEMBERID memid,
    [out] UINT *pVarIndex);

  HRESULT GetCustData(
    [in] REFGUID guid,
    [out] VARIANT *pVarVal);

  HRESULT GetFuncCustData(
    [in] UINT index,
    [in] REFGUID guid,
    [out] VARIANT *pVarVal);

  HRESULT GetParamCustData(
    [in] UINT indexFunc,
    [in] UINT indexParam,
    [in] REFGUID guid,
    [out] VARIANT *pVarVal);

  HRESULT GetVarCustData(
    [in] UINT index,
    [in] REFGUID guid,
    [out] VARIANT *pVarVal);

  HRESULT GetImplTypeCustData(
    [in] UINT index,
    [in] REFGUID guid,
    [out] VARIANT *pVarVal);

  [local]
  HRESULT GetDocumentation2(
    [in] MEMBERID memid,
    [in] LCID lcid,
    [out] BSTR *pbstrHelpString,
    [out] DWORD *pdwHelpStringContext,
    [out] BSTR *pbstrHelpStringDll);

  [call_as(GetDocumentation2)]
  HRESULT RemoteGetDocumentation2(
    [in] MEMBERID memid,
    [in] LCID lcid,
    [in] DWORD refPtrFlags,
    [out] BSTR *pbstrHelpString,
    [out] DWORD *pdwHelpStringContext,
    [out] BSTR *pbstrHelpStringDll);

  HRESULT GetAllCustData(
    [out] CUSTDATA *pCustData);

  HRESULT GetAllFuncCustData(
    [in] UINT index,
    [out] CUSTDATA *pCustData);

  HRESULT GetAllParamCustData(
    [in] UINT indexFunc,
    [in] UINT indexParam,
    [out] CUSTDATA *pCustData);

  HRESULT GetAllVarCustData(
    [in] UINT index,
    [out] CUSTDATA *pCustData);

  HRESULT GetAllImplTypeCustData(
    [in] UINT index,
    [out] CUSTDATA *pCustData);
}

[
  object,
  uuid(00020402-0000-0000-C000-000000000046),
  pointer_default(unique)
]
interface ITypeLib : IUnknown
{
  typedef [unique] ITypeLib *LPTYPELIB;

  typedef [v1_enum] enum tagSYSKIND {
    SYS_WIN16 = 0,
    SYS_WIN32,
    SYS_MAC
  } SYSKIND;

  typedef [v1_enum] enum tagLIBFLAGS {
    LIBFLAG_FRESTRICTED   = 0x01,
    LIBFLAG_FCONTROL      = 0x02,
    LIBFLAG_FHIDDEN       = 0x04,
    LIBFLAG_FHASDISKIMAGE = 0x08
  } LIBFLAGS;

  typedef struct tagTLIBATTR {
    GUID guid;
    LCID lcid;
    SYSKIND syskind;
    WORD wMajorVerNum;
    WORD wMinorVerNum;
    WORD wLibFlags;
  } TLIBATTR, *LPTLIBATTR;

  [local]
  UINT GetTypeInfoCount();

  [call_as(GetTypeInfoCount)]
  HRESULT RemoteGetTypeInfoCount(
    [out] UINT *pcTInfo);

  HRESULT GetTypeInfo(
    [in] UINT index,
    [out] ITypeInfo **ppTInfo);

  HRESULT GetTypeInfoType(
    [in] UINT index,
    [out] TYPEKIND *pTKind);

  HRESULT GetTypeInfoOfGuid(
    [in] REFGUID guid,
    [out] ITypeInfo **ppTinfo);

  [local]
  HRESULT GetLibAttr(
    [out] TLIBATTR **ppTLibAttr);

  [call_as(GetLibAttr)]
  HRESULT RemoteGetLibAttr(
    [out] LPTLIBATTR *ppTLibAttr,
    [out] CLEANLOCALSTORAGE *pDummy);

  HRESULT GetTypeComp(
    [out] ITypeComp **ppTComp);

  [local]
  HRESULT GetDocumentation(
    [in] INT index,
    [out] BSTR *pBstrName,
    [out] BSTR *pBstrDocString,
    [out] DWORD *pdwHelpContext,
    [out] BSTR *pBstrHelpFile);

  [call_as(GetDocumentation)]
  HRESULT RemoteGetDocumentation(
    [in] INT index,
    [in] DWORD refPtrFlags,
    [out] BSTR *pBstrName,
    [out] BSTR *pBstrDocString,
    [out] DWORD *pdwHelpContext,
    [out] BSTR *pBstrHelpFile);

  [local]
  HRESULT IsName(
    [in, out] LPOLESTR szNameBuf,
    [in] ULONG lHashVal,
    [out] BOOL *pfName);

  [call_as(IsName)]
  HRESULT RemoteIsName(
    [in] LPOLESTR szNameBuf,
    [in] ULONG lHashVal,
    [out] BOOL *pfName,
    [out] BSTR *pBstrLibName);

  [local]
  HRESULT FindName(
    [in, out] LPOLESTR szNameBuf,
    [in] ULONG lHashVal,
    [out, size_is(*pcFound), length_is(*pcFound)] ITypeInfo **ppTInfo,
    [out, size_is(*pcFound), length_is(*pcFound)] MEMBERID *rgMemId,
    [in, out] USHORT *pcFound);

  [call_as(FindName)]
  HRESULT RemoteFindName(
    [in] LPOLESTR szNameBuf,
    [in] ULONG lHashVal,
    [out, size_is(*pcFound), length_is(*pcFound)] ITypeInfo **ppTInfo,
    [out, size_is(*pcFound), length_is(*pcFound)] MEMBERID *rgMemId,
    [in, out] USHORT *pcFound,
    [out] BSTR *pBstrLibName);

  [local]
  void ReleaseTLibAttr(
    [in] TLIBATTR *pTLibAttr);

  [call_as(ReleaseTLibAttr)]
  HRESULT LocalReleaseTLibAttr();
}

[
  object,
  uuid(00020411-0000-0000-C000-000000000046),
  pointer_default(unique)
]
interface ITypeLib2 : ITypeLib
{
  typedef [unique] ITypeLib2 *LPTYPELIB2;

  HRESULT GetCustData(
    [in] REFGUID guid,
    [out] VARIANT *pVarVal);

  [local]
  HRESULT GetLibStatistics(
    [out] ULONG *pcUniqueNames,
    [out] ULONG *pcchUniqueNames);

  [call_as(GetLibStatistics)]
  HRESULT RemoteGetLibStatistics(
    [out] ULONG *pcUniqueNames,
    [out] ULONG *pcchUniqueNames);

  [local]
  HRESULT GetDocumentation2(
    [in] INT index,
    [in] LCID lcid,
    [out] BSTR *pbstrHelpString,
    [out] DWORD *pdwHelpStringContext,
    [out] BSTR *pbstrHelpStringDll);

  [call_as(GetDocumentation2)]
  HRESULT RemoteGetDocumentation2(
    [in] INT index,
    [in] LCID lcid,
    [in] DWORD refPtrFlags,
    [out] BSTR *pbstrHelpString,
    [out] DWORD *pdwHelpStringContext,
    [out] BSTR *pbstrHelpStringDll);

  HRESULT GetAllCustData(
    [out] CUSTDATA *pCustData);
}

[
  local,
  object,
  uuid(00020410-0000-0000-C000-000000000046),
  pointer_default(unique)
]
interface ITypeChangeEvents : IUnknown
{
  typedef [unique] ITypeChangeEvents *LPTYPECHANGEEVENTS;

  typedef enum tagCHANGEKIND {
    CHANGEKIND_ADDMEMBER,
    CHANGEKIND_DELETEMEMBER,
    CHANGEKIND_SETNAMES,
    CHANGEKIND_SETDOCUMENTATION,
    CHANGEKIND_GENERAL,
    CHANGEKIND_INVALIDATE,
    CHANGEKIND_CHANGEFAILED,
    CHANGEKIND_MAX
  } CHANGEKIND;

  HRESULT RequestTypeChange(
    [in] CHANGEKIND changeKind,
    [in] ITypeInfo *pTInfoBefore,
    [in] LPOLESTR pStrName,
    [out] INT *pfCancel);
  
  HRESULT AfterTypeChange(
    [in] CHANGEKIND changeKind,
    [in] ITypeInfo *pTInfoAfter,
    [in] LPOLESTR pStrName);
}

[
  object,
  uuid(1CF2B120-547D-101B-8E65-08002B2BD119),
  pointer_default(unique)
]
interface IErrorInfo : IUnknown
{
  typedef [unique] IErrorInfo *LPERRORINFO;

  HRESULT GetGUID(
    [out] GUID *pGUID);

  HRESULT GetSource(
    [out] BSTR *pBstrSource);

  HRESULT GetDescription(
    [out] BSTR *pBstrDescription);

  HRESULT GetHelpFile(
    [out] BSTR *pBstrHelpFile);

  HRESULT GetHelpContext(
    [out] DWORD *pdwHelpContext);
}

[
  object,
  uuid(22F03340-547D-101B-8E65-08002B2BD119),
  pointer_default(unique)
]
interface ICreateErrorInfo : IUnknown
{
  typedef [unique] ICreateErrorInfo *LPCREATEERRORINFO;

  HRESULT SetGUID(
    [in] REFGUID rguid);

  HRESULT SetSource(
    [in] LPOLESTR szSource);

  HRESULT SetDescription(
    [in] LPOLESTR szDescription);

  HRESULT SetHelpFile(
    [in] LPOLESTR szHelpFile);

  HRESULT SetHelpContext(
    [in] DWORD dwHelpContext);
}

[
  object,
  uuid(DF0B3D60-548F-101B-8E65-08002B2BD119),
  pointer_default(unique)
]
interface ISupportErrorInfo : IUnknown
{
  typedef [unique] ISupportErrorInfo *LPSUPPORTERRORINFO;

  HRESULT InterfaceSupportsErrorInfo(
    [in] REFIID riid);
}

[
  object,
  uuid(0000002E-0000-0000-C000-000000000046)
]
interface ITypeFactory : IUnknown
{
  HRESULT CreateFromTypeInfo(
    [in] ITypeInfo *pTypeInfo,
    [in] REFIID riid,
    [out, iid_is(riid)] IUnknown **ppv);
}

[
  local,
  object,
  uuid(0000002D-0000-0000-C000-000000000046)
]
interface ITypeMarshal : IUnknown
{
  HRESULT Size(
    [in] PVOID pvType,
    [in] DWORD dwDestContext,
    [in] PVOID pvDestContext,
    [out] ULONG *pSize);

  HRESULT Marshal(
    [in] PVOID pvType,
    [in] DWORD dwDestContext,
    [in] PVOID pvDestContext,
    [in] ULONG cbBufferLength,
    [out] BYTE *pBuffer,
    [out] ULONG *pcbWritten);

  HRESULT Unmarshal(
    [out] PVOID pvType,
    [in] DWORD dwFlags,
    [in] ULONG cbBufferLength,
    [in] BYTE *pBuffer,
    [out] ULONG *pcbRead);

  HRESULT Free(
    [in] PVOID pvType);
}

[
  local,
  object,
  uuid(0000002F-0000-0000-C000-000000000046)
]
interface IRecordInfo : IUnknown
{
  typedef [unique] IRecordInfo *LPRECORDINFO;

  HRESULT RecordInit(
    [out] PVOID pvNew);

  HRESULT RecordClear(
    [in] PVOID pvExisting);

  HRESULT RecordCopy(
    [in] PVOID pvExisting,
    [out] PVOID pvNew);

  HRESULT GetGuid(
    [out] GUID *pguid);

  HRESULT GetName(
    [out] BSTR *pbstrName);

  HRESULT GetSize(
    [out] ULONG *pcbSize);

  HRESULT GetTypeInfo(
    [out] ITypeInfo **ppTypeInfo);

  HRESULT GetField(
    [in] PVOID pvData,
    [in] LPCOLESTR szFieldName,
    [out] VARIANT *pvarField);

  HRESULT GetFieldNoCopy(
    [in] PVOID pvData,
    [in] LPCOLESTR szFieldName,
    [out] VARIANT *pvarField,
    [out] PVOID *ppvDataCArray);

  HRESULT PutField(
    [in] ULONG wFlags,
    [in, out] PVOID pvData,
    [in] LPCOLESTR szFieldName,
    [in] VARIANT *pvarField);

  HRESULT PutFieldNoCopy(
    [in] ULONG wFlags,
    [in, out] PVOID pvData,
    [in] LPCOLESTR szFieldName,
    [in] VARIANT *pvarField);

  HRESULT GetFieldNames(
    [in, out] ULONG *pcNames,
    [out, size_is(*pcNames), length_is(*pcNames)] BSTR *rgBstrNames);

  BOOL IsMatchingType(
    [in] IRecordInfo *pRecordInfo);

  PVOID RecordCreate();

  HRESULT RecordCreateCopy(
    [in] PVOID pvSource,
    [out] PVOID *ppvDest);

  HRESULT RecordDestroy(
    [in] PVOID pvRecord);
}

[
  local,
  object,
  uuid(00020405-0000-0000-C000-000000000046),
  pointer_default(unique)
]
interface ICreateTypeInfo : IUnknown
{
  typedef [unique] ICreateTypeInfo *LPCREATETYPEINFO;

  HRESULT SetGuid(
    [in] REFGUID guid);

  HRESULT SetTypeFlags(
    [in] UINT uTypeFlags);

  HRESULT SetDocString(
    [in] LPOLESTR pStrDoc);

  HRESULT SetHelpContext(
    [in] DWORD dwHelpContext);

  HRESULT SetVersion(
    [in] WORD wMajorVerNum,
    [in] WORD wMinorVerNum);

  HRESULT AddRefTypeInfo(
    [in] ITypeInfo *pTInfo,
    [in] HREFTYPE *phRefType);

  HRESULT AddFuncDesc(
    [in] UINT index,
    [in] FUNCDESC *pFuncDesc);

  HRESULT AddImplType(
    [in] UINT index,
    [in] HREFTYPE hRefType);

  HRESULT SetImplTypeFlags(
    [in] UINT index,
    [in] INT implTypeFlags);

  HRESULT SetAlignment(
    [in] WORD cbAlignment);

  HRESULT SetSchema(
    [in] LPOLESTR pStrSchema);

  HRESULT AddVarDesc(
    [in] UINT index,
    [in] VARDESC *pVarDesc);

  HRESULT SetFuncAndParamNames(
    [in] UINT index,
    [in, size_is(cNames)] LPOLESTR *rgszNames,
    [in] UINT cNames);

  HRESULT SetVarName(
    [in] UINT index,
    [in] LPOLESTR szName);

  HRESULT SetTypeDescAlias(
    [in] TYPEDESC *pTDescAlias);

  HRESULT DefineFuncAsDllEntry(
    [in] UINT index,
    [in] LPOLESTR szDllName,
    [in] LPOLESTR szProcName);

  HRESULT SetFuncDocString(
    [in] UINT index,
    [in] LPOLESTR szDocString);

  HRESULT SetVarDocString(
    [in] UINT index,
    [in] LPOLESTR szDocString);

  HRESULT SetFuncHelpContext(
    [in] UINT index,
    [in] DWORD dwHelpContext);

  HRESULT SetVarHelpContext(
    [in] UINT index,
    [in] DWORD dwHelpContext);

  HRESULT SetMops(
    [in] UINT index,
    [in] BSTR bstrMops);

  HRESULT SetTypeIdldesc(
    [in] IDLDESC * pIdlDesc);

  HRESULT LayOut();
}

[
  local,
  object,
  uuid(0002040E-0000-0000-C000-000000000046),
  pointer_default(unique)
]
interface ICreateTypeInfo2 : ICreateTypeInfo
{
  typedef [unique] ICreateTypeInfo2 *LPCREATETYPEINFO2;

  HRESULT DeleteFuncDesc(
    [in] UINT index);

  HRESULT DeleteFuncDescByMemId(
    [in] MEMBERID memid,
    [in] INVOKEKIND invKind);

  HRESULT DeleteVarDesc(
    [in] UINT index);

  HRESULT DeleteVarDescByMemId(
    [in] MEMBERID memid);

  HRESULT DeleteImplType(
    [in] UINT index);

  HRESULT SetCustData(
    [in] REFGUID guid,
    [in] VARIANT *pVarVal);

  HRESULT SetFuncCustData( 
    [in] UINT index, 
    [in] REFGUID guid, 
    [in] VARIANT *pVarVal);
  
  HRESULT SetParamCustData( 
    [in] UINT indexFunc, 
    [in] UINT indexParam, 
    [in] REFGUID guid, 
    [in] VARIANT *pVarVal);

  HRESULT SetVarCustData( 
    [in] UINT index, 
    [in] REFGUID guid, 
    [in] VARIANT *pVarVal);

  HRESULT SetImplTypeCustData( 
    [in] UINT index, 
    [in] REFGUID guid, 
    [in] VARIANT *pVarVal);

  HRESULT SetHelpStringContext(
    [in] ULONG dwHelpStringContext);

  HRESULT SetFuncHelpStringContext(
    [in] UINT index,
    [in] ULONG dwHelpStringContext);

  HRESULT SetVarHelpStringContext(
    [in] UINT index,
    [in] ULONG dwHelpStringContext);

  HRESULT Invalidate();

  HRESULT SetName(
    [in] LPOLESTR szName);
}

[
  local,
  object,
  uuid(00020406-0000-0000-C000-000000000046),
  pointer_default(unique)
]
interface ICreateTypeLib : IUnknown
{
  typedef [unique] ICreateTypeLib *LPCREATETYPELIB;

  HRESULT CreateTypeInfo(
    [in] LPOLESTR szName,
    [in] TYPEKIND tkind,
    [out] ICreateTypeInfo **ppCTInfo);

  HRESULT SetName(
    [in] LPOLESTR szName);

  HRESULT SetVersion(
    [in] WORD wMajorVerNum,
    [in] WORD wMinorVerNum);

  HRESULT SetGuid(
    [in] REFGUID guid);

  HRESULT SetDocString(
    [in] LPOLESTR szDoc);

  HRESULT SetHelpFileName(
    [in] LPOLESTR szHelpFileName);

  HRESULT SetHelpContext(
    [in] DWORD dwHelpContext);

  HRESULT SetLcid(
    [in] LCID lcid);

  HRESULT SetLibFlags(
    [in] UINT uLibFlags);

  HRESULT SaveAllChanges();
}

[
  local,
  object,
  uuid(0002040F-0000-0000-C000-000000000046),
  pointer_default(unique)
]
interface ICreateTypeLib2 : ICreateTypeLib
{
  typedef [unique] ICreateTypeLib2 *LPCREATETYPELIB2;

  HRESULT DeleteTypeInfo(
    [in] LPOLESTR szName);

  HRESULT SetCustData(
    [in] REFGUID guid,
    [in] VARIANT *pVarVal);

  HRESULT SetHelpStringContext(
    [in] ULONG dwHelpStringContext);

  HRESULT SetHelpStringDll(
    [in] LPOLESTR szFileName);
}


/*****************************************************************************
 * IErrorLog interface
 */
[
  object,
  uuid(3127ca40-446e-11ce-8135-00aa004bb851),
  pointer_default(unique)
]
interface IErrorLog : IUnknown
{
  typedef IErrorLog *LPERRORLOG;

  HRESULT AddError(
    [in] LPCOLESTR pszPropName,
    [in] EXCEPINFO *pExcepInfo);
}


/*****************************************************************************
 * IPropertyBag interface
 */
[
  object,
  uuid(55272a00-42cb-11ce-8135-00aa004bb851),
  pointer_default(unique)
]
interface IPropertyBag : IUnknown
{
  typedef IPropertyBag *LPPROPERTYBAG;

  [local]
  HRESULT Read(
    [in] LPCOLESTR pszPropName,
    [in, out] VARIANT *pVar,
    [in] IErrorLog *pErrorLog);

  [call_as(Read)]
  HRESULT RemoteRead(
    [in] LPCOLESTR pszPropName,
    [out] VARIANT *pVar,
    [in] IErrorLog *pErrorLog,
    [in] DWORD varType,
    [in] IUnknown *pUnkObj);

  HRESULT Write(
    [in] LPCOLESTR pszPropName,
    [in] VARIANT *pVar);
}