include/objidl.idl

/*
 * 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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 */

import "unknwn.idl";

interface IStream;
interface IEnumString;
interface IRunningObjectTable;
interface IMoniker;
interface IAdviseSink;
interface IAsyncManager;

/* FIXME: COSERVERINFO should be moved here from wtypes.idl */

/******************** Fundamentals ********************/

[
  local,
  object,
  uuid(00000003-0000-0000-C000-000000000046)
]
interface IMarshal : IUnknown
{
  typedef [unique] IMarshal *LPMARSHAL;

  HRESULT GetUnmarshalClass(
    [in] REFIID riid,
    [in, unique] void *pv,
    [in] DWORD dwDestContext,
    [in, unique] void *pvDestContext,
    [in] DWORD mshlflags,
    [out] CLSID *pCid);

  HRESULT GetMarshalSizeMax(
    [in] REFIID riid,
    [in, unique] void *pv,
    [in] DWORD dwDestContext,
    [in, unique] void *pvDestContext,
    [in] DWORD mshlflags,
    [out] DWORD *pSize);

  HRESULT MarshalInterface(
    [in, unique] IStream *pStm,
    [in] REFIID riid,
    [in, unique] void *pv,
    [in] DWORD dwDestContext,
    [in, unique] void *pvDestContext,
    [in] DWORD mshlflags);

  HRESULT UnmarshalInterface(
    [in, unique] IStream *pStm,
    [in] REFIID riid,
    [out] void **ppv);

  HRESULT ReleaseMarshalData(
    [in, unique] IStream *pStm);

  HRESULT DisconnectObject(
    [in] DWORD dwReserved);
}

[
  local,
  object,
  uuid(00000018-0000-0000-C000-000000000046)
]
interface IStdMarshalInfo : IUnknown
{
  typedef [unique] IStdMarshalInfo *LPSTDMARSHALINFO;

  HRESULT GetClassForHandler(
    [in] DWORD dwDestContext,
    [in, unique] void *pvDestContext,
    [out] CLSID *pClsid);
}

[
  local,
  object,
  uuid(00000019-0000-0000-C000-000000000046)
]
interface IExternalConnection : IUnknown
{
  typedef [unique] IExternalConnection *LPEXTERNALCONNECTION;

  typedef enum tagEXTCONN {
    EXTCONN_STRONG   = 0x0001,
    EXTCONN_WEAK     = 0x0002,
    EXTCONN_CALLABLE = 0x0004
  } EXTCONN;

  DWORD AddConnection(
    [in] DWORD extconn,
    [in] DWORD reserved);

  DWORD ReleaseConnection(
    [in] DWORD extconn,
    [in] DWORD reserved,
    [in] BOOL fLastReleaseCloses);
}

[
  local,
  object,
  uuid(00000020-0000-0000-C000-000000000046)
]
interface IMultiQI : IUnknown
{
  typedef [unique] IMultiQI *LPMULTIQI;

  typedef struct tagMULTI_QI {
    const IID *pIID;
    IUnknown *pItf;
    HRESULT hr;
  } MULTI_QI;

  HRESULT QueryMultipleInterfaces(
    [in] ULONG cMQIs,
    [in, out] MULTI_QI *pMQIs);
}

[
  local,
  object,
  uuid(00000002-0000-0000-C000-000000000046)
]
interface IMalloc : IUnknown
{
  typedef [unique] IMalloc *LPMALLOC;

  LPVOID Alloc(
    [in] ULONG cb);

  LPVOID Realloc(
    [in] LPVOID pv,
    [in] ULONG cb);

  void Free(
    [in] LPVOID pv);

  ULONG GetSize(
    [in] LPVOID pv);

  int DidAlloc(LPVOID pv);

  void HeapMinimize();
}

[
  local,
  object,
  uuid(0000001d-0000-0000-C000-000000000046)
]
interface IMallocSpy : IUnknown
{
  typedef [unique] IMallocSpy *LPMALLOCSPY;

  ULONG PreAlloc(
    [in] ULONG cbRequest);

  LPVOID PostAlloc(
    [in] LPVOID pActual);

  LPVOID PreFree(
    [in] LPVOID pRequest,
    [in] BOOL fSpyed);

  void PostFree(
    [in] BOOL fSpyed);

  ULONG PreRealloc(
    [in] LPVOID pRequest,
    [in] ULONG cbRequest,
    [out] LPVOID *ppNewRequest,
    [in] BOOL fSpyed);

  LPVOID PostRealloc(
    [in] LPVOID pActual,
    [in] BOOL fSpyed);

  LPVOID PreGetSize(
    [in] LPVOID pRequest,
    [in] BOOL fSpyed);

  ULONG PostGetSize(
    [in] ULONG cbActual,
    [in] BOOL fSpyed);

  LPVOID PreDidAlloc(
    [in] LPVOID pRequest,
    [in] BOOL fSpyed);

  int PostDidAlloc(
    [in] LPVOID pRequest,
    [in] BOOL fSpyed,
    [in] int fActual);

  void PreHeapMinimize();

  void PostHeapMinimize();
}

[
  object,
  uuid(00000100-0000-0000-C000-000000000046),
  pointer_default(unique)
]
interface IEnumUnknown : IUnknown
{
  typedef [unique] IEnumUnknown *LPENUMUNKNOWN;

  [local]
  HRESULT Next(
    [in] ULONG celt,
    [out] IUnknown **rgelt,
    [out] ULONG *pceltFetched);

  [call_as(Next)]
  HRESULT RemoteNext(
    [in] ULONG celt,
    [out, size_is(celt), length_is(*pceltFetched)]
    IUnknown **rgelt,
    [out] ULONG *pceltFetched);

  HRESULT Skip(
    [in] ULONG celt);

  HRESULT Reset();

  HRESULT Clone(
    [out] IEnumUnknown **ppenum);
}

[
  object,
  uuid(00000022-0000-0000-C000-000000000046),
  version(1.0),
  pointer_default(unique)
]
interface ISurrogate : IUnknown
{
  typedef [unique] ISurrogate *LPSURROGATE;

  HRESULT LoadDllServer(
    [in] REFCLSID Clsid);
  HRESULT FreeSurrogate();
}

[
  local,
  object,
  uuid(00000146-0000-0000-C000-000000000046)
]
interface IGlobalInterfaceTable : IUnknown
{
  typedef [unique] IGlobalInterfaceTable *LPGLOBALINTERFACETABLE;

  HRESULT RegisterInterfaceInGlobal(
    [in] IUnknown *pUnk,
    [in] REFIID riid,
    [out] DWORD *pdwCookie);

  HRESULT RevokeInterfaceFromGlobal(
    [in] DWORD dwCookie);

  HRESULT GetInterfaceFromGlobal(
    [in] DWORD dwCookie,
    [in] REFIID riid,
    [out, iid_is(riid)] void **ppv);
}

/******************** Monikers ********************/

[
  object,
  uuid(0000000e-0000-0000-C000-000000000046),
  pointer_default(unique)
]
interface IBindCtx : IUnknown
{
  typedef [unique] IBindCtx *LPBINDCTX;
  typedef [unique] IBindCtx *LPBC;

  typedef struct tagBIND_OPTS {
    DWORD cbStruct;
    DWORD grfFlags;
    DWORD grfMode;
    DWORD dwTickCountDeadline;
  } BIND_OPTS, *LPBIND_OPTS;

  /* FIXME: C++ crap */
  typedef struct tagBIND_OPTS2 {
    DWORD cbStruct;
    DWORD grfFlags;
    DWORD grfMode;
    DWORD dwTickCountDeadline;
    DWORD dwTrackFlags;
    DWORD dwClassContext;
    LCID  locale;
    COSERVERINFO *pServerInfo;
  } BIND_OPTS2, *LPBIND_OPTS2;

  typedef enum tagBIND_FLAGS {
    BIND_MAYBOTHERUSER   = 1,
    BIND_JUSTTESTEXISTENCE = 2
  } BIND_FLAGS;

  HRESULT RegisterObjectBound(
    [in, unique] IUnknown *punk);

  HRESULT RevokeObjectBound(
    [in, unique] IUnknown *punk);

  HRESULT ReleaseBoundObjects();

  [local]
  HRESULT SetBindOptions(
    [in] BIND_OPTS *pbindopts);

  [call_as(SetBindOptions)]
  HRESULT RemoteSetBindOptions(
    [in] BIND_OPTS2 *pbindopts);

  [local]
  HRESULT GetBindOptions(
    [in, out] BIND_OPTS *pbindopts);

  [call_as(GetBindOptions)]
  HRESULT RemoteGetBindOptions(
    [in, out] BIND_OPTS2 *pbindopts);

  HRESULT GetRunningObjectTable(
    [out] IRunningObjectTable **pprot);

  HRESULT RegisterObjectParam(
    [in] LPOLESTR pszKey,
    [in, unique] IUnknown *punk);

  HRESULT GetObjectParam(
    [in] LPOLESTR pszKey,
    [out] IUnknown **ppunk);

  HRESULT EnumObjectParam(
    [out] IEnumString **ppenum);

  HRESULT RevokeObjectParam(
    [in] LPOLESTR pszKey);
}

[
  object,
  uuid(00000102-0000-0000-C000-000000000046),
  pointer_default(unique)
]
interface IEnumMoniker : IUnknown
{
  typedef [unique] IEnumMoniker *LPENUMMONIKER;

  [local]
  HRESULT Next(
    [in] ULONG celt,
    [out, size_is(celt), length_is(*pceltFetched)]
    IMoniker **rgelt,
    [out] ULONG *pceltFetched);

  [call_as(Next)]
  HRESULT RemoteNext(
    [in] ULONG celt,
    [out, size_is(celt), length_is(*pceltFetched)]
    IMoniker **rgelt,
    [out] ULONG *pceltFetched);

  HRESULT Skip(
    [in] ULONG celt);

  HRESULT Reset();

  HRESULT Clone(
    [out] IEnumMoniker **ppenum);
}

[
  object,
  uuid(00000126-0000-0000-C000-000000000046)
]
interface IRunnableObject : IUnknown
{
  typedef [unique] IRunnableObject *LPRUNNABLEOBJECT;

  HRESULT GetRunningClass(
    [out] LPCLSID lpClsid);

  HRESULT Run(
    [in] LPBINDCTX pbc);

  [local]
  BOOL IsRunning();

  [call_as(IsRunning)]
  HRESULT RemoteIsRunning();

  HRESULT LockRunning(
    [in] BOOL fLock,
    [in] BOOL fLastUnlockCloses);

  HRESULT SetContainedObject(
    [in] BOOL fContained);
}

/* GetObject is defined in wingdi.h as WINELIB_NAME_AW(GetObject),
 * which resolves to a compilation failure if __WINESRC__ is defined,
 * but GetObject is used as a valid method name below, so we have
 * to undefine it if __WINESRC__ is defined */
cpp_quote("#ifdef __WINESRC__")
cpp_quote("#undef GetObject")
cpp_quote("#endif")

[
  object,
  uuid(00000010-0000-0000-C000-000000000046)
]
interface IRunningObjectTable : IUnknown
{
  typedef [unique] IRunningObjectTable *LPRUNNINGOBJECTTABLE;

  HRESULT Register(
    [in] DWORD grfFlags,
    [in, unique] IUnknown *punkObject,
    [in, unique] IMoniker *pmkObjectName,
    [out] DWORD *pdwRegister);

  HRESULT Revoke(
    [in] DWORD dwRegister);

  HRESULT IsRunning(
    [in, unique] IMoniker *pmkObjectName);

  HRESULT GetObject(
    [in, unique] IMoniker *pmkObjectName,
    [out] IUnknown **ppunkObject);

  HRESULT NoteChangeTime(
    [in] DWORD dwRegister,
    [in] FILETIME *pfiletime);

  HRESULT GetTimeOfLastChange(
    [in, unique] IMoniker *pmkObjectName,
    [out] FILETIME *pfiletime);

  HRESULT EnumRunning(
    [out] IEnumMoniker **ppenumMoniker);
}

[
  object,
  uuid(0000010c-0000-0000-C000-000000000046)
]
interface IPersist : IUnknown
{
  typedef [unique] IPersist *LPPERSIST;

  HRESULT GetClassID(
    [out] CLSID *pClassID);
}

[
  object,
  uuid(00000109-0000-0000-C000-000000000046),
  pointer_default(unique)
]
interface IPersistStream : IPersist
{
  typedef [unique] IPersistStream *LPPERSISTSTREAM;

  HRESULT IsDirty();

  HRESULT Load(
    [in, unique] IStream *pStm);

  HRESULT Save(
    [in, unique] IStream *pStm,
    [in] BOOL fClearDirty);

  HRESULT GetSizeMax(
    [out] ULARGE_INTEGER *pcbSize);
}

[
  object,
  uuid(0000000f-0000-0000-C000-000000000046),
  pointer_default(unique)
]
interface IMoniker : IPersistStream
{
  typedef [unique] IMoniker *LPMONIKER;

  typedef enum tagMKSYS {
    MKSYS_NONE             = 0,
    MKSYS_GENERICCOMPOSITE = 1,
    MKSYS_FILEMONIKER      = 2,
    MKSYS_ANTIMONIKER      = 3,
    MKSYS_ITEMMONIKER      = 4,
    MKSYS_POINTERMONIKER   = 5,
    /* MKSYS_URLMONIKER       = 6, */ /* defined in urlmon.idl */
    MKSYS_CLASSMONIKER     = 7
  } MKSYS;

  typedef [v1_enum] enum tagMKREDUCE {
    MKRREDUCE_ONE         = 3 << 16,
    MKRREDUCE_TOUSER      = 2 << 16,
    MKRREDUCE_THROUGHUSER = 1 << 16,
    MKRREDUCE_ALL         = 0
  } MKRREDUCE;

  [local]
  HRESULT BindToObject(
    [in, unique] IBindCtx *pbc,
    [in, unique] IMoniker *pmkToLeft,
    [in] REFIID riidResult,
    [out, iid_is(riidResult)] void **ppvResult);

  [call_as(BindToObject)]
  HRESULT RemoteBindToObject(
    [in, unique] IBindCtx *pbc,
    [in, unique] IMoniker *pmkToLeft,
    [in] REFIID riidResult,
    [out, iid_is(riidResult)] IUnknown **ppvResult);

  [local]
  HRESULT BindToStorage(
    [in, unique] IBindCtx *pbc,
    [in, unique] IMoniker *pmkToLeft,
    [in] REFIID riid,
    [out, iid_is(riid)] void **ppvObj);

  [call_as(BindToStorage)]
  HRESULT RemoteBindToStorage(
    [in, unique] IBindCtx *pbc,
    [in, unique] IMoniker *pmkToLeft,
    [in] REFIID riid,
    [out, iid_is(riid)] IUnknown **ppvObj);

  HRESULT Reduce(
    [in, unique] IBindCtx *pbc,
    [in] DWORD dwReduceHowFar,
    [in, out, unique] IMoniker **ppmkToLeft,
    [out] IMoniker **ppmkReduced);

  HRESULT ComposeWith(
    [in, unique] IMoniker *pmkRight,
    [in] BOOL fOnlyIfNotGeneric,
    [out] IMoniker **ppmkComposite);

  HRESULT Enum(
    [in] BOOL fForward,
    [out] IEnumMoniker **ppenumMoniker);

  HRESULT IsEqual(
    [in, unique] IMoniker *pmkOtherMoniker);

  HRESULT Hash(
    [out] DWORD *pdwHash);

  HRESULT IsRunning(
    [in, unique] IBindCtx *pbc,
    [in, unique] IMoniker *pmkToLeft,
    [in, unique] IMoniker *pmkNewlyRunning);

  HRESULT GetTimeOfLastChange(
    [in, unique] IBindCtx *pbc,
    [in, unique] IMoniker *pmkToLeft,
    [out] FILETIME *pFileTime);

  HRESULT Inverse(
    [out] IMoniker **ppmk);

  HRESULT CommonPrefixWith(
    [in, unique] IMoniker *pmkOther,
    [out] IMoniker **ppmkPrefix);

  HRESULT RelativePathTo(
    [in, unique] IMoniker *pmkOther,
    [out] IMoniker **ppmkRelPath);

  HRESULT GetDisplayName(
    [in, unique] IBindCtx *pbc,
    [in, unique] IMoniker *pmkToLeft,
    [out] LPOLESTR *ppszDisplayName);

  HRESULT ParseDisplayName(
    [in, unique] IBindCtx *pbc,
    [in, unique] IMoniker *pmkToLeft,
    [in] LPOLESTR pszDisplayName,
    [out] ULONG *pchEaten,
    [out] IMoniker **ppmkOut);

  HRESULT IsSystemMoniker(
    [out] DWORD *pdwMksys);
}

[
  object,
  uuid(f29f6bc0-5021-11ce-aa15-00006901293f),
  pointer_default(unique)
]
interface IROTData : IUnknown
{
  HRESULT GetComparisonData(
    [out, size_is(cbMax)] byte *pbData,
    [in] ULONG cbMax,
    [out] ULONG *pcbData);
}

[
  object,
  uuid(00000101-0000-0000-C000-000000000046),
  pointer_default(unique)
]
interface IEnumString : IUnknown
{
  typedef [unique] IEnumString *LPENUMSTRING;

  [local]
  HRESULT Next(
    [in] ULONG celt,
    [out, size_is(celt), length_is(*pceltFetched)]
    LPOLESTR *rgelt,
    [out] ULONG *pceltFetched);

  [call_as(Next)]
  HRESULT RemoteNext(
    [in] ULONG celt,
    [out, size_is(celt), length_is(*pceltFetched)]
    LPOLESTR *rgelt,
    [out] ULONG *pceltFetched);

  HRESULT Skip(
    [in] ULONG celt);

  HRESULT Reset();

  HRESULT Clone(
    [out] IEnumString **ppenum);
}

[
  object,
  uuid(00000140-0000-0000-C000-000000000046)
]
interface IClassActivator : IUnknown
{
  HRESULT GetClassObject(
    [in] REFCLSID rclsid,
    [in] DWORD dwClassContext,
    [in] LCID locale,
    [in] REFIID riid,
    [out, iid_is(riid)] void **ppv);
}

/******************** Storage ********************/

[
  object,
  uuid(0c733a30-2a1c-11ce-ade5-00aa0044773d),
  pointer_default(unique)
]
interface ISequentialStream : IUnknown
{
  [local]
  HRESULT Read(
    [out, size_is(cb), length_is(*pcbRead)]
    void *pv,
    [in] ULONG cb,
    [out] ULONG *pcbRead);

  [call_as(Read)]
  HRESULT RemoteRead(
    [out, size_is(cb), length_is(*pcbRead)]
    byte *pv,
    [in] ULONG cb,
    [out] ULONG *pcbRead);

  [local]
  HRESULT Write(
    [in, size_is(cb)] const void *pv,
    [in] ULONG cb,
    [out] ULONG *pcbWritten);

  [call_as(Write)]
  HRESULT RemoteWrite(
    [in, size_is(cb)] const byte *pv,
    [in] ULONG cb,
    [out] ULONG *pcbWritten);
}

[
  object,
  uuid(0000000c-0000-0000-C000-000000000046),
  pointer_default(unique)
]
interface IStream : ISequentialStream
{
  typedef [unique] IStream *LPSTREAM;

  typedef struct tagSTATSTG {
    LPOLESTR pwcsName;
    DWORD type;
    ULARGE_INTEGER cbSize;
    FILETIME mtime;
    FILETIME ctime;
    FILETIME atime;
    DWORD grfMode;
    DWORD grfLocksSupported;
    CLSID clsid;
    DWORD grfStateBits;
    DWORD reserved;
  } STATSTG;

  typedef enum tagSTGTY {
    STGTY_STORAGE   = 1,
    STGTY_STREAM    = 2,
    STGTY_LOCKBYTES = 3,
    STGTY_PROPERTY  = 4
  } STGTY;

  typedef enum tagSTREAM_SEEK {
    STREAM_SEEK_SET = 0,
    STREAM_SEEK_CUR = 1,
    STREAM_SEEK_END = 2
  } STREAM_SEEK;

  /* these are defined in Linux's fcntl.h,
   * undefine them to avoid conflicts */
  cpp_quote("#undef LOCK_MAND")
  cpp_quote("#undef LOCK_READ")
  cpp_quote("#undef LOCK_WRITE")
  cpp_quote("#undef LOCK_RW")

  typedef enum tagLOCKTYPE {
    LOCK_WRITE      = 1,
    LOCK_EXCLUSIVE  = 2,
    LOCK_ONLYONCE   = 4
  } LOCKTYPE;

  [local]
  HRESULT Seek(
    [in] LARGE_INTEGER dlibMove,
    [in] DWORD dwOrigin,
    [out] ULARGE_INTEGER *plibNewPosition);

  [call_as(Seek)]
  HRESULT RemoteSeek(
    [in] LARGE_INTEGER dlibMove,
    [in] DWORD dwOrigin,
    [out] ULARGE_INTEGER *plibNewPosition);

  HRESULT SetSize(
    [in] ULARGE_INTEGER libNewSize);

  [local]
  HRESULT CopyTo(
    [in, unique] IStream *pstm,
    [in] ULARGE_INTEGER cb,
    [out] ULARGE_INTEGER *pcbRead,
    [out] ULARGE_INTEGER *pcbWritten);

  [call_as(CopyTo)]
  HRESULT RemoteCopyTo(
    [in, unique] IStream *pstm,
    [in] ULARGE_INTEGER cb,
    [out] ULARGE_INTEGER *pcbRead,
    [out] ULARGE_INTEGER *pcbWritten);

  HRESULT Commit(
    [in] DWORD grfCommitFlags);

  HRESULT Revert();

  HRESULT LockRegion(
    [in] ULARGE_INTEGER libOffset,
    [in] ULARGE_INTEGER cb,
    [in] DWORD dwLockType);

  HRESULT UnlockRegion(
    [in] ULARGE_INTEGER libOffset,
    [in] ULARGE_INTEGER cb,
    [in] DWORD dwLockType);

  HRESULT Stat(
    [out] STATSTG *pstatstg,
    [in] DWORD grfStatFlag);

  HRESULT Clone(
    [out] IStream **ppstm);
}

[
  object,
  uuid(0000000d-0000-0000-C000-000000000046),
  pointer_default(unique)
]
interface IEnumSTATSTG : IUnknown
{
  typedef [unique] IEnumSTATSTG *LPENUMSTATSTG;

  [local]
  HRESULT Next(
    [in] ULONG celt,
    [out, size_is(celt), length_is(*pceltFetched)]
    STATSTG *rgelt,
    [out] ULONG *pceltFetched);

  [call_as(Next)]
  HRESULT RemoteNext(
    [in] ULONG celt,
    [out, size_is(celt), length_is(*pceltFetched)]
    STATSTG *rgelt,
    [out] ULONG *pceltFetched);

  HRESULT Skip(
    [in] ULONG celt);

  HRESULT Reset();

  HRESULT Clone(
    [out] IEnumSTATSTG **ppenum);
}

[
  object,
  uuid(0000000b-0000-0000-C000-000000000046),
  pointer_default(unique)
]
interface IStorage : IUnknown
{
  typedef [unique] IStorage *LPSTORAGE;

  typedef struct tagRemSNB {
    unsigned long ulCntStr;
    unsigned long ulCntChar;
    [size_is(ulCntChar)] OLECHAR rgString[];
  } RemSNB;

  typedef [unique] RemSNB *wireSNB;
  typedef [wire_marshal(wireSNB)] OLECHAR **SNB;

  HRESULT CreateStream(
    [in] LPCOLESTR pwcsName,
    [in] DWORD grfMode,
    [in] DWORD reserved1,
    [in] DWORD reserved2,
    [out] IStream **ppstm);

  [local]
  HRESULT OpenStream(
    [in] LPCOLESTR pwcsName,
    [in, unique] void *reserved1,
    [in] DWORD grfMode,
    [in] DWORD reserved2,
    [out] IStream **ppstm);

  [call_as(OpenStream)]
  HRESULT RemoteOpenStream(
    [in] LPCOLESTR pwcsName,
    [in] unsigned long cbReserved1,
    [in, unique, size_is(cbReserved1)] byte *reserved1,
    [in] DWORD grfMode,
    [in] DWORD reserved2,
    [out] IStream **ppstm);

  HRESULT CreateStorage(
    [in] LPCOLESTR pwcsName,
    [in] DWORD grfMode,
    [in] DWORD dwStgFmt,
    [in] DWORD reserved2,
    [out] IStorage **ppstg);

  HRESULT OpenStorage(
    [in, unique] LPCOLESTR pwcsName,
    [in, unique] IStorage *pstgPriority,
    [in] DWORD grfMode,
    [in, unique] SNB snbExclude,
    [in] DWORD reserved,
    [out] IStorage **ppstg);

  HRESULT CopyTo(
    [in] DWORD ciidExclude,
    [in, unique, size_is(ciidExclude)] const IID *rgiidExclude,
    [in, unique] SNB snbExclude,
    [in, unique] IStorage *pstgDest);

  HRESULT MoveElementTo(
    [in] LPCOLESTR pwcsName,
    [in, unique] IStorage *pstgDest,
    [in] LPCOLESTR pwcsNewName,
    [in] DWORD grfFlags);

  HRESULT Commit(
    [in] DWORD grfCommitFlags);

  HRESULT Revert();

  [local]
  HRESULT EnumElements(
    [in] DWORD reserved1,
    [in, unique, size_is(1)] void *reserved2,
    [in] DWORD reserved3,
    [out] IEnumSTATSTG **ppenum);

  [call_as(EnumElements)]
  HRESULT RemoteEnumElements(
    [in] DWORD reserved1,
    [in] unsigned long cbReserved2,
    [in, unique, size_is(cbReserved2)] byte *reserved2,
    [in] DWORD reserved3,
    [out] IEnumSTATSTG **ppenum);

  HRESULT DestroyElement(
    [in] LPCOLESTR pwcsName);

  HRESULT RenameElement(
    [in] LPCOLESTR pwcsOldName,
    [in] LPCOLESTR pwcsNewName);

  HRESULT SetElementTimes(
    [in, unique] LPCOLESTR pwcsName,
    [in, unique] const FILETIME *pctime,
    [in, unique] const FILETIME *patime,
    [in, unique] const FILETIME *pmtime);

  HRESULT SetClass(
    [in] REFCLSID clsid);

  HRESULT SetStateBits(
    [in] DWORD grfStateBits,
    [in] DWORD grfMask);

  HRESULT Stat(
    [out] STATSTG *pstatstg,
    [in] DWORD grfStatFlag);
}

[
  object,
  uuid(0000010b-0000-0000-C000-000000000046),
  pointer_default(unique)
]
interface IPersistFile : IPersist
{
  typedef [unique] IPersistFile *LPPERSISTFILE;

  HRESULT IsDirty();

  HRESULT Load(
    [in] LPCOLESTR pszFileName,
    [in] DWORD dwMode);

  HRESULT Save(
    [in, unique] LPCOLESTR pszFileName,
    [in] BOOL fRemember);

  HRESULT SaveCompleted(
    [in, unique] LPCOLESTR pszFileName);

  HRESULT GetCurFile(
    [out] LPOLESTR *ppszFileName);
}

[
  object,
  uuid(0000010a-0000-0000-C000-000000000046),
  pointer_default(unique)
]
interface IPersistStorage : IPersist
{
  typedef [unique] IPersistStorage *LPPERSISTSTORAGE;

  HRESULT IsDirty();

  HRESULT InitNew(
    [in, unique] IStorage *pStg);

  HRESULT Load(
    [in, unique] IStorage *pStg);

  HRESULT Save(
    [in, unique] IStorage *pStgSave,
    [in] BOOL fSameAsLoad);

  HRESULT SaveCompleted(
    [in, unique] IStorage *pStgNew);

  HRESULT HandsOffStorage();
}

[
  object,
  uuid(00000012-0000-0000-C000-000000000046),
  pointer_default(unique)
]
interface IRootStorage : IUnknown
{
  typedef [unique] IRootStorage *LPROOTSTORAGE;

  HRESULT SwitchToFile(
    [in] LPOLESTR pszFile);
}

[
  object,
  uuid(0000000a-0000-0000-C000-000000000046),
  pointer_default(unique)
]
interface ILockBytes : IUnknown
{
  typedef [unique] ILockBytes *LPLOCKBYTES;

  [local]
  HRESULT ReadAt(
    [in] ULARGE_INTEGER ulOffset,
    [out, size_is(cb), length_is(*pcbRead)]
    void *pv,
    [in] ULONG cb,
    [out] ULONG *pcbRead);

  [call_as(ReadAt)]
  HRESULT RemoteReadAt(
    [in] ULARGE_INTEGER ulOffset,
    [out, size_is(cb), length_is(*pcbRead)]
    byte *pv,
    [in] ULONG cb,
    [out] ULONG *pcbRead);

  [local]
  HRESULT WriteAt(
    [in] ULARGE_INTEGER ulOffset,
    [in, size_is(cb)] const void *pv,
    [in] ULONG cb,
    [out] ULONG *pcbWritten);

  [call_as(WriteAt)]
  HRESULT RemoteWriteAt(
    [in] ULARGE_INTEGER ulOffset,
    [in, size_is(cb)] const byte *pv,
    [in] ULONG cb,
    [out] ULONG *pcbWritten);

  HRESULT Flush();

  HRESULT SetSize(
    [in] ULARGE_INTEGER cb);

  HRESULT LockRegion(
    [in] ULARGE_INTEGER libOffset,
    [in] ULARGE_INTEGER cb,
    [in] DWORD dwLockType);

  HRESULT UnlockRegion(
    [in] ULARGE_INTEGER libOffset,
    [in] ULARGE_INTEGER cb,
    [in] DWORD dwLockType);

  HRESULT Stat(
    [out] STATSTG *pstatstg,
    [in] DWORD grfStatFlag);
}

[
  object,
  uuid(99caf010-415e-11cf-8814-00aa00b569f5),
  pointer_default(unique)
]
interface IFillLockBytes : IUnknown
{
  [local]
  HRESULT FillAppend(
    [in, size_is(cb)] const void *pv,
    [in] ULONG cb,
    [out] ULONG *pcbWritten);

  [call_as(FillAppend)]
  HRESULT RemoteFillAppend(
    [in, size_is(cb)] const byte *pv,
    [in] ULONG cb,
    [out] ULONG *pcbWritten);

  [local]
  HRESULT FillAt(
    [in] ULARGE_INTEGER ulOffset,
    [in, size_is(cb)] const void *pv,
    [in] ULONG cb,
    [out] ULONG *pcbWritten);

  [call_as(FillAt)]
  HRESULT RemoteFillAt(
    [in] ULARGE_INTEGER ulOffset,
    [in, size_is(cb)] const byte *pv,
    [in] ULONG cb,
    [out] ULONG *pcbWritten);

  HRESULT SetFillSize(
    [in] ULARGE_INTEGER ulSize);

  HRESULT Terminate(
    [in] BOOL bCanceled);
}

[
  object,
  uuid(a9d758a0-4617-11cf-95fc-00aa00680db4),
  pointer_default(unique)
]
interface IProgressNotify : IUnknown
{
  HRESULT OnProgress(
    [in] DWORD dwProgressCurrent,
    [in] DWORD dwProgressMaximum,
    [in] BOOL fAccurate,
    [in] BOOL fOwner);
}

[
  local,
  object,
  uuid(0e6d4d90-6738-11cf-9608-00aa00680db4),
  pointer_default(unique)
]
interface ILayoutStorage : IUnknown
{
  typedef struct tagStorageLayout {
    DWORD LayoutType;
    OLECHAR *pwcsElementName;
    LARGE_INTEGER cOffset;
    LARGE_INTEGER cBytes;
  } StorageLayout;

  HRESULT LayoutScript(
    [in] StorageLayout *pStorageLayout,
    [in] DWORD nEntries,
    [in] DWORD glfInterleavedFlag);

  HRESULT BeginMonitor();

  HRESULT EndMonitor();

  HRESULT ReLayoutDocfile(
    [in] OLECHAR *pwcsNewDfName);

  HRESULT ReLayoutDocfileOnILockBytes(
    [in] ILockBytes *pILockBytes);
}

/******************** Data Object ********************/

[
  object,
  uuid(00000103-0000-0000-C000-000000000046),
  pointer_default(unique)
]
interface IEnumFORMATETC : IUnknown
{
  typedef [unique] IEnumFORMATETC *LPENUMFORMATETC;

  typedef struct tagDVTARGETDEVICE {
    DWORD tdSize;
    WORD tdDriverNameOffset;
    WORD tdDeviceNameOffset;
    WORD tdPortNameOffset;
    WORD tdExtDevmodeOffset;
    [size_is(tdSize - sizeof(DWORD) - 4*sizeof(WORD))]
    BYTE tdData[];
  } DVTARGETDEVICE;

  typedef CLIPFORMAT *LPCLIPFORMAT;

  typedef struct tagFORMATETC {
    CLIPFORMAT cfFormat;
    [unique] DVTARGETDEVICE *ptd;
    DWORD dwAspect;
    LONG lindex;
    DWORD tymed;
  } FORMATETC, *LPFORMATETC;

  [local]
  HRESULT Next(
    [in] ULONG celt,
    [out, size_is(celt), length_is(*pceltFetched)]
    FORMATETC *rgelt,
    [out] ULONG *pceltFetched);

  [call_as(Next)]
  HRESULT RemoteNext(
    [in] ULONG celt,
    [out, size_is(celt), length_is(*pceltFetched)]
    FORMATETC *rgelt,
    [out] ULONG *pceltFetched);

  HRESULT Skip(
    [in] ULONG celt);

  HRESULT Reset();

  HRESULT Clone(
    [out] IEnumFORMATETC **ppenum);
}

[
  object,
  uuid(00000105-0000-0000-C000-000000000046),
  pointer_default(unique)
]
interface IEnumSTATDATA : IUnknown
{
  typedef [unique] IEnumSTATDATA *LPENUMSTATDATA;

  typedef enum tagADVF {
    ADVF_NODATA            = 1,
    ADVF_PRIMEFIRST        = 2,
    ADVF_ONLYONCE          = 4,
    ADVF_DATAONSTOP        = 64,
    ADVFCACHE_NOHANDLER    = 8,
    ADVFCACHE_FORCEBUILTIN = 16,
    ADVFCACHE_ONSAVE       = 32
  } ADVF;

  typedef struct tagSTATDATA
  {
    FORMATETC formatetc;
    DWORD advf;
    [unique] IAdviseSink *pAdvSink;
    DWORD dwConnection;
  } STATDATA, *LPSTATDATA;

  [local]
  HRESULT Next(
    [in] ULONG celt,
    [out, size_is(celt), length_is(*pceltFetched)]
    STATDATA *rgelt,
    [out] ULONG *pceltFetched);

  [call_as(Next)]
  HRESULT RemoteNext(
    [in] ULONG celt,
    [out, size_is(celt), length_is(*pceltFetched)]
    STATDATA *rgelt,
    [out] ULONG *pceltFetched);

  HRESULT Skip(
    [in] ULONG celt);

  HRESULT Reset();

  HRESULT Clone(
    [out] IEnumSTATDATA **ppenum);
}

[
  object,
  uuid(0000010f-0000-0000-C000-000000000046),
  pointer_default(unique)
]
interface IAdviseSink : IUnknown
{
  typedef IAdviseSink *LPADVISESINK;

  typedef [v1_enum] enum tagTYMED {
    TYMED_HGLOBAL  = 1,
    TYMED_FILE     = 2,
    TYMED_ISTREAM  = 4,
    TYMED_ISTORAGE = 8,
    TYMED_GDI      = 16,
    TYMED_MFPICT   = 32,
    TYMED_ENHMF    = 64,
    TYMED_NULL     = 0
  } TYMED;

  typedef struct tagRemSTGMEDIUM {
    DWORD tymed;
    DWORD dwHandleType;
    unsigned long pData;
    unsigned long pUnkForRelease;
    unsigned long cbData;
    [size_is(cbData)] byte data[];
  } RemSTGMEDIUM;

  /* FIXME: C/C++ nameless union version */
  typedef struct tagSTGMEDIUM {
    DWORD tymed;
    [switch_is(tymed)] union {
    [case(TYMED_GDI)]      HBITMAP hBitmap;
    [case(TYMED_MFPICT)]   HMETAFILEPICT hMetaFilePict;
    [case(TYMED_ENHMF)]    HENHMETAFILE hEnhMetaFile;
    [case(TYMED_HGLOBAL)]  HGLOBAL hGlobal;
    [case(TYMED_FILE)]     LPOLESTR lpszFileName;
    [case(TYMED_ISTREAM)]  IStream *pstm;
    [case(TYMED_ISTORAGE)] IStorage *pstg;
    [default]              ;
    };
    [unique] IUnknown *pUnkForRelease;
  } uSTGMEDIUM;

/* copied from wingdi.h */
#define OBJ_PEN             1
#define OBJ_BRUSH           2
#define OBJ_DC              3
#define OBJ_METADC          4
#define OBJ_PAL             5
#define OBJ_FONT            6
#define OBJ_BITMAP          7
#define OBJ_REGION          8
#define OBJ_METAFILE        9
#define OBJ_MEMDC           10
#define OBJ_EXTPEN          11
#define OBJ_ENHMETADC       12
#define OBJ_ENHMETAFILE     13

  typedef union _GDI_OBJECT switch(DWORD ObjectType) u {
    case OBJ_BITMAP: wireHBITMAP hBitmap;
    case OBJ_PAL:    wireHPALETTE hPalette;
    default:         wireHGLOBAL hGeneric;
  } GDI_OBJECT;

  typedef struct _userSTGMEDIUM {
    union switch(DWORD tymed) u {
    case TYMED_NULL:     ;
    case TYMED_MFPICT:   wireHMETAFILEPICT hMetaFilePict;
    case TYMED_ENHMF:    wireHENHMETAFILE hHEnhMetaFile;
    case TYMED_GDI:      GDI_OBJECT *hGdiHandle;
    case TYMED_HGLOBAL:  wireHGLOBAL hGlobal;
    case TYMED_FILE:     LPOLESTR lpszFileName;
    case TYMED_ISTREAM:  BYTE_BLOB *pstm;
    case TYMED_ISTORAGE: BYTE_BLOB *pstg;
    };
    IUnknown *pUnkForRelease;
  } userSTGMEDIUM;

  typedef [unique] userSTGMEDIUM *wireSTGMEDIUM;
  typedef [wire_marshal(wireSTGMEDIUM)] uSTGMEDIUM STGMEDIUM;

  typedef [unique] userSTGMEDIUM *wireASYNC_STGMEDIUM;
  typedef [wire_marshal(wireASYNC_STGMEDIUM)] STGMEDIUM ASYNC_STGMEDIUM;

  typedef STGMEDIUM *LPSTGMEDIUM;

  typedef struct _userFLAG_STGMEDIUM {
    long ContextFlags;
    long fPassOwnership;
    userSTGMEDIUM Stgmed;
  } userFLAG_STGMEDIUM;

  typedef [unique] userFLAG_STGMEDIUM *wireFLAG_STGMEDIUM;

  typedef [wire_marshal(wireFLAG_STGMEDIUM)] struct _FLAG_STGMEDIUM {
    long ContextFlags;
    long fPassOwnership;
    STGMEDIUM Stgmed;
  } FLAG_STGMEDIUM;

  [local]
  void OnDataChange(
    [in, unique] FORMATETC *pFormatetc,
    [in, unique] STGMEDIUM *pStgmed);

  [call_as(OnDataChange), async]
  HRESULT  RemoteOnDataChange(
    [in] IAsyncManager **ppIAM,
    [in, unique] FORMATETC *pFormatetc,
    [in, unique] ASYNC_STGMEDIUM *pStgmed);

  [local]
  void OnViewChange(
    [in] DWORD dwAspect,
    [in] LONG lindex);

  [call_as(OnViewChange), async]
  HRESULT RemoteOnViewChange(
    [in] IAsyncManager **ppIAM,
    [in] DWORD dwAspect,
    [in] LONG lindex);

  [local]
  void OnRename(
    [in] IMoniker *pmk);

  [call_as(OnRename), async]
  HRESULT RemoteOnRename(
    [in] IAsyncManager **ppIAM,
    [in] IMoniker *pmk);

  [local]
  void OnSave();

  [call_as(OnSave), async]
  HRESULT RemoteOnSave(
    [in] IAsyncManager **ppIAM);

  [local]
  void OnClose();

  [call_as(OnClose)]
  HRESULT RemoteOnClose();
}

[
  object,
  uuid(00000125-0000-0000-C000-000000000046),
  pointer_default(unique)
]
interface IAdviseSink2 : IAdviseSink
{
  typedef [unique] IAdviseSink2 *LPADVISESINK2;

  [local]
  void OnLinkSrcChange(
    [in, unique] IMoniker *pmk);

  [call_as(OnLinkSrcChange), async]
  HRESULT RemoteOnLinkSrcChange(
    [in] IAsyncManager **ppIAM,
    [in, unique] IMoniker *pmk);
}

[
  object,
  uuid(0000010e-0000-0000-C000-000000000046),
  pointer_default(unique)
]
interface IDataObject : IUnknown
{
  typedef [unique] IDataObject *LPDATAOBJECT;

  typedef enum tagDATADIR {
    DATADIR_GET = 1,
    DATADIR_SET = 2
  } DATADIR;

  [local]
  HRESULT GetData(
    [in, unique] FORMATETC *pformatetcIn,
    [out] STGMEDIUM *pmedium);

  [call_as(GetData)]
  HRESULT RemoteGetData(
    [in, unique] FORMATETC *pformatetcIn,
    [out] STGMEDIUM *pRemoteMedium);

  [local]
  HRESULT GetDataHere(
    [in, unique] FORMATETC *pformatetc,
    [in, out] STGMEDIUM *pmedium);

  [call_as(GetDataHere)]
  HRESULT RemoteGetDataHere(
    [in, unique] FORMATETC *pformatetc,
    [in, out] STGMEDIUM *pRemoteMedium);

  HRESULT QueryGetData(
    [in, unique] FORMATETC *pformatetc);

  HRESULT GetCanonicalFormatEtc(
    [in, unique] FORMATETC *pformatectIn,
    [out] FORMATETC *pformatetcOut);

  [local]
  HRESULT SetData(
    [in, unique] FORMATETC *pformatetc,
    [in, unique] STGMEDIUM *pmedium,
    [in] BOOL fRelease);

  [call_as(SetData)]
  HRESULT RemoteSetData(
    [in, unique] FORMATETC *pformatetc,
    [in, unique] FLAG_STGMEDIUM *pmedium,
    [in] BOOL fRelease);

  HRESULT EnumFormatEtc(
    [in] DWORD dwDirection,
    [out] IEnumFORMATETC **ppenumFormatEtc);

  HRESULT DAdvise(
    [in] FORMATETC *pformatetc,
    [in] DWORD advf,
    [in, unique] IAdviseSink *pAdvSink,
    [out] DWORD *pdwConnection);

  HRESULT DUnadvise(
    [in] DWORD dwConnection);

  HRESULT EnumDAdvise(
    [out] IEnumSTATDATA **ppenumAdvise);
}

[
  local,
  object,
  uuid(00000110-0000-0000-C000-000000000046)
]
interface IDataAdviseHolder : IUnknown
{
  typedef [unique] IDataAdviseHolder *LPDATAADVISEHOLDER;

  HRESULT Advise(
    [in, unique] IDataObject *pDataObject,
    [in, unique] FORMATETC *pFetc,
    [in] DWORD advf,
    [in, unique] IAdviseSink *pAdvise,
    [out] DWORD *pdwConnection);

  HRESULT Unadvise(
    [in] DWORD dwConnection);

  HRESULT EnumAdvise(
    [out] IEnumSTATDATA **ppenumAdvise);

  HRESULT SendOnDataChange(
    [in, unique] IDataObject *pDataObject,
    [in] DWORD dwReserved,
    [in] DWORD advf);
}

/******************** Remoting ********************/

[
  local,
  object,
  uuid(00000016-0000-0000-C000-000000000046)
]
interface IMessageFilter : IUnknown
{
  typedef [unique] IMessageFilter *LPMESSAGEFILTER;

  typedef enum tagCALLTYPE {
    CALLTYPE_TOPLEVEL = 1,
    CALLTYPE_NESTED   = 2,
    CALLTYPE_ASYNC    = 3,
    CALLTYPE_TOPLEVEL_CALLPENDING = 4,
    CALLTYPE_ASYNC_CALLPENDING    = 5
  } CALLTYPE;

  typedef enum tagSERVERCALL {
    SERVERCALL_ISHANDLED  = 0,
    SERVERCALL_REJECTED   = 1,
    SERVERCALL_RETRYLATER = 2
  } SERVERCALL;

  typedef enum tagPENDINGTYPE {
    PENDINGTYPE_TOPLEVEL = 1,
    PENDINGTYPE_NESTED   = 2
  } PENDINGTYPE;

  typedef enum tagPENDINGMSG {
    PENDINGMSG_CANCELCALL     = 0,
    PENDINGMSG_WAITNOPROCESS  = 1,
    PENDINGMSG_WAITDEFPROCESS = 2
  } PENDINGMSG;

  typedef struct tagINTERFACEINFO {
    IUnknown *pUnk;
    IID iid;
    WORD wMethod;
  } INTERFACEINFO, *LPINTERFACEINFO;

  DWORD HandleInComingCall(
    [in] DWORD dwCallType,
    [in] HTASK htaskCaller,
    [in] DWORD dwTickCount,
    [in] LPINTERFACEINFO lpInterfaceInfo);

  DWORD RetryRejectedCall(
    [in] HTASK htaskCallee,
    [in] DWORD dwTickCount,
    [in] DWORD dwRejectType);

  DWORD MessagePending(
    [in] HTASK htaskCallee,
    [in] DWORD dwTickCount,
    [in] DWORD dwPendingType);
}

[
  local,
  object,
  uuid(D5F56B60-593B-101A-B569-08002B2DBF7A)
]
interface IRpcChannelBuffer : IUnknown
{
  typedef [unique] IRpcChannelBuffer *LPRPCCHANNELBUFFER;

  typedef unsigned long RPCOLEDATAREP;

  typedef struct tagRPCOLEMESSAGE {
    void *reserved1;
    RPCOLEDATAREP dataRepresentation;
    void *Buffer;
    ULONG cbBuffer;
    ULONG iMethod;
    void *reserved2[5];
    ULONG rpcFlags;
  } RPCOLEMESSAGE;

  typedef RPCOLEMESSAGE *PRPCOLEMESSAGE;

  HRESULT GetBuffer(
    [in] RPCOLEMESSAGE *pMessage,
    [in] REFIID riid);

  HRESULT SendReceive(
    [in,out] RPCOLEMESSAGE *pMessage,
    [out] ULONG *pStatus);

  HRESULT FreeBuffer(
    [in] RPCOLEMESSAGE *pMessage);

  HRESULT GetDestCtx(
    [out] DWORD *pdwDestContext,
    [out] void **ppvDestContext);

  HRESULT IsConnected();
}

[
  local,
  object,
  uuid(594f31d0-7f19-11d0-b194-00a0c90dc8bf)
]
interface IRpcChannelBuffer2 : IRpcChannelBuffer
{
  typedef [unique] IRpcChannelBuffer2 *LPRPCCHANNELBUFFER2;

  HRESULT GetProtocolVersion(
    [in,out] DWORD *pdwVersion);
}

[
  local,
  object,
  uuid(25B15600-0115-11d0-BF0D-00AA00B8DFD2)
]
interface IRpcChannelBuffer3 : IRpcChannelBuffer2
{
  typedef [unique] IRpcChannelBuffer3 *LPRPCCHANNELBUFFER3;

  HRESULT Send(
    [in,out] RPCOLEMESSAGE *pMsg,
    [out] ULONG *pulStatus);

  HRESULT Receive(
    [in,out] RPCOLEMESSAGE *pMsg,
    [in] ULONG ulSize,
    [out] ULONG *pulStatus);

  HRESULT Cancel(
    [in] RPCOLEMESSAGE *pMsg);

  HRESULT GetCallContext(
    [in] RPCOLEMESSAGE *pMsg,
    [in] REFIID riid,
    [out] void **pInterface);

  HRESULT GetDestCtxEx(
    [in] RPCOLEMESSAGE *pMsg,
    [out] DWORD *pdwDestContext,
    [out] void **ppvDestContext);

  HRESULT GetState(
    [in] RPCOLEMESSAGE *pMsg,
    [out] DWORD *pState);

  HRESULT RegisterAsync(
    [in] RPCOLEMESSAGE *pMsg,
    [in] IAsyncManager *pAsyncMgr);
}

[
  local,
  object,
  uuid(D5F56A34-593B-101A-B569-08002B2DBF7A)
]
interface IRpcProxyBuffer : IUnknown
{
  typedef [unique] IRpcProxyBuffer *LPRPCPROXYBUFFER;

  HRESULT Connect(
    [in, unique] IRpcChannelBuffer *pRpcChannelBuffer);

  void Disconnect();
}

[
  local,
  object,
  uuid(D5F56AFC-593B-101A-B569-08002B2DBF7A)
]
interface IRpcStubBuffer : IUnknown
{
  typedef [unique] IRpcStubBuffer *LPRPCSTUBBUFFER;

  HRESULT Connect(
    [in] IUnknown *pUnkServer);

  void Disconnect();

  HRESULT Invoke(
    [in] RPCOLEMESSAGE *_prpcmsg,
    [in] IRpcChannelBuffer *_pRpcChannelBuffer);

  IRpcStubBuffer *IsIIDSupported(
    [in] REFIID riid);

  ULONG CountRefs();

  HRESULT DebugServerQueryInterface(
    void **ppv);

  void DebugServerRelease(
    void *pv);
}

[
  local,
  object,
  uuid(D5F569D0-593B-101A-B569-08002B2DBF7A)
]
interface IPSFactoryBuffer : IUnknown
{
  typedef [unique] IPSFactoryBuffer *LPPSFACTORYBUFFER;

  HRESULT CreateProxy(
    [in] IUnknown *pUnkOuter,
    [in] REFIID riid,
    [out] IRpcProxyBuffer **ppProxy,
    [out] void **ppv);

  HRESULT CreateStub(
    [in] REFIID riid,
    [in, unique] IUnknown *pUnkServer,
    [out] IRpcStubBuffer **ppStub);
}

[
  local,
  object,
  uuid(1008c4a0-7613-11cf-9af1-0020af6e72f4)
]
interface IChannelHook : IUnknown
{
  typedef [unique] IChannelHook *LPCHANNELHOOK;

  typedef struct SChannelHookCallInfo {
    IID iid;
    DWORD cbSize;
    GUID uCausality;
    DWORD dwServerPid;
    DWORD iMethod;
    void *pObject;
  } SChannelHookCallInfo;

  void ClientGetSize(
    [in] REFGUID uExtent,
    [in] REFIID riid,
    [out] ULONG *pDataSize);

  void ClientFillBuffer(
    [in] REFGUID uExtent,
    [in] REFIID riid,
    [in, out] ULONG *pDataSize,
    [in] void *pDataBuffer);

  void ClientNotify(
    [in] REFGUID uExtent,
    [in] REFIID riid,
    [in] ULONG cbDataSize,
    [in] void *pDataBuffer,
    [in] DWORD lDataRep,
    [in] HRESULT hrFault);

  void ServerNotify(
    [in] REFGUID uExtent,
    [in] REFIID riid,
    [in] ULONG cbDataSize,
    [in] void *pDataBuffer,
    [in] DWORD lDataRep);

  void ServerGetSize(
    [in] REFGUID uExtent,
    [in] REFIID riid,
    [in] HRESULT hrFault,
    [out] ULONG *pDataSize);

  void ServerFillBuffer(
    [in] REFGUID uExtent,
    [in] REFIID riid,
    [in, out] ULONG *pDataSize,
    [in] void *pDataBuffer,
    [in] HRESULT hrFault );
}

/******************** Property Storage ********************/

interface IEnumSTATPROPSTG;
interface IEnumSTATPROPSETSTG;

[
  object,
  uuid(00000138-0000-0000-C000-000000000046),
  pointer_default(unique)
]
interface IPropertyStorage : IUnknown
{
  typedef [unique] IPropertyStorage *LPPROPERTYSTORAGE;

  extern const FMTID FMTID_SummaryInformation;
  extern const FMTID FMTID_DocSummaryInformation;
  extern const FMTID FMTID_UserDefinedProperties;

  const DWORD PROPSETFLAG_DEFAULT = 0;
  const DWORD PROPSETFLAG_NONSIMPLE = 1;
  const DWORD PROPSETFLAG_ANSI = 2;
  const DWORD PROPSETFLAG_UNBUFFERED = 4;

  typedef struct tagPROPVARIANT PROPVARIANT;

  #define TYPEDEF_CA(type, name) \
    typedef struct tag##name { \
      ULONG cElems; \
      [size_is(cElems)] \
      type *pElems; \
    } name

  TYPEDEF_CA(unsigned char, CAUB);
  TYPEDEF_CA(short, CAI);
  TYPEDEF_CA(USHORT, CAUI);
  TYPEDEF_CA(long, CAL);
  TYPEDEF_CA(ULONG, CAUL);
  TYPEDEF_CA(float, CAFLT);
  TYPEDEF_CA(double, CADBL);
  TYPEDEF_CA(CY, CACY);
  TYPEDEF_CA(DATE, CADATE);
  TYPEDEF_CA(BSTR, CABSTR);
  TYPEDEF_CA(BSTRBLOB, CABSTRBLOB);
  TYPEDEF_CA(VARIANT_BOOL, CABOOL);
  TYPEDEF_CA(SCODE,  CASCODE);
  TYPEDEF_CA(PROPVARIANT, CAPROPVARIANT);
  TYPEDEF_CA(LARGE_INTEGER, CAH);
  TYPEDEF_CA(ULARGE_INTEGER, CAUH);
  TYPEDEF_CA(LPSTR, CALPSTR);
  TYPEDEF_CA(LPWSTR, CALPWSTR);
  TYPEDEF_CA(FILETIME, CAFILETIME);
  TYPEDEF_CA(CLIPDATA, CACLIPDATA);
  TYPEDEF_CA(CLSID, CACLSID);

  struct tagPROPVARIANT {
    VARTYPE vt;
    WORD wReserved1;
    WORD wReserved2;
    WORD wReserved3;
    [switch_is(vt & 0x1fff)] union {
    [case(VT_EMPTY, VT_NULL)]             ;
    [case(VT_I1)]                         char cVal;
    [case(VT_UI1)]                        UCHAR bVal;
    [case(VT_I2)]                         short iVal;
    [case(VT_UI2)]                        USHORT uiVal;
    [case(VT_BOOL)]                       VARIANT_BOOL boolVal;
#if 0 /* illegal in C++ */
    [case(VT_ILLEGAL)]                    _VARIANT_BOOL bool;
#endif
    [case(VT_I4)]                         long lVal;
    [case(VT_UI4)]                        ULONG ulVal;
    [case(VT_R4)]                         float fltVal;
    [case(VT_ERROR)]                      SCODE scode;
    [case(VT_I8)]                         LARGE_INTEGER hVal;
    [case(VT_UI8)]                        ULARGE_INTEGER uhVal;
    [case(VT_R8)]                         double dblVal;
    [case(VT_CY)]                         CY cyVal;
    [case(VT_DATE)]                       DATE date;
    [case(VT_FILETIME)]                   FILETIME filetime;
    [case(VT_CLSID)]                      CLSID *puuid;
    [case(VT_BLOB, VT_BLOB_OBJECT)]       BLOB blob;
    [case(VT_CF)]                         CLIPDATA *pclipdata;
    [case(VT_STREAM, VT_STREAMED_OBJECT)] IStream *pStream;
    [case(VT_STORAGE, VT_STORED_OBJECT)]  IStorage *pStorage;
    [case(VT_BSTR)]                       BSTR bstrVal;
    [case(VT_BSTR_BLOB)]                  BSTRBLOB bstrblobVal;
    [case(VT_LPSTR)]                      LPSTR pszVal;
    [case(VT_LPWSTR)]                     LPWSTR pwszVal;
    [case(VT_UI1|VT_VECTOR)]              CAUB caub;
    [case(VT_I2|VT_VECTOR)]               CAI cai;
    [case(VT_UI2|VT_VECTOR)]              CAUI caui;
    [case(VT_BOOL|VT_VECTOR)]             CABOOL cabool;
    [case(VT_I4|VT_VECTOR)]               CAL cal;
    [case(VT_UI4|VT_VECTOR)]              CAUL caul;
    [case(VT_R4|VT_VECTOR)]               CAFLT caflt;
    [case(VT_ERROR|VT_VECTOR)]            CASCODE cascode;
    [case(VT_I8|VT_VECTOR)]               CAH cah;
    [case(VT_UI8|VT_VECTOR)]              CAUH cauh;
    [case(VT_R8|VT_VECTOR)]               CADBL cadbl;
    [case(VT_CY|VT_VECTOR)]               CACY cacy;
    [case(VT_DATE|VT_VECTOR)]             CADATE cadate;
    [case(VT_FILETIME|VT_VECTOR)]         CAFILETIME cafiletime;
    [case(VT_CLSID|VT_VECTOR)]            CACLSID cauuid;
    [case(VT_CF|VT_VECTOR)]               CACLIPDATA caclipdata;
    [case(VT_BSTR|VT_VECTOR)]             CABSTR cabstr;
    [case(VT_BSTR_BLOB|VT_VECTOR)]        CABSTRBLOB cabstrblob;
    [case(VT_LPSTR|VT_VECTOR)]            CALPSTR calpstr;
    [case(VT_LPWSTR|VT_VECTOR)]           CALPWSTR calpwstr;
    [case(VT_VARIANT|VT_VECTOR)]          CAPROPVARIANT capropvar;
    };
  };

  typedef struct tagPROPVARIANT *LPPROPVARIANT;

  /* FIXME: bunches of property IDs */

  const ULONG PRSPEC_INVALID = 0xffffffff;
  const ULONG PRSPEC_LPWSTR = 0;
  const ULONG PRSPEC_PROPID = 1;

  typedef struct tagPROPSPEC {
    ULONG ulKind;
    [switch_is(ulKind)] union {
    [case(PRSPEC_PROPID)] PROPID propid;
    [case(PRSPEC_LPWSTR)] LPOLESTR lpwstr;
    [default]             ;
    };
  } PROPSPEC;

  typedef struct tagSTATPROPSTG {
    LPOLESTR lpwstrName;
    PROPID propid;
    VARTYPE vt;
  } STATPROPSTG;

  /* FIXME: macros */

  typedef struct tagSTATPROPSETSTG {
    FMTID fmtid;
    CLSID clsid;
    DWORD grfFlags;
    FILETIME mtime;
    FILETIME ctime;
    FILETIME atime;
    DWORD dwOSVersion;
  } STATPROPSETSTG;

  HRESULT ReadMultiple(
    [in] ULONG cpspec,
    [in, size_is(cpspec)] const PROPSPEC rgpspec[],
    [out, size_is(cpspec)] PROPVARIANT rgpropvar[]);

  HRESULT WriteMultiple(
    [in] ULONG cpspec,
    [in, size_is(cpspec)] const PROPSPEC rgpspec[],
    [in, size_is(cpspec)] const PROPVARIANT rgpropvar[],
    [in] PROPID propidNameFirst);

  HRESULT DeleteMultiple(
    [in] ULONG cpspec,
    [in, size_is(cpspec)] const PROPSPEC rgpspec[]);

  HRESULT ReadPropertyNames(
    [in] ULONG cpropid,
    [in, size_is(cpropid)] const PROPID rgpropid[],
    [out, size_is(cpropid)] LPOLESTR rglpwstrName[]);

  HRESULT WritePropertyNames(
    [in] ULONG cpropid,
    [in, size_is(cpropid)] const PROPID rgpropid[],
    [in, size_is(cpropid)] const LPOLESTR rglpwstrName[]);

  HRESULT DeletePropertyNames(
    [in] ULONG cpropid,
    [in, size_is(cpropid)] const PROPID rgpropid[]);

  HRESULT Commit(
    [in] DWORD grfCommitFlags);

  HRESULT Revert();

  HRESULT Enum(
    [out] IEnumSTATPROPSTG **ppenum);

  HRESULT SetTimes(
    [in] const FILETIME *pctime,
    [in] const FILETIME *patime,
    [in] const FILETIME *pmtime);

  HRESULT SetClass(
    [in] REFCLSID clsid);

  HRESULT Stat(
    [out] STATPROPSETSTG *statpsstg);
}

[
  object,
  uuid(0000013A-0000-0000-C000-000000000046),
  pointer_default(unique)
]
interface IPropertySetStorage : IUnknown
{
  typedef [unique] IPropertySetStorage *LPPROPERTYSETSTORAGE;

  HRESULT Create(
    [in] REFFMTID rfmtid,
    [in, unique] const CLSID *pclsid,
    [in] DWORD grfFlags,
    [in] DWORD grfMode,
    [out] IPropertyStorage **ppprstg);

  HRESULT Open(
    [in] REFFMTID rfmtid,
    [in] DWORD grfMode,
    [out] IPropertyStorage **ppprstg);

  HRESULT Delete(
    [in] REFFMTID rfmtid);

  HRESULT Enum(
    [out] IEnumSTATPROPSETSTG **ppenum);
}

[
  object,
  uuid(00000139-0000-0000-C000-000000000046),
  pointer_default(unique)
]
interface IEnumSTATPROPSTG : IUnknown
{
  typedef [unique] IEnumSTATPROPSTG *LPENUMSTATPROPSTG;

  [local]
  HRESULT Next(
    [in] ULONG celt,
    [out, size_is(celt), length_is(*pceltFetched)]
    STATPROPSTG *rgelt,
    [out] ULONG *pceltFetched);

  [call_as(Next)]
  HRESULT RemoteNext(
    [in] ULONG celt,
    [out, size_is(celt), length_is(*pceltFetched)]
    STATPROPSTG *rgelt,
    [out] ULONG *pceltFetched);

  HRESULT Skip(
    [in] ULONG celt);

  HRESULT Reset();

  HRESULT Clone(
    [out] IEnumSTATPROPSTG **ppenum);
}

[
  object,
  uuid(0000013B-0000-0000-C000-000000000046),
  pointer_default(unique)
]
interface IEnumSTATPROPSETSTG : IUnknown
{
  typedef [unique] IEnumSTATPROPSETSTG *LPENUMSTATPROPSETSTG;

  [local]
  HRESULT Next(
    [in] ULONG celt,
    [out, size_is(celt), length_is(*pceltFetched)]
    STATPROPSETSTG *rgelt,
    [out] ULONG *pceltFetched);

  [call_as(Next)]
  HRESULT RemoteNext(
    [in] ULONG celt,
    [out, size_is(celt), length_is(*pceltFetched)]
    STATPROPSETSTG *rgelt,
    [out] ULONG *pceltFetched);

  HRESULT Skip(
    [in] ULONG celt);

  HRESULT Reset();

  HRESULT Clone(
    [out] IEnumSTATPROPSETSTG **ppenum);
}

/******************** Connection Points ********************/
/* FIXME */

/******************** DCOM ********************/

[
  local,
  object,
  uuid(0000013D-0000-0000-C000-000000000046)
]
interface IClientSecurity : IUnknown
{
  typedef struct tagSOLE_AUTHENTICATION_SERVICE {
    DWORD dwAuthnSvc;
    DWORD dwAuthzSvc;
    OLECHAR *pPrincipalName;
    HRESULT hr;
  } SOLE_AUTHENTICATION_SERVICE;

  typedef SOLE_AUTHENTICATION_SERVICE *PSOLE_AUTHENTICATION_SERVICE;

  typedef enum tagEOLE_AUTHENTICATION_CAPABILITIES {
    EOAC_NONE           = 0x0,
    EOAC_MUTUAL_AUTH    = 0x1,
    EOAC_CLOAKING       = 0x10,
    EOAC_SECURE_REFS    = 0x2,
    EOAC_ACCESS_CONTROL = 0x4,
    EOAC_APPID          = 0x8
  } EOLE_AUTHENTICATION_CAPABILITIES;

  HRESULT QueryBlanket(
    [in] IUnknown *pProxy,
    [out] DWORD *pAuthnSvc,
    [out] DWORD *pAuthzSvc,
    [out] OLECHAR **pServerPrincName,
    [out] DWORD *pAuthnLevel,
    [out] DWORD *pImpLevel,
    [out] void **pAuthInfo,
    [out] DWORD *pCapabilites);

  HRESULT SetBlanket(
    [in] IUnknown *pProxy,
    [in] DWORD AuthnSvc,
    [in] DWORD AuthzSvc,
    [in] OLECHAR *pServerPrincName,
    [in] DWORD AuthnLevel,
    [in] DWORD ImpLevel,
    [in] void *pAuthInfo,
    [in] DWORD Capabilities);

  HRESULT CopyProxy(
    [in] IUnknown *pProxy,
    [out] IUnknown **ppCopy);
}

[
  local,
  object,
  uuid(0000013E-0000-0000-C000-000000000046)
]
interface IServerSecurity : IUnknown
{
  HRESULT QueryBlanket(
    [out] DWORD *pAuthnSvc,
    [out] DWORD *pAuthzSvc,
    [out] OLECHAR **pServerPrincName,
    [out] DWORD *pAuthnLevel,
    [out] DWORD *pImpLevel,
    [out] void **pPrivs,
    [out] DWORD *pCapabilities);

  HRESULT ImpersonateClient();

  HRESULT RevertToSelf();

  BOOL IsImpersonating();
}

[
  local,
  object,
  uuid(00000024-0000-0000-C000-000000000046)
]
interface IAsyncSetup : IUnknown
{
  HRESULT GetAsyncManager(
    [in] REFIID riid,
    [in] IUnknown *pOuter,
    [in] DWORD dwFlags,
    [out] IUnknown **ppInner,
    [out] IAsyncManager **ppAsyncMgr);
}

[
  local,
  object,
  uuid(0000002A-0000-0000-C000-000000000046)
]
interface IAsyncManager : IUnknown
{
  typedef enum tagDCOM_CALL_STATE {
    DCOM_NONE          = 0,
    DCOM_CALL_COMPLETE = 1,
    DCOM_CALL_CANCELED = 2
  } DCOM_CALL_STATE;

  HRESULT CompleteCall(
    [in] HRESULT Result);
  HRESULT GetCallContext(
    [in] REFIID riid,
    [out] void **pInterface);
  HRESULT GetState(
    [out] ULONG *pulStateFlags);
}