Module:  COM
Copyright:    Original Code is Copyright (c) 1995-2004 Functional Objects, Inc.
              All rights reserved.
License:      See License.txt in this distribution for details.
Warranty:     Distributed WITHOUT WARRANTY OF ANY KIND


/* This file is automatically generated from Unknwn.h; do not edit. */

/* File created by MIDL compiler version 3.03.0110 */
/* at Thu Sep 11 10:57:03 1997
 */
// Adapted from:
//+-------------------------------------------------------------------------
//
//  Microsoft Windows
//
//--------------------------------------------------------------------------



	/*  ----  IUnknown  ----  */



	/*  ----  IClassFactory  ----  */


define open primary COM-interface <IClassFactory> ( <IUnknown> )
end <IClassFactory>;

define C-address IClassFactory_DW_vtbl :: <C-COM-vtbl>
		c-name: "IClassFactory_DW_vtbl"; end;
define C-address $IID-IClassFactory :: <REFIID>
		c-name: "IID_IClassFactory"; end;

define method initialize ( This :: <IClassFactory>, #rest ignore, #key );
  next-method();
  This.vtbl := IClassFactory_DW_vtbl;
  add-interface(This, $IID-IClassFactory);
end initialize;

define open generic IClassFactory/CreateInstance (This,
		pUnkOuter, riid)
		=> (status :: <HRESULT>, Object :: <Interface>);

define C-callable-wrapper of IClassFactory/CreateInstance
  input parameter This :: <mapped-interface>;
  input parameter pUnkOuter :: <C-interface>;
  input parameter riid :: <REFIID>;
  output parameter Object :: <Interface*>;
  result status :: <C-HRESULT>;
  export: #t,
  c-name: "DW_IClassFactory_CreateInstance",
		c-modifiers: "__stdcall";
end;

define inline-only C-function IClassFactory_CreateInstance
  input parameter This :: <C-interface>;
  input parameter pUnkOuter :: <Interface>;
  input parameter riid :: <REFIID>;
  output parameter Object :: <C-interface*>;
  result status :: <C-HRESULT>;
  c-name: "C_IClassFactory_CreateInstance";
end;

define method IClassFactory/CreateInstance(This :: <C-interface>,
		pUnkOuter :: <Interface>, riid :: <REFIID>)
		=> (status :: <HRESULT>, Object :: <Interface>)
  IClassFactory_CreateInstance(This, pUnkOuter, riid)
end;

define open generic IClassFactory/LockServer (This, fLock)
		=> (status :: <HRESULT>);

define C-callable-wrapper of IClassFactory/LockServer
  input parameter This :: <mapped-interface>;
  input parameter fLock :: <BOOL>;
  result status :: <C-HRESULT>;
  export: #t,
  c-name: "DW_IClassFactory_LockServer",
		c-modifiers: "__stdcall";
end;

define inline-only C-function IClassFactory_LockServer
  input parameter This :: <C-interface>;
  input parameter fLock :: <BOOL>;
  result status :: <C-HRESULT>;
  c-name: "C_IClassFactory_LockServer";
end;

define method IClassFactory/LockServer(This :: <C-interface>,
		fLock :: <boolean>) => (status :: <HRESULT>)
  IClassFactory_LockServer(This, fLock)
end;

/* This file is automatically generated from ObjIdl.h; do not edit. */

/* File created by MIDL compiler version 3.03.0110 */
/* at Thu Sep 11 10:57:04 1997
 */
// Adapted from:
//+-------------------------------------------------------------------------
//
//  Microsoft Windows
//
//--------------------------------------------------------------------------



	/*  ----  IMarshal  ----  */


define open primary COM-interface <IMarshal> ( <IUnknown> )
end <IMarshal>;

define C-address IMarshal_DW_vtbl :: <C-COM-vtbl>
		c-name: "IMarshal_DW_vtbl"; end;
define C-address $IID-IMarshal :: <REFIID>
		c-name: "IID_IMarshal"; end;

define method initialize ( This :: <IMarshal>, #rest ignore, #key );
  next-method();
  This.vtbl := IMarshal_DW_vtbl;
  add-interface(This, $IID-IMarshal);
end initialize;

define open generic IMarshal/GetUnmarshalClass (This, riid, pv,
		dwDestContext, pvDestContext, mshlflags, pCid)
		=> (status :: <HRESULT>);

define C-callable-wrapper of IMarshal/GetUnmarshalClass
  input parameter This :: <mapped-interface>;
  input parameter riid :: <REFIID>;
  input parameter pv :: <C-void*>;
  input parameter dwDestContext :: <DWORD>;
  input parameter pvDestContext :: <C-void*>;
  input parameter mshlflags :: <DWORD>;
  parameter pCid :: <LPCLSID>;
  result status :: <C-HRESULT>;
  c-name: "DW_IMarshal_GetUnmarshalClass",
		c-modifiers: "__stdcall";
end;

define inline-only C-function IMarshal_GetUnmarshalClass
  input parameter This :: <C-interface>;
  input parameter riid :: <REFIID>;
  input parameter pv :: <C-void*>;
  input parameter dwDestContext :: <DWORD>;
  input parameter pvDestContext :: <C-void*>;
  input parameter mshlflags :: <DWORD>;
  parameter pCid :: <LPCLSID>;
  result status :: <C-HRESULT>;
  c-name: "C_IMarshal_GetUnmarshalClass";
end;

define method IMarshal/GetUnmarshalClass(This :: <C-interface>,
		riid :: <REFIID>, pv :: <C-pointer>,
		dwDestContext :: <ffi-integer>, pvDestContext :: <C-pointer>,
		mshlflags :: <ffi-integer>, pCid :: <LPCLSID>)
		=> (status :: <HRESULT>)
  IMarshal_GetUnmarshalClass(This, riid, pv, dwDestContext,
		pvDestContext, mshlflags, pCid)
end;

define open generic IMarshal/GetMarshalSizeMax (This, riid, pv,
		dwDestContext, pvDestContext, mshlflags)
		=> (status :: <HRESULT>, Size);

define C-callable-wrapper of IMarshal/GetMarshalSizeMax
  input parameter This :: <mapped-interface>;
  input parameter riid :: <REFIID>;
  input parameter pv :: <C-void*>;
  input parameter dwDestContext :: <DWORD>;
  input parameter pvDestContext :: <C-void*>;
  input parameter mshlflags :: <DWORD>;
  output parameter pSize :: <LPDWORD>;
  result status :: <C-HRESULT>;
  c-name: "DW_IMarshal_GetMarshalSizeMax",
		c-modifiers: "__stdcall";
end;

define inline-only C-function IMarshal_GetMarshalSizeMax
  input parameter This :: <C-interface>;
  input parameter riid :: <REFIID>;
  input parameter pv :: <C-void*>;
  input parameter dwDestContext :: <DWORD>;
  input parameter pvDestContext :: <C-void*>;
  input parameter mshlflags :: <DWORD>;
  output parameter pSize :: <LPDWORD>;
  result status :: <C-HRESULT>;
  c-name: "C_IMarshal_GetMarshalSizeMax";
end;

define method IMarshal/GetMarshalSizeMax(This :: <C-interface>,
		riid :: <REFIID>, pv :: <C-pointer>,
		dwDestContext :: <ffi-integer>, pvDestContext :: <C-pointer>,
		mshlflags :: <ffi-integer>) => (status :: <HRESULT>, Size)
  IMarshal_GetMarshalSizeMax(This, riid, pv, dwDestContext,
		pvDestContext, mshlflags)
end;

define open generic IMarshal/MarshalInterface (This, pStm, riid,
		pv, dwDestContext, pvDestContext, mshlflags)
		=> (status :: <HRESULT>);

define C-callable-wrapper of IMarshal/MarshalInterface
  input parameter This :: <mapped-interface>;
  input parameter pStm :: <C-interface>;
  input parameter riid :: <REFIID>;
  input parameter pv :: <C-void*>;
  input parameter dwDestContext :: <DWORD>;
  input parameter pvDestContext :: <C-void*>;
  input parameter mshlflags :: <DWORD>;
  result status :: <C-HRESULT>;
  c-name: "DW_IMarshal_MarshalInterface",
		c-modifiers: "__stdcall";
end;

define inline-only C-function IMarshal_MarshalInterface
  input parameter This :: <C-interface>;
  input parameter pStm :: <Interface>;
  input parameter riid :: <REFIID>;
  input parameter pv :: <C-void*>;
  input parameter dwDestContext :: <DWORD>;
  input parameter pvDestContext :: <C-void*>;
  input parameter mshlflags :: <DWORD>;
  result status :: <C-HRESULT>;
  c-name: "C_IMarshal_MarshalInterface";
end;

define method IMarshal/MarshalInterface(This :: <C-interface>,
		pStm :: <Interface>, riid :: <REFIID>, pv :: <C-pointer>,
		dwDestContext :: <ffi-integer>, pvDestContext :: <C-pointer>,
		mshlflags :: <ffi-integer>) => (status :: <HRESULT>)
  IMarshal_MarshalInterface(This, pStm, riid, pv, dwDestContext,
		pvDestContext, mshlflags)
end;

define open generic IMarshal/UnmarshalInterface (This, pStm,
		riid) => (status :: <HRESULT>, pv :: <C-void*>);

define C-callable-wrapper of IMarshal/UnmarshalInterface
  input parameter This :: <mapped-interface>;
  input parameter pStm :: <C-interface>;
  input parameter riid :: <REFIID>;
  output parameter ppv :: <C-void**>;
  result status :: <C-HRESULT>;
  c-name: "DW_IMarshal_UnmarshalInterface",
		c-modifiers: "__stdcall";
end;

define inline-only C-function IMarshal_UnmarshalInterface
  input parameter This :: <C-interface>;
  input parameter pStm :: <Interface>;
  input parameter riid :: <REFIID>;
  output parameter ppv :: <C-void**>;
  result status :: <C-HRESULT>;
  c-name: "C_IMarshal_UnmarshalInterface";
end;

define method IMarshal/UnmarshalInterface(This :: <C-interface>,
		pStm :: <Interface>, riid :: <REFIID>)
		=> (status :: <HRESULT>, pv :: <C-void*>)
  IMarshal_UnmarshalInterface(This, pStm, riid)
end;

define open generic IMarshal/ReleaseMarshalData (This, pStm)
		=> (status :: <HRESULT>);

define C-callable-wrapper of IMarshal/ReleaseMarshalData
  input parameter This :: <mapped-interface>;
  input parameter pStm :: <C-interface>;
  result status :: <C-HRESULT>;
  c-name: "DW_IMarshal_ReleaseMarshalData",
		c-modifiers: "__stdcall";
end;

define inline-only C-function IMarshal_ReleaseMarshalData
  input parameter This :: <C-interface>;
  input parameter pStm :: <Interface>;
  result status :: <C-HRESULT>;
  c-name: "C_IMarshal_ReleaseMarshalData";
end;

define method IMarshal/ReleaseMarshalData(This :: <C-interface>,
		pStm :: <Interface>) => (status :: <HRESULT>)
  IMarshal_ReleaseMarshalData(This, pStm)
end;

define open generic IMarshal/DisconnectObject (This, dwReserved)
		=> (status :: <HRESULT>);

define C-callable-wrapper of IMarshal/DisconnectObject
  input parameter This :: <mapped-interface>;
  input parameter dwReserved :: <DWORD>;
  result status :: <C-HRESULT>;
  c-name: "DW_IMarshal_DisconnectObject",
		c-modifiers: "__stdcall";
end;

define inline-only C-function IMarshal_DisconnectObject
  input parameter This :: <C-interface>;
  input parameter dwReserved :: <DWORD>;
  result status :: <C-HRESULT>;
  c-name: "C_IMarshal_DisconnectObject";
end;

define method IMarshal/DisconnectObject(This :: <C-interface>,
		dwReserved :: <ffi-integer>) => (status :: <HRESULT>)
  IMarshal_DisconnectObject(This, dwReserved)
end;


	/*  ----  IMalloc  ----  */


define open primary COM-interface <IMalloc> ( <IUnknown> )
end <IMalloc>;

define C-address IMalloc_DW_vtbl :: <C-COM-vtbl>
		c-name: "IMalloc_DW_vtbl"; end;
define C-address $IID-IMalloc :: <REFIID>
		c-name: "IID_IMalloc"; end;

define method initialize ( This :: <IMalloc>, #rest ignore, #key );
  next-method();
  This.vtbl := IMalloc_DW_vtbl;
  add-interface(This, $IID-IMalloc);
end initialize;

define open generic IMalloc/Alloc (This, cb)
		=> (value :: <C-pointer>);

define C-callable-wrapper of IMalloc/Alloc
  input parameter This :: <mapped-interface>;
  input parameter cb :: <ULONG>;
  result value :: <C-void*>;
  c-name: "DW_IMalloc_Alloc", c-modifiers: "__stdcall";
end;

define inline-only C-function IMalloc_Alloc
  input parameter This :: <C-interface>;
  input parameter cb :: <ULONG>;
  result value :: <C-void*>;
  c-name: "C_IMalloc_Alloc";
end;

define method IMalloc/Alloc(This :: <C-interface>,
		cb :: <ffi-integer>) => (value :: <C-pointer>)
  IMalloc_Alloc(This, cb)
end;

define open generic IMalloc/Realloc (This, pv, cb)
		=> (value :: <C-pointer>);

define C-callable-wrapper of IMalloc/Realloc
  input parameter This :: <mapped-interface>;
  input parameter pv :: <C-void*>;
  input parameter cb :: <ULONG>;
  result value :: <C-void*>;
  c-name: "DW_IMalloc_Realloc", c-modifiers: "__stdcall";
end;

define inline-only C-function IMalloc_Realloc
  input parameter This :: <C-interface>;
  input parameter pv :: <C-void*>;
  input parameter cb :: <ULONG>;
  result value :: <C-void*>;
  c-name: "C_IMalloc_Realloc";
end;

define method IMalloc/Realloc(This :: <C-interface>,
		pv :: <C-pointer>, cb :: <ffi-integer>)
		=> (value :: <C-pointer>)
  IMalloc_Realloc(This, pv, cb)
end;

define open generic IMalloc/Free (This, pv) => ();

define C-callable-wrapper of IMalloc/Free
  input parameter This :: <mapped-interface>;
  input parameter pv :: <C-void*>;
  c-name: "DW_IMalloc_Free", c-modifiers: "__stdcall";
end;

define inline-only C-function IMalloc_Free
  input parameter This :: <C-interface>;
  input parameter pv :: <C-void*>;
  c-name: "C_IMalloc_Free";
end;

define method IMalloc/Free(This :: <C-interface>,
		pv :: <C-pointer>) => ()
  IMalloc_Free(This, pv)
end;

define open generic IMalloc/GetSize (This, pv)
		=> (value :: <ffi-integer>);

define C-callable-wrapper of IMalloc/GetSize
  input parameter This :: <mapped-interface>;
  input parameter pv :: <C-void*>;
  result value :: <ULONG>;
  c-name: "DW_IMalloc_GetSize", c-modifiers: "__stdcall";
end;

define inline-only C-function IMalloc_GetSize
  input parameter This :: <C-interface>;
  input parameter pv :: <C-void*>;
  result value :: <ULONG>;
  c-name: "C_IMalloc_GetSize";
end;

define method IMalloc/GetSize(This :: <C-interface>,
		pv :: <C-pointer>) => (value :: <ffi-integer>)
  IMalloc_GetSize(This, pv)
end;

define open generic IMalloc/DidAlloc (This, pv)
		=> (value :: <integer>);

define C-callable-wrapper of IMalloc/DidAlloc
  input parameter This :: <mapped-interface>;
  input parameter pv :: <C-void*>;
  result value :: <C-int>;
  c-name: "DW_IMalloc_DidAlloc", c-modifiers: "__stdcall";
end;

define inline-only C-function IMalloc_DidAlloc
  input parameter This :: <C-interface>;
  input parameter pv :: <C-void*>;
  result value :: <C-int>;
  c-name: "C_IMalloc_DidAlloc";
end;

define method IMalloc/DidAlloc(This :: <C-interface>,
		pv :: <C-pointer>) => (value :: <integer>)
  IMalloc_DidAlloc(This, pv)
end;

define open generic IMalloc/HeapMinimize (This) => ();

define C-callable-wrapper of IMalloc/HeapMinimize
  input parameter This :: <mapped-interface>;
  c-name: "DW_IMalloc_HeapMinimize", c-modifiers: "__stdcall";
end;

define inline-only C-function IMalloc_HeapMinimize
  input parameter This :: <C-interface>;
  c-name: "C_IMalloc_HeapMinimize";
end;

define method IMalloc/HeapMinimize(This :: <C-interface>) => ()
  IMalloc_HeapMinimize(This)
end;


	/*  ----  IMallocSpy  ----  */


define open primary COM-interface <IMallocSpy> ( <IUnknown> )
end <IMallocSpy>;

define C-address IMallocSpy_DW_vtbl :: <C-COM-vtbl>
		c-name: "IMallocSpy_DW_vtbl"; end;
define C-address $IID-IMallocSpy :: <REFIID>
		c-name: "IID_IMallocSpy"; end;

define method initialize ( This :: <IMallocSpy>, #rest ignore, #key );
  next-method();
  This.vtbl := IMallocSpy_DW_vtbl;
  add-interface(This, $IID-IMallocSpy);
end initialize;

define open generic IMallocSpy/PreAlloc (This, cbRequest)
		=> (value :: <ffi-integer>);

define C-callable-wrapper of IMallocSpy/PreAlloc
  input parameter This :: <mapped-interface>;
  input parameter cbRequest :: <ULONG>;
  result value :: <ULONG>;
  c-name: "DW_IMallocSpy_PreAlloc", c-modifiers: "__stdcall";
end;

define inline-only C-function IMallocSpy_PreAlloc
  input parameter This :: <C-interface>;
  input parameter cbRequest :: <ULONG>;
  result value :: <ULONG>;
  c-name: "C_IMallocSpy_PreAlloc";
end;

define method IMallocSpy/PreAlloc(This :: <C-interface>,
		cbRequest :: <ffi-integer>) => (value :: <ffi-integer>)
  IMallocSpy_PreAlloc(This, cbRequest)
end;

define open generic IMallocSpy/PostAlloc (This, pActual)
		=> (value :: <C-pointer>);

define C-callable-wrapper of IMallocSpy/PostAlloc
  input parameter This :: <mapped-interface>;
  input parameter pActual :: <C-void*>;
  result value :: <C-void*>;
  c-name: "DW_IMallocSpy_PostAlloc", c-modifiers: "__stdcall";
end;

define inline-only C-function IMallocSpy_PostAlloc
  input parameter This :: <C-interface>;
  input parameter pActual :: <C-void*>;
  result value :: <C-void*>;
  c-name: "C_IMallocSpy_PostAlloc";
end;

define method IMallocSpy/PostAlloc(This :: <C-interface>,
		pActual :: <C-pointer>) => (value :: <C-pointer>)
  IMallocSpy_PostAlloc(This, pActual)
end;

define open generic IMallocSpy/PreFree (This, pRequest, fSpyed)
		=> (value :: <C-pointer>);

define C-callable-wrapper of IMallocSpy/PreFree
  input parameter This :: <mapped-interface>;
  input parameter pRequest :: <C-void*>;
  input parameter fSpyed :: <BOOL>;
  result value :: <C-void*>;
  c-name: "DW_IMallocSpy_PreFree", c-modifiers: "__stdcall";
end;

define inline-only C-function IMallocSpy_PreFree
  input parameter This :: <C-interface>;
  input parameter pRequest :: <C-void*>;
  input parameter fSpyed :: <BOOL>;
  result value :: <C-void*>;
  c-name: "C_IMallocSpy_PreFree";
end;

define method IMallocSpy/PreFree(This :: <C-interface>,
		pRequest :: <C-pointer>, fSpyed :: <boolean>)
		=> (value :: <C-pointer>)
  IMallocSpy_PreFree(This, pRequest, fSpyed)
end;

define open generic IMallocSpy/PostFree (This, fSpyed) => ();

define C-callable-wrapper of IMallocSpy/PostFree
  input parameter This :: <mapped-interface>;
  input parameter fSpyed :: <BOOL>;
  c-name: "DW_IMallocSpy_PostFree", c-modifiers: "__stdcall";
end;

define inline-only C-function IMallocSpy_PostFree
  input parameter This :: <C-interface>;
  input parameter fSpyed :: <BOOL>;
  c-name: "C_IMallocSpy_PostFree";
end;

define method IMallocSpy/PostFree(This :: <C-interface>,
		fSpyed :: <boolean>) => ()
  IMallocSpy_PostFree(This, fSpyed)
end;

define open generic IMallocSpy/PreRealloc (This, pRequest,
		cbRequest, fSpyed)
		=> (value :: <ffi-integer>, pNewRequest :: <C-void*>);

define C-callable-wrapper of IMallocSpy/PreRealloc
  input parameter This :: <mapped-interface>;
  input parameter pRequest :: <C-void*>;
  input parameter cbRequest :: <ULONG>;
  output parameter ppNewRequest :: <C-void**>;
  input parameter fSpyed :: <BOOL>;
  result value :: <ULONG>;
  c-name: "DW_IMallocSpy_PreRealloc", c-modifiers: "__stdcall";
end;

define inline-only C-function IMallocSpy_PreRealloc
  input parameter This :: <C-interface>;
  input parameter pRequest :: <C-void*>;
  input parameter cbRequest :: <ULONG>;
  output parameter ppNewRequest :: <C-void**>;
  input parameter fSpyed :: <BOOL>;
  result value :: <ULONG>;
  c-name: "C_IMallocSpy_PreRealloc";
end;

define method IMallocSpy/PreRealloc(This :: <C-interface>,
		pRequest :: <C-pointer>, cbRequest :: <ffi-integer>,
		fSpyed :: <boolean>)
		=> (value :: <ffi-integer>, pNewRequest :: <C-void*>)
  IMallocSpy_PreRealloc(This, pRequest, cbRequest, fSpyed)
end;

define open generic IMallocSpy/PostRealloc (This, pActual,
		fSpyed) => (value :: <C-pointer>);

define C-callable-wrapper of IMallocSpy/PostRealloc
  input parameter This :: <mapped-interface>;
  input parameter pActual :: <C-void*>;
  input parameter fSpyed :: <BOOL>;
  result value :: <C-void*>;
  c-name: "DW_IMallocSpy_PostRealloc", c-modifiers: "__stdcall";
end;

define inline-only C-function IMallocSpy_PostRealloc
  input parameter This :: <C-interface>;
  input parameter pActual :: <C-void*>;
  input parameter fSpyed :: <BOOL>;
  result value :: <C-void*>;
  c-name: "C_IMallocSpy_PostRealloc";
end;

define method IMallocSpy/PostRealloc(This :: <C-interface>,
		pActual :: <C-pointer>, fSpyed :: <boolean>)
		=> (value :: <C-pointer>)
  IMallocSpy_PostRealloc(This, pActual, fSpyed)
end;

define open generic IMallocSpy/PreGetSize (This, pRequest,
		fSpyed) => (value :: <C-pointer>);

define C-callable-wrapper of IMallocSpy/PreGetSize
  input parameter This :: <mapped-interface>;
  input parameter pRequest :: <C-void*>;
  input parameter fSpyed :: <BOOL>;
  result value :: <C-void*>;
  c-name: "DW_IMallocSpy_PreGetSize", c-modifiers: "__stdcall";
end;

define inline-only C-function IMallocSpy_PreGetSize
  input parameter This :: <C-interface>;
  input parameter pRequest :: <C-void*>;
  input parameter fSpyed :: <BOOL>;
  result value :: <C-void*>;
  c-name: "C_IMallocSpy_PreGetSize";
end;

define method IMallocSpy/PreGetSize(This :: <C-interface>,
		pRequest :: <C-pointer>, fSpyed :: <boolean>)
		=> (value :: <C-pointer>)
  IMallocSpy_PreGetSize(This, pRequest, fSpyed)
end;

define open generic IMallocSpy/PostGetSize (This, cbActual,
		fSpyed) => (value :: <ffi-integer>);

define C-callable-wrapper of IMallocSpy/PostGetSize
  input parameter This :: <mapped-interface>;
  input parameter cbActual :: <ULONG>;
  input parameter fSpyed :: <BOOL>;
  result value :: <ULONG>;
  c-name: "DW_IMallocSpy_PostGetSize", c-modifiers: "__stdcall";
end;

define inline-only C-function IMallocSpy_PostGetSize
  input parameter This :: <C-interface>;
  input parameter cbActual :: <ULONG>;
  input parameter fSpyed :: <BOOL>;
  result value :: <ULONG>;
  c-name: "C_IMallocSpy_PostGetSize";
end;

define method IMallocSpy/PostGetSize(This :: <C-interface>,
		cbActual :: <ffi-integer>, fSpyed :: <boolean>)
		=> (value :: <ffi-integer>)
  IMallocSpy_PostGetSize(This, cbActual, fSpyed)
end;

define open generic IMallocSpy/PreDidAlloc (This, pRequest,
		fSpyed) => (value :: <C-pointer>);

define C-callable-wrapper of IMallocSpy/PreDidAlloc
  input parameter This :: <mapped-interface>;
  input parameter pRequest :: <C-void*>;
  input parameter fSpyed :: <BOOL>;
  result value :: <C-void*>;
  c-name: "DW_IMallocSpy_PreDidAlloc", c-modifiers: "__stdcall";
end;

define inline-only C-function IMallocSpy_PreDidAlloc
  input parameter This :: <C-interface>;
  input parameter pRequest :: <C-void*>;
  input parameter fSpyed :: <BOOL>;
  result value :: <C-void*>;
  c-name: "C_IMallocSpy_PreDidAlloc";
end;

define method IMallocSpy/PreDidAlloc(This :: <C-interface>,
		pRequest :: <C-pointer>, fSpyed :: <boolean>)
		=> (value :: <C-pointer>)
  IMallocSpy_PreDidAlloc(This, pRequest, fSpyed)
end;

define open generic IMallocSpy/PostDidAlloc (This, pRequest,
		fSpyed, fActual) => (value :: <integer>);

define C-callable-wrapper of IMallocSpy/PostDidAlloc
  input parameter This :: <mapped-interface>;
  input parameter pRequest :: <C-void*>;
  input parameter fSpyed :: <BOOL>;
  input parameter fActual :: <C-int>;
  result value :: <C-int>;
  c-name: "DW_IMallocSpy_PostDidAlloc",
		c-modifiers: "__stdcall";
end;

define inline-only C-function IMallocSpy_PostDidAlloc
  input parameter This :: <C-interface>;
  input parameter pRequest :: <C-void*>;
  input parameter fSpyed :: <BOOL>;
  input parameter fActual :: <C-int>;
  result value :: <C-int>;
  c-name: "C_IMallocSpy_PostDidAlloc";
end;

define method IMallocSpy/PostDidAlloc(This :: <C-interface>,
		pRequest :: <C-pointer>, fSpyed :: <boolean>,
		fActual :: <integer>) => (value :: <integer>)
  IMallocSpy_PostDidAlloc(This, pRequest, fSpyed, fActual)
end;

define open generic IMallocSpy/PreHeapMinimize (This) => ();

define C-callable-wrapper of IMallocSpy/PreHeapMinimize
  input parameter This :: <mapped-interface>;
  c-name: "DW_IMallocSpy_PreHeapMinimize",
		c-modifiers: "__stdcall";
end;

define inline-only C-function IMallocSpy_PreHeapMinimize
  input parameter This :: <C-interface>;
  c-name: "C_IMallocSpy_PreHeapMinimize";
end;

define method IMallocSpy/PreHeapMinimize(This :: <C-interface>)
		=> ()
  IMallocSpy_PreHeapMinimize(This)
end;

define open generic IMallocSpy/PostHeapMinimize (This) => ();

define C-callable-wrapper of IMallocSpy/PostHeapMinimize
  input parameter This :: <mapped-interface>;
  c-name: "DW_IMallocSpy_PostHeapMinimize",
		c-modifiers: "__stdcall";
end;

define inline-only C-function IMallocSpy_PostHeapMinimize
  input parameter This :: <C-interface>;
  c-name: "C_IMallocSpy_PostHeapMinimize";
end;

define method IMallocSpy/PostHeapMinimize(This :: <C-interface>)
		=> ()
  IMallocSpy_PostHeapMinimize(This)
end;


	/*  ----  IStdMarshalInfo  ----  */


define open primary COM-interface <IStdMarshalInfo> ( <IUnknown> )
end <IStdMarshalInfo>;

define C-address IStdMarshalInfo_DW_vtbl :: <C-COM-vtbl>
		c-name: "IStdMarshalInfo_DW_vtbl"; end;
define C-address $IID-IStdMarshalInfo :: <REFIID>
		c-name: "IID_IStdMarshalInfo"; end;

define method initialize ( This :: <IStdMarshalInfo>, #rest ignore, #key );
  next-method();
  This.vtbl := IStdMarshalInfo_DW_vtbl;
  add-interface(This, $IID-IStdMarshalInfo);
end initialize;

define open generic IStdMarshalInfo/GetClassForHandler (This,
		dwDestContext, pvDestContext, pClsid)
		=> (status :: <HRESULT>);

define C-callable-wrapper of IStdMarshalInfo/GetClassForHandler
  input parameter This :: <mapped-interface>;
  input parameter dwDestContext :: <DWORD>;
  input parameter pvDestContext :: <C-void*>;
  parameter pClsid :: <LPCLSID>;
  result status :: <C-HRESULT>;
  c-name: "DW_IStdMarshalInfo_GetClassForHandler",
		c-modifiers: "__stdcall";
end;

define inline-only C-function IStdMarshalInfo_GetClassForHandler
  input parameter This :: <C-interface>;
  input parameter dwDestContext :: <DWORD>;
  input parameter pvDestContext :: <C-void*>;
  parameter pClsid :: <LPCLSID>;
  result status :: <C-HRESULT>;
  c-name: "C_IStdMarshalInfo_GetClassForHandler";
end;

define method IStdMarshalInfo/GetClassForHandler(This :: <C-interface>,
		dwDestContext :: <ffi-integer>, pvDestContext :: <C-pointer>,
		pClsid :: <LPCLSID>) => (status :: <HRESULT>)
  IStdMarshalInfo_GetClassForHandler(This, dwDestContext,
		pvDestContext, pClsid)
end;


	/*  ----  IExternalConnection  ----  */


define open primary COM-interface <IExternalConnection> ( <IUnknown> )
end <IExternalConnection>;

define C-address IExternalConnection_DW_vtbl :: <C-COM-vtbl>
		c-name: "IExternalConnection_DW_vtbl"; end;
define C-address $IID-IExternalConnection :: <REFIID>
		c-name: "IID_IExternalConnection"; end;

define method initialize ( This :: <IExternalConnection>, #rest ignore, #key );
  next-method();
  This.vtbl := IExternalConnection_DW_vtbl;
  add-interface(This, $IID-IExternalConnection);
end initialize;

define open generic IExternalConnection/AddConnection (This,
		extconn, reserved) => (value :: <ffi-integer>);

define C-callable-wrapper of IExternalConnection/AddConnection
  input parameter This :: <mapped-interface>;
  input parameter extconn :: <DWORD>;
  input parameter reserved :: <DWORD>;
  result value :: <DWORD>;
  c-name: "DW_IExternalConnection_AddConnection",
		c-modifiers: "__stdcall";
end;

define inline-only C-function IExternalConnection_AddConnection
  input parameter This :: <C-interface>;
  input parameter extconn :: <DWORD>;
  input parameter reserved :: <DWORD>;
  result value :: <DWORD>;
  c-name: "C_IExternalConnection_AddConnection";
end;

define method IExternalConnection/AddConnection(This :: <C-interface>,
		extconn :: <ffi-integer>, reserved :: <ffi-integer>)
		=> (value :: <ffi-integer>)
  IExternalConnection_AddConnection(This, extconn, reserved)
end;

define open generic IExternalConnection/ReleaseConnection (This,
		extconn, reserved, fLastReleaseCloses)
		=> (value :: <ffi-integer>);

define C-callable-wrapper
		of IExternalConnection/ReleaseConnection
  input parameter This :: <mapped-interface>;
  input parameter extconn :: <DWORD>;
  input parameter reserved :: <DWORD>;
  input parameter fLastReleaseCloses :: <BOOL>;
  result value :: <DWORD>;
  c-name: "DW_IExternalConnection_ReleaseConnection",
		c-modifiers: "__stdcall";
end;

define inline-only C-function IExternalConnection_ReleaseConnection
  input parameter This :: <C-interface>;
  input parameter extconn :: <DWORD>;
  input parameter reserved :: <DWORD>;
  input parameter fLastReleaseCloses :: <BOOL>;
  result value :: <DWORD>;
  c-name: "C_IExternalConnection_ReleaseConnection";
end;

define method IExternalConnection/ReleaseConnection(This :: <C-interface>,
		extconn :: <ffi-integer>, reserved :: <ffi-integer>,
		fLastReleaseCloses :: <boolean>) => (value :: <ffi-integer>)
  IExternalConnection_ReleaseConnection(This, extconn, reserved,
		fLastReleaseCloses)
end;


	/*  ----  IMultiQI  ----  */


define C-address $IID-IMultiQI :: <REFIID>
		c-name: "IID_IMultiQI"; end;


define open generic IMultiQI/QueryMultipleInterfaces (This,
		cMQIs, pMQIs) => (status :: <HRESULT>);

define inline-only C-function IMultiQI_QueryMultipleInterfaces
  input parameter This :: <C-interface>;
  input parameter cMQIs :: <ULONG>;
   parameter pMQIs :: <LPMULTI-QI>;
  result status :: <C-HRESULT>;
  c-name: "C_IMultiQI_QueryMultipleInterfaces";
end;

define method IMultiQI/QueryMultipleInterfaces(This :: <C-interface>,
		cMQIs :: <ffi-integer>, pMQIs :: <LPMULTI-QI>)
		=> (status :: <HRESULT>)
  IMultiQI_QueryMultipleInterfaces(This, cMQIs, pMQIs)
end;


	/*  ----  IEnumUnknown  ----  */


define open primary COM-interface <IEnumUnknown> ( <IUnknown> )
end <IEnumUnknown>;

define C-address IEnumUnknown_DW_vtbl :: <C-COM-vtbl>
		c-name: "IEnumUnknown_DW_vtbl"; end;
define C-address $IID-IEnumUnknown :: <REFIID>
		c-name: "IID_IEnumUnknown"; end;

define method initialize ( This :: <IEnumUnknown>, #rest ignore, #key );
  next-method();
  This.vtbl := IEnumUnknown_DW_vtbl;
  add-interface(This, $IID-IEnumUnknown);
end initialize;

define open generic IEnumUnknown/Next (This, celt)
		=> (status :: <HRESULT>, rgelt :: <Interface>, celtFetched);

define C-callable-wrapper of IEnumUnknown/Next
  input parameter This :: <mapped-interface>;
  input parameter celt :: <ULONG>;
  output parameter rgelt :: <Interface*>;
  output parameter pceltFetched :: <LPULONG>;
  result status :: <C-HRESULT>;
  c-name: "DW_IEnumUnknown_Next", c-modifiers: "__stdcall";
end;

define inline-only C-function IEnumUnknown_Next
  input parameter This :: <C-interface>;
  input parameter celt :: <ULONG>;
  output parameter rgelt :: <C-interface*>;
  output parameter pceltFetched :: <LPULONG>;
  result status :: <C-HRESULT>;
  c-name: "C_IEnumUnknown_Next";
end;

define method IEnumUnknown/Next(This :: <C-interface>,
		celt :: <ffi-integer>)
		=> (status :: <HRESULT>, rgelt :: <Interface>, celtFetched)
  IEnumUnknown_Next(This, celt)
end;

define open generic IEnumUnknown/Skip (This, celt)
		=> (status :: <HRESULT>);

define C-callable-wrapper of IEnumUnknown/Skip
  input parameter This :: <mapped-interface>;
  input parameter celt :: <ULONG>;
  result status :: <C-HRESULT>;
  c-name: "DW_IEnumUnknown_Skip", c-modifiers: "__stdcall";
end;

define inline-only C-function IEnumUnknown_Skip
  input parameter This :: <C-interface>;
  input parameter celt :: <ULONG>;
  result status :: <C-HRESULT>;
  c-name: "C_IEnumUnknown_Skip";
end;

define method IEnumUnknown/Skip(This :: <C-interface>,
		celt :: <ffi-integer>) => (status :: <HRESULT>)
  IEnumUnknown_Skip(This, celt)
end;

define open generic IEnumUnknown/Reset (This)
		=> (status :: <HRESULT>);

define C-callable-wrapper of IEnumUnknown/Reset
  input parameter This :: <mapped-interface>;
  result status :: <C-HRESULT>;
  c-name: "DW_IEnumUnknown_Reset", c-modifiers: "__stdcall";
end;

define inline-only C-function IEnumUnknown_Reset
  input parameter This :: <C-interface>;
  result status :: <C-HRESULT>;
  c-name: "C_IEnumUnknown_Reset";
end;

define method IEnumUnknown/Reset(This :: <C-interface>)
		=> (status :: <HRESULT>)
  IEnumUnknown_Reset(This)
end;

define open generic IEnumUnknown/Clone (This)
		=> (status :: <HRESULT>, penum :: <Interface>);

define C-callable-wrapper of IEnumUnknown/Clone
  input parameter This :: <mapped-interface>;
  output parameter ppenum :: <Interface*>;
  result status :: <C-HRESULT>;
  c-name: "DW_IEnumUnknown_Clone", c-modifiers: "__stdcall";
end;

define inline-only C-function IEnumUnknown_Clone
  input parameter This :: <C-interface>;
  output parameter ppenum :: <C-interface*>;
  result status :: <C-HRESULT>;
  c-name: "C_IEnumUnknown_Clone";
end;

define method IEnumUnknown/Clone(This :: <C-interface>)
		=> (status :: <HRESULT>, penum :: <Interface>)
  IEnumUnknown_Clone(This)
end;


	/*  ----  IBindCtx  ----  */


define open primary COM-interface <IBindCtx> ( <IUnknown> )
end <IBindCtx>;

define C-address IBindCtx_DW_vtbl :: <C-COM-vtbl>
		c-name: "IBindCtx_DW_vtbl"; end;
define C-address $IID-IBindCtx :: <REFIID>
		c-name: "IID_IBindCtx"; end;

define method initialize ( This :: <IBindCtx>, #rest ignore, #key );
  next-method();
  This.vtbl := IBindCtx_DW_vtbl;
  add-interface(This, $IID-IBindCtx);
end initialize;

define open generic IBindCtx/RegisterObjectBound (This, punk)
		=> (status :: <HRESULT>);

define C-callable-wrapper of IBindCtx/RegisterObjectBound
  input parameter This :: <mapped-interface>;
  input parameter punk :: <C-interface>;
  result status :: <C-HRESULT>;
  c-name: "DW_IBindCtx_RegisterObjectBound",
		c-modifiers: "__stdcall";
end;

define inline-only C-function IBindCtx_RegisterObjectBound
  input parameter This :: <C-interface>;
  input parameter punk :: <Interface>;
  result status :: <C-HRESULT>;
  c-name: "C_IBindCtx_RegisterObjectBound";
end;

define method IBindCtx/RegisterObjectBound(This :: <C-interface>,
		punk :: <Interface>) => (status :: <HRESULT>)
  IBindCtx_RegisterObjectBound(This, punk)
end;

define open generic IBindCtx/RevokeObjectBound (This, punk)
		=> (status :: <HRESULT>);

define C-callable-wrapper of IBindCtx/RevokeObjectBound
  input parameter This :: <mapped-interface>;
  input parameter punk :: <C-interface>;
  result status :: <C-HRESULT>;
  c-name: "DW_IBindCtx_RevokeObjectBound",
		c-modifiers: "__stdcall";
end;

define inline-only C-function IBindCtx_RevokeObjectBound
  input parameter This :: <C-interface>;
  input parameter punk :: <Interface>;
  result status :: <C-HRESULT>;
  c-name: "C_IBindCtx_RevokeObjectBound";
end;

define method IBindCtx/RevokeObjectBound(This :: <C-interface>,
		punk :: <Interface>) => (status :: <HRESULT>)
  IBindCtx_RevokeObjectBound(This, punk)
end;

define open generic IBindCtx/ReleaseBoundObjects (This)
		=> (status :: <HRESULT>);

define C-callable-wrapper of IBindCtx/ReleaseBoundObjects
  input parameter This :: <mapped-interface>;
  result status :: <C-HRESULT>;
  c-name: "DW_IBindCtx_ReleaseBoundObjects",
		c-modifiers: "__stdcall";
end;

define inline-only C-function IBindCtx_ReleaseBoundObjects
  input parameter This :: <C-interface>;
  result status :: <C-HRESULT>;
  c-name: "C_IBindCtx_ReleaseBoundObjects";
end;

define method IBindCtx/ReleaseBoundObjects(This :: <C-interface>)
		=> (status :: <HRESULT>)
  IBindCtx_ReleaseBoundObjects(This)
end;

define open generic IBindCtx/SetBindOptions (This, pbindopts)
		=> (status :: <HRESULT>);

define C-callable-wrapper of IBindCtx/SetBindOptions
  input parameter This :: <mapped-interface>;
  input parameter pbindopts :: <LPBIND-OPTS>;
  result status :: <C-HRESULT>;
  c-name: "DW_IBindCtx_SetBindOptions",
		c-modifiers: "__stdcall";
end;

define inline-only C-function IBindCtx_SetBindOptions
  input parameter This :: <C-interface>;
  input parameter pbindopts :: <LPBIND-OPTS>;
  result status :: <C-HRESULT>;
  c-name: "C_IBindCtx_SetBindOptions";
end;

define method IBindCtx/SetBindOptions(This :: <C-interface>,
		pbindopts :: <LPBIND-OPTS>) => (status :: <HRESULT>)
  IBindCtx_SetBindOptions(This, pbindopts)
end;

define open generic IBindCtx/GetBindOptions (This, pbindopts)
		=> (status :: <HRESULT>);

define C-callable-wrapper of IBindCtx/GetBindOptions
  input parameter This :: <mapped-interface>;
   parameter pbindopts :: <LPBIND-OPTS>;
  result status :: <C-HRESULT>;
  c-name: "DW_IBindCtx_GetBindOptions",
		c-modifiers: "__stdcall";
end;

define inline-only C-function IBindCtx_GetBindOptions
  input parameter This :: <C-interface>;
   parameter pbindopts :: <LPBIND-OPTS>;
  result status :: <C-HRESULT>;
  c-name: "C_IBindCtx_GetBindOptions";
end;

define method IBindCtx/GetBindOptions(This :: <C-interface>,
		pbindopts :: <LPBIND-OPTS>) => (status :: <HRESULT>)
  IBindCtx_GetBindOptions(This, pbindopts)
end;

define open generic IBindCtx/GetRunningObjectTable (This)
		=> (status :: <HRESULT>, prot :: <Interface>);

define C-callable-wrapper of IBindCtx/GetRunningObjectTable
  input parameter This :: <mapped-interface>;
  output parameter pprot :: <Interface*>;
  result status :: <C-HRESULT>;
  c-name: "DW_IBindCtx_GetRunningObjectTable",
		c-modifiers: "__stdcall";
end;

define inline-only C-function IBindCtx_GetRunningObjectTable
  input parameter This :: <C-interface>;
  output parameter pprot :: <C-interface*>;
  result status :: <C-HRESULT>;
  c-name: "C_IBindCtx_GetRunningObjectTable";
end;

define method IBindCtx/GetRunningObjectTable(This :: <C-interface>)
		=> (status :: <HRESULT>, prot :: <Interface>)
  IBindCtx_GetRunningObjectTable(This)
end;

define open generic IBindCtx/RegisterObjectParam (This, pszKey,
		punk) => (status :: <HRESULT>);

define C-callable-wrapper of IBindCtx/RegisterObjectParam
  input parameter This :: <mapped-interface>;
  input parameter pszKey :: <LPOLESTR>;
  input parameter punk :: <C-interface>;
  result status :: <C-HRESULT>;
  c-name: "DW_IBindCtx_RegisterObjectParam",
		c-modifiers: "__stdcall";
end;

define inline-only C-function IBindCtx_RegisterObjectParam
  input parameter This :: <C-interface>;
  input parameter pszKey :: <LPOLESTR>;
  input parameter punk :: <Interface>;
  result status :: <C-HRESULT>;
  c-name: "C_IBindCtx_RegisterObjectParam";
end;

define method IBindCtx/RegisterObjectParam(This :: <C-interface>,
		pszKey :: <LPOLESTR>, punk :: <Interface>)
		=> (status :: <HRESULT>)
  IBindCtx_RegisterObjectParam(This, pszKey, punk)
end;

define open generic IBindCtx/GetObjectParam (This, pszKey)
		=> (status :: <HRESULT>, punk :: <Interface>);

define C-callable-wrapper of IBindCtx/GetObjectParam
  input parameter This :: <mapped-interface>;
  input parameter pszKey :: <LPOLESTR>;
  output parameter ppunk :: <Interface*>;
  result status :: <C-HRESULT>;
  c-name: "DW_IBindCtx_GetObjectParam",
		c-modifiers: "__stdcall";
end;

define inline-only C-function IBindCtx_GetObjectParam
  input parameter This :: <C-interface>;
  input parameter pszKey :: <LPOLESTR>;
  output parameter ppunk :: <C-interface*>;
  result status :: <C-HRESULT>;
  c-name: "C_IBindCtx_GetObjectParam";
end;

define method IBindCtx/GetObjectParam(This :: <C-interface>,
		pszKey :: <LPOLESTR>)
		=> (status :: <HRESULT>, punk :: <Interface>)
  IBindCtx_GetObjectParam(This, pszKey)
end;

define open generic IBindCtx/EnumObjectParam (This)
		=> (status :: <HRESULT>, penum :: <Interface>);

define C-callable-wrapper of IBindCtx/EnumObjectParam
  input parameter This :: <mapped-interface>;
  output parameter ppenum :: <Interface*>;
  result status :: <C-HRESULT>;
  c-name: "DW_IBindCtx_EnumObjectParam",
		c-modifiers: "__stdcall";
end;

define inline-only C-function IBindCtx_EnumObjectParam
  input parameter This :: <C-interface>;
  output parameter ppenum :: <C-interface*>;
  result status :: <C-HRESULT>;
  c-name: "C_IBindCtx_EnumObjectParam";
end;

define method IBindCtx/EnumObjectParam(This :: <C-interface>)
		=> (status :: <HRESULT>, penum :: <Interface>)
  IBindCtx_EnumObjectParam(This)
end;

define open generic IBindCtx/RevokeObjectParam (This, pszKey)
		=> (status :: <HRESULT>);

define C-callable-wrapper of IBindCtx/RevokeObjectParam
  input parameter This :: <mapped-interface>;
  input parameter pszKey :: <LPOLESTR>;
  result status :: <C-HRESULT>;
  c-name: "DW_IBindCtx_RevokeObjectParam",
		c-modifiers: "__stdcall";
end;

define inline-only C-function IBindCtx_RevokeObjectParam
  input parameter This :: <C-interface>;
  input parameter pszKey :: <LPOLESTR>;
  result status :: <C-HRESULT>;
  c-name: "C_IBindCtx_RevokeObjectParam";
end;

define method IBindCtx/RevokeObjectParam(This :: <C-interface>,
		pszKey :: <LPOLESTR>) => (status :: <HRESULT>)
  IBindCtx_RevokeObjectParam(This, pszKey)
end;


	/*  ----  IEnumMoniker  ----  */


define open primary COM-interface <IEnumMoniker> ( <IUnknown> )
end <IEnumMoniker>;

define C-address IEnumMoniker_DW_vtbl :: <C-COM-vtbl>
		c-name: "IEnumMoniker_DW_vtbl"; end;
define C-address $IID-IEnumMoniker :: <REFIID>
		c-name: "IID_IEnumMoniker"; end;

define method initialize ( This :: <IEnumMoniker>, #rest ignore, #key );
  next-method();
  This.vtbl := IEnumMoniker_DW_vtbl;
  add-interface(This, $IID-IEnumMoniker);
end initialize;

define open generic IEnumMoniker/Next (This, celt, rgelt)
		=> (status :: <HRESULT>, celtFetched);

define C-callable-wrapper of IEnumMoniker/Next
  input parameter This :: <mapped-interface>;
  input parameter celt :: <ULONG>;
   parameter rgelt :: <Interface*>;
  output parameter pceltFetched :: <LPULONG>;
  result status :: <C-HRESULT>;
  c-name: "DW_IEnumMoniker_Next", c-modifiers: "__stdcall";
end;

define inline-only C-function IEnumMoniker_Next
  input parameter This :: <C-interface>;
  input parameter celt :: <ULONG>;
   parameter rgelt :: <Interface*>;
  output parameter pceltFetched :: <LPULONG>;
  result status :: <C-HRESULT>;
  c-name: "C_IEnumMoniker_Next";
end;

define method IEnumMoniker/Next(This :: <C-interface>,
		celt :: <ffi-integer>, rgelt :: <Interface*>)
		=> (status :: <HRESULT>, celtFetched)
  IEnumMoniker_Next(This, celt, rgelt)
end;

define open generic IEnumMoniker/Skip (This, celt)
		=> (status :: <HRESULT>);

define C-callable-wrapper of IEnumMoniker/Skip
  input parameter This :: <mapped-interface>;
  input parameter celt :: <ULONG>;
  result status :: <C-HRESULT>;
  c-name: "DW_IEnumMoniker_Skip", c-modifiers: "__stdcall";
end;

define inline-only C-function IEnumMoniker_Skip
  input parameter This :: <C-interface>;
  input parameter celt :: <ULONG>;
  result status :: <C-HRESULT>;
  c-name: "C_IEnumMoniker_Skip";
end;

define method IEnumMoniker/Skip(This :: <C-interface>,
		celt :: <ffi-integer>) => (status :: <HRESULT>)
  IEnumMoniker_Skip(This, celt)
end;

define open generic IEnumMoniker/Reset (This)
		=> (status :: <HRESULT>);

define C-callable-wrapper of IEnumMoniker/Reset
  input parameter This :: <mapped-interface>;
  result status :: <C-HRESULT>;
  c-name: "DW_IEnumMoniker_Reset", c-modifiers: "__stdcall";
end;

define inline-only C-function IEnumMoniker_Reset
  input parameter This :: <C-interface>;
  result status :: <C-HRESULT>;
  c-name: "C_IEnumMoniker_Reset";
end;

define method IEnumMoniker/Reset(This :: <C-interface>)
		=> (status :: <HRESULT>)
  IEnumMoniker_Reset(This)
end;

define open generic IEnumMoniker/Clone (This)
		=> (status :: <HRESULT>, penum :: <Interface>);

define C-callable-wrapper of IEnumMoniker/Clone
  input parameter This :: <mapped-interface>;
  output parameter ppenum :: <Interface*>;
  result status :: <C-HRESULT>;
  c-name: "DW_IEnumMoniker_Clone", c-modifiers: "__stdcall";
end;

define inline-only C-function IEnumMoniker_Clone
  input parameter This :: <C-interface>;
  output parameter ppenum :: <C-interface*>;
  result status :: <C-HRESULT>;
  c-name: "C_IEnumMoniker_Clone";
end;

define method IEnumMoniker/Clone(This :: <C-interface>)
		=> (status :: <HRESULT>, penum :: <Interface>)
  IEnumMoniker_Clone(This)
end;


	/*  ----  IRunnableObject  ----  */


define open primary COM-interface <IRunnableObject> ( <IUnknown> )
end <IRunnableObject>;

define C-address IRunnableObject_DW_vtbl :: <C-COM-vtbl>
		c-name: "IRunnableObject_DW_vtbl"; end;
define C-address $IID-IRunnableObject :: <REFIID>
		c-name: "IID_IRunnableObject"; end;

define method initialize ( This :: <IRunnableObject>, #rest ignore, #key );
  next-method();
  This.vtbl := IRunnableObject_DW_vtbl;
  add-interface(This, $IID-IRunnableObject);
end initialize;

define open generic IRunnableObject/GetRunningClass (This,
		lpClsid) => (status :: <HRESULT>);

define C-callable-wrapper of IRunnableObject/GetRunningClass
  input parameter This :: <mapped-interface>;
  parameter lpClsid :: <LPCLSID>;
  result status :: <C-HRESULT>;
  c-name: "DW_IRunnableObject_GetRunningClass",
		c-modifiers: "__stdcall";
end;

define inline-only C-function IRunnableObject_GetRunningClass
  input parameter This :: <C-interface>;
  parameter lpClsid :: <LPCLSID>;
  result status :: <C-HRESULT>;
  c-name: "C_IRunnableObject_GetRunningClass";
end;

define method IRunnableObject/GetRunningClass(This :: <C-interface>,
		lpClsid :: <LPCLSID>) => (status :: <HRESULT>)
  IRunnableObject_GetRunningClass(This, lpClsid)
end;

define open generic IRunnableObject/Run (This, pbc)
		=> (status :: <HRESULT>);

define C-callable-wrapper of IRunnableObject/Run
  input parameter This :: <mapped-interface>;
  input parameter pbc :: <IBindCtx>;
  result status :: <C-HRESULT>;
  c-name: "DW_IRunnableObject_Run", c-modifiers: "__stdcall";
end;

define inline-only C-function IRunnableObject_Run
  input parameter This :: <C-interface>;
  input parameter pbc :: <IBindCtx>;
  result status :: <C-HRESULT>;
  c-name: "C_IRunnableObject_Run";
end;

define method IRunnableObject/Run(This :: <C-interface>,
		pbc :: <IBindCtx>) => (status :: <HRESULT>)
  IRunnableObject_Run(This, pbc)
end;

define open generic IRunnableObject/IsRunning (This)
		=> (value :: <boolean>);

define C-callable-wrapper of IRunnableObject/IsRunning
  input parameter This :: <mapped-interface>;
  result value :: <BOOL>;
  c-name: "DW_IRunnableObject_IsRunning",
		c-modifiers: "__stdcall";
end;

define inline-only C-function IRunnableObject_IsRunning
  input parameter This :: <C-interface>;
  result value :: <BOOL>;
  c-name: "C_IRunnableObject_IsRunning";
end;

define method IRunnableObject/IsRunning(This :: <C-interface>)
		=> (value :: <boolean>)
  IRunnableObject_IsRunning(This)
end;

define open generic IRunnableObject/LockRunning (This, fLock,
		fLastUnlockCloses) => (status :: <HRESULT>);

define C-callable-wrapper of IRunnableObject/LockRunning
  input parameter This :: <mapped-interface>;
  input parameter fLock :: <BOOL>;
  input parameter fLastUnlockCloses :: <BOOL>;
  result status :: <C-HRESULT>;
  c-name: "DW_IRunnableObject_LockRunning",
		c-modifiers: "__stdcall";
end;

define inline-only C-function IRunnableObject_LockRunning
  input parameter This :: <C-interface>;
  input parameter fLock :: <BOOL>;
  input parameter fLastUnlockCloses :: <BOOL>;
  result status :: <C-HRESULT>;
  c-name: "C_IRunnableObject_LockRunning";
end;

define method IRunnableObject/LockRunning(This :: <C-interface>,
		fLock :: <boolean>, fLastUnlockCloses :: <boolean>)
		=> (status :: <HRESULT>)
  IRunnableObject_LockRunning(This, fLock, fLastUnlockCloses)
end;

define open generic IRunnableObject/SetContainedObject (This,
		fContained) => (status :: <HRESULT>);

define C-callable-wrapper of IRunnableObject/SetContainedObject
  input parameter This :: <mapped-interface>;
  input parameter fContained :: <BOOL>;
  result status :: <C-HRESULT>;
  c-name: "DW_IRunnableObject_SetContainedObject",
		c-modifiers: "__stdcall";
end;

define inline-only C-function IRunnableObject_SetContainedObject
  input parameter This :: <C-interface>;
  input parameter fContained :: <BOOL>;
  result status :: <C-HRESULT>;
  c-name: "C_IRunnableObject_SetContainedObject";
end;

define method IRunnableObject/SetContainedObject(This :: <C-interface>,
		fContained :: <boolean>) => (status :: <HRESULT>)
  IRunnableObject_SetContainedObject(This, fContained)
end;


	/*  ----  IRunningObjectTable  ----  */


define C-address $IID-IRunningObjectTable :: <REFIID>
		c-name: "IID_IRunningObjectTable"; end;


define open generic IRunningObjectTable/Register (This, grfFlags,
		punkObject, pmkObjectName)
		=> (status :: <HRESULT>, dwRegister);

define inline-only C-function IRunningObjectTable_Register
  input parameter This :: <C-interface>;
  input parameter grfFlags :: <DWORD>;
  input parameter punkObject :: <Interface>;
  input parameter pmkObjectName :: <Interface>;
  output parameter pdwRegister :: <LPDWORD>;
  result status :: <C-HRESULT>;
  c-name: "C_IRunningObjectTable_Register";
end;

define method IRunningObjectTable/Register(This :: <C-interface>,
		grfFlags :: <ffi-integer>, punkObject :: <Interface>,
		pmkObjectName :: <Interface>)
		=> (status :: <HRESULT>, dwRegister)
  IRunningObjectTable_Register(This, grfFlags, punkObject,
		pmkObjectName)
end;

define open generic IRunningObjectTable/Revoke (This, dwRegister)
		=> (status :: <HRESULT>);

define inline-only C-function IRunningObjectTable_Revoke
  input parameter This :: <C-interface>;
  input parameter dwRegister :: <DWORD>;
  result status :: <C-HRESULT>;
  c-name: "C_IRunningObjectTable_Revoke";
end;

define method IRunningObjectTable/Revoke(This :: <C-interface>,
		dwRegister :: <ffi-integer>) => (status :: <HRESULT>)
  IRunningObjectTable_Revoke(This, dwRegister)
end;

define open generic IRunningObjectTable/IsRunning (This,
		pmkObjectName) => (status :: <HRESULT>);

define inline-only C-function IRunningObjectTable_IsRunning
  input parameter This :: <C-interface>;
  input parameter pmkObjectName :: <Interface>;
  result status :: <C-HRESULT>;
  c-name: "C_IRunningObjectTable_IsRunning";
end;

define method IRunningObjectTable/IsRunning(This :: <C-interface>,
		pmkObjectName :: <Interface>) => (status :: <HRESULT>)
  IRunningObjectTable_IsRunning(This, pmkObjectName)
end;

define open generic IRunningObjectTable/GetObject (This,
		pmkObjectName)
		=> (status :: <HRESULT>, punkObject :: <Interface>);

define inline-only C-function IRunningObjectTable_GetObject
  input parameter This :: <C-interface>;
  input parameter pmkObjectName :: <Interface>;
  output parameter ppunkObject :: <C-interface*>;
  result status :: <C-HRESULT>;
  c-name: "C_IRunningObjectTable_GetObject";
end;

define method IRunningObjectTable/GetObject(This :: <C-interface>,
		pmkObjectName :: <Interface>)
		=> (status :: <HRESULT>, punkObject :: <Interface>)
  IRunningObjectTable_GetObject(This, pmkObjectName)
end;

define open generic IRunningObjectTable/NoteChangeTime (This,
		dwRegister, pfiletime) => (status :: <HRESULT>);

define inline-only C-function IRunningObjectTable_NoteChangeTime
  input parameter This :: <C-interface>;
  input parameter dwRegister :: <DWORD>;
  input parameter pfiletime :: <LPFILETIME>;
  result status :: <C-HRESULT>;
  c-name: "C_IRunningObjectTable_NoteChangeTime";
end;

define method IRunningObjectTable/NoteChangeTime(This :: <C-interface>,
		dwRegister :: <ffi-integer>, pfiletime :: <LPFILETIME>)
		=> (status :: <HRESULT>)
  IRunningObjectTable_NoteChangeTime(This, dwRegister, pfiletime)
end;

define open generic IRunningObjectTable/GetTimeOfLastChange
		(This, pmkObjectName, pfiletime) => (status :: <HRESULT>);

define inline-only C-function IRunningObjectTable_GetTimeOfLastChange
  input parameter This :: <C-interface>;
  input parameter pmkObjectName :: <Interface>;
  parameter pfiletime :: <LPFILETIME>;
  result status :: <C-HRESULT>;
  c-name: "C_IRunningObjectTable_GetTimeOfLastChange";
end;

define method IRunningObjectTable/GetTimeOfLastChange(This :: <C-interface>,
		pmkObjectName :: <Interface>, pfiletime :: <LPFILETIME>)
		=> (status :: <HRESULT>)
  IRunningObjectTable_GetTimeOfLastChange(This, pmkObjectName,
		pfiletime)
end;

define open generic IRunningObjectTable/EnumRunning (This)
		=> (status :: <HRESULT>, penumMoniker :: <Interface>);

define inline-only C-function IRunningObjectTable_EnumRunning
  input parameter This :: <C-interface>;
  output parameter ppenumMoniker :: <C-interface*>;
  result status :: <C-HRESULT>;
  c-name: "C_IRunningObjectTable_EnumRunning";
end;

define method IRunningObjectTable/EnumRunning(This :: <C-interface>)
		=> (status :: <HRESULT>, penumMoniker :: <Interface>)
  IRunningObjectTable_EnumRunning(This)
end;


	/*  ----  IPersist  ----  */


define open primary COM-interface <IPersist> ( <IUnknown> )
end <IPersist>;

define C-address IPersist_DW_vtbl :: <C-COM-vtbl>
		c-name: "IPersist_DW_vtbl"; end;
define C-address $IID-IPersist :: <REFIID>
		c-name: "IID_IPersist"; end;

define method initialize ( This :: <IPersist>, #rest ignore, #key );
  next-method();
  This.vtbl := IPersist_DW_vtbl;
  add-interface(This, $IID-IPersist);
end initialize;

define open generic IPersist/GetClassID (This, pClassID)
		=> (status :: <HRESULT>);

define C-callable-wrapper of IPersist/GetClassID
  input parameter This :: <mapped-interface>;
  parameter pClassID :: <LPCLSID>;
  result status :: <C-HRESULT>;
  export: #t,
  c-name: "DW_IPersist_GetClassID", c-modifiers: "__stdcall";
end;

define inline-only C-function IPersist_GetClassID
  input parameter This :: <C-interface>;
  parameter pClassID :: <LPCLSID>;
  result status :: <C-HRESULT>;
  c-name: "C_IPersist_GetClassID";
end;

define method IPersist/GetClassID(This :: <C-interface>,
		pClassID :: <LPCLSID>) => (status :: <HRESULT>)
  IPersist_GetClassID(This, pClassID)
end;


	/*  ----  IPersistStream  ----  */


define open primary COM-interface <IPersistStream> ( <IPersist> )
end <IPersistStream>;

define C-address IPersistStream_DW_vtbl :: <C-COM-vtbl>
		c-name: "IPersistStream_DW_vtbl"; end;
define C-address $IID-IPersistStream :: <REFIID>
		c-name: "IID_IPersistStream"; end;

define method initialize ( This :: <IPersistStream>, #rest ignore, #key );
  next-method();
  This.vtbl := IPersistStream_DW_vtbl;
  add-interface(This, $IID-IPersistStream);
end initialize;

define open generic IPersistStream/IsDirty (This)
		=> (status :: <HRESULT>);

define C-callable-wrapper of IPersistStream/IsDirty
  input parameter This :: <mapped-interface>;
  result status :: <C-HRESULT>;
  c-name: "DW_IPersistStream_IsDirty", c-modifiers: "__stdcall";
end;

define inline-only C-function IPersistStream_IsDirty
  input parameter This :: <C-interface>;
  result status :: <C-HRESULT>;
  c-name: "C_IPersistStream_IsDirty";
end;

define method IPersistStream/IsDirty(This :: <C-interface>)
		=> (status :: <HRESULT>)
  IPersistStream_IsDirty(This)
end;

define open generic IPersistStream/Load (This, pStm)
		=> (status :: <HRESULT>);

define C-callable-wrapper of IPersistStream/Load
  input parameter This :: <mapped-interface>;
  input parameter pStm :: <C-interface>;
  result status :: <C-HRESULT>;
  c-name: "DW_IPersistStream_Load", c-modifiers: "__stdcall";
end;

define inline-only C-function IPersistStream_Load
  input parameter This :: <C-interface>;
  input parameter pStm :: <Interface>;
  result status :: <C-HRESULT>;
  c-name: "C_IPersistStream_Load";
end;

define method IPersistStream/Load(This :: <C-interface>,
		pStm :: <Interface>) => (status :: <HRESULT>)
  IPersistStream_Load(This, pStm)
end;

define open generic IPersistStream/Save (This, pStm, fClearDirty)
		=> (status :: <HRESULT>);

define C-callable-wrapper of IPersistStream/Save
  input parameter This :: <mapped-interface>;
  input parameter pStm :: <C-interface>;
  input parameter fClearDirty :: <BOOL>;
  result status :: <C-HRESULT>;
  c-name: "DW_IPersistStream_Save", c-modifiers: "__stdcall";
end;

define inline-only C-function IPersistStream_Save
  input parameter This :: <C-interface>;
  input parameter pStm :: <Interface>;
  input parameter fClearDirty :: <BOOL>;
  result status :: <C-HRESULT>;
  c-name: "C_IPersistStream_Save";
end;

define method IPersistStream/Save(This :: <C-interface>,
		pStm :: <Interface>, fClearDirty :: <boolean>)
		=> (status :: <HRESULT>)
  IPersistStream_Save(This, pStm, fClearDirty)
end;

define open generic IPersistStream/GetSizeMax (This, pcbSize)
		=> (status :: <HRESULT>);

define C-callable-wrapper of IPersistStream/GetSizeMax
  input parameter This :: <mapped-interface>;
  parameter pcbSize :: <PULARGE-INTEGER>;
  result status :: <C-HRESULT>;
  c-name: "DW_IPersistStream_GetSizeMax",
		c-modifiers: "__stdcall";
end;

define inline-only C-function IPersistStream_GetSizeMax
  input parameter This :: <C-interface>;
  parameter pcbSize :: <PULARGE-INTEGER>;
  result status :: <C-HRESULT>;
  c-name: "C_IPersistStream_GetSizeMax";
end;

define method IPersistStream/GetSizeMax(This :: <C-interface>,
		pcbSize :: <PULARGE-INTEGER>) => (status :: <HRESULT>)
  IPersistStream_GetSizeMax(This, pcbSize)
end;


	/*  ----  IMoniker  ----  */


define open primary COM-interface <IMoniker> ( <IPersistStream> )
end <IMoniker>;

define C-address IMoniker_DW_vtbl :: <C-COM-vtbl>
		c-name: "IMoniker_DW_vtbl"; end;
define C-address $IID-IMoniker :: <REFIID>
		c-name: "IID_IMoniker"; end;

define method initialize ( This :: <IMoniker>, #rest ignore, #key );
  next-method();
  This.vtbl := IMoniker_DW_vtbl;
  add-interface(This, $IID-IMoniker);
end initialize;

define open generic IMoniker/BindToObject (This, pbc, pmkToLeft,
		riidResult) => (status :: <HRESULT>, pvResult :: <C-void*>);

define C-callable-wrapper of IMoniker/BindToObject
  input parameter This :: <mapped-interface>;
  input parameter pbc :: <C-interface>;
  input parameter pmkToLeft :: <C-interface>;
  input parameter riidResult :: <REFIID>;
  output parameter ppvResult :: <C-void**>;
  result status :: <C-HRESULT>;
  c-name: "DW_IMoniker_BindToObject", c-modifiers: "__stdcall";
end;

define inline-only C-function IMoniker_BindToObject
  input parameter This :: <C-interface>;
  input parameter pbc :: <Interface>;
  input parameter pmkToLeft :: <Interface>;
  input parameter riidResult :: <REFIID>;
  output parameter ppvResult :: <C-void**>;
  result status :: <C-HRESULT>;
  c-name: "C_IMoniker_BindToObject";
end;

define method IMoniker/BindToObject(This :: <C-interface>,
		pbc :: <Interface>, pmkToLeft :: <Interface>,
		riidResult :: <REFIID>)
		=> (status :: <HRESULT>, pvResult :: <C-void*>)
  IMoniker_BindToObject(This, pbc, pmkToLeft, riidResult)
end;

define open generic IMoniker/BindToStorage (This, pbc, pmkToLeft,
		riid) => (status :: <HRESULT>, pvObj :: <C-void*>);

define C-callable-wrapper of IMoniker/BindToStorage
  input parameter This :: <mapped-interface>;
  input parameter pbc :: <C-interface>;
  input parameter pmkToLeft :: <C-interface>;
  input parameter riid :: <REFIID>;
  output parameter ppvObj :: <C-void**>;
  result status :: <C-HRESULT>;
  c-name: "DW_IMoniker_BindToStorage", c-modifiers: "__stdcall";
end;

define inline-only C-function IMoniker_BindToStorage
  input parameter This :: <C-interface>;
  input parameter pbc :: <Interface>;
  input parameter pmkToLeft :: <Interface>;
  input parameter riid :: <REFIID>;
  output parameter ppvObj :: <C-void**>;
  result status :: <C-HRESULT>;
  c-name: "C_IMoniker_BindToStorage";
end;

define method IMoniker/BindToStorage(This :: <C-interface>,
		pbc :: <Interface>, pmkToLeft :: <Interface>, riid :: <REFIID>)
		=> (status :: <HRESULT>, pvObj :: <C-void*>)
  IMoniker_BindToStorage(This, pbc, pmkToLeft, riid)
end;

define open generic IMoniker/Reduce (This, pbc, dwReduceHowFar)
		=> (status :: <HRESULT>, mkToLeft :: <Interface>,
		pmkReduced :: <Interface>);

define C-callable-wrapper of IMoniker/Reduce
  input parameter This :: <mapped-interface>;
  input parameter pbc :: <C-interface>;
  input parameter dwReduceHowFar :: <DWORD>;
  output parameter pmkToLeft :: <Interface*>;
  output parameter ppmkReduced :: <Interface*>;
  result status :: <C-HRESULT>;
  c-name: "DW_IMoniker_Reduce", c-modifiers: "__stdcall";
end;

define inline-only C-function IMoniker_Reduce
  input parameter This :: <C-interface>;
  input parameter pbc :: <Interface>;
  input parameter dwReduceHowFar :: <DWORD>;
  output parameter pmkToLeft :: <C-interface*>;
  output parameter ppmkReduced :: <C-interface*>;
  result status :: <C-HRESULT>;
  c-name: "C_IMoniker_Reduce";
end;

define method IMoniker/Reduce(This :: <C-interface>,
		pbc :: <Interface>, dwReduceHowFar :: <ffi-integer>)
		=> (status :: <HRESULT>, mkToLeft :: <Interface>,
		pmkReduced :: <Interface>)
  IMoniker_Reduce(This, pbc, dwReduceHowFar)
end;

define open generic IMoniker/ComposeWith (This, pmkRight,
		fOnlyIfNotGeneric)
		=> (status :: <HRESULT>, pmkComposite :: <Interface>);

define C-callable-wrapper of IMoniker/ComposeWith
  input parameter This :: <mapped-interface>;
  input parameter pmkRight :: <C-interface>;
  input parameter fOnlyIfNotGeneric :: <BOOL>;
  output parameter ppmkComposite :: <Interface*>;
  result status :: <C-HRESULT>;
  c-name: "DW_IMoniker_ComposeWith", c-modifiers: "__stdcall";
end;

define inline-only C-function IMoniker_ComposeWith
  input parameter This :: <C-interface>;
  input parameter pmkRight :: <Interface>;
  input parameter fOnlyIfNotGeneric :: <BOOL>;
  output parameter ppmkComposite :: <C-interface*>;
  result status :: <C-HRESULT>;
  c-name: "C_IMoniker_ComposeWith";
end;

define method IMoniker/ComposeWith(This :: <C-interface>,
		pmkRight :: <Interface>, fOnlyIfNotGeneric :: <boolean>)
		=> (status :: <HRESULT>, pmkComposite :: <Interface>)
  IMoniker_ComposeWith(This, pmkRight, fOnlyIfNotGeneric)
end;

define open generic IMoniker/Enum (This, fForward)
		=> (status :: <HRESULT>, penumMoniker :: <Interface>);

define C-callable-wrapper of IMoniker/Enum
  input parameter This :: <mapped-interface>;
  input parameter fForward :: <BOOL>;
  output parameter ppenumMoniker :: <Interface*>;
  result status :: <C-HRESULT>;
  c-name: "DW_IMoniker_Enum", c-modifiers: "__stdcall";
end;

define inline-only C-function IMoniker_Enum
  input parameter This :: <C-interface>;
  input parameter fForward :: <BOOL>;
  output parameter ppenumMoniker :: <C-interface*>;
  result status :: <C-HRESULT>;
  c-name: "C_IMoniker_Enum";
end;

define method IMoniker/Enum(This :: <C-interface>,
		fForward :: <boolean>)
		=> (status :: <HRESULT>, penumMoniker :: <Interface>)
  IMoniker_Enum(This, fForward)
end;

define open generic IMoniker/IsEqual (This, pmkOtherMoniker)
		=> (status :: <HRESULT>);

define C-callable-wrapper of IMoniker/IsEqual
  input parameter This :: <mapped-interface>;
  input parameter pmkOtherMoniker :: <C-interface>;
  result status :: <C-HRESULT>;
  c-name: "DW_IMoniker_IsEqual", c-modifiers: "__stdcall";
end;

define inline-only C-function IMoniker_IsEqual
  input parameter This :: <C-interface>;
  input parameter pmkOtherMoniker :: <Interface>;
  result status :: <C-HRESULT>;
  c-name: "C_IMoniker_IsEqual";
end;

define method IMoniker/IsEqual(This :: <C-interface>,
		pmkOtherMoniker :: <Interface>) => (status :: <HRESULT>)
  IMoniker_IsEqual(This, pmkOtherMoniker)
end;

define open generic IMoniker/Hash (This)
		=> (status :: <HRESULT>, dwHash);

define C-callable-wrapper of IMoniker/Hash
  input parameter This :: <mapped-interface>;
  output parameter pdwHash :: <LPDWORD>;
  result status :: <C-HRESULT>;
  c-name: "DW_IMoniker_Hash", c-modifiers: "__stdcall";
end;

define inline-only C-function IMoniker_Hash
  input parameter This :: <C-interface>;
  output parameter pdwHash :: <LPDWORD>;
  result status :: <C-HRESULT>;
  c-name: "C_IMoniker_Hash";
end;

define method IMoniker/Hash(This :: <C-interface>)
		=> (status :: <HRESULT>, dwHash)
  IMoniker_Hash(This)
end;

define open generic IMoniker/IsRunning (This, pbc, pmkToLeft,
		pmkNewlyRunning) => (status :: <HRESULT>);

define C-callable-wrapper of IMoniker/IsRunning
  input parameter This :: <mapped-interface>;
  input parameter pbc :: <C-interface>;
  input parameter pmkToLeft :: <C-interface>;
  input parameter pmkNewlyRunning :: <C-interface>;
  result status :: <C-HRESULT>;
  c-name: "DW_IMoniker_IsRunning", c-modifiers: "__stdcall";
end;

define inline-only C-function IMoniker_IsRunning
  input parameter This :: <C-interface>;
  input parameter pbc :: <Interface>;
  input parameter pmkToLeft :: <Interface>;
  input parameter pmkNewlyRunning :: <Interface>;
  result status :: <C-HRESULT>;
  c-name: "C_IMoniker_IsRunning";
end;

define method IMoniker/IsRunning(This :: <C-interface>,
		pbc :: <Interface>, pmkToLeft :: <Interface>,
		pmkNewlyRunning :: <Interface>) => (status :: <HRESULT>)
  IMoniker_IsRunning(This, pbc, pmkToLeft, pmkNewlyRunning)
end;

define open generic IMoniker/GetTimeOfLastChange (This, pbc,
		pmkToLeft, pFileTime) => (status :: <HRESULT>);

define C-callable-wrapper of IMoniker/GetTimeOfLastChange
  input parameter This :: <mapped-interface>;
  input parameter pbc :: <C-interface>;
  input parameter pmkToLeft :: <C-interface>;
  parameter pFileTime :: <LPFILETIME>;
  result status :: <C-HRESULT>;
  c-name: "DW_IMoniker_GetTimeOfLastChange",
		c-modifiers: "__stdcall";
end;

define inline-only C-function IMoniker_GetTimeOfLastChange
  input parameter This :: <C-interface>;
  input parameter pbc :: <Interface>;
  input parameter pmkToLeft :: <Interface>;
  parameter pFileTime :: <LPFILETIME>;
  result status :: <C-HRESULT>;
  c-name: "C_IMoniker_GetTimeOfLastChange";
end;

define method IMoniker/GetTimeOfLastChange(This :: <C-interface>,
		pbc :: <Interface>, pmkToLeft :: <Interface>,
		pFileTime :: <LPFILETIME>) => (status :: <HRESULT>)
  IMoniker_GetTimeOfLastChange(This, pbc, pmkToLeft, pFileTime)
end;

define open generic IMoniker/Inverse (This)
		=> (status :: <HRESULT>, pmk :: <Interface>);

define C-callable-wrapper of IMoniker/Inverse
  input parameter This :: <mapped-interface>;
  output parameter ppmk :: <Interface*>;
  result status :: <C-HRESULT>;
  c-name: "DW_IMoniker_Inverse", c-modifiers: "__stdcall";
end;

define inline-only C-function IMoniker_Inverse
  input parameter This :: <C-interface>;
  output parameter ppmk :: <C-interface*>;
  result status :: <C-HRESULT>;
  c-name: "C_IMoniker_Inverse";
end;

define method IMoniker/Inverse(This :: <C-interface>)
		=> (status :: <HRESULT>, pmk :: <Interface>)
  IMoniker_Inverse(This)
end;

define open generic IMoniker/CommonPrefixWith (This, pmkOther)
		=> (status :: <HRESULT>, pmkPrefix :: <Interface>);

define C-callable-wrapper of IMoniker/CommonPrefixWith
  input parameter This :: <mapped-interface>;
  input parameter pmkOther :: <C-interface>;
  output parameter ppmkPrefix :: <Interface*>;
  result status :: <C-HRESULT>;
  c-name: "DW_IMoniker_CommonPrefixWith",
		c-modifiers: "__stdcall";
end;

define inline-only C-function IMoniker_CommonPrefixWith
  input parameter This :: <C-interface>;
  input parameter pmkOther :: <Interface>;
  output parameter ppmkPrefix :: <C-interface*>;
  result status :: <C-HRESULT>;
  c-name: "C_IMoniker_CommonPrefixWith";
end;

define method IMoniker/CommonPrefixWith(This :: <C-interface>,
		pmkOther :: <Interface>)
		=> (status :: <HRESULT>, pmkPrefix :: <Interface>)
  IMoniker_CommonPrefixWith(This, pmkOther)
end;

define open generic IMoniker/RelativePathTo (This, pmkOther)
		=> (status :: <HRESULT>, pmkRelPath :: <Interface>);

define C-callable-wrapper of IMoniker/RelativePathTo
  input parameter This :: <mapped-interface>;
  input parameter pmkOther :: <C-interface>;
  output parameter ppmkRelPath :: <Interface*>;
  result status :: <C-HRESULT>;
  c-name: "DW_IMoniker_RelativePathTo",
		c-modifiers: "__stdcall";
end;

define inline-only C-function IMoniker_RelativePathTo
  input parameter This :: <C-interface>;
  input parameter pmkOther :: <Interface>;
  output parameter ppmkRelPath :: <C-interface*>;
  result status :: <C-HRESULT>;
  c-name: "C_IMoniker_RelativePathTo";
end;

define method IMoniker/RelativePathTo(This :: <C-interface>,
		pmkOther :: <Interface>)
		=> (status :: <HRESULT>, pmkRelPath :: <Interface>)
  IMoniker_RelativePathTo(This, pmkOther)
end;

define open generic IMoniker/GetDisplayName (This, pbc,
		pmkToLeft)
		=> (status :: <HRESULT>, pszDisplayName :: <LPOLESTR>);

define C-callable-wrapper of IMoniker/GetDisplayName
  input parameter This :: <mapped-interface>;
  input parameter pbc :: <C-interface>;
  input parameter pmkToLeft :: <C-interface>;
  output parameter ppszDisplayName :: <LPLPOLESTR>;
  result status :: <C-HRESULT>;
  c-name: "DW_IMoniker_GetDisplayName",
		c-modifiers: "__stdcall";
end;

define inline-only C-function IMoniker_GetDisplayName
  input parameter This :: <C-interface>;
  input parameter pbc :: <Interface>;
  input parameter pmkToLeft :: <Interface>;
  output parameter ppszDisplayName :: <LPLPOLESTR>;
  result status :: <C-HRESULT>;
  c-name: "C_IMoniker_GetDisplayName";
end;

define method IMoniker/GetDisplayName(This :: <C-interface>,
		pbc :: <Interface>, pmkToLeft :: <Interface>)
		=> (status :: <HRESULT>, pszDisplayName :: <LPOLESTR>)
  IMoniker_GetDisplayName(This, pbc, pmkToLeft)
end;

define open generic IMoniker/ParseDisplayName (This, pbc,
		pmkToLeft, pszDisplayName)
		=> (status :: <HRESULT>, chEaten, pmkOut :: <Interface>);

define C-callable-wrapper of IMoniker/ParseDisplayName
  input parameter This :: <mapped-interface>;
  input parameter pbc :: <C-interface>;
  input parameter pmkToLeft :: <C-interface>;
  input parameter pszDisplayName :: <LPOLESTR>;
  output parameter pchEaten :: <LPULONG>;
  output parameter ppmkOut :: <Interface*>;
  result status :: <C-HRESULT>;
  c-name: "DW_IMoniker_ParseDisplayName",
		c-modifiers: "__stdcall";
end;

define inline-only C-function IMoniker_ParseDisplayName
  input parameter This :: <C-interface>;
  input parameter pbc :: <Interface>;
  input parameter pmkToLeft :: <Interface>;
  input parameter pszDisplayName :: <LPOLESTR>;
  output parameter pchEaten :: <LPULONG>;
  output parameter ppmkOut :: <C-interface*>;
  result status :: <C-HRESULT>;
  c-name: "C_IMoniker_ParseDisplayName";
end;

define method IMoniker/ParseDisplayName(This :: <C-interface>,
		pbc :: <Interface>, pmkToLeft :: <Interface>,
		pszDisplayName :: <LPOLESTR>)
		=> (status :: <HRESULT>, chEaten, pmkOut :: <Interface>)
  IMoniker_ParseDisplayName(This, pbc, pmkToLeft, pszDisplayName)
end;

define open generic IMoniker/IsSystemMoniker (This)
		=> (status :: <HRESULT>, dwMksys);

define C-callable-wrapper of IMoniker/IsSystemMoniker
  input parameter This :: <mapped-interface>;
  output parameter pdwMksys :: <LPDWORD>;
  result status :: <C-HRESULT>;
  c-name: "DW_IMoniker_IsSystemMoniker",
		c-modifiers: "__stdcall";
end;

define inline-only C-function IMoniker_IsSystemMoniker
  input parameter This :: <C-interface>;
  output parameter pdwMksys :: <LPDWORD>;
  result status :: <C-HRESULT>;
  c-name: "C_IMoniker_IsSystemMoniker";
end;

define method IMoniker/IsSystemMoniker(This :: <C-interface>)
		=> (status :: <HRESULT>, dwMksys)
  IMoniker_IsSystemMoniker(This)
end;


	/*  ----  IROTData  ----  */


define open primary COM-interface <IROTData> ( <IUnknown> )
end <IROTData>;

define C-address IROTData_DW_vtbl :: <C-COM-vtbl>
		c-name: "IROTData_DW_vtbl"; end;
define C-address $IID-IROTData :: <REFIID>
		c-name: "IID_IROTData"; end;

define method initialize ( This :: <IROTData>, #rest ignore, #key );
  next-method();
  This.vtbl := IROTData_DW_vtbl;
  add-interface(This, $IID-IROTData);
end initialize;

define open generic IROTData/GetComparisonData (This, pbData,
		cbMax) => (status :: <HRESULT>, cbData);

define C-callable-wrapper of IROTData/GetComparisonData
  input parameter This :: <mapped-interface>;
   parameter pbData :: <LPBYTE>;
  input parameter cbMax :: <ULONG>;
  output parameter pcbData :: <LPULONG>;
  result status :: <C-HRESULT>;
  c-name: "DW_IROTData_GetComparisonData",
		c-modifiers: "__stdcall";
end;

define inline-only C-function IROTData_GetComparisonData
  input parameter This :: <C-interface>;
   parameter pbData :: <LPBYTE>;
  input parameter cbMax :: <ULONG>;
  output parameter pcbData :: <LPULONG>;
  result status :: <C-HRESULT>;
  c-name: "C_IROTData_GetComparisonData";
end;

define method IROTData/GetComparisonData(This :: <C-interface>,
		pbData :: <LPBYTE>, cbMax :: <ffi-integer>)
		=> (status :: <HRESULT>, cbData)
  IROTData_GetComparisonData(This, pbData, cbMax)
end;


	/*  ----  IEnumString  ----  */


define open primary COM-interface <IEnumString> ( <IUnknown> )
end <IEnumString>;

define C-address IEnumString_DW_vtbl :: <C-COM-vtbl>
		c-name: "IEnumString_DW_vtbl"; end;
define C-address $IID-IEnumString :: <REFIID>
		c-name: "IID_IEnumString"; end;

define method initialize ( This :: <IEnumString>, #rest ignore, #key );
  next-method();
  This.vtbl := IEnumString_DW_vtbl;
  add-interface(This, $IID-IEnumString);
end initialize;

define open generic IEnumString/Next (This, celt, rgelt)
		=> (status :: <HRESULT>, celtFetched);

define C-callable-wrapper of IEnumString/Next
  input parameter This :: <mapped-interface>;
  input parameter celt :: <ULONG>;
   parameter rgelt :: <LPLPOLESTR>;
  output parameter pceltFetched :: <LPULONG>;
  result status :: <C-HRESULT>;
  c-name: "DW_IEnumString_Next", c-modifiers: "__stdcall";
end;

define inline-only C-function IEnumString_Next
  input parameter This :: <C-interface>;
  input parameter celt :: <ULONG>;
   parameter rgelt :: <LPLPOLESTR>;
  output parameter pceltFetched :: <LPULONG>;
  result status :: <C-HRESULT>;
  c-name: "C_IEnumString_Next";
end;

define method IEnumString/Next(This :: <C-interface>,
		celt :: <ffi-integer>, rgelt :: <LPLPOLESTR>)
		=> (status :: <HRESULT>, celtFetched)
  IEnumString_Next(This, celt, rgelt)
end;

define open generic IEnumString/Skip (This, celt)
		=> (status :: <HRESULT>);

define C-callable-wrapper of IEnumString/Skip
  input parameter This :: <mapped-interface>;
  input parameter celt :: <ULONG>;
  result status :: <C-HRESULT>;
  c-name: "DW_IEnumString_Skip", c-modifiers: "__stdcall";
end;

define inline-only C-function IEnumString_Skip
  input parameter This :: <C-interface>;
  input parameter celt :: <ULONG>;
  result status :: <C-HRESULT>;
  c-name: "C_IEnumString_Skip";
end;

define method IEnumString/Skip(This :: <C-interface>,
		celt :: <ffi-integer>) => (status :: <HRESULT>)
  IEnumString_Skip(This, celt)
end;

define open generic IEnumString/Reset (This)
		=> (status :: <HRESULT>);

define C-callable-wrapper of IEnumString/Reset
  input parameter This :: <mapped-interface>;
  result status :: <C-HRESULT>;
  c-name: "DW_IEnumString_Reset", c-modifiers: "__stdcall";
end;

define inline-only C-function IEnumString_Reset
  input parameter This :: <C-interface>;
  result status :: <C-HRESULT>;
  c-name: "C_IEnumString_Reset";
end;

define method IEnumString/Reset(This :: <C-interface>)
		=> (status :: <HRESULT>)
  IEnumString_Reset(This)
end;

define open generic IEnumString/Clone (This)
		=> (status :: <HRESULT>, penum :: <Interface>);

define C-callable-wrapper of IEnumString/Clone
  input parameter This :: <mapped-interface>;
  output parameter ppenum :: <Interface*>;
  result status :: <C-HRESULT>;
  c-name: "DW_IEnumString_Clone", c-modifiers: "__stdcall";
end;

define inline-only C-function IEnumString_Clone
  input parameter This :: <C-interface>;
  output parameter ppenum :: <C-interface*>;
  result status :: <C-HRESULT>;
  c-name: "C_IEnumString_Clone";
end;

define method IEnumString/Clone(This :: <C-interface>)
		=> (status :: <HRESULT>, penum :: <Interface>)
  IEnumString_Clone(This)
end;


	/*  ----  ISequentialStream  ----  */


define open primary COM-interface <ISequentialStream> ( <IUnknown>, <storage-istream> )
end <ISequentialStream>;

define C-address ISequentialStream_DW_vtbl :: <C-COM-vtbl>
		c-name: "ISequentialStream_DW_vtbl"; end;
define C-address $IID-ISequentialStream :: <REFIID>
		c-name: "IID_ISequentialStream"; end;

define method initialize ( This :: <ISequentialStream>, #rest ignore, #key );
  next-method();
  This.vtbl := ISequentialStream_DW_vtbl;
  add-interface(This, $IID-ISequentialStream);
end initialize;

define open generic ISequentialStream/Read (This, pv, cb)
		=> (status :: <HRESULT>, cbRead);

define C-callable-wrapper of ISequentialStream/Read
  input parameter This :: <mapped-interface>;
   parameter pv :: <C-void*>;
  input parameter cb :: <ULONG>;
  output parameter pcbRead :: <LPULONG>;
  result status :: <C-HRESULT>;
  c-name: "DW_ISequentialStream_Read", c-modifiers: "__stdcall";
end;

define inline-only C-function ISequentialStream_Read
  input parameter This :: <C-interface>;
   parameter pv :: <C-void*>;
  input parameter cb :: <ULONG>;
  output parameter pcbRead :: <LPULONG>;
  result status :: <C-HRESULT>;
  c-name: "C_ISequentialStream_Read";
end;

define method ISequentialStream/Read(This :: <C-interface>,
		pv :: <C-pointer>, cb :: <ffi-integer>)
		=> (status :: <HRESULT>, cbRead)
  ISequentialStream_Read(This, pv, cb)
end;

define open generic ISequentialStream/Write (This, pv, cb)
		=> (status :: <HRESULT>, cbWritten);

define C-callable-wrapper of ISequentialStream/Write
  input parameter This :: <mapped-interface>;
  /* constant */ input parameter pv :: <C-void*>;
  input parameter cb :: <ULONG>;
  output parameter pcbWritten :: <LPULONG>;
  result status :: <C-HRESULT>;
  c-name: "DW_ISequentialStream_Write",
		c-modifiers: "__stdcall";
end;

define inline-only C-function ISequentialStream_Write
  input parameter This :: <C-interface>;
  /* constant */ input parameter pv :: <C-void*>;
  input parameter cb :: <ULONG>;
  output parameter pcbWritten :: <LPULONG>;
  result status :: <C-HRESULT>;
  c-name: "C_ISequentialStream_Write";
end;

define method ISequentialStream/Write(This :: <C-interface>,
		pv :: <C-pointer>, cb :: <ffi-integer>)
		=> (status :: <HRESULT>, cbWritten)
  ISequentialStream_Write(This, pv, cb)
end;


	/*  ----  IStream  ----  */


define open primary COM-interface <IStream> ( <ISequentialStream> )
end <IStream>;

define C-address IStream_DW_vtbl :: <C-COM-vtbl>
		c-name: "IStream_DW_vtbl"; end;
define C-address $IID-IStream :: <REFIID>
		c-name: "IID_IStream"; end;

define method initialize ( This :: <IStream>, #rest ignore, #key );
  next-method();
  This.vtbl := IStream_DW_vtbl;
  add-interface(This, $IID-IStream);
end initialize;

define open generic IStream/Seek (This, dlibMove, dwOrigin,
		plibNewPosition) => (status :: <HRESULT>);

define C-callable-wrapper of IStream/Seek
  input parameter This :: <mapped-interface>;
  input parameter dlibMove :: <LARGE-INTEGER>;
  input parameter dwOrigin :: <DWORD>;
  parameter plibNewPosition :: <PULARGE-INTEGER>;
  result status :: <C-HRESULT>;
  c-name: "DW_IStream_Seek", c-modifiers: "__stdcall";
end;

define inline-only C-function IStream_Seek
  input parameter This :: <C-interface>;
  input parameter dlibMove :: <LARGE-INTEGER>;
  input parameter dwOrigin :: <DWORD>;
  parameter plibNewPosition :: <PULARGE-INTEGER>;
  result status :: <C-HRESULT>;
  c-name: "C_IStream_Seek";
end;

define method IStream/Seek(This :: <C-interface>,
		dlibMove :: <PLARGE-INTEGER>, dwOrigin :: <ffi-integer>,
		plibNewPosition :: <PULARGE-INTEGER>) => (status :: <HRESULT>)
  IStream_Seek(This, dlibMove, dwOrigin, plibNewPosition)
end;

define open generic IStream/SetSize (This, libNewSize)
		=> (status :: <HRESULT>);

define C-callable-wrapper of IStream/SetSize
  input parameter This :: <mapped-interface>;
  input parameter libNewSize :: <ULARGE-INTEGER>;
  result status :: <C-HRESULT>;
  c-name: "DW_IStream_SetSize", c-modifiers: "__stdcall";
end;

define inline-only C-function IStream_SetSize
  input parameter This :: <C-interface>;
  input parameter libNewSize :: <ULARGE-INTEGER>;
  result status :: <C-HRESULT>;
  c-name: "C_IStream_SetSize";
end;

define method IStream/SetSize(This :: <C-interface>,
		libNewSize :: <PULARGE-INTEGER>) => (status :: <HRESULT>)
  IStream_SetSize(This, libNewSize)
end;

define open generic IStream/CopyTo (This, pstm, cb, pcbRead,
		pcbWritten) => (status :: <HRESULT>);

define C-callable-wrapper of IStream/CopyTo
  input parameter This :: <mapped-interface>;
  input parameter pstm :: <C-interface>;
  input parameter cb :: <ULARGE-INTEGER>;
  parameter pcbRead :: <PULARGE-INTEGER>;
  parameter pcbWritten :: <PULARGE-INTEGER>;
  result status :: <C-HRESULT>;
  c-name: "DW_IStream_CopyTo", c-modifiers: "__stdcall";
end;

define inline-only C-function IStream_CopyTo
  input parameter This :: <C-interface>;
  input parameter pstm :: <Interface>;
  input parameter cb :: <ULARGE-INTEGER>;
  parameter pcbRead :: <PULARGE-INTEGER>;
  parameter pcbWritten :: <PULARGE-INTEGER>;
  result status :: <C-HRESULT>;
  c-name: "C_IStream_CopyTo";
end;

define method IStream/CopyTo(This :: <C-interface>,
		pstm :: <Interface>, cb :: <PULARGE-INTEGER>,
		pcbRead :: <PULARGE-INTEGER>, pcbWritten :: <PULARGE-INTEGER>)
		=> (status :: <HRESULT>)
  IStream_CopyTo(This, pstm, cb, pcbRead, pcbWritten)
end;

define open generic IStream/Commit (This, grfCommitFlags)
		=> (status :: <HRESULT>);

define C-callable-wrapper of IStream/Commit
  input parameter This :: <mapped-interface>;
  input parameter grfCommitFlags :: <DWORD>;
  result status :: <C-HRESULT>;
  c-name: "DW_IStream_Commit", c-modifiers: "__stdcall";
end;

define inline-only C-function IStream_Commit
  input parameter This :: <C-interface>;
  input parameter grfCommitFlags :: <DWORD>;
  result status :: <C-HRESULT>;
  c-name: "C_IStream_Commit";
end;

define method IStream/Commit(This :: <C-interface>,
		grfCommitFlags :: <ffi-integer>) => (status :: <HRESULT>)
  IStream_Commit(This, grfCommitFlags)
end;

define open generic IStream/Revert (This)
		=> (status :: <HRESULT>);

define C-callable-wrapper of IStream/Revert
  input parameter This :: <mapped-interface>;
  result status :: <C-HRESULT>;
  c-name: "DW_IStream_Revert", c-modifiers: "__stdcall";
end;

define inline-only C-function IStream_Revert
  input parameter This :: <C-interface>;
  result status :: <C-HRESULT>;
  c-name: "C_IStream_Revert";
end;

define method IStream/Revert(This :: <C-interface>)
		=> (status :: <HRESULT>)
  IStream_Revert(This)
end;

define open generic IStream/LockRegion (This, libOffset, cb,
		dwLockType) => (status :: <HRESULT>);

define C-callable-wrapper of IStream/LockRegion
  input parameter This :: <mapped-interface>;
  input parameter libOffset :: <ULARGE-INTEGER>;
  input parameter cb :: <ULARGE-INTEGER>;
  input parameter dwLockType :: <DWORD>;
  result status :: <C-HRESULT>;
  c-name: "DW_IStream_LockRegion", c-modifiers: "__stdcall";
end;

define inline-only C-function IStream_LockRegion
  input parameter This :: <C-interface>;
  input parameter libOffset :: <ULARGE-INTEGER>;
  input parameter cb :: <ULARGE-INTEGER>;
  input parameter dwLockType :: <DWORD>;
  result status :: <C-HRESULT>;
  c-name: "C_IStream_LockRegion";
end;

define method IStream/LockRegion(This :: <C-interface>,
		libOffset :: <PULARGE-INTEGER>, cb :: <PULARGE-INTEGER>,
		dwLockType :: <ffi-integer>) => (status :: <HRESULT>)
  IStream_LockRegion(This, libOffset, cb, dwLockType)
end;

define open generic IStream/UnlockRegion (This, libOffset, cb,
		dwLockType) => (status :: <HRESULT>);

define C-callable-wrapper of IStream/UnlockRegion
  input parameter This :: <mapped-interface>;
  input parameter libOffset :: <ULARGE-INTEGER>;
  input parameter cb :: <ULARGE-INTEGER>;
  input parameter dwLockType :: <DWORD>;
  result status :: <C-HRESULT>;
  c-name: "DW_IStream_UnlockRegion", c-modifiers: "__stdcall";
end;

define inline-only C-function IStream_UnlockRegion
  input parameter This :: <C-interface>;
  input parameter libOffset :: <ULARGE-INTEGER>;
  input parameter cb :: <ULARGE-INTEGER>;
  input parameter dwLockType :: <DWORD>;
  result status :: <C-HRESULT>;
  c-name: "C_IStream_UnlockRegion";
end;

define method IStream/UnlockRegion(This :: <C-interface>,
		libOffset :: <PULARGE-INTEGER>, cb :: <PULARGE-INTEGER>,
		dwLockType :: <ffi-integer>) => (status :: <HRESULT>)
  IStream_UnlockRegion(This, libOffset, cb, dwLockType)
end;

define open generic IStream/Stat (This, pstatstg, grfStatFlag)
		=> (status :: <HRESULT>);

define C-callable-wrapper of IStream/Stat
  input parameter This :: <mapped-interface>;
  parameter pstatstg :: <LPSTATSTG>;
  input parameter grfStatFlag :: <DWORD>;
  result status :: <C-HRESULT>;
  c-name: "DW_IStream_Stat", c-modifiers: "__stdcall";
end;

define inline-only C-function IStream_Stat
  input parameter This :: <C-interface>;
  parameter pstatstg :: <LPSTATSTG>;
  input parameter grfStatFlag :: <DWORD>;
  result status :: <C-HRESULT>;
  c-name: "C_IStream_Stat";
end;

define method IStream/Stat(This :: <C-interface>,
		pstatstg :: <LPSTATSTG>, grfStatFlag :: <ffi-integer>)
		=> (status :: <HRESULT>)
  IStream_Stat(This, pstatstg, grfStatFlag)
end;

define open generic IStream/Clone (This)
		=> (status :: <HRESULT>, pstm :: <Interface>);

define C-callable-wrapper of IStream/Clone
  input parameter This :: <mapped-interface>;
  output parameter ppstm :: <Interface*>;
  result status :: <C-HRESULT>;
  c-name: "DW_IStream_Clone", c-modifiers: "__stdcall";
end;

define inline-only C-function IStream_Clone
  input parameter This :: <C-interface>;
  output parameter ppstm :: <C-interface*>;
  result status :: <C-HRESULT>;
  c-name: "C_IStream_Clone";
end;

define method IStream/Clone(This :: <C-interface>)
		=> (status :: <HRESULT>, pstm :: <Interface>)
  IStream_Clone(This)
end;


	/*  ----  IEnumSTATSTG  ----  */


define open primary COM-interface <IEnumSTATSTG> ( <IUnknown> )
end <IEnumSTATSTG>;

define C-address IEnumSTATSTG_DW_vtbl :: <C-COM-vtbl>
		c-name: "IEnumSTATSTG_DW_vtbl"; end;
define C-address $IID-IEnumSTATSTG :: <REFIID>
		c-name: "IID_IEnumSTATSTG"; end;

define method initialize ( This :: <IEnumSTATSTG>, #rest ignore, #key );
  next-method();
  This.vtbl := IEnumSTATSTG_DW_vtbl;
  add-interface(This, $IID-IEnumSTATSTG);
end initialize;

define open generic IEnumSTATSTG/Next (This, celt, rgelt)
		=> (status :: <HRESULT>, celtFetched);

define C-callable-wrapper of IEnumSTATSTG/Next
  input parameter This :: <mapped-interface>;
  input parameter celt :: <ULONG>;
   parameter rgelt :: <LPSTATSTG>;
  output parameter pceltFetched :: <LPULONG>;
  result status :: <C-HRESULT>;
  c-name: "DW_IEnumSTATSTG_Next", c-modifiers: "__stdcall";
end;

define inline-only C-function IEnumSTATSTG_Next
  input parameter This :: <C-interface>;
  input parameter celt :: <ULONG>;
   parameter rgelt :: <LPSTATSTG>;
  output parameter pceltFetched :: <LPULONG>;
  result status :: <C-HRESULT>;
  c-name: "C_IEnumSTATSTG_Next";
end;

define method IEnumSTATSTG/Next(This :: <C-interface>,
		celt :: <ffi-integer>, rgelt :: <LPSTATSTG>)
		=> (status :: <HRESULT>, celtFetched)
  IEnumSTATSTG_Next(This, celt, rgelt)
end;

define open generic IEnumSTATSTG/Skip (This, celt)
		=> (status :: <HRESULT>);

define C-callable-wrapper of IEnumSTATSTG/Skip
  input parameter This :: <mapped-interface>;
  input parameter celt :: <ULONG>;
  result status :: <C-HRESULT>;
  c-name: "DW_IEnumSTATSTG_Skip", c-modifiers: "__stdcall";
end;

define inline-only C-function IEnumSTATSTG_Skip
  input parameter This :: <C-interface>;
  input parameter celt :: <ULONG>;
  result status :: <C-HRESULT>;
  c-name: "C_IEnumSTATSTG_Skip";
end;

define method IEnumSTATSTG/Skip(This :: <C-interface>,
		celt :: <ffi-integer>) => (status :: <HRESULT>)
  IEnumSTATSTG_Skip(This, celt)
end;

define open generic IEnumSTATSTG/Reset (This)
		=> (status :: <HRESULT>);

define C-callable-wrapper of IEnumSTATSTG/Reset
  input parameter This :: <mapped-interface>;
  result status :: <C-HRESULT>;
  c-name: "DW_IEnumSTATSTG_Reset", c-modifiers: "__stdcall";
end;

define inline-only C-function IEnumSTATSTG_Reset
  input parameter This :: <C-interface>;
  result status :: <C-HRESULT>;
  c-name: "C_IEnumSTATSTG_Reset";
end;

define method IEnumSTATSTG/Reset(This :: <C-interface>)
		=> (status :: <HRESULT>)
  IEnumSTATSTG_Reset(This)
end;

define open generic IEnumSTATSTG/Clone (This)
		=> (status :: <HRESULT>, penum :: <Interface>);

define C-callable-wrapper of IEnumSTATSTG/Clone
  input parameter This :: <mapped-interface>;
  output parameter ppenum :: <Interface*>;
  result status :: <C-HRESULT>;
  c-name: "DW_IEnumSTATSTG_Clone", c-modifiers: "__stdcall";
end;

define inline-only C-function IEnumSTATSTG_Clone
  input parameter This :: <C-interface>;
  output parameter ppenum :: <C-interface*>;
  result status :: <C-HRESULT>;
  c-name: "C_IEnumSTATSTG_Clone";
end;

define method IEnumSTATSTG/Clone(This :: <C-interface>)
		=> (status :: <HRESULT>, penum :: <Interface>)
  IEnumSTATSTG_Clone(This)
end;


	/*  ----  IStorage  ----  */


define open primary COM-interface <IStorage> ( <IUnknown> )
end <IStorage>;

define C-address IStorage_DW_vtbl :: <C-COM-vtbl>
		c-name: "IStorage_DW_vtbl"; end;
define C-address $IID-IStorage :: <REFIID>
		c-name: "IID_IStorage"; end;

define method initialize ( This :: <IStorage>, #rest ignore, #key );
  next-method();
  This.vtbl := IStorage_DW_vtbl;
  add-interface(This, $IID-IStorage);
end initialize;

define open generic IStorage/CreateStream (This, pwcsName,
		grfMode, reserved1, reserved2)
		=> (status :: <HRESULT>, pstm :: <Interface>);

define C-callable-wrapper of IStorage/CreateStream
  input parameter This :: <mapped-interface>;
  /* constant */ input parameter pwcsName :: <C-unicode-string>;
  input parameter grfMode :: <DWORD>;
  input parameter reserved1 :: <DWORD>;
  input parameter reserved2 :: <DWORD>;
  output parameter ppstm :: <Interface*>;
  result status :: <C-HRESULT>;
  c-name: "DW_IStorage_CreateStream", c-modifiers: "__stdcall";
end;

define inline-only C-function IStorage_CreateStream
  input parameter This :: <C-interface>;
  /* constant */ input parameter pwcsName :: <C-unicode-string>;
  input parameter grfMode :: <DWORD>;
  input parameter reserved1 :: <DWORD>;
  input parameter reserved2 :: <DWORD>;
  output parameter ppstm :: <C-interface*>;
  result status :: <C-HRESULT>;
  c-name: "C_IStorage_CreateStream";
end;

define method IStorage/CreateStream(This :: <C-interface>,
		pwcsName :: <C-unicode-string>, grfMode :: <ffi-integer>,
		reserved1 :: <ffi-integer>, reserved2 :: <ffi-integer>)
		=> (status :: <HRESULT>, pstm :: <Interface>)
  IStorage_CreateStream(This, pwcsName, grfMode, reserved1,
		reserved2)
end;

define open generic IStorage/OpenStream (This, pwcsName,
		reserved1, grfMode, reserved2)
		=> (status :: <HRESULT>, pstm :: <Interface>);

define C-callable-wrapper of IStorage/OpenStream
  input parameter This :: <mapped-interface>;
  /* constant */ input parameter pwcsName :: <C-unicode-string>;
  input parameter reserved1 :: <C-void*>;
  input parameter grfMode :: <DWORD>;
  input parameter reserved2 :: <DWORD>;
  output parameter ppstm :: <Interface*>;
  result status :: <C-HRESULT>;
  c-name: "DW_IStorage_OpenStream", c-modifiers: "__stdcall";
end;

define inline-only C-function IStorage_OpenStream
  input parameter This :: <C-interface>;
  /* constant */ input parameter pwcsName :: <C-unicode-string>;
  input parameter reserved1 :: <C-void*>;
  input parameter grfMode :: <DWORD>;
  input parameter reserved2 :: <DWORD>;
  output parameter ppstm :: <C-interface*>;
  result status :: <C-HRESULT>;
  c-name: "C_IStorage_OpenStream";
end;

define method IStorage/OpenStream(This :: <C-interface>,
		pwcsName :: <C-unicode-string>, reserved1 :: <C-pointer>,
		grfMode :: <ffi-integer>, reserved2 :: <ffi-integer>)
		=> (status :: <HRESULT>, pstm :: <Interface>)
  IStorage_OpenStream(This, pwcsName, reserved1, grfMode,
		reserved2)
end;

define open generic IStorage/CreateStorage (This, pwcsName,
		grfMode, reserved1, reserved2)
		=> (status :: <HRESULT>, pstg :: <Interface>);

define C-callable-wrapper of IStorage/CreateStorage
  input parameter This :: <mapped-interface>;
  /* constant */ input parameter pwcsName :: <C-unicode-string>;
  input parameter grfMode :: <DWORD>;
  input parameter reserved1 :: <DWORD>;
  input parameter reserved2 :: <DWORD>;
  output parameter ppstg :: <Interface*>;
  result status :: <C-HRESULT>;
  c-name: "DW_IStorage_CreateStorage", c-modifiers: "__stdcall";
end;

define inline-only C-function IStorage_CreateStorage
  input parameter This :: <C-interface>;
  /* constant */ input parameter pwcsName :: <C-unicode-string>;
  input parameter grfMode :: <DWORD>;
  input parameter reserved1 :: <DWORD>;
  input parameter reserved2 :: <DWORD>;
  output parameter ppstg :: <C-interface*>;
  result status :: <C-HRESULT>;
  c-name: "C_IStorage_CreateStorage";
end;

define method IStorage/CreateStorage(This :: <C-interface>,
		pwcsName :: <C-unicode-string>, grfMode :: <ffi-integer>,
		reserved1 :: <ffi-integer>, reserved2 :: <ffi-integer>)
		=> (status :: <HRESULT>, pstg :: <Interface>)
  IStorage_CreateStorage(This, pwcsName, grfMode, reserved1,
		reserved2)
end;

define open generic IStorage/OpenStorage (This, pwcsName,
		pstgPriority, grfMode, snbExclude, reserved)
		=> (status :: <HRESULT>, pstg :: <Interface>);

define C-callable-wrapper of IStorage/OpenStorage
  input parameter This :: <mapped-interface>;
  /* constant */ input parameter pwcsName :: <C-unicode-string>;
  input parameter pstgPriority :: <C-interface>;
  input parameter grfMode :: <DWORD>;
  input parameter snbExclude :: <SNB>;
  input parameter reserved :: <DWORD>;
  output parameter ppstg :: <Interface*>;
  result status :: <C-HRESULT>;
  c-name: "DW_IStorage_OpenStorage", c-modifiers: "__stdcall";
end;

define inline-only C-function IStorage_OpenStorage
  input parameter This :: <C-interface>;
  /* constant */ input parameter pwcsName :: <C-unicode-string>;
  input parameter pstgPriority :: <Interface>;
  input parameter grfMode :: <DWORD>;
  input parameter snbExclude :: <SNB>;
  input parameter reserved :: <DWORD>;
  output parameter ppstg :: <C-interface*>;
  result status :: <C-HRESULT>;
  c-name: "C_IStorage_OpenStorage";
end;

define method IStorage/OpenStorage(This :: <C-interface>,
		pwcsName :: <C-unicode-string>, pstgPriority :: <Interface>,
		grfMode :: <ffi-integer>, snbExclude :: <SNB>,
		reserved :: <ffi-integer>)
		=> (status :: <HRESULT>, pstg :: <Interface>)
  IStorage_OpenStorage(This, pwcsName, pstgPriority, grfMode,
		snbExclude, reserved)
end;

define open generic IStorage/CopyTo (This, ciidExclude,
		rgiidExclude, snbExclude, pstgDest) => (status :: <HRESULT>);

define C-callable-wrapper of IStorage/CopyTo
  input parameter This :: <mapped-interface>;
  input parameter ciidExclude :: <DWORD>;
  /* constant */ input parameter rgiidExclude :: <REFIID>;
  input parameter snbExclude :: <SNB>;
  input parameter pstgDest :: <C-interface>;
  result status :: <C-HRESULT>;
  c-name: "DW_IStorage_CopyTo", c-modifiers: "__stdcall";
end;

define inline-only C-function IStorage_CopyTo
  input parameter This :: <C-interface>;
  input parameter ciidExclude :: <DWORD>;
  /* constant */ input parameter rgiidExclude :: <REFIID>;
  input parameter snbExclude :: <SNB>;
  input parameter pstgDest :: <Interface>;
  result status :: <C-HRESULT>;
  c-name: "C_IStorage_CopyTo";
end;

define method IStorage/CopyTo(This :: <C-interface>,
		ciidExclude :: <ffi-integer>, rgiidExclude :: <REFIID>,
		snbExclude :: <SNB>, pstgDest :: <Interface>)
		=> (status :: <HRESULT>)
  IStorage_CopyTo(This, ciidExclude, rgiidExclude, snbExclude,
		pstgDest)
end;

define open generic IStorage/MoveElementTo (This, pwcsName,
		pstgDest, pwcsNewName, grfFlags) => (status :: <HRESULT>);

define C-callable-wrapper of IStorage/MoveElementTo
  input parameter This :: <mapped-interface>;
  /* constant */ input parameter pwcsName :: <C-unicode-string>;
  input parameter pstgDest :: <C-interface>;
  /* constant */ input parameter pwcsNewName :: <C-unicode-string>;
  input parameter grfFlags :: <DWORD>;
  result status :: <C-HRESULT>;
  c-name: "DW_IStorage_MoveElementTo", c-modifiers: "__stdcall";
end;

define inline-only C-function IStorage_MoveElementTo
  input parameter This :: <C-interface>;
  /* constant */ input parameter pwcsName :: <C-unicode-string>;
  input parameter pstgDest :: <Interface>;
  /* constant */ input parameter pwcsNewName :: <C-unicode-string>;
  input parameter grfFlags :: <DWORD>;
  result status :: <C-HRESULT>;
  c-name: "C_IStorage_MoveElementTo";
end;

define method IStorage/MoveElementTo(This :: <C-interface>,
		pwcsName :: <C-unicode-string>, pstgDest :: <Interface>,
		pwcsNewName :: <C-unicode-string>, grfFlags :: <ffi-integer>)
		=> (status :: <HRESULT>)
  IStorage_MoveElementTo(This, pwcsName, pstgDest, pwcsNewName,
		grfFlags)
end;

define open generic IStorage/Commit (This, grfCommitFlags)
		=> (status :: <HRESULT>);

define C-callable-wrapper of IStorage/Commit
  input parameter This :: <mapped-interface>;
  input parameter grfCommitFlags :: <DWORD>;
  result status :: <C-HRESULT>;
  c-name: "DW_IStorage_Commit", c-modifiers: "__stdcall";
end;

define inline-only C-function IStorage_Commit
  input parameter This :: <C-interface>;
  input parameter grfCommitFlags :: <DWORD>;
  result status :: <C-HRESULT>;
  c-name: "C_IStorage_Commit";
end;

define method IStorage/Commit(This :: <C-interface>,
		grfCommitFlags :: <ffi-integer>) => (status :: <HRESULT>)
  IStorage_Commit(This, grfCommitFlags)
end;

define open generic IStorage/Revert (This)
		=> (status :: <HRESULT>);

define C-callable-wrapper of IStorage/Revert
  input parameter This :: <mapped-interface>;
  result status :: <C-HRESULT>;
  c-name: "DW_IStorage_Revert", c-modifiers: "__stdcall";
end;

define inline-only C-function IStorage_Revert
  input parameter This :: <C-interface>;
  result status :: <C-HRESULT>;
  c-name: "C_IStorage_Revert";
end;

define method IStorage/Revert(This :: <C-interface>)
		=> (status :: <HRESULT>)
  IStorage_Revert(This)
end;

define open generic IStorage/EnumElements (This, reserved1,
		reserved2, reserved3)
		=> (status :: <HRESULT>, penum :: <Interface>);

define C-callable-wrapper of IStorage/EnumElements
  input parameter This :: <mapped-interface>;
  input parameter reserved1 :: <DWORD>;
  input parameter reserved2 :: <C-void*>;
  input parameter reserved3 :: <DWORD>;
  output parameter ppenum :: <Interface*>;
  result status :: <C-HRESULT>;
  c-name: "DW_IStorage_EnumElements", c-modifiers: "__stdcall";
end;

define inline-only C-function IStorage_EnumElements
  input parameter This :: <C-interface>;
  input parameter reserved1 :: <DWORD>;
  input parameter reserved2 :: <C-void*>;
  input parameter reserved3 :: <DWORD>;
  output parameter ppenum :: <C-interface*>;
  result status :: <C-HRESULT>;
  c-name: "C_IStorage_EnumElements";
end;

define method IStorage/EnumElements(This :: <C-interface>,
		reserved1 :: <ffi-integer>, reserved2 :: <C-pointer>,
		reserved3 :: <ffi-integer>)
		=> (status :: <HRESULT>, penum :: <Interface>)
  IStorage_EnumElements(This, reserved1, reserved2, reserved3)
end;

define open generic IStorage/DestroyElement (This, pwcsName)
		=> (status :: <HRESULT>);

define C-callable-wrapper of IStorage/DestroyElement
  input parameter This :: <mapped-interface>;
  /* constant */ input parameter pwcsName :: <C-unicode-string>;
  result status :: <C-HRESULT>;
  c-name: "DW_IStorage_DestroyElement",
		c-modifiers: "__stdcall";
end;

define inline-only C-function IStorage_DestroyElement
  input parameter This :: <C-interface>;
  /* constant */ input parameter pwcsName :: <C-unicode-string>;
  result status :: <C-HRESULT>;
  c-name: "C_IStorage_DestroyElement";
end;

define method IStorage/DestroyElement(This :: <C-interface>,
		pwcsName :: <C-unicode-string>) => (status :: <HRESULT>)
  IStorage_DestroyElement(This, pwcsName)
end;

define open generic IStorage/RenameElement (This, pwcsOldName,
		pwcsNewName) => (status :: <HRESULT>);

define C-callable-wrapper of IStorage/RenameElement
  input parameter This :: <mapped-interface>;
  /* constant */ input parameter pwcsOldName :: <C-unicode-string>;
  /* constant */ input parameter pwcsNewName :: <C-unicode-string>;
  result status :: <C-HRESULT>;
  c-name: "DW_IStorage_RenameElement", c-modifiers: "__stdcall";
end;

define inline-only C-function IStorage_RenameElement
  input parameter This :: <C-interface>;
  /* constant */ input parameter pwcsOldName :: <C-unicode-string>;
  /* constant */ input parameter pwcsNewName :: <C-unicode-string>;
  result status :: <C-HRESULT>;
  c-name: "C_IStorage_RenameElement";
end;

define method IStorage/RenameElement(This :: <C-interface>,
		pwcsOldName :: <C-unicode-string>,
		pwcsNewName :: <C-unicode-string>) => (status :: <HRESULT>)
  IStorage_RenameElement(This, pwcsOldName, pwcsNewName)
end;

define open generic IStorage/SetElementTimes (This, pwcsName,
		pctime, patime, pmtime) => (status :: <HRESULT>);

define C-callable-wrapper of IStorage/SetElementTimes
  input parameter This :: <mapped-interface>;
  /* constant */ input parameter pwcsName :: <C-unicode-string>;
  /* constant */ input parameter pctime :: <LPFILETIME>;
  /* constant */ input parameter patime :: <LPFILETIME>;
  /* constant */ input parameter pmtime :: <LPFILETIME>;
  result status :: <C-HRESULT>;
  c-name: "DW_IStorage_SetElementTimes",
		c-modifiers: "__stdcall";
end;

define inline-only C-function IStorage_SetElementTimes
  input parameter This :: <C-interface>;
  /* constant */ input parameter pwcsName :: <C-unicode-string>;
  /* constant */ input parameter pctime :: <LPFILETIME>;
  /* constant */ input parameter patime :: <LPFILETIME>;
  /* constant */ input parameter pmtime :: <LPFILETIME>;
  result status :: <C-HRESULT>;
  c-name: "C_IStorage_SetElementTimes";
end;

define method IStorage/SetElementTimes(This :: <C-interface>,
		pwcsName :: <C-unicode-string>, pctime :: <LPFILETIME>,
		patime :: <LPFILETIME>, pmtime :: <LPFILETIME>)
		=> (status :: <HRESULT>)
  IStorage_SetElementTimes(This, pwcsName, pctime, patime,
		pmtime)
end;

define open generic IStorage/SetClass (This, clsid)
		=> (status :: <HRESULT>);

define C-callable-wrapper of IStorage/SetClass
  input parameter This :: <mapped-interface>;
  input parameter clsid :: <REFCLSID>;
  result status :: <C-HRESULT>;
  c-name: "DW_IStorage_SetClass", c-modifiers: "__stdcall";
end;

define inline-only C-function IStorage_SetClass
  input parameter This :: <C-interface>;
  input parameter clsid :: <REFCLSID>;
  result status :: <C-HRESULT>;
  c-name: "C_IStorage_SetClass";
end;

define method IStorage/SetClass(This :: <C-interface>,
		clsid :: <REFCLSID>) => (status :: <HRESULT>)
  IStorage_SetClass(This, clsid)
end;

define open generic IStorage/SetStateBits (This, grfStateBits,
		grfMask) => (status :: <HRESULT>);

define C-callable-wrapper of IStorage/SetStateBits
  input parameter This :: <mapped-interface>;
  input parameter grfStateBits :: <DWORD>;
  input parameter grfMask :: <DWORD>;
  result status :: <C-HRESULT>;
  c-name: "DW_IStorage_SetStateBits", c-modifiers: "__stdcall";
end;

define inline-only C-function IStorage_SetStateBits
  input parameter This :: <C-interface>;
  input parameter grfStateBits :: <DWORD>;
  input parameter grfMask :: <DWORD>;
  result status :: <C-HRESULT>;
  c-name: "C_IStorage_SetStateBits";
end;

define method IStorage/SetStateBits(This :: <C-interface>,
		grfStateBits :: <ffi-integer>, grfMask :: <ffi-integer>)
		=> (status :: <HRESULT>)
  IStorage_SetStateBits(This, grfStateBits, grfMask)
end;

define open generic IStorage/Stat (This, pstatstg, grfStatFlag)
		=> (status :: <HRESULT>);

define C-callable-wrapper of IStorage/Stat
  input parameter This :: <mapped-interface>;
  parameter pstatstg :: <LPSTATSTG>;
  input parameter grfStatFlag :: <DWORD>;
  result status :: <C-HRESULT>;
  c-name: "DW_IStorage_Stat", c-modifiers: "__stdcall";
end;

define inline-only C-function IStorage_Stat
  input parameter This :: <C-interface>;
  parameter pstatstg :: <LPSTATSTG>;
  input parameter grfStatFlag :: <DWORD>;
  result status :: <C-HRESULT>;
  c-name: "C_IStorage_Stat";
end;

define method IStorage/Stat(This :: <C-interface>,
		pstatstg :: <LPSTATSTG>, grfStatFlag :: <ffi-integer>)
		=> (status :: <HRESULT>)
  IStorage_Stat(This, pstatstg, grfStatFlag)
end;


	/*  ----  IPersistFile  ----  */


define open primary COM-interface <IPersistFile> ( <IPersist> )
end <IPersistFile>;

define C-address IPersistFile_DW_vtbl :: <C-COM-vtbl>
		c-name: "IPersistFile_DW_vtbl"; end;
define C-address $IID-IPersistFile :: <REFIID>
		c-name: "IID_IPersistFile"; end;

define method initialize ( This :: <IPersistFile>, #rest ignore, #key );
  next-method();
  This.vtbl := IPersistFile_DW_vtbl;
  add-interface(This, $IID-IPersistFile);
end initialize;

define open generic IPersistFile/IsDirty (This)
		=> (status :: <HRESULT>);

define C-callable-wrapper of IPersistFile/IsDirty
  input parameter This :: <mapped-interface>;
  result status :: <C-HRESULT>;
  c-name: "DW_IPersistFile_IsDirty", c-modifiers: "__stdcall";
end;

define inline-only C-function IPersistFile_IsDirty
  input parameter This :: <C-interface>;
  result status :: <C-HRESULT>;
  c-name: "C_IPersistFile_IsDirty";
end;

define method IPersistFile/IsDirty(This :: <C-interface>)
		=> (status :: <HRESULT>)
  IPersistFile_IsDirty(This)
end;

define open generic IPersistFile/Load (This, pszFileName, dwMode)
		=> (status :: <HRESULT>);

define C-callable-wrapper of IPersistFile/Load
  input parameter This :: <mapped-interface>;
  input parameter pszFileName :: <LPCOLESTR>;
  input parameter dwMode :: <DWORD>;
  result status :: <C-HRESULT>;
  c-name: "DW_IPersistFile_Load", c-modifiers: "__stdcall";
end;

define inline-only C-function IPersistFile_Load
  input parameter This :: <C-interface>;
  input parameter pszFileName :: <LPCOLESTR>;
  input parameter dwMode :: <DWORD>;
  result status :: <C-HRESULT>;
  c-name: "C_IPersistFile_Load";
end;

define method IPersistFile/Load(This :: <C-interface>,
		pszFileName :: <LPCOLESTR>, dwMode :: <ffi-integer>)
		=> (status :: <HRESULT>)
  IPersistFile_Load(This, pszFileName, dwMode)
end;

define open generic IPersistFile/Save (This, pszFileName,
		fRemember) => (status :: <HRESULT>);

define C-callable-wrapper of IPersistFile/Save
  input parameter This :: <mapped-interface>;
  input parameter pszFileName :: <LPCOLESTR>;
  input parameter fRemember :: <BOOL>;
  result status :: <C-HRESULT>;
  c-name: "DW_IPersistFile_Save", c-modifiers: "__stdcall";
end;

define inline-only C-function IPersistFile_Save
  input parameter This :: <C-interface>;
  input parameter pszFileName :: <LPCOLESTR>;
  input parameter fRemember :: <BOOL>;
  result status :: <C-HRESULT>;
  c-name: "C_IPersistFile_Save";
end;

define method IPersistFile/Save(This :: <C-interface>,
		pszFileName :: <LPCOLESTR>, fRemember :: <boolean>)
		=> (status :: <HRESULT>)
  IPersistFile_Save(This, pszFileName, fRemember)
end;

define open generic IPersistFile/SaveCompleted (This,
		pszFileName) => (status :: <HRESULT>);

define C-callable-wrapper of IPersistFile/SaveCompleted
  input parameter This :: <mapped-interface>;
  input parameter pszFileName :: <LPCOLESTR>;
  result status :: <C-HRESULT>;
  c-name: "DW_IPersistFile_SaveCompleted",
		c-modifiers: "__stdcall";
end;

define inline-only C-function IPersistFile_SaveCompleted
  input parameter This :: <C-interface>;
  input parameter pszFileName :: <LPCOLESTR>;
  result status :: <C-HRESULT>;
  c-name: "C_IPersistFile_SaveCompleted";
end;

define method IPersistFile/SaveCompleted(This :: <C-interface>,
		pszFileName :: <LPCOLESTR>) => (status :: <HRESULT>)
  IPersistFile_SaveCompleted(This, pszFileName)
end;

define open generic IPersistFile/GetCurFile (This)
		=> (status :: <HRESULT>, pszFileName :: <LPOLESTR>);

define C-callable-wrapper of IPersistFile/GetCurFile
  input parameter This :: <mapped-interface>;
  output parameter ppszFileName :: <LPLPOLESTR>;
  result status :: <C-HRESULT>;
  c-name: "DW_IPersistFile_GetCurFile",
		c-modifiers: "__stdcall";
end;

define inline-only C-function IPersistFile_GetCurFile
  input parameter This :: <C-interface>;
  output parameter ppszFileName :: <LPLPOLESTR>;
  result status :: <C-HRESULT>;
  c-name: "C_IPersistFile_GetCurFile";
end;

define method IPersistFile/GetCurFile(This :: <C-interface>)
		=> (status :: <HRESULT>, pszFileName :: <LPOLESTR>)
  IPersistFile_GetCurFile(This)
end;


	/*  ----  IPersistStorage  ----  */


define open primary COM-interface <IPersistStorage> ( <IPersist> )
end <IPersistStorage>;

define C-address IPersistStorage_DW_vtbl :: <C-COM-vtbl>
		c-name: "IPersistStorage_DW_vtbl"; end;
define C-address $IID-IPersistStorage :: <REFIID>
		c-name: "IID_IPersistStorage"; end;

define method initialize ( This :: <IPersistStorage>, #rest ignore, #key );
  next-method();
  This.vtbl := IPersistStorage_DW_vtbl;
  add-interface(This, $IID-IPersistStorage);
end initialize;

define open generic IPersistStorage/IsDirty (This)
		=> (status :: <HRESULT>);

define C-callable-wrapper of IPersistStorage/IsDirty
  input parameter This :: <mapped-interface>;
  result status :: <C-HRESULT>;
  c-name: "DW_IPersistStorage_IsDirty",
		c-modifiers: "__stdcall";
end;

define inline-only C-function IPersistStorage_IsDirty
  input parameter This :: <C-interface>;
  result status :: <C-HRESULT>;
  c-name: "C_IPersistStorage_IsDirty";
end;

define method IPersistStorage/IsDirty(This :: <C-interface>)
		=> (status :: <HRESULT>)
  IPersistStorage_IsDirty(This)
end;

define open generic IPersistStorage/InitNew (This, pStg)
		=> (status :: <HRESULT>);

define C-callable-wrapper of IPersistStorage/InitNew
  input parameter This :: <mapped-interface>;
  input parameter pStg :: <C-interface>;
  result status :: <C-HRESULT>;
  c-name: "DW_IPersistStorage_InitNew",
		c-modifiers: "__stdcall";
end;

define inline-only C-function IPersistStorage_InitNew
  input parameter This :: <C-interface>;
  input parameter pStg :: <Interface>;
  result status :: <C-HRESULT>;
  c-name: "C_IPersistStorage_InitNew";
end;

define method IPersistStorage/InitNew(This :: <C-interface>,
		pStg :: <Interface>) => (status :: <HRESULT>)
  IPersistStorage_InitNew(This, pStg)
end;

define open generic IPersistStorage/Load (This, pStg)
		=> (status :: <HRESULT>);

define C-callable-wrapper of IPersistStorage/Load
  input parameter This :: <mapped-interface>;
  input parameter pStg :: <C-interface>;
  result status :: <C-HRESULT>;
  c-name: "DW_IPersistStorage_Load", c-modifiers: "__stdcall";
end;

define inline-only C-function IPersistStorage_Load
  input parameter This :: <C-interface>;
  input parameter pStg :: <Interface>;
  result status :: <C-HRESULT>;
  c-name: "C_IPersistStorage_Load";
end;

define method IPersistStorage/Load(This :: <C-interface>,
		pStg :: <Interface>) => (status :: <HRESULT>)
  IPersistStorage_Load(This, pStg)
end;

define open generic IPersistStorage/Save (This, pStgSave,
		fSameAsLoad) => (status :: <HRESULT>);

define C-callable-wrapper of IPersistStorage/Save
  input parameter This :: <mapped-interface>;
  input parameter pStgSave :: <C-interface>;
  input parameter fSameAsLoad :: <BOOL>;
  result status :: <C-HRESULT>;
  c-name: "DW_IPersistStorage_Save", c-modifiers: "__stdcall";
end;

define inline-only C-function IPersistStorage_Save
  input parameter This :: <C-interface>;
  input parameter pStgSave :: <Interface>;
  input parameter fSameAsLoad :: <BOOL>;
  result status :: <C-HRESULT>;
  c-name: "C_IPersistStorage_Save";
end;

define method IPersistStorage/Save(This :: <C-interface>,
		pStgSave :: <Interface>, fSameAsLoad :: <boolean>)
		=> (status :: <HRESULT>)
  IPersistStorage_Save(This, pStgSave, fSameAsLoad)
end;

define open generic IPersistStorage/SaveCompleted (This, pStgNew)
		=> (status :: <HRESULT>);

define C-callable-wrapper of IPersistStorage/SaveCompleted
  input parameter This :: <mapped-interface>;
  input parameter pStgNew :: <C-interface>;
  result status :: <C-HRESULT>;
  c-name: "DW_IPersistStorage_SaveCompleted",
		c-modifiers: "__stdcall";
end;

define inline-only C-function IPersistStorage_SaveCompleted
  input parameter This :: <C-interface>;
  input parameter pStgNew :: <Interface>;
  result status :: <C-HRESULT>;
  c-name: "C_IPersistStorage_SaveCompleted";
end;

define method IPersistStorage/SaveCompleted(This :: <C-interface>,
		pStgNew :: <Interface>) => (status :: <HRESULT>)
  IPersistStorage_SaveCompleted(This, pStgNew)
end;

define open generic IPersistStorage/HandsOffStorage (This)
		=> (status :: <HRESULT>);

define C-callable-wrapper of IPersistStorage/HandsOffStorage
  input parameter This :: <mapped-interface>;
  result status :: <C-HRESULT>;
  c-name: "DW_IPersistStorage_HandsOffStorage",
		c-modifiers: "__stdcall";
end;

define inline-only C-function IPersistStorage_HandsOffStorage
  input parameter This :: <C-interface>;
  result status :: <C-HRESULT>;
  c-name: "C_IPersistStorage_HandsOffStorage";
end;

define method IPersistStorage/HandsOffStorage(This :: <C-interface>)
		=> (status :: <HRESULT>)
  IPersistStorage_HandsOffStorage(This)
end;


	/*  ----  ILockBytes  ----  */


define open primary COM-interface <ILockBytes> ( <IUnknown> )
end <ILockBytes>;

define C-address ILockBytes_DW_vtbl :: <C-COM-vtbl>
		c-name: "ILockBytes_DW_vtbl"; end;
define C-address $IID-ILockBytes :: <REFIID>
		c-name: "IID_ILockBytes"; end;

define method initialize ( This :: <ILockBytes>, #rest ignore, #key );
  next-method();
  This.vtbl := ILockBytes_DW_vtbl;
  add-interface(This, $IID-ILockBytes);
end initialize;

define open generic ILockBytes/ReadAt (This, ulOffset, pv, cb)
		=> (status :: <HRESULT>, cbRead);

define C-callable-wrapper of ILockBytes/ReadAt
  input parameter This :: <mapped-interface>;
  input parameter ulOffset :: <ULARGE-INTEGER>;
   parameter pv :: <C-void*>;
  input parameter cb :: <ULONG>;
  output parameter pcbRead :: <LPULONG>;
  result status :: <C-HRESULT>;
  c-name: "DW_ILockBytes_ReadAt", c-modifiers: "__stdcall";
end;

define inline-only C-function ILockBytes_ReadAt
  input parameter This :: <C-interface>;
  input parameter ulOffset :: <ULARGE-INTEGER>;
   parameter pv :: <C-void*>;
  input parameter cb :: <ULONG>;
  output parameter pcbRead :: <LPULONG>;
  result status :: <C-HRESULT>;
  c-name: "C_ILockBytes_ReadAt";
end;

define method ILockBytes/ReadAt(This :: <C-interface>,
		ulOffset :: <PULARGE-INTEGER>, pv :: <C-pointer>,
		cb :: <ffi-integer>) => (status :: <HRESULT>, cbRead)
  ILockBytes_ReadAt(This, ulOffset, pv, cb)
end;

define open generic ILockBytes/WriteAt (This, ulOffset, pv, cb)
		=> (status :: <HRESULT>, cbWritten);

define C-callable-wrapper of ILockBytes/WriteAt
  input parameter This :: <mapped-interface>;
  input parameter ulOffset :: <ULARGE-INTEGER>;
  /* constant */ input parameter pv :: <C-void*>;
  input parameter cb :: <ULONG>;
  output parameter pcbWritten :: <LPULONG>;
  result status :: <C-HRESULT>;
  c-name: "DW_ILockBytes_WriteAt", c-modifiers: "__stdcall";
end;

define inline-only C-function ILockBytes_WriteAt
  input parameter This :: <C-interface>;
  input parameter ulOffset :: <ULARGE-INTEGER>;
  /* constant */ input parameter pv :: <C-void*>;
  input parameter cb :: <ULONG>;
  output parameter pcbWritten :: <LPULONG>;
  result status :: <C-HRESULT>;
  c-name: "C_ILockBytes_WriteAt";
end;

define method ILockBytes/WriteAt(This :: <C-interface>,
		ulOffset :: <PULARGE-INTEGER>, pv :: <C-pointer>,
		cb :: <ffi-integer>) => (status :: <HRESULT>, cbWritten)
  ILockBytes_WriteAt(This, ulOffset, pv, cb)
end;

define open generic ILockBytes/Flush (This)
		=> (status :: <HRESULT>);

define C-callable-wrapper of ILockBytes/Flush
  input parameter This :: <mapped-interface>;
  result status :: <C-HRESULT>;
  c-name: "DW_ILockBytes_Flush", c-modifiers: "__stdcall";
end;

define inline-only C-function ILockBytes_Flush
  input parameter This :: <C-interface>;
  result status :: <C-HRESULT>;
  c-name: "C_ILockBytes_Flush";
end;

define method ILockBytes/Flush(This :: <C-interface>)
		=> (status :: <HRESULT>)
  ILockBytes_Flush(This)
end;

define open generic ILockBytes/SetSize (This, cb)
		=> (status :: <HRESULT>);

define C-callable-wrapper of ILockBytes/SetSize
  input parameter This :: <mapped-interface>;
  input parameter cb :: <ULARGE-INTEGER>;
  result status :: <C-HRESULT>;
  c-name: "DW_ILockBytes_SetSize", c-modifiers: "__stdcall";
end;

define inline-only C-function ILockBytes_SetSize
  input parameter This :: <C-interface>;
  input parameter cb :: <ULARGE-INTEGER>;
  result status :: <C-HRESULT>;
  c-name: "C_ILockBytes_SetSize";
end;

define method ILockBytes/SetSize(This :: <C-interface>,
		cb :: <PULARGE-INTEGER>) => (status :: <HRESULT>)
  ILockBytes_SetSize(This, cb)
end;

define open generic ILockBytes/LockRegion (This, libOffset, cb,
		dwLockType) => (status :: <HRESULT>);

define C-callable-wrapper of ILockBytes/LockRegion
  input parameter This :: <mapped-interface>;
  input parameter libOffset :: <ULARGE-INTEGER>;
  input parameter cb :: <ULARGE-INTEGER>;
  input parameter dwLockType :: <DWORD>;
  result status :: <C-HRESULT>;
  c-name: "DW_ILockBytes_LockRegion", c-modifiers: "__stdcall";
end;

define inline-only C-function ILockBytes_LockRegion
  input parameter This :: <C-interface>;
  input parameter libOffset :: <ULARGE-INTEGER>;
  input parameter cb :: <ULARGE-INTEGER>;
  input parameter dwLockType :: <DWORD>;
  result status :: <C-HRESULT>;
  c-name: "C_ILockBytes_LockRegion";
end;

define method ILockBytes/LockRegion(This :: <C-interface>,
		libOffset :: <PULARGE-INTEGER>, cb :: <PULARGE-INTEGER>,
		dwLockType :: <ffi-integer>) => (status :: <HRESULT>)
  ILockBytes_LockRegion(This, libOffset, cb, dwLockType)
end;

define open generic ILockBytes/UnlockRegion (This, libOffset, cb,
		dwLockType) => (status :: <HRESULT>);

define C-callable-wrapper of ILockBytes/UnlockRegion
  input parameter This :: <mapped-interface>;
  input parameter libOffset :: <ULARGE-INTEGER>;
  input parameter cb :: <ULARGE-INTEGER>;
  input parameter dwLockType :: <DWORD>;
  result status :: <C-HRESULT>;
  c-name: "DW_ILockBytes_UnlockRegion",
		c-modifiers: "__stdcall";
end;

define inline-only C-function ILockBytes_UnlockRegion
  input parameter This :: <C-interface>;
  input parameter libOffset :: <ULARGE-INTEGER>;
  input parameter cb :: <ULARGE-INTEGER>;
  input parameter dwLockType :: <DWORD>;
  result status :: <C-HRESULT>;
  c-name: "C_ILockBytes_UnlockRegion";
end;

define method ILockBytes/UnlockRegion(This :: <C-interface>,
		libOffset :: <PULARGE-INTEGER>, cb :: <PULARGE-INTEGER>,
		dwLockType :: <ffi-integer>) => (status :: <HRESULT>)
  ILockBytes_UnlockRegion(This, libOffset, cb, dwLockType)
end;

define open generic ILockBytes/Stat (This, pstatstg, grfStatFlag)
		=> (status :: <HRESULT>);

define C-callable-wrapper of ILockBytes/Stat
  input parameter This :: <mapped-interface>;
  parameter pstatstg :: <LPSTATSTG>;
  input parameter grfStatFlag :: <DWORD>;
  result status :: <C-HRESULT>;
  c-name: "DW_ILockBytes_Stat", c-modifiers: "__stdcall";
end;

define inline-only C-function ILockBytes_Stat
  input parameter This :: <C-interface>;
  parameter pstatstg :: <LPSTATSTG>;
  input parameter grfStatFlag :: <DWORD>;
  result status :: <C-HRESULT>;
  c-name: "C_ILockBytes_Stat";
end;

define method ILockBytes/Stat(This :: <C-interface>,
		pstatstg :: <LPSTATSTG>, grfStatFlag :: <ffi-integer>)
		=> (status :: <HRESULT>)
  ILockBytes_Stat(This, pstatstg, grfStatFlag)
end;


	/*  ----  IEnumFORMATETC  ----  */


define open primary COM-interface <IEnumFORMATETC> ( <IUnknown> )
end <IEnumFORMATETC>;

define C-address IEnumFORMATETC_DW_vtbl :: <C-COM-vtbl>
		c-name: "IEnumFORMATETC_DW_vtbl"; end;
define C-address $IID-IEnumFORMATETC :: <REFIID>
		c-name: "IID_IEnumFORMATETC"; end;

define method initialize ( This :: <IEnumFORMATETC>, #rest ignore, #key );
  next-method();
  This.vtbl := IEnumFORMATETC_DW_vtbl;
  add-interface(This, $IID-IEnumFORMATETC);
end initialize;

define open generic IEnumFORMATETC/Next (This, celt, rgelt)
		=> (status :: <HRESULT>, celtFetched);

define C-callable-wrapper of IEnumFORMATETC/Next
  input parameter This :: <mapped-interface>;
  input parameter celt :: <ULONG>;
   parameter rgelt :: <LPFORMATETC>;
  output parameter pceltFetched :: <LPULONG>;
  result status :: <C-HRESULT>;
  c-name: "DW_IEnumFORMATETC_Next", c-modifiers: "__stdcall";
end;

define inline-only C-function IEnumFORMATETC_Next
  input parameter This :: <C-interface>;
  input parameter celt :: <ULONG>;
   parameter rgelt :: <LPFORMATETC>;
  output parameter pceltFetched :: <LPULONG>;
  result status :: <C-HRESULT>;
  c-name: "C_IEnumFORMATETC_Next";
end;

define method IEnumFORMATETC/Next(This :: <C-interface>,
		celt :: <ffi-integer>, rgelt :: <LPFORMATETC>)
		=> (status :: <HRESULT>, celtFetched)
  IEnumFORMATETC_Next(This, celt, rgelt)
end;

define open generic IEnumFORMATETC/Skip (This, celt)
		=> (status :: <HRESULT>);

define C-callable-wrapper of IEnumFORMATETC/Skip
  input parameter This :: <mapped-interface>;
  input parameter celt :: <ULONG>;
  result status :: <C-HRESULT>;
  c-name: "DW_IEnumFORMATETC_Skip", c-modifiers: "__stdcall";
end;

define inline-only C-function IEnumFORMATETC_Skip
  input parameter This :: <C-interface>;
  input parameter celt :: <ULONG>;
  result status :: <C-HRESULT>;
  c-name: "C_IEnumFORMATETC_Skip";
end;

define method IEnumFORMATETC/Skip(This :: <C-interface>,
		celt :: <ffi-integer>) => (status :: <HRESULT>)
  IEnumFORMATETC_Skip(This, celt)
end;

define open generic IEnumFORMATETC/Reset (This)
		=> (status :: <HRESULT>);

define C-callable-wrapper of IEnumFORMATETC/Reset
  input parameter This :: <mapped-interface>;
  result status :: <C-HRESULT>;
  c-name: "DW_IEnumFORMATETC_Reset", c-modifiers: "__stdcall";
end;

define inline-only C-function IEnumFORMATETC_Reset
  input parameter This :: <C-interface>;
  result status :: <C-HRESULT>;
  c-name: "C_IEnumFORMATETC_Reset";
end;

define method IEnumFORMATETC/Reset(This :: <C-interface>)
		=> (status :: <HRESULT>)
  IEnumFORMATETC_Reset(This)
end;

define open generic IEnumFORMATETC/Clone (This)
		=> (status :: <HRESULT>, penum :: <Interface>);

define C-callable-wrapper of IEnumFORMATETC/Clone
  input parameter This :: <mapped-interface>;
  output parameter ppenum :: <Interface*>;
  result status :: <C-HRESULT>;
  c-name: "DW_IEnumFORMATETC_Clone", c-modifiers: "__stdcall";
end;

define inline-only C-function IEnumFORMATETC_Clone
  input parameter This :: <C-interface>;
  output parameter ppenum :: <C-interface*>;
  result status :: <C-HRESULT>;
  c-name: "C_IEnumFORMATETC_Clone";
end;

define method IEnumFORMATETC/Clone(This :: <C-interface>)
		=> (status :: <HRESULT>, penum :: <Interface>)
  IEnumFORMATETC_Clone(This)
end;


	/*  ----  IEnumSTATDATA  ----  */


define C-address $IID-IEnumSTATDATA :: <REFIID>
		c-name: "IID_IEnumSTATDATA"; end;


define open generic IEnumSTATDATA/Next (This, celt, rgelt)
		=> (status :: <HRESULT>, celtFetched);

define inline-only C-function IEnumSTATDATA_Next
  input parameter This :: <C-interface>;
  input parameter celt :: <ULONG>;
   parameter rgelt :: <LPSTATDATA>;
  output parameter pceltFetched :: <LPULONG>;
  result status :: <C-HRESULT>;
  c-name: "C_IEnumSTATDATA_Next";
end;

define method IEnumSTATDATA/Next(This :: <C-interface>,
		celt :: <ffi-integer>, rgelt :: <LPSTATDATA>)
		=> (status :: <HRESULT>, celtFetched)
  IEnumSTATDATA_Next(This, celt, rgelt)
end;

define open generic IEnumSTATDATA/Skip (This, celt)
		=> (status :: <HRESULT>);

define inline-only C-function IEnumSTATDATA_Skip
  input parameter This :: <C-interface>;
  input parameter celt :: <ULONG>;
  result status :: <C-HRESULT>;
  c-name: "C_IEnumSTATDATA_Skip";
end;

define method IEnumSTATDATA/Skip(This :: <C-interface>,
		celt :: <ffi-integer>) => (status :: <HRESULT>)
  IEnumSTATDATA_Skip(This, celt)
end;

define open generic IEnumSTATDATA/Reset (This)
		=> (status :: <HRESULT>);

define inline-only C-function IEnumSTATDATA_Reset
  input parameter This :: <C-interface>;
  result status :: <C-HRESULT>;
  c-name: "C_IEnumSTATDATA_Reset";
end;

define method IEnumSTATDATA/Reset(This :: <C-interface>)
		=> (status :: <HRESULT>)
  IEnumSTATDATA_Reset(This)
end;

define open generic IEnumSTATDATA/Clone (This)
		=> (status :: <HRESULT>, penum :: <Interface>);

define inline-only C-function IEnumSTATDATA_Clone
  input parameter This :: <C-interface>;
  output parameter ppenum :: <C-interface*>;
  result status :: <C-HRESULT>;
  c-name: "C_IEnumSTATDATA_Clone";
end;

define method IEnumSTATDATA/Clone(This :: <C-interface>)
		=> (status :: <HRESULT>, penum :: <Interface>)
  IEnumSTATDATA_Clone(This)
end;


	/*  ----  IRootStorage  ----  */


define open primary COM-interface <IRootStorage> ( <IUnknown> )
end <IRootStorage>;

define C-address IRootStorage_DW_vtbl :: <C-COM-vtbl>
		c-name: "IRootStorage_DW_vtbl"; end;
define C-address $IID-IRootStorage :: <REFIID>
		c-name: "IID_IRootStorage"; end;

define method initialize ( This :: <IRootStorage>, #rest ignore, #key );
  next-method();
  This.vtbl := IRootStorage_DW_vtbl;
  add-interface(This, $IID-IRootStorage);
end initialize;

define open generic IRootStorage/SwitchToFile (This, pszFile)
		=> (status :: <HRESULT>);

define C-callable-wrapper of IRootStorage/SwitchToFile
  input parameter This :: <mapped-interface>;
  input parameter pszFile :: <LPOLESTR>;
  result status :: <C-HRESULT>;
  c-name: "DW_IRootStorage_SwitchToFile",
		c-modifiers: "__stdcall";
end;

define inline-only C-function IRootStorage_SwitchToFile
  input parameter This :: <C-interface>;
  input parameter pszFile :: <LPOLESTR>;
  result status :: <C-HRESULT>;
  c-name: "C_IRootStorage_SwitchToFile";
end;

define method IRootStorage/SwitchToFile(This :: <C-interface>,
		pszFile :: <LPOLESTR>) => (status :: <HRESULT>)
  IRootStorage_SwitchToFile(This, pszFile)
end;


	/*  ----  IAdviseSink  ----  */


define open primary COM-interface <IAdviseSink> ( <IUnknown> )
end <IAdviseSink>;

define C-address IAdviseSink_DW_vtbl :: <C-COM-vtbl>
		c-name: "IAdviseSink_DW_vtbl"; end;
define C-address $IID-IAdviseSink :: <REFIID>
		c-name: "IID_IAdviseSink"; end;

define method initialize ( This :: <IAdviseSink>, #rest ignore, #key );
  next-method();
  This.vtbl := IAdviseSink_DW_vtbl;
  add-interface(This, $IID-IAdviseSink);
end initialize;

define open generic IAdviseSink/OnDataChange (This, pFormatetc,
		pStgmed) => ();

define C-callable-wrapper of IAdviseSink/OnDataChange
  input parameter This :: <mapped-interface>;
  input parameter pFormatetc :: <LPFORMATETC>;
  input parameter pStgmed :: <LPSTGMEDIUM>;
  export: #t,
  c-name: "DW_IAdviseSink_OnDataChange",
		c-modifiers: "__stdcall";
end;

define inline-only C-function IAdviseSink_OnDataChange
  input parameter This :: <C-interface>;
  input parameter pFormatetc :: <LPFORMATETC>;
  input parameter pStgmed :: <LPSTGMEDIUM>;
  c-name: "C_IAdviseSink_OnDataChange";
end;

define method IAdviseSink/OnDataChange(This :: <C-interface>,
		pFormatetc :: <LPFORMATETC>, pStgmed :: <LPSTGMEDIUM>) => ()
  IAdviseSink_OnDataChange(This, pFormatetc, pStgmed)
end;

define open generic IAdviseSink/OnViewChange (This, dwAspect,
		lindex) => ();

define C-callable-wrapper of IAdviseSink/OnViewChange
  input parameter This :: <mapped-interface>;
  input parameter dwAspect :: <DWORD>;
  input parameter lindex :: <LONG>;
  export: #t,
  c-name: "DW_IAdviseSink_OnViewChange",
		c-modifiers: "__stdcall";
end;

define inline-only C-function IAdviseSink_OnViewChange
  input parameter This :: <C-interface>;
  input parameter dwAspect :: <DWORD>;
  input parameter lindex :: <LONG>;
  c-name: "C_IAdviseSink_OnViewChange";
end;

define method IAdviseSink/OnViewChange(This :: <C-interface>,
		dwAspect :: <ffi-integer>, lindex :: <ffi-integer>) => ()
  IAdviseSink_OnViewChange(This, dwAspect, lindex)
end;

define open generic IAdviseSink/OnRename (This, pmk) => ();

define C-callable-wrapper of IAdviseSink/OnRename
  input parameter This :: <mapped-interface>;
  input parameter pmk :: <C-interface>;
  export: #t,
  c-name: "DW_IAdviseSink_OnRename", c-modifiers: "__stdcall";
end;

define inline-only C-function IAdviseSink_OnRename
  input parameter This :: <C-interface>;
  input parameter pmk :: <Interface>;
  c-name: "C_IAdviseSink_OnRename";
end;

define method IAdviseSink/OnRename(This :: <C-interface>,
		pmk :: <Interface>) => ()
  IAdviseSink_OnRename(This, pmk)
end;

define open generic IAdviseSink/OnSave (This) => ();

define C-callable-wrapper of IAdviseSink/OnSave
  input parameter This :: <mapped-interface>;
  export: #t,
  c-name: "DW_IAdviseSink_OnSave", c-modifiers: "__stdcall";
end;

define inline-only C-function IAdviseSink_OnSave
  input parameter This :: <C-interface>;
  c-name: "C_IAdviseSink_OnSave";
end;

define method IAdviseSink/OnSave(This :: <C-interface>) => ()
  IAdviseSink_OnSave(This)
end;

define open generic IAdviseSink/OnClose (This) => ();

define C-callable-wrapper of IAdviseSink/OnClose
  input parameter This :: <mapped-interface>;
  export: #t,
  c-name: "DW_IAdviseSink_OnClose", c-modifiers: "__stdcall";
end;

define inline-only C-function IAdviseSink_OnClose
  input parameter This :: <C-interface>;
  c-name: "C_IAdviseSink_OnClose";
end;

define method IAdviseSink/OnClose(This :: <C-interface>) => ()
  IAdviseSink_OnClose(This)
end;


	/*  ----  IAdviseSink2  ----  */


define open primary COM-interface <IAdviseSink2> ( <IAdviseSink> )
end <IAdviseSink2>;

define C-address IAdviseSink2_DW_vtbl :: <C-COM-vtbl>
		c-name: "IAdviseSink2_DW_vtbl"; end;
define C-address $IID-IAdviseSink2 :: <REFIID>
		c-name: "IID_IAdviseSink2"; end;

define method initialize ( This :: <IAdviseSink2>, #rest ignore, #key );
  next-method();
  This.vtbl := IAdviseSink2_DW_vtbl;
  add-interface(This, $IID-IAdviseSink2);
end initialize;

define open generic IAdviseSink2/OnLinkSrcChange (This, pmk)
		=> ();

define C-callable-wrapper of IAdviseSink2/OnLinkSrcChange
  input parameter This :: <mapped-interface>;
  input parameter pmk :: <C-interface>;
  c-name: "DW_IAdviseSink2_OnLinkSrcChange",
		c-modifiers: "__stdcall";
end;

define inline-only C-function IAdviseSink2_OnLinkSrcChange
  input parameter This :: <C-interface>;
  input parameter pmk :: <Interface>;
  c-name: "C_IAdviseSink2_OnLinkSrcChange";
end;

define method IAdviseSink2/OnLinkSrcChange(This :: <C-interface>,
		pmk :: <Interface>) => ()
  IAdviseSink2_OnLinkSrcChange(This, pmk)
end;


	/*  ----  IDataObject  ----  */


define open primary COM-interface <IDataObject> ( <IUnknown> )
end <IDataObject>;

define C-address IDataObject_DW_vtbl :: <C-COM-vtbl>
		c-name: "IDataObject_DW_vtbl"; end;
define C-address $IID-IDataObject :: <REFIID>
		c-name: "IID_IDataObject"; end;

define method initialize ( This :: <IDataObject>, #rest ignore, #key );
  next-method();
  This.vtbl := IDataObject_DW_vtbl;
  add-interface(This, $IID-IDataObject);
end initialize;

define open generic IDataObject/GetData (This, pformatetcIn,
		pmedium) => (status :: <HRESULT>);

define C-callable-wrapper of IDataObject/GetData
  input parameter This :: <mapped-interface>;
  input parameter pformatetcIn :: <LPFORMATETC>;
  parameter pmedium :: <LPSTGMEDIUM>;
  result status :: <C-HRESULT>;
  c-name: "DW_IDataObject_GetData", c-modifiers: "__stdcall";
end;

define inline-only C-function IDataObject_GetData
  input parameter This :: <C-interface>;
  input parameter pformatetcIn :: <LPFORMATETC>;
  parameter pmedium :: <LPSTGMEDIUM>;
  result status :: <C-HRESULT>;
  c-name: "C_IDataObject_GetData";
end;

define method IDataObject/GetData(This :: <C-interface>,
		pformatetcIn :: <LPFORMATETC>, pmedium :: <LPSTGMEDIUM>)
		=> (status :: <HRESULT>)
  IDataObject_GetData(This, pformatetcIn, pmedium)
end;

define open generic IDataObject/GetDataHere (This, pformatetc,
		pmedium) => (status :: <HRESULT>);

define C-callable-wrapper of IDataObject/GetDataHere
  input parameter This :: <mapped-interface>;
  input parameter pformatetc :: <LPFORMATETC>;
   parameter pmedium :: <LPSTGMEDIUM>;
  result status :: <C-HRESULT>;
  c-name: "DW_IDataObject_GetDataHere",
		c-modifiers: "__stdcall";
end;

define inline-only C-function IDataObject_GetDataHere
  input parameter This :: <C-interface>;
  input parameter pformatetc :: <LPFORMATETC>;
   parameter pmedium :: <LPSTGMEDIUM>;
  result status :: <C-HRESULT>;
  c-name: "C_IDataObject_GetDataHere";
end;

define method IDataObject/GetDataHere(This :: <C-interface>,
		pformatetc :: <LPFORMATETC>, pmedium :: <LPSTGMEDIUM>)
		=> (status :: <HRESULT>)
  IDataObject_GetDataHere(This, pformatetc, pmedium)
end;

define open generic IDataObject/QueryGetData (This, pformatetc)
		=> (status :: <HRESULT>);

define C-callable-wrapper of IDataObject/QueryGetData
  input parameter This :: <mapped-interface>;
  input parameter pformatetc :: <LPFORMATETC>;
  result status :: <C-HRESULT>;
  c-name: "DW_IDataObject_QueryGetData",
		c-modifiers: "__stdcall";
end;

define inline-only C-function IDataObject_QueryGetData
  input parameter This :: <C-interface>;
  input parameter pformatetc :: <LPFORMATETC>;
  result status :: <C-HRESULT>;
  c-name: "C_IDataObject_QueryGetData";
end;

define method IDataObject/QueryGetData(This :: <C-interface>,
		pformatetc :: <LPFORMATETC>) => (status :: <HRESULT>)
  IDataObject_QueryGetData(This, pformatetc)
end;

define open generic IDataObject/GetCanonicalFormatEtc (This,
		pformatectIn, pformatetcOut) => (status :: <HRESULT>);

define C-callable-wrapper of IDataObject/GetCanonicalFormatEtc
  input parameter This :: <mapped-interface>;
  input parameter pformatectIn :: <LPFORMATETC>;
  parameter pformatetcOut :: <LPFORMATETC>;
  result status :: <C-HRESULT>;
  c-name: "DW_IDataObject_GetCanonicalFormatEtc",
		c-modifiers: "__stdcall";
end;

define inline-only C-function IDataObject_GetCanonicalFormatEtc
  input parameter This :: <C-interface>;
  input parameter pformatectIn :: <LPFORMATETC>;
  parameter pformatetcOut :: <LPFORMATETC>;
  result status :: <C-HRESULT>;
  c-name: "C_IDataObject_GetCanonicalFormatEtc";
end;

define method IDataObject/GetCanonicalFormatEtc(This :: <C-interface>,
		pformatectIn :: <LPFORMATETC>, pformatetcOut :: <LPFORMATETC>)
		=> (status :: <HRESULT>)
  IDataObject_GetCanonicalFormatEtc(This, pformatectIn,
		pformatetcOut)
end;

define open generic IDataObject/SetData (This, pformatetc,
		pmedium, fRelease) => (status :: <HRESULT>);

define C-callable-wrapper of IDataObject/SetData
  input parameter This :: <mapped-interface>;
  input parameter pformatetc :: <LPFORMATETC>;
  input parameter pmedium :: <LPSTGMEDIUM>;
  input parameter fRelease :: <BOOL>;
  result status :: <C-HRESULT>;
  c-name: "DW_IDataObject_SetData", c-modifiers: "__stdcall";
end;

define inline-only C-function IDataObject_SetData
  input parameter This :: <C-interface>;
  input parameter pformatetc :: <LPFORMATETC>;
  input parameter pmedium :: <LPSTGMEDIUM>;
  input parameter fRelease :: <BOOL>;
  result status :: <C-HRESULT>;
  c-name: "C_IDataObject_SetData";
end;

define method IDataObject/SetData(This :: <C-interface>,
		pformatetc :: <LPFORMATETC>, pmedium :: <LPSTGMEDIUM>,
		fRelease :: <boolean>) => (status :: <HRESULT>)
  IDataObject_SetData(This, pformatetc, pmedium, fRelease)
end;

define open generic IDataObject/EnumFormatEtc (This, dwDirection)
		=> (status :: <HRESULT>, penumFormatEtc :: <Interface>);

define C-callable-wrapper of IDataObject/EnumFormatEtc
  input parameter This :: <mapped-interface>;
  input parameter dwDirection :: <DWORD>;
  output parameter ppenumFormatEtc :: <Interface*>;
  result status :: <C-HRESULT>;
  c-name: "DW_IDataObject_EnumFormatEtc",
		c-modifiers: "__stdcall";
end;

define inline-only C-function IDataObject_EnumFormatEtc
  input parameter This :: <C-interface>;
  input parameter dwDirection :: <DWORD>;
  output parameter ppenumFormatEtc :: <C-interface*>;
  result status :: <C-HRESULT>;
  c-name: "C_IDataObject_EnumFormatEtc";
end;

define method IDataObject/EnumFormatEtc(This :: <C-interface>,
		dwDirection :: <ffi-integer>)
		=> (status :: <HRESULT>, penumFormatEtc :: <Interface>)
  IDataObject_EnumFormatEtc(This, dwDirection)
end;

define open generic IDataObject/DAdvise (This, pformatetc, advf,
		pAdvSink) => (status :: <HRESULT>, dwConnection);

define C-callable-wrapper of IDataObject/DAdvise
  input parameter This :: <mapped-interface>;
  input parameter pformatetc :: <LPFORMATETC>;
  input parameter advf :: <DWORD>;
  input parameter pAdvSink :: <C-interface>;
  output parameter pdwConnection :: <LPDWORD>;
  result status :: <C-HRESULT>;
  c-name: "DW_IDataObject_DAdvise", c-modifiers: "__stdcall";
end;

define inline-only C-function IDataObject_DAdvise
  input parameter This :: <C-interface>;
  input parameter pformatetc :: <LPFORMATETC>;
  input parameter advf :: <DWORD>;
  input parameter pAdvSink :: <Interface>;
  output parameter pdwConnection :: <LPDWORD>;
  result status :: <C-HRESULT>;
  c-name: "C_IDataObject_DAdvise";
end;

define method IDataObject/DAdvise(This :: <C-interface>,
		pformatetc :: <LPFORMATETC>, advf :: <ffi-integer>,
		pAdvSink :: <Interface>)
		=> (status :: <HRESULT>, dwConnection)
  IDataObject_DAdvise(This, pformatetc, advf, pAdvSink)
end;

define open generic IDataObject/DUnadvise (This, dwConnection)
		=> (status :: <HRESULT>);

define C-callable-wrapper of IDataObject/DUnadvise
  input parameter This :: <mapped-interface>;
  input parameter dwConnection :: <DWORD>;
  result status :: <C-HRESULT>;
  c-name: "DW_IDataObject_DUnadvise", c-modifiers: "__stdcall";
end;

define inline-only C-function IDataObject_DUnadvise
  input parameter This :: <C-interface>;
  input parameter dwConnection :: <DWORD>;
  result status :: <C-HRESULT>;
  c-name: "C_IDataObject_DUnadvise";
end;

define method IDataObject/DUnadvise(This :: <C-interface>,
		dwConnection :: <ffi-integer>) => (status :: <HRESULT>)
  IDataObject_DUnadvise(This, dwConnection)
end;

define open generic IDataObject/EnumDAdvise (This)
		=> (status :: <HRESULT>, penumAdvise :: <Interface>);

define C-callable-wrapper of IDataObject/EnumDAdvise
  input parameter This :: <mapped-interface>;
  output parameter ppenumAdvise :: <Interface*>;
  result status :: <C-HRESULT>;
  c-name: "DW_IDataObject_EnumDAdvise",
		c-modifiers: "__stdcall";
end;

define inline-only C-function IDataObject_EnumDAdvise
  input parameter This :: <C-interface>;
  output parameter ppenumAdvise :: <C-interface*>;
  result status :: <C-HRESULT>;
  c-name: "C_IDataObject_EnumDAdvise";
end;

define method IDataObject/EnumDAdvise(This :: <C-interface>)
		=> (status :: <HRESULT>, penumAdvise :: <Interface>)
  IDataObject_EnumDAdvise(This)
end;


	/*  ----  IDataAdviseHolder  ----  */


define open primary COM-interface <IDataAdviseHolder> ( <IUnknown> )
end <IDataAdviseHolder>;

define C-address IDataAdviseHolder_DW_vtbl :: <C-COM-vtbl>
		c-name: "IDataAdviseHolder_DW_vtbl"; end;
define C-address $IID-IDataAdviseHolder :: <REFIID>
		c-name: "IID_IDataAdviseHolder"; end;

define method initialize ( This :: <IDataAdviseHolder>, #rest ignore, #key );
  next-method();
  This.vtbl := IDataAdviseHolder_DW_vtbl;
  add-interface(This, $IID-IDataAdviseHolder);
end initialize;

define open generic IDataAdviseHolder/Advise (This, pDataObject,
		pFetc, advf, pAdvise) => (status :: <HRESULT>, dwConnection);

define C-callable-wrapper of IDataAdviseHolder/Advise
  input parameter This :: <mapped-interface>;
  input parameter pDataObject :: <C-interface>;
  input parameter pFetc :: <LPFORMATETC>;
  input parameter advf :: <DWORD>;
  input parameter pAdvise :: <C-interface>;
  output parameter pdwConnection :: <LPDWORD>;
  result status :: <C-HRESULT>;
  c-name: "DW_IDataAdviseHolder_Advise",
		c-modifiers: "__stdcall";
end;

define inline-only C-function IDataAdviseHolder_Advise
  input parameter This :: <C-interface>;
  input parameter pDataObject :: <Interface>;
  input parameter pFetc :: <LPFORMATETC>;
  input parameter advf :: <DWORD>;
  input parameter pAdvise :: <Interface>;
  output parameter pdwConnection :: <LPDWORD>;
  result status :: <C-HRESULT>;
  c-name: "C_IDataAdviseHolder_Advise";
end;

define method IDataAdviseHolder/Advise(This :: <C-interface>,
		pDataObject :: <Interface>, pFetc :: <LPFORMATETC>,
		advf :: <ffi-integer>, pAdvise :: <Interface>)
		=> (status :: <HRESULT>, dwConnection)
  IDataAdviseHolder_Advise(This, pDataObject, pFetc, advf,
		pAdvise)
end;

define open generic IDataAdviseHolder/Unadvise (This,
		dwConnection) => (status :: <HRESULT>);

define C-callable-wrapper of IDataAdviseHolder/Unadvise
  input parameter This :: <mapped-interface>;
  input parameter dwConnection :: <DWORD>;
  result status :: <C-HRESULT>;
  c-name: "DW_IDataAdviseHolder_Unadvise",
		c-modifiers: "__stdcall";
end;

define inline-only C-function IDataAdviseHolder_Unadvise
  input parameter This :: <C-interface>;
  input parameter dwConnection :: <DWORD>;
  result status :: <C-HRESULT>;
  c-name: "C_IDataAdviseHolder_Unadvise";
end;

define method IDataAdviseHolder/Unadvise(This :: <C-interface>,
		dwConnection :: <ffi-integer>) => (status :: <HRESULT>)
  IDataAdviseHolder_Unadvise(This, dwConnection)
end;

define open generic IDataAdviseHolder/EnumAdvise (This)
		=> (status :: <HRESULT>, penumAdvise :: <Interface>);

define C-callable-wrapper of IDataAdviseHolder/EnumAdvise
  input parameter This :: <mapped-interface>;
  output parameter ppenumAdvise :: <Interface*>;
  result status :: <C-HRESULT>;
  c-name: "DW_IDataAdviseHolder_EnumAdvise",
		c-modifiers: "__stdcall";
end;

define inline-only C-function IDataAdviseHolder_EnumAdvise
  input parameter This :: <C-interface>;
  output parameter ppenumAdvise :: <C-interface*>;
  result status :: <C-HRESULT>;
  c-name: "C_IDataAdviseHolder_EnumAdvise";
end;

define method IDataAdviseHolder/EnumAdvise(This :: <C-interface>)
		=> (status :: <HRESULT>, penumAdvise :: <Interface>)
  IDataAdviseHolder_EnumAdvise(This)
end;

define open generic IDataAdviseHolder/SendOnDataChange (This,
		pDataObject, dwReserved, advf) => (status :: <HRESULT>);

define C-callable-wrapper of IDataAdviseHolder/SendOnDataChange
  input parameter This :: <mapped-interface>;
  input parameter pDataObject :: <C-interface>;
  input parameter dwReserved :: <DWORD>;
  input parameter advf :: <DWORD>;
  result status :: <C-HRESULT>;
  c-name: "DW_IDataAdviseHolder_SendOnDataChange",
		c-modifiers: "__stdcall";
end;

define inline-only C-function IDataAdviseHolder_SendOnDataChange
  input parameter This :: <C-interface>;
  input parameter pDataObject :: <Interface>;
  input parameter dwReserved :: <DWORD>;
  input parameter advf :: <DWORD>;
  result status :: <C-HRESULT>;
  c-name: "C_IDataAdviseHolder_SendOnDataChange";
end;

define method IDataAdviseHolder/SendOnDataChange(This :: <C-interface>,
		pDataObject :: <Interface>, dwReserved :: <ffi-integer>,
		advf :: <ffi-integer>) => (status :: <HRESULT>)
  IDataAdviseHolder_SendOnDataChange(This, pDataObject,
		dwReserved, advf)
end;


	/*  ----  IMessageFilter  ----  */


define open primary COM-interface <IMessageFilter> ( <IUnknown> )
end <IMessageFilter>;

define C-address IMessageFilter_DW_vtbl :: <C-COM-vtbl>
		c-name: "IMessageFilter_DW_vtbl"; end;
define C-address $IID-IMessageFilter :: <REFIID>
		c-name: "IID_IMessageFilter"; end;

define method initialize ( This :: <IMessageFilter>, #rest ignore, #key );
  next-method();
  This.vtbl := IMessageFilter_DW_vtbl;
  add-interface(This, $IID-IMessageFilter);
end initialize;

define open generic IMessageFilter/HandleInComingCall (This,
		dwCallType, htaskCaller, dwTickCount, lpInterfaceInfo)
		=> (value :: <ffi-integer>);

define C-callable-wrapper of IMessageFilter/HandleInComingCall
  input parameter This :: <mapped-interface>;
  input parameter dwCallType :: <DWORD>;
  input parameter htaskCaller :: <HTASK>;
  input parameter dwTickCount :: <DWORD>;
  input parameter lpInterfaceInfo :: <LPINTERFACEINFO>;
  result value :: <DWORD>;
  c-name: "DW_IMessageFilter_HandleInComingCall",
		c-modifiers: "__stdcall";
end;

define inline-only C-function IMessageFilter_HandleInComingCall
  input parameter This :: <C-interface>;
  input parameter dwCallType :: <DWORD>;
  input parameter htaskCaller :: <HTASK>;
  input parameter dwTickCount :: <DWORD>;
  input parameter lpInterfaceInfo :: <LPINTERFACEINFO>;
  result value :: <DWORD>;
  c-name: "C_IMessageFilter_HandleInComingCall";
end;

define method IMessageFilter/HandleInComingCall(This :: <C-interface>,
		dwCallType :: <ffi-integer>, htaskCaller :: <HTASK>,
		dwTickCount :: <ffi-integer>,
		lpInterfaceInfo :: <LPINTERFACEINFO>)
		=> (value :: <ffi-integer>)
  IMessageFilter_HandleInComingCall(This, dwCallType,
		htaskCaller, dwTickCount, lpInterfaceInfo)
end;

define open generic IMessageFilter/RetryRejectedCall (This,
		htaskCallee, dwTickCount, dwRejectType)
		=> (value :: <ffi-integer>);

define C-callable-wrapper of IMessageFilter/RetryRejectedCall
  input parameter This :: <mapped-interface>;
  input parameter htaskCallee :: <HTASK>;
  input parameter dwTickCount :: <DWORD>;
  input parameter dwRejectType :: <DWORD>;
  result value :: <DWORD>;
  c-name: "DW_IMessageFilter_RetryRejectedCall",
		c-modifiers: "__stdcall";
end;

define inline-only C-function IMessageFilter_RetryRejectedCall
  input parameter This :: <C-interface>;
  input parameter htaskCallee :: <HTASK>;
  input parameter dwTickCount :: <DWORD>;
  input parameter dwRejectType :: <DWORD>;
  result value :: <DWORD>;
  c-name: "C_IMessageFilter_RetryRejectedCall";
end;

define method IMessageFilter/RetryRejectedCall(This :: <C-interface>,
		htaskCallee :: <HTASK>, dwTickCount :: <ffi-integer>,
		dwRejectType :: <ffi-integer>) => (value :: <ffi-integer>)
  IMessageFilter_RetryRejectedCall(This, htaskCallee,
		dwTickCount, dwRejectType)
end;

define open generic IMessageFilter/MessagePending (This,
		htaskCallee, dwTickCount, dwPendingType)
		=> (value :: <ffi-integer>);

define C-callable-wrapper of IMessageFilter/MessagePending
  input parameter This :: <mapped-interface>;
  input parameter htaskCallee :: <HTASK>;
  input parameter dwTickCount :: <DWORD>;
  input parameter dwPendingType :: <DWORD>;
  result value :: <DWORD>;
  c-name: "DW_IMessageFilter_MessagePending",
		c-modifiers: "__stdcall";
end;

define inline-only C-function IMessageFilter_MessagePending
  input parameter This :: <C-interface>;
  input parameter htaskCallee :: <HTASK>;
  input parameter dwTickCount :: <DWORD>;
  input parameter dwPendingType :: <DWORD>;
  result value :: <DWORD>;
  c-name: "C_IMessageFilter_MessagePending";
end;

define method IMessageFilter/MessagePending(This :: <C-interface>,
		htaskCallee :: <HTASK>, dwTickCount :: <ffi-integer>,
		dwPendingType :: <ffi-integer>) => (value :: <ffi-integer>)
  IMessageFilter_MessagePending(This, htaskCallee, dwTickCount,
		dwPendingType)
end;


	/*  ----  IRpcChannelBuffer  ----  */


define C-address $IID-IRpcChannelBuffer :: <REFIID>
		c-name: "IID_IRpcChannelBuffer"; end;


define open generic IRpcChannelBuffer/GetBuffer (This, pMessage,
		riid) => (status :: <HRESULT>);

define inline-only C-function IRpcChannelBuffer_GetBuffer
  input parameter This :: <C-interface>;
  input parameter pMessage :: <LPRPCOLEMESSAGE>;
  input parameter riid :: <REFIID>;
  result status :: <C-HRESULT>;
  c-name: "C_IRpcChannelBuffer_GetBuffer";
end;

define method IRpcChannelBuffer/GetBuffer(This :: <C-interface>,
		pMessage :: <LPRPCOLEMESSAGE>, riid :: <REFIID>)
		=> (status :: <HRESULT>)
  IRpcChannelBuffer_GetBuffer(This, pMessage, riid)
end;

define open generic IRpcChannelBuffer/SendReceive (This,
		pMessage) => (status :: <HRESULT>, Status);

define inline-only C-function IRpcChannelBuffer_SendReceive
  input parameter This :: <C-interface>;
   parameter pMessage :: <LPRPCOLEMESSAGE>;
  output parameter pStatus :: <LPULONG>;
  result status :: <C-HRESULT>;
  c-name: "C_IRpcChannelBuffer_SendReceive";
end;

define method IRpcChannelBuffer/SendReceive(This :: <C-interface>,
		pMessage :: <LPRPCOLEMESSAGE>)
		=> (status :: <HRESULT>, Status)
  IRpcChannelBuffer_SendReceive(This, pMessage)
end;

define open generic IRpcChannelBuffer/FreeBuffer (This, pMessage)
		=> (status :: <HRESULT>);

define inline-only C-function IRpcChannelBuffer_FreeBuffer
  input parameter This :: <C-interface>;
  input parameter pMessage :: <LPRPCOLEMESSAGE>;
  result status :: <C-HRESULT>;
  c-name: "C_IRpcChannelBuffer_FreeBuffer";
end;

define method IRpcChannelBuffer/FreeBuffer(This :: <C-interface>,
		pMessage :: <LPRPCOLEMESSAGE>) => (status :: <HRESULT>)
  IRpcChannelBuffer_FreeBuffer(This, pMessage)
end;

define open generic IRpcChannelBuffer/GetDestCtx (This)
		=> (status :: <HRESULT>, dwDestContext,
		pvDestContext :: <C-void*>);

define inline-only C-function IRpcChannelBuffer_GetDestCtx
  input parameter This :: <C-interface>;
  output parameter pdwDestContext :: <LPDWORD>;
  output parameter ppvDestContext :: <C-void**>;
  result status :: <C-HRESULT>;
  c-name: "C_IRpcChannelBuffer_GetDestCtx";
end;

define method IRpcChannelBuffer/GetDestCtx(This :: <C-interface>)
		=> (status :: <HRESULT>, dwDestContext,
		pvDestContext :: <C-void*>)
  IRpcChannelBuffer_GetDestCtx(This)
end;

define open generic IRpcChannelBuffer/IsConnected (This)
		=> (status :: <HRESULT>);

define inline-only C-function IRpcChannelBuffer_IsConnected
  input parameter This :: <C-interface>;
  result status :: <C-HRESULT>;
  c-name: "C_IRpcChannelBuffer_IsConnected";
end;

define method IRpcChannelBuffer/IsConnected(This :: <C-interface>)
		=> (status :: <HRESULT>)
  IRpcChannelBuffer_IsConnected(This)
end;


	/*  ----  IRpcChannelBuffer2  ----  */



	/*  ----  IRpcChannelBuffer3  ----  */



	/*  ----  IRpcProxyBuffer  ----  */


define open primary COM-interface <IRpcProxyBuffer> ( <IUnknown> )
end <IRpcProxyBuffer>;

define C-address IRpcProxyBuffer_DW_vtbl :: <C-COM-vtbl>
		c-name: "IRpcProxyBuffer_DW_vtbl"; end;
define C-address $IID-IRpcProxyBuffer :: <REFIID>
		c-name: "IID_IRpcProxyBuffer"; end;

define method initialize ( This :: <IRpcProxyBuffer>, #rest ignore, #key );
  next-method();
  This.vtbl := IRpcProxyBuffer_DW_vtbl;
  add-interface(This, $IID-IRpcProxyBuffer);
end initialize;

define open generic IRpcProxyBuffer/Connect (This,
		pRpcChannelBuffer) => (status :: <HRESULT>);

define C-callable-wrapper of IRpcProxyBuffer/Connect
  input parameter This :: <mapped-interface>;
  input parameter pRpcChannelBuffer :: <C-interface>;
  result status :: <C-HRESULT>;
  c-name: "DW_IRpcProxyBuffer_Connect",
		c-modifiers: "__stdcall";
end;

define inline-only C-function IRpcProxyBuffer_Connect
  input parameter This :: <C-interface>;
  input parameter pRpcChannelBuffer :: <Interface>;
  result status :: <C-HRESULT>;
  c-name: "C_IRpcProxyBuffer_Connect";
end;

define method IRpcProxyBuffer/Connect(This :: <C-interface>,
		pRpcChannelBuffer :: <Interface>) => (status :: <HRESULT>)
  IRpcProxyBuffer_Connect(This, pRpcChannelBuffer)
end;

define open generic IRpcProxyBuffer/Disconnect (This) => ();

define C-callable-wrapper of IRpcProxyBuffer/Disconnect
  input parameter This :: <mapped-interface>;
  c-name: "DW_IRpcProxyBuffer_Disconnect",
		c-modifiers: "__stdcall";
end;

define inline-only C-function IRpcProxyBuffer_Disconnect
  input parameter This :: <C-interface>;
  c-name: "C_IRpcProxyBuffer_Disconnect";
end;

define method IRpcProxyBuffer/Disconnect(This :: <C-interface>)
		=> ()
  IRpcProxyBuffer_Disconnect(This)
end;


	/*  ----  IRpcStubBuffer  ----  */


define open primary COM-interface <IRpcStubBuffer> ( <IUnknown> )
end <IRpcStubBuffer>;

define C-address IRpcStubBuffer_DW_vtbl :: <C-COM-vtbl>
		c-name: "IRpcStubBuffer_DW_vtbl"; end;
define C-address $IID-IRpcStubBuffer :: <REFIID>
		c-name: "IID_IRpcStubBuffer"; end;

define method initialize ( This :: <IRpcStubBuffer>, #rest ignore, #key );
  next-method();
  This.vtbl := IRpcStubBuffer_DW_vtbl;
  add-interface(This, $IID-IRpcStubBuffer);
end initialize;

define open generic IRpcStubBuffer/Connect (This, pUnkServer)
		=> (status :: <HRESULT>);

define C-callable-wrapper of IRpcStubBuffer/Connect
  input parameter This :: <mapped-interface>;
  input parameter pUnkServer :: <C-interface>;
  result status :: <C-HRESULT>;
  c-name: "DW_IRpcStubBuffer_Connect", c-modifiers: "__stdcall";
end;

define inline-only C-function IRpcStubBuffer_Connect
  input parameter This :: <C-interface>;
  input parameter pUnkServer :: <Interface>;
  result status :: <C-HRESULT>;
  c-name: "C_IRpcStubBuffer_Connect";
end;

define method IRpcStubBuffer/Connect(This :: <C-interface>,
		pUnkServer :: <Interface>) => (status :: <HRESULT>)
  IRpcStubBuffer_Connect(This, pUnkServer)
end;

define open generic IRpcStubBuffer/Disconnect (This) => ();

define C-callable-wrapper of IRpcStubBuffer/Disconnect
  input parameter This :: <mapped-interface>;
  c-name: "DW_IRpcStubBuffer_Disconnect",
		c-modifiers: "__stdcall";
end;

define inline-only C-function IRpcStubBuffer_Disconnect
  input parameter This :: <C-interface>;
  c-name: "C_IRpcStubBuffer_Disconnect";
end;

define method IRpcStubBuffer/Disconnect(This :: <C-interface>)
		=> ()
  IRpcStubBuffer_Disconnect(This)
end;

define open generic IRpcStubBuffer/Invoke (This, _prpcmsg,
		_pRpcChannelBuffer) => (status :: <HRESULT>);

define C-callable-wrapper of IRpcStubBuffer/Invoke
  input parameter This :: <mapped-interface>;
  input parameter _prpcmsg :: <LPRPCOLEMESSAGE>;
  input parameter _pRpcChannelBuffer :: <C-interface>;
  result status :: <C-HRESULT>;
  c-name: "DW_IRpcStubBuffer_Invoke", c-modifiers: "__stdcall";
end;

define inline-only C-function IRpcStubBuffer_Invoke
  input parameter This :: <C-interface>;
  input parameter _prpcmsg :: <LPRPCOLEMESSAGE>;
  input parameter _pRpcChannelBuffer :: <Interface>;
  result status :: <C-HRESULT>;
  c-name: "C_IRpcStubBuffer_Invoke";
end;

define method IRpcStubBuffer/Invoke(This :: <C-interface>,
		_prpcmsg :: <LPRPCOLEMESSAGE>,
		_pRpcChannelBuffer :: <Interface>) => (status :: <HRESULT>)
  IRpcStubBuffer_Invoke(This, _prpcmsg, _pRpcChannelBuffer)
end;

define open generic IRpcStubBuffer/IsIIDSupported (This, riid)
		=> (value :: <Interface>);

define C-callable-wrapper of IRpcStubBuffer/IsIIDSupported
  input parameter This :: <mapped-interface>;
  input parameter riid :: <REFIID>;
  result value :: <Interface>;
  c-name: "DW_IRpcStubBuffer_IsIIDSupported",
		c-modifiers: "__stdcall";
end;

define inline-only C-function IRpcStubBuffer_IsIIDSupported
  input parameter This :: <C-interface>;
  input parameter riid :: <REFIID>;
  result value :: <Interface>;
  c-name: "C_IRpcStubBuffer_IsIIDSupported";
end;

define method IRpcStubBuffer/IsIIDSupported(This :: <C-interface>,
		riid :: <REFIID>) => (value :: <Interface>)
  IRpcStubBuffer_IsIIDSupported(This, riid)
end;

define open generic IRpcStubBuffer/CountRefs (This)
		=> (value :: <ffi-integer>);

define C-callable-wrapper of IRpcStubBuffer/CountRefs
  input parameter This :: <mapped-interface>;
  result value :: <ULONG>;
  c-name: "DW_IRpcStubBuffer_CountRefs",
		c-modifiers: "__stdcall";
end;

define inline-only C-function IRpcStubBuffer_CountRefs
  input parameter This :: <C-interface>;
  result value :: <ULONG>;
  c-name: "C_IRpcStubBuffer_CountRefs";
end;

define method IRpcStubBuffer/CountRefs(This :: <C-interface>)
		=> (value :: <ffi-integer>)
  IRpcStubBuffer_CountRefs(This)
end;

define open generic IRpcStubBuffer/DebugServerQueryInterface
		(This, ppv) => (status :: <HRESULT>);

define C-callable-wrapper
		of IRpcStubBuffer/DebugServerQueryInterface
  input parameter This :: <mapped-interface>;
  input parameter ppv :: <C-void**>;
  result status :: <C-HRESULT>;
  c-name: "DW_IRpcStubBuffer_DebugServerQueryInterface",
		c-modifiers: "__stdcall";
end;

define inline-only C-function IRpcStubBuffer_DebugServerQueryInterface
  input parameter This :: <C-interface>;
  input parameter ppv :: <C-void**>;
  result status :: <C-HRESULT>;
  c-name: "C_IRpcStubBuffer_DebugServerQueryInterface";
end;

define method IRpcStubBuffer/DebugServerQueryInterface(This :: <C-interface>,
		ppv :: <C-pointer>) => (status :: <HRESULT>)
  IRpcStubBuffer_DebugServerQueryInterface(This, ppv)
end;

define open generic IRpcStubBuffer/DebugServerRelease (This, pv)
		=> ();

define C-callable-wrapper of IRpcStubBuffer/DebugServerRelease
  input parameter This :: <mapped-interface>;
  input parameter pv :: <C-void*>;
  c-name: "DW_IRpcStubBuffer_DebugServerRelease",
		c-modifiers: "__stdcall";
end;

define inline-only C-function IRpcStubBuffer_DebugServerRelease
  input parameter This :: <C-interface>;
  input parameter pv :: <C-void*>;
  c-name: "C_IRpcStubBuffer_DebugServerRelease";
end;

define method IRpcStubBuffer/DebugServerRelease(This :: <C-interface>,
		pv :: <C-pointer>) => ()
  IRpcStubBuffer_DebugServerRelease(This, pv)
end;


	/*  ----  IPSFactoryBuffer  ----  */


define open primary COM-interface <IPSFactoryBuffer> ( <IUnknown> )
end <IPSFactoryBuffer>;

define C-address IPSFactoryBuffer_DW_vtbl :: <C-COM-vtbl>
		c-name: "IPSFactoryBuffer_DW_vtbl"; end;
define C-address $IID-IPSFactoryBuffer :: <REFIID>
		c-name: "IID_IPSFactoryBuffer"; end;

define method initialize ( This :: <IPSFactoryBuffer>, #rest ignore, #key );
  next-method();
  This.vtbl := IPSFactoryBuffer_DW_vtbl;
  add-interface(This, $IID-IPSFactoryBuffer);
end initialize;

define open generic IPSFactoryBuffer/CreateProxy (This,
		pUnkOuter, riid)
		=> (status :: <HRESULT>, pProxy :: <Interface>, pv :: <C-void*>);

define C-callable-wrapper of IPSFactoryBuffer/CreateProxy
  input parameter This :: <mapped-interface>;
  input parameter pUnkOuter :: <C-interface>;
  input parameter riid :: <REFIID>;
  output parameter ppProxy :: <Interface*>;
  output parameter ppv :: <C-void**>;
  result status :: <C-HRESULT>;
  c-name: "DW_IPSFactoryBuffer_CreateProxy",
		c-modifiers: "__stdcall";
end;

define inline-only C-function IPSFactoryBuffer_CreateProxy
  input parameter This :: <C-interface>;
  input parameter pUnkOuter :: <Interface>;
  input parameter riid :: <REFIID>;
  output parameter ppProxy :: <C-interface*>;
  output parameter ppv :: <C-void**>;
  result status :: <C-HRESULT>;
  c-name: "C_IPSFactoryBuffer_CreateProxy";
end;

define method IPSFactoryBuffer/CreateProxy(This :: <C-interface>,
		pUnkOuter :: <Interface>, riid :: <REFIID>)
		=> (status :: <HRESULT>, pProxy :: <Interface>, pv :: <C-void*>)
  IPSFactoryBuffer_CreateProxy(This, pUnkOuter, riid)
end;

define open generic IPSFactoryBuffer/CreateStub (This, riid,
		pUnkServer) => (status :: <HRESULT>, pStub :: <Interface>);

define C-callable-wrapper of IPSFactoryBuffer/CreateStub
  input parameter This :: <mapped-interface>;
  input parameter riid :: <REFIID>;
  input parameter pUnkServer :: <C-interface>;
  output parameter ppStub :: <Interface*>;
  result status :: <C-HRESULT>;
  c-name: "DW_IPSFactoryBuffer_CreateStub",
		c-modifiers: "__stdcall";
end;

define inline-only C-function IPSFactoryBuffer_CreateStub
  input parameter This :: <C-interface>;
  input parameter riid :: <REFIID>;
  input parameter pUnkServer :: <Interface>;
  output parameter ppStub :: <C-interface*>;
  result status :: <C-HRESULT>;
  c-name: "C_IPSFactoryBuffer_CreateStub";
end;

define method IPSFactoryBuffer/CreateStub(This :: <C-interface>,
		riid :: <REFIID>, pUnkServer :: <Interface>)
		=> (status :: <HRESULT>, pStub :: <Interface>)
  IPSFactoryBuffer_CreateStub(This, riid, pUnkServer)
end;


	/*  ----  IPropertyStorage  ----  */


define open primary COM-interface <IPropertyStorage> ( <IUnknown> )
end <IPropertyStorage>;

define C-address IPropertyStorage_DW_vtbl :: <C-COM-vtbl>
		c-name: "IPropertyStorage_DW_vtbl"; end;
define C-address $IID-IPropertyStorage :: <REFIID>
		c-name: "IID_IPropertyStorage"; end;

define method initialize ( This :: <IPropertyStorage>, #rest ignore, #key );
  next-method();
  This.vtbl := IPropertyStorage_DW_vtbl;
  add-interface(This, $IID-IPropertyStorage);
end initialize;

define open generic IPropertyStorage/ReadMultiple (This, cpspec,
		rgpspec, rgpropvar) => (status :: <HRESULT>);

define C-callable-wrapper of IPropertyStorage/ReadMultiple
  input parameter This :: <mapped-interface>;
  input parameter cpspec :: <ULONG>;
  /* constant */ input parameter rgpspec :: <LPPROPSPEC>;
   parameter rgpropvar :: <LPPROPVARIANT>;
  result status :: <C-HRESULT>;
  c-name: "DW_IPropertyStorage_ReadMultiple",
		c-modifiers: "__stdcall";
end;

define inline-only C-function IPropertyStorage_ReadMultiple
  input parameter This :: <C-interface>;
  input parameter cpspec :: <ULONG>;
  /* constant */ input parameter rgpspec :: <LPPROPSPEC>;
   parameter rgpropvar :: <LPPROPVARIANT>;
  result status :: <C-HRESULT>;
  c-name: "C_IPropertyStorage_ReadMultiple";
end;

define method IPropertyStorage/ReadMultiple(This :: <C-interface>,
		cpspec :: <ffi-integer>, rgpspec :: <LPPROPSPEC>,
		rgpropvar :: <LPPROPVARIANT>) => (status :: <HRESULT>)
  IPropertyStorage_ReadMultiple(This, cpspec, rgpspec, rgpropvar)
end;

define open generic IPropertyStorage/WriteMultiple (This, cpspec,
		rgpspec, rgpropvar, propidNameFirst) => (status :: <HRESULT>);

define C-callable-wrapper of IPropertyStorage/WriteMultiple
  input parameter This :: <mapped-interface>;
  input parameter cpspec :: <ULONG>;
  /* constant */ input parameter rgpspec :: <LPPROPSPEC>;
  /* constant */ input parameter rgpropvar :: <LPPROPVARIANT>;
  input parameter propidNameFirst :: <PROPID>;
  result status :: <C-HRESULT>;
  c-name: "DW_IPropertyStorage_WriteMultiple",
		c-modifiers: "__stdcall";
end;

define inline-only C-function IPropertyStorage_WriteMultiple
  input parameter This :: <C-interface>;
  input parameter cpspec :: <ULONG>;
  /* constant */ input parameter rgpspec :: <LPPROPSPEC>;
  /* constant */ input parameter rgpropvar :: <LPPROPVARIANT>;
  input parameter propidNameFirst :: <PROPID>;
  result status :: <C-HRESULT>;
  c-name: "C_IPropertyStorage_WriteMultiple";
end;

define method IPropertyStorage/WriteMultiple(This :: <C-interface>,
		cpspec :: <ffi-integer>, rgpspec :: <LPPROPSPEC>,
		rgpropvar :: <LPPROPVARIANT>, propidNameFirst :: <ffi-integer>)
		=> (status :: <HRESULT>)
  IPropertyStorage_WriteMultiple(This, cpspec, rgpspec,
		rgpropvar, propidNameFirst)
end;

define open generic IPropertyStorage/DeleteMultiple (This,
		cpspec, rgpspec) => (status :: <HRESULT>);

define C-callable-wrapper of IPropertyStorage/DeleteMultiple
  input parameter This :: <mapped-interface>;
  input parameter cpspec :: <ULONG>;
  /* constant */ input parameter rgpspec :: <LPPROPSPEC>;
  result status :: <C-HRESULT>;
  c-name: "DW_IPropertyStorage_DeleteMultiple",
		c-modifiers: "__stdcall";
end;

define inline-only C-function IPropertyStorage_DeleteMultiple
  input parameter This :: <C-interface>;
  input parameter cpspec :: <ULONG>;
  /* constant */ input parameter rgpspec :: <LPPROPSPEC>;
  result status :: <C-HRESULT>;
  c-name: "C_IPropertyStorage_DeleteMultiple";
end;

define method IPropertyStorage/DeleteMultiple(This :: <C-interface>,
		cpspec :: <ffi-integer>, rgpspec :: <LPPROPSPEC>)
		=> (status :: <HRESULT>)
  IPropertyStorage_DeleteMultiple(This, cpspec, rgpspec)
end;

define open generic IPropertyStorage/ReadPropertyNames (This,
		cpropid, rgpropid, rglpwstrName) => (status :: <HRESULT>);

define C-callable-wrapper of IPropertyStorage/ReadPropertyNames
  input parameter This :: <mapped-interface>;
  input parameter cpropid :: <ULONG>;
  /* constant */ input parameter rgpropid :: <LPPROPID>;
   parameter rglpwstrName :: <LPLPOLESTR>;
  result status :: <C-HRESULT>;
  c-name: "DW_IPropertyStorage_ReadPropertyNames",
		c-modifiers: "__stdcall";
end;

define inline-only C-function IPropertyStorage_ReadPropertyNames
  input parameter This :: <C-interface>;
  input parameter cpropid :: <ULONG>;
  /* constant */ input parameter rgpropid :: <LPPROPID>;
   parameter rglpwstrName :: <LPLPOLESTR>;
  result status :: <C-HRESULT>;
  c-name: "C_IPropertyStorage_ReadPropertyNames";
end;

define method IPropertyStorage/ReadPropertyNames(This :: <C-interface>,
		cpropid :: <ffi-integer>, rgpropid :: <LPPROPID>,
		rglpwstrName :: <LPLPOLESTR>) => (status :: <HRESULT>)
  IPropertyStorage_ReadPropertyNames(This, cpropid, rgpropid,
		rglpwstrName)
end;

define open generic IPropertyStorage/WritePropertyNames (This,
		cpropid, rgpropid, rglpwstrName) => (status :: <HRESULT>);

define C-callable-wrapper of IPropertyStorage/WritePropertyNames
  input parameter This :: <mapped-interface>;
  input parameter cpropid :: <ULONG>;
  /* constant */ input parameter rgpropid :: <LPPROPID>;
  /* constant */ input parameter rglpwstrName :: <LPLPOLESTR>;
  result status :: <C-HRESULT>;
  c-name: "DW_IPropertyStorage_WritePropertyNames",
		c-modifiers: "__stdcall";
end;

define inline-only C-function IPropertyStorage_WritePropertyNames
  input parameter This :: <C-interface>;
  input parameter cpropid :: <ULONG>;
  /* constant */ input parameter rgpropid :: <LPPROPID>;
  /* constant */ input parameter rglpwstrName :: <LPLPOLESTR>;
  result status :: <C-HRESULT>;
  c-name: "C_IPropertyStorage_WritePropertyNames";
end;

define method IPropertyStorage/WritePropertyNames(This :: <C-interface>,
		cpropid :: <ffi-integer>, rgpropid :: <LPPROPID>,
		rglpwstrName :: <LPLPOLESTR>) => (status :: <HRESULT>)
  IPropertyStorage_WritePropertyNames(This, cpropid, rgpropid,
		rglpwstrName)
end;

define open generic IPropertyStorage/DeletePropertyNames (This,
		cpropid, rgpropid) => (status :: <HRESULT>);

define C-callable-wrapper
		of IPropertyStorage/DeletePropertyNames
  input parameter This :: <mapped-interface>;
  input parameter cpropid :: <ULONG>;
  /* constant */ input parameter rgpropid :: <LPPROPID>;
  result status :: <C-HRESULT>;
  c-name: "DW_IPropertyStorage_DeletePropertyNames",
		c-modifiers: "__stdcall";
end;

define inline-only C-function IPropertyStorage_DeletePropertyNames
  input parameter This :: <C-interface>;
  input parameter cpropid :: <ULONG>;
  /* constant */ input parameter rgpropid :: <LPPROPID>;
  result status :: <C-HRESULT>;
  c-name: "C_IPropertyStorage_DeletePropertyNames";
end;

define method IPropertyStorage/DeletePropertyNames(This :: <C-interface>,
		cpropid :: <ffi-integer>, rgpropid :: <LPPROPID>)
		=> (status :: <HRESULT>)
  IPropertyStorage_DeletePropertyNames(This, cpropid, rgpropid)
end;

define open generic IPropertyStorage/Commit (This,
		grfCommitFlags) => (status :: <HRESULT>);

define C-callable-wrapper of IPropertyStorage/Commit
  input parameter This :: <mapped-interface>;
  input parameter grfCommitFlags :: <DWORD>;
  result status :: <C-HRESULT>;
  c-name: "DW_IPropertyStorage_Commit",
		c-modifiers: "__stdcall";
end;

define inline-only C-function IPropertyStorage_Commit
  input parameter This :: <C-interface>;
  input parameter grfCommitFlags :: <DWORD>;
  result status :: <C-HRESULT>;
  c-name: "C_IPropertyStorage_Commit";
end;

define method IPropertyStorage/Commit(This :: <C-interface>,
		grfCommitFlags :: <ffi-integer>) => (status :: <HRESULT>)
  IPropertyStorage_Commit(This, grfCommitFlags)
end;

define open generic IPropertyStorage/Revert (This)
		=> (status :: <HRESULT>);

define C-callable-wrapper of IPropertyStorage/Revert
  input parameter This :: <mapped-interface>;
  result status :: <C-HRESULT>;
  c-name: "DW_IPropertyStorage_Revert",
		c-modifiers: "__stdcall";
end;

define inline-only C-function IPropertyStorage_Revert
  input parameter This :: <C-interface>;
  result status :: <C-HRESULT>;
  c-name: "C_IPropertyStorage_Revert";
end;

define method IPropertyStorage/Revert(This :: <C-interface>)
		=> (status :: <HRESULT>)
  IPropertyStorage_Revert(This)
end;

define open generic IPropertyStorage/Enum (This)
		=> (status :: <HRESULT>, penum :: <Interface>);

define C-callable-wrapper of IPropertyStorage/Enum
  input parameter This :: <mapped-interface>;
  output parameter ppenum :: <Interface*>;
  result status :: <C-HRESULT>;
  c-name: "DW_IPropertyStorage_Enum", c-modifiers: "__stdcall";
end;

define inline-only C-function IPropertyStorage_Enum
  input parameter This :: <C-interface>;
  output parameter ppenum :: <C-interface*>;
  result status :: <C-HRESULT>;
  c-name: "C_IPropertyStorage_Enum";
end;

define method IPropertyStorage/Enum(This :: <C-interface>)
		=> (status :: <HRESULT>, penum :: <Interface>)
  IPropertyStorage_Enum(This)
end;

define open generic IPropertyStorage/SetTimes (This, pctime,
		patime, pmtime) => (status :: <HRESULT>);

define C-callable-wrapper of IPropertyStorage/SetTimes
  input parameter This :: <mapped-interface>;
  /* constant */ input parameter pctime :: <LPFILETIME>;
  /* constant */ input parameter patime :: <LPFILETIME>;
  /* constant */ input parameter pmtime :: <LPFILETIME>;
  result status :: <C-HRESULT>;
  c-name: "DW_IPropertyStorage_SetTimes",
		c-modifiers: "__stdcall";
end;

define inline-only C-function IPropertyStorage_SetTimes
  input parameter This :: <C-interface>;
  /* constant */ input parameter pctime :: <LPFILETIME>;
  /* constant */ input parameter patime :: <LPFILETIME>;
  /* constant */ input parameter pmtime :: <LPFILETIME>;
  result status :: <C-HRESULT>;
  c-name: "C_IPropertyStorage_SetTimes";
end;

define method IPropertyStorage/SetTimes(This :: <C-interface>,
		pctime :: <LPFILETIME>, patime :: <LPFILETIME>,
		pmtime :: <LPFILETIME>) => (status :: <HRESULT>)
  IPropertyStorage_SetTimes(This, pctime, patime, pmtime)
end;

define open generic IPropertyStorage/SetClass (This, clsid)
		=> (status :: <HRESULT>);

define C-callable-wrapper of IPropertyStorage/SetClass
  input parameter This :: <mapped-interface>;
  input parameter clsid :: <REFCLSID>;
  result status :: <C-HRESULT>;
  c-name: "DW_IPropertyStorage_SetClass",
		c-modifiers: "__stdcall";
end;

define inline-only C-function IPropertyStorage_SetClass
  input parameter This :: <C-interface>;
  input parameter clsid :: <REFCLSID>;
  result status :: <C-HRESULT>;
  c-name: "C_IPropertyStorage_SetClass";
end;

define method IPropertyStorage/SetClass(This :: <C-interface>,
		clsid :: <REFCLSID>) => (status :: <HRESULT>)
  IPropertyStorage_SetClass(This, clsid)
end;

define open generic IPropertyStorage/Stat (This, pstatpsstg)
		=> (status :: <HRESULT>);

define C-callable-wrapper of IPropertyStorage/Stat
  input parameter This :: <mapped-interface>;
  parameter pstatpsstg :: <LPSTATPROPSETSTG>;
  result status :: <C-HRESULT>;
  c-name: "DW_IPropertyStorage_Stat", c-modifiers: "__stdcall";
end;

define inline-only C-function IPropertyStorage_Stat
  input parameter This :: <C-interface>;
  parameter pstatpsstg :: <LPSTATPROPSETSTG>;
  result status :: <C-HRESULT>;
  c-name: "C_IPropertyStorage_Stat";
end;

define method IPropertyStorage/Stat(This :: <C-interface>,
		pstatpsstg :: <LPSTATPROPSETSTG>) => (status :: <HRESULT>)
  IPropertyStorage_Stat(This, pstatpsstg)
end;


	/*  ----  IPropertySetStorage  ----  */


define open primary COM-interface <IPropertySetStorage> ( <IUnknown> )
end <IPropertySetStorage>;

define C-address IPropertySetStorage_DW_vtbl :: <C-COM-vtbl>
		c-name: "IPropertySetStorage_DW_vtbl"; end;
define C-address $IID-IPropertySetStorage :: <REFIID>
		c-name: "IID_IPropertySetStorage"; end;

define method initialize ( This :: <IPropertySetStorage>, #rest ignore, #key );
  next-method();
  This.vtbl := IPropertySetStorage_DW_vtbl;
  add-interface(This, $IID-IPropertySetStorage);
end initialize;

define open generic IPropertySetStorage/Create (This, rfmtid,
		pclsid, grfFlags, grfMode)
		=> (status :: <HRESULT>, pprstg :: <Interface>);

define C-callable-wrapper of IPropertySetStorage/Create
  input parameter This :: <mapped-interface>;
  input parameter rfmtid :: <REFFMTID>;
  /* constant */ input parameter pclsid :: <LPCLSID>;
  input parameter grfFlags :: <DWORD>;
  input parameter grfMode :: <DWORD>;
  output parameter ppprstg :: <Interface*>;
  result status :: <C-HRESULT>;
  c-name: "DW_IPropertySetStorage_Create",
		c-modifiers: "__stdcall";
end;

define inline-only C-function IPropertySetStorage_Create
  input parameter This :: <C-interface>;
  input parameter rfmtid :: <REFFMTID>;
  /* constant */ input parameter pclsid :: <LPCLSID>;
  input parameter grfFlags :: <DWORD>;
  input parameter grfMode :: <DWORD>;
  output parameter ppprstg :: <C-interface*>;
  result status :: <C-HRESULT>;
  c-name: "C_IPropertySetStorage_Create";
end;

define method IPropertySetStorage/Create(This :: <C-interface>,
		rfmtid :: <REFFMTID>, pclsid :: <LPCLSID>,
		grfFlags :: <ffi-integer>, grfMode :: <ffi-integer>)
		=> (status :: <HRESULT>, pprstg :: <Interface>)
  IPropertySetStorage_Create(This, rfmtid, pclsid, grfFlags,
		grfMode)
end;

define open generic IPropertySetStorage/Open (This, rfmtid,
		grfMode) => (status :: <HRESULT>, pprstg :: <Interface>);

define C-callable-wrapper of IPropertySetStorage/Open
  input parameter This :: <mapped-interface>;
  input parameter rfmtid :: <REFFMTID>;
  input parameter grfMode :: <DWORD>;
  output parameter ppprstg :: <Interface*>;
  result status :: <C-HRESULT>;
  c-name: "DW_IPropertySetStorage_Open",
		c-modifiers: "__stdcall";
end;

define inline-only C-function IPropertySetStorage_Open
  input parameter This :: <C-interface>;
  input parameter rfmtid :: <REFFMTID>;
  input parameter grfMode :: <DWORD>;
  output parameter ppprstg :: <C-interface*>;
  result status :: <C-HRESULT>;
  c-name: "C_IPropertySetStorage_Open";
end;

define method IPropertySetStorage/Open(This :: <C-interface>,
		rfmtid :: <REFFMTID>, grfMode :: <ffi-integer>)
		=> (status :: <HRESULT>, pprstg :: <Interface>)
  IPropertySetStorage_Open(This, rfmtid, grfMode)
end;

define open generic IPropertySetStorage/Delete (This, rfmtid)
		=> (status :: <HRESULT>);

define C-callable-wrapper of IPropertySetStorage/Delete
  input parameter This :: <mapped-interface>;
  input parameter rfmtid :: <REFFMTID>;
  result status :: <C-HRESULT>;
  c-name: "DW_IPropertySetStorage_Delete",
		c-modifiers: "__stdcall";
end;

define inline-only C-function IPropertySetStorage_Delete
  input parameter This :: <C-interface>;
  input parameter rfmtid :: <REFFMTID>;
  result status :: <C-HRESULT>;
  c-name: "C_IPropertySetStorage_Delete";
end;

define method IPropertySetStorage/Delete(This :: <C-interface>,
		rfmtid :: <REFFMTID>) => (status :: <HRESULT>)
  IPropertySetStorage_Delete(This, rfmtid)
end;

define open generic IPropertySetStorage/Enum (This)
		=> (status :: <HRESULT>, penum :: <Interface>);

define C-callable-wrapper of IPropertySetStorage/Enum
  input parameter This :: <mapped-interface>;
  output parameter ppenum :: <Interface*>;
  result status :: <C-HRESULT>;
  c-name: "DW_IPropertySetStorage_Enum",
		c-modifiers: "__stdcall";
end;

define inline-only C-function IPropertySetStorage_Enum
  input parameter This :: <C-interface>;
  output parameter ppenum :: <C-interface*>;
  result status :: <C-HRESULT>;
  c-name: "C_IPropertySetStorage_Enum";
end;

define method IPropertySetStorage/Enum(This :: <C-interface>)
		=> (status :: <HRESULT>, penum :: <Interface>)
  IPropertySetStorage_Enum(This)
end;


	/*  ----  IEnumSTATPROPSTG  ----  */


define open primary COM-interface <IEnumSTATPROPSTG> ( <IUnknown> )
end <IEnumSTATPROPSTG>;

define C-address IEnumSTATPROPSTG_DW_vtbl :: <C-COM-vtbl>
		c-name: "IEnumSTATPROPSTG_DW_vtbl"; end;
define C-address $IID-IEnumSTATPROPSTG :: <REFIID>
		c-name: "IID_IEnumSTATPROPSTG"; end;

define method initialize ( This :: <IEnumSTATPROPSTG>, #rest ignore, #key );
  next-method();
  This.vtbl := IEnumSTATPROPSTG_DW_vtbl;
  add-interface(This, $IID-IEnumSTATPROPSTG);
end initialize;

define open generic IEnumSTATPROPSTG/Next (This, celt, rgelt)
		=> (status :: <HRESULT>, celtFetched);

define C-callable-wrapper of IEnumSTATPROPSTG/Next
  input parameter This :: <mapped-interface>;
  input parameter celt :: <ULONG>;
   parameter rgelt :: <LPSTATPROPSTG>;
  output parameter pceltFetched :: <LPULONG>;
  result status :: <C-HRESULT>;
  c-name: "DW_IEnumSTATPROPSTG_Next", c-modifiers: "__stdcall";
end;

define inline-only C-function IEnumSTATPROPSTG_Next
  input parameter This :: <C-interface>;
  input parameter celt :: <ULONG>;
   parameter rgelt :: <LPSTATPROPSTG>;
  output parameter pceltFetched :: <LPULONG>;
  result status :: <C-HRESULT>;
  c-name: "C_IEnumSTATPROPSTG_Next";
end;

define method IEnumSTATPROPSTG/Next(This :: <C-interface>,
		celt :: <ffi-integer>, rgelt :: <LPSTATPROPSTG>)
		=> (status :: <HRESULT>, celtFetched)
  IEnumSTATPROPSTG_Next(This, celt, rgelt)
end;

define open generic IEnumSTATPROPSTG/Skip (This, celt)
		=> (status :: <HRESULT>);

define C-callable-wrapper of IEnumSTATPROPSTG/Skip
  input parameter This :: <mapped-interface>;
  input parameter celt :: <ULONG>;
  result status :: <C-HRESULT>;
  c-name: "DW_IEnumSTATPROPSTG_Skip", c-modifiers: "__stdcall";
end;

define inline-only C-function IEnumSTATPROPSTG_Skip
  input parameter This :: <C-interface>;
  input parameter celt :: <ULONG>;
  result status :: <C-HRESULT>;
  c-name: "C_IEnumSTATPROPSTG_Skip";
end;

define method IEnumSTATPROPSTG/Skip(This :: <C-interface>,
		celt :: <ffi-integer>) => (status :: <HRESULT>)
  IEnumSTATPROPSTG_Skip(This, celt)
end;

define open generic IEnumSTATPROPSTG/Reset (This)
		=> (status :: <HRESULT>);

define C-callable-wrapper of IEnumSTATPROPSTG/Reset
  input parameter This :: <mapped-interface>;
  result status :: <C-HRESULT>;
  c-name: "DW_IEnumSTATPROPSTG_Reset", c-modifiers: "__stdcall";
end;

define inline-only C-function IEnumSTATPROPSTG_Reset
  input parameter This :: <C-interface>;
  result status :: <C-HRESULT>;
  c-name: "C_IEnumSTATPROPSTG_Reset";
end;

define method IEnumSTATPROPSTG/Reset(This :: <C-interface>)
		=> (status :: <HRESULT>)
  IEnumSTATPROPSTG_Reset(This)
end;

define open generic IEnumSTATPROPSTG/Clone (This)
		=> (status :: <HRESULT>, penum :: <Interface>);

define C-callable-wrapper of IEnumSTATPROPSTG/Clone
  input parameter This :: <mapped-interface>;
  output parameter ppenum :: <Interface*>;
  result status :: <C-HRESULT>;
  c-name: "DW_IEnumSTATPROPSTG_Clone", c-modifiers: "__stdcall";
end;

define inline-only C-function IEnumSTATPROPSTG_Clone
  input parameter This :: <C-interface>;
  output parameter ppenum :: <C-interface*>;
  result status :: <C-HRESULT>;
  c-name: "C_IEnumSTATPROPSTG_Clone";
end;

define method IEnumSTATPROPSTG/Clone(This :: <C-interface>)
		=> (status :: <HRESULT>, penum :: <Interface>)
  IEnumSTATPROPSTG_Clone(This)
end;


	/*  ----  IEnumSTATPROPSETSTG  ----  */


define open primary COM-interface <IEnumSTATPROPSETSTG> ( <IUnknown> )
end <IEnumSTATPROPSETSTG>;

define C-address IEnumSTATPROPSETSTG_DW_vtbl :: <C-COM-vtbl>
		c-name: "IEnumSTATPROPSETSTG_DW_vtbl"; end;
define C-address $IID-IEnumSTATPROPSETSTG :: <REFIID>
		c-name: "IID_IEnumSTATPROPSETSTG"; end;

define method initialize ( This :: <IEnumSTATPROPSETSTG>, #rest ignore, #key );
  next-method();
  This.vtbl := IEnumSTATPROPSETSTG_DW_vtbl;
  add-interface(This, $IID-IEnumSTATPROPSETSTG);
end initialize;

define open generic IEnumSTATPROPSETSTG/Next (This, celt, rgelt)
		=> (status :: <HRESULT>, celtFetched);

define C-callable-wrapper of IEnumSTATPROPSETSTG/Next
  input parameter This :: <mapped-interface>;
  input parameter celt :: <ULONG>;
   parameter rgelt :: <LPSTATPROPSETSTG>;
  output parameter pceltFetched :: <LPULONG>;
  result status :: <C-HRESULT>;
  c-name: "DW_IEnumSTATPROPSETSTG_Next",
		c-modifiers: "__stdcall";
end;

define inline-only C-function IEnumSTATPROPSETSTG_Next
  input parameter This :: <C-interface>;
  input parameter celt :: <ULONG>;
   parameter rgelt :: <LPSTATPROPSETSTG>;
  output parameter pceltFetched :: <LPULONG>;
  result status :: <C-HRESULT>;
  c-name: "C_IEnumSTATPROPSETSTG_Next";
end;

define method IEnumSTATPROPSETSTG/Next(This :: <C-interface>,
		celt :: <ffi-integer>, rgelt :: <LPSTATPROPSETSTG>)
		=> (status :: <HRESULT>, celtFetched)
  IEnumSTATPROPSETSTG_Next(This, celt, rgelt)
end;

define open generic IEnumSTATPROPSETSTG/Skip (This, celt)
		=> (status :: <HRESULT>);

define C-callable-wrapper of IEnumSTATPROPSETSTG/Skip
  input parameter This :: <mapped-interface>;
  input parameter celt :: <ULONG>;
  result status :: <C-HRESULT>;
  c-name: "DW_IEnumSTATPROPSETSTG_Skip",
		c-modifiers: "__stdcall";
end;

define inline-only C-function IEnumSTATPROPSETSTG_Skip
  input parameter This :: <C-interface>;
  input parameter celt :: <ULONG>;
  result status :: <C-HRESULT>;
  c-name: "C_IEnumSTATPROPSETSTG_Skip";
end;

define method IEnumSTATPROPSETSTG/Skip(This :: <C-interface>,
		celt :: <ffi-integer>) => (status :: <HRESULT>)
  IEnumSTATPROPSETSTG_Skip(This, celt)
end;

define open generic IEnumSTATPROPSETSTG/Reset (This)
		=> (status :: <HRESULT>);

define C-callable-wrapper of IEnumSTATPROPSETSTG/Reset
  input parameter This :: <mapped-interface>;
  result status :: <C-HRESULT>;
  c-name: "DW_IEnumSTATPROPSETSTG_Reset",
		c-modifiers: "__stdcall";
end;

define inline-only C-function IEnumSTATPROPSETSTG_Reset
  input parameter This :: <C-interface>;
  result status :: <C-HRESULT>;
  c-name: "C_IEnumSTATPROPSETSTG_Reset";
end;

define method IEnumSTATPROPSETSTG/Reset(This :: <C-interface>)
		=> (status :: <HRESULT>)
  IEnumSTATPROPSETSTG_Reset(This)
end;

define open generic IEnumSTATPROPSETSTG/Clone (This)
		=> (status :: <HRESULT>, penum :: <Interface>);

define C-callable-wrapper of IEnumSTATPROPSETSTG/Clone
  input parameter This :: <mapped-interface>;
  output parameter ppenum :: <Interface*>;
  result status :: <C-HRESULT>;
  c-name: "DW_IEnumSTATPROPSETSTG_Clone",
		c-modifiers: "__stdcall";
end;

define inline-only C-function IEnumSTATPROPSETSTG_Clone
  input parameter This :: <C-interface>;
  output parameter ppenum :: <C-interface*>;
  result status :: <C-HRESULT>;
  c-name: "C_IEnumSTATPROPSETSTG_Clone";
end;

define method IEnumSTATPROPSETSTG/Clone(This :: <C-interface>)
		=> (status :: <HRESULT>, penum :: <Interface>)
  IEnumSTATPROPSETSTG_Clone(This)
end;


	/*  ----  IFillLockBytes  ----  */



	/*  ----  IProgressNotify  ----  */



	/*  ----  ILayoutStorage  ----  */


define C-address $IID-ILayoutStorage :: <REFIID>
		c-name: "IID_ILayoutStorage"; end;


define open generic ILayoutStorage/LayoutScript (This,
		pStorageLayout, nEntries, glfInterleavedFlag)
		=> (status :: <HRESULT>);

define inline-only C-function ILayoutStorage_LayoutScript
  input parameter This :: <C-interface>;
  input parameter pStorageLayout :: <LPStorageLayout>;
  input parameter nEntries :: <DWORD>;
  input parameter glfInterleavedFlag :: <DWORD>;
  result status :: <C-HRESULT>;
  c-name: "C_ILayoutStorage_LayoutScript";
end;

define method ILayoutStorage/LayoutScript(This :: <C-interface>,
		pStorageLayout :: <LPStorageLayout>, nEntries :: <ffi-integer>,
		glfInterleavedFlag :: <ffi-integer>) => (status :: <HRESULT>)
  ILayoutStorage_LayoutScript(This, pStorageLayout, nEntries,
		glfInterleavedFlag)
end;

define open generic ILayoutStorage/BeginMonitor (This)
		=> (status :: <HRESULT>);

define inline-only C-function ILayoutStorage_BeginMonitor
  input parameter This :: <C-interface>;
  result status :: <C-HRESULT>;
  c-name: "C_ILayoutStorage_BeginMonitor";
end;

define method ILayoutStorage/BeginMonitor(This :: <C-interface>)
		=> (status :: <HRESULT>)
  ILayoutStorage_BeginMonitor(This)
end;

define open generic ILayoutStorage/EndMonitor (This)
		=> (status :: <HRESULT>);

define inline-only C-function ILayoutStorage_EndMonitor
  input parameter This :: <C-interface>;
  result status :: <C-HRESULT>;
  c-name: "C_ILayoutStorage_EndMonitor";
end;

define method ILayoutStorage/EndMonitor(This :: <C-interface>)
		=> (status :: <HRESULT>)
  ILayoutStorage_EndMonitor(This)
end;

define open generic ILayoutStorage/ReLayoutDocfile (This,
		pwcsNewDfName) => (status :: <HRESULT>);

define inline-only C-function ILayoutStorage_ReLayoutDocfile
  input parameter This :: <C-interface>;
  input parameter pwcsNewDfName :: <C-unicode-string>;
  result status :: <C-HRESULT>;
  c-name: "C_ILayoutStorage_ReLayoutDocfile";
end;

define method ILayoutStorage/ReLayoutDocfile(This :: <C-interface>,
		pwcsNewDfName :: <C-unicode-string>) => (status :: <HRESULT>)
  ILayoutStorage_ReLayoutDocfile(This, pwcsNewDfName)
end;

define open generic ILayoutStorage/ReLayoutDocfileOnILockBytes
		(This, pILockBytes) => (status :: <HRESULT>);

define inline-only C-function ILayoutStorage_ReLayoutDocfileOnILockBytes
  input parameter This :: <C-interface>;
  input parameter pILockBytes :: <Interface>;
  result status :: <C-HRESULT>;
  c-name: "C_ILayoutStorage_ReLayoutDocfileOnILockBytes";
end;

define method ILayoutStorage/ReLayoutDocfileOnILockBytes(This :: <C-interface>,
		pILockBytes :: <Interface>) => (status :: <HRESULT>)
  ILayoutStorage_ReLayoutDocfileOnILockBytes(This, pILockBytes)
end;


	/*  ----  ISurrogate  ----  */



	/*  ----  IGlobalInterfaceTable  ----  */



	/*  ----  IDirectWriterLock  ----  */


define C-address $IID-IDirectWriterLock :: <REFIID>
		c-name: "IID_IDirectWriterLock"; end;


define open generic IDirectWriterLock/WaitForWriteAccess (This,
		dwTimeout) => (status :: <HRESULT>);

define inline-only C-function IDirectWriterLock_WaitForWriteAccess
  input parameter This :: <C-interface>;
  input parameter dwTimeout :: <DWORD>;
  result status :: <C-HRESULT>;
  c-name: "C_IDirectWriterLock_WaitForWriteAccess";
end;

define method IDirectWriterLock/WaitForWriteAccess(This :: <C-interface>,
		dwTimeout :: <ffi-integer>) => (status :: <HRESULT>)
  IDirectWriterLock_WaitForWriteAccess(This, dwTimeout)
end;

define open generic IDirectWriterLock/ReleaseWriteAccess (This)
		=> (status :: <HRESULT>);

define inline-only C-function IDirectWriterLock_ReleaseWriteAccess
  input parameter This :: <C-interface>;
  result status :: <C-HRESULT>;
  c-name: "C_IDirectWriterLock_ReleaseWriteAccess";
end;

define method IDirectWriterLock/ReleaseWriteAccess(This :: <C-interface>)
		=> (status :: <HRESULT>)
  IDirectWriterLock_ReleaseWriteAccess(This)
end;

define open generic IDirectWriterLock/HaveWriteAccess (This)
		=> (status :: <HRESULT>);

define inline-only C-function IDirectWriterLock_HaveWriteAccess
  input parameter This :: <C-interface>;
  result status :: <C-HRESULT>;
  c-name: "C_IDirectWriterLock_HaveWriteAccess";
end;

define method IDirectWriterLock/HaveWriteAccess(This :: <C-interface>)
		=> (status :: <HRESULT>)
  IDirectWriterLock_HaveWriteAccess(This)
end;


	/*  ----  ISynchronize  ----  */



	/*  ----  ISynchronizeMutex  ----  */



	/*  ----  IAsyncSetup  ----  */



	/*  ----  ICancelMethodCalls  ----  */


define C-address $IID-ICancelMethodCalls :: <REFIID>
		c-name: "IID_ICancelMethodCalls"; end;


define open generic ICancelMethodCalls/Cancel (This, ulSeconds)
		=> (status :: <HRESULT>);

define inline-only C-function ICancelMethodCalls_Cancel
  input parameter This :: <C-interface>;
  input parameter ulSeconds :: <ULONG>;
  result status :: <C-HRESULT>;
  c-name: "C_ICancelMethodCalls_Cancel";
end;

define method ICancelMethodCalls/Cancel(This :: <C-interface>,
		ulSeconds :: <ffi-integer>) => (status :: <HRESULT>)
  ICancelMethodCalls_Cancel(This, ulSeconds)
end;

define open generic ICancelMethodCalls/TestCancel (This)
		=> (status :: <HRESULT>);

define inline-only C-function ICancelMethodCalls_TestCancel
  input parameter This :: <C-interface>;
  result status :: <C-HRESULT>;
  c-name: "C_ICancelMethodCalls_TestCancel";
end;

define method ICancelMethodCalls/TestCancel(This :: <C-interface>)
		=> (status :: <HRESULT>)
  ICancelMethodCalls_TestCancel(This)
end;



	/*  ----  IAsyncManager  ----  */



	/*  ----  IWaitMultiple  ----  */



	/*  ----  ISynchronizeEvent  ----  */



	/*  ----  IUrlMon  ----  */



