Module:  WIN32-Automation
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 oleauto.h; do not edit. */


// Adapted from:
//+---------------------------------------------------------------------------
//
//  Microsoft Windows
//
//  File:       oleauto.h
//
//  Contents:   Defines Ole Automation support function prototypes, constants
//
//----------------------------------------------------------------------------


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

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



	/*  ----  IOleAutomationTypes  ----  */



	/*  ----  ICreateTypeInfo  ----  */


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

define C-address ICreateTypeInfo_DW_vtbl :: <C-COM-vtbl>
		c-name: "ICreateTypeInfo_DW_vtbl"; end;
define C-address $IID-ICreateTypeInfo :: <REFIID>
		c-name: "IID_ICreateTypeInfo"; end;

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

define open generic ICreateTypeInfo/SetGuid (This, guid)
		=> (status :: <HRESULT>);

define C-callable-wrapper of ICreateTypeInfo/SetGuid
  input parameter This :: <mapped-interface>;
  input parameter guid :: <REFGUID>;
  result status :: <C-HRESULT>;
  c-name: "DW_ICreateTypeInfo_SetGuid",
		c-modifiers: "__stdcall";
end;

define inline-only C-function ICreateTypeInfo_SetGuid
  input parameter This :: <C-interface>;
  input parameter guid :: <REFGUID>;
  result status :: <C-HRESULT>;
  c-name: "C_ICreateTypeInfo_SetGuid";
end;

define method ICreateTypeInfo/SetGuid(This :: <C-interface>,
		guid :: <REFGUID>) => (status :: <HRESULT>)
  ICreateTypeInfo_SetGuid(This, guid)
end;

define open generic ICreateTypeInfo/SetTypeFlags (This,
		uTypeFlags) => (status :: <HRESULT>);

define C-callable-wrapper of ICreateTypeInfo/SetTypeFlags
  input parameter This :: <mapped-interface>;
  input parameter uTypeFlags :: <UINT>;
  result status :: <C-HRESULT>;
  c-name: "DW_ICreateTypeInfo_SetTypeFlags",
		c-modifiers: "__stdcall";
end;

define inline-only C-function ICreateTypeInfo_SetTypeFlags
  input parameter This :: <C-interface>;
  input parameter uTypeFlags :: <UINT>;
  result status :: <C-HRESULT>;
  c-name: "C_ICreateTypeInfo_SetTypeFlags";
end;

define method ICreateTypeInfo/SetTypeFlags(This :: <C-interface>,
		uTypeFlags :: <ffi-integer>) => (status :: <HRESULT>)
  ICreateTypeInfo_SetTypeFlags(This, uTypeFlags)
end;

define open generic ICreateTypeInfo/SetDocString (This, pStrDoc)
		=> (status :: <HRESULT>);

define C-callable-wrapper of ICreateTypeInfo/SetDocString
  input parameter This :: <mapped-interface>;
  input parameter pStrDoc :: <LPOLESTR>;
  result status :: <C-HRESULT>;
  c-name: "DW_ICreateTypeInfo_SetDocString",
		c-modifiers: "__stdcall";
end;

define inline-only C-function ICreateTypeInfo_SetDocString
  input parameter This :: <C-interface>;
  input parameter pStrDoc :: <LPOLESTR>;
  result status :: <C-HRESULT>;
  c-name: "C_ICreateTypeInfo_SetDocString";
end;

define method ICreateTypeInfo/SetDocString(This :: <C-interface>,
		pStrDoc :: <LPOLESTR>) => (status :: <HRESULT>)
  ICreateTypeInfo_SetDocString(This, pStrDoc)
end;

define open generic ICreateTypeInfo/SetHelpContext (This,
		dwHelpContext) => (status :: <HRESULT>);

define C-callable-wrapper of ICreateTypeInfo/SetHelpContext
  input parameter This :: <mapped-interface>;
  input parameter dwHelpContext :: <DWORD>;
  result status :: <C-HRESULT>;
  c-name: "DW_ICreateTypeInfo_SetHelpContext",
		c-modifiers: "__stdcall";
end;

define inline-only C-function ICreateTypeInfo_SetHelpContext
  input parameter This :: <C-interface>;
  input parameter dwHelpContext :: <DWORD>;
  result status :: <C-HRESULT>;
  c-name: "C_ICreateTypeInfo_SetHelpContext";
end;

define method ICreateTypeInfo/SetHelpContext(This :: <C-interface>,
		dwHelpContext :: <ffi-integer>) => (status :: <HRESULT>)
  ICreateTypeInfo_SetHelpContext(This, dwHelpContext)
end;

define open generic ICreateTypeInfo/SetVersion (This,
		wMajorVerNum, wMinorVerNum) => (status :: <HRESULT>);

define C-callable-wrapper of ICreateTypeInfo/SetVersion
  input parameter This :: <mapped-interface>;
  input parameter wMajorVerNum :: <WORD>;
  input parameter wMinorVerNum :: <WORD>;
  result status :: <C-HRESULT>;
  c-name: "DW_ICreateTypeInfo_SetVersion",
		c-modifiers: "__stdcall";
end;

define inline-only C-function ICreateTypeInfo_SetVersion
  input parameter This :: <C-interface>;
  input parameter wMajorVerNum :: <WORD>;
  input parameter wMinorVerNum :: <WORD>;
  result status :: <C-HRESULT>;
  c-name: "C_ICreateTypeInfo_SetVersion";
end;

define method ICreateTypeInfo/SetVersion(This :: <C-interface>,
		wMajorVerNum :: <integer>, wMinorVerNum :: <integer>) => (status :: <HRESULT>)
  ICreateTypeInfo_SetVersion(This, wMajorVerNum, wMinorVerNum)
end;

define open generic ICreateTypeInfo/AddRefTypeInfo (This, pTInfo)
		=> (status :: <HRESULT>, hreftype);

define C-callable-wrapper of ICreateTypeInfo/AddRefTypeInfo
  input parameter This :: <mapped-interface>;
  input parameter pTInfo :: <C-interface>;
  output parameter phreftype :: <LPHREFTYPE>;
  result status :: <C-HRESULT>;
  c-name: "DW_ICreateTypeInfo_AddRefTypeInfo",
		c-modifiers: "__stdcall";
end;

define inline-only C-function ICreateTypeInfo_AddRefTypeInfo
  input parameter This :: <C-interface>;
  input parameter pTInfo :: <Interface>;
  output parameter phreftype :: <LPHREFTYPE>;
  result status :: <C-HRESULT>;
  c-name: "C_ICreateTypeInfo_AddRefTypeInfo";
end;

define method ICreateTypeInfo/AddRefTypeInfo(This :: <C-interface>,
		pTInfo :: <Interface>) => (status :: <HRESULT>, hreftype)
  ICreateTypeInfo_AddRefTypeInfo(This, pTInfo)
end;

define open generic ICreateTypeInfo/AddFuncDesc (This, index,
		pFuncDesc) => (status :: <HRESULT>);

define C-callable-wrapper of ICreateTypeInfo/AddFuncDesc
  input parameter This :: <mapped-interface>;
  input parameter index :: <UINT>;
  input parameter pFuncDesc :: <LPFUNCDESC>;
  result status :: <C-HRESULT>;
  c-name: "DW_ICreateTypeInfo_AddFuncDesc",
		c-modifiers: "__stdcall";
end;

define inline-only C-function ICreateTypeInfo_AddFuncDesc
  input parameter This :: <C-interface>;
  input parameter index :: <UINT>;
  input parameter pFuncDesc :: <LPFUNCDESC>;
  result status :: <C-HRESULT>;
  c-name: "C_ICreateTypeInfo_AddFuncDesc";
end;

define method ICreateTypeInfo/AddFuncDesc(This :: <C-interface>,
		index :: <ffi-integer>, pFuncDesc :: <LPFUNCDESC>) => (status :: <HRESULT>)
  ICreateTypeInfo_AddFuncDesc(This, index, pFuncDesc)
end;

define open generic ICreateTypeInfo/AddImplType (This, index,
		hRefType) => (status :: <HRESULT>);

define C-callable-wrapper of ICreateTypeInfo/AddImplType
  input parameter This :: <mapped-interface>;
  input parameter index :: <UINT>;
  input parameter hRefType :: <HREFTYPE>;
  result status :: <C-HRESULT>;
  c-name: "DW_ICreateTypeInfo_AddImplType",
		c-modifiers: "__stdcall";
end;

define inline-only C-function ICreateTypeInfo_AddImplType
  input parameter This :: <C-interface>;
  input parameter index :: <UINT>;
  input parameter hRefType :: <HREFTYPE>;
  result status :: <C-HRESULT>;
  c-name: "C_ICreateTypeInfo_AddImplType";
end;

define method ICreateTypeInfo/AddImplType(This :: <C-interface>,
		index :: <ffi-integer>, hRefType :: <ffi-integer>) => (status :: <HRESULT>)
  ICreateTypeInfo_AddImplType(This, index, hRefType)
end;

define open generic ICreateTypeInfo/SetImplTypeFlags (This,
		index, implTypeFlags) => (status :: <HRESULT>);

define C-callable-wrapper of ICreateTypeInfo/SetImplTypeFlags
  input parameter This :: <mapped-interface>;
  input parameter index :: <UINT>;
  input parameter implTypeFlags :: <INT>;
  result status :: <C-HRESULT>;
  c-name: "DW_ICreateTypeInfo_SetImplTypeFlags",
		c-modifiers: "__stdcall";
end;

define inline-only C-function ICreateTypeInfo_SetImplTypeFlags
  input parameter This :: <C-interface>;
  input parameter index :: <UINT>;
  input parameter implTypeFlags :: <INT>;
  result status :: <C-HRESULT>;
  c-name: "C_ICreateTypeInfo_SetImplTypeFlags";
end;

define method ICreateTypeInfo/SetImplTypeFlags(This :: <C-interface>,
		index :: <integer>, implTypeFlags :: <integer>) => (status :: <HRESULT>)
  ICreateTypeInfo_SetImplTypeFlags(This, index, implTypeFlags)
end;

define open generic ICreateTypeInfo/SetAlignment (This,
		cbAlignment) => (status :: <HRESULT>);

define C-callable-wrapper of ICreateTypeInfo/SetAlignment
  input parameter This :: <mapped-interface>;
  input parameter cbAlignment :: <WORD>;
  result status :: <C-HRESULT>;
  c-name: "DW_ICreateTypeInfo_SetAlignment",
		c-modifiers: "__stdcall";
end;

define inline-only C-function ICreateTypeInfo_SetAlignment
  input parameter This :: <C-interface>;
  input parameter cbAlignment :: <WORD>;
  result status :: <C-HRESULT>;
  c-name: "C_ICreateTypeInfo_SetAlignment";
end;

define method ICreateTypeInfo/SetAlignment(This :: <C-interface>,
		cbAlignment :: <integer>) => (status :: <HRESULT>)
  ICreateTypeInfo_SetAlignment(This, cbAlignment)
end;

define open generic ICreateTypeInfo/SetSchema (This, pStrSchema)
		=> (status :: <HRESULT>);

define C-callable-wrapper of ICreateTypeInfo/SetSchema
  input parameter This :: <mapped-interface>;
  input parameter pStrSchema :: <LPOLESTR>;
  result status :: <C-HRESULT>;
  c-name: "DW_ICreateTypeInfo_SetSchema",
		c-modifiers: "__stdcall";
end;

define inline-only C-function ICreateTypeInfo_SetSchema
  input parameter This :: <C-interface>;
  input parameter pStrSchema :: <LPOLESTR>;
  result status :: <C-HRESULT>;
  c-name: "C_ICreateTypeInfo_SetSchema";
end;

define method ICreateTypeInfo/SetSchema(This :: <C-interface>,
		pStrSchema :: <LPOLESTR>) => (status :: <HRESULT>)
  ICreateTypeInfo_SetSchema(This, pStrSchema)
end;

define open generic ICreateTypeInfo/AddVarDesc (This, index,
		pVarDesc) => (status :: <HRESULT>);

define C-callable-wrapper of ICreateTypeInfo/AddVarDesc
  input parameter This :: <mapped-interface>;
  input parameter index :: <UINT>;
  input parameter pVarDesc :: <LPVARDESC>;
  result status :: <C-HRESULT>;
  c-name: "DW_ICreateTypeInfo_AddVarDesc",
		c-modifiers: "__stdcall";
end;

define inline-only C-function ICreateTypeInfo_AddVarDesc
  input parameter This :: <C-interface>;
  input parameter index :: <UINT>;
  input parameter pVarDesc :: <LPVARDESC>;
  result status :: <C-HRESULT>;
  c-name: "C_ICreateTypeInfo_AddVarDesc";
end;

define method ICreateTypeInfo/AddVarDesc(This :: <C-interface>,
		index :: <ffi-integer>, pVarDesc :: <LPVARDESC>) => (status :: <HRESULT>)
  ICreateTypeInfo_AddVarDesc(This, index, pVarDesc)
end;

define open generic ICreateTypeInfo/SetFuncAndParamNames (This,
		index, rgszNames, cNames) => (status :: <HRESULT>);

define C-callable-wrapper
		of ICreateTypeInfo/SetFuncAndParamNames
  input parameter This :: <mapped-interface>;
  input parameter index :: <UINT>;
  input parameter rgszNames :: <LPLPOLESTR>;
  input parameter cNames :: <UINT>;
  result status :: <C-HRESULT>;
  c-name: "DW_ICreateTypeInfo_SetFuncAndParamNames",
		c-modifiers: "__stdcall";
end;

define inline-only C-function ICreateTypeInfo_SetFuncAndParamNames
  input parameter This :: <C-interface>;
  input parameter index :: <UINT>;
  input parameter rgszNames :: <LPLPOLESTR>;
  input parameter cNames :: <UINT>;
  result status :: <C-HRESULT>;
  c-name: "C_ICreateTypeInfo_SetFuncAndParamNames";
end;

define method ICreateTypeInfo/SetFuncAndParamNames(This :: <C-interface>,
		index :: <ffi-integer>, rgszNames :: <LPLPOLESTR>, cNames :: <ffi-integer>)
		=> (status :: <HRESULT>)
  ICreateTypeInfo_SetFuncAndParamNames(This, index, rgszNames,
		cNames)
end;

define open generic ICreateTypeInfo/SetVarName (This, index,
		szName) => (status :: <HRESULT>);

define C-callable-wrapper of ICreateTypeInfo/SetVarName
  input parameter This :: <mapped-interface>;
  input parameter index :: <UINT>;
  input parameter szName :: <LPOLESTR>;
  result status :: <C-HRESULT>;
  c-name: "DW_ICreateTypeInfo_SetVarName",
		c-modifiers: "__stdcall";
end;

define inline-only C-function ICreateTypeInfo_SetVarName
  input parameter This :: <C-interface>;
  input parameter index :: <UINT>;
  input parameter szName :: <LPOLESTR>;
  result status :: <C-HRESULT>;
  c-name: "C_ICreateTypeInfo_SetVarName";
end;

define method ICreateTypeInfo/SetVarName(This :: <C-interface>,
		index :: <ffi-integer>, szName :: <LPOLESTR>) => (status :: <HRESULT>)
  ICreateTypeInfo_SetVarName(This, index, szName)
end;

define open generic ICreateTypeInfo/SetTypeDescAlias (This,
		pTDescAlias) => (status :: <HRESULT>);

define C-callable-wrapper of ICreateTypeInfo/SetTypeDescAlias
  input parameter This :: <mapped-interface>;
  input parameter pTDescAlias :: <LPTYPEDESC>;
  result status :: <C-HRESULT>;
  c-name: "DW_ICreateTypeInfo_SetTypeDescAlias",
		c-modifiers: "__stdcall";
end;

define inline-only C-function ICreateTypeInfo_SetTypeDescAlias
  input parameter This :: <C-interface>;
  input parameter pTDescAlias :: <LPTYPEDESC>;
  result status :: <C-HRESULT>;
  c-name: "C_ICreateTypeInfo_SetTypeDescAlias";
end;

define method ICreateTypeInfo/SetTypeDescAlias(This :: <C-interface>,
		pTDescAlias :: <LPTYPEDESC>) => (status :: <HRESULT>)
  ICreateTypeInfo_SetTypeDescAlias(This, pTDescAlias)
end;

define open generic ICreateTypeInfo/DefineFuncAsDllEntry (This,
		index, szDllName, szProcName) => (status :: <HRESULT>);

define C-callable-wrapper
		of ICreateTypeInfo/DefineFuncAsDllEntry
  input parameter This :: <mapped-interface>;
  input parameter index :: <UINT>;
  input parameter szDllName :: <LPOLESTR>;
  input parameter szProcName :: <LPOLESTR>;
  result status :: <C-HRESULT>;
  c-name: "DW_ICreateTypeInfo_DefineFuncAsDllEntry",
		c-modifiers: "__stdcall";
end;

define inline-only C-function ICreateTypeInfo_DefineFuncAsDllEntry
  input parameter This :: <C-interface>;
  input parameter index :: <UINT>;
  input parameter szDllName :: <LPOLESTR>;
  input parameter szProcName :: <LPOLESTR>;
  result status :: <C-HRESULT>;
  c-name: "C_ICreateTypeInfo_DefineFuncAsDllEntry";
end;

define method ICreateTypeInfo/DefineFuncAsDllEntry(This :: <C-interface>,
		index :: <ffi-integer>, szDllName :: <LPOLESTR>, szProcName :: <LPOLESTR>)
		=> (status :: <HRESULT>)
  ICreateTypeInfo_DefineFuncAsDllEntry(This, index, szDllName,
		szProcName)
end;

define open generic ICreateTypeInfo/SetFuncDocString (This,
		index, szDocString) => (status :: <HRESULT>);

define C-callable-wrapper of ICreateTypeInfo/SetFuncDocString
  input parameter This :: <mapped-interface>;
  input parameter index :: <UINT>;
  input parameter szDocString :: <LPOLESTR>;
  result status :: <C-HRESULT>;
  c-name: "DW_ICreateTypeInfo_SetFuncDocString",
		c-modifiers: "__stdcall";
end;

define inline-only C-function ICreateTypeInfo_SetFuncDocString
  input parameter This :: <C-interface>;
  input parameter index :: <UINT>;
  input parameter szDocString :: <LPOLESTR>;
  result status :: <C-HRESULT>;
  c-name: "C_ICreateTypeInfo_SetFuncDocString";
end;

define method ICreateTypeInfo/SetFuncDocString(This :: <C-interface>,
		index :: <integer>, szDocString :: <LPOLESTR>) => (status :: <HRESULT>)
  ICreateTypeInfo_SetFuncDocString(This, index, szDocString)
end;

define open generic ICreateTypeInfo/SetVarDocString (This, index,
		szDocString) => (status :: <HRESULT>);

define C-callable-wrapper of ICreateTypeInfo/SetVarDocString
  input parameter This :: <mapped-interface>;
  input parameter index :: <UINT>;
  input parameter szDocString :: <LPOLESTR>;
  result status :: <C-HRESULT>;
  c-name: "DW_ICreateTypeInfo_SetVarDocString",
		c-modifiers: "__stdcall";
end;

define inline-only C-function ICreateTypeInfo_SetVarDocString
  input parameter This :: <C-interface>;
  input parameter index :: <UINT>;
  input parameter szDocString :: <LPOLESTR>;
  result status :: <C-HRESULT>;
  c-name: "C_ICreateTypeInfo_SetVarDocString";
end;

define method ICreateTypeInfo/SetVarDocString(This :: <C-interface>,
		index :: <integer>, szDocString :: <LPOLESTR>) => (status :: <HRESULT>)
  ICreateTypeInfo_SetVarDocString(This, index, szDocString)
end;

define open generic ICreateTypeInfo/SetFuncHelpContext (This,
		index, dwHelpContext) => (status :: <HRESULT>);

define C-callable-wrapper of ICreateTypeInfo/SetFuncHelpContext
  input parameter This :: <mapped-interface>;
  input parameter index :: <UINT>;
  input parameter dwHelpContext :: <DWORD>;
  result status :: <C-HRESULT>;
  c-name: "DW_ICreateTypeInfo_SetFuncHelpContext",
		c-modifiers: "__stdcall";
end;

define inline-only C-function ICreateTypeInfo_SetFuncHelpContext
  input parameter This :: <C-interface>;
  input parameter index :: <UINT>;
  input parameter dwHelpContext :: <DWORD>;
  result status :: <C-HRESULT>;
  c-name: "C_ICreateTypeInfo_SetFuncHelpContext";
end;

define method ICreateTypeInfo/SetFuncHelpContext(This :: <C-interface>,
		index :: <integer>, dwHelpContext :: <ffi-integer>) => (status :: <HRESULT>)
  ICreateTypeInfo_SetFuncHelpContext(This, index, dwHelpContext)
end;

define open generic ICreateTypeInfo/SetVarHelpContext (This,
		index, dwHelpContext) => (status :: <HRESULT>);

define C-callable-wrapper of ICreateTypeInfo/SetVarHelpContext
  input parameter This :: <mapped-interface>;
  input parameter index :: <UINT>;
  input parameter dwHelpContext :: <DWORD>;
  result status :: <C-HRESULT>;
  c-name: "DW_ICreateTypeInfo_SetVarHelpContext",
		c-modifiers: "__stdcall";
end;

define inline-only C-function ICreateTypeInfo_SetVarHelpContext
  input parameter This :: <C-interface>;
  input parameter index :: <UINT>;
  input parameter dwHelpContext :: <DWORD>;
  result status :: <C-HRESULT>;
  c-name: "C_ICreateTypeInfo_SetVarHelpContext";
end;

define method ICreateTypeInfo/SetVarHelpContext(This :: <C-interface>,
		index :: <integer>, dwHelpContext :: <ffi-integer>) => (status :: <HRESULT>)
  ICreateTypeInfo_SetVarHelpContext(This, index, dwHelpContext)
end;

define open generic ICreateTypeInfo/SetMops (This, index,
		bstrMops) => (status :: <HRESULT>);

define C-callable-wrapper of ICreateTypeInfo/SetMops
  input parameter This :: <mapped-interface>;
  input parameter index :: <UINT>;
  input parameter bstrMops :: <BSTR>;
  result status :: <C-HRESULT>;
  c-name: "DW_ICreateTypeInfo_SetMops",
		c-modifiers: "__stdcall";
end;

define inline-only C-function ICreateTypeInfo_SetMops
  input parameter This :: <C-interface>;
  input parameter index :: <UINT>;
  input parameter bstrMops :: <BSTR>;
  result status :: <C-HRESULT>;
  c-name: "C_ICreateTypeInfo_SetMops";
end;

define method ICreateTypeInfo/SetMops(This :: <C-interface>,
		index :: <ffi-integer>, bstrMops :: <BSTR>) => (status :: <HRESULT>)
  ICreateTypeInfo_SetMops(This, index, bstrMops)
end;

define open generic ICreateTypeInfo/SetTypeIdldesc (This,
		pIdlDesc) => (status :: <HRESULT>);

define C-callable-wrapper of ICreateTypeInfo/SetTypeIdldesc
  input parameter This :: <mapped-interface>;
  input parameter pIdlDesc :: <LPIDLDESC>;
  result status :: <C-HRESULT>;
  c-name: "DW_ICreateTypeInfo_SetTypeIdldesc",
		c-modifiers: "__stdcall";
end;

define inline-only C-function ICreateTypeInfo_SetTypeIdldesc
  input parameter This :: <C-interface>;
  input parameter pIdlDesc :: <LPIDLDESC>;
  result status :: <C-HRESULT>;
  c-name: "C_ICreateTypeInfo_SetTypeIdldesc";
end;

define method ICreateTypeInfo/SetTypeIdldesc(This :: <C-interface>,
		pIdlDesc :: <LPIDLDESC>) => (status :: <HRESULT>)
  ICreateTypeInfo_SetTypeIdldesc(This, pIdlDesc)
end;

define open generic ICreateTypeInfo/LayOut (This)
		=> (status :: <HRESULT>);

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

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

define method ICreateTypeInfo/LayOut(This :: <C-interface>)
		=> (status :: <HRESULT>)
  ICreateTypeInfo_LayOut(This)
end;


	/*  ----  ICreateTypeInfo2  ----  */


define open primary COM-interface <ICreateTypeInfo2> ( <ICreateTypeInfo> )
end <ICreateTypeInfo2>;

define C-address ICreateTypeInfo2_DW_vtbl :: <C-COM-vtbl>
		c-name: "ICreateTypeInfo2_DW_vtbl"; end;
define C-address $IID-ICreateTypeInfo2 :: <REFIID>
		c-name: "IID_ICreateTypeInfo2"; end;

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

define open generic ICreateTypeInfo2/DeleteFuncDesc (This, index)
		=> (status :: <HRESULT>);

define C-callable-wrapper of ICreateTypeInfo2/DeleteFuncDesc
  input parameter This :: <mapped-interface>;
  input parameter index :: <UINT>;
  result status :: <C-HRESULT>;
  c-name: "DW_ICreateTypeInfo2_DeleteFuncDesc",
		c-modifiers: "__stdcall";
end;

define inline-only C-function ICreateTypeInfo2_DeleteFuncDesc
  input parameter This :: <C-interface>;
  input parameter index :: <UINT>;
  result status :: <C-HRESULT>;
  c-name: "C_ICreateTypeInfo2_DeleteFuncDesc";
end;

define method ICreateTypeInfo2/DeleteFuncDesc(This :: <C-interface>,
		index :: <integer>) => (status :: <HRESULT>)
  ICreateTypeInfo2_DeleteFuncDesc(This, index)
end;

define open generic ICreateTypeInfo2/DeleteFuncDescByMemId (This,
		memid, invKind) => (status :: <HRESULT>);

define C-callable-wrapper
		of ICreateTypeInfo2/DeleteFuncDescByMemId
  input parameter This :: <mapped-interface>;
  input parameter memid :: <MEMBERID>;
  input parameter invKind :: <INVOKEKIND>;
  result status :: <C-HRESULT>;
  c-name: "DW_ICreateTypeInfo2_DeleteFuncDescByMemId",
		c-modifiers: "__stdcall";
end;

define inline-only C-function ICreateTypeInfo2_DeleteFuncDescByMemId
  input parameter This :: <C-interface>;
  input parameter memid :: <MEMBERID>;
  input parameter invKind :: <INVOKEKIND>;
  result status :: <C-HRESULT>;
  c-name: "C_ICreateTypeInfo2_DeleteFuncDescByMemId";
end;

define method ICreateTypeInfo2/DeleteFuncDescByMemId(This :: <C-interface>,
		memid :: <ffi-integer>, invKind :: <integer>) => (status :: <HRESULT>)
  ICreateTypeInfo2_DeleteFuncDescByMemId(This, memid, invKind)
end;

define open generic ICreateTypeInfo2/DeleteVarDesc (This, index)
		=> (status :: <HRESULT>);

define C-callable-wrapper of ICreateTypeInfo2/DeleteVarDesc
  input parameter This :: <mapped-interface>;
  input parameter index :: <UINT>;
  result status :: <C-HRESULT>;
  c-name: "DW_ICreateTypeInfo2_DeleteVarDesc",
		c-modifiers: "__stdcall";
end;

define inline-only C-function ICreateTypeInfo2_DeleteVarDesc
  input parameter This :: <C-interface>;
  input parameter index :: <UINT>;
  result status :: <C-HRESULT>;
  c-name: "C_ICreateTypeInfo2_DeleteVarDesc";
end;

define method ICreateTypeInfo2/DeleteVarDesc(This :: <C-interface>,
		index :: <integer>) => (status :: <HRESULT>)
  ICreateTypeInfo2_DeleteVarDesc(This, index)
end;

define open generic ICreateTypeInfo2/DeleteVarDescByMemId (This,
		memid) => (status :: <HRESULT>);

define C-callable-wrapper
		of ICreateTypeInfo2/DeleteVarDescByMemId
  input parameter This :: <mapped-interface>;
  input parameter memid :: <MEMBERID>;
  result status :: <C-HRESULT>;
  c-name: "DW_ICreateTypeInfo2_DeleteVarDescByMemId",
		c-modifiers: "__stdcall";
end;

define inline-only C-function ICreateTypeInfo2_DeleteVarDescByMemId
  input parameter This :: <C-interface>;
  input parameter memid :: <MEMBERID>;
  result status :: <C-HRESULT>;
  c-name: "C_ICreateTypeInfo2_DeleteVarDescByMemId";
end;

define method ICreateTypeInfo2/DeleteVarDescByMemId(This :: <C-interface>,
		memid :: <ffi-integer>) => (status :: <HRESULT>)
  ICreateTypeInfo2_DeleteVarDescByMemId(This, memid)
end;

define open generic ICreateTypeInfo2/DeleteImplType (This, index)
		=> (status :: <HRESULT>);

define C-callable-wrapper of ICreateTypeInfo2/DeleteImplType
  input parameter This :: <mapped-interface>;
  input parameter index :: <UINT>;
  result status :: <C-HRESULT>;
  c-name: "DW_ICreateTypeInfo2_DeleteImplType",
		c-modifiers: "__stdcall";
end;

define inline-only C-function ICreateTypeInfo2_DeleteImplType
  input parameter This :: <C-interface>;
  input parameter index :: <UINT>;
  result status :: <C-HRESULT>;
  c-name: "C_ICreateTypeInfo2_DeleteImplType";
end;

define method ICreateTypeInfo2/DeleteImplType(This :: <C-interface>,
		index :: <integer>) => (status :: <HRESULT>)
  ICreateTypeInfo2_DeleteImplType(This, index)
end;

define open generic ICreateTypeInfo2/SetCustData (This, guid,
		pVarVal) => (status :: <HRESULT>);

define C-callable-wrapper of ICreateTypeInfo2/SetCustData
  input parameter This :: <mapped-interface>;
  input parameter guid :: <REFGUID>;
  input parameter pVarVal :: <LPVARIANT>;
  result status :: <C-HRESULT>;
  c-name: "DW_ICreateTypeInfo2_SetCustData",
		c-modifiers: "__stdcall";
end;

define inline-only C-function ICreateTypeInfo2_SetCustData
  input parameter This :: <C-interface>;
  input parameter guid :: <REFGUID>;
  input parameter pVarVal :: <LPVARIANT>;
  result status :: <C-HRESULT>;
  c-name: "C_ICreateTypeInfo2_SetCustData";
end;

define method ICreateTypeInfo2/SetCustData(This :: <C-interface>,
		guid :: <REFGUID>, pVarVal :: <LPVARIANT>) => (status :: <HRESULT>)
  ICreateTypeInfo2_SetCustData(This, guid, pVarVal)
end;

define open generic ICreateTypeInfo2/SetFuncCustData (This,
		index, guid, pVarVal) => (status :: <HRESULT>);

define C-callable-wrapper of ICreateTypeInfo2/SetFuncCustData
  input parameter This :: <mapped-interface>;
  input parameter index :: <UINT>;
  input parameter guid :: <REFGUID>;
  input parameter pVarVal :: <LPVARIANT>;
  result status :: <C-HRESULT>;
  c-name: "DW_ICreateTypeInfo2_SetFuncCustData",
		c-modifiers: "__stdcall";
end;

define inline-only C-function ICreateTypeInfo2_SetFuncCustData
  input parameter This :: <C-interface>;
  input parameter index :: <UINT>;
  input parameter guid :: <REFGUID>;
  input parameter pVarVal :: <LPVARIANT>;
  result status :: <C-HRESULT>;
  c-name: "C_ICreateTypeInfo2_SetFuncCustData";
end;

define method ICreateTypeInfo2/SetFuncCustData(This :: <C-interface>,
		index :: <integer>, guid :: <REFGUID>, pVarVal :: <LPVARIANT>) => (status :: <HRESULT>)
  ICreateTypeInfo2_SetFuncCustData(This, index, guid, pVarVal)
end;

define open generic ICreateTypeInfo2/SetParamCustData (This,
		indexFunc, indexParam, guid, pVarVal)
		=> (status :: <HRESULT>);

define C-callable-wrapper of ICreateTypeInfo2/SetParamCustData
  input parameter This :: <mapped-interface>;
  input parameter indexFunc :: <UINT>;
  input parameter indexParam :: <UINT>;
  input parameter guid :: <REFGUID>;
  input parameter pVarVal :: <LPVARIANT>;
  result status :: <C-HRESULT>;
  c-name: "DW_ICreateTypeInfo2_SetParamCustData",
		c-modifiers: "__stdcall";
end;

define inline-only C-function ICreateTypeInfo2_SetParamCustData
  input parameter This :: <C-interface>;
  input parameter indexFunc :: <UINT>;
  input parameter indexParam :: <UINT>;
  input parameter guid :: <REFGUID>;
  input parameter pVarVal :: <LPVARIANT>;
  result status :: <C-HRESULT>;
  c-name: "C_ICreateTypeInfo2_SetParamCustData";
end;

define method ICreateTypeInfo2/SetParamCustData(This :: <C-interface>,
		indexFunc :: <integer>, indexParam :: <integer>, guid :: <REFGUID>, pVarVal :: <LPVARIANT>)
		=> (status :: <HRESULT>)
  ICreateTypeInfo2_SetParamCustData(This, indexFunc, indexParam,
		guid, pVarVal)
end;

define open generic ICreateTypeInfo2/SetVarCustData (This, index,
		guid, pVarVal) => (status :: <HRESULT>);

define C-callable-wrapper of ICreateTypeInfo2/SetVarCustData
  input parameter This :: <mapped-interface>;
  input parameter index :: <UINT>;
  input parameter guid :: <REFGUID>;
  input parameter pVarVal :: <LPVARIANT>;
  result status :: <C-HRESULT>;
  c-name: "DW_ICreateTypeInfo2_SetVarCustData",
		c-modifiers: "__stdcall";
end;

define inline-only C-function ICreateTypeInfo2_SetVarCustData
  input parameter This :: <C-interface>;
  input parameter index :: <UINT>;
  input parameter guid :: <REFGUID>;
  input parameter pVarVal :: <LPVARIANT>;
  result status :: <C-HRESULT>;
  c-name: "C_ICreateTypeInfo2_SetVarCustData";
end;

define method ICreateTypeInfo2/SetVarCustData(This :: <C-interface>,
		index :: <integer>, guid :: <REFGUID>, pVarVal :: <LPVARIANT>) => (status :: <HRESULT>)
  ICreateTypeInfo2_SetVarCustData(This, index, guid, pVarVal)
end;

define open generic ICreateTypeInfo2/SetImplTypeCustData (This,
		index, guid, pVarVal) => (status :: <HRESULT>);

define C-callable-wrapper
		of ICreateTypeInfo2/SetImplTypeCustData
  input parameter This :: <mapped-interface>;
  input parameter index :: <UINT>;
  input parameter guid :: <REFGUID>;
  input parameter pVarVal :: <LPVARIANT>;
  result status :: <C-HRESULT>;
  c-name: "DW_ICreateTypeInfo2_SetImplTypeCustData",
		c-modifiers: "__stdcall";
end;

define inline-only C-function ICreateTypeInfo2_SetImplTypeCustData
  input parameter This :: <C-interface>;
  input parameter index :: <UINT>;
  input parameter guid :: <REFGUID>;
  input parameter pVarVal :: <LPVARIANT>;
  result status :: <C-HRESULT>;
  c-name: "C_ICreateTypeInfo2_SetImplTypeCustData";
end;

define method ICreateTypeInfo2/SetImplTypeCustData(This :: <C-interface>,
		index :: <integer>, guid :: <REFGUID>, pVarVal :: <LPVARIANT>) => (status :: <HRESULT>)
  ICreateTypeInfo2_SetImplTypeCustData(This, index, guid,
		pVarVal)
end;

define open generic ICreateTypeInfo2/SetHelpStringContext (This,
		dwHelpStringContext) => (status :: <HRESULT>);

define C-callable-wrapper
		of ICreateTypeInfo2/SetHelpStringContext
  input parameter This :: <mapped-interface>;
  input parameter dwHelpStringContext :: <ULONG>;
  result status :: <C-HRESULT>;
  c-name: "DW_ICreateTypeInfo2_SetHelpStringContext",
		c-modifiers: "__stdcall";
end;

define inline-only C-function ICreateTypeInfo2_SetHelpStringContext
  input parameter This :: <C-interface>;
  input parameter dwHelpStringContext :: <ULONG>;
  result status :: <C-HRESULT>;
  c-name: "C_ICreateTypeInfo2_SetHelpStringContext";
end;

define method ICreateTypeInfo2/SetHelpStringContext(This :: <C-interface>,
		dwHelpStringContext :: <ffi-integer>) => (status :: <HRESULT>)
  ICreateTypeInfo2_SetHelpStringContext(This,
		dwHelpStringContext)
end;

define open generic ICreateTypeInfo2/SetFuncHelpStringContext
		(This, index, dwHelpStringContext) => (status :: <HRESULT>);

define C-callable-wrapper
		of ICreateTypeInfo2/SetFuncHelpStringContext
  input parameter This :: <mapped-interface>;
  input parameter index :: <UINT>;
  input parameter dwHelpStringContext :: <ULONG>;
  result status :: <C-HRESULT>;
  c-name: "DW_ICreateTypeInfo2_SetFuncHelpStringContext",
		c-modifiers: "__stdcall";
end;

define inline-only C-function ICreateTypeInfo2_SetFuncHelpStringContext
  input parameter This :: <C-interface>;
  input parameter index :: <UINT>;
  input parameter dwHelpStringContext :: <ULONG>;
  result status :: <C-HRESULT>;
  c-name: "C_ICreateTypeInfo2_SetFuncHelpStringContext";
end;

define method ICreateTypeInfo2/SetFuncHelpStringContext(This :: <C-interface>,
		index :: <integer>, dwHelpStringContext :: <ffi-integer>) => (status :: <HRESULT>)
  ICreateTypeInfo2_SetFuncHelpStringContext(This, index,
		dwHelpStringContext)
end;

define open generic ICreateTypeInfo2/SetVarHelpStringContext
		(This, index, dwHelpStringContext) => (status :: <HRESULT>);

define C-callable-wrapper
		of ICreateTypeInfo2/SetVarHelpStringContext
  input parameter This :: <mapped-interface>;
  input parameter index :: <UINT>;
  input parameter dwHelpStringContext :: <ULONG>;
  result status :: <C-HRESULT>;
  c-name: "DW_ICreateTypeInfo2_SetVarHelpStringContext",
		c-modifiers: "__stdcall";
end;

define inline-only C-function ICreateTypeInfo2_SetVarHelpStringContext
  input parameter This :: <C-interface>;
  input parameter index :: <UINT>;
  input parameter dwHelpStringContext :: <ULONG>;
  result status :: <C-HRESULT>;
  c-name: "C_ICreateTypeInfo2_SetVarHelpStringContext";
end;

define method ICreateTypeInfo2/SetVarHelpStringContext(This :: <C-interface>,
		index :: <integer>, dwHelpStringContext :: <ffi-integer>) => (status :: <HRESULT>)
  ICreateTypeInfo2_SetVarHelpStringContext(This, index,
		dwHelpStringContext)
end;

define open generic ICreateTypeInfo2/Invalidate (This)
		=> (status :: <HRESULT>);

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

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

define method ICreateTypeInfo2/Invalidate(This :: <C-interface>)
		=> (status :: <HRESULT>)
  ICreateTypeInfo2_Invalidate(This)
end;

define open generic ICreateTypeInfo2/SetName (This, szName)
		=> (status :: <HRESULT>);

define C-callable-wrapper of ICreateTypeInfo2/SetName
  input parameter This :: <mapped-interface>;
  input parameter szName :: <LPOLESTR>;
  result status :: <C-HRESULT>;
  c-name: "DW_ICreateTypeInfo2_SetName",
		c-modifiers: "__stdcall";
end;

define inline-only C-function ICreateTypeInfo2_SetName
  input parameter This :: <C-interface>;
  input parameter szName :: <LPOLESTR>;
  result status :: <C-HRESULT>;
  c-name: "C_ICreateTypeInfo2_SetName";
end;

define method ICreateTypeInfo2/SetName(This :: <C-interface>,
		szName :: <LPOLESTR>) => (status :: <HRESULT>)
  ICreateTypeInfo2_SetName(This, szName)
end;


	/*  ----  ICreateTypeLib  ----  */


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

define C-address ICreateTypeLib_DW_vtbl :: <C-COM-vtbl>
		c-name: "ICreateTypeLib_DW_vtbl"; end;
define C-address $IID-ICreateTypeLib :: <REFIID>
		c-name: "IID_ICreateTypeLib"; end;

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

define open generic ICreateTypeLib/CreateTypeInfo (This, szName,
		tkind) => (status :: <HRESULT>, pCTInfo :: <Interface>);

define C-callable-wrapper of ICreateTypeLib/CreateTypeInfo
  input parameter This :: <mapped-interface>;
  input parameter szName :: <LPOLESTR>;
  input parameter tkind :: <TYPEKIND>;
  output parameter ppCTInfo :: <Interface*>;
  result status :: <C-HRESULT>;
  c-name: "DW_ICreateTypeLib_CreateTypeInfo",
		c-modifiers: "__stdcall";
end;

define inline-only C-function ICreateTypeLib_CreateTypeInfo
  input parameter This :: <C-interface>;
  input parameter szName :: <LPOLESTR>;
  input parameter tkind :: <TYPEKIND>;
  output parameter ppCTInfo :: <C-interface*>;
  result status :: <C-HRESULT>;
  c-name: "C_ICreateTypeLib_CreateTypeInfo";
end;

define method ICreateTypeLib/CreateTypeInfo(This :: <C-interface>,
		szName :: <LPOLESTR>, tkind :: <integer>)
		=> (status :: <HRESULT>, pCTInfo :: <Interface>)
  ICreateTypeLib_CreateTypeInfo(This, szName, tkind)
end;

define open generic ICreateTypeLib/SetName (This, szName)
		=> (status :: <HRESULT>);

define C-callable-wrapper of ICreateTypeLib/SetName
  input parameter This :: <mapped-interface>;
  input parameter szName :: <LPOLESTR>;
  result status :: <C-HRESULT>;
  c-name: "DW_ICreateTypeLib_SetName", c-modifiers: "__stdcall";
end;

define inline-only C-function ICreateTypeLib_SetName
  input parameter This :: <C-interface>;
  input parameter szName :: <LPOLESTR>;
  result status :: <C-HRESULT>;
  c-name: "C_ICreateTypeLib_SetName";
end;

define method ICreateTypeLib/SetName(This :: <C-interface>,
		szName :: <LPOLESTR>) => (status :: <HRESULT>)
  ICreateTypeLib_SetName(This, szName)
end;

define open generic ICreateTypeLib/SetVersion (This,
		wMajorVerNum, wMinorVerNum) => (status :: <HRESULT>);

define C-callable-wrapper of ICreateTypeLib/SetVersion
  input parameter This :: <mapped-interface>;
  input parameter wMajorVerNum :: <WORD>;
  input parameter wMinorVerNum :: <WORD>;
  result status :: <C-HRESULT>;
  c-name: "DW_ICreateTypeLib_SetVersion",
		c-modifiers: "__stdcall";
end;

define inline-only C-function ICreateTypeLib_SetVersion
  input parameter This :: <C-interface>;
  input parameter wMajorVerNum :: <WORD>;
  input parameter wMinorVerNum :: <WORD>;
  result status :: <C-HRESULT>;
  c-name: "C_ICreateTypeLib_SetVersion";
end;

define method ICreateTypeLib/SetVersion(This :: <C-interface>,
		wMajorVerNum :: <integer>, wMinorVerNum :: <integer>) => (status :: <HRESULT>)
  ICreateTypeLib_SetVersion(This, wMajorVerNum, wMinorVerNum)
end;

define open generic ICreateTypeLib/SetGuid (This, guid)
		=> (status :: <HRESULT>);

define C-callable-wrapper of ICreateTypeLib/SetGuid
  input parameter This :: <mapped-interface>;
  input parameter guid :: <REFGUID>;
  result status :: <C-HRESULT>;
  c-name: "DW_ICreateTypeLib_SetGuid", c-modifiers: "__stdcall";
end;

define inline-only C-function ICreateTypeLib_SetGuid
  input parameter This :: <C-interface>;
  input parameter guid :: <REFGUID>;
  result status :: <C-HRESULT>;
  c-name: "C_ICreateTypeLib_SetGuid";
end;

define method ICreateTypeLib/SetGuid(This :: <C-interface>, guid :: <REFGUID>)
		=> (status :: <HRESULT>)
  ICreateTypeLib_SetGuid(This, guid)
end;

define open generic ICreateTypeLib/SetDocString (This, szDoc)
		=> (status :: <HRESULT>);

define C-callable-wrapper of ICreateTypeLib/SetDocString
  input parameter This :: <mapped-interface>;
  input parameter szDoc :: <LPOLESTR>;
  result status :: <C-HRESULT>;
  c-name: "DW_ICreateTypeLib_SetDocString",
		c-modifiers: "__stdcall";
end;

define inline-only C-function ICreateTypeLib_SetDocString
  input parameter This :: <C-interface>;
  input parameter szDoc :: <LPOLESTR>;
  result status :: <C-HRESULT>;
  c-name: "C_ICreateTypeLib_SetDocString";
end;

define method ICreateTypeLib/SetDocString(This :: <C-interface>,
		szDoc :: <LPOLESTR>) => (status :: <HRESULT>)
  ICreateTypeLib_SetDocString(This, szDoc)
end;

define open generic ICreateTypeLib/SetHelpFileName (This,
		szHelpFileName) => (status :: <HRESULT>);

define C-callable-wrapper of ICreateTypeLib/SetHelpFileName
  input parameter This :: <mapped-interface>;
  input parameter szHelpFileName :: <LPOLESTR>;
  result status :: <C-HRESULT>;
  c-name: "DW_ICreateTypeLib_SetHelpFileName",
		c-modifiers: "__stdcall";
end;

define inline-only C-function ICreateTypeLib_SetHelpFileName
  input parameter This :: <C-interface>;
  input parameter szHelpFileName :: <LPOLESTR>;
  result status :: <C-HRESULT>;
  c-name: "C_ICreateTypeLib_SetHelpFileName";
end;

define method ICreateTypeLib/SetHelpFileName(This :: <C-interface>,
		szHelpFileName :: <LPOLESTR>) => (status :: <HRESULT>)
  ICreateTypeLib_SetHelpFileName(This, szHelpFileName)
end;

define open generic ICreateTypeLib/SetHelpContext (This,
		dwHelpContext) => (status :: <HRESULT>);

define C-callable-wrapper of ICreateTypeLib/SetHelpContext
  input parameter This :: <mapped-interface>;
  input parameter dwHelpContext :: <DWORD>;
  result status :: <C-HRESULT>;
  c-name: "DW_ICreateTypeLib_SetHelpContext",
		c-modifiers: "__stdcall";
end;

define inline-only C-function ICreateTypeLib_SetHelpContext
  input parameter This :: <C-interface>;
  input parameter dwHelpContext :: <DWORD>;
  result status :: <C-HRESULT>;
  c-name: "C_ICreateTypeLib_SetHelpContext";
end;

define method ICreateTypeLib/SetHelpContext(This :: <C-interface>,
		dwHelpContext :: <ffi-integer>) => (status :: <HRESULT>)
  ICreateTypeLib_SetHelpContext(This, dwHelpContext)
end;

define open generic ICreateTypeLib/SetLcid (This, lcid)
		=> (status :: <HRESULT>);

define C-callable-wrapper of ICreateTypeLib/SetLcid
  input parameter This :: <mapped-interface>;
  input parameter lcid :: <LCID>;
  result status :: <C-HRESULT>;
  c-name: "DW_ICreateTypeLib_SetLcid", c-modifiers: "__stdcall";
end;

define inline-only C-function ICreateTypeLib_SetLcid
  input parameter This :: <C-interface>;
  input parameter lcid :: <LCID>;
  result status :: <C-HRESULT>;
  c-name: "C_ICreateTypeLib_SetLcid";
end;

define method ICreateTypeLib/SetLcid(This :: <C-interface>, lcid :: <integer>)
		=> (status :: <HRESULT>)
  ICreateTypeLib_SetLcid(This, lcid)
end;

define open generic ICreateTypeLib/SetLibFlags (This, uLibFlags)
		=> (status :: <HRESULT>);

define C-callable-wrapper of ICreateTypeLib/SetLibFlags
  input parameter This :: <mapped-interface>;
  input parameter uLibFlags :: <UINT>;
  result status :: <C-HRESULT>;
  c-name: "DW_ICreateTypeLib_SetLibFlags",
		c-modifiers: "__stdcall";
end;

define inline-only C-function ICreateTypeLib_SetLibFlags
  input parameter This :: <C-interface>;
  input parameter uLibFlags :: <UINT>;
  result status :: <C-HRESULT>;
  c-name: "C_ICreateTypeLib_SetLibFlags";
end;

define method ICreateTypeLib/SetLibFlags(This :: <C-interface>,
		uLibFlags :: <ffi-integer>) => (status :: <HRESULT>)
  ICreateTypeLib_SetLibFlags(This, uLibFlags)
end;

define open generic ICreateTypeLib/SaveAllChanges (This)
		=> (status :: <HRESULT>);

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

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

define method ICreateTypeLib/SaveAllChanges(This :: <C-interface>)
		=> (status :: <HRESULT>)
  ICreateTypeLib_SaveAllChanges(This)
end;


	/*  ----  ICreateTypeLib2  ----  */


define open primary COM-interface <ICreateTypeLib2> ( <ICreateTypeLib> )
end <ICreateTypeLib2>;

define C-address ICreateTypeLib2_DW_vtbl :: <C-COM-vtbl>
		c-name: "ICreateTypeLib2_DW_vtbl"; end;
define C-address $IID-ICreateTypeLib2 :: <REFIID>
		c-name: "IID_ICreateTypeLib2"; end;

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

define open generic ICreateTypeLib2/DeleteTypeInfo (This, szName)
		=> (status :: <HRESULT>);

define C-callable-wrapper of ICreateTypeLib2/DeleteTypeInfo
  input parameter This :: <mapped-interface>;
  input parameter szName :: <LPOLESTR>;
  result status :: <C-HRESULT>;
  c-name: "DW_ICreateTypeLib2_DeleteTypeInfo",
		c-modifiers: "__stdcall";
end;

define inline-only C-function ICreateTypeLib2_DeleteTypeInfo
  input parameter This :: <C-interface>;
  input parameter szName :: <LPOLESTR>;
  result status :: <C-HRESULT>;
  c-name: "C_ICreateTypeLib2_DeleteTypeInfo";
end;

define method ICreateTypeLib2/DeleteTypeInfo(This :: <C-interface>,
		szName :: <LPOLESTR>) => (status :: <HRESULT>)
  ICreateTypeLib2_DeleteTypeInfo(This, szName)
end;

define open generic ICreateTypeLib2/SetCustData (This, guid,
		pVarVal) => (status :: <HRESULT>);

define C-callable-wrapper of ICreateTypeLib2/SetCustData
  input parameter This :: <mapped-interface>;
  input parameter guid :: <REFGUID>;
  input parameter pVarVal :: <LPVARIANT>;
  result status :: <C-HRESULT>;
  c-name: "DW_ICreateTypeLib2_SetCustData",
		c-modifiers: "__stdcall";
end;

define inline-only C-function ICreateTypeLib2_SetCustData
  input parameter This :: <C-interface>;
  input parameter guid :: <REFGUID>;
  input parameter pVarVal :: <LPVARIANT>;
  result status :: <C-HRESULT>;
  c-name: "C_ICreateTypeLib2_SetCustData";
end;

define method ICreateTypeLib2/SetCustData(This :: <C-interface>,
		guid :: <REFGUID>, pVarVal :: <LPVARIANT>) => (status :: <HRESULT>)
  ICreateTypeLib2_SetCustData(This, guid, pVarVal)
end;

define open generic ICreateTypeLib2/SetHelpStringContext (This,
		dwHelpStringContext) => (status :: <HRESULT>);

define C-callable-wrapper
		of ICreateTypeLib2/SetHelpStringContext
  input parameter This :: <mapped-interface>;
  input parameter dwHelpStringContext :: <ULONG>;
  result status :: <C-HRESULT>;
  c-name: "DW_ICreateTypeLib2_SetHelpStringContext",
		c-modifiers: "__stdcall";
end;

define inline-only C-function ICreateTypeLib2_SetHelpStringContext
  input parameter This :: <C-interface>;
  input parameter dwHelpStringContext :: <ULONG>;
  result status :: <C-HRESULT>;
  c-name: "C_ICreateTypeLib2_SetHelpStringContext";
end;

define method ICreateTypeLib2/SetHelpStringContext(This :: <C-interface>,
		dwHelpStringContext :: <ffi-integer>) => (status :: <HRESULT>)
  ICreateTypeLib2_SetHelpStringContext(This, dwHelpStringContext)
end;

define open generic ICreateTypeLib2/SetHelpStringDll (This,
		szFileName) => (status :: <HRESULT>);

define C-callable-wrapper of ICreateTypeLib2/SetHelpStringDll
  input parameter This :: <mapped-interface>;
  input parameter szFileName :: <LPOLESTR>;
  result status :: <C-HRESULT>;
  c-name: "DW_ICreateTypeLib2_SetHelpStringDll",
		c-modifiers: "__stdcall";
end;

define inline-only C-function ICreateTypeLib2_SetHelpStringDll
  input parameter This :: <C-interface>;
  input parameter szFileName :: <LPOLESTR>;
  result status :: <C-HRESULT>;
  c-name: "C_ICreateTypeLib2_SetHelpStringDll";
end;

define method ICreateTypeLib2/SetHelpStringDll(This :: <C-interface>,
		szFileName :: <LPOLESTR>) => (status :: <HRESULT>)
  ICreateTypeLib2_SetHelpStringDll(This, szFileName)
end;


	/*  ----  IDispatch  ----  */


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

define C-address IDispatch_DW_vtbl :: <C-COM-vtbl>
		c-name: "IDispatch_DW_vtbl"; end;
define C-address $IID-IDispatch :: <REFIID>
		c-name: "IID_IDispatch"; end;

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

define open generic IDispatch/GetTypeInfoCount (This)
		=> (status :: <HRESULT>, ctinfo :: <integer>);

define C-callable-wrapper of IDispatch/GetTypeInfoCount
  input parameter This :: <mapped-interface>;
  output parameter pctinfo :: <LPUINT>;
  result status :: <C-HRESULT>;
  export: #t,
  c-name: "DW_IDispatch_GetTypeInfoCount",
		c-modifiers: "__stdcall";
end;

define inline-only C-function IDispatch_GetTypeInfoCount
  input parameter This :: <C-interface>;
  output parameter pctinfo :: <LPUINT>;
  result status :: <C-HRESULT>;
  c-name: "C_IDispatch_GetTypeInfoCount";
end;

define method IDispatch/GetTypeInfoCount(This :: <C-interface>)
		=> (status :: <HRESULT>, ctinfo :: <integer>)
  IDispatch_GetTypeInfoCount(This)
end;

define open generic IDispatch/GetTypeInfo (This, iTInfo, lcid)
		=> (status :: <HRESULT>, pTInfo :: <Interface>);

define C-callable-wrapper of IDispatch/GetTypeInfo
  input parameter This :: <mapped-interface>;
  input parameter iTInfo :: <UINT>;
  input parameter lcid :: <LCID>;
  output parameter ppTInfo :: <Interface*>;
  result status :: <C-HRESULT>;
  export: #t,
  c-name: "DW_IDispatch_GetTypeInfo", c-modifiers: "__stdcall";
end;

define inline-only C-function IDispatch_GetTypeInfo
  input parameter This :: <C-interface>;
  input parameter iTInfo :: <UINT>;
  input parameter lcid :: <LCID>;
  output parameter ppTInfo :: <C-interface*>;
  result status :: <C-HRESULT>;
  c-name: "C_IDispatch_GetTypeInfo";
end;

define method IDispatch/GetTypeInfo(This :: <C-interface>,
		iTInfo :: <integer>, lcid :: <ffi-integer>) => (status :: <HRESULT>, pTInfo :: <Interface>)
  IDispatch_GetTypeInfo(This, iTInfo, lcid)
end;

define open generic IDispatch/GetIDsOfNames (This, riid,
		rgszNames, cNames, lcid, rgDispId) => (status :: <HRESULT>);

define C-callable-wrapper of IDispatch/GetIDsOfNames
  input parameter This :: <mapped-interface>;
  input parameter riid :: <REFIID>;
  input parameter rgszNames :: <LPLPOLESTR>;
  input parameter cNames :: <UINT>;
  input parameter lcid :: <LCID>;
   parameter rgDispId :: <LPDISPID>;
  result status :: <C-HRESULT>;
  export: #t,
  c-name: "DW_IDispatch_GetIDsOfNames",
		c-modifiers: "__stdcall";
end;

define inline-only C-function IDispatch_GetIDsOfNames
  input parameter This :: <C-interface>;
  input parameter riid :: <REFIID>;
  input parameter rgszNames :: <LPLPOLESTR>;
  input parameter cNames :: <UINT>;
  input parameter lcid :: <LCID>;
   parameter rgDispId :: <LPDISPID>;
  result status :: <C-HRESULT>;
  c-name: "C_IDispatch_GetIDsOfNames";
end;

define method IDispatch/GetIDsOfNames(This :: <C-interface>,
		riid :: <REFIID>, rgszNames :: <LPLPOLESTR>, cNames :: <integer>, lcid :: <ffi-integer>,
		rgDispId :: <LPDISPID>) => (status :: <HRESULT>)
  IDispatch_GetIDsOfNames(This, riid, rgszNames, cNames, lcid,
		rgDispId)
end;

define open generic IDispatch/Invoke (This, dispIdMember, riid,
		lcid, wFlags, pDispParams, pVarResult, pExcepInfo)
		=> (status :: <HRESULT>, uArgErr :: <integer>);

define C-callable-wrapper of IDispatch/Invoke
  input parameter This :: <mapped-interface>;
  input parameter dispIdMember :: <DISPID>;
  input parameter riid :: <REFIID>;
  input parameter lcid :: <LCID>;
  input parameter wFlags :: <WORD>;
   parameter pDispParams :: <LPDISPPARAMS>;
  parameter pVarResult :: <LPVARIANT>;
  parameter pExcepInfo :: <LPEXCEPINFO>;
  output parameter puArgErr :: <LPUINT>;
  result status :: <C-HRESULT>;
  export: #t,
  c-name: "DW_IDispatch_Invoke", c-modifiers: "__stdcall";
end;

define inline-only C-function IDispatch_Invoke
  input parameter This :: <C-interface>;
  input parameter dispIdMember :: <DISPID>;
  input parameter riid :: <REFIID>;
  input parameter lcid :: <LCID>;
  input parameter wFlags :: <WORD>;
   parameter pDispParams :: <LPDISPPARAMS>;
  parameter pVarResult :: <LPVARIANT>;
  parameter pExcepInfo :: <LPEXCEPINFO>;
  output parameter puArgErr :: <LPUINT>;
  result status :: <C-HRESULT>;
  c-name: "C_IDispatch_Invoke";
end;

define method IDispatch/Invoke(This :: <C-interface>,
		dispIdMember :: <ffi-integer>, riid :: <REFIID>, lcid :: <ffi-integer>, wFlags :: <integer>,
		pDispParams :: <LPDISPPARAMS>, pVarResult :: <LPVARIANT>,
		pExcepInfo :: <LPEXCEPINFO>)
		=> (status :: <HRESULT>, uArgErr :: <integer>)
  let (status :: <HRESULT>, raw-arg-err) =
    IDispatch_Invoke(This, dispidMember, riid, lcid, wFlags,
		     pdispparams, pvarResult, pexcepinfo);
  let arg-err :: <integer> =
    if ( instance?(raw-arg-err, <integer>) )
      raw-arg-err
    else
      // Valid values for the second result will always be small positive
      // integers, but when not being used, the server might not store any
      // value, leaving random garbage that might not fit an <integer>.
      assert( status ~= $DISP-E-TYPEMISMATCH &
	       status ~= $DISP-E-PARAMNOTFOUND );
      -1
    end if;
  values(status, arg-err)
end;


	/*  ----  IEnumVARIANT  ----  */


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

define C-address IEnumVARIANT_DW_vtbl :: <C-COM-vtbl>
		c-name: "IEnumVARIANT_DW_vtbl"; end;
define C-address $IID-IEnumVARIANT :: <REFIID>
		c-name: "IID_IEnumVARIANT"; end;

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

define open generic IEnumVARIANT/Next (This, celt, rgVar)
		=> (status :: <HRESULT>, CeltFetched);

define C-callable-wrapper of IEnumVARIANT/Next
  input parameter This :: <mapped-interface>;
  input parameter celt :: <ULONG>;
   parameter rgVar :: <LPVARIANT>;
  output parameter pCeltFetched :: <LPULONG>;
  result status :: <C-HRESULT>;
  c-name: "DW_IEnumVARIANT_Next", c-modifiers: "__stdcall";
end;

define inline-only C-function IEnumVARIANT_Next
  input parameter This :: <C-interface>;
  input parameter celt :: <ULONG>;
   parameter rgVar :: <LPVARIANT>;
  output parameter pCeltFetched :: <LPULONG>;
  result status :: <C-HRESULT>;
  c-name: "C_IEnumVARIANT_Next";
end;

define method IEnumVARIANT/Next(This :: <C-interface>, celt :: <ffi-integer>,
		rgVar :: <LPVARIANT>) => (status :: <HRESULT>, CeltFetched)
  IEnumVARIANT_Next(This, celt, rgVar)
end;

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

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

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

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

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

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

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

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

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

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

define inline-only C-function IEnumVARIANT_Clone
  input parameter This :: <C-interface>;
  output parameter ppEnum :: <C-interface*>;
  result status :: <C-HRESULT>;
  c-name: "C_IEnumVARIANT_Clone";
end;

define method IEnumVARIANT/Clone(This :: <C-interface>)
		=> (status :: <HRESULT>, pEnum :: <Interface>)
  IEnumVARIANT_Clone(This)
end;


	/*  ----  ITypeComp  ----  */


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

define C-address ITypeComp_DW_vtbl :: <C-COM-vtbl>
		c-name: "ITypeComp_DW_vtbl"; end;
define C-address $IID-ITypeComp :: <REFIID>
		c-name: "IID_ITypeComp"; end;

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

define open generic ITypeComp/Bind (This, szName, lHashVal,
		wFlags, pBindPtr)
		=> (status :: <HRESULT>, pTInfo :: <Interface>, DescKind);

define C-callable-wrapper of ITypeComp/Bind
  input parameter This :: <mapped-interface>;
  input parameter szName :: <LPOLESTR>;
  input parameter lHashVal :: <ULONG>;
  input parameter wFlags :: <WORD>;
  output parameter ppTInfo :: <Interface*>;
  output parameter pDescKind :: <LPDESCKIND>;
  parameter pBindPtr :: <LPBINDPTR>;
  result status :: <C-HRESULT>;
  c-name: "DW_ITypeComp_Bind", c-modifiers: "__stdcall";
end;

define inline-only C-function ITypeComp_Bind
  input parameter This :: <C-interface>;
  input parameter szName :: <LPOLESTR>;
  input parameter lHashVal :: <ULONG>;
  input parameter wFlags :: <WORD>;
  output parameter ppTInfo :: <C-interface*>;
  output parameter pDescKind :: <LPDESCKIND>;
  parameter pBindPtr :: <LPBINDPTR>;
  result status :: <C-HRESULT>;
  c-name: "C_ITypeComp_Bind";
end;

define method ITypeComp/Bind(This :: <C-interface>,
		szName :: <LPOLESTR>, lHashVal :: <ffi-integer>, wFlags :: <integer>,
		pBindPtr :: <LPBINDPTR>)
		=> (status :: <HRESULT>, pTInfo :: <Interface>, DescKind)
  ITypeComp_Bind(This, szName, lHashVal, wFlags, pBindPtr)
end;

define open generic ITypeComp/BindType (This, szName, lHashVal)
		=> (status :: <HRESULT>, pTInfo :: <Interface>,
		pTComp :: <Interface>);

define C-callable-wrapper of ITypeComp/BindType
  input parameter This :: <mapped-interface>;
  input parameter szName :: <LPOLESTR>;
  input parameter lHashVal :: <ULONG>;
  output parameter ppTInfo :: <Interface*>;
  output parameter ppTComp :: <Interface*>;
  result status :: <C-HRESULT>;
  c-name: "DW_ITypeComp_BindType", c-modifiers: "__stdcall";
end;

define inline-only C-function ITypeComp_BindType
  input parameter This :: <C-interface>;
  input parameter szName :: <LPOLESTR>;
  input parameter lHashVal :: <ULONG>;
  output parameter ppTInfo :: <C-interface*>;
  output parameter ppTComp :: <C-interface*>;
  result status :: <C-HRESULT>;
  c-name: "C_ITypeComp_BindType";
end;

define method ITypeComp/BindType(This :: <C-interface>,
		szName :: <LPOLESTR>, lHashVal :: <ffi-integer>)
		=> (status :: <HRESULT>, pTInfo :: <Interface>,
		pTComp :: <Interface>)
  ITypeComp_BindType(This, szName, lHashVal)
end;


	/*  ----  ITypeInfo  ----  */


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

define C-address ITypeInfo_DW_vtbl :: <C-COM-vtbl>
		c-name: "ITypeInfo_DW_vtbl"; end;
define C-address $IID-ITypeInfo :: <REFIID>
		c-name: "IID_ITypeInfo"; end;

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

define open generic ITypeInfo/GetTypeAttr (This)
		=> (status :: <HRESULT>, pTypeAttr);

define C-callable-wrapper of ITypeInfo/GetTypeAttr
  input parameter This :: <mapped-interface>;
  output parameter ppTypeAttr :: <TYPEATTR**>;
  result status :: <C-HRESULT>;
  c-name: "DW_ITypeInfo_GetTypeAttr", c-modifiers: "__stdcall";
end;

define inline-only C-function ITypeInfo_GetTypeAttr
  input parameter This :: <C-interface>;
  output parameter ppTypeAttr :: <TYPEATTR**>;
  result status :: <C-HRESULT>;
  c-name: "C_ITypeInfo_GetTypeAttr";
end;

define method ITypeInfo/GetTypeAttr(This :: <C-interface>)
		=> (status :: <HRESULT>, pTypeAttr)
  ITypeInfo_GetTypeAttr(This)
end;

define open generic ITypeInfo/GetTypeComp (This)
		=> (status :: <HRESULT>, pTComp :: <Interface>);

define C-callable-wrapper of ITypeInfo/GetTypeComp
  input parameter This :: <mapped-interface>;
  output parameter ppTComp :: <Interface*>;
  result status :: <C-HRESULT>;
  c-name: "DW_ITypeInfo_GetTypeComp", c-modifiers: "__stdcall";
end;

define inline-only C-function ITypeInfo_GetTypeComp
  input parameter This :: <C-interface>;
  output parameter ppTComp :: <C-interface*>;
  result status :: <C-HRESULT>;
  c-name: "C_ITypeInfo_GetTypeComp";
end;

define method ITypeInfo/GetTypeComp(This :: <C-interface>)
		=> (status :: <HRESULT>, pTComp :: <Interface>)
  ITypeInfo_GetTypeComp(This)
end;

define open generic ITypeInfo/GetFuncDesc (This, index)
		=> (status :: <HRESULT>, pFuncDesc);

define C-callable-wrapper of ITypeInfo/GetFuncDesc
  input parameter This :: <mapped-interface>;
  input parameter index :: <UINT>;
  output parameter ppFuncDesc :: <FUNCDESC**>;
  result status :: <C-HRESULT>;
  c-name: "DW_ITypeInfo_GetFuncDesc", c-modifiers: "__stdcall";
end;

define inline-only C-function ITypeInfo_GetFuncDesc
  input parameter This :: <C-interface>;
  input parameter index :: <UINT>;
  output parameter ppFuncDesc :: <FUNCDESC**>;
  result status :: <C-HRESULT>;
  c-name: "C_ITypeInfo_GetFuncDesc";
end;

define method ITypeInfo/GetFuncDesc(This :: <C-interface>, index :: <integer>)
		=> (status :: <HRESULT>, pFuncDesc)
  ITypeInfo_GetFuncDesc(This, index)
end;

define open generic ITypeInfo/GetVarDesc (This, index)
		=> (status :: <HRESULT>, pVarDesc);

define C-callable-wrapper of ITypeInfo/GetVarDesc
  input parameter This :: <mapped-interface>;
  input parameter index :: <UINT>;
  output parameter ppVarDesc :: <VARDESC**>;
  result status :: <C-HRESULT>;
  c-name: "DW_ITypeInfo_GetVarDesc", c-modifiers: "__stdcall";
end;

define inline-only C-function ITypeInfo_GetVarDesc
  input parameter This :: <C-interface>;
  input parameter index :: <UINT>;
  output parameter ppVarDesc :: <VARDESC**>;
  result status :: <C-HRESULT>;
  c-name: "C_ITypeInfo_GetVarDesc";
end;

define method ITypeInfo/GetVarDesc(This :: <C-interface>, index :: <integer>)
		=> (status :: <HRESULT>, pVarDesc)
  ITypeInfo_GetVarDesc(This, index)
end;

define open generic ITypeInfo/GetNames (This, memid, rgBstrNames,
		cMaxNames) => (status :: <HRESULT>, cNames :: <integer>);

define C-callable-wrapper of ITypeInfo/GetNames
  input parameter This :: <mapped-interface>;
  input parameter memid :: <MEMBERID>;
   parameter rgBstrNames :: <LPBSTR>;
  input parameter cMaxNames :: <UINT>;
  output parameter pcNames :: <LPUINT>;
  result status :: <C-HRESULT>;
  c-name: "DW_ITypeInfo_GetNames", c-modifiers: "__stdcall";
end;

define inline-only C-function ITypeInfo_GetNames
  input parameter This :: <C-interface>;
  input parameter memid :: <MEMBERID>;
   parameter rgBstrNames :: <LPBSTR>;
  input parameter cMaxNames :: <UINT>;
  output parameter pcNames :: <LPUINT>;
  result status :: <C-HRESULT>;
  c-name: "C_ITypeInfo_GetNames";
end;

define method ITypeInfo/GetNames(This :: <C-interface>, memid :: <ffi-integer>,
		rgBstrNames :: <LPBSTR>, cMaxNames :: <integer>)
		=> (status :: <HRESULT>, cNames :: <integer>)
  ITypeInfo_GetNames(This, memid, rgBstrNames, cMaxNames)
end;

define open generic ITypeInfo/GetRefTypeOfImplType (This, index)
		=> (status :: <HRESULT>, RefType);

define C-callable-wrapper of ITypeInfo/GetRefTypeOfImplType
  input parameter This :: <mapped-interface>;
  input parameter index :: <UINT>;
  output parameter pRefType :: <LPHREFTYPE>;
  result status :: <C-HRESULT>;
  c-name: "DW_ITypeInfo_GetRefTypeOfImplType",
		c-modifiers: "__stdcall";
end;

define inline-only C-function ITypeInfo_GetRefTypeOfImplType
  input parameter This :: <C-interface>;
  input parameter index :: <UINT>;
  output parameter pRefType :: <LPHREFTYPE>;
  result status :: <C-HRESULT>;
  c-name: "C_ITypeInfo_GetRefTypeOfImplType";
end;

define method ITypeInfo/GetRefTypeOfImplType(This :: <C-interface>,
		index :: <integer>) => (status :: <HRESULT>, RefType)
  ITypeInfo_GetRefTypeOfImplType(This, index)
end;

define open generic ITypeInfo/GetImplTypeFlags (This, index)
		=> (status :: <HRESULT>, ImplTypeFlags :: <integer>);

define C-callable-wrapper of ITypeInfo/GetImplTypeFlags
  input parameter This :: <mapped-interface>;
  input parameter index :: <UINT>;
  output parameter pImplTypeFlags :: <LPINT>;
  result status :: <C-HRESULT>;
  c-name: "DW_ITypeInfo_GetImplTypeFlags",
		c-modifiers: "__stdcall";
end;

define inline-only C-function ITypeInfo_GetImplTypeFlags
  input parameter This :: <C-interface>;
  input parameter index :: <UINT>;
  output parameter pImplTypeFlags :: <LPINT>;
  result status :: <C-HRESULT>;
  c-name: "C_ITypeInfo_GetImplTypeFlags";
end;

define method ITypeInfo/GetImplTypeFlags(This :: <C-interface>,
		index :: <integer>) => (status :: <HRESULT>, ImplTypeFlags :: <integer>)
  ITypeInfo_GetImplTypeFlags(This, index)
end;

define open generic ITypeInfo/GetIDsOfNames (This, rgszNames,
		cNames, pMemId) => (status :: <HRESULT>);

define C-callable-wrapper of ITypeInfo/GetIDsOfNames
  input parameter This :: <mapped-interface>;
  input parameter rgszNames :: <LPLPOLESTR>;
  input parameter cNames :: <UINT>;
   parameter pMemId :: <LPMEMBERID>;
  result status :: <C-HRESULT>;
  c-name: "DW_ITypeInfo_GetIDsOfNames",
		c-modifiers: "__stdcall";
end;

define inline-only C-function ITypeInfo_GetIDsOfNames
  input parameter This :: <C-interface>;
  input parameter rgszNames :: <LPLPOLESTR>;
  input parameter cNames :: <UINT>;
   parameter pMemId :: <LPMEMBERID>;
  result status :: <C-HRESULT>;
  c-name: "C_ITypeInfo_GetIDsOfNames";
end;

define method ITypeInfo/GetIDsOfNames(This :: <C-interface>,
		rgszNames :: <LPLPOLESTR>, cNames :: <integer>, pMemId :: <LPMEMBERID>)
		=> (status :: <HRESULT>)
  ITypeInfo_GetIDsOfNames(This, rgszNames, cNames, pMemId)
end;

define open generic ITypeInfo/Invoke (This, pvInstance, memid,
		wFlags, pDispParams, pVarResult, pExcepInfo)
		=> (status :: <HRESULT>, uArgErr :: <integer>);

define C-callable-wrapper of ITypeInfo/Invoke
  input parameter This :: <mapped-interface>;
  input parameter pvInstance :: <C-void*>;
  input parameter memid :: <MEMBERID>;
  input parameter wFlags :: <WORD>;
   parameter pDispParams :: <LPDISPPARAMS>;
  parameter pVarResult :: <LPVARIANT>;
  parameter pExcepInfo :: <LPEXCEPINFO>;
  output parameter puArgErr :: <LPUINT>;
  result status :: <C-HRESULT>;
  c-name: "DW_ITypeInfo_Invoke", c-modifiers: "__stdcall";
end;

define inline-only C-function ITypeInfo_Invoke
  input parameter This :: <C-interface>;
  input parameter pvInstance :: <C-void*>;
  input parameter memid :: <MEMBERID>;
  input parameter wFlags :: <WORD>;
   parameter pDispParams :: <LPDISPPARAMS>;
  parameter pVarResult :: <LPVARIANT>;
  parameter pExcepInfo :: <LPEXCEPINFO>;
  output parameter puArgErr :: <LPUINT>;
  result status :: <C-HRESULT>;
  c-name: "C_ITypeInfo_Invoke";
end;

define method ITypeInfo/Invoke(This :: <C-interface>,
		pvInstance :: <C-pointer>, memid :: <ffi-integer>, wFlags :: <integer>,
		pDispParams :: <LPDISPPARAMS>, pVarResult :: <LPVARIANT>,
		pExcepInfo :: <LPEXCEPINFO>)
		=> (status :: <HRESULT>, uArgErr :: <integer>)
  let (status :: <HRESULT>, raw-arg-err) =
    ITypeInfo_Invoke(This, pvInstance, memid, wFlags, pdispparams,
		     pvarResult, pexcepinfo);
  let arg-err :: <integer> =
    if ( instance?(raw-arg-err, <integer>) )
      raw-arg-err
    else
      // Valid values for the second result will always be small positive
      // integers, but when not being used, the server might not store any
      // value, leaving random garbage that might not fit an <integer>.
      assert( status ~= $DISP-E-TYPEMISMATCH &
	       status ~= $DISP-E-PARAMNOTFOUND );
      -1
    end if;
  values(status, arg-err)
end;

define open generic ITypeInfo/GetDocumentation (This, memid)
		=> (status :: <HRESULT>, BstrName :: <BSTR>,
		BstrDocString :: <BSTR>, dwHelpContext, BstrHelpFile :: <BSTR>);

define C-callable-wrapper of ITypeInfo/GetDocumentation
  input parameter This :: <mapped-interface>;
  input parameter memid :: <MEMBERID>;
  output parameter pBstrName :: <LPBSTR>;
  output parameter pBstrDocString :: <LPBSTR>;
  output parameter pdwHelpContext :: <LPDWORD>;
  output parameter pBstrHelpFile :: <LPBSTR>;
  result status :: <C-HRESULT>;
  c-name: "DW_ITypeInfo_GetDocumentation",
		c-modifiers: "__stdcall";
end;

define inline-only C-function ITypeInfo_GetDocumentation
  input parameter This :: <C-interface>;
  input parameter memid :: <MEMBERID>;
  output parameter pBstrName :: <LPBSTR>;
  output parameter pBstrDocString :: <LPBSTR>;
  output parameter pdwHelpContext :: <LPDWORD>;
  output parameter pBstrHelpFile :: <LPBSTR>;
  result status :: <C-HRESULT>;
  c-name: "C_ITypeInfo_GetDocumentation";
end;

define method ITypeInfo/GetDocumentation(This :: <C-interface>,
		memid :: <ffi-integer>)
		=> (status :: <HRESULT>, BstrName :: <BSTR>,
		BstrDocString :: <BSTR>, dwHelpContext, BstrHelpFile :: <BSTR>)
  ITypeInfo_GetDocumentation(This, memid)
end;

define open generic ITypeInfo/GetDllEntry (This, memid, invKind)
		=> (status :: <HRESULT>, BstrDllName :: <BSTR>,
		BstrName :: <BSTR>, wOrdinal :: <integer>);

define C-callable-wrapper of ITypeInfo/GetDllEntry
  input parameter This :: <mapped-interface>;
  input parameter memid :: <MEMBERID>;
  input parameter invKind :: <INVOKEKIND>;
  output parameter pBstrDllName :: <LPBSTR>;
  output parameter pBstrName :: <LPBSTR>;
  output parameter pwOrdinal :: <LPWORD>;
  result status :: <C-HRESULT>;
  c-name: "DW_ITypeInfo_GetDllEntry", c-modifiers: "__stdcall";
end;

define inline-only C-function ITypeInfo_GetDllEntry
  input parameter This :: <C-interface>;
  input parameter memid :: <MEMBERID>;
  input parameter invKind :: <INVOKEKIND>;
  output parameter pBstrDllName :: <LPBSTR>;
  output parameter pBstrName :: <LPBSTR>;
  output parameter pwOrdinal :: <LPWORD>;
  result status :: <C-HRESULT>;
  c-name: "C_ITypeInfo_GetDllEntry";
end;

define method ITypeInfo/GetDllEntry(This :: <C-interface>, memid :: <ffi-integer>,
		invKind :: <integer>)
		=> (status :: <HRESULT>, BstrDllName :: <BSTR>,
		BstrName :: <BSTR>, wOrdinal :: <integer>)
  ITypeInfo_GetDllEntry(This, memid, invKind)
end;

define open generic ITypeInfo/GetRefTypeInfo (This, hRefType)
		=> (status :: <HRESULT>, pTInfo :: <Interface>);

define C-callable-wrapper of ITypeInfo/GetRefTypeInfo
  input parameter This :: <mapped-interface>;
  input parameter hRefType :: <HREFTYPE>;
  output parameter ppTInfo :: <Interface*>;
  result status :: <C-HRESULT>;
  c-name: "DW_ITypeInfo_GetRefTypeInfo",
		c-modifiers: "__stdcall";
end;

define inline-only C-function ITypeInfo_GetRefTypeInfo
  input parameter This :: <C-interface>;
  input parameter hRefType :: <HREFTYPE>;
  output parameter ppTInfo :: <C-interface*>;
  result status :: <C-HRESULT>;
  c-name: "C_ITypeInfo_GetRefTypeInfo";
end;

define method ITypeInfo/GetRefTypeInfo(This :: <C-interface>,
		hRefType :: <ffi-integer>) => (status :: <HRESULT>, pTInfo :: <Interface>)
  ITypeInfo_GetRefTypeInfo(This, hRefType)
end;

define open generic ITypeInfo/AddressOfMember (This, memid,
		invKind) => (status :: <HRESULT>, pv :: <C-void*>);

define C-callable-wrapper of ITypeInfo/AddressOfMember
  input parameter This :: <mapped-interface>;
  input parameter memid :: <MEMBERID>;
  input parameter invKind :: <INVOKEKIND>;
  output parameter ppv :: <C-void**>;
  result status :: <C-HRESULT>;
  c-name: "DW_ITypeInfo_AddressOfMember",
		c-modifiers: "__stdcall";
end;

define inline-only C-function ITypeInfo_AddressOfMember
  input parameter This :: <C-interface>;
  input parameter memid :: <MEMBERID>;
  input parameter invKind :: <INVOKEKIND>;
  output parameter ppv :: <C-void**>;
  result status :: <C-HRESULT>;
  c-name: "C_ITypeInfo_AddressOfMember";
end;

define method ITypeInfo/AddressOfMember(This :: <C-interface>,
		memid :: <ffi-integer>, invKind :: <integer>) => (status :: <HRESULT>, pv :: <C-void*>)
  ITypeInfo_AddressOfMember(This, memid, invKind)
end;

define open generic ITypeInfo/CreateInstance (This, pUnkOuter,
		riid) => (status :: <HRESULT>, pvObj :: <C-void*>);

define C-callable-wrapper of ITypeInfo/CreateInstance
  input parameter This :: <mapped-interface>;
  input parameter pUnkOuter :: <C-interface>;
  input parameter riid :: <REFIID>;
  output parameter ppvObj :: <C-void**>;
  result status :: <C-HRESULT>;
  c-name: "DW_ITypeInfo_CreateInstance",
		c-modifiers: "__stdcall";
end;

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

define method ITypeInfo/CreateInstance(This :: <C-interface>,
		pUnkOuter :: <Interface>, riid :: <REFIID>)
		=> (status :: <HRESULT>, pvObj :: <C-void*>)
  ITypeInfo_CreateInstance(This, pUnkOuter, riid)
end;

define open generic ITypeInfo/GetMops (This, memid)
		=> (status :: <HRESULT>, BstrMops :: <BSTR>);

define C-callable-wrapper of ITypeInfo/GetMops
  input parameter This :: <mapped-interface>;
  input parameter memid :: <MEMBERID>;
  output parameter pBstrMops :: <LPBSTR>;
  result status :: <C-HRESULT>;
  c-name: "DW_ITypeInfo_GetMops", c-modifiers: "__stdcall";
end;

define inline-only C-function ITypeInfo_GetMops
  input parameter This :: <C-interface>;
  input parameter memid :: <MEMBERID>;
  output parameter pBstrMops :: <LPBSTR>;
  result status :: <C-HRESULT>;
  c-name: "C_ITypeInfo_GetMops";
end;

define method ITypeInfo/GetMops(This :: <C-interface>, memid :: <ffi-integer>)
		=> (status :: <HRESULT>, BstrMops :: <BSTR>)
  ITypeInfo_GetMops(This, memid)
end;

define open generic ITypeInfo/GetContainingTypeLib (This)
		=> (status :: <HRESULT>, pTLib :: <Interface>,
		Index :: <integer>);

define C-callable-wrapper of ITypeInfo/GetContainingTypeLib
  input parameter This :: <mapped-interface>;
  output parameter ppTLib :: <Interface*>;
  output parameter pIndex :: <LPUINT>;
  result status :: <C-HRESULT>;
  c-name: "DW_ITypeInfo_GetContainingTypeLib",
		c-modifiers: "__stdcall";
end;

define inline-only C-function ITypeInfo_GetContainingTypeLib
  input parameter This :: <C-interface>;
  output parameter ppTLib :: <C-interface*>;
  output parameter pIndex :: <LPUINT>;
  result status :: <C-HRESULT>;
  c-name: "C_ITypeInfo_GetContainingTypeLib";
end;

define method ITypeInfo/GetContainingTypeLib(This :: <C-interface>)
		=> (status :: <HRESULT>, pTLib :: <Interface>,
		Index :: <integer>)
  ITypeInfo_GetContainingTypeLib(This)
end;

define open generic ITypeInfo/ReleaseTypeAttr (This, pTypeAttr)
		=> ();

define C-callable-wrapper of ITypeInfo/ReleaseTypeAttr
  input parameter This :: <mapped-interface>;
  input parameter pTypeAttr :: <LPTYPEATTR>;
  c-name: "DW_ITypeInfo_ReleaseTypeAttr",
		c-modifiers: "__stdcall";
end;

define inline-only C-function ITypeInfo_ReleaseTypeAttr
  input parameter This :: <C-interface>;
  input parameter pTypeAttr :: <LPTYPEATTR>;
  c-name: "C_ITypeInfo_ReleaseTypeAttr";
end;

define method ITypeInfo/ReleaseTypeAttr(This :: <C-interface>,
		pTypeAttr :: <LPTYPEATTR>) => ()
  ITypeInfo_ReleaseTypeAttr(This, pTypeAttr)
end;

define open generic ITypeInfo/ReleaseFuncDesc (This, pFuncDesc)
		=> ();

define C-callable-wrapper of ITypeInfo/ReleaseFuncDesc
  input parameter This :: <mapped-interface>;
  input parameter pFuncDesc :: <LPFUNCDESC>;
  c-name: "DW_ITypeInfo_ReleaseFuncDesc",
		c-modifiers: "__stdcall";
end;

define inline-only C-function ITypeInfo_ReleaseFuncDesc
  input parameter This :: <C-interface>;
  input parameter pFuncDesc :: <LPFUNCDESC>;
  c-name: "C_ITypeInfo_ReleaseFuncDesc";
end;

define method ITypeInfo/ReleaseFuncDesc(This :: <C-interface>,
		pFuncDesc :: <LPFUNCDESC>) => ()
  ITypeInfo_ReleaseFuncDesc(This, pFuncDesc)
end;

define open generic ITypeInfo/ReleaseVarDesc (This, pVarDesc)
		=> ();

define C-callable-wrapper of ITypeInfo/ReleaseVarDesc
  input parameter This :: <mapped-interface>;
  input parameter pVarDesc :: <LPVARDESC>;
  c-name: "DW_ITypeInfo_ReleaseVarDesc",
		c-modifiers: "__stdcall";
end;

define inline-only C-function ITypeInfo_ReleaseVarDesc
  input parameter This :: <C-interface>;
  input parameter pVarDesc :: <LPVARDESC>;
  c-name: "C_ITypeInfo_ReleaseVarDesc";
end;

define method ITypeInfo/ReleaseVarDesc(This :: <C-interface>,
		pVarDesc :: <LPVARDESC>) => ()
  ITypeInfo_ReleaseVarDesc(This, pVarDesc)
end;


	/*  ----  ITypeInfo2  ----  */


define open primary COM-interface <ITypeInfo2> ( <ITypeInfo> )
end <ITypeInfo2>;

define C-address ITypeInfo2_DW_vtbl :: <C-COM-vtbl>
		c-name: "ITypeInfo2_DW_vtbl"; end;
define C-address $IID-ITypeInfo2 :: <REFIID>
		c-name: "IID_ITypeInfo2"; end;

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

define open generic ITypeInfo2/GetTypeKind (This)
		=> (status :: <HRESULT>, TypeKind);

define C-callable-wrapper of ITypeInfo2/GetTypeKind
  input parameter This :: <mapped-interface>;
  output parameter pTypeKind :: <LPTYPEKIND>;
  result status :: <C-HRESULT>;
  c-name: "DW_ITypeInfo2_GetTypeKind", c-modifiers: "__stdcall";
end;

define inline-only C-function ITypeInfo2_GetTypeKind
  input parameter This :: <C-interface>;
  output parameter pTypeKind :: <LPTYPEKIND>;
  result status :: <C-HRESULT>;
  c-name: "C_ITypeInfo2_GetTypeKind";
end;

define method ITypeInfo2/GetTypeKind(This :: <C-interface>)
		=> (status :: <HRESULT>, TypeKind)
  ITypeInfo2_GetTypeKind(This)
end;

define open generic ITypeInfo2/GetTypeFlags (This)
		=> (status :: <HRESULT>, TypeFlags);

define C-callable-wrapper of ITypeInfo2/GetTypeFlags
  input parameter This :: <mapped-interface>;
  output parameter pTypeFlags :: <LPULONG>;
  result status :: <C-HRESULT>;
  c-name: "DW_ITypeInfo2_GetTypeFlags",
		c-modifiers: "__stdcall";
end;

define inline-only C-function ITypeInfo2_GetTypeFlags
  input parameter This :: <C-interface>;
  output parameter pTypeFlags :: <LPULONG>;
  result status :: <C-HRESULT>;
  c-name: "C_ITypeInfo2_GetTypeFlags";
end;

define method ITypeInfo2/GetTypeFlags(This :: <C-interface>)
		=> (status :: <HRESULT>, TypeFlags)
  ITypeInfo2_GetTypeFlags(This)
end;

define open generic ITypeInfo2/GetFuncIndexOfMemId (This, memid,
		invKind) => (status :: <HRESULT>, FuncIndex :: <integer>);

define C-callable-wrapper of ITypeInfo2/GetFuncIndexOfMemId
  input parameter This :: <mapped-interface>;
  input parameter memid :: <MEMBERID>;
  input parameter invKind :: <INVOKEKIND>;
  output parameter pFuncIndex :: <LPUINT>;
  result status :: <C-HRESULT>;
  c-name: "DW_ITypeInfo2_GetFuncIndexOfMemId",
		c-modifiers: "__stdcall";
end;

define inline-only C-function ITypeInfo2_GetFuncIndexOfMemId
  input parameter This :: <C-interface>;
  input parameter memid :: <MEMBERID>;
  input parameter invKind :: <INVOKEKIND>;
  output parameter pFuncIndex :: <LPUINT>;
  result status :: <C-HRESULT>;
  c-name: "C_ITypeInfo2_GetFuncIndexOfMemId";
end;

define method ITypeInfo2/GetFuncIndexOfMemId(This :: <C-interface>,
		memid :: <ffi-integer>, invKind :: <integer>)
		=> (status :: <HRESULT>, FuncIndex :: <integer>)
  ITypeInfo2_GetFuncIndexOfMemId(This, memid, invKind)
end;

define open generic ITypeInfo2/GetVarIndexOfMemId (This, memid)
		=> (status :: <HRESULT>, VarIndex :: <integer>);

define C-callable-wrapper of ITypeInfo2/GetVarIndexOfMemId
  input parameter This :: <mapped-interface>;
  input parameter memid :: <MEMBERID>;
  output parameter pVarIndex :: <LPUINT>;
  result status :: <C-HRESULT>;
  c-name: "DW_ITypeInfo2_GetVarIndexOfMemId",
		c-modifiers: "__stdcall";
end;

define inline-only C-function ITypeInfo2_GetVarIndexOfMemId
  input parameter This :: <C-interface>;
  input parameter memid :: <MEMBERID>;
  output parameter pVarIndex :: <LPUINT>;
  result status :: <C-HRESULT>;
  c-name: "C_ITypeInfo2_GetVarIndexOfMemId";
end;

define method ITypeInfo2/GetVarIndexOfMemId(This :: <C-interface>,
		memid :: <ffi-integer>) => (status :: <HRESULT>, VarIndex :: <integer>)
  ITypeInfo2_GetVarIndexOfMemId(This, memid)
end;

define open generic ITypeInfo2/GetCustData (This, guid, pVarVal)
		=> (status :: <HRESULT>);

define C-callable-wrapper of ITypeInfo2/GetCustData
  input parameter This :: <mapped-interface>;
  input parameter guid :: <REFGUID>;
  parameter pVarVal :: <LPVARIANT>;
  result status :: <C-HRESULT>;
  c-name: "DW_ITypeInfo2_GetCustData", c-modifiers: "__stdcall";
end;

define inline-only C-function ITypeInfo2_GetCustData
  input parameter This :: <C-interface>;
  input parameter guid :: <REFGUID>;
  parameter pVarVal :: <LPVARIANT>;
  result status :: <C-HRESULT>;
  c-name: "C_ITypeInfo2_GetCustData";
end;

define method ITypeInfo2/GetCustData(This :: <C-interface>, guid :: <REFGUID>,
		pVarVal :: <LPVARIANT>) => (status :: <HRESULT>)
  ITypeInfo2_GetCustData(This, guid, pVarVal)
end;

define open generic ITypeInfo2/GetFuncCustData (This, index,
		guid, pVarVal) => (status :: <HRESULT>);

define C-callable-wrapper of ITypeInfo2/GetFuncCustData
  input parameter This :: <mapped-interface>;
  input parameter index :: <UINT>;
  input parameter guid :: <REFGUID>;
  parameter pVarVal :: <LPVARIANT>;
  result status :: <C-HRESULT>;
  c-name: "DW_ITypeInfo2_GetFuncCustData",
		c-modifiers: "__stdcall";
end;

define inline-only C-function ITypeInfo2_GetFuncCustData
  input parameter This :: <C-interface>;
  input parameter index :: <UINT>;
  input parameter guid :: <REFGUID>;
  parameter pVarVal :: <LPVARIANT>;
  result status :: <C-HRESULT>;
  c-name: "C_ITypeInfo2_GetFuncCustData";
end;

define method ITypeInfo2/GetFuncCustData(This :: <C-interface>,
		index :: <integer>, guid :: <REFGUID>, pVarVal :: <LPVARIANT>) => (status :: <HRESULT>)
  ITypeInfo2_GetFuncCustData(This, index, guid, pVarVal)
end;

define open generic ITypeInfo2/GetParamCustData (This, indexFunc,
		indexParam, guid, pVarVal) => (status :: <HRESULT>);

define C-callable-wrapper of ITypeInfo2/GetParamCustData
  input parameter This :: <mapped-interface>;
  input parameter indexFunc :: <UINT>;
  input parameter indexParam :: <UINT>;
  input parameter guid :: <REFGUID>;
  parameter pVarVal :: <LPVARIANT>;
  result status :: <C-HRESULT>;
  c-name: "DW_ITypeInfo2_GetParamCustData",
		c-modifiers: "__stdcall";
end;

define inline-only C-function ITypeInfo2_GetParamCustData
  input parameter This :: <C-interface>;
  input parameter indexFunc :: <UINT>;
  input parameter indexParam :: <UINT>;
  input parameter guid :: <REFGUID>;
  parameter pVarVal :: <LPVARIANT>;
  result status :: <C-HRESULT>;
  c-name: "C_ITypeInfo2_GetParamCustData";
end;

define method ITypeInfo2/GetParamCustData(This :: <C-interface>,
		indexFunc :: <integer>, indexParam :: <integer>,
                guid :: <REFGUID>, pVarVal :: <LPVARIANT>)
		=> (status :: <HRESULT>)
  ITypeInfo2_GetParamCustData(This, indexFunc, indexParam, guid,
		pVarVal)
end;

define open generic ITypeInfo2/GetVarCustData (This, index, guid,
		pVarVal) => (status :: <HRESULT>);

define C-callable-wrapper of ITypeInfo2/GetVarCustData
  input parameter This :: <mapped-interface>;
  input parameter index :: <UINT>;
  input parameter guid :: <REFGUID>;
  parameter pVarVal :: <LPVARIANT>;
  result status :: <C-HRESULT>;
  c-name: "DW_ITypeInfo2_GetVarCustData",
		c-modifiers: "__stdcall";
end;

define inline-only C-function ITypeInfo2_GetVarCustData
  input parameter This :: <C-interface>;
  input parameter index :: <UINT>;
  input parameter guid :: <REFGUID>;
  parameter pVarVal :: <LPVARIANT>;
  result status :: <C-HRESULT>;
  c-name: "C_ITypeInfo2_GetVarCustData";
end;

define method ITypeInfo2/GetVarCustData(This :: <C-interface>,
		index :: <integer>, guid :: <REFGUID>, pVarVal :: <LPVARIANT>) => (status :: <HRESULT>)
  ITypeInfo2_GetVarCustData(This, index, guid, pVarVal)
end;

define open generic ITypeInfo2/GetImplTypeCustData (This, index,
		guid, pVarVal) => (status :: <HRESULT>);

define C-callable-wrapper of ITypeInfo2/GetImplTypeCustData
  input parameter This :: <mapped-interface>;
  input parameter index :: <UINT>;
  input parameter guid :: <REFGUID>;
  parameter pVarVal :: <LPVARIANT>;
  result status :: <C-HRESULT>;
  c-name: "DW_ITypeInfo2_GetImplTypeCustData",
		c-modifiers: "__stdcall";
end;

define inline-only C-function ITypeInfo2_GetImplTypeCustData
  input parameter This :: <C-interface>;
  input parameter index :: <UINT>;
  input parameter guid :: <REFGUID>;
  parameter pVarVal :: <LPVARIANT>;
  result status :: <C-HRESULT>;
  c-name: "C_ITypeInfo2_GetImplTypeCustData";
end;

define method ITypeInfo2/GetImplTypeCustData(This :: <C-interface>,
		index :: <integer>, guid :: <REFGUID>, pVarVal :: <LPVARIANT>) => (status :: <HRESULT>)
  ITypeInfo2_GetImplTypeCustData(This, index, guid, pVarVal)
end;

define open generic ITypeInfo2/GetDocumentation2 (This, memid,
		lcid)
		=> (status :: <HRESULT>, bstrHelpString :: <BSTR>,
		dwHelpStringContext, bstrHelpStringDll :: <BSTR>);

define C-callable-wrapper of ITypeInfo2/GetDocumentation2
  input parameter This :: <mapped-interface>;
  input parameter memid :: <MEMBERID>;
  input parameter lcid :: <LCID>;
  output parameter pbstrHelpString :: <LPBSTR>;
  output parameter pdwHelpStringContext :: <LPDWORD>;
  output parameter pbstrHelpStringDll :: <LPBSTR>;
  result status :: <C-HRESULT>;
  c-name: "DW_ITypeInfo2_GetDocumentation2",
		c-modifiers: "__stdcall";
end;

define inline-only C-function ITypeInfo2_GetDocumentation2
  input parameter This :: <C-interface>;
  input parameter memid :: <MEMBERID>;
  input parameter lcid :: <LCID>;
  output parameter pbstrHelpString :: <LPBSTR>;
  output parameter pdwHelpStringContext :: <LPDWORD>;
  output parameter pbstrHelpStringDll :: <LPBSTR>;
  result status :: <C-HRESULT>;
  c-name: "C_ITypeInfo2_GetDocumentation2";
end;

define method ITypeInfo2/GetDocumentation2(This :: <C-interface>,
		memid :: <ffi-integer>, lcid :: <ffi-integer>)
		=> (status :: <HRESULT>, bstrHelpString :: <BSTR>,
		dwHelpStringContext, bstrHelpStringDll :: <BSTR>)
  ITypeInfo2_GetDocumentation2(This, memid, lcid)
end;

define open generic ITypeInfo2/GetAllCustData (This, pCustData)
		=> (status :: <HRESULT>);

define C-callable-wrapper of ITypeInfo2/GetAllCustData
  input parameter This :: <mapped-interface>;
  parameter pCustData :: <LPCUSTDATA>;
  result status :: <C-HRESULT>;
  c-name: "DW_ITypeInfo2_GetAllCustData",
		c-modifiers: "__stdcall";
end;

define inline-only C-function ITypeInfo2_GetAllCustData
  input parameter This :: <C-interface>;
  parameter pCustData :: <LPCUSTDATA>;
  result status :: <C-HRESULT>;
  c-name: "C_ITypeInfo2_GetAllCustData";
end;

define method ITypeInfo2/GetAllCustData(This :: <C-interface>,
		pCustData :: <LPCUSTDATA>) => (status :: <HRESULT>)
  ITypeInfo2_GetAllCustData(This, pCustData)
end;

define open generic ITypeInfo2/GetAllFuncCustData (This, index,
		pCustData) => (status :: <HRESULT>);

define C-callable-wrapper of ITypeInfo2/GetAllFuncCustData
  input parameter This :: <mapped-interface>;
  input parameter index :: <UINT>;
  parameter pCustData :: <LPCUSTDATA>;
  result status :: <C-HRESULT>;
  c-name: "DW_ITypeInfo2_GetAllFuncCustData",
		c-modifiers: "__stdcall";
end;

define inline-only C-function ITypeInfo2_GetAllFuncCustData
  input parameter This :: <C-interface>;
  input parameter index :: <UINT>;
  parameter pCustData :: <LPCUSTDATA>;
  result status :: <C-HRESULT>;
  c-name: "C_ITypeInfo2_GetAllFuncCustData";
end;

define method ITypeInfo2/GetAllFuncCustData(This :: <C-interface>,
		index :: <integer>, pCustData :: <LPCUSTDATA>) => (status :: <HRESULT>)
  ITypeInfo2_GetAllFuncCustData(This, index, pCustData)
end;

define open generic ITypeInfo2/GetAllParamCustData (This,
		indexFunc, indexParam, pCustData) => (status :: <HRESULT>);

define C-callable-wrapper of ITypeInfo2/GetAllParamCustData
  input parameter This :: <mapped-interface>;
  input parameter indexFunc :: <UINT>;
  input parameter indexParam :: <UINT>;
  parameter pCustData :: <LPCUSTDATA>;
  result status :: <C-HRESULT>;
  c-name: "DW_ITypeInfo2_GetAllParamCustData",
		c-modifiers: "__stdcall";
end;

define inline-only C-function ITypeInfo2_GetAllParamCustData
  input parameter This :: <C-interface>;
  input parameter indexFunc :: <UINT>;
  input parameter indexParam :: <UINT>;
  parameter pCustData :: <LPCUSTDATA>;
  result status :: <C-HRESULT>;
  c-name: "C_ITypeInfo2_GetAllParamCustData";
end;

define method ITypeInfo2/GetAllParamCustData(This :: <C-interface>,
		indexFunc :: <integer>, indexParam :: <integer>, pCustData :: <LPCUSTDATA>)
		=> (status :: <HRESULT>)
  ITypeInfo2_GetAllParamCustData(This, indexFunc, indexParam,
		pCustData)
end;

define open generic ITypeInfo2/GetAllVarCustData (This, index,
		pCustData) => (status :: <HRESULT>);

define C-callable-wrapper of ITypeInfo2/GetAllVarCustData
  input parameter This :: <mapped-interface>;
  input parameter index :: <UINT>;
  parameter pCustData :: <LPCUSTDATA>;
  result status :: <C-HRESULT>;
  c-name: "DW_ITypeInfo2_GetAllVarCustData",
		c-modifiers: "__stdcall";
end;

define inline-only C-function ITypeInfo2_GetAllVarCustData
  input parameter This :: <C-interface>;
  input parameter index :: <UINT>;
  parameter pCustData :: <LPCUSTDATA>;
  result status :: <C-HRESULT>;
  c-name: "C_ITypeInfo2_GetAllVarCustData";
end;

define method ITypeInfo2/GetAllVarCustData(This :: <C-interface>,
		index :: <integer>, pCustData :: <LPCUSTDATA>) => (status :: <HRESULT>)
  ITypeInfo2_GetAllVarCustData(This, index, pCustData)
end;

define open generic ITypeInfo2/GetAllImplTypeCustData (This,
		index, pCustData) => (status :: <HRESULT>);

define C-callable-wrapper of ITypeInfo2/GetAllImplTypeCustData
  input parameter This :: <mapped-interface>;
  input parameter index :: <UINT>;
  parameter pCustData :: <LPCUSTDATA>;
  result status :: <C-HRESULT>;
  c-name: "DW_ITypeInfo2_GetAllImplTypeCustData",
		c-modifiers: "__stdcall";
end;

define inline-only C-function ITypeInfo2_GetAllImplTypeCustData
  input parameter This :: <C-interface>;
  input parameter index :: <UINT>;
  parameter pCustData :: <LPCUSTDATA>;
  result status :: <C-HRESULT>;
  c-name: "C_ITypeInfo2_GetAllImplTypeCustData";
end;

define method ITypeInfo2/GetAllImplTypeCustData(This :: <C-interface>,
		index :: <integer>, pCustData :: <LPCUSTDATA>) => (status :: <HRESULT>)
  ITypeInfo2_GetAllImplTypeCustData(This, index, pCustData)
end;


	/*  ----  ITypeLib  ----  */


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

define C-address ITypeLib_DW_vtbl :: <C-COM-vtbl>
		c-name: "ITypeLib_DW_vtbl"; end;
define C-address $IID-ITypeLib :: <REFIID>
		c-name: "IID_ITypeLib"; end;

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

define open generic ITypeLib/GetTypeInfoCount (This) => (value);

define C-callable-wrapper of ITypeLib/GetTypeInfoCount
  input parameter This :: <mapped-interface>;
  result value :: <UINT>;
  c-name: "DW_ITypeLib_GetTypeInfoCount",
		c-modifiers: "__stdcall";
end;

define inline-only C-function ITypeLib_GetTypeInfoCount
  input parameter This :: <C-interface>;
  result value :: <UINT>;
  c-name: "C_ITypeLib_GetTypeInfoCount";
end;

define method ITypeLib/GetTypeInfoCount(This :: <C-interface>)
		=> (value)
  ITypeLib_GetTypeInfoCount(This)
end;

define open generic ITypeLib/GetTypeInfo (This, index)
		=> (status :: <HRESULT>, pTInfo :: <Interface>);

define C-callable-wrapper of ITypeLib/GetTypeInfo
  input parameter This :: <mapped-interface>;
  input parameter index :: <UINT>;
  output parameter ppTInfo :: <Interface*>;
  result status :: <C-HRESULT>;
  c-name: "DW_ITypeLib_GetTypeInfo", c-modifiers: "__stdcall";
end;

define inline-only C-function ITypeLib_GetTypeInfo
  input parameter This :: <C-interface>;
  input parameter index :: <UINT>;
  output parameter ppTInfo :: <C-interface*>;
  result status :: <C-HRESULT>;
  c-name: "C_ITypeLib_GetTypeInfo";
end;

define method ITypeLib/GetTypeInfo(This :: <C-interface>, index :: <integer>)
		=> (status :: <HRESULT>, pTInfo :: <Interface>)
  ITypeLib_GetTypeInfo(This, index)
end;

define open generic ITypeLib/GetTypeInfoType (This, index)
		=> (status :: <HRESULT>, TKind);

define C-callable-wrapper of ITypeLib/GetTypeInfoType
  input parameter This :: <mapped-interface>;
  input parameter index :: <UINT>;
  output parameter pTKind :: <LPTYPEKIND>;
  result status :: <C-HRESULT>;
  c-name: "DW_ITypeLib_GetTypeInfoType",
		c-modifiers: "__stdcall";
end;

define inline-only C-function ITypeLib_GetTypeInfoType
  input parameter This :: <C-interface>;
  input parameter index :: <UINT>;
  output parameter pTKind :: <LPTYPEKIND>;
  result status :: <C-HRESULT>;
  c-name: "C_ITypeLib_GetTypeInfoType";
end;

define method ITypeLib/GetTypeInfoType(This :: <C-interface>,
		index :: <integer>) => (status :: <HRESULT>, TKind)
  ITypeLib_GetTypeInfoType(This, index)
end;

define open generic ITypeLib/GetTypeInfoOfGuid (This, guid)
		=> (status :: <HRESULT>, pTinfo :: <Interface>);

define C-callable-wrapper of ITypeLib/GetTypeInfoOfGuid
  input parameter This :: <mapped-interface>;
  input parameter guid :: <REFGUID>;
  output parameter ppTinfo :: <Interface*>;
  result status :: <C-HRESULT>;
  c-name: "DW_ITypeLib_GetTypeInfoOfGuid",
		c-modifiers: "__stdcall";
end;

define inline-only C-function ITypeLib_GetTypeInfoOfGuid
  input parameter This :: <C-interface>;
  input parameter guid :: <REFGUID>;
  output parameter ppTinfo :: <C-interface*>;
  result status :: <C-HRESULT>;
  c-name: "C_ITypeLib_GetTypeInfoOfGuid";
end;

define method ITypeLib/GetTypeInfoOfGuid(This :: <C-interface>,
		guid :: <REFGUID>) => (status :: <HRESULT>, pTinfo :: <Interface>)
  ITypeLib_GetTypeInfoOfGuid(This, guid)
end;

define open generic ITypeLib/GetLibAttr (This)
		=> (status :: <HRESULT>, pTLibAttr);

define C-callable-wrapper of ITypeLib/GetLibAttr
  input parameter This :: <mapped-interface>;
  output parameter ppTLibAttr :: <TLIBATTR**>;
  result status :: <C-HRESULT>;
  c-name: "DW_ITypeLib_GetLibAttr", c-modifiers: "__stdcall";
end;

define inline-only C-function ITypeLib_GetLibAttr
  input parameter This :: <C-interface>;
  output parameter ppTLibAttr :: <TLIBATTR**>;
  result status :: <C-HRESULT>;
  c-name: "C_ITypeLib_GetLibAttr";
end;

define method ITypeLib/GetLibAttr(This :: <C-interface>)
		=> (status :: <HRESULT>, pTLibAttr)
  ITypeLib_GetLibAttr(This)
end;

define open generic ITypeLib/GetTypeComp (This)
		=> (status :: <HRESULT>, pTComp :: <Interface>);

define C-callable-wrapper of ITypeLib/GetTypeComp
  input parameter This :: <mapped-interface>;
  output parameter ppTComp :: <Interface*>;
  result status :: <C-HRESULT>;
  c-name: "DW_ITypeLib_GetTypeComp", c-modifiers: "__stdcall";
end;

define inline-only C-function ITypeLib_GetTypeComp
  input parameter This :: <C-interface>;
  output parameter ppTComp :: <C-interface*>;
  result status :: <C-HRESULT>;
  c-name: "C_ITypeLib_GetTypeComp";
end;

define method ITypeLib/GetTypeComp(This :: <C-interface>)
		=> (status :: <HRESULT>, pTComp :: <Interface>)
  ITypeLib_GetTypeComp(This)
end;

define open generic ITypeLib/GetDocumentation (This, index)
		=> (status :: <HRESULT>, BstrName :: <BSTR>,
		BstrDocString :: <BSTR>, dwHelpContext, BstrHelpFile :: <BSTR>);

define C-callable-wrapper of ITypeLib/GetDocumentation
  input parameter This :: <mapped-interface>;
  input parameter index :: <INT>;
  output parameter pBstrName :: <LPBSTR>;
  output parameter pBstrDocString :: <LPBSTR>;
  output parameter pdwHelpContext :: <LPDWORD>;
  output parameter pBstrHelpFile :: <LPBSTR>;
  result status :: <C-HRESULT>;
  c-name: "DW_ITypeLib_GetDocumentation",
		c-modifiers: "__stdcall";
end;

define inline-only C-function ITypeLib_GetDocumentation
  input parameter This :: <C-interface>;
  input parameter index :: <INT>;
  output parameter pBstrName :: <LPBSTR>;
  output parameter pBstrDocString :: <LPBSTR>;
  output parameter pdwHelpContext :: <LPDWORD>;
  output parameter pBstrHelpFile :: <LPBSTR>;
  result status :: <C-HRESULT>;
  c-name: "C_ITypeLib_GetDocumentation";
end;

define method ITypeLib/GetDocumentation(This :: <C-interface>,
		index :: <integer>)
		=> (status :: <HRESULT>, BstrName :: <BSTR>,
		BstrDocString :: <BSTR>, dwHelpContext, BstrHelpFile :: <BSTR>)
  ITypeLib_GetDocumentation(This, index)
end;

define open generic ITypeLib/IsName (This, szNameBuf, lHashVal)
		=> (status :: <HRESULT>, fName :: <boolean>);

define C-callable-wrapper of ITypeLib/IsName
  input parameter This :: <mapped-interface>;
   parameter szNameBuf :: <LPOLESTR>;
  input parameter lHashVal :: <ULONG>;
  output parameter pfName :: <LPBOOL>;
  result status :: <C-HRESULT>;
  c-name: "DW_ITypeLib_IsName", c-modifiers: "__stdcall";
end;

define inline-only C-function ITypeLib_IsName
  input parameter This :: <C-interface>;
   parameter szNameBuf :: <LPOLESTR>;
  input parameter lHashVal :: <ULONG>;
  output parameter pfName :: <LPBOOL>;
  result status :: <C-HRESULT>;
  c-name: "C_ITypeLib_IsName";
end;

define method ITypeLib/IsName(This :: <C-interface>,
		szNameBuf :: <LPOLESTR>, lHashVal :: <ffi-integer>)
		=> (status :: <HRESULT>, fName :: <boolean>)
  ITypeLib_IsName(This, szNameBuf, lHashVal)
end;

define open generic ITypeLib/FindName (This, szNameBuf, lHashVal,
		ppTInfo, rgMemId, pcFound) => (status :: <HRESULT>);

define C-callable-wrapper of ITypeLib/FindName
  input parameter This :: <mapped-interface>;
   parameter szNameBuf :: <LPOLESTR>;
  input parameter lHashVal :: <ULONG>;
   parameter ppTInfo :: <Interface*>;
   parameter rgMemId :: <LPMEMBERID>;
   parameter pcFound :: <LPUSHORT>;
  result status :: <C-HRESULT>;
  c-name: "DW_ITypeLib_FindName", c-modifiers: "__stdcall";
end;

define inline-only C-function ITypeLib_FindName
  input parameter This :: <C-interface>;
   parameter szNameBuf :: <LPOLESTR>;
  input parameter lHashVal :: <ULONG>;
   parameter ppTInfo :: <Interface*>;
   parameter rgMemId :: <LPMEMBERID>;
   parameter pcFound :: <LPUSHORT>;
  result status :: <C-HRESULT>;
  c-name: "C_ITypeLib_FindName";
end;

define method ITypeLib/FindName(This :: <C-interface>,
		szNameBuf :: <LPOLESTR>, lHashVal :: <ffi-integer>, ppTInfo :: <Interface*>,
		rgMemId :: <LPMEMBERID>, pcFound :: <LPUSHORT>)
		=> (status :: <HRESULT>)
  ITypeLib_FindName(This, szNameBuf, lHashVal, ppTInfo, rgMemId,
		pcFound)
end;

define open generic ITypeLib/ReleaseTLibAttr (This, pTLibAttr)
		=> ();

define C-callable-wrapper of ITypeLib/ReleaseTLibAttr
  input parameter This :: <mapped-interface>;
  input parameter pTLibAttr :: <LPTLIBATTR>;
  c-name: "DW_ITypeLib_ReleaseTLibAttr",
		c-modifiers: "__stdcall";
end;

define inline-only C-function ITypeLib_ReleaseTLibAttr
  input parameter This :: <C-interface>;
  input parameter pTLibAttr :: <LPTLIBATTR>;
  c-name: "C_ITypeLib_ReleaseTLibAttr";
end;

define method ITypeLib/ReleaseTLibAttr(This :: <C-interface>,
		pTLibAttr :: <LPTLIBATTR>) => ()
  ITypeLib_ReleaseTLibAttr(This, pTLibAttr)
end;


	/*  ----  ITypeLib2  ----  */


define open primary COM-interface <ITypeLib2> ( <ITypeLib> )
end <ITypeLib2>;

define C-address ITypeLib2_DW_vtbl :: <C-COM-vtbl>
		c-name: "ITypeLib2_DW_vtbl"; end;
define C-address $IID-ITypeLib2 :: <REFIID>
		c-name: "IID_ITypeLib2"; end;

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

define open generic ITypeLib2/GetCustData (This, guid, pVarVal)
		=> (status :: <HRESULT>);

define C-callable-wrapper of ITypeLib2/GetCustData
  input parameter This :: <mapped-interface>;
  input parameter guid :: <REFGUID>;
  parameter pVarVal :: <LPVARIANT>;
  result status :: <C-HRESULT>;
  c-name: "DW_ITypeLib2_GetCustData", c-modifiers: "__stdcall";
end;

define inline-only C-function ITypeLib2_GetCustData
  input parameter This :: <C-interface>;
  input parameter guid :: <REFGUID>;
  parameter pVarVal :: <LPVARIANT>;
  result status :: <C-HRESULT>;
  c-name: "C_ITypeLib2_GetCustData";
end;

define method ITypeLib2/GetCustData(This :: <C-interface>, guid :: <REFGUID>,
		pVarVal :: <LPVARIANT>) => (status :: <HRESULT>)
  ITypeLib2_GetCustData(This, guid, pVarVal)
end;

define open generic ITypeLib2/GetLibStatistics (This)
		=> (status :: <HRESULT>, cUniqueNames, cchUniqueNames);

define C-callable-wrapper of ITypeLib2/GetLibStatistics
  input parameter This :: <mapped-interface>;
  output parameter pcUniqueNames :: <LPULONG>;
  output parameter pcchUniqueNames :: <LPULONG>;
  result status :: <C-HRESULT>;
  c-name: "DW_ITypeLib2_GetLibStatistics",
		c-modifiers: "__stdcall";
end;

define inline-only C-function ITypeLib2_GetLibStatistics
  input parameter This :: <C-interface>;
  output parameter pcUniqueNames :: <LPULONG>;
  output parameter pcchUniqueNames :: <LPULONG>;
  result status :: <C-HRESULT>;
  c-name: "C_ITypeLib2_GetLibStatistics";
end;

define method ITypeLib2/GetLibStatistics(This :: <C-interface>)
		=> (status :: <HRESULT>, cUniqueNames, cchUniqueNames)
  ITypeLib2_GetLibStatistics(This)
end;

define open generic ITypeLib2/GetDocumentation2 (This, index,
		lcid)
		=> (status :: <HRESULT>, bstrHelpString :: <BSTR>,
		dwHelpStringContext, bstrHelpStringDll :: <BSTR>);

define C-callable-wrapper of ITypeLib2/GetDocumentation2
  input parameter This :: <mapped-interface>;
  input parameter index :: <INT>;
  input parameter lcid :: <LCID>;
  output parameter pbstrHelpString :: <LPBSTR>;
  output parameter pdwHelpStringContext :: <LPDWORD>;
  output parameter pbstrHelpStringDll :: <LPBSTR>;
  result status :: <C-HRESULT>;
  c-name: "DW_ITypeLib2_GetDocumentation2",
		c-modifiers: "__stdcall";
end;

define inline-only C-function ITypeLib2_GetDocumentation2
  input parameter This :: <C-interface>;
  input parameter index :: <INT>;
  input parameter lcid :: <LCID>;
  output parameter pbstrHelpString :: <LPBSTR>;
  output parameter pdwHelpStringContext :: <LPDWORD>;
  output parameter pbstrHelpStringDll :: <LPBSTR>;
  result status :: <C-HRESULT>;
  c-name: "C_ITypeLib2_GetDocumentation2";
end;

define method ITypeLib2/GetDocumentation2(This :: <C-interface>,
		index :: <integer>, lcid :: <ffi-integer>)
		=> (status :: <HRESULT>, bstrHelpString :: <BSTR>,
		dwHelpStringContext, bstrHelpStringDll :: <BSTR>)
  ITypeLib2_GetDocumentation2(This, index, lcid)
end;

define open generic ITypeLib2/GetAllCustData (This, pCustData)
		=> (status :: <HRESULT>);

define C-callable-wrapper of ITypeLib2/GetAllCustData
  input parameter This :: <mapped-interface>;
  parameter pCustData :: <LPCUSTDATA>;
  result status :: <C-HRESULT>;
  c-name: "DW_ITypeLib2_GetAllCustData",
		c-modifiers: "__stdcall";
end;

define inline-only C-function ITypeLib2_GetAllCustData
  input parameter This :: <C-interface>;
  parameter pCustData :: <LPCUSTDATA>;
  result status :: <C-HRESULT>;
  c-name: "C_ITypeLib2_GetAllCustData";
end;

define method ITypeLib2/GetAllCustData(This :: <C-interface>,
		pCustData :: <LPCUSTDATA>) => (status :: <HRESULT>)
  ITypeLib2_GetAllCustData(This, pCustData)
end;


	/*  ----  ITypeChangeEvents  ----  */



	/*  ----  IErrorInfo  ----  */


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

define C-address IErrorInfo_DW_vtbl :: <C-COM-vtbl>
		c-name: "IErrorInfo_DW_vtbl"; end;
define C-address $IID-IErrorInfo :: <REFIID>
		c-name: "IID_IErrorInfo"; end;

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

define open generic IErrorInfo/GetGUID (This, pGUID)
		=> (status :: <HRESULT>);

define C-callable-wrapper of IErrorInfo/GetGUID
  input parameter This :: <mapped-interface>;
  parameter pGUID :: <LPGUID>;
  result status :: <C-HRESULT>;
  c-name: "DW_IErrorInfo_GetGUID", c-modifiers: "__stdcall";
end;

define inline-only C-function IErrorInfo_GetGUID
  input parameter This :: <C-interface>;
  parameter pGUID :: <LPGUID>;
  result status :: <C-HRESULT>;
  c-name: "C_IErrorInfo_GetGUID";
end;

define method IErrorInfo/GetGUID(This :: <C-interface>,
		pGUID :: <LPGUID>) => (status :: <HRESULT>)
  IErrorInfo_GetGUID(This, pGUID)
end;

define open generic IErrorInfo/GetSource (This)
		=> (status :: <HRESULT>, BstrSource :: <BSTR>);

define C-callable-wrapper of IErrorInfo/GetSource
  input parameter This :: <mapped-interface>;
  output parameter pBstrSource :: <LPBSTR>;
  result status :: <C-HRESULT>;
  c-name: "DW_IErrorInfo_GetSource", c-modifiers: "__stdcall";
end;

define inline-only C-function IErrorInfo_GetSource
  input parameter This :: <C-interface>;
  output parameter pBstrSource :: <LPBSTR>;
  result status :: <C-HRESULT>;
  c-name: "C_IErrorInfo_GetSource";
end;

define method IErrorInfo/GetSource(This :: <C-interface>)
		=> (status :: <HRESULT>, BstrSource :: <BSTR>)
  IErrorInfo_GetSource(This)
end;

define open generic IErrorInfo/GetDescription (This)
		=> (status :: <HRESULT>, BstrDescription :: <BSTR>);

define C-callable-wrapper of IErrorInfo/GetDescription
  input parameter This :: <mapped-interface>;
  output parameter pBstrDescription :: <LPBSTR>;
  result status :: <C-HRESULT>;
  c-name: "DW_IErrorInfo_GetDescription",
		c-modifiers: "__stdcall";
end;

define inline-only C-function IErrorInfo_GetDescription
  input parameter This :: <C-interface>;
  output parameter pBstrDescription :: <LPBSTR>;
  result status :: <C-HRESULT>;
  c-name: "C_IErrorInfo_GetDescription";
end;

define method IErrorInfo/GetDescription(This :: <C-interface>)
		=> (status :: <HRESULT>, BstrDescription :: <BSTR>)
  IErrorInfo_GetDescription(This)
end;

define open generic IErrorInfo/GetHelpFile (This)
		=> (status :: <HRESULT>, BstrHelpFile :: <BSTR>);

define C-callable-wrapper of IErrorInfo/GetHelpFile
  input parameter This :: <mapped-interface>;
  output parameter pBstrHelpFile :: <LPBSTR>;
  result status :: <C-HRESULT>;
  c-name: "DW_IErrorInfo_GetHelpFile", c-modifiers: "__stdcall";
end;

define inline-only C-function IErrorInfo_GetHelpFile
  input parameter This :: <C-interface>;
  output parameter pBstrHelpFile :: <LPBSTR>;
  result status :: <C-HRESULT>;
  c-name: "C_IErrorInfo_GetHelpFile";
end;

define method IErrorInfo/GetHelpFile(This :: <C-interface>)
		=> (status :: <HRESULT>, BstrHelpFile :: <BSTR>)
  IErrorInfo_GetHelpFile(This)
end;

define open generic IErrorInfo/GetHelpContext (This)
		=> (status :: <HRESULT>, dwHelpContext);

define C-callable-wrapper of IErrorInfo/GetHelpContext
  input parameter This :: <mapped-interface>;
  output parameter pdwHelpContext :: <LPDWORD>;
  result status :: <C-HRESULT>;
  c-name: "DW_IErrorInfo_GetHelpContext",
		c-modifiers: "__stdcall";
end;

define inline-only C-function IErrorInfo_GetHelpContext
  input parameter This :: <C-interface>;
  output parameter pdwHelpContext :: <LPDWORD>;
  result status :: <C-HRESULT>;
  c-name: "C_IErrorInfo_GetHelpContext";
end;

define method IErrorInfo/GetHelpContext(This :: <C-interface>)
		=> (status :: <HRESULT>, dwHelpContext)
  IErrorInfo_GetHelpContext(This)
end;


	/*  ----  ICreateErrorInfo  ----  */


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

define C-address ICreateErrorInfo_DW_vtbl :: <C-COM-vtbl>
		c-name: "ICreateErrorInfo_DW_vtbl"; end;
define C-address $IID-ICreateErrorInfo :: <REFIID>
		c-name: "IID_ICreateErrorInfo"; end;

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

define open generic ICreateErrorInfo/SetGUID (This, rguid)
		=> (status :: <HRESULT>);

define C-callable-wrapper of ICreateErrorInfo/SetGUID
  input parameter This :: <mapped-interface>;
  input parameter rguid :: <REFGUID>;
  result status :: <C-HRESULT>;
  c-name: "DW_ICreateErrorInfo_SetGUID",
		c-modifiers: "__stdcall";
end;

define inline-only C-function ICreateErrorInfo_SetGUID
  input parameter This :: <C-interface>;
  input parameter rguid :: <REFGUID>;
  result status :: <C-HRESULT>;
  c-name: "C_ICreateErrorInfo_SetGUID";
end;

define method ICreateErrorInfo/SetGUID(This :: <C-interface>,
		rguid :: <REFGUID>) => (status :: <HRESULT>)
  ICreateErrorInfo_SetGUID(This, rguid)
end;

define open generic ICreateErrorInfo/SetSource (This, szSource)
		=> (status :: <HRESULT>);

define C-callable-wrapper of ICreateErrorInfo/SetSource
  input parameter This :: <mapped-interface>;
  input parameter szSource :: <LPOLESTR>;
  result status :: <C-HRESULT>;
  c-name: "DW_ICreateErrorInfo_SetSource",
		c-modifiers: "__stdcall";
end;

define inline-only C-function ICreateErrorInfo_SetSource
  input parameter This :: <C-interface>;
  input parameter szSource :: <LPOLESTR>;
  result status :: <C-HRESULT>;
  c-name: "C_ICreateErrorInfo_SetSource";
end;

define method ICreateErrorInfo/SetSource(This :: <C-interface>,
		szSource :: <LPOLESTR>) => (status :: <HRESULT>)
  ICreateErrorInfo_SetSource(This, szSource)
end;

define open generic ICreateErrorInfo/SetDescription (This,
		szDescription) => (status :: <HRESULT>);

define C-callable-wrapper of ICreateErrorInfo/SetDescription
  input parameter This :: <mapped-interface>;
  input parameter szDescription :: <LPOLESTR>;
  result status :: <C-HRESULT>;
  c-name: "DW_ICreateErrorInfo_SetDescription",
		c-modifiers: "__stdcall";
end;

define inline-only C-function ICreateErrorInfo_SetDescription
  input parameter This :: <C-interface>;
  input parameter szDescription :: <LPOLESTR>;
  result status :: <C-HRESULT>;
  c-name: "C_ICreateErrorInfo_SetDescription";
end;

define method ICreateErrorInfo/SetDescription(This :: <C-interface>,
		szDescription :: <LPOLESTR>) => (status :: <HRESULT>)
  ICreateErrorInfo_SetDescription(This, szDescription)
end;

define open generic ICreateErrorInfo/SetHelpFile (This,
		szHelpFile) => (status :: <HRESULT>);

define C-callable-wrapper of ICreateErrorInfo/SetHelpFile
  input parameter This :: <mapped-interface>;
  input parameter szHelpFile :: <LPOLESTR>;
  result status :: <C-HRESULT>;
  c-name: "DW_ICreateErrorInfo_SetHelpFile",
		c-modifiers: "__stdcall";
end;

define inline-only C-function ICreateErrorInfo_SetHelpFile
  input parameter This :: <C-interface>;
  input parameter szHelpFile :: <LPOLESTR>;
  result status :: <C-HRESULT>;
  c-name: "C_ICreateErrorInfo_SetHelpFile";
end;

define method ICreateErrorInfo/SetHelpFile(This :: <C-interface>,
		szHelpFile :: <LPOLESTR>) => (status :: <HRESULT>)
  ICreateErrorInfo_SetHelpFile(This, szHelpFile)
end;

define open generic ICreateErrorInfo/SetHelpContext (This,
		dwHelpContext) => (status :: <HRESULT>);

define C-callable-wrapper of ICreateErrorInfo/SetHelpContext
  input parameter This :: <mapped-interface>;
  input parameter dwHelpContext :: <DWORD>;
  result status :: <C-HRESULT>;
  c-name: "DW_ICreateErrorInfo_SetHelpContext",
		c-modifiers: "__stdcall";
end;

define inline-only C-function ICreateErrorInfo_SetHelpContext
  input parameter This :: <C-interface>;
  input parameter dwHelpContext :: <DWORD>;
  result status :: <C-HRESULT>;
  c-name: "C_ICreateErrorInfo_SetHelpContext";
end;

define method ICreateErrorInfo/SetHelpContext(This :: <C-interface>,
		dwHelpContext :: <ffi-integer>) => (status :: <HRESULT>)
  ICreateErrorInfo_SetHelpContext(This, dwHelpContext)
end;


	/*  ----  ISupportErrorInfo  ----  */


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

define C-address ISupportErrorInfo_DW_vtbl :: <C-COM-vtbl>
		c-name: "ISupportErrorInfo_DW_vtbl"; end;
define C-address $IID-ISupportErrorInfo :: <REFIID>
		c-name: "IID_ISupportErrorInfo"; end;

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

define open generic ISupportErrorInfo/InterfaceSupportsErrorInfo
		(This, riid) => (status :: <HRESULT>);

define C-callable-wrapper
		of ISupportErrorInfo/InterfaceSupportsErrorInfo
  input parameter This :: <mapped-interface>;
  input parameter riid :: <REFIID>;
  result status :: <C-HRESULT>;
  c-name: "DW_ISupportErrorInfo_InterfaceSupportsErrorInfo",
		c-modifiers: "__stdcall";
end;

define inline-only C-function ISupportErrorInfo_InterfaceSupportsErrorInfo
  input parameter This :: <C-interface>;
  input parameter riid :: <REFIID>;
  result status :: <C-HRESULT>;
  c-name: "C_ISupportErrorInfo_InterfaceSupportsErrorInfo";
end;

define method ISupportErrorInfo/InterfaceSupportsErrorInfo(This :: <C-interface>,
		riid :: <REFIID>) => (status :: <HRESULT>)
  ISupportErrorInfo_InterfaceSupportsErrorInfo(This, riid)
end;


	/*  ----  ITypeFactory  ----  */


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

define C-address ITypeFactory_DW_vtbl :: <C-COM-vtbl>
		c-name: "ITypeFactory_DW_vtbl"; end;
define C-address $IID-ITypeFactory :: <REFIID>
		c-name: "IID_ITypeFactory"; end;

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

define open generic ITypeFactory/CreateFromTypeInfo (This,
		pTypeInfo, riid) => (status :: <HRESULT>, pv :: <Interface>);

define C-callable-wrapper of ITypeFactory/CreateFromTypeInfo
  input parameter This :: <mapped-interface>;
  input parameter pTypeInfo :: <C-interface>;
  input parameter riid :: <REFIID>;
  output parameter ppv :: <Interface*>;
  result status :: <C-HRESULT>;
  c-name: "DW_ITypeFactory_CreateFromTypeInfo",
		c-modifiers: "__stdcall";
end;

define inline-only C-function ITypeFactory_CreateFromTypeInfo
  input parameter This :: <C-interface>;
  input parameter pTypeInfo :: <Interface>;
  input parameter riid :: <REFIID>;
  output parameter ppv :: <C-interface*>;
  result status :: <C-HRESULT>;
  c-name: "C_ITypeFactory_CreateFromTypeInfo";
end;

define method ITypeFactory/CreateFromTypeInfo(This :: <C-interface>,
		pTypeInfo :: <Interface>, riid :: <REFIID>)
		=> (status :: <HRESULT>, pv :: <Interface>)
  ITypeFactory_CreateFromTypeInfo(This, pTypeInfo, riid)
end;


	/*  ----  ITypeMarshal  ----  */


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

define C-address ITypeMarshal_DW_vtbl :: <C-COM-vtbl>
		c-name: "ITypeMarshal_DW_vtbl"; end;
define C-address $IID-ITypeMarshal :: <REFIID>
		c-name: "IID_ITypeMarshal"; end;

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

define open generic ITypeMarshal/Size (This, pvType,
		dwDestContext, pvDestContext) => (status :: <HRESULT>, Size);

define C-callable-wrapper of ITypeMarshal/Size
  input parameter This :: <mapped-interface>;
  input parameter pvType :: <C-void*>;
  input parameter dwDestContext :: <DWORD>;
  input parameter pvDestContext :: <C-void*>;
  output parameter pSize :: <LPULONG>;
  result status :: <C-HRESULT>;
  c-name: "DW_ITypeMarshal_Size", c-modifiers: "__stdcall";
end;

define inline-only C-function ITypeMarshal_Size
  input parameter This :: <C-interface>;
  input parameter pvType :: <C-void*>;
  input parameter dwDestContext :: <DWORD>;
  input parameter pvDestContext :: <C-void*>;
  output parameter pSize :: <LPULONG>;
  result status :: <C-HRESULT>;
  c-name: "C_ITypeMarshal_Size";
end;

define method ITypeMarshal/Size(This :: <C-interface>,
		pvType :: <C-pointer>, dwDestContext :: <ffi-integer>,
		pvDestContext :: <C-pointer>) => (status :: <HRESULT>, Size)
  ITypeMarshal_Size(This, pvType, dwDestContext, pvDestContext)
end;

define open generic ITypeMarshal/Marshal (This, pvType,
		dwDestContext, pvDestContext, cbBufferLength, pBuffer)
		=> (status :: <HRESULT>, cbWritten);

define C-callable-wrapper of ITypeMarshal/Marshal
  input parameter This :: <mapped-interface>;
  input parameter pvType :: <C-void*>;
  input parameter dwDestContext :: <DWORD>;
  input parameter pvDestContext :: <C-void*>;
  input parameter cbBufferLength :: <ULONG>;
  parameter pBuffer :: <LPBYTE>;
  output parameter pcbWritten :: <LPULONG>;
  result status :: <C-HRESULT>;
  c-name: "DW_ITypeMarshal_Marshal", c-modifiers: "__stdcall";
end;

define inline-only C-function ITypeMarshal_Marshal
  input parameter This :: <C-interface>;
  input parameter pvType :: <C-void*>;
  input parameter dwDestContext :: <DWORD>;
  input parameter pvDestContext :: <C-void*>;
  input parameter cbBufferLength :: <ULONG>;
  parameter pBuffer :: <LPBYTE>;
  output parameter pcbWritten :: <LPULONG>;
  result status :: <C-HRESULT>;
  c-name: "C_ITypeMarshal_Marshal";
end;

define method ITypeMarshal/Marshal(This :: <C-interface>,
		pvType :: <C-pointer>, dwDestContext :: <ffi-integer>,
		pvDestContext :: <C-pointer>, cbBufferLength :: <ffi-integer>,
		pBuffer :: <LPBYTE>) => (status :: <HRESULT>, cbWritten)
  ITypeMarshal_Marshal(This, pvType, dwDestContext,
		pvDestContext, cbBufferLength, pBuffer)
end;

define open generic ITypeMarshal/Unmarshal (This, pvType,
		dwFlags, cbBufferLength, pBuffer)
		=> (status :: <HRESULT>, cbRead);

define C-callable-wrapper of ITypeMarshal/Unmarshal
  input parameter This :: <mapped-interface>;
  parameter pvType :: <C-void*>;
  input parameter dwFlags :: <DWORD>;
  input parameter cbBufferLength :: <ULONG>;
  input parameter pBuffer :: <LPBYTE>;
  output parameter pcbRead :: <LPULONG>;
  result status :: <C-HRESULT>;
  c-name: "DW_ITypeMarshal_Unmarshal", c-modifiers: "__stdcall";
end;

define inline-only C-function ITypeMarshal_Unmarshal
  input parameter This :: <C-interface>;
  parameter pvType :: <C-void*>;
  input parameter dwFlags :: <DWORD>;
  input parameter cbBufferLength :: <ULONG>;
  input parameter pBuffer :: <LPBYTE>;
  output parameter pcbRead :: <LPULONG>;
  result status :: <C-HRESULT>;
  c-name: "C_ITypeMarshal_Unmarshal";
end;

define method ITypeMarshal/Unmarshal(This :: <C-interface>,
		pvType :: <C-pointer>, dwFlags :: <ffi-integer>, cbBufferLength :: <ffi-integer>,
		pBuffer :: <LPBYTE>) => (status :: <HRESULT>, cbRead)
  ITypeMarshal_Unmarshal(This, pvType, dwFlags, cbBufferLength,
		pBuffer)
end;

define open generic ITypeMarshal/Free (This, pvType)
		=> (status :: <HRESULT>);

define C-callable-wrapper of ITypeMarshal/Free
  input parameter This :: <mapped-interface>;
  input parameter pvType :: <C-void*>;
  result status :: <C-HRESULT>;
  c-name: "DW_ITypeMarshal_Free", c-modifiers: "__stdcall";
end;

define inline-only C-function ITypeMarshal_Free
  input parameter This :: <C-interface>;
  input parameter pvType :: <C-void*>;
  result status :: <C-HRESULT>;
  c-name: "C_ITypeMarshal_Free";
end;

define method ITypeMarshal/Free(This :: <C-interface>,
		pvType :: <C-pointer>) => (status :: <HRESULT>)
  ITypeMarshal_Free(This, pvType)
end;


	/*  ----  IRecordInfo  ----  */


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

define C-address IRecordInfo_DW_vtbl :: <C-COM-vtbl>
		c-name: "IRecordInfo_DW_vtbl"; end;
define C-address $IID-IRecordInfo :: <REFIID>
		c-name: "IID_IRecordInfo"; end;

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

define open generic IRecordInfo/RecordInit (This, pvNew)
		=> (status :: <HRESULT>);

define C-callable-wrapper of IRecordInfo/RecordInit
  input parameter This :: <mapped-interface>;
  parameter pvNew :: <C-void*>;
  result status :: <C-HRESULT>;
  c-name: "DW_IRecordInfo_RecordInit", c-modifiers: "__stdcall";
end;

define inline-only C-function IRecordInfo_RecordInit
  input parameter This :: <C-interface>;
  parameter pvNew :: <C-void*>;
  result status :: <C-HRESULT>;
  c-name: "C_IRecordInfo_RecordInit";
end;

define method IRecordInfo/RecordInit(This :: <C-interface>,
		pvNew :: <C-pointer>) => (status :: <HRESULT>)
  IRecordInfo_RecordInit(This, pvNew)
end;

define open generic IRecordInfo/RecordClear (This, pvExisting)
		=> (status :: <HRESULT>);

define C-callable-wrapper of IRecordInfo/RecordClear
  input parameter This :: <mapped-interface>;
  input parameter pvExisting :: <C-void*>;
  result status :: <C-HRESULT>;
  c-name: "DW_IRecordInfo_RecordClear",
		c-modifiers: "__stdcall";
end;

define inline-only C-function IRecordInfo_RecordClear
  input parameter This :: <C-interface>;
  input parameter pvExisting :: <C-void*>;
  result status :: <C-HRESULT>;
  c-name: "C_IRecordInfo_RecordClear";
end;

define method IRecordInfo/RecordClear(This :: <C-interface>,
		pvExisting :: <C-pointer>) => (status :: <HRESULT>)
  IRecordInfo_RecordClear(This, pvExisting)
end;

define open generic IRecordInfo/RecordCopy (This, pvExisting,
		pvNew) => (status :: <HRESULT>);

define C-callable-wrapper of IRecordInfo/RecordCopy
  input parameter This :: <mapped-interface>;
  input parameter pvExisting :: <C-void*>;
  parameter pvNew :: <C-void*>;
  result status :: <C-HRESULT>;
  c-name: "DW_IRecordInfo_RecordCopy", c-modifiers: "__stdcall";
end;

define inline-only C-function IRecordInfo_RecordCopy
  input parameter This :: <C-interface>;
  input parameter pvExisting :: <C-void*>;
  parameter pvNew :: <C-void*>;
  result status :: <C-HRESULT>;
  c-name: "C_IRecordInfo_RecordCopy";
end;

define method IRecordInfo/RecordCopy(This :: <C-interface>,
		pvExisting :: <C-pointer>, pvNew :: <C-pointer>)
		=> (status :: <HRESULT>)
  IRecordInfo_RecordCopy(This, pvExisting, pvNew)
end;

define open generic IRecordInfo/GetGuid (This, pguid)
		=> (status :: <HRESULT>);

define C-callable-wrapper of IRecordInfo/GetGuid
  input parameter This :: <mapped-interface>;
  parameter pguid :: <LPGUID>;
  result status :: <C-HRESULT>;
  c-name: "DW_IRecordInfo_GetGuid", c-modifiers: "__stdcall";
end;

define inline-only C-function IRecordInfo_GetGuid
  input parameter This :: <C-interface>;
  parameter pguid :: <LPGUID>;
  result status :: <C-HRESULT>;
  c-name: "C_IRecordInfo_GetGuid";
end;

define method IRecordInfo/GetGuid(This :: <C-interface>,
		pguid :: <LPGUID>) => (status :: <HRESULT>)
  IRecordInfo_GetGuid(This, pguid)
end;

define open generic IRecordInfo/GetName (This)
		=> (status :: <HRESULT>, bstrName :: <BSTR>);

define C-callable-wrapper of IRecordInfo/GetName
  input parameter This :: <mapped-interface>;
  output parameter pbstrName :: <LPBSTR>;
  result status :: <C-HRESULT>;
  c-name: "DW_IRecordInfo_GetName", c-modifiers: "__stdcall";
end;

define inline-only C-function IRecordInfo_GetName
  input parameter This :: <C-interface>;
  output parameter pbstrName :: <LPBSTR>;
  result status :: <C-HRESULT>;
  c-name: "C_IRecordInfo_GetName";
end;

define method IRecordInfo/GetName(This :: <C-interface>)
		=> (status :: <HRESULT>, bstrName :: <BSTR>)
  IRecordInfo_GetName(This)
end;

define open generic IRecordInfo/GetSize (This)
		=> (status :: <HRESULT>, cbSize);

define C-callable-wrapper of IRecordInfo/GetSize
  input parameter This :: <mapped-interface>;
  output parameter pcbSize :: <LPULONG>;
  result status :: <C-HRESULT>;
  c-name: "DW_IRecordInfo_GetSize", c-modifiers: "__stdcall";
end;

define inline-only C-function IRecordInfo_GetSize
  input parameter This :: <C-interface>;
  output parameter pcbSize :: <LPULONG>;
  result status :: <C-HRESULT>;
  c-name: "C_IRecordInfo_GetSize";
end;

define method IRecordInfo/GetSize(This :: <C-interface>)
		=> (status :: <HRESULT>, cbSize)
  IRecordInfo_GetSize(This)
end;

define open generic IRecordInfo/GetTypeInfo (This)
		=> (status :: <HRESULT>, pTypeInfo :: <Interface>);

define C-callable-wrapper of IRecordInfo/GetTypeInfo
  input parameter This :: <mapped-interface>;
  output parameter ppTypeInfo :: <Interface*>;
  result status :: <C-HRESULT>;
  c-name: "DW_IRecordInfo_GetTypeInfo",
		c-modifiers: "__stdcall";
end;

define inline-only C-function IRecordInfo_GetTypeInfo
  input parameter This :: <C-interface>;
  output parameter ppTypeInfo :: <C-interface*>;
  result status :: <C-HRESULT>;
  c-name: "C_IRecordInfo_GetTypeInfo";
end;

define method IRecordInfo/GetTypeInfo(This :: <C-interface>)
		=> (status :: <HRESULT>, pTypeInfo :: <Interface>)
  IRecordInfo_GetTypeInfo(This)
end;

define open generic IRecordInfo/GetField (This, pvData,
		szFieldName, pvarField) => (status :: <HRESULT>);

define C-callable-wrapper of IRecordInfo/GetField
  input parameter This :: <mapped-interface>;
  input parameter pvData :: <C-void*>;
  input parameter szFieldName :: <LPCOLESTR>;
  parameter pvarField :: <LPVARIANT>;
  result status :: <C-HRESULT>;
  c-name: "DW_IRecordInfo_GetField", c-modifiers: "__stdcall";
end;

define inline-only C-function IRecordInfo_GetField
  input parameter This :: <C-interface>;
  input parameter pvData :: <C-void*>;
  input parameter szFieldName :: <LPCOLESTR>;
  parameter pvarField :: <LPVARIANT>;
  result status :: <C-HRESULT>;
  c-name: "C_IRecordInfo_GetField";
end;

define method IRecordInfo/GetField(This :: <C-interface>,
		pvData :: <C-pointer>, szFieldName :: <LPCOLESTR>,
		pvarField :: <LPVARIANT>) => (status :: <HRESULT>)
  IRecordInfo_GetField(This, pvData, szFieldName, pvarField)
end;

define open generic IRecordInfo/GetFieldNoCopy (This, pvData,
		szFieldName, pvarField)
		=> (status :: <HRESULT>, pvDataCArray :: <C-void*>);

define C-callable-wrapper of IRecordInfo/GetFieldNoCopy
  input parameter This :: <mapped-interface>;
  input parameter pvData :: <C-void*>;
  input parameter szFieldName :: <LPCOLESTR>;
  parameter pvarField :: <LPVARIANT>;
  output parameter ppvDataCArray :: <C-void**>;
  result status :: <C-HRESULT>;
  c-name: "DW_IRecordInfo_GetFieldNoCopy",
		c-modifiers: "__stdcall";
end;

define inline-only C-function IRecordInfo_GetFieldNoCopy
  input parameter This :: <C-interface>;
  input parameter pvData :: <C-void*>;
  input parameter szFieldName :: <LPCOLESTR>;
  parameter pvarField :: <LPVARIANT>;
  output parameter ppvDataCArray :: <C-void**>;
  result status :: <C-HRESULT>;
  c-name: "C_IRecordInfo_GetFieldNoCopy";
end;

define method IRecordInfo/GetFieldNoCopy(This :: <C-interface>,
		pvData :: <C-pointer>, szFieldName :: <LPCOLESTR>,
		pvarField :: <LPVARIANT>)
		=> (status :: <HRESULT>, pvDataCArray :: <C-void*>)
  IRecordInfo_GetFieldNoCopy(This, pvData, szFieldName,
		pvarField)
end;

define open generic IRecordInfo/PutField (This, wFlags, pvData,
		szFieldName, pvarField) => (status :: <HRESULT>);

define C-callable-wrapper of IRecordInfo/PutField
  input parameter This :: <mapped-interface>;
  input parameter wFlags :: <ULONG>;
   parameter pvData :: <C-void*>;
  input parameter szFieldName :: <LPCOLESTR>;
  input parameter pvarField :: <LPVARIANT>;
  result status :: <C-HRESULT>;
  c-name: "DW_IRecordInfo_PutField", c-modifiers: "__stdcall";
end;

define inline-only C-function IRecordInfo_PutField
  input parameter This :: <C-interface>;
  input parameter wFlags :: <ULONG>;
   parameter pvData :: <C-void*>;
  input parameter szFieldName :: <LPCOLESTR>;
  input parameter pvarField :: <LPVARIANT>;
  result status :: <C-HRESULT>;
  c-name: "C_IRecordInfo_PutField";
end;

define method IRecordInfo/PutField(This :: <C-interface>, wFlags :: <ffi-integer>,
		pvData :: <C-pointer>, szFieldName :: <LPCOLESTR>,
		pvarField :: <LPVARIANT>) => (status :: <HRESULT>)
  IRecordInfo_PutField(This, wFlags, pvData, szFieldName,
		pvarField)
end;

define open generic IRecordInfo/PutFieldNoCopy (This, wFlags,
		pvData, szFieldName, pvarField) => (status :: <HRESULT>);

define C-callable-wrapper of IRecordInfo/PutFieldNoCopy
  input parameter This :: <mapped-interface>;
  input parameter wFlags :: <ULONG>;
   parameter pvData :: <C-void*>;
  input parameter szFieldName :: <LPCOLESTR>;
  input parameter pvarField :: <LPVARIANT>;
  result status :: <C-HRESULT>;
  c-name: "DW_IRecordInfo_PutFieldNoCopy",
		c-modifiers: "__stdcall";
end;

define inline-only C-function IRecordInfo_PutFieldNoCopy
  input parameter This :: <C-interface>;
  input parameter wFlags :: <ULONG>;
   parameter pvData :: <C-void*>;
  input parameter szFieldName :: <LPCOLESTR>;
  input parameter pvarField :: <LPVARIANT>;
  result status :: <C-HRESULT>;
  c-name: "C_IRecordInfo_PutFieldNoCopy";
end;

define method IRecordInfo/PutFieldNoCopy(This :: <C-interface>,
		wFlags :: <ffi-integer>, pvData :: <C-pointer>, szFieldName :: <LPCOLESTR>,
		pvarField :: <LPVARIANT>) => (status :: <HRESULT>)
  IRecordInfo_PutFieldNoCopy(This, wFlags, pvData, szFieldName,
		pvarField)
end;

define open generic IRecordInfo/GetFieldNames (This, pcNames,
		rgBstrNames) => (status :: <HRESULT>);

define C-callable-wrapper of IRecordInfo/GetFieldNames
  input parameter This :: <mapped-interface>;
   parameter pcNames :: <LPULONG>;
   parameter rgBstrNames :: <LPBSTR>;
  result status :: <C-HRESULT>;
  c-name: "DW_IRecordInfo_GetFieldNames",
		c-modifiers: "__stdcall";
end;

define inline-only C-function IRecordInfo_GetFieldNames
  input parameter This :: <C-interface>;
   parameter pcNames :: <LPULONG>;
   parameter rgBstrNames :: <LPBSTR>;
  result status :: <C-HRESULT>;
  c-name: "C_IRecordInfo_GetFieldNames";
end;

define method IRecordInfo/GetFieldNames(This :: <C-interface>,
		pcNames :: <LPULONG>, rgBstrNames :: <LPBSTR>)
		=> (status :: <HRESULT>)
  IRecordInfo_GetFieldNames(This, pcNames, rgBstrNames)
end;

define open generic IRecordInfo/IsMatchingType (This,
		pRecordInfo) => (value :: <boolean>);

define C-callable-wrapper of IRecordInfo/IsMatchingType
  input parameter This :: <mapped-interface>;
  input parameter pRecordInfo :: <C-interface>;
  result value :: <BOOL>;
  c-name: "DW_IRecordInfo_IsMatchingType",
		c-modifiers: "__stdcall";
end;

define inline-only C-function IRecordInfo_IsMatchingType
  input parameter This :: <C-interface>;
  input parameter pRecordInfo :: <Interface>;
  result value :: <BOOL>;
  c-name: "C_IRecordInfo_IsMatchingType";
end;

define method IRecordInfo/IsMatchingType(This :: <C-interface>,
		pRecordInfo :: <Interface>) => (value :: <boolean>)
  IRecordInfo_IsMatchingType(This, pRecordInfo)
end;

define open generic IRecordInfo/RecordCreate (This)
		=> (value :: <C-pointer>);

define C-callable-wrapper of IRecordInfo/RecordCreate
  input parameter This :: <mapped-interface>;
  result value :: <C-void*>;
  c-name: "DW_IRecordInfo_RecordCreate",
		c-modifiers: "__stdcall";
end;

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

define method IRecordInfo/RecordCreate(This :: <C-interface>)
		=> (value :: <C-pointer>)
  IRecordInfo_RecordCreate(This)
end;

define open generic IRecordInfo/RecordCreateCopy (This, pvSource)
		=> (status :: <HRESULT>, pvDest :: <C-void*>);

define C-callable-wrapper of IRecordInfo/RecordCreateCopy
  input parameter This :: <mapped-interface>;
  input parameter pvSource :: <C-void*>;
  output parameter ppvDest :: <C-void**>;
  result status :: <C-HRESULT>;
  c-name: "DW_IRecordInfo_RecordCreateCopy",
		c-modifiers: "__stdcall";
end;

define inline-only C-function IRecordInfo_RecordCreateCopy
  input parameter This :: <C-interface>;
  input parameter pvSource :: <C-void*>;
  output parameter ppvDest :: <C-void**>;
  result status :: <C-HRESULT>;
  c-name: "C_IRecordInfo_RecordCreateCopy";
end;

define method IRecordInfo/RecordCreateCopy(This :: <C-interface>,
		pvSource :: <C-pointer>)
		=> (status :: <HRESULT>, pvDest :: <C-void*>)
  IRecordInfo_RecordCreateCopy(This, pvSource)
end;

define open generic IRecordInfo/RecordDestroy (This, pvRecord)
		=> (status :: <HRESULT>);

define C-callable-wrapper of IRecordInfo/RecordDestroy
  input parameter This :: <mapped-interface>;
  input parameter pvRecord :: <C-void*>;
  result status :: <C-HRESULT>;
  c-name: "DW_IRecordInfo_RecordDestroy",
		c-modifiers: "__stdcall";
end;

define inline-only C-function IRecordInfo_RecordDestroy
  input parameter This :: <C-interface>;
  input parameter pvRecord :: <C-void*>;
  result status :: <C-HRESULT>;
  c-name: "C_IRecordInfo_RecordDestroy";
end;

define method IRecordInfo/RecordDestroy(This :: <C-interface>,
		pvRecord :: <C-pointer>) => (status :: <HRESULT>)
  IRecordInfo_RecordDestroy(This, pvRecord)
end;
