/*** Autogenerated by WIDL 0.9.4 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>
#include <msxml.h>
#ifndef __IInternetProtocolSink_FWD_DEFINED__
#define __IInternetProtocolSink_FWD_DEFINED__
typedef interface IInternetProtocolSink IInternetProtocolSink;
#endif

#ifndef __IBinding_FWD_DEFINED__
#define __IBinding_FWD_DEFINED__
typedef interface 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)
interface 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 {
    BEGIN_INTERFACE

    /*** 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);

    END_INTERFACE
} IBindingVtbl;
interface IBinding {
    const IBindingVtbl* lpVtbl;
};

#ifdef COBJMACROS
/*** 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

#endif

HRESULT CALLBACK IBinding_Abort_Proxy(
    IBinding* This);
void __RPC_STUB IBinding_Abort_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IBinding_Suspend_Proxy(
    IBinding* This);
void __RPC_STUB IBinding_Suspend_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IBinding_Resume_Proxy(
    IBinding* This);
void __RPC_STUB IBinding_Resume_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IBinding_SetPriority_Proxy(
    IBinding* This,
    LONG nPriority);
void __RPC_STUB IBinding_SetPriority_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IBinding_GetPriority_Proxy(
    IBinding* This,
    LONG* pnPriority);
void __RPC_STUB IBinding_GetPriority_Stub(
    IRpcStubBuffer* This,
    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(
    IRpcStubBuffer* This,
    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 interface IBindStatusCallback IBindStatusCallback;
#endif

typedef IBindStatusCallback *LPBINDSTATUSCALLBACK;
typedef enum {
    BINDVERB_GET = 0x0,
    BINDVERB_POST = 0x1,
    BINDVERB_PUT = 0x2,
    BINDVERB_CUSTOM = 0x3
} BINDVERB;
typedef enum
{
    BINDINFOF_URLENCODESTGMEDDATA = 0x1,
    BINDINFOF_URLENCODEDEXTRAINFO = 0x2
} BINDINFOF;
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_VERIFIEDMIMETYPEAVAILABLE,
    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_CONTENTDISPOSITIONFILENAME,
    BINDSTATUS_MIMETEXTPLAINMISMATCH,
    BINDSTATUS_PUBLISHERAVAILABLE,
    BINDSTATUS_DISPLAYNAMEAVAILABLE
} 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)
interface 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 {
    BEGIN_INTERFACE

    /*** 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);

    END_INTERFACE
} IBindStatusCallbackVtbl;
interface IBindStatusCallback {
    const IBindStatusCallbackVtbl* lpVtbl;
};

#ifdef COBJMACROS
/*** 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

#endif

HRESULT CALLBACK IBindStatusCallback_OnStartBinding_Proxy(
    IBindStatusCallback* This,
    DWORD dwReserved,
    IBinding* pib);
void __RPC_STUB IBindStatusCallback_OnStartBinding_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IBindStatusCallback_GetPriority_Proxy(
    IBindStatusCallback* This,
    LONG* pnPriority);
void __RPC_STUB IBindStatusCallback_GetPriority_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IBindStatusCallback_OnLowResource_Proxy(
    IBindStatusCallback* This,
    DWORD reserved);
void __RPC_STUB IBindStatusCallback_OnLowResource_Stub(
    IRpcStubBuffer* This,
    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(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IBindStatusCallback_OnStopBinding_Proxy(
    IBindStatusCallback* This,
    HRESULT hresult,
    LPCWSTR szError);
void __RPC_STUB IBindStatusCallback_OnStopBinding_Stub(
    IRpcStubBuffer* This,
    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(
    IRpcStubBuffer* This,
    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(
    IRpcStubBuffer* This,
    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(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);

#endif  /* __IBindStatusCallback_INTERFACE_DEFINED__ */

#ifndef __IAuthenticate_FWD_DEFINED__
#define __IAuthenticate_FWD_DEFINED__
typedef interface IAuthenticate IAuthenticate;
#endif

typedef IAuthenticate *LPAUTHENTICATION;
/*****************************************************************************
 * IAuthenticate interface
 */
#ifndef __IAuthenticate_INTERFACE_DEFINED__
#define __IAuthenticate_INTERFACE_DEFINED__

DEFINE_GUID(IID_IAuthenticate, 0x79eac9d0, 0xbaf9, 0x11ce, 0x8c,0x82, 0x00,0xaa,0x00,0x4b,0xa9,0x0b);
#if defined(__cplusplus) && !defined(CINTERFACE)
interface IAuthenticate : public IUnknown
{
    virtual HRESULT STDMETHODCALLTYPE Authenticate(
        HWND* phwnd,
        LPWSTR* pszUsername,
        LPWSTR* pszPassword) = 0;

};
#else
typedef struct IAuthenticateVtbl {
    BEGIN_INTERFACE

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

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

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

    /*** IAuthenticate methods ***/
    HRESULT (STDMETHODCALLTYPE *Authenticate)(
        IAuthenticate* This,
        HWND* phwnd,
        LPWSTR* pszUsername,
        LPWSTR* pszPassword);

    END_INTERFACE
} IAuthenticateVtbl;
interface IAuthenticate {
    const IAuthenticateVtbl* lpVtbl;
};

#ifdef COBJMACROS
/*** IUnknown methods ***/
#define IAuthenticate_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b)
#define IAuthenticate_AddRef(p) (p)->lpVtbl->AddRef(p)
#define IAuthenticate_Release(p) (p)->lpVtbl->Release(p)
/*** IAuthenticate methods ***/
#define IAuthenticate_Authenticate(p,a,b,c) (p)->lpVtbl->Authenticate(p,a,b,c)
#endif

#endif

HRESULT CALLBACK IAuthenticate_Authenticate_Proxy(
    IAuthenticate* This,
    HWND* phwnd,
    LPWSTR* pszUsername,
    LPWSTR* pszPassword);
void __RPC_STUB IAuthenticate_Authenticate_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);

#endif  /* __IAuthenticate_INTERFACE_DEFINED__ */

#ifndef __IHttpNegotiate_FWD_DEFINED__
#define __IHttpNegotiate_FWD_DEFINED__
typedef interface IHttpNegotiate IHttpNegotiate;
#endif

typedef IHttpNegotiate *LPHTTPNEGOTIATE;
/*****************************************************************************
 * IHttpNegotiate interface
 */
#ifndef __IHttpNegotiate_INTERFACE_DEFINED__
#define __IHttpNegotiate_INTERFACE_DEFINED__

DEFINE_GUID(IID_IHttpNegotiate, 0x79eac9d2, 0xbaf9, 0x11ce, 0x8c,0x82, 0x00,0xaa,0x00,0x4b,0xa9,0x0b);
#if defined(__cplusplus) && !defined(CINTERFACE)
interface IHttpNegotiate : public IUnknown
{
    virtual HRESULT STDMETHODCALLTYPE BeginningTransaction(
        LPCWSTR szURL,
        LPCWSTR szHeaders,
        DWORD dwReserved,
        LPWSTR* pszAdditionalHeaders) = 0;

    virtual HRESULT STDMETHODCALLTYPE OnResponse(
        DWORD dwResponseCode,
        LPCWSTR szResponseHeaders,
        LPCWSTR szRequestHeaders,
        LPWSTR* pszAdditionalRequestHeaders) = 0;

};
#else
typedef struct IHttpNegotiateVtbl {
    BEGIN_INTERFACE

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

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

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

    /*** IHttpNegotiate methods ***/
    HRESULT (STDMETHODCALLTYPE *BeginningTransaction)(
        IHttpNegotiate* This,
        LPCWSTR szURL,
        LPCWSTR szHeaders,
        DWORD dwReserved,
        LPWSTR* pszAdditionalHeaders);

    HRESULT (STDMETHODCALLTYPE *OnResponse)(
        IHttpNegotiate* This,
        DWORD dwResponseCode,
        LPCWSTR szResponseHeaders,
        LPCWSTR szRequestHeaders,
        LPWSTR* pszAdditionalRequestHeaders);

    END_INTERFACE
} IHttpNegotiateVtbl;
interface IHttpNegotiate {
    const IHttpNegotiateVtbl* lpVtbl;
};

#ifdef COBJMACROS
/*** IUnknown methods ***/
#define IHttpNegotiate_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b)
#define IHttpNegotiate_AddRef(p) (p)->lpVtbl->AddRef(p)
#define IHttpNegotiate_Release(p) (p)->lpVtbl->Release(p)
/*** IHttpNegotiate methods ***/
#define IHttpNegotiate_BeginningTransaction(p,a,b,c,d) (p)->lpVtbl->BeginningTransaction(p,a,b,c,d)
#define IHttpNegotiate_OnResponse(p,a,b,c,d) (p)->lpVtbl->OnResponse(p,a,b,c,d)
#endif

#endif

HRESULT CALLBACK IHttpNegotiate_BeginningTransaction_Proxy(
    IHttpNegotiate* This,
    LPCWSTR szURL,
    LPCWSTR szHeaders,
    DWORD dwReserved,
    LPWSTR* pszAdditionalHeaders);
void __RPC_STUB IHttpNegotiate_BeginningTransaction_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IHttpNegotiate_OnResponse_Proxy(
    IHttpNegotiate* This,
    DWORD dwResponseCode,
    LPCWSTR szResponseHeaders,
    LPCWSTR szRequestHeaders,
    LPWSTR* pszAdditionalRequestHeaders);
void __RPC_STUB IHttpNegotiate_OnResponse_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);

#endif  /* __IHttpNegotiate_INTERFACE_DEFINED__ */

#ifndef __IHttpNegotiate2_FWD_DEFINED__
#define __IHttpNegotiate2_FWD_DEFINED__
typedef interface IHttpNegotiate2 IHttpNegotiate2;
#endif

typedef IHttpNegotiate2 *LPHTTPNEGOTIATE2;
/*****************************************************************************
 * IHttpNegotiate2 interface
 */
#ifndef __IHttpNegotiate2_INTERFACE_DEFINED__
#define __IHttpNegotiate2_INTERFACE_DEFINED__

DEFINE_GUID(IID_IHttpNegotiate2, 0x4f9f9fcb, 0xe0f4, 0x48eb, 0xb7,0xab, 0xfa,0x2e,0xa9,0x36,0x5c,0xb4);
#if defined(__cplusplus) && !defined(CINTERFACE)
interface IHttpNegotiate2 : public IHttpNegotiate
{
    virtual HRESULT STDMETHODCALLTYPE GetRootSecurityId(
        BYTE* pbSecurityId,
        DWORD* pcbSecurityId,
        DWORD_PTR dwReserved) = 0;

};
#else
typedef struct IHttpNegotiate2Vtbl {
    BEGIN_INTERFACE

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

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

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

    /*** IHttpNegotiate methods ***/
    HRESULT (STDMETHODCALLTYPE *BeginningTransaction)(
        IHttpNegotiate2* This,
        LPCWSTR szURL,
        LPCWSTR szHeaders,
        DWORD dwReserved,
        LPWSTR* pszAdditionalHeaders);

    HRESULT (STDMETHODCALLTYPE *OnResponse)(
        IHttpNegotiate2* This,
        DWORD dwResponseCode,
        LPCWSTR szResponseHeaders,
        LPCWSTR szRequestHeaders,
        LPWSTR* pszAdditionalRequestHeaders);

    /*** IHttpNegotiate2 methods ***/
    HRESULT (STDMETHODCALLTYPE *GetRootSecurityId)(
        IHttpNegotiate2* This,
        BYTE* pbSecurityId,
        DWORD* pcbSecurityId,
        DWORD_PTR dwReserved);

    END_INTERFACE
} IHttpNegotiate2Vtbl;
interface IHttpNegotiate2 {
    const IHttpNegotiate2Vtbl* lpVtbl;
};

#ifdef COBJMACROS
/*** IUnknown methods ***/
#define IHttpNegotiate2_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b)
#define IHttpNegotiate2_AddRef(p) (p)->lpVtbl->AddRef(p)
#define IHttpNegotiate2_Release(p) (p)->lpVtbl->Release(p)
/*** IHttpNegotiate methods ***/
#define IHttpNegotiate2_BeginningTransaction(p,a,b,c,d) (p)->lpVtbl->BeginningTransaction(p,a,b,c,d)
#define IHttpNegotiate2_OnResponse(p,a,b,c,d) (p)->lpVtbl->OnResponse(p,a,b,c,d)
/*** IHttpNegotiate2 methods ***/
#define IHttpNegotiate2_GetRootSecurityId(p,a,b,c) (p)->lpVtbl->GetRootSecurityId(p,a,b,c)
#endif

#endif

HRESULT CALLBACK IHttpNegotiate2_GetRootSecurityId_Proxy(
    IHttpNegotiate2* This,
    BYTE* pbSecurityId,
    DWORD* pcbSecurityId,
    DWORD_PTR dwReserved);
void __RPC_STUB IHttpNegotiate2_GetRootSecurityId_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);

#endif  /* __IHttpNegotiate2_INTERFACE_DEFINED__ */

#define SID_IBindHost IID_IBindHost
#define SID_SBindHost IID_IBindHost
#ifndef __IBindHost_FWD_DEFINED__
#define __IBindHost_FWD_DEFINED__
typedef interface 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)
interface 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 {
    BEGIN_INTERFACE

    /*** 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);

    END_INTERFACE
} IBindHostVtbl;
interface IBindHost {
    const IBindHostVtbl* lpVtbl;
};

#ifdef COBJMACROS
/*** 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

#endif

HRESULT CALLBACK IBindHost_CreateMoniker_Proxy(
    IBindHost* This,
    LPOLESTR szName,
    IBindCtx* pBC,
    IMoniker** ppmk,
    DWORD dwReserved);
void __RPC_STUB IBindHost_CreateMoniker_Stub(
    IRpcStubBuffer* This,
    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(
    IRpcStubBuffer* This,
    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(
    IRpcStubBuffer* This,
    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 interface 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)
interface IWinInetInfo : public IUnknown
{
    virtual HRESULT STDMETHODCALLTYPE QueryOption(
        DWORD dwOption,
        LPVOID pBuffer,
        DWORD* pcbBuf) = 0;

};
#else
typedef struct IWinInetInfoVtbl {
    BEGIN_INTERFACE

    /*** 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);

    END_INTERFACE
} IWinInetInfoVtbl;
interface IWinInetInfo {
    const IWinInetInfoVtbl* lpVtbl;
};

#ifdef COBJMACROS
/*** 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

#endif

HRESULT CALLBACK IWinInetInfo_RemoteQueryOption_Proxy(
    IWinInetInfo* This,
    DWORD dwOption,
    BYTE* pBuffer,
    DWORD* pcbBuf);
void __RPC_STUB IWinInetInfo_RemoteQueryOption_Stub(
    IRpcStubBuffer* This,
    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 interface 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)
interface IWinInetHttpInfo : public IWinInetInfo
{
    virtual HRESULT STDMETHODCALLTYPE QueryInfo(
        DWORD dwOption,
        LPVOID pBuffer,
        DWORD* pcbBuf,
        DWORD* pdwFlags,
        DWORD* pdwReserved) = 0;

};
#else
typedef struct IWinInetHttpInfoVtbl {
    BEGIN_INTERFACE

    /*** 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);

    END_INTERFACE
} IWinInetHttpInfoVtbl;
interface IWinInetHttpInfo {
    const IWinInetHttpInfoVtbl* lpVtbl;
};

#ifdef COBJMACROS
/*** 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

#endif

HRESULT CALLBACK IWinInetHttpInfo_RemoteQueryInfo_Proxy(
    IWinInetHttpInfo* This,
    DWORD dwOption,
    BYTE* pBuffer,
    DWORD* pcbBuf,
    DWORD* pdwFlags,
    DWORD* pdwReserved);
void __RPC_STUB IWinInetHttpInfo_RemoteQueryInfo_Stub(
    IRpcStubBuffer* This,
    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 interface 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)
interface 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 {
    BEGIN_INTERFACE

    /*** 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);

    END_INTERFACE
} IPersistMonikerVtbl;
interface IPersistMoniker {
    const IPersistMonikerVtbl* lpVtbl;
};

#ifdef COBJMACROS
/*** 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

#endif

HRESULT CALLBACK IPersistMoniker_GetClassID_Proxy(
    IPersistMoniker* This,
    CLSID* pClassID);
void __RPC_STUB IPersistMoniker_GetClassID_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IPersistMoniker_IsDirty_Proxy(
    IPersistMoniker* This);
void __RPC_STUB IPersistMoniker_IsDirty_Stub(
    IRpcStubBuffer* This,
    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(
    IRpcStubBuffer* This,
    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(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IPersistMoniker_SaveCompleted_Proxy(
    IPersistMoniker* This,
    IMoniker* pimkName,
    LPBC pibc);
void __RPC_STUB IPersistMoniker_SaveCompleted_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IPersistMoniker_GetCurMoniker_Proxy(
    IPersistMoniker* This,
    IMoniker** ppimkName);
void __RPC_STUB IPersistMoniker_GetCurMoniker_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);

#endif  /* __IPersistMoniker_INTERFACE_DEFINED__ */

#ifndef __IMonikerProp_FWD_DEFINED__
#define __IMonikerProp_FWD_DEFINED__
typedef interface IMonikerProp IMonikerProp;
#endif

typedef IMonikerProp *LPMONIKERPROP;
typedef enum {
    MIMETYPEPROP = 0x0,
    USE_SRC_URL = 0x1
} MONIKERPROPERTY;
/*****************************************************************************
 * IMonikerProp interface
 */
#ifndef __IMonikerProp_INTERFACE_DEFINED__
#define __IMonikerProp_INTERFACE_DEFINED__

DEFINE_GUID(IID_IMonikerProp, 0xa5ca5f7f, 0x1847, 0x4d87, 0x9c,0x5b, 0x91,0x85,0x09,0xf7,0x51,0x1d);
#if defined(__cplusplus) && !defined(CINTERFACE)
interface IMonikerProp : public IUnknown
{
    virtual HRESULT STDMETHODCALLTYPE PutProperty(
        MONIKERPROPERTY mkp,
        LPCWSTR val) = 0;

};
#else
typedef struct IMonikerPropVtbl {
    BEGIN_INTERFACE

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

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

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

    /*** IMonikerProp methods ***/
    HRESULT (STDMETHODCALLTYPE *PutProperty)(
        IMonikerProp* This,
        MONIKERPROPERTY mkp,
        LPCWSTR val);

    END_INTERFACE
} IMonikerPropVtbl;
interface IMonikerProp {
    const IMonikerPropVtbl* lpVtbl;
};

#ifdef COBJMACROS
/*** IUnknown methods ***/
#define IMonikerProp_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b)
#define IMonikerProp_AddRef(p) (p)->lpVtbl->AddRef(p)
#define IMonikerProp_Release(p) (p)->lpVtbl->Release(p)
/*** IMonikerProp methods ***/
#define IMonikerProp_PutProperty(p,a,b) (p)->lpVtbl->PutProperty(p,a,b)
#endif

#endif

HRESULT CALLBACK IMonikerProp_PutProperty_Proxy(
    IMonikerProp* This,
    MONIKERPROPERTY mkp,
    LPCWSTR val);
void __RPC_STUB IMonikerProp_PutProperty_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);

#endif  /* __IMonikerProp_INTERFACE_DEFINED__ */

#ifndef __IInternetBindInfo_FWD_DEFINED__
#define __IInternetBindInfo_FWD_DEFINED__
typedef interface IInternetBindInfo IInternetBindInfo;
#endif

typedef IInternetBindInfo *LPIINTERNETBINDINFO;
typedef enum tagBINDSTRING {
    BINDSTRING_HEADERS = 1,
    BINDSTRING_ACCEPT_MIMES,
    BINDSTRING_EXTRA_URL,
    BINDSTRING_LANGUAGE,
    BINDSTRING_USERNAME,
    BINDSTRING_PASSWORD,
    BINDSTRING_UA_PIXELS,
    BINDSTRING_UA_COLOR,
    BINDSTRING_OS,
    BINDSTRING_USER_AGENT,
    BINDSTRING_ACCEPT_ENCODINGS,
    BINDSTRING_POST_COOKIE,
    BINDSTRING_POST_DATA_MIME,
    BINDSTRING_URL,
    BINDSTRING_IID,
    BINDSTRING_FLAG_BIND_TO_OBJECT,
    BINDSTRING_PTR_BIND_CONTEXT
} BINDSTRING;
/*****************************************************************************
 * IInternetBindInfo interface
 */
#ifndef __IInternetBindInfo_INTERFACE_DEFINED__
#define __IInternetBindInfo_INTERFACE_DEFINED__

DEFINE_GUID(IID_IInternetBindInfo, 0x79eac9e1, 0xbaf9, 0x11ce, 0x8c,0x82, 0x00,0xaa,0x00,0x4b,0xa9,0x0b);
#if defined(__cplusplus) && !defined(CINTERFACE)
interface IInternetBindInfo : public IUnknown
{
    virtual HRESULT STDMETHODCALLTYPE GetBindInfo(
        DWORD* grfBINDF,
        BINDINFO* pbindinfo) = 0;

    virtual HRESULT STDMETHODCALLTYPE GetBindString(
        ULONG ulStringType,
        LPOLESTR* ppwzStr,
        ULONG cEl,
        ULONG* pcElFetched) = 0;

};
#else
typedef struct IInternetBindInfoVtbl {
    BEGIN_INTERFACE

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

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

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

    /*** IInternetBindInfo methods ***/
    HRESULT (STDMETHODCALLTYPE *GetBindInfo)(
        IInternetBindInfo* This,
        DWORD* grfBINDF,
        BINDINFO* pbindinfo);

    HRESULT (STDMETHODCALLTYPE *GetBindString)(
        IInternetBindInfo* This,
        ULONG ulStringType,
        LPOLESTR* ppwzStr,
        ULONG cEl,
        ULONG* pcElFetched);

    END_INTERFACE
} IInternetBindInfoVtbl;
interface IInternetBindInfo {
    const IInternetBindInfoVtbl* lpVtbl;
};

#ifdef COBJMACROS
/*** IUnknown methods ***/
#define IInternetBindInfo_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b)
#define IInternetBindInfo_AddRef(p) (p)->lpVtbl->AddRef(p)
#define IInternetBindInfo_Release(p) (p)->lpVtbl->Release(p)
/*** IInternetBindInfo methods ***/
#define IInternetBindInfo_GetBindInfo(p,a,b) (p)->lpVtbl->GetBindInfo(p,a,b)
#define IInternetBindInfo_GetBindString(p,a,b,c,d) (p)->lpVtbl->GetBindString(p,a,b,c,d)
#endif

#endif

HRESULT CALLBACK IInternetBindInfo_GetBindInfo_Proxy(
    IInternetBindInfo* This,
    DWORD* grfBINDF,
    BINDINFO* pbindinfo);
void __RPC_STUB IInternetBindInfo_GetBindInfo_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IInternetBindInfo_GetBindString_Proxy(
    IInternetBindInfo* This,
    ULONG ulStringType,
    LPOLESTR* ppwzStr,
    ULONG cEl,
    ULONG* pcElFetched);
void __RPC_STUB IInternetBindInfo_GetBindString_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);

#endif  /* __IInternetBindInfo_INTERFACE_DEFINED__ */

#ifndef __IInternetPriority_FWD_DEFINED__
#define __IInternetPriority_FWD_DEFINED__
typedef interface IInternetPriority IInternetPriority;
#endif

typedef IInternetPriority *LPIINTERNETPRIORITY;
/*****************************************************************************
 * IInternetPriority interface
 */
#ifndef __IInternetPriority_INTERFACE_DEFINED__
#define __IInternetPriority_INTERFACE_DEFINED__

DEFINE_GUID(IID_IInternetPriority, 0x79eac9eb, 0xbaf9, 0x11ce, 0x8c,0x82, 0x00,0xaa,0x00,0x4b,0xa9,0x0b);
#if defined(__cplusplus) && !defined(CINTERFACE)
interface IInternetPriority : public IUnknown
{
    virtual HRESULT STDMETHODCALLTYPE SetPriority(
        LONG nPriority) = 0;

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

};
#else
typedef struct IInternetPriorityVtbl {
    BEGIN_INTERFACE

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

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

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

    /*** IInternetPriority methods ***/
    HRESULT (STDMETHODCALLTYPE *SetPriority)(
        IInternetPriority* This,
        LONG nPriority);

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

    END_INTERFACE
} IInternetPriorityVtbl;
interface IInternetPriority {
    const IInternetPriorityVtbl* lpVtbl;
};

#ifdef COBJMACROS
/*** IUnknown methods ***/
#define IInternetPriority_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b)
#define IInternetPriority_AddRef(p) (p)->lpVtbl->AddRef(p)
#define IInternetPriority_Release(p) (p)->lpVtbl->Release(p)
/*** IInternetPriority methods ***/
#define IInternetPriority_SetPriority(p,a) (p)->lpVtbl->SetPriority(p,a)
#define IInternetPriority_GetPriority(p,a) (p)->lpVtbl->GetPriority(p,a)
#endif

#endif

HRESULT CALLBACK IInternetPriority_SetPriority_Proxy(
    IInternetPriority* This,
    LONG nPriority);
void __RPC_STUB IInternetPriority_SetPriority_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IInternetPriority_GetPriority_Proxy(
    IInternetPriority* This,
    LONG* pnPriority);
void __RPC_STUB IInternetPriority_GetPriority_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);

#endif  /* __IInternetPriority_INTERFACE_DEFINED__ */

#ifndef __IInternetProtocolRoot_FWD_DEFINED__
#define __IInternetProtocolRoot_FWD_DEFINED__
typedef interface IInternetProtocolRoot IInternetProtocolRoot;
#endif

typedef IInternetProtocolRoot *LPIINTERNETPROTOCOLROOT;
typedef enum _tagPI_FLAGS {
    PI_PARSE_URL = 0x1,
    PI_FILTER_MODE = 0x2,
    PI_FORCE_ASYNC = 0x4,
    PI_USE_WORKERTHREAD = 0x8,
    PI_MIMEVERIFICATION = 0x10,
    PI_CLSIDLOOKUP = 0x20,
    PI_DATAPROGRESS = 0x40,
    PI_SYNCHRONOUS = 0x80,
    PI_APARTMENTTHREADED = 0x100,
    PI_CLASSINSTALL = 0x200,
    PD_FORCE_SWITCH = 0x10000
} PI_FLAGS;
typedef struct _tagPROTOCOLDATA {
    DWORD grfFlags;
    DWORD dwState;
    LPVOID pData;
    ULONG cbData;
} PROTOCOLDATA;
/*****************************************************************************
 * IInternetProtocolRoot interface
 */
#ifndef __IInternetProtocolRoot_INTERFACE_DEFINED__
#define __IInternetProtocolRoot_INTERFACE_DEFINED__

DEFINE_GUID(IID_IInternetProtocolRoot, 0x79eac9e3, 0xbaf9, 0x11ce, 0x8c,0x82, 0x00,0xaa,0x00,0x4b,0xa9,0x0b);
#if defined(__cplusplus) && !defined(CINTERFACE)
interface IInternetProtocolRoot : public IUnknown
{
    virtual HRESULT STDMETHODCALLTYPE Start(
        LPCWSTR szUrl,
        IInternetProtocolSink* pOIProtSink,
        IInternetBindInfo* pOIBindInfo,
        DWORD grfPI,
        DWORD dwReserved) = 0;

    virtual HRESULT STDMETHODCALLTYPE Continue(
        PROTOCOLDATA* pProtocolData) = 0;

    virtual HRESULT STDMETHODCALLTYPE Abort(
        HRESULT hrReason,
        DWORD dwOptions) = 0;

    virtual HRESULT STDMETHODCALLTYPE Terminate(
        DWORD dwOptions) = 0;

    virtual HRESULT STDMETHODCALLTYPE Suspend(
        ) = 0;

    virtual HRESULT STDMETHODCALLTYPE Resume(
        ) = 0;

};
#else
typedef struct IInternetProtocolRootVtbl {
    BEGIN_INTERFACE

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

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

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

    /*** IInternetProtocolRoot methods ***/
    HRESULT (STDMETHODCALLTYPE *Start)(
        IInternetProtocolRoot* This,
        LPCWSTR szUrl,
        IInternetProtocolSink* pOIProtSink,
        IInternetBindInfo* pOIBindInfo,
        DWORD grfPI,
        DWORD dwReserved);

    HRESULT (STDMETHODCALLTYPE *Continue)(
        IInternetProtocolRoot* This,
        PROTOCOLDATA* pProtocolData);

    HRESULT (STDMETHODCALLTYPE *Abort)(
        IInternetProtocolRoot* This,
        HRESULT hrReason,
        DWORD dwOptions);

    HRESULT (STDMETHODCALLTYPE *Terminate)(
        IInternetProtocolRoot* This,
        DWORD dwOptions);

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

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

    END_INTERFACE
} IInternetProtocolRootVtbl;
interface IInternetProtocolRoot {
    const IInternetProtocolRootVtbl* lpVtbl;
};

#ifdef COBJMACROS
/*** IUnknown methods ***/
#define IInternetProtocolRoot_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b)
#define IInternetProtocolRoot_AddRef(p) (p)->lpVtbl->AddRef(p)
#define IInternetProtocolRoot_Release(p) (p)->lpVtbl->Release(p)
/*** IInternetProtocolRoot methods ***/
#define IInternetProtocolRoot_Start(p,a,b,c,d,e) (p)->lpVtbl->Start(p,a,b,c,d,e)
#define IInternetProtocolRoot_Continue(p,a) (p)->lpVtbl->Continue(p,a)
#define IInternetProtocolRoot_Abort(p,a,b) (p)->lpVtbl->Abort(p,a,b)
#define IInternetProtocolRoot_Terminate(p,a) (p)->lpVtbl->Terminate(p,a)
#define IInternetProtocolRoot_Suspend(p) (p)->lpVtbl->Suspend(p)
#define IInternetProtocolRoot_Resume(p) (p)->lpVtbl->Resume(p)
#endif

#endif

HRESULT CALLBACK IInternetProtocolRoot_Start_Proxy(
    IInternetProtocolRoot* This,
    LPCWSTR szUrl,
    IInternetProtocolSink* pOIProtSink,
    IInternetBindInfo* pOIBindInfo,
    DWORD grfPI,
    DWORD dwReserved);
void __RPC_STUB IInternetProtocolRoot_Start_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IInternetProtocolRoot_Continue_Proxy(
    IInternetProtocolRoot* This,
    PROTOCOLDATA* pProtocolData);
void __RPC_STUB IInternetProtocolRoot_Continue_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IInternetProtocolRoot_Abort_Proxy(
    IInternetProtocolRoot* This,
    HRESULT hrReason,
    DWORD dwOptions);
void __RPC_STUB IInternetProtocolRoot_Abort_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IInternetProtocolRoot_Terminate_Proxy(
    IInternetProtocolRoot* This,
    DWORD dwOptions);
void __RPC_STUB IInternetProtocolRoot_Terminate_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IInternetProtocolRoot_Suspend_Proxy(
    IInternetProtocolRoot* This);
void __RPC_STUB IInternetProtocolRoot_Suspend_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IInternetProtocolRoot_Resume_Proxy(
    IInternetProtocolRoot* This);
void __RPC_STUB IInternetProtocolRoot_Resume_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);

#endif  /* __IInternetProtocolRoot_INTERFACE_DEFINED__ */

typedef IInternetProtocolSink *LPIINTERNETPROTOCOLSINK;
/*****************************************************************************
 * IInternetProtocolSink interface
 */
#ifndef __IInternetProtocolSink_INTERFACE_DEFINED__
#define __IInternetProtocolSink_INTERFACE_DEFINED__

DEFINE_GUID(IID_IInternetProtocolSink, 0x79eac9e5, 0xbaf9, 0x11ce, 0x8c,0x82, 0x00,0xaa,0x00,0x4b,0xa9,0x0b);
#if defined(__cplusplus) && !defined(CINTERFACE)
interface IInternetProtocolSink : public IUnknown
{
    virtual HRESULT STDMETHODCALLTYPE Switch(
        PROTOCOLDATA* pProtocolData) = 0;

    virtual HRESULT STDMETHODCALLTYPE ReportProgress(
        ULONG ulStatusCode,
        LPCWSTR szStatusText) = 0;

    virtual HRESULT STDMETHODCALLTYPE ReportData(
        DWORD grfBSCF,
        ULONG ulProgress,
        ULONG ulProgressMax) = 0;

    virtual HRESULT STDMETHODCALLTYPE ReportResult(
        HRESULT hrResult,
        DWORD dwError,
        LPCWSTR szResult) = 0;

};
#else
typedef struct IInternetProtocolSinkVtbl {
    BEGIN_INTERFACE

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

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

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

    /*** IInternetProtocolSink methods ***/
    HRESULT (STDMETHODCALLTYPE *Switch)(
        IInternetProtocolSink* This,
        PROTOCOLDATA* pProtocolData);

    HRESULT (STDMETHODCALLTYPE *ReportProgress)(
        IInternetProtocolSink* This,
        ULONG ulStatusCode,
        LPCWSTR szStatusText);

    HRESULT (STDMETHODCALLTYPE *ReportData)(
        IInternetProtocolSink* This,
        DWORD grfBSCF,
        ULONG ulProgress,
        ULONG ulProgressMax);

    HRESULT (STDMETHODCALLTYPE *ReportResult)(
        IInternetProtocolSink* This,
        HRESULT hrResult,
        DWORD dwError,
        LPCWSTR szResult);

    END_INTERFACE
} IInternetProtocolSinkVtbl;
interface IInternetProtocolSink {
    const IInternetProtocolSinkVtbl* lpVtbl;
};

#ifdef COBJMACROS
/*** IUnknown methods ***/
#define IInternetProtocolSink_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b)
#define IInternetProtocolSink_AddRef(p) (p)->lpVtbl->AddRef(p)
#define IInternetProtocolSink_Release(p) (p)->lpVtbl->Release(p)
/*** IInternetProtocolSink methods ***/
#define IInternetProtocolSink_Switch(p,a) (p)->lpVtbl->Switch(p,a)
#define IInternetProtocolSink_ReportProgress(p,a,b) (p)->lpVtbl->ReportProgress(p,a,b)
#define IInternetProtocolSink_ReportData(p,a,b,c) (p)->lpVtbl->ReportData(p,a,b,c)
#define IInternetProtocolSink_ReportResult(p,a,b,c) (p)->lpVtbl->ReportResult(p,a,b,c)
#endif

#endif

HRESULT CALLBACK IInternetProtocolSink_Switch_Proxy(
    IInternetProtocolSink* This,
    PROTOCOLDATA* pProtocolData);
void __RPC_STUB IInternetProtocolSink_Switch_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IInternetProtocolSink_ReportProgress_Proxy(
    IInternetProtocolSink* This,
    ULONG ulStatusCode,
    LPCWSTR szStatusText);
void __RPC_STUB IInternetProtocolSink_ReportProgress_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IInternetProtocolSink_ReportData_Proxy(
    IInternetProtocolSink* This,
    DWORD grfBSCF,
    ULONG ulProgress,
    ULONG ulProgressMax);
void __RPC_STUB IInternetProtocolSink_ReportData_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IInternetProtocolSink_ReportResult_Proxy(
    IInternetProtocolSink* This,
    HRESULT hrResult,
    DWORD dwError,
    LPCWSTR szResult);
void __RPC_STUB IInternetProtocolSink_ReportResult_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);

#endif  /* __IInternetProtocolSink_INTERFACE_DEFINED__ */

#ifndef __IInternetProtocol_FWD_DEFINED__
#define __IInternetProtocol_FWD_DEFINED__
typedef interface IInternetProtocol IInternetProtocol;
#endif

typedef IInternetProtocol *LPIINTERNETPROTOCOL;
/*****************************************************************************
 * IInternetProtocol interface
 */
#ifndef __IInternetProtocol_INTERFACE_DEFINED__
#define __IInternetProtocol_INTERFACE_DEFINED__

DEFINE_GUID(IID_IInternetProtocol, 0x79eac9e4, 0xbaf9, 0x11ce, 0x8c,0x82, 0x00,0xaa,0x00,0x4b,0xa9,0x0b);
#if defined(__cplusplus) && !defined(CINTERFACE)
interface IInternetProtocol : public IInternetProtocolRoot
{
    virtual HRESULT STDMETHODCALLTYPE Read(
        void* pv,
        ULONG cb,
        ULONG* pcbRead) = 0;

    virtual HRESULT STDMETHODCALLTYPE Seek(
        LARGE_INTEGER dlibMove,
        DWORD dwOrigin,
        ULARGE_INTEGER* plibNewPosition) = 0;

    virtual HRESULT STDMETHODCALLTYPE LockRequest(
        DWORD dwOptions) = 0;

    virtual HRESULT STDMETHODCALLTYPE UnlockRequest(
        ) = 0;

};
#else
typedef struct IInternetProtocolVtbl {
    BEGIN_INTERFACE

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

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

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

    /*** IInternetProtocolRoot methods ***/
    HRESULT (STDMETHODCALLTYPE *Start)(
        IInternetProtocol* This,
        LPCWSTR szUrl,
        IInternetProtocolSink* pOIProtSink,
        IInternetBindInfo* pOIBindInfo,
        DWORD grfPI,
        DWORD dwReserved);

    HRESULT (STDMETHODCALLTYPE *Continue)(
        IInternetProtocol* This,
        PROTOCOLDATA* pProtocolData);

    HRESULT (STDMETHODCALLTYPE *Abort)(
        IInternetProtocol* This,
        HRESULT hrReason,
        DWORD dwOptions);

    HRESULT (STDMETHODCALLTYPE *Terminate)(
        IInternetProtocol* This,
        DWORD dwOptions);

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

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

    /*** IInternetProtocol methods ***/
    HRESULT (STDMETHODCALLTYPE *Read)(
        IInternetProtocol* This,
        void* pv,
        ULONG cb,
        ULONG* pcbRead);

    HRESULT (STDMETHODCALLTYPE *Seek)(
        IInternetProtocol* This,
        LARGE_INTEGER dlibMove,
        DWORD dwOrigin,
        ULARGE_INTEGER* plibNewPosition);

    HRESULT (STDMETHODCALLTYPE *LockRequest)(
        IInternetProtocol* This,
        DWORD dwOptions);

    HRESULT (STDMETHODCALLTYPE *UnlockRequest)(
        IInternetProtocol* This);

    END_INTERFACE
} IInternetProtocolVtbl;
interface IInternetProtocol {
    const IInternetProtocolVtbl* lpVtbl;
};

#ifdef COBJMACROS
/*** IUnknown methods ***/
#define IInternetProtocol_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b)
#define IInternetProtocol_AddRef(p) (p)->lpVtbl->AddRef(p)
#define IInternetProtocol_Release(p) (p)->lpVtbl->Release(p)
/*** IInternetProtocolRoot methods ***/
#define IInternetProtocol_Start(p,a,b,c,d,e) (p)->lpVtbl->Start(p,a,b,c,d,e)
#define IInternetProtocol_Continue(p,a) (p)->lpVtbl->Continue(p,a)
#define IInternetProtocol_Abort(p,a,b) (p)->lpVtbl->Abort(p,a,b)
#define IInternetProtocol_Terminate(p,a) (p)->lpVtbl->Terminate(p,a)
#define IInternetProtocol_Suspend(p) (p)->lpVtbl->Suspend(p)
#define IInternetProtocol_Resume(p) (p)->lpVtbl->Resume(p)
/*** IInternetProtocol methods ***/
#define IInternetProtocol_Read(p,a,b,c) (p)->lpVtbl->Read(p,a,b,c)
#define IInternetProtocol_Seek(p,a,b,c) (p)->lpVtbl->Seek(p,a,b,c)
#define IInternetProtocol_LockRequest(p,a) (p)->lpVtbl->LockRequest(p,a)
#define IInternetProtocol_UnlockRequest(p) (p)->lpVtbl->UnlockRequest(p)
#endif

#endif

HRESULT CALLBACK IInternetProtocol_Read_Proxy(
    IInternetProtocol* This,
    void* pv,
    ULONG cb,
    ULONG* pcbRead);
void __RPC_STUB IInternetProtocol_Read_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IInternetProtocol_Seek_Proxy(
    IInternetProtocol* This,
    LARGE_INTEGER dlibMove,
    DWORD dwOrigin,
    ULARGE_INTEGER* plibNewPosition);
void __RPC_STUB IInternetProtocol_Seek_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IInternetProtocol_LockRequest_Proxy(
    IInternetProtocol* This,
    DWORD dwOptions);
void __RPC_STUB IInternetProtocol_LockRequest_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IInternetProtocol_UnlockRequest_Proxy(
    IInternetProtocol* This);
void __RPC_STUB IInternetProtocol_UnlockRequest_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);

#endif  /* __IInternetProtocol_INTERFACE_DEFINED__ */

#ifndef __IInternetProtocolInfo_FWD_DEFINED__
#define __IInternetProtocolInfo_FWD_DEFINED__
typedef interface 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)
interface 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 {
    BEGIN_INTERFACE

    /*** 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);

    END_INTERFACE
} IInternetProtocolInfoVtbl;
interface IInternetProtocolInfo {
    const IInternetProtocolInfoVtbl* lpVtbl;
};

#ifdef COBJMACROS
/*** 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

#endif

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(
    IRpcStubBuffer* This,
    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(
    IRpcStubBuffer* This,
    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(
    IRpcStubBuffer* This,
    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(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);

#endif  /* __IInternetProtocolInfo_INTERFACE_DEFINED__ */

#ifndef __IInternetSession_FWD_DEFINED__
#define __IInternetSession_FWD_DEFINED__
typedef interface IInternetSession IInternetSession;
#endif

typedef IInternetSession *LPIINTERNETSESSION;
typedef enum _tagOIBDG_FLAGS {
    OIBDG_APARTMENTTHREADED = 0x100,
    OIBDG_DATAONLY = 0x1000
} OIBDG_FLAGS;
/*****************************************************************************
 * IInternetSession interface
 */
#ifndef __IInternetSession_INTERFACE_DEFINED__
#define __IInternetSession_INTERFACE_DEFINED__

DEFINE_GUID(IID_IInternetSession, 0x79eac9e7, 0xbaf9, 0x11ce, 0x8c,0x82, 0x00,0xaa,0x00,0x4b,0xa9,0x0b);
#if defined(__cplusplus) && !defined(CINTERFACE)
interface IInternetSession : public IUnknown
{
    virtual HRESULT STDMETHODCALLTYPE RegisterNameSpace(
        IClassFactory* pCF,
        REFCLSID rclsid,
        LPCWSTR pwzProtocol,
        ULONG cPatterns,
        const LPCWSTR* ppwzPatterns,
        DWORD dwReserved) = 0;

    virtual HRESULT STDMETHODCALLTYPE UnregisterNameSpace(
        IClassFactory* pCF,
        LPCWSTR pszProtocol) = 0;

    virtual HRESULT STDMETHODCALLTYPE RegisterMimeFilter(
        IClassFactory* pCF,
        REFCLSID rclsid,
        LPCWSTR pwzType) = 0;

    virtual HRESULT STDMETHODCALLTYPE UnregisterMimeFilter(
        IClassFactory* pCF,
        LPCWSTR pwzType) = 0;

    virtual HRESULT STDMETHODCALLTYPE CreateBinding(
        LPBC pBC,
        LPCWSTR szUrl,
        IUnknown* pUnkOuter,
        IUnknown** ppUnk,
        IInternetProtocol** ppOInetProt,
        DWORD dwOption) = 0;

    virtual HRESULT STDMETHODCALLTYPE SetSessionOption(
        DWORD dwOption,
        LPVOID pBuffer,
        DWORD dwBufferLength,
        DWORD dwReserved) = 0;

};
#else
typedef struct IInternetSessionVtbl {
    BEGIN_INTERFACE

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

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

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

    /*** IInternetSession methods ***/
    HRESULT (STDMETHODCALLTYPE *RegisterNameSpace)(
        IInternetSession* This,
        IClassFactory* pCF,
        REFCLSID rclsid,
        LPCWSTR pwzProtocol,
        ULONG cPatterns,
        const LPCWSTR* ppwzPatterns,
        DWORD dwReserved);

    HRESULT (STDMETHODCALLTYPE *UnregisterNameSpace)(
        IInternetSession* This,
        IClassFactory* pCF,
        LPCWSTR pszProtocol);

    HRESULT (STDMETHODCALLTYPE *RegisterMimeFilter)(
        IInternetSession* This,
        IClassFactory* pCF,
        REFCLSID rclsid,
        LPCWSTR pwzType);

    HRESULT (STDMETHODCALLTYPE *UnregisterMimeFilter)(
        IInternetSession* This,
        IClassFactory* pCF,
        LPCWSTR pwzType);

    HRESULT (STDMETHODCALLTYPE *CreateBinding)(
        IInternetSession* This,
        LPBC pBC,
        LPCWSTR szUrl,
        IUnknown* pUnkOuter,
        IUnknown** ppUnk,
        IInternetProtocol** ppOInetProt,
        DWORD dwOption);

    HRESULT (STDMETHODCALLTYPE *SetSessionOption)(
        IInternetSession* This,
        DWORD dwOption,
        LPVOID pBuffer,
        DWORD dwBufferLength,
        DWORD dwReserved);

    END_INTERFACE
} IInternetSessionVtbl;
interface IInternetSession {
    const IInternetSessionVtbl* lpVtbl;
};

#ifdef COBJMACROS
/*** IUnknown methods ***/
#define IInternetSession_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b)
#define IInternetSession_AddRef(p) (p)->lpVtbl->AddRef(p)
#define IInternetSession_Release(p) (p)->lpVtbl->Release(p)
/*** IInternetSession methods ***/
#define IInternetSession_RegisterNameSpace(p,a,b,c,d,e,f) (p)->lpVtbl->RegisterNameSpace(p,a,b,c,d,e,f)
#define IInternetSession_UnregisterNameSpace(p,a,b) (p)->lpVtbl->UnregisterNameSpace(p,a,b)
#define IInternetSession_RegisterMimeFilter(p,a,b,c) (p)->lpVtbl->RegisterMimeFilter(p,a,b,c)
#define IInternetSession_UnregisterMimeFilter(p,a,b) (p)->lpVtbl->UnregisterMimeFilter(p,a,b)
#define IInternetSession_CreateBinding(p,a,b,c,d,e,f) (p)->lpVtbl->CreateBinding(p,a,b,c,d,e,f)
#define IInternetSession_SetSessionOption(p,a,b,c,d) (p)->lpVtbl->SetSessionOption(p,a,b,c,d)
#endif

#endif

HRESULT CALLBACK IInternetSession_RegisterNameSpace_Proxy(
    IInternetSession* This,
    IClassFactory* pCF,
    REFCLSID rclsid,
    LPCWSTR pwzProtocol,
    ULONG cPatterns,
    const LPCWSTR* ppwzPatterns,
    DWORD dwReserved);
void __RPC_STUB IInternetSession_RegisterNameSpace_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IInternetSession_UnregisterNameSpace_Proxy(
    IInternetSession* This,
    IClassFactory* pCF,
    LPCWSTR pszProtocol);
void __RPC_STUB IInternetSession_UnregisterNameSpace_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IInternetSession_RegisterMimeFilter_Proxy(
    IInternetSession* This,
    IClassFactory* pCF,
    REFCLSID rclsid,
    LPCWSTR pwzType);
void __RPC_STUB IInternetSession_RegisterMimeFilter_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IInternetSession_UnregisterMimeFilter_Proxy(
    IInternetSession* This,
    IClassFactory* pCF,
    LPCWSTR pwzType);
void __RPC_STUB IInternetSession_UnregisterMimeFilter_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IInternetSession_CreateBinding_Proxy(
    IInternetSession* This,
    LPBC pBC,
    LPCWSTR szUrl,
    IUnknown* pUnkOuter,
    IUnknown** ppUnk,
    IInternetProtocol** ppOInetProt,
    DWORD dwOption);
void __RPC_STUB IInternetSession_CreateBinding_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IInternetSession_SetSessionOption_Proxy(
    IInternetSession* This,
    DWORD dwOption,
    LPVOID pBuffer,
    DWORD dwBufferLength,
    DWORD dwReserved);
void __RPC_STUB IInternetSession_SetSessionOption_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);

#endif  /* __IInternetSession_INTERFACE_DEFINED__ */

#ifndef __IInternetSecurityMgrSite_FWD_DEFINED__
#define __IInternetSecurityMgrSite_FWD_DEFINED__
typedef interface IInternetSecurityMgrSite IInternetSecurityMgrSite;
#endif

/*****************************************************************************
 * IInternetSecurityMgrSite interface
 */
#ifndef __IInternetSecurityMgrSite_INTERFACE_DEFINED__
#define __IInternetSecurityMgrSite_INTERFACE_DEFINED__

DEFINE_GUID(IID_IInternetSecurityMgrSite, 0x79eac9ed, 0xbaf9, 0x11ce, 0x8c,0x82, 0x00,0xaa,0x00,0x4b,0xa9,0x0b);
#if defined(__cplusplus) && !defined(CINTERFACE)
interface IInternetSecurityMgrSite : public IUnknown
{
    virtual HRESULT STDMETHODCALLTYPE GetWindow(
        HWND* phwnd) = 0;

    virtual HRESULT STDMETHODCALLTYPE EnableModeless(
        BOOL fEnable) = 0;

};
#else
typedef struct IInternetSecurityMgrSiteVtbl {
    BEGIN_INTERFACE

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

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

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

    /*** IInternetSecurityMgrSite methods ***/
    HRESULT (STDMETHODCALLTYPE *GetWindow)(
        IInternetSecurityMgrSite* This,
        HWND* phwnd);

    HRESULT (STDMETHODCALLTYPE *EnableModeless)(
        IInternetSecurityMgrSite* This,
        BOOL fEnable);

    END_INTERFACE
} IInternetSecurityMgrSiteVtbl;
interface IInternetSecurityMgrSite {
    const IInternetSecurityMgrSiteVtbl* lpVtbl;
};

#ifdef COBJMACROS
/*** IUnknown methods ***/
#define IInternetSecurityMgrSite_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b)
#define IInternetSecurityMgrSite_AddRef(p) (p)->lpVtbl->AddRef(p)
#define IInternetSecurityMgrSite_Release(p) (p)->lpVtbl->Release(p)
/*** IInternetSecurityMgrSite methods ***/
#define IInternetSecurityMgrSite_GetWindow(p,a) (p)->lpVtbl->GetWindow(p,a)
#define IInternetSecurityMgrSite_EnableModeless(p,a) (p)->lpVtbl->EnableModeless(p,a)
#endif

#endif

HRESULT CALLBACK IInternetSecurityMgrSite_GetWindow_Proxy(
    IInternetSecurityMgrSite* This,
    HWND* phwnd);
void __RPC_STUB IInternetSecurityMgrSite_GetWindow_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IInternetSecurityMgrSite_EnableModeless_Proxy(
    IInternetSecurityMgrSite* This,
    BOOL fEnable);
void __RPC_STUB IInternetSecurityMgrSite_EnableModeless_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);

#endif  /* __IInternetSecurityMgrSite_INTERFACE_DEFINED__ */

#define SID_SInternetSecurityManager IID_IInternetSecurityManager
#ifndef __IInternetSecurityManager_FWD_DEFINED__
#define __IInternetSecurityManager_FWD_DEFINED__
typedef interface IInternetSecurityManager IInternetSecurityManager;
#endif

#define MAX_SIZE_SECURITY_ID 512
typedef enum {
    PUAF_DEFAULT = 0x0,
    PUAF_NOUI = 0x1,
    PUAF_ISFILE = 0x2,
    PUAF_WARN_IF_DENIED = 0x4,
    PUAF_FORCEUI_FOREGROUND = 0x8,
    PUAF_CHECK_TIPS = 0x10
} PUAF;
typedef enum {
    SZM_CREATE = 0x0,
    SZM_DELETE = 0x1
} SZM_FLAGS;
/*****************************************************************************
 * IInternetSecurityManager interface
 */
#ifndef __IInternetSecurityManager_INTERFACE_DEFINED__
#define __IInternetSecurityManager_INTERFACE_DEFINED__

DEFINE_GUID(IID_IInternetSecurityManager, 0x79eac9ee, 0xbaf9, 0x11ce, 0x8c,0x82, 0x00,0xaa,0x00,0x4b,0xa9,0x0b);
#if defined(__cplusplus) && !defined(CINTERFACE)
interface IInternetSecurityManager : public IUnknown
{
    virtual HRESULT STDMETHODCALLTYPE SetSecuritySite(
        IInternetSecurityMgrSite* pSite) = 0;

    virtual HRESULT STDMETHODCALLTYPE GetSecuritySite(
        IInternetSecurityMgrSite** ppSite) = 0;

    virtual HRESULT STDMETHODCALLTYPE MapUrlToZone(
        LPCWSTR pwszUrl,
        DWORD* pdwZone,
        DWORD dwFlags) = 0;

    virtual HRESULT STDMETHODCALLTYPE GetSecurityId(
        LPCWSTR pwszUrl,
        BYTE* pbSecurityId,
        DWORD* pcbSecurityId,
        DWORD_PTR dwReserved) = 0;

    virtual HRESULT STDMETHODCALLTYPE ProcessUrlAction(
        LPCWSTR pwszUrl,
        DWORD dwAction,
        BYTE* pPolicy,
        DWORD cbPolicy,
        BYTE* pContext,
        DWORD cbContext,
        DWORD dwFlags,
        DWORD dwReserved) = 0;

    virtual HRESULT STDMETHODCALLTYPE QueryCustomPolicy(
        LPCWSTR pwszUrl,
        REFGUID guidKey,
        BYTE** ppPolicy,
        DWORD* pcbPolicy,
        BYTE* pContext,
        DWORD cbContext,
        DWORD dwReserved) = 0;

    virtual HRESULT STDMETHODCALLTYPE SetZoneMapping(
        DWORD dwZone,
        LPCWSTR lpszPattern,
        DWORD dwFlags) = 0;

    virtual HRESULT STDMETHODCALLTYPE GetZoneMappings(
        DWORD dwZone,
        IEnumString** ppenumString,
        DWORD dwFlags) = 0;

};
#else
typedef struct IInternetSecurityManagerVtbl {
    BEGIN_INTERFACE

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

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

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

    /*** IInternetSecurityManager methods ***/
    HRESULT (STDMETHODCALLTYPE *SetSecuritySite)(
        IInternetSecurityManager* This,
        IInternetSecurityMgrSite* pSite);

    HRESULT (STDMETHODCALLTYPE *GetSecuritySite)(
        IInternetSecurityManager* This,
        IInternetSecurityMgrSite** ppSite);

    HRESULT (STDMETHODCALLTYPE *MapUrlToZone)(
        IInternetSecurityManager* This,
        LPCWSTR pwszUrl,
        DWORD* pdwZone,
        DWORD dwFlags);

    HRESULT (STDMETHODCALLTYPE *GetSecurityId)(
        IInternetSecurityManager* This,
        LPCWSTR pwszUrl,
        BYTE* pbSecurityId,
        DWORD* pcbSecurityId,
        DWORD_PTR dwReserved);

    HRESULT (STDMETHODCALLTYPE *ProcessUrlAction)(
        IInternetSecurityManager* This,
        LPCWSTR pwszUrl,
        DWORD dwAction,
        BYTE* pPolicy,
        DWORD cbPolicy,
        BYTE* pContext,
        DWORD cbContext,
        DWORD dwFlags,
        DWORD dwReserved);

    HRESULT (STDMETHODCALLTYPE *QueryCustomPolicy)(
        IInternetSecurityManager* This,
        LPCWSTR pwszUrl,
        REFGUID guidKey,
        BYTE** ppPolicy,
        DWORD* pcbPolicy,
        BYTE* pContext,
        DWORD cbContext,
        DWORD dwReserved);

    HRESULT (STDMETHODCALLTYPE *SetZoneMapping)(
        IInternetSecurityManager* This,
        DWORD dwZone,
        LPCWSTR lpszPattern,
        DWORD dwFlags);

    HRESULT (STDMETHODCALLTYPE *GetZoneMappings)(
        IInternetSecurityManager* This,
        DWORD dwZone,
        IEnumString** ppenumString,
        DWORD dwFlags);

    END_INTERFACE
} IInternetSecurityManagerVtbl;
interface IInternetSecurityManager {
    const IInternetSecurityManagerVtbl* lpVtbl;
};

#ifdef COBJMACROS
/*** IUnknown methods ***/
#define IInternetSecurityManager_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b)
#define IInternetSecurityManager_AddRef(p) (p)->lpVtbl->AddRef(p)
#define IInternetSecurityManager_Release(p) (p)->lpVtbl->Release(p)
/*** IInternetSecurityManager methods ***/
#define IInternetSecurityManager_SetSecuritySite(p,a) (p)->lpVtbl->SetSecuritySite(p,a)
#define IInternetSecurityManager_GetSecuritySite(p,a) (p)->lpVtbl->GetSecuritySite(p,a)
#define IInternetSecurityManager_MapUrlToZone(p,a,b,c) (p)->lpVtbl->MapUrlToZone(p,a,b,c)
#define IInternetSecurityManager_GetSecurityId(p,a,b,c,d) (p)->lpVtbl->GetSecurityId(p,a,b,c,d)
#define IInternetSecurityManager_ProcessUrlAction(p,a,b,c,d,e,f,g,h) (p)->lpVtbl->ProcessUrlAction(p,a,b,c,d,e,f,g,h)
#define IInternetSecurityManager_QueryCustomPolicy(p,a,b,c,d,e,f,g) (p)->lpVtbl->QueryCustomPolicy(p,a,b,c,d,e,f,g)
#define IInternetSecurityManager_SetZoneMapping(p,a,b,c) (p)->lpVtbl->SetZoneMapping(p,a,b,c)
#define IInternetSecurityManager_GetZoneMappings(p,a,b,c) (p)->lpVtbl->GetZoneMappings(p,a,b,c)
#endif

#endif

HRESULT CALLBACK IInternetSecurityManager_SetSecuritySite_Proxy(
    IInternetSecurityManager* This,
    IInternetSecurityMgrSite* pSite);
void __RPC_STUB IInternetSecurityManager_SetSecuritySite_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IInternetSecurityManager_GetSecuritySite_Proxy(
    IInternetSecurityManager* This,
    IInternetSecurityMgrSite** ppSite);
void __RPC_STUB IInternetSecurityManager_GetSecuritySite_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IInternetSecurityManager_MapUrlToZone_Proxy(
    IInternetSecurityManager* This,
    LPCWSTR pwszUrl,
    DWORD* pdwZone,
    DWORD dwFlags);
void __RPC_STUB IInternetSecurityManager_MapUrlToZone_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IInternetSecurityManager_GetSecurityId_Proxy(
    IInternetSecurityManager* This,
    LPCWSTR pwszUrl,
    BYTE* pbSecurityId,
    DWORD* pcbSecurityId,
    DWORD_PTR dwReserved);
void __RPC_STUB IInternetSecurityManager_GetSecurityId_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IInternetSecurityManager_ProcessUrlAction_Proxy(
    IInternetSecurityManager* This,
    LPCWSTR pwszUrl,
    DWORD dwAction,
    BYTE* pPolicy,
    DWORD cbPolicy,
    BYTE* pContext,
    DWORD cbContext,
    DWORD dwFlags,
    DWORD dwReserved);
void __RPC_STUB IInternetSecurityManager_ProcessUrlAction_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IInternetSecurityManager_QueryCustomPolicy_Proxy(
    IInternetSecurityManager* This,
    LPCWSTR pwszUrl,
    REFGUID guidKey,
    BYTE** ppPolicy,
    DWORD* pcbPolicy,
    BYTE* pContext,
    DWORD cbContext,
    DWORD dwReserved);
void __RPC_STUB IInternetSecurityManager_QueryCustomPolicy_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IInternetSecurityManager_SetZoneMapping_Proxy(
    IInternetSecurityManager* This,
    DWORD dwZone,
    LPCWSTR lpszPattern,
    DWORD dwFlags);
void __RPC_STUB IInternetSecurityManager_SetZoneMapping_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IInternetSecurityManager_GetZoneMappings_Proxy(
    IInternetSecurityManager* This,
    DWORD dwZone,
    IEnumString** ppenumString,
    DWORD dwFlags);
void __RPC_STUB IInternetSecurityManager_GetZoneMappings_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);

#endif  /* __IInternetSecurityManager_INTERFACE_DEFINED__ */

#ifndef __IInternetZoneManager_FWD_DEFINED__
#define __IInternetZoneManager_FWD_DEFINED__
typedef interface IInternetZoneManager IInternetZoneManager;
#endif

typedef IInternetZoneManager *LPURLZONEMANAGER;
typedef enum tagURLZONE {
    URLZONE_PREDEFINED_MIN = 0,
    URLZONE_LOCAL_MACHINE = 0,
    URLZONE_INTRANET = 1,
    URLZONE_TRUSTED = 2,
    URLZONE_INTERNET = 3,
    URLZONE_UNTRUSTED = 4,
    URLZONE_PREDEFINED_MAX = 999,
    URLZONE_USER_MIN = 1000,
    URLZONE_USER_MAX = 10000
} URLZONE;
typedef enum tagURLTEMPLATE {
    URLTEMPLATE_CUSTOM = 0x0,
    URLTEMPLATE_PREDEFINED_MIN = 0x10000,
    URLTEMPLATE_LOW = 0x10000,
    URLTEMPLATE_MEDIUM = 0x11000,
    URLTEMPLATE_HIGH = 0x12000,
    URLTEMPLATE_PREDEFINED_MAX = 0x20000
} URLTEMPLATE;
typedef enum {
    ZAFLAGS_CUSTOM_EDIT = 0x1,
    ZAFLAGS_ADD_SITES = 0x2,
    ZAFLAGS_REQUIRE_VERIFICATION = 0x4,
    ZAFLAGS_INCLUDE_PROXY_OVERRIDE = 0x8,
    ZAFLAGS_INCLUDE_INTRANET_SITES = 0x10,
    ZAFLAGS_NO_UI = 0x20,
    ZAFLAGS_SUPPORTS_VERIFICATION = 0x40,
    ZAFLAGS_UNC_AS_INTRANET = 0x80
} ZAFLAGS;
enum {
    MAX_ZONE_PATH = 260,
    MAX_ZONE_DESCRIPTION = 200
};

typedef struct _ZONEATTRIBUTES {
    ULONG cbSize;
    WCHAR szDisplayName[260];
    WCHAR szDescription[200];
    WCHAR szIconPath[260];
    DWORD dwTemplateMinLevel;
    DWORD dwTemplateRecommended;
    DWORD dwTemplateCurrentLevel;
    DWORD dwFlags;
} ZONEATTRIBUTES, *LPZONEATTRIBUTES;
typedef enum _URLZONEREG {
    URLZONEREG_DEFAULT,
    URLZONEREG_HKLM,
    URLZONEREG_HKCU
} URLZONEREG;
/*****************************************************************************
 * IInternetZoneManager interface
 */
#ifndef __IInternetZoneManager_INTERFACE_DEFINED__
#define __IInternetZoneManager_INTERFACE_DEFINED__

DEFINE_GUID(IID_IInternetZoneManager, 0x79eac9ef, 0xbaf9, 0x11ce, 0x8c,0x82, 0x00,0xaa,0x00,0x4b,0xa9,0x0b);
#if defined(__cplusplus) && !defined(CINTERFACE)
interface IInternetZoneManager : public IUnknown
{
    virtual HRESULT STDMETHODCALLTYPE GetZoneAttributes(
        DWORD dwZone,
        ZONEATTRIBUTES* pZoneAttributes) = 0;

    virtual HRESULT STDMETHODCALLTYPE SetZoneAttributes(
        DWORD dwZone,
        ZONEATTRIBUTES* pZoneAttributes) = 0;

    virtual HRESULT STDMETHODCALLTYPE GetZoneCustomPolicy(
        DWORD dwZone,
        REFGUID guidKey,
        BYTE** ppPolicy,
        DWORD* pcbPolicy,
        URLZONEREG ulrZoneReg) = 0;

    virtual HRESULT STDMETHODCALLTYPE SetZoneCustomPolicy(
        DWORD dwZone,
        REFGUID guidKey,
        BYTE* ppPolicy,
        DWORD pcbPolicy,
        URLZONEREG ulrZoneReg) = 0;

    virtual HRESULT STDMETHODCALLTYPE GetZoneActionPolicy(
        DWORD dwZone,
        DWORD dwAction,
        BYTE* pPolicy,
        DWORD cbPolicy,
        URLZONEREG urlZoneReg) = 0;

    virtual HRESULT STDMETHODCALLTYPE SetZoneActionPolicy(
        DWORD dwZone,
        DWORD dwAction,
        BYTE* pPolicy,
        DWORD cbPolicy,
        URLZONEREG urlZoneReg) = 0;

    virtual HRESULT STDMETHODCALLTYPE PromptAction(
        DWORD dwAction,
        HWND hwndParent,
        LPCWSTR pwszUrl,
        LPCWSTR pwszText,
        DWORD dwPromptFlags) = 0;

    virtual HRESULT STDMETHODCALLTYPE LogAction(
        DWORD dwAction,
        LPCWSTR pwszUrl,
        LPCWSTR pwszText,
        DWORD dwLogFlags) = 0;

    virtual HRESULT STDMETHODCALLTYPE CreateZoneEnumerator(
        DWORD* pdwEnum,
        DWORD* pdwCount,
        DWORD dwFlags) = 0;

    virtual HRESULT STDMETHODCALLTYPE GetZoneAt(
        DWORD dwEnum,
        DWORD dwIndex,
        DWORD* pdwZone) = 0;

    virtual HRESULT STDMETHODCALLTYPE DestroyZoneEnumerator(
        DWORD dwEnum) = 0;

    virtual HRESULT STDMETHODCALLTYPE CopyTemplatePoliciesToZone(
        DWORD dwTemplate,
        DWORD dwZone,
        DWORD dwReserved) = 0;

};
#else
typedef struct IInternetZoneManagerVtbl {
    BEGIN_INTERFACE

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

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

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

    /*** IInternetZoneManager methods ***/
    HRESULT (STDMETHODCALLTYPE *GetZoneAttributes)(
        IInternetZoneManager* This,
        DWORD dwZone,
        ZONEATTRIBUTES* pZoneAttributes);

    HRESULT (STDMETHODCALLTYPE *SetZoneAttributes)(
        IInternetZoneManager* This,
        DWORD dwZone,
        ZONEATTRIBUTES* pZoneAttributes);

    HRESULT (STDMETHODCALLTYPE *GetZoneCustomPolicy)(
        IInternetZoneManager* This,
        DWORD dwZone,
        REFGUID guidKey,
        BYTE** ppPolicy,
        DWORD* pcbPolicy,
        URLZONEREG ulrZoneReg);

    HRESULT (STDMETHODCALLTYPE *SetZoneCustomPolicy)(
        IInternetZoneManager* This,
        DWORD dwZone,
        REFGUID guidKey,
        BYTE* ppPolicy,
        DWORD pcbPolicy,
        URLZONEREG ulrZoneReg);

    HRESULT (STDMETHODCALLTYPE *GetZoneActionPolicy)(
        IInternetZoneManager* This,
        DWORD dwZone,
        DWORD dwAction,
        BYTE* pPolicy,
        DWORD cbPolicy,
        URLZONEREG urlZoneReg);

    HRESULT (STDMETHODCALLTYPE *SetZoneActionPolicy)(
        IInternetZoneManager* This,
        DWORD dwZone,
        DWORD dwAction,
        BYTE* pPolicy,
        DWORD cbPolicy,
        URLZONEREG urlZoneReg);

    HRESULT (STDMETHODCALLTYPE *PromptAction)(
        IInternetZoneManager* This,
        DWORD dwAction,
        HWND hwndParent,
        LPCWSTR pwszUrl,
        LPCWSTR pwszText,
        DWORD dwPromptFlags);

    HRESULT (STDMETHODCALLTYPE *LogAction)(
        IInternetZoneManager* This,
        DWORD dwAction,
        LPCWSTR pwszUrl,
        LPCWSTR pwszText,
        DWORD dwLogFlags);

    HRESULT (STDMETHODCALLTYPE *CreateZoneEnumerator)(
        IInternetZoneManager* This,
        DWORD* pdwEnum,
        DWORD* pdwCount,
        DWORD dwFlags);

    HRESULT (STDMETHODCALLTYPE *GetZoneAt)(
        IInternetZoneManager* This,
        DWORD dwEnum,
        DWORD dwIndex,
        DWORD* pdwZone);

    HRESULT (STDMETHODCALLTYPE *DestroyZoneEnumerator)(
        IInternetZoneManager* This,
        DWORD dwEnum);

    HRESULT (STDMETHODCALLTYPE *CopyTemplatePoliciesToZone)(
        IInternetZoneManager* This,
        DWORD dwTemplate,
        DWORD dwZone,
        DWORD dwReserved);

    END_INTERFACE
} IInternetZoneManagerVtbl;
interface IInternetZoneManager {
    const IInternetZoneManagerVtbl* lpVtbl;
};

#ifdef COBJMACROS
/*** IUnknown methods ***/
#define IInternetZoneManager_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b)
#define IInternetZoneManager_AddRef(p) (p)->lpVtbl->AddRef(p)
#define IInternetZoneManager_Release(p) (p)->lpVtbl->Release(p)
/*** IInternetZoneManager methods ***/
#define IInternetZoneManager_GetZoneAttributes(p,a,b) (p)->lpVtbl->GetZoneAttributes(p,a,b)
#define IInternetZoneManager_SetZoneAttributes(p,a,b) (p)->lpVtbl->SetZoneAttributes(p,a,b)
#define IInternetZoneManager_GetZoneCustomPolicy(p,a,b,c,d,e) (p)->lpVtbl->GetZoneCustomPolicy(p,a,b,c,d,e)
#define IInternetZoneManager_SetZoneCustomPolicy(p,a,b,c,d,e) (p)->lpVtbl->SetZoneCustomPolicy(p,a,b,c,d,e)
#define IInternetZoneManager_GetZoneActionPolicy(p,a,b,c,d,e) (p)->lpVtbl->GetZoneActionPolicy(p,a,b,c,d,e)
#define IInternetZoneManager_SetZoneActionPolicy(p,a,b,c,d,e) (p)->lpVtbl->SetZoneActionPolicy(p,a,b,c,d,e)
#define IInternetZoneManager_PromptAction(p,a,b,c,d,e) (p)->lpVtbl->PromptAction(p,a,b,c,d,e)
#define IInternetZoneManager_LogAction(p,a,b,c,d) (p)->lpVtbl->LogAction(p,a,b,c,d)
#define IInternetZoneManager_CreateZoneEnumerator(p,a,b,c) (p)->lpVtbl->CreateZoneEnumerator(p,a,b,c)
#define IInternetZoneManager_GetZoneAt(p,a,b,c) (p)->lpVtbl->GetZoneAt(p,a,b,c)
#define IInternetZoneManager_DestroyZoneEnumerator(p,a) (p)->lpVtbl->DestroyZoneEnumerator(p,a)
#define IInternetZoneManager_CopyTemplatePoliciesToZone(p,a,b,c) (p)->lpVtbl->CopyTemplatePoliciesToZone(p,a,b,c)
#endif

#endif

HRESULT CALLBACK IInternetZoneManager_GetZoneAttributes_Proxy(
    IInternetZoneManager* This,
    DWORD dwZone,
    ZONEATTRIBUTES* pZoneAttributes);
void __RPC_STUB IInternetZoneManager_GetZoneAttributes_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IInternetZoneManager_SetZoneAttributes_Proxy(
    IInternetZoneManager* This,
    DWORD dwZone,
    ZONEATTRIBUTES* pZoneAttributes);
void __RPC_STUB IInternetZoneManager_SetZoneAttributes_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IInternetZoneManager_GetZoneCustomPolicy_Proxy(
    IInternetZoneManager* This,
    DWORD dwZone,
    REFGUID guidKey,
    BYTE** ppPolicy,
    DWORD* pcbPolicy,
    URLZONEREG ulrZoneReg);
void __RPC_STUB IInternetZoneManager_GetZoneCustomPolicy_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IInternetZoneManager_SetZoneCustomPolicy_Proxy(
    IInternetZoneManager* This,
    DWORD dwZone,
    REFGUID guidKey,
    BYTE* ppPolicy,
    DWORD pcbPolicy,
    URLZONEREG ulrZoneReg);
void __RPC_STUB IInternetZoneManager_SetZoneCustomPolicy_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IInternetZoneManager_GetZoneActionPolicy_Proxy(
    IInternetZoneManager* This,
    DWORD dwZone,
    DWORD dwAction,
    BYTE* pPolicy,
    DWORD cbPolicy,
    URLZONEREG urlZoneReg);
void __RPC_STUB IInternetZoneManager_GetZoneActionPolicy_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IInternetZoneManager_SetZoneActionPolicy_Proxy(
    IInternetZoneManager* This,
    DWORD dwZone,
    DWORD dwAction,
    BYTE* pPolicy,
    DWORD cbPolicy,
    URLZONEREG urlZoneReg);
void __RPC_STUB IInternetZoneManager_SetZoneActionPolicy_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IInternetZoneManager_PromptAction_Proxy(
    IInternetZoneManager* This,
    DWORD dwAction,
    HWND hwndParent,
    LPCWSTR pwszUrl,
    LPCWSTR pwszText,
    DWORD dwPromptFlags);
void __RPC_STUB IInternetZoneManager_PromptAction_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IInternetZoneManager_LogAction_Proxy(
    IInternetZoneManager* This,
    DWORD dwAction,
    LPCWSTR pwszUrl,
    LPCWSTR pwszText,
    DWORD dwLogFlags);
void __RPC_STUB IInternetZoneManager_LogAction_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IInternetZoneManager_CreateZoneEnumerator_Proxy(
    IInternetZoneManager* This,
    DWORD* pdwEnum,
    DWORD* pdwCount,
    DWORD dwFlags);
void __RPC_STUB IInternetZoneManager_CreateZoneEnumerator_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IInternetZoneManager_GetZoneAt_Proxy(
    IInternetZoneManager* This,
    DWORD dwEnum,
    DWORD dwIndex,
    DWORD* pdwZone);
void __RPC_STUB IInternetZoneManager_GetZoneAt_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IInternetZoneManager_DestroyZoneEnumerator_Proxy(
    IInternetZoneManager* This,
    DWORD dwEnum);
void __RPC_STUB IInternetZoneManager_DestroyZoneEnumerator_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IInternetZoneManager_CopyTemplatePoliciesToZone_Proxy(
    IInternetZoneManager* This,
    DWORD dwTemplate,
    DWORD dwZone,
    DWORD dwReserved);
void __RPC_STUB IInternetZoneManager_CopyTemplatePoliciesToZone_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);

#endif  /* __IInternetZoneManager_INTERFACE_DEFINED__ */

typedef struct _tagSOFTDISTINFO {
    ULONG cbSize;
    DWORD dwFlags;
    DWORD dwAdState;
    LPWSTR szTitle;
    LPWSTR szAbstract;
    LPWSTR szHREF;
    DWORD dwInstalledVersionMS;
    DWORD dwInstalledVersionLS;
    DWORD dwUpdateVersionMS;
    DWORD dwUpdateVersionLS;
    DWORD dwAdvertisedVersionMS;
    DWORD dwAdvertisedVersionLS;
    DWORD dwReserved;
} SOFTDISTINFO, *LPSOFTDISTINFO;
typedef struct _tagCODEBASEHOLD {
    DWORD cbSize;
    LPWSTR szDistUnit;
    LPWSTR szCodeBase;
    DWORD dwVersionMS;
    DWORD dwVersionLS;
    DWORD dwStyle;
} CODEBASEHOLD, *LPCODEBASEHOLD;
#ifndef __ISoftDistExt_FWD_DEFINED__
#define __ISoftDistExt_FWD_DEFINED__
typedef interface ISoftDistExt ISoftDistExt;
#endif

/*****************************************************************************
 * ISoftDistExt interface
 */
#ifndef __ISoftDistExt_INTERFACE_DEFINED__
#define __ISoftDistExt_INTERFACE_DEFINED__

DEFINE_GUID(IID_ISoftDistExt, 0xb15b8dc1, 0xc7e1, 0x11d0, 0x86,0x80, 0x00,0xaa,0x00,0xbd,0xcb,0x71);
#if defined(__cplusplus) && !defined(CINTERFACE)
interface ISoftDistExt : public IUnknown
{
    virtual HRESULT STDMETHODCALLTYPE ProcessSoftDist(
        LPCWSTR szCDFURL,
        IXMLElement* pSoftDistElement,
        LPSOFTDISTINFO lpsdi) = 0;

    virtual HRESULT STDMETHODCALLTYPE GetFirstCodeBase(
        LPWSTR* szCodeBase,
        LPDWORD dwMaxSize) = 0;

    virtual HRESULT STDMETHODCALLTYPE GetNextCodeBase(
        LPWSTR* szCodeBase,
        LPDWORD dwMaxSize) = 0;

    virtual HRESULT STDMETHODCALLTYPE AsyncInstallDistributionUnit(
        IBindCtx* pbc,
        LPVOID lpReserved,
        DWORD flags,
        LPCODEBASEHOLD lpcbh) = 0;

};
#else
typedef struct ISoftDistExtVtbl {
    BEGIN_INTERFACE

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

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

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

    /*** ISoftDistExt methods ***/
    HRESULT (STDMETHODCALLTYPE *ProcessSoftDist)(
        ISoftDistExt* This,
        LPCWSTR szCDFURL,
        IXMLElement* pSoftDistElement,
        LPSOFTDISTINFO lpsdi);

    HRESULT (STDMETHODCALLTYPE *GetFirstCodeBase)(
        ISoftDistExt* This,
        LPWSTR* szCodeBase,
        LPDWORD dwMaxSize);

    HRESULT (STDMETHODCALLTYPE *GetNextCodeBase)(
        ISoftDistExt* This,
        LPWSTR* szCodeBase,
        LPDWORD dwMaxSize);

    HRESULT (STDMETHODCALLTYPE *AsyncInstallDistributionUnit)(
        ISoftDistExt* This,
        IBindCtx* pbc,
        LPVOID lpReserved,
        DWORD flags,
        LPCODEBASEHOLD lpcbh);

    END_INTERFACE
} ISoftDistExtVtbl;
interface ISoftDistExt {
    const ISoftDistExtVtbl* lpVtbl;
};

#ifdef COBJMACROS
/*** IUnknown methods ***/
#define ISoftDistExt_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b)
#define ISoftDistExt_AddRef(p) (p)->lpVtbl->AddRef(p)
#define ISoftDistExt_Release(p) (p)->lpVtbl->Release(p)
/*** ISoftDistExt methods ***/
#define ISoftDistExt_ProcessSoftDist(p,a,b,c) (p)->lpVtbl->ProcessSoftDist(p,a,b,c)
#define ISoftDistExt_GetFirstCodeBase(p,a,b) (p)->lpVtbl->GetFirstCodeBase(p,a,b)
#define ISoftDistExt_GetNextCodeBase(p,a,b) (p)->lpVtbl->GetNextCodeBase(p,a,b)
#define ISoftDistExt_AsyncInstallDistributionUnit(p,a,b,c,d) (p)->lpVtbl->AsyncInstallDistributionUnit(p,a,b,c,d)
#endif

#endif

HRESULT CALLBACK ISoftDistExt_ProcessSoftDist_Proxy(
    ISoftDistExt* This,
    LPCWSTR szCDFURL,
    IXMLElement* pSoftDistElement,
    LPSOFTDISTINFO lpsdi);
void __RPC_STUB ISoftDistExt_ProcessSoftDist_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK ISoftDistExt_GetFirstCodeBase_Proxy(
    ISoftDistExt* This,
    LPWSTR* szCodeBase,
    LPDWORD dwMaxSize);
void __RPC_STUB ISoftDistExt_GetFirstCodeBase_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK ISoftDistExt_GetNextCodeBase_Proxy(
    ISoftDistExt* This,
    LPWSTR* szCodeBase,
    LPDWORD dwMaxSize);
void __RPC_STUB ISoftDistExt_GetNextCodeBase_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK ISoftDistExt_AsyncInstallDistributionUnit_Proxy(
    ISoftDistExt* This,
    IBindCtx* pbc,
    LPVOID lpReserved,
    DWORD flags,
    LPCODEBASEHOLD lpcbh);
void __RPC_STUB ISoftDistExt_AsyncInstallDistributionUnit_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);

#endif  /* __ISoftDistExt_INTERFACE_DEFINED__ */

DEFINE_GUID(CLSID_InternetSecurityManager, 0x7b8a2d94, 0x0ac9, 0x11d1, 0x89, 0x6c, 0x00, 0xc0, 0x4f, 0xB6, 0xbf, 0xc4);
DEFINE_GUID(CLSID_InternetZoneManager, 0x7B8A2D95, 0x0AC9, 0x11D1, 0x89, 0x6C, 0x00, 0xC0, 0x4F, 0xB6, 0xBF, 0xC4);
DEFINE_GUID(IID_IAsyncMoniker, 0x79EAC9D3, 0xBAF9, 0x11CE, 0x8C, 0x82, 0x00, 0xAA, 0x00, 0x4B, 0xA9, 0x0B);
DEFINE_GUID(IID_IAsyncBindCtx, 0x79EAC9D4, 0xBAF9, 0x11CE, 0x8C, 0x82, 0x00, 0xAA, 0x00, 0x4B, 0xA9, 0x0B);
DEFINE_GUID(CLSID_StdURLMoniker, 0x79EAC9E0, 0xBAF9, 0x11CE, 0x8C, 0x82, 0x00, 0xAA, 0x00, 0x4B, 0xA9, 0x0B);
DEFINE_GUID(CLSID_CdlProtocol, 0x3dd53d40, 0x7b8b, 0x11D0, 0xb0,0x13, 0x00,0xaa,0x00,0x59,0xce,0x02);
DEFINE_GUID(CLSID_FileProtocol, 0x79EAC9E7, 0xBAF9, 0x11CE, 0x8C,0x82, 0x00,0xAA,0x00,0x4B,0xA9,0x0B);
DEFINE_GUID(CLSID_FtpProtocol, 0x79EAC9E3, 0xBAF9, 0x11CE, 0x8C,0x82, 0x00,0xAA,0x00,0x4B,0xA9,0x0B);
DEFINE_GUID(CLSID_GopherProtocol, 0x79EAC9E4, 0xBAF9, 0x11CE, 0x8C,0x82, 0x00,0xAA,0x00,0x4B,0xA9,0x0B);
DEFINE_GUID(CLSID_HttpProtocol, 0x79EAC9E2, 0xBAF9, 0x11CE, 0x8C,0x82, 0x00,0xAA,0x00,0x4B,0xA9,0x0B);
DEFINE_GUID(CLSID_HttpSProtocol, 0x79EAC9E5, 0xBAF9, 0x11CE, 0x8C,0x82, 0x00,0xAA,0x00,0x4B,0xA9,0x0B);
DEFINE_GUID(CLSID_MkProtocol, 0x79EAC9E6, 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               0x800C0002
#define INET_E_INVALID_URL               0x800C0002
#define INET_E_NO_SESSION                0x800C0003
#define INET_E_CANNOT_CONNECT            0x800C0004
#define INET_E_RESOURCE_NOT_FOUND        0x800C0005
#define INET_E_OBJECT_NOT_FOUND          0x800C0006
#define INET_E_DATA_NOT_AVAILABLE        0x800C0007
#define INET_E_DOWNLOAD_FAILURE          0x800C0008
#define INET_E_AUTHENTICATION_REQUIRED   0x800C0009
#define INET_E_NO_VALID_MEDIA            0x800C000A
#define INET_E_CONNECTION_TIMEOUT        0x800C000B
#define INET_E_INVALID_REQUEST           0x800C000C
#define INET_E_UNKNOWN_PROTOCOL          0x800C000D
#define INET_E_SECURITY_PROBLEM          0x800C000E
#define INET_E_CANNOT_LOAD_DATA          0x800C000F
#define INET_E_CANNOT_INSTANTIATE_OBJECT 0x800C0010
#define INET_E_USE_DEFAULT_PROTOCOLHANDLER 0x800C0011
#define INET_E_QUERYOPTION_UNKNOWN       0x800C0013
#define INET_E_REDIRECT_FAILED           0x800C0014
#define INET_E_REDIRECT_TO_DIR           0x800C0015
#define INET_E_CANNOT_LOCK_REQUEST       0x800C0016
#define INET_E_ERROR_LAST                INET_E_REDIRECT_TO_DIR
#define INET_E_DEFAULT_ACTION            INET_E_USE_DEFAULT_PROTOCOLHANDLER
HRESULT WINAPI CoGetClassObjectFromURL(REFCLSID, LPCWSTR, DWORD, DWORD, LPCWSTR, LPBINDCTX, DWORD, LPVOID, REFIID, LPVOID*);
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,LPCSTR,LPCSTR,DWORD,LPBINDSTATUSCALLBACK);
HRESULT WINAPI URLDownloadToFileW(LPUNKNOWN,LPCWSTR,LPCWSTR,DWORD,LPBINDSTATUSCALLBACK);
HRESULT WINAPI URLDownloadToCacheFileA(LPUNKNOWN,LPCSTR,LPSTR,DWORD,DWORD,LPBINDSTATUSCALLBACK);
HRESULT WINAPI URLDownloadToCacheFileW(LPUNKNOWN,LPCWSTR,LPWSTR,DWORD,DWORD,LPBINDSTATUSCALLBACK);
HRESULT WINAPI CoInternetGetSession(DWORD,IInternetSession**,DWORD);
HRESULT WINAPI MkParseDisplayNameEx(IBindCtx*,LPCWSTR,ULONG*,IMoniker**);
HRESULT WINAPI IsAsyncMoniker(IMoniker* pmk);
HRESULT WINAPI CreateAsyncBindCtx(DWORD, IBindStatusCallback*, IEnumFORMATETC*, IBindCtx**);
HRESULT WINAPI CreateAsyncBindCtxEx(IBindCtx*,DWORD,IBindStatusCallback*,IEnumFORMATETC*,IBindCtx**,DWORD);
HRESULT WINAPI CoInternetCreateSecurityManager(IServiceProvider*,IInternetSecurityManager**,DWORD);
HRESULT WINAPI CoInternetCombineUrl(LPCWSTR,LPCWSTR,DWORD,LPWSTR,DWORD,DWORD*,DWORD);
HRESULT WINAPI CoInternetCompareUrl(LPCWSTR,LPCWSTR,DWORD);
HRESULT WINAPI CoInternetCreateZoneManager(IServiceProvider*, IInternetZoneManager**, DWORD);
HRESULT WINAPI CoInternetParseUrl(LPCWSTR,PARSEACTION,DWORD,LPWSTR,DWORD,DWORD*,DWORD);
HRESULT WINAPI CoInternetQueryInfo(LPCWSTR,QUERYOPTION,DWORD,LPVOID,DWORD,DWORD*,DWORD);
HRESULT WINAPI CreateFormatEnumerator(UINT,FORMATETC*,IEnumFORMATETC**);
HRESULT WINAPI GetSoftwareUpdateInfo( LPCWSTR szDistUnit, LPSOFTDISTINFO psdi);
HRESULT WINAPI FaultInIEFeature(HWND,uCLSSPEC*,QUERYCONTEXT*,DWORD);
HRESULT WINAPI FindMimeFromData(LPBC,LPCWSTR,LPVOID,DWORD,LPCWSTR,DWORD,LPWSTR*,DWORD);
HRESULT WINAPI HlinkGoBack(IUnknown*);
HRESULT WINAPI HlinkGoForward(IUnknown*);
HRESULT WINAPI HlinkNavigateMoniker(IUnknown*,IMoniker*);
HRESULT WINAPI HlinkNavigateString(IUnknown*,LPCWSTR);
HRESULT WINAPI HlinkSimpleNavigateToMoniker(IMoniker*,LPCWSTR,LPCWSTR,IUnknown*,IBindCtx*,IBindStatusCallback*,DWORD,DWORD);
HRESULT WINAPI HlinkSimpleNavigateToString(LPCWSTR,LPCWSTR,LPCWSTR,IUnknown*,IBindCtx*,IBindStatusCallback*,DWORD,DWORD);
HRESULT WINAPI IsValidURL(LPBC,LPCWSTR,DWORD);
HRESULT WINAPI ObtainUserAgentString(DWORD,LPSTR,DWORD*);
HRESULT WINAPI RegisterFormatEnumerator(LPBC,IEnumFORMATETC*,DWORD);
HRESULT WINAPI RevokeFormatEnumerator(LPBC,IEnumFORMATETC*);
HRESULT WINAPI RevokeBindStatusCallback(LPBC,IBindStatusCallback*);
void WINAPI ReleaseBindInfo(BINDINFO*);
HRESULT WINAPI UrlMkGetSessionOption(DWORD,LPVOID,DWORD,DWORD*,DWORD);
HRESULT WINAPI UrlMkSetSessionOption(DWORD,LPVOID,DWORD,DWORD);
#define OInetCombineUrl CoInternetCombineUrl
#define OInetCompareUrl CoInternetCompareUrl
#define OInetGetSession CoInternetGetSession
#define MKSYS_URLMONIKER 6
/* Begin additional prototypes for all interfaces */

unsigned long   __RPC_USER STGMEDIUM_UserSize     (unsigned long *, unsigned long,   STGMEDIUM *);
unsigned char * __RPC_USER STGMEDIUM_UserMarshal  (unsigned long *, unsigned char *, STGMEDIUM *);
unsigned char * __RPC_USER STGMEDIUM_UserUnmarshal(unsigned long *, unsigned char *, STGMEDIUM *);
void            __RPC_USER STGMEDIUM_UserFree     (unsigned long *, STGMEDIUM *);
unsigned long   __RPC_USER HWND_UserSize     (unsigned long *, unsigned long,   HWND *);
unsigned char * __RPC_USER HWND_UserMarshal  (unsigned long *, unsigned char *, HWND *);
unsigned char * __RPC_USER HWND_UserUnmarshal(unsigned long *, unsigned char *, HWND *);
void            __RPC_USER HWND_UserFree     (unsigned long *, HWND *);

/* End additional prototypes */

#ifdef __cplusplus
}
#endif
#endif /* __WIDL_URLMON_H */
