/*** Autogenerated by WIDL 0.1 from urlmon.idl - Do not edit ***/
#include <rpc.h>
#include <rpcndr.h>

#ifndef __WIDL_URLMON_H
#define __WIDL_URLMON_H
#ifdef __cplusplus
extern "C" {
#endif
#include <objidl.h>
#include <oleidl.h>
#include <servprov.h>
#ifndef __IBinding_FWD_DEFINED__
#define __IBinding_FWD_DEFINED__
typedef struct IBinding IBinding;
#endif

typedef IBinding *LPBINDING;

/*****************************************************************************
 * IBinding interface
 */
#ifndef __IBinding_INTERFACE_DEFINED__
#define __IBinding_INTERFACE_DEFINED__

DEFINE_GUID(IID_IBinding, 0x79eac9c0, 0xbaf9, 0x11ce, 0x8c,0x82, 0x00,0xaa,0x00,0x4b,0xa9,0x0b);
#if defined(__cplusplus) && !defined(CINTERFACE)
struct IBinding : public IUnknown
{
    virtual HRESULT STDMETHODCALLTYPE Abort(
        ) = 0;

    virtual HRESULT STDMETHODCALLTYPE Suspend(
        ) = 0;

    virtual HRESULT STDMETHODCALLTYPE Resume(
        ) = 0;

    virtual HRESULT STDMETHODCALLTYPE SetPriority(
        LONG nPriority) = 0;

    virtual HRESULT STDMETHODCALLTYPE GetPriority(
        LONG* pnPriority) = 0;

    virtual HRESULT STDMETHODCALLTYPE GetBindResult(
        CLSID* pclsidProtocol,
        DWORD* pdwResult,
        LPOLESTR* pszResult,
        DWORD* pdwReserved) = 0;

};
#else
typedef struct IBindingVtbl IBindingVtbl;
struct IBinding {
    const IBindingVtbl* lpVtbl;
};
struct IBindingVtbl {
    ICOM_MSVTABLE_COMPAT_FIELDS

    /*** IUnknown methods ***/
    HRESULT (STDMETHODCALLTYPE *QueryInterface)(
        IBinding* This,
        REFIID riid,
        void** ppvObject);

    ULONG (STDMETHODCALLTYPE *AddRef)(
        IBinding* This);

    ULONG (STDMETHODCALLTYPE *Release)(
        IBinding* This);

    /*** IBinding methods ***/
    HRESULT (STDMETHODCALLTYPE *Abort)(
        IBinding* This);

    HRESULT (STDMETHODCALLTYPE *Suspend)(
        IBinding* This);

    HRESULT (STDMETHODCALLTYPE *Resume)(
        IBinding* This);

    HRESULT (STDMETHODCALLTYPE *SetPriority)(
        IBinding* This,
        LONG nPriority);

    HRESULT (STDMETHODCALLTYPE *GetPriority)(
        IBinding* This,
        LONG* pnPriority);

    HRESULT (STDMETHODCALLTYPE *GetBindResult)(
        IBinding* This,
        CLSID* pclsidProtocol,
        DWORD* pdwResult,
        LPOLESTR* pszResult,
        DWORD* pdwReserved);

};

/*** IUnknown methods ***/
#define IBinding_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b)
#define IBinding_AddRef(p) (p)->lpVtbl->AddRef(p)
#define IBinding_Release(p) (p)->lpVtbl->Release(p)
/*** IBinding methods ***/
#define IBinding_Abort(p) (p)->lpVtbl->Abort(p)
#define IBinding_Suspend(p) (p)->lpVtbl->Suspend(p)
#define IBinding_Resume(p) (p)->lpVtbl->Resume(p)
#define IBinding_SetPriority(p,a) (p)->lpVtbl->SetPriority(p,a)
#define IBinding_GetPriority(p,a) (p)->lpVtbl->GetPriority(p,a)
#define IBinding_GetBindResult(p,a,b,c,d) (p)->lpVtbl->GetBindResult(p,a,b,c,d)

#endif

#define IBinding_METHODS \
    ICOM_MSVTABLE_COMPAT_FIELDS \
    /*** IUnknown methods ***/ \
    STDMETHOD_(HRESULT,QueryInterface)(THIS_ REFIID riid, void** ppvObject) PURE; \
    STDMETHOD_(ULONG,AddRef)(THIS) PURE; \
    STDMETHOD_(ULONG,Release)(THIS) PURE; \
    /*** IBinding methods ***/ \
    STDMETHOD_(HRESULT,Abort)(THIS) PURE; \
    STDMETHOD_(HRESULT,Suspend)(THIS) PURE; \
    STDMETHOD_(HRESULT,Resume)(THIS) PURE; \
    STDMETHOD_(HRESULT,SetPriority)(THIS_ LONG nPriority) PURE; \
    STDMETHOD_(HRESULT,GetPriority)(THIS_ LONG* pnPriority) PURE; \
    STDMETHOD_(HRESULT,GetBindResult)(THIS_ CLSID* pclsidProtocol, DWORD* pdwResult, LPOLESTR* pszResult, DWORD* pdwReserved) PURE;

HRESULT CALLBACK IBinding_Abort_Proxy(
    IBinding* This);
void __RPC_STUB IBinding_Abort_Stub(
    struct IRpcStubBuffer* This,
    struct IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IBinding_Suspend_Proxy(
    IBinding* This);
void __RPC_STUB IBinding_Suspend_Stub(
    struct IRpcStubBuffer* This,
    struct IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IBinding_Resume_Proxy(
    IBinding* This);
void __RPC_STUB IBinding_Resume_Stub(
    struct IRpcStubBuffer* This,
    struct IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IBinding_SetPriority_Proxy(
    IBinding* This,
    LONG nPriority);
void __RPC_STUB IBinding_SetPriority_Stub(
    struct IRpcStubBuffer* This,
    struct IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IBinding_GetPriority_Proxy(
    IBinding* This,
    LONG* pnPriority);
void __RPC_STUB IBinding_GetPriority_Stub(
    struct IRpcStubBuffer* This,
    struct IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IBinding_RemoteGetBindResult_Proxy(
    IBinding* This,
    CLSID* pclsidProtocol,
    DWORD* pdwResult,
    LPOLESTR* pszResult,
    DWORD dwReserved);
void __RPC_STUB IBinding_RemoteGetBindResult_Stub(
    struct IRpcStubBuffer* This,
    struct IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IBinding_GetBindResult_Proxy(
    IBinding* This,
    CLSID* pclsidProtocol,
    DWORD* pdwResult,
    LPOLESTR* pszResult,
    DWORD* pdwReserved);
HRESULT __RPC_STUB IBinding_GetBindResult_Stub(
    IBinding* This,
    CLSID* pclsidProtocol,
    DWORD* pdwResult,
    LPOLESTR* pszResult,
    DWORD dwReserved);

#endif  /* __IBinding_INTERFACE_DEFINED__ */

#ifndef __IBindStatusCallback_FWD_DEFINED__
#define __IBindStatusCallback_FWD_DEFINED__
typedef struct IBindStatusCallback IBindStatusCallback;
#endif

typedef IBindStatusCallback *LPBINDSTATUSCALLBACK;

typedef enum {
    BINDF_ASYNCHRONOUS = 0x1,
    BINDF_ASYNCSTORAGE = 0x2,
    BINDF_NOPROGRESSIVERENDERING = 0x4,
    BINDF_OFFLINEOPERATION = 0x8,
    BINDF_GETNEWESTVERSION = 0x10,
    BINDF_NOWRITECACHE = 0x20,
    BINDF_NEEDFILE = 0x40,
    BINDF_PULLDATA = 0x80,
    BINDF_IGNORESECURITYPROBLEM = 0x100,
    BINDF_RESYNCHRONIZE = 0x200,
    BINDF_HYPERLINK = 0x400,
    BINDF_NO_UI = 0x800,
    BINDF_SILENTOPERATION = 0x1000,
    BINDF_PRAGMA_NO_CACHE = 0x2000,
    BINDF_GETCLASSOBJECT = 0x4000,
    BINDF_RESERVED_1 = 0x8000,
    BINDF_FREE_THREADED = 0x10000,
    BINDF_DIRECT_READ = 0x20000,
    BINDF_FORMS_SUBMIT = 0x40000,
    BINDF_GETFROMCACHE_IF_NET_FAIL = 0x80000,
    BINDF_FROMURLMON = 0x100000,
    BINDF_FWD_BACK = 0x200000,
    BINDF_PREFERDEFAULTHANDLER = 0x400000,
    BINDF_ENFORCERESTRICTED = 0x800000
} BINDF;

typedef struct _tagBINDINFO {
    ULONG cbSize;
    LPWSTR szExtraInfo;
    STGMEDIUM stgmedData;
    DWORD grfBindInfoF;
    DWORD dwBindVerb;
    LPWSTR szCustomVerb;
    DWORD cbStgmedData;
    DWORD dwOptions;
    DWORD dwOptionsFlags;
    DWORD dwCodePage;
    SECURITY_ATTRIBUTES securityAttributes;
    IID iid;
    IUnknown *pUnk;
    DWORD dwReserved;
} BINDINFO;

typedef struct _REMSECURITY_ATTRIBUTES {
    DWORD nLength;
    DWORD lpSecurityDescriptor;
    BOOL bInheritHandle;
} REMSECURITY_ATTRIBUTES, *PREMSECURITY_ATTRIBUTES, *LPREMSECURITY_ATTRIBUTES;

typedef struct _tagRemBINDINFO {
    ULONG cbSize;
    LPWSTR szExtraInfo;
    DWORD grfBindInfoF;
    DWORD dwBindVerb;
    LPWSTR szCustomVerb;
    DWORD cbstgmedData;
    DWORD dwOptions;
    DWORD dwOptionsFlags;
    DWORD dwCodePage;
    REMSECURITY_ATTRIBUTES securityAttributes;
    IID iid;
    IUnknown *pUnk;
    DWORD dwReserved;
} RemBINDINFO;

typedef struct tagRemFORMATETC {
    DWORD cfFormat;
    DWORD ptd;
    DWORD dwAspect;
    LONG lindex;
    DWORD tymed;
} RemFORMATETC, *LPREMFORMATETC;

typedef enum {
    BSCF_FIRSTDATANOTIFICATION = 0x1,
    BSCF_INTERMEDIATEDATANOTIFICATION = 0x2,
    BSCF_LASTDATANOTIFICATION = 0x4,
    BSCF_DATAFULLYAVAILABLE = 0x8,
    BSCF_AVAILABLEDATASIZEUNKNOWN = 0x10
} BSCF;

typedef enum BINDSTATUS {
    BINDSTATUS_FINDINGRESOURCE = 1,
    BINDSTATUS_CONNECTING,
    BINDSTATUS_REDIRECTING,
    BINDSTATUS_BEGINDOWNLOADDATA,
    BINDSTATUS_DOWNLOADINGDATA,
    BINDSTATUS_ENDDOWNLOADDATA,
    BINDSTATUS_BEGINDOWNLOADCOMPONENTS,
    BINDSTATUS_INSTALLINGCOMPONENTS,
    BINDSTATUS_ENDDOWNLOADCOMPONENTS,
    BINDSTATUS_USINGCACHEDCOPY,
    BINDSTATUS_SENDINGREQUEST,
    BINDSTATUS_CLASSIDAVAILABLE,
    BINDSTATUS_MIMETYPEAVAILABLE,
    BINDSTATUS_CACHEFILENAMEAVAILABLE,
    BINDSTATUS_BEGINSYNCOPERATION,
    BINDSTATUS_ENDSYNCOPERATION,
    BINDSTATUS_BEGINUPLOADDATA,
    BINDSTATUS_UPLOADINGDATA,
    BINDSTATUS_ENDUPLOADINGDATA,
    BINDSTATUS_PROTOCOLCLASSID,
    BINDSTATUS_ENCODING,
    BINDSTATUS_VERFIEDMIMETYPEAVAILABLE,
    BINDSTATUS_CLASSINSTALLLOCATION,
    BINDSTATUS_DECODING,
    BINDSTATUS_LOADINGMIMEHANDLER,
    BINDSTATUS_CONTENTDISPOSITIONATTACH,
    BINDSTATUS_FILTERREPORTMIMETYPE,
    BINDSTATUS_CLSIDCANINSTANTIATE,
    BINDSTATUS_IUNKNOWNAVAILABLE,
    BINDSTATUS_DIRECTBIND,
    BINDSTATUS_RAWMIMETYPE,
    BINDSTATUS_PROXYDETECTING,
    BINDSTATUS_ACCEPTRANGES,
    BINDSTATUS_COOKIE_SENT,
    BINDSTATUS_COMPACT_POLICY_RECEIVED,
    BINDSTATUS_COOKIE_SUPPRESSED,
    BINDSTATUS_COOKIE_STATE_UNKNOWN,
    BINDSTATUS_COOKIE_STATE_ACCEPT,
    BINDSTATUS_COOKIE_STATE_REJECT,
    BINDSTATUS_COOKIE_STATE_PROMPT,
    BINDSTATUS_COOKIE_STATE_LEASH,
    BINDSTATUS_COOKIE_STATE_DOWNGRADE,
    BINDSTATUS_POLICY_HREF,
    BINDSTATUS_P3P_HEADER,
    BINDSTATUS_SESSION_COOKIE_RECEIVED,
    BINDSTATUS_PERSISTENT_COOKIE_RECEIVED,
    BINDSTATUS_SESSION_COOKIES_ALLOWED,
    BINDSTATUS_CACHECONTROL
} BINDSTATUS;

/*****************************************************************************
 * IBindStatusCallback interface
 */
#ifndef __IBindStatusCallback_INTERFACE_DEFINED__
#define __IBindStatusCallback_INTERFACE_DEFINED__

DEFINE_GUID(IID_IBindStatusCallback, 0x79eac9c1, 0xbaf9, 0x11ce, 0x8c,0x82, 0x00,0xaa,0x00,0x4b,0xa9,0x0b);
#if defined(__cplusplus) && !defined(CINTERFACE)
struct IBindStatusCallback : public IUnknown
{
    virtual HRESULT STDMETHODCALLTYPE OnStartBinding(
        DWORD dwReserved,
        IBinding* pib) = 0;

    virtual HRESULT STDMETHODCALLTYPE GetPriority(
        LONG* pnPriority) = 0;

    virtual HRESULT STDMETHODCALLTYPE OnLowResource(
        DWORD reserved) = 0;

    virtual HRESULT STDMETHODCALLTYPE OnProgress(
        ULONG ulProgress,
        ULONG ulProgressMax,
        ULONG ulStatusCode,
        LPCWSTR szStatusText) = 0;

    virtual HRESULT STDMETHODCALLTYPE OnStopBinding(
        HRESULT hresult,
        LPCWSTR szError) = 0;

    virtual HRESULT STDMETHODCALLTYPE GetBindInfo(
        DWORD* grfBINDF,
        BINDINFO* pbindinfo) = 0;

    virtual HRESULT STDMETHODCALLTYPE OnDataAvailable(
        DWORD grfBSCF,
        DWORD dwSize,
        FORMATETC* pformatetc,
        STGMEDIUM* pstgmed) = 0;

    virtual HRESULT STDMETHODCALLTYPE OnObjectAvailable(
        REFIID riid,
        IUnknown* punk) = 0;

};
#else
typedef struct IBindStatusCallbackVtbl IBindStatusCallbackVtbl;
struct IBindStatusCallback {
    const IBindStatusCallbackVtbl* lpVtbl;
};
struct IBindStatusCallbackVtbl {
    ICOM_MSVTABLE_COMPAT_FIELDS

    /*** IUnknown methods ***/
    HRESULT (STDMETHODCALLTYPE *QueryInterface)(
        IBindStatusCallback* This,
        REFIID riid,
        void** ppvObject);

    ULONG (STDMETHODCALLTYPE *AddRef)(
        IBindStatusCallback* This);

    ULONG (STDMETHODCALLTYPE *Release)(
        IBindStatusCallback* This);

    /*** IBindStatusCallback methods ***/
    HRESULT (STDMETHODCALLTYPE *OnStartBinding)(
        IBindStatusCallback* This,
        DWORD dwReserved,
        IBinding* pib);

    HRESULT (STDMETHODCALLTYPE *GetPriority)(
        IBindStatusCallback* This,
        LONG* pnPriority);

    HRESULT (STDMETHODCALLTYPE *OnLowResource)(
        IBindStatusCallback* This,
        DWORD reserved);

    HRESULT (STDMETHODCALLTYPE *OnProgress)(
        IBindStatusCallback* This,
        ULONG ulProgress,
        ULONG ulProgressMax,
        ULONG ulStatusCode,
        LPCWSTR szStatusText);

    HRESULT (STDMETHODCALLTYPE *OnStopBinding)(
        IBindStatusCallback* This,
        HRESULT hresult,
        LPCWSTR szError);

    HRESULT (STDMETHODCALLTYPE *GetBindInfo)(
        IBindStatusCallback* This,
        DWORD* grfBINDF,
        BINDINFO* pbindinfo);

    HRESULT (STDMETHODCALLTYPE *OnDataAvailable)(
        IBindStatusCallback* This,
        DWORD grfBSCF,
        DWORD dwSize,
        FORMATETC* pformatetc,
        STGMEDIUM* pstgmed);

    HRESULT (STDMETHODCALLTYPE *OnObjectAvailable)(
        IBindStatusCallback* This,
        REFIID riid,
        IUnknown* punk);

};

/*** IUnknown methods ***/
#define IBindStatusCallback_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b)
#define IBindStatusCallback_AddRef(p) (p)->lpVtbl->AddRef(p)
#define IBindStatusCallback_Release(p) (p)->lpVtbl->Release(p)
/*** IBindStatusCallback methods ***/
#define IBindStatusCallback_OnStartBinding(p,a,b) (p)->lpVtbl->OnStartBinding(p,a,b)
#define IBindStatusCallback_GetPriority(p,a) (p)->lpVtbl->GetPriority(p,a)
#define IBindStatusCallback_OnLowResource(p,a) (p)->lpVtbl->OnLowResource(p,a)
#define IBindStatusCallback_OnProgress(p,a,b,c,d) (p)->lpVtbl->OnProgress(p,a,b,c,d)
#define IBindStatusCallback_OnStopBinding(p,a,b) (p)->lpVtbl->OnStopBinding(p,a,b)
#define IBindStatusCallback_GetBindInfo(p,a,b) (p)->lpVtbl->GetBindInfo(p,a,b)
#define IBindStatusCallback_OnDataAvailable(p,a,b,c,d) (p)->lpVtbl->OnDataAvailable(p,a,b,c,d)
#define IBindStatusCallback_OnObjectAvailable(p,a,b) (p)->lpVtbl->OnObjectAvailable(p,a,b)

#endif

#define IBindStatusCallback_METHODS \
    ICOM_MSVTABLE_COMPAT_FIELDS \
    /*** IUnknown methods ***/ \
    STDMETHOD_(HRESULT,QueryInterface)(THIS_ REFIID riid, void** ppvObject) PURE; \
    STDMETHOD_(ULONG,AddRef)(THIS) PURE; \
    STDMETHOD_(ULONG,Release)(THIS) PURE; \
    /*** IBindStatusCallback methods ***/ \
    STDMETHOD_(HRESULT,OnStartBinding)(THIS_ DWORD dwReserved, IBinding* pib) PURE; \
    STDMETHOD_(HRESULT,GetPriority)(THIS_ LONG* pnPriority) PURE; \
    STDMETHOD_(HRESULT,OnLowResource)(THIS_ DWORD reserved) PURE; \
    STDMETHOD_(HRESULT,OnProgress)(THIS_ ULONG ulProgress, ULONG ulProgressMax, ULONG ulStatusCode, LPCWSTR szStatusText) PURE; \
    STDMETHOD_(HRESULT,OnStopBinding)(THIS_ HRESULT hresult, LPCWSTR szError) PURE; \
    STDMETHOD_(HRESULT,GetBindInfo)(THIS_ DWORD* grfBINDF, BINDINFO* pbindinfo) PURE; \
    STDMETHOD_(HRESULT,OnDataAvailable)(THIS_ DWORD grfBSCF, DWORD dwSize, FORMATETC* pformatetc, STGMEDIUM* pstgmed) PURE; \
    STDMETHOD_(HRESULT,OnObjectAvailable)(THIS_ REFIID riid, IUnknown* punk) PURE;

HRESULT CALLBACK IBindStatusCallback_OnStartBinding_Proxy(
    IBindStatusCallback* This,
    DWORD dwReserved,
    IBinding* pib);
void __RPC_STUB IBindStatusCallback_OnStartBinding_Stub(
    struct IRpcStubBuffer* This,
    struct IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IBindStatusCallback_GetPriority_Proxy(
    IBindStatusCallback* This,
    LONG* pnPriority);
void __RPC_STUB IBindStatusCallback_GetPriority_Stub(
    struct IRpcStubBuffer* This,
    struct IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IBindStatusCallback_OnLowResource_Proxy(
    IBindStatusCallback* This,
    DWORD reserved);
void __RPC_STUB IBindStatusCallback_OnLowResource_Stub(
    struct IRpcStubBuffer* This,
    struct IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IBindStatusCallback_OnProgress_Proxy(
    IBindStatusCallback* This,
    ULONG ulProgress,
    ULONG ulProgressMax,
    ULONG ulStatusCode,
    LPCWSTR szStatusText);
void __RPC_STUB IBindStatusCallback_OnProgress_Stub(
    struct IRpcStubBuffer* This,
    struct IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IBindStatusCallback_OnStopBinding_Proxy(
    IBindStatusCallback* This,
    HRESULT hresult,
    LPCWSTR szError);
void __RPC_STUB IBindStatusCallback_OnStopBinding_Stub(
    struct IRpcStubBuffer* This,
    struct IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IBindStatusCallback_RemoteGetBindInfo_Proxy(
    IBindStatusCallback* This,
    DWORD* grfBINDF,
    RemBINDINFO* pbindinfo,
    RemSTGMEDIUM* pstgmed);
void __RPC_STUB IBindStatusCallback_RemoteGetBindInfo_Stub(
    struct IRpcStubBuffer* This,
    struct IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IBindStatusCallback_GetBindInfo_Proxy(
    IBindStatusCallback* This,
    DWORD* grfBINDF,
    BINDINFO* pbindinfo);
HRESULT __RPC_STUB IBindStatusCallback_GetBindInfo_Stub(
    IBindStatusCallback* This,
    DWORD* grfBINDF,
    RemBINDINFO* pbindinfo,
    RemSTGMEDIUM* pstgmed);
HRESULT CALLBACK IBindStatusCallback_RemoteOnDataAvailable_Proxy(
    IBindStatusCallback* This,
    DWORD grfBSCF,
    DWORD dwSize,
    RemFORMATETC* pformatetc,
    RemSTGMEDIUM* pstgmed);
void __RPC_STUB IBindStatusCallback_RemoteOnDataAvailable_Stub(
    struct IRpcStubBuffer* This,
    struct IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IBindStatusCallback_OnDataAvailable_Proxy(
    IBindStatusCallback* This,
    DWORD grfBSCF,
    DWORD dwSize,
    FORMATETC* pformatetc,
    STGMEDIUM* pstgmed);
HRESULT __RPC_STUB IBindStatusCallback_OnDataAvailable_Stub(
    IBindStatusCallback* This,
    DWORD grfBSCF,
    DWORD dwSize,
    RemFORMATETC* pformatetc,
    RemSTGMEDIUM* pstgmed);
HRESULT CALLBACK IBindStatusCallback_OnObjectAvailable_Proxy(
    IBindStatusCallback* This,
    REFIID riid,
    IUnknown* punk);
void __RPC_STUB IBindStatusCallback_OnObjectAvailable_Stub(
    struct IRpcStubBuffer* This,
    struct IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);

#endif  /* __IBindStatusCallback_INTERFACE_DEFINED__ */

#define SID_IBindHost IID_IBindHost
#define SID_SBindHost IID_IBindHost
#ifndef __IBindHost_FWD_DEFINED__
#define __IBindHost_FWD_DEFINED__
typedef struct IBindHost IBindHost;
#endif

typedef IBindHost *LPBINDHOST;

/*****************************************************************************
 * IBindHost interface
 */
#ifndef __IBindHost_INTERFACE_DEFINED__
#define __IBindHost_INTERFACE_DEFINED__

DEFINE_GUID(IID_IBindHost, 0xfc4801a1, 0x2ba9, 0x11cf, 0xa2,0x29, 0x00,0xaa,0x00,0x3d,0x73,0x52);
#if defined(__cplusplus) && !defined(CINTERFACE)
struct IBindHost : public IUnknown
{
    virtual HRESULT STDMETHODCALLTYPE CreateMoniker(
        LPOLESTR szName,
        IBindCtx* pBC,
        IMoniker** ppmk,
        DWORD dwReserved) = 0;

    virtual HRESULT STDMETHODCALLTYPE MonikerBindToStorage(
        IMoniker* pMk,
        IBindCtx* pBC,
        IBindStatusCallback* pBSC,
        REFIID riid,
        void** ppvObj) = 0;

    virtual HRESULT STDMETHODCALLTYPE MonikerBindToObject(
        IMoniker* pMk,
        IBindCtx* pBC,
        IBindStatusCallback* pBSC,
        REFIID riid,
        void** ppvObj) = 0;

};
#else
typedef struct IBindHostVtbl IBindHostVtbl;
struct IBindHost {
    const IBindHostVtbl* lpVtbl;
};
struct IBindHostVtbl {
    ICOM_MSVTABLE_COMPAT_FIELDS

    /*** IUnknown methods ***/
    HRESULT (STDMETHODCALLTYPE *QueryInterface)(
        IBindHost* This,
        REFIID riid,
        void** ppvObject);

    ULONG (STDMETHODCALLTYPE *AddRef)(
        IBindHost* This);

    ULONG (STDMETHODCALLTYPE *Release)(
        IBindHost* This);

    /*** IBindHost methods ***/
    HRESULT (STDMETHODCALLTYPE *CreateMoniker)(
        IBindHost* This,
        LPOLESTR szName,
        IBindCtx* pBC,
        IMoniker** ppmk,
        DWORD dwReserved);

    HRESULT (STDMETHODCALLTYPE *MonikerBindToStorage)(
        IBindHost* This,
        IMoniker* pMk,
        IBindCtx* pBC,
        IBindStatusCallback* pBSC,
        REFIID riid,
        void** ppvObj);

    HRESULT (STDMETHODCALLTYPE *MonikerBindToObject)(
        IBindHost* This,
        IMoniker* pMk,
        IBindCtx* pBC,
        IBindStatusCallback* pBSC,
        REFIID riid,
        void** ppvObj);

};

/*** IUnknown methods ***/
#define IBindHost_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b)
#define IBindHost_AddRef(p) (p)->lpVtbl->AddRef(p)
#define IBindHost_Release(p) (p)->lpVtbl->Release(p)
/*** IBindHost methods ***/
#define IBindHost_CreateMoniker(p,a,b,c,d) (p)->lpVtbl->CreateMoniker(p,a,b,c,d)
#define IBindHost_MonikerBindToStorage(p,a,b,c,d,e) (p)->lpVtbl->MonikerBindToStorage(p,a,b,c,d,e)
#define IBindHost_MonikerBindToObject(p,a,b,c,d,e) (p)->lpVtbl->MonikerBindToObject(p,a,b,c,d,e)

#endif

#define IBindHost_METHODS \
    ICOM_MSVTABLE_COMPAT_FIELDS \
    /*** IUnknown methods ***/ \
    STDMETHOD_(HRESULT,QueryInterface)(THIS_ REFIID riid, void** ppvObject) PURE; \
    STDMETHOD_(ULONG,AddRef)(THIS) PURE; \
    STDMETHOD_(ULONG,Release)(THIS) PURE; \
    /*** IBindHost methods ***/ \
    STDMETHOD_(HRESULT,CreateMoniker)(THIS_ LPOLESTR szName, IBindCtx* pBC, IMoniker** ppmk, DWORD dwReserved) PURE; \
    STDMETHOD_(HRESULT,MonikerBindToStorage)(THIS_ IMoniker* pMk, IBindCtx* pBC, IBindStatusCallback* pBSC, REFIID riid, void** ppvObj) PURE; \
    STDMETHOD_(HRESULT,MonikerBindToObject)(THIS_ IMoniker* pMk, IBindCtx* pBC, IBindStatusCallback* pBSC, REFIID riid, void** ppvObj) PURE;

HRESULT CALLBACK IBindHost_CreateMoniker_Proxy(
    IBindHost* This,
    LPOLESTR szName,
    IBindCtx* pBC,
    IMoniker** ppmk,
    DWORD dwReserved);
void __RPC_STUB IBindHost_CreateMoniker_Stub(
    struct IRpcStubBuffer* This,
    struct IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IBindHost_RemoteMonikerBindToStorage_Proxy(
    IBindHost* This,
    IMoniker* pMk,
    IBindCtx* pBC,
    IBindStatusCallback* pBSC,
    REFIID riid,
    IUnknown** ppvObj);
void __RPC_STUB IBindHost_RemoteMonikerBindToStorage_Stub(
    struct IRpcStubBuffer* This,
    struct IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IBindHost_MonikerBindToStorage_Proxy(
    IBindHost* This,
    IMoniker* pMk,
    IBindCtx* pBC,
    IBindStatusCallback* pBSC,
    REFIID riid,
    void** ppvObj);
HRESULT __RPC_STUB IBindHost_MonikerBindToStorage_Stub(
    IBindHost* This,
    IMoniker* pMk,
    IBindCtx* pBC,
    IBindStatusCallback* pBSC,
    REFIID riid,
    IUnknown** ppvObj);
HRESULT CALLBACK IBindHost_RemoteMonikerBindToObject_Proxy(
    IBindHost* This,
    IMoniker* pMk,
    IBindCtx* pBC,
    IBindStatusCallback* pBSC,
    REFIID riid,
    IUnknown** ppvObj);
void __RPC_STUB IBindHost_RemoteMonikerBindToObject_Stub(
    struct IRpcStubBuffer* This,
    struct IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IBindHost_MonikerBindToObject_Proxy(
    IBindHost* This,
    IMoniker* pMk,
    IBindCtx* pBC,
    IBindStatusCallback* pBSC,
    REFIID riid,
    void** ppvObj);
HRESULT __RPC_STUB IBindHost_MonikerBindToObject_Stub(
    IBindHost* This,
    IMoniker* pMk,
    IBindCtx* pBC,
    IBindStatusCallback* pBSC,
    REFIID riid,
    IUnknown** ppvObj);

#endif  /* __IBindHost_INTERFACE_DEFINED__ */

#ifndef __IWinInetInfo_FWD_DEFINED__
#define __IWinInetInfo_FWD_DEFINED__
typedef struct IWinInetInfo IWinInetInfo;
#endif

typedef IWinInetInfo *LPWININETINFO;

/*****************************************************************************
 * IWinInetInfo interface
 */
#ifndef __IWinInetInfo_INTERFACE_DEFINED__
#define __IWinInetInfo_INTERFACE_DEFINED__

DEFINE_GUID(IID_IWinInetInfo, 0x79eac9d6, 0xbafa, 0x11ce, 0x8c,0x82, 0x00,0xaa,0x00,0x4b,0xa9,0x0b);
#if defined(__cplusplus) && !defined(CINTERFACE)
struct IWinInetInfo : public IUnknown
{
    virtual HRESULT STDMETHODCALLTYPE QueryOption(
        DWORD dwOption,
        LPVOID pBuffer,
        DWORD* pcbBuf) = 0;

};
#else
typedef struct IWinInetInfoVtbl IWinInetInfoVtbl;
struct IWinInetInfo {
    const IWinInetInfoVtbl* lpVtbl;
};
struct IWinInetInfoVtbl {
    ICOM_MSVTABLE_COMPAT_FIELDS

    /*** IUnknown methods ***/
    HRESULT (STDMETHODCALLTYPE *QueryInterface)(
        IWinInetInfo* This,
        REFIID riid,
        void** ppvObject);

    ULONG (STDMETHODCALLTYPE *AddRef)(
        IWinInetInfo* This);

    ULONG (STDMETHODCALLTYPE *Release)(
        IWinInetInfo* This);

    /*** IWinInetInfo methods ***/
    HRESULT (STDMETHODCALLTYPE *QueryOption)(
        IWinInetInfo* This,
        DWORD dwOption,
        LPVOID pBuffer,
        DWORD* pcbBuf);

};

/*** IUnknown methods ***/
#define IWinInetInfo_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b)
#define IWinInetInfo_AddRef(p) (p)->lpVtbl->AddRef(p)
#define IWinInetInfo_Release(p) (p)->lpVtbl->Release(p)
/*** IWinInetInfo methods ***/
#define IWinInetInfo_QueryOption(p,a,b,c) (p)->lpVtbl->QueryOption(p,a,b,c)

#endif

#define IWinInetInfo_METHODS \
    ICOM_MSVTABLE_COMPAT_FIELDS \
    /*** IUnknown methods ***/ \
    STDMETHOD_(HRESULT,QueryInterface)(THIS_ REFIID riid, void** ppvObject) PURE; \
    STDMETHOD_(ULONG,AddRef)(THIS) PURE; \
    STDMETHOD_(ULONG,Release)(THIS) PURE; \
    /*** IWinInetInfo methods ***/ \
    STDMETHOD_(HRESULT,QueryOption)(THIS_ DWORD dwOption, LPVOID pBuffer, DWORD* pcbBuf) PURE;

HRESULT CALLBACK IWinInetInfo_RemoteQueryOption_Proxy(
    IWinInetInfo* This,
    DWORD dwOption,
    BYTE* pBuffer,
    DWORD* pcbBuf);
void __RPC_STUB IWinInetInfo_RemoteQueryOption_Stub(
    struct IRpcStubBuffer* This,
    struct IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IWinInetInfo_QueryOption_Proxy(
    IWinInetInfo* This,
    DWORD dwOption,
    LPVOID pBuffer,
    DWORD* pcbBuf);
HRESULT __RPC_STUB IWinInetInfo_QueryOption_Stub(
    IWinInetInfo* This,
    DWORD dwOption,
    BYTE* pBuffer,
    DWORD* pcbBuf);

#endif  /* __IWinInetInfo_INTERFACE_DEFINED__ */

#ifndef __IWinInetHttpInfo_FWD_DEFINED__
#define __IWinInetHttpInfo_FWD_DEFINED__
typedef struct IWinInetHttpInfo IWinInetHttpInfo;
#endif

typedef IWinInetHttpInfo *LPWININETHTTPINFO;

/*****************************************************************************
 * IWinInetHttpInfo interface
 */
#ifndef __IWinInetHttpInfo_INTERFACE_DEFINED__
#define __IWinInetHttpInfo_INTERFACE_DEFINED__

DEFINE_GUID(IID_IWinInetHttpInfo, 0x79eac9d8, 0xbafa, 0x11ce, 0x8c,0x82, 0x00,0xaa,0x00,0x4b,0xa9,0x0b);
#if defined(__cplusplus) && !defined(CINTERFACE)
struct IWinInetHttpInfo : public IWinInetInfo
{
    virtual HRESULT STDMETHODCALLTYPE QueryInfo(
        DWORD dwOption,
        LPVOID pBuffer,
        DWORD* pcbBuf,
        DWORD* pdwFlags,
        DWORD* pdwReserved) = 0;

};
#else
typedef struct IWinInetHttpInfoVtbl IWinInetHttpInfoVtbl;
struct IWinInetHttpInfo {
    const IWinInetHttpInfoVtbl* lpVtbl;
};
struct IWinInetHttpInfoVtbl {
    ICOM_MSVTABLE_COMPAT_FIELDS

    /*** IUnknown methods ***/
    HRESULT (STDMETHODCALLTYPE *QueryInterface)(
        IWinInetHttpInfo* This,
        REFIID riid,
        void** ppvObject);

    ULONG (STDMETHODCALLTYPE *AddRef)(
        IWinInetHttpInfo* This);

    ULONG (STDMETHODCALLTYPE *Release)(
        IWinInetHttpInfo* This);

    /*** IWinInetInfo methods ***/
    HRESULT (STDMETHODCALLTYPE *QueryOption)(
        IWinInetHttpInfo* This,
        DWORD dwOption,
        LPVOID pBuffer,
        DWORD* pcbBuf);

    /*** IWinInetHttpInfo methods ***/
    HRESULT (STDMETHODCALLTYPE *QueryInfo)(
        IWinInetHttpInfo* This,
        DWORD dwOption,
        LPVOID pBuffer,
        DWORD* pcbBuf,
        DWORD* pdwFlags,
        DWORD* pdwReserved);

};

/*** IUnknown methods ***/
#define IWinInetHttpInfo_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b)
#define IWinInetHttpInfo_AddRef(p) (p)->lpVtbl->AddRef(p)
#define IWinInetHttpInfo_Release(p) (p)->lpVtbl->Release(p)
/*** IWinInetInfo methods ***/
#define IWinInetHttpInfo_QueryOption(p,a,b,c) (p)->lpVtbl->QueryOption(p,a,b,c)
/*** IWinInetHttpInfo methods ***/
#define IWinInetHttpInfo_QueryInfo(p,a,b,c,d,e) (p)->lpVtbl->QueryInfo(p,a,b,c,d,e)

#endif

#define IWinInetHttpInfo_METHODS \
    ICOM_MSVTABLE_COMPAT_FIELDS \
    /*** IUnknown methods ***/ \
    STDMETHOD_(HRESULT,QueryInterface)(THIS_ REFIID riid, void** ppvObject) PURE; \
    STDMETHOD_(ULONG,AddRef)(THIS) PURE; \
    STDMETHOD_(ULONG,Release)(THIS) PURE; \
    /*** IWinInetInfo methods ***/ \
    STDMETHOD_(HRESULT,QueryOption)(THIS_ DWORD dwOption, LPVOID pBuffer, DWORD* pcbBuf) PURE; \
    /*** IWinInetHttpInfo methods ***/ \
    STDMETHOD_(HRESULT,QueryInfo)(THIS_ DWORD dwOption, LPVOID pBuffer, DWORD* pcbBuf, DWORD* pdwFlags, DWORD* pdwReserved) PURE;

HRESULT CALLBACK IWinInetHttpInfo_RemoteQueryInfo_Proxy(
    IWinInetHttpInfo* This,
    DWORD dwOption,
    BYTE* pBuffer,
    DWORD* pcbBuf,
    DWORD* pdwFlags,
    DWORD* pdwReserved);
void __RPC_STUB IWinInetHttpInfo_RemoteQueryInfo_Stub(
    struct IRpcStubBuffer* This,
    struct IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IWinInetHttpInfo_QueryInfo_Proxy(
    IWinInetHttpInfo* This,
    DWORD dwOption,
    LPVOID pBuffer,
    DWORD* pcbBuf,
    DWORD* pdwFlags,
    DWORD* pdwReserved);
HRESULT __RPC_STUB IWinInetHttpInfo_QueryInfo_Stub(
    IWinInetHttpInfo* This,
    DWORD dwOption,
    BYTE* pBuffer,
    DWORD* pcbBuf,
    DWORD* pdwFlags,
    DWORD* pdwReserved);

#endif  /* __IWinInetHttpInfo_INTERFACE_DEFINED__ */

#ifndef __IPersistMoniker_FWD_DEFINED__
#define __IPersistMoniker_FWD_DEFINED__
typedef struct IPersistMoniker IPersistMoniker;
#endif

typedef IPersistMoniker *LPPERSISTMONIKER;

/*****************************************************************************
 * IPersistMoniker interface
 */
#ifndef __IPersistMoniker_INTERFACE_DEFINED__
#define __IPersistMoniker_INTERFACE_DEFINED__

DEFINE_GUID(IID_IPersistMoniker, 0x79eac9c9, 0xbaf9, 0x11ce, 0x8c,0x82, 0x00,0xaa,0x00,0x4b,0xa9,0x0b);
#if defined(__cplusplus) && !defined(CINTERFACE)
struct IPersistMoniker : public IUnknown
{
    virtual HRESULT STDMETHODCALLTYPE GetClassID(
        CLSID* pClassID) = 0;

    virtual HRESULT STDMETHODCALLTYPE IsDirty(
        ) = 0;

    virtual HRESULT STDMETHODCALLTYPE Load(
        BOOL fFullyAvailable,
        IMoniker* pimkName,
        LPBC pibc,
        DWORD grfMode) = 0;

    virtual HRESULT STDMETHODCALLTYPE Save(
        IMoniker* pimkName,
        LPBC pbc,
        BOOL fRemember) = 0;

    virtual HRESULT STDMETHODCALLTYPE SaveCompleted(
        IMoniker* pimkName,
        LPBC pibc) = 0;

    virtual HRESULT STDMETHODCALLTYPE GetCurMoniker(
        IMoniker** ppimkName) = 0;

};
#else
typedef struct IPersistMonikerVtbl IPersistMonikerVtbl;
struct IPersistMoniker {
    const IPersistMonikerVtbl* lpVtbl;
};
struct IPersistMonikerVtbl {
    ICOM_MSVTABLE_COMPAT_FIELDS

    /*** IUnknown methods ***/
    HRESULT (STDMETHODCALLTYPE *QueryInterface)(
        IPersistMoniker* This,
        REFIID riid,
        void** ppvObject);

    ULONG (STDMETHODCALLTYPE *AddRef)(
        IPersistMoniker* This);

    ULONG (STDMETHODCALLTYPE *Release)(
        IPersistMoniker* This);

    /*** IPersistMoniker methods ***/
    HRESULT (STDMETHODCALLTYPE *GetClassID)(
        IPersistMoniker* This,
        CLSID* pClassID);

    HRESULT (STDMETHODCALLTYPE *IsDirty)(
        IPersistMoniker* This);

    HRESULT (STDMETHODCALLTYPE *Load)(
        IPersistMoniker* This,
        BOOL fFullyAvailable,
        IMoniker* pimkName,
        LPBC pibc,
        DWORD grfMode);

    HRESULT (STDMETHODCALLTYPE *Save)(
        IPersistMoniker* This,
        IMoniker* pimkName,
        LPBC pbc,
        BOOL fRemember);

    HRESULT (STDMETHODCALLTYPE *SaveCompleted)(
        IPersistMoniker* This,
        IMoniker* pimkName,
        LPBC pibc);

    HRESULT (STDMETHODCALLTYPE *GetCurMoniker)(
        IPersistMoniker* This,
        IMoniker** ppimkName);

};

/*** IUnknown methods ***/
#define IPersistMoniker_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b)
#define IPersistMoniker_AddRef(p) (p)->lpVtbl->AddRef(p)
#define IPersistMoniker_Release(p) (p)->lpVtbl->Release(p)
/*** IPersistMoniker methods ***/
#define IPersistMoniker_GetClassID(p,a) (p)->lpVtbl->GetClassID(p,a)
#define IPersistMoniker_IsDirty(p) (p)->lpVtbl->IsDirty(p)
#define IPersistMoniker_Load(p,a,b,c,d) (p)->lpVtbl->Load(p,a,b,c,d)
#define IPersistMoniker_Save(p,a,b,c) (p)->lpVtbl->Save(p,a,b,c)
#define IPersistMoniker_SaveCompleted(p,a,b) (p)->lpVtbl->SaveCompleted(p,a,b)
#define IPersistMoniker_GetCurMoniker(p,a) (p)->lpVtbl->GetCurMoniker(p,a)

#endif

#define IPersistMoniker_METHODS \
    ICOM_MSVTABLE_COMPAT_FIELDS \
    /*** IUnknown methods ***/ \
    STDMETHOD_(HRESULT,QueryInterface)(THIS_ REFIID riid, void** ppvObject) PURE; \
    STDMETHOD_(ULONG,AddRef)(THIS) PURE; \
    STDMETHOD_(ULONG,Release)(THIS) PURE; \
    /*** IPersistMoniker methods ***/ \
    STDMETHOD_(HRESULT,GetClassID)(THIS_ CLSID* pClassID) PURE; \
    STDMETHOD_(HRESULT,IsDirty)(THIS) PURE; \
    STDMETHOD_(HRESULT,Load)(THIS_ BOOL fFullyAvailable, IMoniker* pimkName, LPBC pibc, DWORD grfMode) PURE; \
    STDMETHOD_(HRESULT,Save)(THIS_ IMoniker* pimkName, LPBC pbc, BOOL fRemember) PURE; \
    STDMETHOD_(HRESULT,SaveCompleted)(THIS_ IMoniker* pimkName, LPBC pibc) PURE; \
    STDMETHOD_(HRESULT,GetCurMoniker)(THIS_ IMoniker** ppimkName) PURE;

HRESULT CALLBACK IPersistMoniker_GetClassID_Proxy(
    IPersistMoniker* This,
    CLSID* pClassID);
void __RPC_STUB IPersistMoniker_GetClassID_Stub(
    struct IRpcStubBuffer* This,
    struct IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IPersistMoniker_IsDirty_Proxy(
    IPersistMoniker* This);
void __RPC_STUB IPersistMoniker_IsDirty_Stub(
    struct IRpcStubBuffer* This,
    struct IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IPersistMoniker_Load_Proxy(
    IPersistMoniker* This,
    BOOL fFullyAvailable,
    IMoniker* pimkName,
    LPBC pibc,
    DWORD grfMode);
void __RPC_STUB IPersistMoniker_Load_Stub(
    struct IRpcStubBuffer* This,
    struct IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IPersistMoniker_Save_Proxy(
    IPersistMoniker* This,
    IMoniker* pimkName,
    LPBC pbc,
    BOOL fRemember);
void __RPC_STUB IPersistMoniker_Save_Stub(
    struct IRpcStubBuffer* This,
    struct IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IPersistMoniker_SaveCompleted_Proxy(
    IPersistMoniker* This,
    IMoniker* pimkName,
    LPBC pibc);
void __RPC_STUB IPersistMoniker_SaveCompleted_Stub(
    struct IRpcStubBuffer* This,
    struct IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IPersistMoniker_GetCurMoniker_Proxy(
    IPersistMoniker* This,
    IMoniker** ppimkName);
void __RPC_STUB IPersistMoniker_GetCurMoniker_Stub(
    struct IRpcStubBuffer* This,
    struct IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);

#endif  /* __IPersistMoniker_INTERFACE_DEFINED__ */

#ifndef __IInternetProtocolInfo_FWD_DEFINED__
#define __IInternetProtocolInfo_FWD_DEFINED__
typedef struct IInternetProtocolInfo IInternetProtocolInfo;
#endif

typedef IInternetProtocolInfo *LPIINTERNETPROTOCOLINFO;

typedef enum _tagPARSEACTION {
    PARSE_CANONICALIZE = 1,
    PARSE_FRIENDLY,
    PARSE_SECURITY_URL,
    PARSE_ROOTDOCUMENT,
    PARSE_DOCUMENT,
    PARSE_ANCHOR,
    PARSE_ENCODE,
    PARSE_DECODE,
    PARSE_PATH_FROM_URL,
    PARSE_URL_FROM_PATH,
    PARSE_MIME,
    PARSE_SERVER,
    PARSE_SCHEMA,
    PARSE_SITE,
    PARSE_DOMAIN,
    PARSE_LOCATION,
    PARSE_SECURITY_DOMAIN,
    PARSE_ESCAPE,
    PARSE_UNESCAPE
} PARSEACTION;

typedef enum _tagPSUACTION {
    PSU_DEFAULT = 1,
    PSU_SECURITY_URL_ONLY
} PSUACTION;

typedef enum _tagQUERYOPTION {
    QUERY_EXPIRATION_DATE = 1,
    QUERY_TIME_OF_LAST_CHANGE,
    QUERY_CONTENT_ENCODING,
    QUERY_CONTENT_TYPE,
    QUERY_REFRESH,
    QUERY_RECOMBINE,
    QUERY_CAN_NAVIGATE,
    QUERY_USES_NETWORK,
    QUERY_IS_CACHED,
    QUERY_IS_INSTALLEDENTRY,
    QUERY_IS_CACHED_OR_MAPPED,
    QUERY_USES_CACHE,
    QUERY_IS_SECURE,
    QUERY_IS_SAFE
} QUERYOPTION;

/*****************************************************************************
 * IInternetProtocolInfo interface
 */
#ifndef __IInternetProtocolInfo_INTERFACE_DEFINED__
#define __IInternetProtocolInfo_INTERFACE_DEFINED__

DEFINE_GUID(IID_IInternetProtocolInfo, 0x79eac9ec, 0xbaf9, 0x11ce, 0x8c,0x82, 0x00,0xaa,0x00,0x4b,0xa9,0x0b);
#if defined(__cplusplus) && !defined(CINTERFACE)
struct IInternetProtocolInfo : public IUnknown
{
    virtual HRESULT STDMETHODCALLTYPE ParseUrl(
        LPCWSTR pwzUrl,
        PARSEACTION ParseAction,
        DWORD dwParseFlags,
        LPWSTR pwzResult,
        DWORD cchResult,
        DWORD* pcchResult,
        DWORD dwReserved) = 0;

    virtual HRESULT STDMETHODCALLTYPE CombineUrl(
        LPCWSTR pwzBaseUrl,
        LPCWSTR pwzRelativeUrl,
        DWORD dwCombineFlags,
        LPWSTR pwzResult,
        DWORD cchResult,
        DWORD* pcchResult,
        DWORD dwReserved) = 0;

    virtual HRESULT STDMETHODCALLTYPE CompareUrl(
        LPCWSTR pwzUrl1,
        LPCWSTR pwzUrl2,
        DWORD dwCompareFlags) = 0;

    virtual HRESULT STDMETHODCALLTYPE QueryInfo(
        LPCWSTR pwzUrl,
        QUERYOPTION OueryOption,
        DWORD dwQueryFlags,
        LPVOID pBuffer,
        DWORD cbBuffer,
        DWORD* pcbBuf,
        DWORD dwReserved) = 0;

};
#else
typedef struct IInternetProtocolInfoVtbl IInternetProtocolInfoVtbl;
struct IInternetProtocolInfo {
    const IInternetProtocolInfoVtbl* lpVtbl;
};
struct IInternetProtocolInfoVtbl {
    ICOM_MSVTABLE_COMPAT_FIELDS

    /*** IUnknown methods ***/
    HRESULT (STDMETHODCALLTYPE *QueryInterface)(
        IInternetProtocolInfo* This,
        REFIID riid,
        void** ppvObject);

    ULONG (STDMETHODCALLTYPE *AddRef)(
        IInternetProtocolInfo* This);

    ULONG (STDMETHODCALLTYPE *Release)(
        IInternetProtocolInfo* This);

    /*** IInternetProtocolInfo methods ***/
    HRESULT (STDMETHODCALLTYPE *ParseUrl)(
        IInternetProtocolInfo* This,
        LPCWSTR pwzUrl,
        PARSEACTION ParseAction,
        DWORD dwParseFlags,
        LPWSTR pwzResult,
        DWORD cchResult,
        DWORD* pcchResult,
        DWORD dwReserved);

    HRESULT (STDMETHODCALLTYPE *CombineUrl)(
        IInternetProtocolInfo* This,
        LPCWSTR pwzBaseUrl,
        LPCWSTR pwzRelativeUrl,
        DWORD dwCombineFlags,
        LPWSTR pwzResult,
        DWORD cchResult,
        DWORD* pcchResult,
        DWORD dwReserved);

    HRESULT (STDMETHODCALLTYPE *CompareUrl)(
        IInternetProtocolInfo* This,
        LPCWSTR pwzUrl1,
        LPCWSTR pwzUrl2,
        DWORD dwCompareFlags);

    HRESULT (STDMETHODCALLTYPE *QueryInfo)(
        IInternetProtocolInfo* This,
        LPCWSTR pwzUrl,
        QUERYOPTION OueryOption,
        DWORD dwQueryFlags,
        LPVOID pBuffer,
        DWORD cbBuffer,
        DWORD* pcbBuf,
        DWORD dwReserved);

};

/*** IUnknown methods ***/
#define IInternetProtocolInfo_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b)
#define IInternetProtocolInfo_AddRef(p) (p)->lpVtbl->AddRef(p)
#define IInternetProtocolInfo_Release(p) (p)->lpVtbl->Release(p)
/*** IInternetProtocolInfo methods ***/
#define IInternetProtocolInfo_ParseUrl(p,a,b,c,d,e,f,g) (p)->lpVtbl->ParseUrl(p,a,b,c,d,e,f,g)
#define IInternetProtocolInfo_CombineUrl(p,a,b,c,d,e,f,g) (p)->lpVtbl->CombineUrl(p,a,b,c,d,e,f,g)
#define IInternetProtocolInfo_CompareUrl(p,a,b,c) (p)->lpVtbl->CompareUrl(p,a,b,c)
#define IInternetProtocolInfo_QueryInfo(p,a,b,c,d,e,f,g) (p)->lpVtbl->QueryInfo(p,a,b,c,d,e,f,g)

#endif

#define IInternetProtocolInfo_METHODS \
    ICOM_MSVTABLE_COMPAT_FIELDS \
    /*** IUnknown methods ***/ \
    STDMETHOD_(HRESULT,QueryInterface)(THIS_ REFIID riid, void** ppvObject) PURE; \
    STDMETHOD_(ULONG,AddRef)(THIS) PURE; \
    STDMETHOD_(ULONG,Release)(THIS) PURE; \
    /*** IInternetProtocolInfo methods ***/ \
    STDMETHOD_(HRESULT,ParseUrl)(THIS_ LPCWSTR pwzUrl, PARSEACTION ParseAction, DWORD dwParseFlags, LPWSTR pwzResult, DWORD cchResult, DWORD* pcchResult, DWORD dwReserved) PURE; \
    STDMETHOD_(HRESULT,CombineUrl)(THIS_ LPCWSTR pwzBaseUrl, LPCWSTR pwzRelativeUrl, DWORD dwCombineFlags, LPWSTR pwzResult, DWORD cchResult, DWORD* pcchResult, DWORD dwReserved) PURE; \
    STDMETHOD_(HRESULT,CompareUrl)(THIS_ LPCWSTR pwzUrl1, LPCWSTR pwzUrl2, DWORD dwCompareFlags) PURE; \
    STDMETHOD_(HRESULT,QueryInfo)(THIS_ LPCWSTR pwzUrl, QUERYOPTION OueryOption, DWORD dwQueryFlags, LPVOID pBuffer, DWORD cbBuffer, DWORD* pcbBuf, DWORD dwReserved) PURE;

HRESULT CALLBACK IInternetProtocolInfo_ParseUrl_Proxy(
    IInternetProtocolInfo* This,
    LPCWSTR pwzUrl,
    PARSEACTION ParseAction,
    DWORD dwParseFlags,
    LPWSTR pwzResult,
    DWORD cchResult,
    DWORD* pcchResult,
    DWORD dwReserved);
void __RPC_STUB IInternetProtocolInfo_ParseUrl_Stub(
    struct IRpcStubBuffer* This,
    struct IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IInternetProtocolInfo_CombineUrl_Proxy(
    IInternetProtocolInfo* This,
    LPCWSTR pwzBaseUrl,
    LPCWSTR pwzRelativeUrl,
    DWORD dwCombineFlags,
    LPWSTR pwzResult,
    DWORD cchResult,
    DWORD* pcchResult,
    DWORD dwReserved);
void __RPC_STUB IInternetProtocolInfo_CombineUrl_Stub(
    struct IRpcStubBuffer* This,
    struct IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IInternetProtocolInfo_CompareUrl_Proxy(
    IInternetProtocolInfo* This,
    LPCWSTR pwzUrl1,
    LPCWSTR pwzUrl2,
    DWORD dwCompareFlags);
void __RPC_STUB IInternetProtocolInfo_CompareUrl_Stub(
    struct IRpcStubBuffer* This,
    struct IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IInternetProtocolInfo_QueryInfo_Proxy(
    IInternetProtocolInfo* This,
    LPCWSTR pwzUrl,
    QUERYOPTION OueryOption,
    DWORD dwQueryFlags,
    LPVOID pBuffer,
    DWORD cbBuffer,
    DWORD* pcbBuf,
    DWORD dwReserved);
void __RPC_STUB IInternetProtocolInfo_QueryInfo_Stub(
    struct IRpcStubBuffer* This,
    struct IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);

#endif  /* __IInternetProtocolInfo_INTERFACE_DEFINED__ */

DEFINE_GUID(CLSID_StdURLMoniker, 0x79EAC9E0, 0xBAF9, 0x11CE, 0x8C, 0x82, 0x00, 0xAA, 0x00, 0x4B, 0xA9, 0x0B);
#define MK_S_ASYNCHRONOUS                0x000401E8
#define S_ASYNCHRONOUS                   MK_S_ASYNCHRONOUS
#define INET_E_ERROR_FIRST               0x800C0002L
#define INET_E_INVALID_URL               0x800C0002L
#define INET_E_NO_SESSION                0x800C0003L
#define INET_E_CANNOT_CONNECT            0x800C0004L
#define INET_E_RESOURCE_NOT_FOUND        0x800C0005L
#define INET_E_OBJECT_NOT_FOUND          0x800C0006L
#define INET_E_DATA_NOT_AVAILABLE        0x800C0007L
#define INET_E_DOWNLOAD_FAILURE          0x800C0008L
#define INET_E_AUTHENTICATION_REQUIRED   0x800C0009L
#define INET_E_NO_VALID_MEDIA            0x800C000AL
#define INET_E_CONNECTION_TIMEOUT        0x800C000BL
#define INET_E_INVALID_REQUEST           0x800C000CL
#define INET_E_UNKNOWN_PROTOCOL          0x800C000DL
#define INET_E_SECURITY_PROBLEM          0x800C000EL
#define INET_E_CANNOT_LOAD_DATA          0x800C000FL
#define INET_E_CANNOT_INSTANTIATE_OBJECT 0x800C0010L
#define INET_E_QUERYOPTION_UNKNOWN       0x800C0013L
#define INET_E_REDIRECT_FAILED           0x800C0014L
#define INET_E_REDIRECT_TO_DIR           0x800C0015L
#define INET_E_CANNOT_LOCK_REQUEST       0x800C0016L
#define INET_E_ERROR_LAST                INET_E_REDIRECT_TO_DIR
HRESULT WINAPI CreateURLMoniker(IMoniker *pmkContext, LPCWSTR szURL, IMoniker **ppmk);
HRESULT WINAPI RegisterBindStatusCallback(IBindCtx *pbc, IBindStatusCallback *pbsc, IBindStatusCallback **ppbsc, DWORD dwReserved);
HRESULT WINAPI CompareSecurityIds(BYTE*,DWORD,BYTE*,DWORD,DWORD);
HRESULT WINAPI URLDownloadToFileA(LPUNKNOWN pCaller, LPCSTR szURL,  LPCSTR  szFileName, DWORD dwReserved, LPBINDSTATUSCALLBACK lpfnCB);
HRESULT WINAPI URLDownloadToFileW(LPUNKNOWN pCaller, LPCWSTR szURL, LPCWSTR szFileName, DWORD dwReserved, LPBINDSTATUSCALLBACK lpfnCB);
HRESULT WINAPI CoInternetGetSession(DWORD,/*IInternetSession*/void**,DWORD);
HRESULT WINAPI MkParseDisplayNameEx(IBindCtx*,LPCWSTR,ULONG*,IMoniker**);
HRESULT WINAPI IsAsyncMoniker(IMoniker* pmk);
HRESULT WINAPI CreateAsyncBindCtx(DWORD, IBindStatusCallback*, IEnumFORMATETC*, IBindCtx**);
HRESULT WINAPI CoInternetCombineUrl(LPCWSTR,LPCWSTR,DWORD,LPWSTR,DWORD,DWORD*,DWORD);
HRESULT WINAPI CoInternetCompareUrl(LPCWSTR,LPCWSTR,DWORD);
#define OInetCombineUrl CoInternetCombineUrl
#define OInetCompareUrl CoInternetCompareUrl
#define OInetGetSession CoInternetGetSession
#define MKSYS_URLMONIKER 6
#ifdef __cplusplus
}
#endif
#endif /* __WIDL_URLMON_H */
