// **********************************************************************
//
// Copyright (c) 2003-2009 ZeroC, Inc. All rights reserved.
//
// This copy of Ice is licensed to you under the terms described in the
// ICE_LICENSE file included in this distribution.
//
// **********************************************************************

// Ice version 3.3.1
// Generated from file `ehr.ice'

#ifndef __ehr_h__
#define __ehr_h__

#include <Ice/LocalObjectF.h>
#include <Ice/ProxyF.h>
#include <Ice/ObjectF.h>
#include <Ice/Exception.h>
#include <Ice/LocalObject.h>
#include <Ice/Proxy.h>
#include <Ice/Object.h>
#include <Ice/Outgoing.h>
#include <Ice/Incoming.h>
#include <Ice/Direct.h>
#include <Ice/UserExceptionFactory.h>
#include <Ice/FactoryTable.h>
#include <Ice/StreamF.h>
#include <Ice/UndefSysMacros.h>

#ifndef ICE_IGNORE_VERSION
#   if ICE_INT_VERSION / 100 != 303
#       error Ice version mismatch!
#   endif
#   if ICE_INT_VERSION % 100 > 50
#       error Beta header file detected
#   endif
#   if ICE_INT_VERSION % 100 < 1
#       error Ice patch level mismatch!
#   endif
#endif

namespace IceProxy
{

namespace Ehr
{

class Document;

class Prescription;

class ConsumedPrescription;

class Request;

class ThirdPartyRequest;

class CreatePrescriptionRequest;

class ConsumePrescriptionRequest;

class ListDocumentsRequest;

class FindDocumentsRequest;

class CreatePermissionRequest;

class SetDefaultAccessRequest;

class ListPermissionsRequest;

class RemovePermissionRequest;

class Provider;

}

}

namespace Ehr
{

class Document;
bool operator==(const Document&, const Document&);
bool operator<(const Document&, const Document&);

class Prescription;
bool operator==(const Prescription&, const Prescription&);
bool operator<(const Prescription&, const Prescription&);

class ConsumedPrescription;
bool operator==(const ConsumedPrescription&, const ConsumedPrescription&);
bool operator<(const ConsumedPrescription&, const ConsumedPrescription&);

class Request;
bool operator==(const Request&, const Request&);
bool operator<(const Request&, const Request&);

class ThirdPartyRequest;
bool operator==(const ThirdPartyRequest&, const ThirdPartyRequest&);
bool operator<(const ThirdPartyRequest&, const ThirdPartyRequest&);

class CreatePrescriptionRequest;
bool operator==(const CreatePrescriptionRequest&, const CreatePrescriptionRequest&);
bool operator<(const CreatePrescriptionRequest&, const CreatePrescriptionRequest&);

class ConsumePrescriptionRequest;
bool operator==(const ConsumePrescriptionRequest&, const ConsumePrescriptionRequest&);
bool operator<(const ConsumePrescriptionRequest&, const ConsumePrescriptionRequest&);

class ListDocumentsRequest;
bool operator==(const ListDocumentsRequest&, const ListDocumentsRequest&);
bool operator<(const ListDocumentsRequest&, const ListDocumentsRequest&);

class FindDocumentsRequest;
bool operator==(const FindDocumentsRequest&, const FindDocumentsRequest&);
bool operator<(const FindDocumentsRequest&, const FindDocumentsRequest&);

class CreatePermissionRequest;
bool operator==(const CreatePermissionRequest&, const CreatePermissionRequest&);
bool operator<(const CreatePermissionRequest&, const CreatePermissionRequest&);

class SetDefaultAccessRequest;
bool operator==(const SetDefaultAccessRequest&, const SetDefaultAccessRequest&);
bool operator<(const SetDefaultAccessRequest&, const SetDefaultAccessRequest&);

class ListPermissionsRequest;
bool operator==(const ListPermissionsRequest&, const ListPermissionsRequest&);
bool operator<(const ListPermissionsRequest&, const ListPermissionsRequest&);

class RemovePermissionRequest;
bool operator==(const RemovePermissionRequest&, const RemovePermissionRequest&);
bool operator<(const RemovePermissionRequest&, const RemovePermissionRequest&);

class Provider;
bool operator==(const Provider&, const Provider&);
bool operator<(const Provider&, const Provider&);

}

namespace IceInternal
{

::Ice::Object* upCast(::Ehr::Document*);
::IceProxy::Ice::Object* upCast(::IceProxy::Ehr::Document*);

::Ice::Object* upCast(::Ehr::Prescription*);
::IceProxy::Ice::Object* upCast(::IceProxy::Ehr::Prescription*);

::Ice::Object* upCast(::Ehr::ConsumedPrescription*);
::IceProxy::Ice::Object* upCast(::IceProxy::Ehr::ConsumedPrescription*);

::Ice::Object* upCast(::Ehr::Request*);
::IceProxy::Ice::Object* upCast(::IceProxy::Ehr::Request*);

::Ice::Object* upCast(::Ehr::ThirdPartyRequest*);
::IceProxy::Ice::Object* upCast(::IceProxy::Ehr::ThirdPartyRequest*);

::Ice::Object* upCast(::Ehr::CreatePrescriptionRequest*);
::IceProxy::Ice::Object* upCast(::IceProxy::Ehr::CreatePrescriptionRequest*);

::Ice::Object* upCast(::Ehr::ConsumePrescriptionRequest*);
::IceProxy::Ice::Object* upCast(::IceProxy::Ehr::ConsumePrescriptionRequest*);

::Ice::Object* upCast(::Ehr::ListDocumentsRequest*);
::IceProxy::Ice::Object* upCast(::IceProxy::Ehr::ListDocumentsRequest*);

::Ice::Object* upCast(::Ehr::FindDocumentsRequest*);
::IceProxy::Ice::Object* upCast(::IceProxy::Ehr::FindDocumentsRequest*);

::Ice::Object* upCast(::Ehr::CreatePermissionRequest*);
::IceProxy::Ice::Object* upCast(::IceProxy::Ehr::CreatePermissionRequest*);

::Ice::Object* upCast(::Ehr::SetDefaultAccessRequest*);
::IceProxy::Ice::Object* upCast(::IceProxy::Ehr::SetDefaultAccessRequest*);

::Ice::Object* upCast(::Ehr::ListPermissionsRequest*);
::IceProxy::Ice::Object* upCast(::IceProxy::Ehr::ListPermissionsRequest*);

::Ice::Object* upCast(::Ehr::RemovePermissionRequest*);
::IceProxy::Ice::Object* upCast(::IceProxy::Ehr::RemovePermissionRequest*);

::Ice::Object* upCast(::Ehr::Provider*);
::IceProxy::Ice::Object* upCast(::IceProxy::Ehr::Provider*);

}

namespace Ehr
{

typedef ::IceInternal::Handle< ::Ehr::Document> DocumentPtr;
typedef ::IceInternal::ProxyHandle< ::IceProxy::Ehr::Document> DocumentPrx;

void __read(::IceInternal::BasicStream*, DocumentPrx&);
void __patch__DocumentPtr(void*, ::Ice::ObjectPtr&);

void ice_writeDocumentPrx(const ::Ice::OutputStreamPtr&, const DocumentPrx&);
void ice_readDocumentPrx(const ::Ice::InputStreamPtr&, DocumentPrx&);
void ice_writeDocument(const ::Ice::OutputStreamPtr&, const DocumentPtr&);
void ice_readDocument(const ::Ice::InputStreamPtr&, DocumentPtr&);

typedef ::IceInternal::Handle< ::Ehr::Prescription> PrescriptionPtr;
typedef ::IceInternal::ProxyHandle< ::IceProxy::Ehr::Prescription> PrescriptionPrx;

void __read(::IceInternal::BasicStream*, PrescriptionPrx&);
void __patch__PrescriptionPtr(void*, ::Ice::ObjectPtr&);

void ice_writePrescriptionPrx(const ::Ice::OutputStreamPtr&, const PrescriptionPrx&);
void ice_readPrescriptionPrx(const ::Ice::InputStreamPtr&, PrescriptionPrx&);
void ice_writePrescription(const ::Ice::OutputStreamPtr&, const PrescriptionPtr&);
void ice_readPrescription(const ::Ice::InputStreamPtr&, PrescriptionPtr&);

typedef ::IceInternal::Handle< ::Ehr::ConsumedPrescription> ConsumedPrescriptionPtr;
typedef ::IceInternal::ProxyHandle< ::IceProxy::Ehr::ConsumedPrescription> ConsumedPrescriptionPrx;

void __read(::IceInternal::BasicStream*, ConsumedPrescriptionPrx&);
void __patch__ConsumedPrescriptionPtr(void*, ::Ice::ObjectPtr&);

void ice_writeConsumedPrescriptionPrx(const ::Ice::OutputStreamPtr&, const ConsumedPrescriptionPrx&);
void ice_readConsumedPrescriptionPrx(const ::Ice::InputStreamPtr&, ConsumedPrescriptionPrx&);
void ice_writeConsumedPrescription(const ::Ice::OutputStreamPtr&, const ConsumedPrescriptionPtr&);
void ice_readConsumedPrescription(const ::Ice::InputStreamPtr&, ConsumedPrescriptionPtr&);

typedef ::IceInternal::Handle< ::Ehr::Request> RequestPtr;
typedef ::IceInternal::ProxyHandle< ::IceProxy::Ehr::Request> RequestPrx;

void __read(::IceInternal::BasicStream*, RequestPrx&);
void __patch__RequestPtr(void*, ::Ice::ObjectPtr&);

void ice_writeRequestPrx(const ::Ice::OutputStreamPtr&, const RequestPrx&);
void ice_readRequestPrx(const ::Ice::InputStreamPtr&, RequestPrx&);
void ice_writeRequest(const ::Ice::OutputStreamPtr&, const RequestPtr&);
void ice_readRequest(const ::Ice::InputStreamPtr&, RequestPtr&);

typedef ::IceInternal::Handle< ::Ehr::ThirdPartyRequest> ThirdPartyRequestPtr;
typedef ::IceInternal::ProxyHandle< ::IceProxy::Ehr::ThirdPartyRequest> ThirdPartyRequestPrx;

void __read(::IceInternal::BasicStream*, ThirdPartyRequestPrx&);
void __patch__ThirdPartyRequestPtr(void*, ::Ice::ObjectPtr&);

void ice_writeThirdPartyRequestPrx(const ::Ice::OutputStreamPtr&, const ThirdPartyRequestPrx&);
void ice_readThirdPartyRequestPrx(const ::Ice::InputStreamPtr&, ThirdPartyRequestPrx&);
void ice_writeThirdPartyRequest(const ::Ice::OutputStreamPtr&, const ThirdPartyRequestPtr&);
void ice_readThirdPartyRequest(const ::Ice::InputStreamPtr&, ThirdPartyRequestPtr&);

typedef ::IceInternal::Handle< ::Ehr::CreatePrescriptionRequest> CreatePrescriptionRequestPtr;
typedef ::IceInternal::ProxyHandle< ::IceProxy::Ehr::CreatePrescriptionRequest> CreatePrescriptionRequestPrx;

void __read(::IceInternal::BasicStream*, CreatePrescriptionRequestPrx&);
void __patch__CreatePrescriptionRequestPtr(void*, ::Ice::ObjectPtr&);

void ice_writeCreatePrescriptionRequestPrx(const ::Ice::OutputStreamPtr&, const CreatePrescriptionRequestPrx&);
void ice_readCreatePrescriptionRequestPrx(const ::Ice::InputStreamPtr&, CreatePrescriptionRequestPrx&);
void ice_writeCreatePrescriptionRequest(const ::Ice::OutputStreamPtr&, const CreatePrescriptionRequestPtr&);
void ice_readCreatePrescriptionRequest(const ::Ice::InputStreamPtr&, CreatePrescriptionRequestPtr&);

typedef ::IceInternal::Handle< ::Ehr::ConsumePrescriptionRequest> ConsumePrescriptionRequestPtr;
typedef ::IceInternal::ProxyHandle< ::IceProxy::Ehr::ConsumePrescriptionRequest> ConsumePrescriptionRequestPrx;

void __read(::IceInternal::BasicStream*, ConsumePrescriptionRequestPrx&);
void __patch__ConsumePrescriptionRequestPtr(void*, ::Ice::ObjectPtr&);

void ice_writeConsumePrescriptionRequestPrx(const ::Ice::OutputStreamPtr&, const ConsumePrescriptionRequestPrx&);
void ice_readConsumePrescriptionRequestPrx(const ::Ice::InputStreamPtr&, ConsumePrescriptionRequestPrx&);
void ice_writeConsumePrescriptionRequest(const ::Ice::OutputStreamPtr&, const ConsumePrescriptionRequestPtr&);
void ice_readConsumePrescriptionRequest(const ::Ice::InputStreamPtr&, ConsumePrescriptionRequestPtr&);

typedef ::IceInternal::Handle< ::Ehr::ListDocumentsRequest> ListDocumentsRequestPtr;
typedef ::IceInternal::ProxyHandle< ::IceProxy::Ehr::ListDocumentsRequest> ListDocumentsRequestPrx;

void __read(::IceInternal::BasicStream*, ListDocumentsRequestPrx&);
void __patch__ListDocumentsRequestPtr(void*, ::Ice::ObjectPtr&);

void ice_writeListDocumentsRequestPrx(const ::Ice::OutputStreamPtr&, const ListDocumentsRequestPrx&);
void ice_readListDocumentsRequestPrx(const ::Ice::InputStreamPtr&, ListDocumentsRequestPrx&);
void ice_writeListDocumentsRequest(const ::Ice::OutputStreamPtr&, const ListDocumentsRequestPtr&);
void ice_readListDocumentsRequest(const ::Ice::InputStreamPtr&, ListDocumentsRequestPtr&);

typedef ::IceInternal::Handle< ::Ehr::FindDocumentsRequest> FindDocumentsRequestPtr;
typedef ::IceInternal::ProxyHandle< ::IceProxy::Ehr::FindDocumentsRequest> FindDocumentsRequestPrx;

void __read(::IceInternal::BasicStream*, FindDocumentsRequestPrx&);
void __patch__FindDocumentsRequestPtr(void*, ::Ice::ObjectPtr&);

void ice_writeFindDocumentsRequestPrx(const ::Ice::OutputStreamPtr&, const FindDocumentsRequestPrx&);
void ice_readFindDocumentsRequestPrx(const ::Ice::InputStreamPtr&, FindDocumentsRequestPrx&);
void ice_writeFindDocumentsRequest(const ::Ice::OutputStreamPtr&, const FindDocumentsRequestPtr&);
void ice_readFindDocumentsRequest(const ::Ice::InputStreamPtr&, FindDocumentsRequestPtr&);

typedef ::IceInternal::Handle< ::Ehr::CreatePermissionRequest> CreatePermissionRequestPtr;
typedef ::IceInternal::ProxyHandle< ::IceProxy::Ehr::CreatePermissionRequest> CreatePermissionRequestPrx;

void __read(::IceInternal::BasicStream*, CreatePermissionRequestPrx&);
void __patch__CreatePermissionRequestPtr(void*, ::Ice::ObjectPtr&);

void ice_writeCreatePermissionRequestPrx(const ::Ice::OutputStreamPtr&, const CreatePermissionRequestPrx&);
void ice_readCreatePermissionRequestPrx(const ::Ice::InputStreamPtr&, CreatePermissionRequestPrx&);
void ice_writeCreatePermissionRequest(const ::Ice::OutputStreamPtr&, const CreatePermissionRequestPtr&);
void ice_readCreatePermissionRequest(const ::Ice::InputStreamPtr&, CreatePermissionRequestPtr&);

typedef ::IceInternal::Handle< ::Ehr::SetDefaultAccessRequest> SetDefaultAccessRequestPtr;
typedef ::IceInternal::ProxyHandle< ::IceProxy::Ehr::SetDefaultAccessRequest> SetDefaultAccessRequestPrx;

void __read(::IceInternal::BasicStream*, SetDefaultAccessRequestPrx&);
void __patch__SetDefaultAccessRequestPtr(void*, ::Ice::ObjectPtr&);

void ice_writeSetDefaultAccessRequestPrx(const ::Ice::OutputStreamPtr&, const SetDefaultAccessRequestPrx&);
void ice_readSetDefaultAccessRequestPrx(const ::Ice::InputStreamPtr&, SetDefaultAccessRequestPrx&);
void ice_writeSetDefaultAccessRequest(const ::Ice::OutputStreamPtr&, const SetDefaultAccessRequestPtr&);
void ice_readSetDefaultAccessRequest(const ::Ice::InputStreamPtr&, SetDefaultAccessRequestPtr&);

typedef ::IceInternal::Handle< ::Ehr::ListPermissionsRequest> ListPermissionsRequestPtr;
typedef ::IceInternal::ProxyHandle< ::IceProxy::Ehr::ListPermissionsRequest> ListPermissionsRequestPrx;

void __read(::IceInternal::BasicStream*, ListPermissionsRequestPrx&);
void __patch__ListPermissionsRequestPtr(void*, ::Ice::ObjectPtr&);

void ice_writeListPermissionsRequestPrx(const ::Ice::OutputStreamPtr&, const ListPermissionsRequestPrx&);
void ice_readListPermissionsRequestPrx(const ::Ice::InputStreamPtr&, ListPermissionsRequestPrx&);
void ice_writeListPermissionsRequest(const ::Ice::OutputStreamPtr&, const ListPermissionsRequestPtr&);
void ice_readListPermissionsRequest(const ::Ice::InputStreamPtr&, ListPermissionsRequestPtr&);

typedef ::IceInternal::Handle< ::Ehr::RemovePermissionRequest> RemovePermissionRequestPtr;
typedef ::IceInternal::ProxyHandle< ::IceProxy::Ehr::RemovePermissionRequest> RemovePermissionRequestPrx;

void __read(::IceInternal::BasicStream*, RemovePermissionRequestPrx&);
void __patch__RemovePermissionRequestPtr(void*, ::Ice::ObjectPtr&);

void ice_writeRemovePermissionRequestPrx(const ::Ice::OutputStreamPtr&, const RemovePermissionRequestPrx&);
void ice_readRemovePermissionRequestPrx(const ::Ice::InputStreamPtr&, RemovePermissionRequestPrx&);
void ice_writeRemovePermissionRequest(const ::Ice::OutputStreamPtr&, const RemovePermissionRequestPtr&);
void ice_readRemovePermissionRequest(const ::Ice::InputStreamPtr&, RemovePermissionRequestPtr&);

typedef ::IceInternal::Handle< ::Ehr::Provider> ProviderPtr;
typedef ::IceInternal::ProxyHandle< ::IceProxy::Ehr::Provider> ProviderPrx;

void __read(::IceInternal::BasicStream*, ProviderPrx&);
void __patch__ProviderPtr(void*, ::Ice::ObjectPtr&);

void ice_writeProviderPrx(const ::Ice::OutputStreamPtr&, const ProviderPrx&);
void ice_readProviderPrx(const ::Ice::InputStreamPtr&, ProviderPrx&);
void ice_writeProvider(const ::Ice::OutputStreamPtr&, const ProviderPtr&);
void ice_readProvider(const ::Ice::InputStreamPtr&, ProviderPtr&);

}

namespace Ehr
{

typedef ::std::vector< ::Ice::Byte> ByteSeq;

class EhrException : public ::Ice::UserException
{
public:

    EhrException() {}
    explicit EhrException(const ::std::string&);
    virtual ~EhrException() throw();

    virtual ::std::string ice_name() const;
    virtual ::Ice::Exception* ice_clone() const;
    virtual void ice_throw() const;

    static const ::IceInternal::UserExceptionFactoryPtr& ice_factory();

    ::std::string what;

    virtual void __write(::IceInternal::BasicStream*) const;
    virtual void __read(::IceInternal::BasicStream*, bool);
    virtual void __write(const ::Ice::OutputStreamPtr&) const;
    virtual void __read(const ::Ice::InputStreamPtr&, bool);
};

static EhrException __EhrException_init;

class InvalidRequestException : public ::Ehr::EhrException
{
public:

    InvalidRequestException() {}
    explicit InvalidRequestException(const ::std::string&);
    virtual ~InvalidRequestException() throw();

    virtual ::std::string ice_name() const;
    virtual ::Ice::Exception* ice_clone() const;
    virtual void ice_throw() const;

    static const ::IceInternal::UserExceptionFactoryPtr& ice_factory();

    virtual void __write(::IceInternal::BasicStream*) const;
    virtual void __read(::IceInternal::BasicStream*, bool);
    virtual void __write(const ::Ice::OutputStreamPtr&) const;
    virtual void __read(const ::Ice::InputStreamPtr&, bool);
};

class InvalidAccountException : public ::Ehr::InvalidRequestException
{
public:

    InvalidAccountException() {}
    explicit InvalidAccountException(const ::std::string&);
    virtual ~InvalidAccountException() throw();

    virtual ::std::string ice_name() const;
    virtual ::Ice::Exception* ice_clone() const;
    virtual void ice_throw() const;

    static const ::IceInternal::UserExceptionFactoryPtr& ice_factory();

    virtual void __write(::IceInternal::BasicStream*) const;
    virtual void __read(::IceInternal::BasicStream*, bool);
    virtual void __write(const ::Ice::OutputStreamPtr&) const;
    virtual void __read(const ::Ice::InputStreamPtr&, bool);
};

class SignatureException : public ::Ehr::EhrException
{
public:

    SignatureException() {}
    explicit SignatureException(const ::std::string&);
    virtual ~SignatureException() throw();

    virtual ::std::string ice_name() const;
    virtual ::Ice::Exception* ice_clone() const;
    virtual void ice_throw() const;

    static const ::IceInternal::UserExceptionFactoryPtr& ice_factory();

    virtual void __write(::IceInternal::BasicStream*) const;
    virtual void __read(::IceInternal::BasicStream*, bool);
    virtual void __write(const ::Ice::OutputStreamPtr&) const;
    virtual void __read(const ::Ice::InputStreamPtr&, bool);
};

class PermissionDeniedException : public ::Ehr::EhrException
{
public:

    PermissionDeniedException() {}
    explicit PermissionDeniedException(const ::std::string&);
    virtual ~PermissionDeniedException() throw();

    virtual ::std::string ice_name() const;
    virtual ::Ice::Exception* ice_clone() const;
    virtual void ice_throw() const;

    static const ::IceInternal::UserExceptionFactoryPtr& ice_factory();

    virtual void __write(::IceInternal::BasicStream*) const;
    virtual void __read(::IceInternal::BasicStream*, bool);
    virtual void __write(const ::Ice::OutputStreamPtr&) const;
    virtual void __read(const ::Ice::InputStreamPtr&, bool);
};

struct AccountIdentifier
{
    ::std::string user;
    ::std::string provider;

    bool operator==(const AccountIdentifier&) const;
    bool operator<(const AccountIdentifier&) const;
    bool operator!=(const AccountIdentifier& __rhs) const
    {
        return !operator==(__rhs);
    }
    bool operator<=(const AccountIdentifier& __rhs) const
    {
        return operator<(__rhs) || operator==(__rhs);
    }
    bool operator>(const AccountIdentifier& __rhs) const
    {
        return !operator<(__rhs) && !operator==(__rhs);
    }
    bool operator>=(const AccountIdentifier& __rhs) const
    {
        return !operator<(__rhs);
    }

    void __write(::IceInternal::BasicStream*) const;
    void __read(::IceInternal::BasicStream*);

    void ice_write(const ::Ice::OutputStreamPtr&) const;
    void ice_read(const ::Ice::InputStreamPtr&);
};

void ice_writeAccountIdentifier(const ::Ice::OutputStreamPtr&, const AccountIdentifier&);
void ice_readAccountIdentifier(const ::Ice::InputStreamPtr&, AccountIdentifier&);

enum DocumentType
{
    DOCANY,
    DOCPRESCRIPTION,
    DOCCONSUMEDPRESCRIPTION
};

void __write(::IceInternal::BasicStream*, DocumentType);
void __read(::IceInternal::BasicStream*, DocumentType&);

void ice_writeDocumentType(const ::Ice::OutputStreamPtr&, DocumentType);
void ice_readDocumentType(const ::Ice::InputStreamPtr&, DocumentType&);

struct Signature
{
    ::Ehr::ByteSeq data;

    bool operator==(const Signature&) const;
    bool operator<(const Signature&) const;
    bool operator!=(const Signature& __rhs) const
    {
        return !operator==(__rhs);
    }
    bool operator<=(const Signature& __rhs) const
    {
        return operator<(__rhs) || operator==(__rhs);
    }
    bool operator>(const Signature& __rhs) const
    {
        return !operator<(__rhs) && !operator==(__rhs);
    }
    bool operator>=(const Signature& __rhs) const
    {
        return !operator<(__rhs);
    }

    void __write(::IceInternal::BasicStream*) const;
    void __read(::IceInternal::BasicStream*);

    void ice_write(const ::Ice::OutputStreamPtr&) const;
    void ice_read(const ::Ice::InputStreamPtr&);
};

void ice_writeSignature(const ::Ice::OutputStreamPtr&, const Signature&);
void ice_readSignature(const ::Ice::InputStreamPtr&, Signature&);

struct Timestamp
{
    ::Ice::Long msecs;

    bool operator==(const Timestamp&) const;
    bool operator<(const Timestamp&) const;
    bool operator!=(const Timestamp& __rhs) const
    {
        return !operator==(__rhs);
    }
    bool operator<=(const Timestamp& __rhs) const
    {
        return operator<(__rhs) || operator==(__rhs);
    }
    bool operator>(const Timestamp& __rhs) const
    {
        return !operator<(__rhs) && !operator==(__rhs);
    }
    bool operator>=(const Timestamp& __rhs) const
    {
        return !operator<(__rhs);
    }

    void __write(::IceInternal::BasicStream*) const;
    void __read(::IceInternal::BasicStream*);

    void ice_write(const ::Ice::OutputStreamPtr&) const;
    void ice_read(const ::Ice::InputStreamPtr&);
};

void ice_writeTimestamp(const ::Ice::OutputStreamPtr&, const Timestamp&);
void ice_readTimestamp(const ::Ice::InputStreamPtr&, Timestamp&);

struct Date
{
    ::Ice::Byte day;
    ::Ice::Byte month;
    ::Ice::Short year;

    bool operator==(const Date&) const;
    bool operator<(const Date&) const;
    bool operator!=(const Date& __rhs) const
    {
        return !operator==(__rhs);
    }
    bool operator<=(const Date& __rhs) const
    {
        return operator<(__rhs) || operator==(__rhs);
    }
    bool operator>(const Date& __rhs) const
    {
        return !operator<(__rhs) && !operator==(__rhs);
    }
    bool operator>=(const Date& __rhs) const
    {
        return !operator<(__rhs);
    }

    void __write(::IceInternal::BasicStream*) const;
    void __read(::IceInternal::BasicStream*);

    void ice_write(const ::Ice::OutputStreamPtr&) const;
    void ice_read(const ::Ice::InputStreamPtr&);
};

void ice_writeDate(const ::Ice::OutputStreamPtr&, const Date&);
void ice_readDate(const ::Ice::InputStreamPtr&, Date&);

enum AccessType
{
    ALLOW,
    DENY
};

void __write(::IceInternal::BasicStream*, AccessType);
void __read(::IceInternal::BasicStream*, AccessType&);

void ice_writeAccessType(const ::Ice::OutputStreamPtr&, AccessType);
void ice_readAccessType(const ::Ice::InputStreamPtr&, AccessType&);

struct EncryptedDocument
{
    ::Ehr::ByteSeq encryptedKey;
    ::Ehr::ByteSeq initialVector;
    ::Ehr::ByteSeq encryptedData;

    bool operator==(const EncryptedDocument&) const;
    bool operator<(const EncryptedDocument&) const;
    bool operator!=(const EncryptedDocument& __rhs) const
    {
        return !operator==(__rhs);
    }
    bool operator<=(const EncryptedDocument& __rhs) const
    {
        return operator<(__rhs) || operator==(__rhs);
    }
    bool operator>(const EncryptedDocument& __rhs) const
    {
        return !operator<(__rhs) && !operator==(__rhs);
    }
    bool operator>=(const EncryptedDocument& __rhs) const
    {
        return !operator<(__rhs);
    }

    void __write(::IceInternal::BasicStream*) const;
    void __read(::IceInternal::BasicStream*);

    void ice_write(const ::Ice::OutputStreamPtr&) const;
    void ice_read(const ::Ice::InputStreamPtr&);
};

void ice_writeEncryptedDocument(const ::Ice::OutputStreamPtr&, const EncryptedDocument&);
void ice_readEncryptedDocument(const ::Ice::InputStreamPtr&, EncryptedDocument&);

struct DocumentListItem
{
    ::Ice::Long id;
    ::Ehr::Timestamp created;
    ::Ehr::EncryptedDocument document;

    bool operator==(const DocumentListItem&) const;
    bool operator<(const DocumentListItem&) const;
    bool operator!=(const DocumentListItem& __rhs) const
    {
        return !operator==(__rhs);
    }
    bool operator<=(const DocumentListItem& __rhs) const
    {
        return operator<(__rhs) || operator==(__rhs);
    }
    bool operator>(const DocumentListItem& __rhs) const
    {
        return !operator<(__rhs) && !operator==(__rhs);
    }
    bool operator>=(const DocumentListItem& __rhs) const
    {
        return !operator<(__rhs);
    }

    void __write(::IceInternal::BasicStream*) const;
    void __read(::IceInternal::BasicStream*);

    void ice_write(const ::Ice::OutputStreamPtr&) const;
    void ice_read(const ::Ice::InputStreamPtr&);
};

void ice_writeDocumentListItem(const ::Ice::OutputStreamPtr&, const DocumentListItem&);
void ice_readDocumentListItem(const ::Ice::InputStreamPtr&, DocumentListItem&);

typedef ::std::vector< ::Ehr::DocumentListItem> DocumentList;
void __writeDocumentList(::IceInternal::BasicStream*, const ::Ehr::DocumentListItem*, const ::Ehr::DocumentListItem*);
void __readDocumentList(::IceInternal::BasicStream*, DocumentList&);
void ice_writeDocumentList(const ::Ice::OutputStreamPtr&, const DocumentList&);
void ice_readDocumentList(const ::Ice::InputStreamPtr&, DocumentList&);

struct AccessControlListItem
{
    ::Ice::Long id;
    ::Ehr::AccountIdentifier account;
    ::Ehr::AccessType access;

    bool operator==(const AccessControlListItem&) const;
    bool operator<(const AccessControlListItem&) const;
    bool operator!=(const AccessControlListItem& __rhs) const
    {
        return !operator==(__rhs);
    }
    bool operator<=(const AccessControlListItem& __rhs) const
    {
        return operator<(__rhs) || operator==(__rhs);
    }
    bool operator>(const AccessControlListItem& __rhs) const
    {
        return !operator<(__rhs) && !operator==(__rhs);
    }
    bool operator>=(const AccessControlListItem& __rhs) const
    {
        return !operator<(__rhs);
    }

    void __write(::IceInternal::BasicStream*) const;
    void __read(::IceInternal::BasicStream*);

    void ice_write(const ::Ice::OutputStreamPtr&) const;
    void ice_read(const ::Ice::InputStreamPtr&);
};

void ice_writeAccessControlListItem(const ::Ice::OutputStreamPtr&, const AccessControlListItem&);
void ice_readAccessControlListItem(const ::Ice::InputStreamPtr&, AccessControlListItem&);

typedef ::std::vector< ::Ehr::AccessControlListItem> AccessControlList;
void __writeAccessControlList(::IceInternal::BasicStream*, const ::Ehr::AccessControlListItem*, const ::Ehr::AccessControlListItem*);
void __readAccessControlList(::IceInternal::BasicStream*, AccessControlList&);
void ice_writeAccessControlList(const ::Ice::OutputStreamPtr&, const AccessControlList&);
void ice_readAccessControlList(const ::Ice::InputStreamPtr&, AccessControlList&);

struct Permissions
{
    ::Ehr::AccessType defaultAccess;
    ::Ehr::AccessControlList acl;

    bool operator==(const Permissions&) const;
    bool operator<(const Permissions&) const;
    bool operator!=(const Permissions& __rhs) const
    {
        return !operator==(__rhs);
    }
    bool operator<=(const Permissions& __rhs) const
    {
        return operator<(__rhs) || operator==(__rhs);
    }
    bool operator>(const Permissions& __rhs) const
    {
        return !operator<(__rhs) && !operator==(__rhs);
    }
    bool operator>=(const Permissions& __rhs) const
    {
        return !operator<(__rhs);
    }

    void __write(::IceInternal::BasicStream*) const;
    void __read(::IceInternal::BasicStream*);

    void ice_write(const ::Ice::OutputStreamPtr&) const;
    void ice_read(const ::Ice::InputStreamPtr&);
};

void ice_writePermissions(const ::Ice::OutputStreamPtr&, const Permissions&);
void ice_readPermissions(const ::Ice::InputStreamPtr&, Permissions&);

}

namespace IceProxy
{

namespace Ehr
{

class Document : virtual public ::IceProxy::Ice::Object
{
public:
    
    ::IceInternal::ProxyHandle<Document> ice_context(const ::Ice::Context& __context) const
    {
    #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
        typedef ::IceProxy::Ice::Object _Base;
        return dynamic_cast<Document*>(_Base::ice_context(__context).get());
    #else
        return dynamic_cast<Document*>(::IceProxy::Ice::Object::ice_context(__context).get());
    #endif
    }
    
    ::IceInternal::ProxyHandle<Document> ice_adapterId(const std::string& __id) const
    {
    #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
        typedef ::IceProxy::Ice::Object _Base;
        return dynamic_cast<Document*>(_Base::ice_adapterId(__id).get());
    #else
        return dynamic_cast<Document*>(::IceProxy::Ice::Object::ice_adapterId(__id).get());
    #endif
    }
    
    ::IceInternal::ProxyHandle<Document> ice_endpoints(const ::Ice::EndpointSeq& __endpoints) const
    {
    #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
        typedef ::IceProxy::Ice::Object _Base;
        return dynamic_cast<Document*>(_Base::ice_endpoints(__endpoints).get());
    #else
        return dynamic_cast<Document*>(::IceProxy::Ice::Object::ice_endpoints(__endpoints).get());
    #endif
    }
    
    ::IceInternal::ProxyHandle<Document> ice_locatorCacheTimeout(int __timeout) const
    {
    #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
        typedef ::IceProxy::Ice::Object _Base;
        return dynamic_cast<Document*>(_Base::ice_locatorCacheTimeout(__timeout).get());
    #else
        return dynamic_cast<Document*>(::IceProxy::Ice::Object::ice_locatorCacheTimeout(__timeout).get());
    #endif
    }
    
    ::IceInternal::ProxyHandle<Document> ice_connectionCached(bool __cached) const
    {
    #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
        typedef ::IceProxy::Ice::Object _Base;
        return dynamic_cast<Document*>(_Base::ice_connectionCached(__cached).get());
    #else
        return dynamic_cast<Document*>(::IceProxy::Ice::Object::ice_connectionCached(__cached).get());
    #endif
    }
    
    ::IceInternal::ProxyHandle<Document> ice_endpointSelection(::Ice::EndpointSelectionType __est) const
    {
    #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
        typedef ::IceProxy::Ice::Object _Base;
        return dynamic_cast<Document*>(_Base::ice_endpointSelection(__est).get());
    #else
        return dynamic_cast<Document*>(::IceProxy::Ice::Object::ice_endpointSelection(__est).get());
    #endif
    }
    
    ::IceInternal::ProxyHandle<Document> ice_secure(bool __secure) const
    {
    #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
        typedef ::IceProxy::Ice::Object _Base;
        return dynamic_cast<Document*>(_Base::ice_secure(__secure).get());
    #else
        return dynamic_cast<Document*>(::IceProxy::Ice::Object::ice_secure(__secure).get());
    #endif
    }
    
    ::IceInternal::ProxyHandle<Document> ice_preferSecure(bool __preferSecure) const
    {
    #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
        typedef ::IceProxy::Ice::Object _Base;
        return dynamic_cast<Document*>(_Base::ice_preferSecure(__preferSecure).get());
    #else
        return dynamic_cast<Document*>(::IceProxy::Ice::Object::ice_preferSecure(__preferSecure).get());
    #endif
    }
    
    ::IceInternal::ProxyHandle<Document> ice_router(const ::Ice::RouterPrx& __router) const
    {
    #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
        typedef ::IceProxy::Ice::Object _Base;
        return dynamic_cast<Document*>(_Base::ice_router(__router).get());
    #else
        return dynamic_cast<Document*>(::IceProxy::Ice::Object::ice_router(__router).get());
    #endif
    }
    
    ::IceInternal::ProxyHandle<Document> ice_locator(const ::Ice::LocatorPrx& __locator) const
    {
    #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
        typedef ::IceProxy::Ice::Object _Base;
        return dynamic_cast<Document*>(_Base::ice_locator(__locator).get());
    #else
        return dynamic_cast<Document*>(::IceProxy::Ice::Object::ice_locator(__locator).get());
    #endif
    }
    
    ::IceInternal::ProxyHandle<Document> ice_collocationOptimized(bool __co) const
    {
    #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
        typedef ::IceProxy::Ice::Object _Base;
        return dynamic_cast<Document*>(_Base::ice_collocationOptimized(__co).get());
    #else
        return dynamic_cast<Document*>(::IceProxy::Ice::Object::ice_collocationOptimized(__co).get());
    #endif
    }
    
    ::IceInternal::ProxyHandle<Document> ice_twoway() const
    {
    #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
        typedef ::IceProxy::Ice::Object _Base;
        return dynamic_cast<Document*>(_Base::ice_twoway().get());
    #else
        return dynamic_cast<Document*>(::IceProxy::Ice::Object::ice_twoway().get());
    #endif
    }
    
    ::IceInternal::ProxyHandle<Document> ice_oneway() const
    {
    #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
        typedef ::IceProxy::Ice::Object _Base;
        return dynamic_cast<Document*>(_Base::ice_oneway().get());
    #else
        return dynamic_cast<Document*>(::IceProxy::Ice::Object::ice_oneway().get());
    #endif
    }
    
    ::IceInternal::ProxyHandle<Document> ice_batchOneway() const
    {
    #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
        typedef ::IceProxy::Ice::Object _Base;
        return dynamic_cast<Document*>(_Base::ice_batchOneway().get());
    #else
        return dynamic_cast<Document*>(::IceProxy::Ice::Object::ice_batchOneway().get());
    #endif
    }
    
    ::IceInternal::ProxyHandle<Document> ice_datagram() const
    {
    #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
        typedef ::IceProxy::Ice::Object _Base;
        return dynamic_cast<Document*>(_Base::ice_datagram().get());
    #else
        return dynamic_cast<Document*>(::IceProxy::Ice::Object::ice_datagram().get());
    #endif
    }
    
    ::IceInternal::ProxyHandle<Document> ice_batchDatagram() const
    {
    #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
        typedef ::IceProxy::Ice::Object _Base;
        return dynamic_cast<Document*>(_Base::ice_batchDatagram().get());
    #else
        return dynamic_cast<Document*>(::IceProxy::Ice::Object::ice_batchDatagram().get());
    #endif
    }
    
    ::IceInternal::ProxyHandle<Document> ice_compress(bool __compress) const
    {
    #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
        typedef ::IceProxy::Ice::Object _Base;
        return dynamic_cast<Document*>(_Base::ice_compress(__compress).get());
    #else
        return dynamic_cast<Document*>(::IceProxy::Ice::Object::ice_compress(__compress).get());
    #endif
    }
    
    ::IceInternal::ProxyHandle<Document> ice_timeout(int __timeout) const
    {
    #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
        typedef ::IceProxy::Ice::Object _Base;
        return dynamic_cast<Document*>(_Base::ice_timeout(__timeout).get());
    #else
        return dynamic_cast<Document*>(::IceProxy::Ice::Object::ice_timeout(__timeout).get());
    #endif
    }
    
    ::IceInternal::ProxyHandle<Document> ice_connectionId(const std::string& __id) const
    {
    #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
        typedef ::IceProxy::Ice::Object _Base;
        return dynamic_cast<Document*>(_Base::ice_connectionId(__id).get());
    #else
        return dynamic_cast<Document*>(::IceProxy::Ice::Object::ice_connectionId(__id).get());
    #endif
    }
    
    static const ::std::string& ice_staticId();

private: 

    virtual ::IceInternal::Handle< ::IceDelegateM::Ice::Object> __createDelegateM();
    virtual ::IceInternal::Handle< ::IceDelegateD::Ice::Object> __createDelegateD();
    virtual ::IceProxy::Ice::Object* __newInstance() const;
};

class Prescription : virtual public ::IceProxy::Ehr::Document
{
public:
    
    ::IceInternal::ProxyHandle<Prescription> ice_context(const ::Ice::Context& __context) const
    {
    #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
        typedef ::IceProxy::Ice::Object _Base;
        return dynamic_cast<Prescription*>(_Base::ice_context(__context).get());
    #else
        return dynamic_cast<Prescription*>(::IceProxy::Ice::Object::ice_context(__context).get());
    #endif
    }
    
    ::IceInternal::ProxyHandle<Prescription> ice_adapterId(const std::string& __id) const
    {
    #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
        typedef ::IceProxy::Ice::Object _Base;
        return dynamic_cast<Prescription*>(_Base::ice_adapterId(__id).get());
    #else
        return dynamic_cast<Prescription*>(::IceProxy::Ice::Object::ice_adapterId(__id).get());
    #endif
    }
    
    ::IceInternal::ProxyHandle<Prescription> ice_endpoints(const ::Ice::EndpointSeq& __endpoints) const
    {
    #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
        typedef ::IceProxy::Ice::Object _Base;
        return dynamic_cast<Prescription*>(_Base::ice_endpoints(__endpoints).get());
    #else
        return dynamic_cast<Prescription*>(::IceProxy::Ice::Object::ice_endpoints(__endpoints).get());
    #endif
    }
    
    ::IceInternal::ProxyHandle<Prescription> ice_locatorCacheTimeout(int __timeout) const
    {
    #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
        typedef ::IceProxy::Ice::Object _Base;
        return dynamic_cast<Prescription*>(_Base::ice_locatorCacheTimeout(__timeout).get());
    #else
        return dynamic_cast<Prescription*>(::IceProxy::Ice::Object::ice_locatorCacheTimeout(__timeout).get());
    #endif
    }
    
    ::IceInternal::ProxyHandle<Prescription> ice_connectionCached(bool __cached) const
    {
    #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
        typedef ::IceProxy::Ice::Object _Base;
        return dynamic_cast<Prescription*>(_Base::ice_connectionCached(__cached).get());
    #else
        return dynamic_cast<Prescription*>(::IceProxy::Ice::Object::ice_connectionCached(__cached).get());
    #endif
    }
    
    ::IceInternal::ProxyHandle<Prescription> ice_endpointSelection(::Ice::EndpointSelectionType __est) const
    {
    #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
        typedef ::IceProxy::Ice::Object _Base;
        return dynamic_cast<Prescription*>(_Base::ice_endpointSelection(__est).get());
    #else
        return dynamic_cast<Prescription*>(::IceProxy::Ice::Object::ice_endpointSelection(__est).get());
    #endif
    }
    
    ::IceInternal::ProxyHandle<Prescription> ice_secure(bool __secure) const
    {
    #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
        typedef ::IceProxy::Ice::Object _Base;
        return dynamic_cast<Prescription*>(_Base::ice_secure(__secure).get());
    #else
        return dynamic_cast<Prescription*>(::IceProxy::Ice::Object::ice_secure(__secure).get());
    #endif
    }
    
    ::IceInternal::ProxyHandle<Prescription> ice_preferSecure(bool __preferSecure) const
    {
    #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
        typedef ::IceProxy::Ice::Object _Base;
        return dynamic_cast<Prescription*>(_Base::ice_preferSecure(__preferSecure).get());
    #else
        return dynamic_cast<Prescription*>(::IceProxy::Ice::Object::ice_preferSecure(__preferSecure).get());
    #endif
    }
    
    ::IceInternal::ProxyHandle<Prescription> ice_router(const ::Ice::RouterPrx& __router) const
    {
    #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
        typedef ::IceProxy::Ice::Object _Base;
        return dynamic_cast<Prescription*>(_Base::ice_router(__router).get());
    #else
        return dynamic_cast<Prescription*>(::IceProxy::Ice::Object::ice_router(__router).get());
    #endif
    }
    
    ::IceInternal::ProxyHandle<Prescription> ice_locator(const ::Ice::LocatorPrx& __locator) const
    {
    #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
        typedef ::IceProxy::Ice::Object _Base;
        return dynamic_cast<Prescription*>(_Base::ice_locator(__locator).get());
    #else
        return dynamic_cast<Prescription*>(::IceProxy::Ice::Object::ice_locator(__locator).get());
    #endif
    }
    
    ::IceInternal::ProxyHandle<Prescription> ice_collocationOptimized(bool __co) const
    {
    #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
        typedef ::IceProxy::Ice::Object _Base;
        return dynamic_cast<Prescription*>(_Base::ice_collocationOptimized(__co).get());
    #else
        return dynamic_cast<Prescription*>(::IceProxy::Ice::Object::ice_collocationOptimized(__co).get());
    #endif
    }
    
    ::IceInternal::ProxyHandle<Prescription> ice_twoway() const
    {
    #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
        typedef ::IceProxy::Ice::Object _Base;
        return dynamic_cast<Prescription*>(_Base::ice_twoway().get());
    #else
        return dynamic_cast<Prescription*>(::IceProxy::Ice::Object::ice_twoway().get());
    #endif
    }
    
    ::IceInternal::ProxyHandle<Prescription> ice_oneway() const
    {
    #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
        typedef ::IceProxy::Ice::Object _Base;
        return dynamic_cast<Prescription*>(_Base::ice_oneway().get());
    #else
        return dynamic_cast<Prescription*>(::IceProxy::Ice::Object::ice_oneway().get());
    #endif
    }
    
    ::IceInternal::ProxyHandle<Prescription> ice_batchOneway() const
    {
    #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
        typedef ::IceProxy::Ice::Object _Base;
        return dynamic_cast<Prescription*>(_Base::ice_batchOneway().get());
    #else
        return dynamic_cast<Prescription*>(::IceProxy::Ice::Object::ice_batchOneway().get());
    #endif
    }
    
    ::IceInternal::ProxyHandle<Prescription> ice_datagram() const
    {
    #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
        typedef ::IceProxy::Ice::Object _Base;
        return dynamic_cast<Prescription*>(_Base::ice_datagram().get());
    #else
        return dynamic_cast<Prescription*>(::IceProxy::Ice::Object::ice_datagram().get());
    #endif
    }
    
    ::IceInternal::ProxyHandle<Prescription> ice_batchDatagram() const
    {
    #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
        typedef ::IceProxy::Ice::Object _Base;
        return dynamic_cast<Prescription*>(_Base::ice_batchDatagram().get());
    #else
        return dynamic_cast<Prescription*>(::IceProxy::Ice::Object::ice_batchDatagram().get());
    #endif
    }
    
    ::IceInternal::ProxyHandle<Prescription> ice_compress(bool __compress) const
    {
    #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
        typedef ::IceProxy::Ice::Object _Base;
        return dynamic_cast<Prescription*>(_Base::ice_compress(__compress).get());
    #else
        return dynamic_cast<Prescription*>(::IceProxy::Ice::Object::ice_compress(__compress).get());
    #endif
    }
    
    ::IceInternal::ProxyHandle<Prescription> ice_timeout(int __timeout) const
    {
    #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
        typedef ::IceProxy::Ice::Object _Base;
        return dynamic_cast<Prescription*>(_Base::ice_timeout(__timeout).get());
    #else
        return dynamic_cast<Prescription*>(::IceProxy::Ice::Object::ice_timeout(__timeout).get());
    #endif
    }
    
    ::IceInternal::ProxyHandle<Prescription> ice_connectionId(const std::string& __id) const
    {
    #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
        typedef ::IceProxy::Ice::Object _Base;
        return dynamic_cast<Prescription*>(_Base::ice_connectionId(__id).get());
    #else
        return dynamic_cast<Prescription*>(::IceProxy::Ice::Object::ice_connectionId(__id).get());
    #endif
    }
    
    static const ::std::string& ice_staticId();

private: 

    virtual ::IceInternal::Handle< ::IceDelegateM::Ice::Object> __createDelegateM();
    virtual ::IceInternal::Handle< ::IceDelegateD::Ice::Object> __createDelegateD();
    virtual ::IceProxy::Ice::Object* __newInstance() const;
};

class ConsumedPrescription : virtual public ::IceProxy::Ehr::Prescription
{
public:
    
    ::IceInternal::ProxyHandle<ConsumedPrescription> ice_context(const ::Ice::Context& __context) const
    {
    #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
        typedef ::IceProxy::Ice::Object _Base;
        return dynamic_cast<ConsumedPrescription*>(_Base::ice_context(__context).get());
    #else
        return dynamic_cast<ConsumedPrescription*>(::IceProxy::Ice::Object::ice_context(__context).get());
    #endif
    }
    
    ::IceInternal::ProxyHandle<ConsumedPrescription> ice_adapterId(const std::string& __id) const
    {
    #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
        typedef ::IceProxy::Ice::Object _Base;
        return dynamic_cast<ConsumedPrescription*>(_Base::ice_adapterId(__id).get());
    #else
        return dynamic_cast<ConsumedPrescription*>(::IceProxy::Ice::Object::ice_adapterId(__id).get());
    #endif
    }
    
    ::IceInternal::ProxyHandle<ConsumedPrescription> ice_endpoints(const ::Ice::EndpointSeq& __endpoints) const
    {
    #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
        typedef ::IceProxy::Ice::Object _Base;
        return dynamic_cast<ConsumedPrescription*>(_Base::ice_endpoints(__endpoints).get());
    #else
        return dynamic_cast<ConsumedPrescription*>(::IceProxy::Ice::Object::ice_endpoints(__endpoints).get());
    #endif
    }
    
    ::IceInternal::ProxyHandle<ConsumedPrescription> ice_locatorCacheTimeout(int __timeout) const
    {
    #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
        typedef ::IceProxy::Ice::Object _Base;
        return dynamic_cast<ConsumedPrescription*>(_Base::ice_locatorCacheTimeout(__timeout).get());
    #else
        return dynamic_cast<ConsumedPrescription*>(::IceProxy::Ice::Object::ice_locatorCacheTimeout(__timeout).get());
    #endif
    }
    
    ::IceInternal::ProxyHandle<ConsumedPrescription> ice_connectionCached(bool __cached) const
    {
    #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
        typedef ::IceProxy::Ice::Object _Base;
        return dynamic_cast<ConsumedPrescription*>(_Base::ice_connectionCached(__cached).get());
    #else
        return dynamic_cast<ConsumedPrescription*>(::IceProxy::Ice::Object::ice_connectionCached(__cached).get());
    #endif
    }
    
    ::IceInternal::ProxyHandle<ConsumedPrescription> ice_endpointSelection(::Ice::EndpointSelectionType __est) const
    {
    #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
        typedef ::IceProxy::Ice::Object _Base;
        return dynamic_cast<ConsumedPrescription*>(_Base::ice_endpointSelection(__est).get());
    #else
        return dynamic_cast<ConsumedPrescription*>(::IceProxy::Ice::Object::ice_endpointSelection(__est).get());
    #endif
    }
    
    ::IceInternal::ProxyHandle<ConsumedPrescription> ice_secure(bool __secure) const
    {
    #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
        typedef ::IceProxy::Ice::Object _Base;
        return dynamic_cast<ConsumedPrescription*>(_Base::ice_secure(__secure).get());
    #else
        return dynamic_cast<ConsumedPrescription*>(::IceProxy::Ice::Object::ice_secure(__secure).get());
    #endif
    }
    
    ::IceInternal::ProxyHandle<ConsumedPrescription> ice_preferSecure(bool __preferSecure) const
    {
    #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
        typedef ::IceProxy::Ice::Object _Base;
        return dynamic_cast<ConsumedPrescription*>(_Base::ice_preferSecure(__preferSecure).get());
    #else
        return dynamic_cast<ConsumedPrescription*>(::IceProxy::Ice::Object::ice_preferSecure(__preferSecure).get());
    #endif
    }
    
    ::IceInternal::ProxyHandle<ConsumedPrescription> ice_router(const ::Ice::RouterPrx& __router) const
    {
    #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
        typedef ::IceProxy::Ice::Object _Base;
        return dynamic_cast<ConsumedPrescription*>(_Base::ice_router(__router).get());
    #else
        return dynamic_cast<ConsumedPrescription*>(::IceProxy::Ice::Object::ice_router(__router).get());
    #endif
    }
    
    ::IceInternal::ProxyHandle<ConsumedPrescription> ice_locator(const ::Ice::LocatorPrx& __locator) const
    {
    #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
        typedef ::IceProxy::Ice::Object _Base;
        return dynamic_cast<ConsumedPrescription*>(_Base::ice_locator(__locator).get());
    #else
        return dynamic_cast<ConsumedPrescription*>(::IceProxy::Ice::Object::ice_locator(__locator).get());
    #endif
    }
    
    ::IceInternal::ProxyHandle<ConsumedPrescription> ice_collocationOptimized(bool __co) const
    {
    #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
        typedef ::IceProxy::Ice::Object _Base;
        return dynamic_cast<ConsumedPrescription*>(_Base::ice_collocationOptimized(__co).get());
    #else
        return dynamic_cast<ConsumedPrescription*>(::IceProxy::Ice::Object::ice_collocationOptimized(__co).get());
    #endif
    }
    
    ::IceInternal::ProxyHandle<ConsumedPrescription> ice_twoway() const
    {
    #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
        typedef ::IceProxy::Ice::Object _Base;
        return dynamic_cast<ConsumedPrescription*>(_Base::ice_twoway().get());
    #else
        return dynamic_cast<ConsumedPrescription*>(::IceProxy::Ice::Object::ice_twoway().get());
    #endif
    }
    
    ::IceInternal::ProxyHandle<ConsumedPrescription> ice_oneway() const
    {
    #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
        typedef ::IceProxy::Ice::Object _Base;
        return dynamic_cast<ConsumedPrescription*>(_Base::ice_oneway().get());
    #else
        return dynamic_cast<ConsumedPrescription*>(::IceProxy::Ice::Object::ice_oneway().get());
    #endif
    }
    
    ::IceInternal::ProxyHandle<ConsumedPrescription> ice_batchOneway() const
    {
    #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
        typedef ::IceProxy::Ice::Object _Base;
        return dynamic_cast<ConsumedPrescription*>(_Base::ice_batchOneway().get());
    #else
        return dynamic_cast<ConsumedPrescription*>(::IceProxy::Ice::Object::ice_batchOneway().get());
    #endif
    }
    
    ::IceInternal::ProxyHandle<ConsumedPrescription> ice_datagram() const
    {
    #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
        typedef ::IceProxy::Ice::Object _Base;
        return dynamic_cast<ConsumedPrescription*>(_Base::ice_datagram().get());
    #else
        return dynamic_cast<ConsumedPrescription*>(::IceProxy::Ice::Object::ice_datagram().get());
    #endif
    }
    
    ::IceInternal::ProxyHandle<ConsumedPrescription> ice_batchDatagram() const
    {
    #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
        typedef ::IceProxy::Ice::Object _Base;
        return dynamic_cast<ConsumedPrescription*>(_Base::ice_batchDatagram().get());
    #else
        return dynamic_cast<ConsumedPrescription*>(::IceProxy::Ice::Object::ice_batchDatagram().get());
    #endif
    }
    
    ::IceInternal::ProxyHandle<ConsumedPrescription> ice_compress(bool __compress) const
    {
    #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
        typedef ::IceProxy::Ice::Object _Base;
        return dynamic_cast<ConsumedPrescription*>(_Base::ice_compress(__compress).get());
    #else
        return dynamic_cast<ConsumedPrescription*>(::IceProxy::Ice::Object::ice_compress(__compress).get());
    #endif
    }
    
    ::IceInternal::ProxyHandle<ConsumedPrescription> ice_timeout(int __timeout) const
    {
    #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
        typedef ::IceProxy::Ice::Object _Base;
        return dynamic_cast<ConsumedPrescription*>(_Base::ice_timeout(__timeout).get());
    #else
        return dynamic_cast<ConsumedPrescription*>(::IceProxy::Ice::Object::ice_timeout(__timeout).get());
    #endif
    }
    
    ::IceInternal::ProxyHandle<ConsumedPrescription> ice_connectionId(const std::string& __id) const
    {
    #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
        typedef ::IceProxy::Ice::Object _Base;
        return dynamic_cast<ConsumedPrescription*>(_Base::ice_connectionId(__id).get());
    #else
        return dynamic_cast<ConsumedPrescription*>(::IceProxy::Ice::Object::ice_connectionId(__id).get());
    #endif
    }
    
    static const ::std::string& ice_staticId();

private: 

    virtual ::IceInternal::Handle< ::IceDelegateM::Ice::Object> __createDelegateM();
    virtual ::IceInternal::Handle< ::IceDelegateD::Ice::Object> __createDelegateD();
    virtual ::IceProxy::Ice::Object* __newInstance() const;
};

class Request : virtual public ::IceProxy::Ice::Object
{
public:
    
    ::IceInternal::ProxyHandle<Request> ice_context(const ::Ice::Context& __context) const
    {
    #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
        typedef ::IceProxy::Ice::Object _Base;
        return dynamic_cast<Request*>(_Base::ice_context(__context).get());
    #else
        return dynamic_cast<Request*>(::IceProxy::Ice::Object::ice_context(__context).get());
    #endif
    }
    
    ::IceInternal::ProxyHandle<Request> ice_adapterId(const std::string& __id) const
    {
    #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
        typedef ::IceProxy::Ice::Object _Base;
        return dynamic_cast<Request*>(_Base::ice_adapterId(__id).get());
    #else
        return dynamic_cast<Request*>(::IceProxy::Ice::Object::ice_adapterId(__id).get());
    #endif
    }
    
    ::IceInternal::ProxyHandle<Request> ice_endpoints(const ::Ice::EndpointSeq& __endpoints) const
    {
    #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
        typedef ::IceProxy::Ice::Object _Base;
        return dynamic_cast<Request*>(_Base::ice_endpoints(__endpoints).get());
    #else
        return dynamic_cast<Request*>(::IceProxy::Ice::Object::ice_endpoints(__endpoints).get());
    #endif
    }
    
    ::IceInternal::ProxyHandle<Request> ice_locatorCacheTimeout(int __timeout) const
    {
    #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
        typedef ::IceProxy::Ice::Object _Base;
        return dynamic_cast<Request*>(_Base::ice_locatorCacheTimeout(__timeout).get());
    #else
        return dynamic_cast<Request*>(::IceProxy::Ice::Object::ice_locatorCacheTimeout(__timeout).get());
    #endif
    }
    
    ::IceInternal::ProxyHandle<Request> ice_connectionCached(bool __cached) const
    {
    #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
        typedef ::IceProxy::Ice::Object _Base;
        return dynamic_cast<Request*>(_Base::ice_connectionCached(__cached).get());
    #else
        return dynamic_cast<Request*>(::IceProxy::Ice::Object::ice_connectionCached(__cached).get());
    #endif
    }
    
    ::IceInternal::ProxyHandle<Request> ice_endpointSelection(::Ice::EndpointSelectionType __est) const
    {
    #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
        typedef ::IceProxy::Ice::Object _Base;
        return dynamic_cast<Request*>(_Base::ice_endpointSelection(__est).get());
    #else
        return dynamic_cast<Request*>(::IceProxy::Ice::Object::ice_endpointSelection(__est).get());
    #endif
    }
    
    ::IceInternal::ProxyHandle<Request> ice_secure(bool __secure) const
    {
    #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
        typedef ::IceProxy::Ice::Object _Base;
        return dynamic_cast<Request*>(_Base::ice_secure(__secure).get());
    #else
        return dynamic_cast<Request*>(::IceProxy::Ice::Object::ice_secure(__secure).get());
    #endif
    }
    
    ::IceInternal::ProxyHandle<Request> ice_preferSecure(bool __preferSecure) const
    {
    #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
        typedef ::IceProxy::Ice::Object _Base;
        return dynamic_cast<Request*>(_Base::ice_preferSecure(__preferSecure).get());
    #else
        return dynamic_cast<Request*>(::IceProxy::Ice::Object::ice_preferSecure(__preferSecure).get());
    #endif
    }
    
    ::IceInternal::ProxyHandle<Request> ice_router(const ::Ice::RouterPrx& __router) const
    {
    #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
        typedef ::IceProxy::Ice::Object _Base;
        return dynamic_cast<Request*>(_Base::ice_router(__router).get());
    #else
        return dynamic_cast<Request*>(::IceProxy::Ice::Object::ice_router(__router).get());
    #endif
    }
    
    ::IceInternal::ProxyHandle<Request> ice_locator(const ::Ice::LocatorPrx& __locator) const
    {
    #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
        typedef ::IceProxy::Ice::Object _Base;
        return dynamic_cast<Request*>(_Base::ice_locator(__locator).get());
    #else
        return dynamic_cast<Request*>(::IceProxy::Ice::Object::ice_locator(__locator).get());
    #endif
    }
    
    ::IceInternal::ProxyHandle<Request> ice_collocationOptimized(bool __co) const
    {
    #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
        typedef ::IceProxy::Ice::Object _Base;
        return dynamic_cast<Request*>(_Base::ice_collocationOptimized(__co).get());
    #else
        return dynamic_cast<Request*>(::IceProxy::Ice::Object::ice_collocationOptimized(__co).get());
    #endif
    }
    
    ::IceInternal::ProxyHandle<Request> ice_twoway() const
    {
    #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
        typedef ::IceProxy::Ice::Object _Base;
        return dynamic_cast<Request*>(_Base::ice_twoway().get());
    #else
        return dynamic_cast<Request*>(::IceProxy::Ice::Object::ice_twoway().get());
    #endif
    }
    
    ::IceInternal::ProxyHandle<Request> ice_oneway() const
    {
    #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
        typedef ::IceProxy::Ice::Object _Base;
        return dynamic_cast<Request*>(_Base::ice_oneway().get());
    #else
        return dynamic_cast<Request*>(::IceProxy::Ice::Object::ice_oneway().get());
    #endif
    }
    
    ::IceInternal::ProxyHandle<Request> ice_batchOneway() const
    {
    #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
        typedef ::IceProxy::Ice::Object _Base;
        return dynamic_cast<Request*>(_Base::ice_batchOneway().get());
    #else
        return dynamic_cast<Request*>(::IceProxy::Ice::Object::ice_batchOneway().get());
    #endif
    }
    
    ::IceInternal::ProxyHandle<Request> ice_datagram() const
    {
    #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
        typedef ::IceProxy::Ice::Object _Base;
        return dynamic_cast<Request*>(_Base::ice_datagram().get());
    #else
        return dynamic_cast<Request*>(::IceProxy::Ice::Object::ice_datagram().get());
    #endif
    }
    
    ::IceInternal::ProxyHandle<Request> ice_batchDatagram() const
    {
    #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
        typedef ::IceProxy::Ice::Object _Base;
        return dynamic_cast<Request*>(_Base::ice_batchDatagram().get());
    #else
        return dynamic_cast<Request*>(::IceProxy::Ice::Object::ice_batchDatagram().get());
    #endif
    }
    
    ::IceInternal::ProxyHandle<Request> ice_compress(bool __compress) const
    {
    #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
        typedef ::IceProxy::Ice::Object _Base;
        return dynamic_cast<Request*>(_Base::ice_compress(__compress).get());
    #else
        return dynamic_cast<Request*>(::IceProxy::Ice::Object::ice_compress(__compress).get());
    #endif
    }
    
    ::IceInternal::ProxyHandle<Request> ice_timeout(int __timeout) const
    {
    #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
        typedef ::IceProxy::Ice::Object _Base;
        return dynamic_cast<Request*>(_Base::ice_timeout(__timeout).get());
    #else
        return dynamic_cast<Request*>(::IceProxy::Ice::Object::ice_timeout(__timeout).get());
    #endif
    }
    
    ::IceInternal::ProxyHandle<Request> ice_connectionId(const std::string& __id) const
    {
    #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
        typedef ::IceProxy::Ice::Object _Base;
        return dynamic_cast<Request*>(_Base::ice_connectionId(__id).get());
    #else
        return dynamic_cast<Request*>(::IceProxy::Ice::Object::ice_connectionId(__id).get());
    #endif
    }
    
    static const ::std::string& ice_staticId();

private: 

    virtual ::IceInternal::Handle< ::IceDelegateM::Ice::Object> __createDelegateM();
    virtual ::IceInternal::Handle< ::IceDelegateD::Ice::Object> __createDelegateD();
    virtual ::IceProxy::Ice::Object* __newInstance() const;
};

class ThirdPartyRequest : virtual public ::IceProxy::Ehr::Request
{
public:
    
    ::IceInternal::ProxyHandle<ThirdPartyRequest> ice_context(const ::Ice::Context& __context) const
    {
    #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
        typedef ::IceProxy::Ice::Object _Base;
        return dynamic_cast<ThirdPartyRequest*>(_Base::ice_context(__context).get());
    #else
        return dynamic_cast<ThirdPartyRequest*>(::IceProxy::Ice::Object::ice_context(__context).get());
    #endif
    }
    
    ::IceInternal::ProxyHandle<ThirdPartyRequest> ice_adapterId(const std::string& __id) const
    {
    #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
        typedef ::IceProxy::Ice::Object _Base;
        return dynamic_cast<ThirdPartyRequest*>(_Base::ice_adapterId(__id).get());
    #else
        return dynamic_cast<ThirdPartyRequest*>(::IceProxy::Ice::Object::ice_adapterId(__id).get());
    #endif
    }
    
    ::IceInternal::ProxyHandle<ThirdPartyRequest> ice_endpoints(const ::Ice::EndpointSeq& __endpoints) const
    {
    #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
        typedef ::IceProxy::Ice::Object _Base;
        return dynamic_cast<ThirdPartyRequest*>(_Base::ice_endpoints(__endpoints).get());
    #else
        return dynamic_cast<ThirdPartyRequest*>(::IceProxy::Ice::Object::ice_endpoints(__endpoints).get());
    #endif
    }
    
    ::IceInternal::ProxyHandle<ThirdPartyRequest> ice_locatorCacheTimeout(int __timeout) const
    {
    #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
        typedef ::IceProxy::Ice::Object _Base;
        return dynamic_cast<ThirdPartyRequest*>(_Base::ice_locatorCacheTimeout(__timeout).get());
    #else
        return dynamic_cast<ThirdPartyRequest*>(::IceProxy::Ice::Object::ice_locatorCacheTimeout(__timeout).get());
    #endif
    }
    
    ::IceInternal::ProxyHandle<ThirdPartyRequest> ice_connectionCached(bool __cached) const
    {
    #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
        typedef ::IceProxy::Ice::Object _Base;
        return dynamic_cast<ThirdPartyRequest*>(_Base::ice_connectionCached(__cached).get());
    #else
        return dynamic_cast<ThirdPartyRequest*>(::IceProxy::Ice::Object::ice_connectionCached(__cached).get());
    #endif
    }
    
    ::IceInternal::ProxyHandle<ThirdPartyRequest> ice_endpointSelection(::Ice::EndpointSelectionType __est) const
    {
    #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
        typedef ::IceProxy::Ice::Object _Base;
        return dynamic_cast<ThirdPartyRequest*>(_Base::ice_endpointSelection(__est).get());
    #else
        return dynamic_cast<ThirdPartyRequest*>(::IceProxy::Ice::Object::ice_endpointSelection(__est).get());
    #endif
    }
    
    ::IceInternal::ProxyHandle<ThirdPartyRequest> ice_secure(bool __secure) const
    {
    #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
        typedef ::IceProxy::Ice::Object _Base;
        return dynamic_cast<ThirdPartyRequest*>(_Base::ice_secure(__secure).get());
    #else
        return dynamic_cast<ThirdPartyRequest*>(::IceProxy::Ice::Object::ice_secure(__secure).get());
    #endif
    }
    
    ::IceInternal::ProxyHandle<ThirdPartyRequest> ice_preferSecure(bool __preferSecure) const
    {
    #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
        typedef ::IceProxy::Ice::Object _Base;
        return dynamic_cast<ThirdPartyRequest*>(_Base::ice_preferSecure(__preferSecure).get());
    #else
        return dynamic_cast<ThirdPartyRequest*>(::IceProxy::Ice::Object::ice_preferSecure(__preferSecure).get());
    #endif
    }
    
    ::IceInternal::ProxyHandle<ThirdPartyRequest> ice_router(const ::Ice::RouterPrx& __router) const
    {
    #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
        typedef ::IceProxy::Ice::Object _Base;
        return dynamic_cast<ThirdPartyRequest*>(_Base::ice_router(__router).get());
    #else
        return dynamic_cast<ThirdPartyRequest*>(::IceProxy::Ice::Object::ice_router(__router).get());
    #endif
    }
    
    ::IceInternal::ProxyHandle<ThirdPartyRequest> ice_locator(const ::Ice::LocatorPrx& __locator) const
    {
    #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
        typedef ::IceProxy::Ice::Object _Base;
        return dynamic_cast<ThirdPartyRequest*>(_Base::ice_locator(__locator).get());
    #else
        return dynamic_cast<ThirdPartyRequest*>(::IceProxy::Ice::Object::ice_locator(__locator).get());
    #endif
    }
    
    ::IceInternal::ProxyHandle<ThirdPartyRequest> ice_collocationOptimized(bool __co) const
    {
    #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
        typedef ::IceProxy::Ice::Object _Base;
        return dynamic_cast<ThirdPartyRequest*>(_Base::ice_collocationOptimized(__co).get());
    #else
        return dynamic_cast<ThirdPartyRequest*>(::IceProxy::Ice::Object::ice_collocationOptimized(__co).get());
    #endif
    }
    
    ::IceInternal::ProxyHandle<ThirdPartyRequest> ice_twoway() const
    {
    #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
        typedef ::IceProxy::Ice::Object _Base;
        return dynamic_cast<ThirdPartyRequest*>(_Base::ice_twoway().get());
    #else
        return dynamic_cast<ThirdPartyRequest*>(::IceProxy::Ice::Object::ice_twoway().get());
    #endif
    }
    
    ::IceInternal::ProxyHandle<ThirdPartyRequest> ice_oneway() const
    {
    #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
        typedef ::IceProxy::Ice::Object _Base;
        return dynamic_cast<ThirdPartyRequest*>(_Base::ice_oneway().get());
    #else
        return dynamic_cast<ThirdPartyRequest*>(::IceProxy::Ice::Object::ice_oneway().get());
    #endif
    }
    
    ::IceInternal::ProxyHandle<ThirdPartyRequest> ice_batchOneway() const
    {
    #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
        typedef ::IceProxy::Ice::Object _Base;
        return dynamic_cast<ThirdPartyRequest*>(_Base::ice_batchOneway().get());
    #else
        return dynamic_cast<ThirdPartyRequest*>(::IceProxy::Ice::Object::ice_batchOneway().get());
    #endif
    }
    
    ::IceInternal::ProxyHandle<ThirdPartyRequest> ice_datagram() const
    {
    #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
        typedef ::IceProxy::Ice::Object _Base;
        return dynamic_cast<ThirdPartyRequest*>(_Base::ice_datagram().get());
    #else
        return dynamic_cast<ThirdPartyRequest*>(::IceProxy::Ice::Object::ice_datagram().get());
    #endif
    }
    
    ::IceInternal::ProxyHandle<ThirdPartyRequest> ice_batchDatagram() const
    {
    #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
        typedef ::IceProxy::Ice::Object _Base;
        return dynamic_cast<ThirdPartyRequest*>(_Base::ice_batchDatagram().get());
    #else
        return dynamic_cast<ThirdPartyRequest*>(::IceProxy::Ice::Object::ice_batchDatagram().get());
    #endif
    }
    
    ::IceInternal::ProxyHandle<ThirdPartyRequest> ice_compress(bool __compress) const
    {
    #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
        typedef ::IceProxy::Ice::Object _Base;
        return dynamic_cast<ThirdPartyRequest*>(_Base::ice_compress(__compress).get());
    #else
        return dynamic_cast<ThirdPartyRequest*>(::IceProxy::Ice::Object::ice_compress(__compress).get());
    #endif
    }
    
    ::IceInternal::ProxyHandle<ThirdPartyRequest> ice_timeout(int __timeout) const
    {
    #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
        typedef ::IceProxy::Ice::Object _Base;
        return dynamic_cast<ThirdPartyRequest*>(_Base::ice_timeout(__timeout).get());
    #else
        return dynamic_cast<ThirdPartyRequest*>(::IceProxy::Ice::Object::ice_timeout(__timeout).get());
    #endif
    }
    
    ::IceInternal::ProxyHandle<ThirdPartyRequest> ice_connectionId(const std::string& __id) const
    {
    #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
        typedef ::IceProxy::Ice::Object _Base;
        return dynamic_cast<ThirdPartyRequest*>(_Base::ice_connectionId(__id).get());
    #else
        return dynamic_cast<ThirdPartyRequest*>(::IceProxy::Ice::Object::ice_connectionId(__id).get());
    #endif
    }
    
    static const ::std::string& ice_staticId();

private: 

    virtual ::IceInternal::Handle< ::IceDelegateM::Ice::Object> __createDelegateM();
    virtual ::IceInternal::Handle< ::IceDelegateD::Ice::Object> __createDelegateD();
    virtual ::IceProxy::Ice::Object* __newInstance() const;
};

class CreatePrescriptionRequest : virtual public ::IceProxy::Ehr::ThirdPartyRequest
{
public:
    
    ::IceInternal::ProxyHandle<CreatePrescriptionRequest> ice_context(const ::Ice::Context& __context) const
    {
    #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
        typedef ::IceProxy::Ice::Object _Base;
        return dynamic_cast<CreatePrescriptionRequest*>(_Base::ice_context(__context).get());
    #else
        return dynamic_cast<CreatePrescriptionRequest*>(::IceProxy::Ice::Object::ice_context(__context).get());
    #endif
    }
    
    ::IceInternal::ProxyHandle<CreatePrescriptionRequest> ice_adapterId(const std::string& __id) const
    {
    #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
        typedef ::IceProxy::Ice::Object _Base;
        return dynamic_cast<CreatePrescriptionRequest*>(_Base::ice_adapterId(__id).get());
    #else
        return dynamic_cast<CreatePrescriptionRequest*>(::IceProxy::Ice::Object::ice_adapterId(__id).get());
    #endif
    }
    
    ::IceInternal::ProxyHandle<CreatePrescriptionRequest> ice_endpoints(const ::Ice::EndpointSeq& __endpoints) const
    {
    #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
        typedef ::IceProxy::Ice::Object _Base;
        return dynamic_cast<CreatePrescriptionRequest*>(_Base::ice_endpoints(__endpoints).get());
    #else
        return dynamic_cast<CreatePrescriptionRequest*>(::IceProxy::Ice::Object::ice_endpoints(__endpoints).get());
    #endif
    }
    
    ::IceInternal::ProxyHandle<CreatePrescriptionRequest> ice_locatorCacheTimeout(int __timeout) const
    {
    #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
        typedef ::IceProxy::Ice::Object _Base;
        return dynamic_cast<CreatePrescriptionRequest*>(_Base::ice_locatorCacheTimeout(__timeout).get());
    #else
        return dynamic_cast<CreatePrescriptionRequest*>(::IceProxy::Ice::Object::ice_locatorCacheTimeout(__timeout).get());
    #endif
    }
    
    ::IceInternal::ProxyHandle<CreatePrescriptionRequest> ice_connectionCached(bool __cached) const
    {
    #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
        typedef ::IceProxy::Ice::Object _Base;
        return dynamic_cast<CreatePrescriptionRequest*>(_Base::ice_connectionCached(__cached).get());
    #else
        return dynamic_cast<CreatePrescriptionRequest*>(::IceProxy::Ice::Object::ice_connectionCached(__cached).get());
    #endif
    }
    
    ::IceInternal::ProxyHandle<CreatePrescriptionRequest> ice_endpointSelection(::Ice::EndpointSelectionType __est) const
    {
    #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
        typedef ::IceProxy::Ice::Object _Base;
        return dynamic_cast<CreatePrescriptionRequest*>(_Base::ice_endpointSelection(__est).get());
    #else
        return dynamic_cast<CreatePrescriptionRequest*>(::IceProxy::Ice::Object::ice_endpointSelection(__est).get());
    #endif
    }
    
    ::IceInternal::ProxyHandle<CreatePrescriptionRequest> ice_secure(bool __secure) const
    {
    #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
        typedef ::IceProxy::Ice::Object _Base;
        return dynamic_cast<CreatePrescriptionRequest*>(_Base::ice_secure(__secure).get());
    #else
        return dynamic_cast<CreatePrescriptionRequest*>(::IceProxy::Ice::Object::ice_secure(__secure).get());
    #endif
    }
    
    ::IceInternal::ProxyHandle<CreatePrescriptionRequest> ice_preferSecure(bool __preferSecure) const
    {
    #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
        typedef ::IceProxy::Ice::Object _Base;
        return dynamic_cast<CreatePrescriptionRequest*>(_Base::ice_preferSecure(__preferSecure).get());
    #else
        return dynamic_cast<CreatePrescriptionRequest*>(::IceProxy::Ice::Object::ice_preferSecure(__preferSecure).get());
    #endif
    }
    
    ::IceInternal::ProxyHandle<CreatePrescriptionRequest> ice_router(const ::Ice::RouterPrx& __router) const
    {
    #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
        typedef ::IceProxy::Ice::Object _Base;
        return dynamic_cast<CreatePrescriptionRequest*>(_Base::ice_router(__router).get());
    #else
        return dynamic_cast<CreatePrescriptionRequest*>(::IceProxy::Ice::Object::ice_router(__router).get());
    #endif
    }
    
    ::IceInternal::ProxyHandle<CreatePrescriptionRequest> ice_locator(const ::Ice::LocatorPrx& __locator) const
    {
    #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
        typedef ::IceProxy::Ice::Object _Base;
        return dynamic_cast<CreatePrescriptionRequest*>(_Base::ice_locator(__locator).get());
    #else
        return dynamic_cast<CreatePrescriptionRequest*>(::IceProxy::Ice::Object::ice_locator(__locator).get());
    #endif
    }
    
    ::IceInternal::ProxyHandle<CreatePrescriptionRequest> ice_collocationOptimized(bool __co) const
    {
    #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
        typedef ::IceProxy::Ice::Object _Base;
        return dynamic_cast<CreatePrescriptionRequest*>(_Base::ice_collocationOptimized(__co).get());
    #else
        return dynamic_cast<CreatePrescriptionRequest*>(::IceProxy::Ice::Object::ice_collocationOptimized(__co).get());
    #endif
    }
    
    ::IceInternal::ProxyHandle<CreatePrescriptionRequest> ice_twoway() const
    {
    #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
        typedef ::IceProxy::Ice::Object _Base;
        return dynamic_cast<CreatePrescriptionRequest*>(_Base::ice_twoway().get());
    #else
        return dynamic_cast<CreatePrescriptionRequest*>(::IceProxy::Ice::Object::ice_twoway().get());
    #endif
    }
    
    ::IceInternal::ProxyHandle<CreatePrescriptionRequest> ice_oneway() const
    {
    #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
        typedef ::IceProxy::Ice::Object _Base;
        return dynamic_cast<CreatePrescriptionRequest*>(_Base::ice_oneway().get());
    #else
        return dynamic_cast<CreatePrescriptionRequest*>(::IceProxy::Ice::Object::ice_oneway().get());
    #endif
    }
    
    ::IceInternal::ProxyHandle<CreatePrescriptionRequest> ice_batchOneway() const
    {
    #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
        typedef ::IceProxy::Ice::Object _Base;
        return dynamic_cast<CreatePrescriptionRequest*>(_Base::ice_batchOneway().get());
    #else
        return dynamic_cast<CreatePrescriptionRequest*>(::IceProxy::Ice::Object::ice_batchOneway().get());
    #endif
    }
    
    ::IceInternal::ProxyHandle<CreatePrescriptionRequest> ice_datagram() const
    {
    #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
        typedef ::IceProxy::Ice::Object _Base;
        return dynamic_cast<CreatePrescriptionRequest*>(_Base::ice_datagram().get());
    #else
        return dynamic_cast<CreatePrescriptionRequest*>(::IceProxy::Ice::Object::ice_datagram().get());
    #endif
    }
    
    ::IceInternal::ProxyHandle<CreatePrescriptionRequest> ice_batchDatagram() const
    {
    #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
        typedef ::IceProxy::Ice::Object _Base;
        return dynamic_cast<CreatePrescriptionRequest*>(_Base::ice_batchDatagram().get());
    #else
        return dynamic_cast<CreatePrescriptionRequest*>(::IceProxy::Ice::Object::ice_batchDatagram().get());
    #endif
    }
    
    ::IceInternal::ProxyHandle<CreatePrescriptionRequest> ice_compress(bool __compress) const
    {
    #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
        typedef ::IceProxy::Ice::Object _Base;
        return dynamic_cast<CreatePrescriptionRequest*>(_Base::ice_compress(__compress).get());
    #else
        return dynamic_cast<CreatePrescriptionRequest*>(::IceProxy::Ice::Object::ice_compress(__compress).get());
    #endif
    }
    
    ::IceInternal::ProxyHandle<CreatePrescriptionRequest> ice_timeout(int __timeout) const
    {
    #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
        typedef ::IceProxy::Ice::Object _Base;
        return dynamic_cast<CreatePrescriptionRequest*>(_Base::ice_timeout(__timeout).get());
    #else
        return dynamic_cast<CreatePrescriptionRequest*>(::IceProxy::Ice::Object::ice_timeout(__timeout).get());
    #endif
    }
    
    ::IceInternal::ProxyHandle<CreatePrescriptionRequest> ice_connectionId(const std::string& __id) const
    {
    #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
        typedef ::IceProxy::Ice::Object _Base;
        return dynamic_cast<CreatePrescriptionRequest*>(_Base::ice_connectionId(__id).get());
    #else
        return dynamic_cast<CreatePrescriptionRequest*>(::IceProxy::Ice::Object::ice_connectionId(__id).get());
    #endif
    }
    
    static const ::std::string& ice_staticId();

private: 

    virtual ::IceInternal::Handle< ::IceDelegateM::Ice::Object> __createDelegateM();
    virtual ::IceInternal::Handle< ::IceDelegateD::Ice::Object> __createDelegateD();
    virtual ::IceProxy::Ice::Object* __newInstance() const;
};

class ConsumePrescriptionRequest : virtual public ::IceProxy::Ehr::ThirdPartyRequest
{
public:
    
    ::IceInternal::ProxyHandle<ConsumePrescriptionRequest> ice_context(const ::Ice::Context& __context) const
    {
    #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
        typedef ::IceProxy::Ice::Object _Base;
        return dynamic_cast<ConsumePrescriptionRequest*>(_Base::ice_context(__context).get());
    #else
        return dynamic_cast<ConsumePrescriptionRequest*>(::IceProxy::Ice::Object::ice_context(__context).get());
    #endif
    }
    
    ::IceInternal::ProxyHandle<ConsumePrescriptionRequest> ice_adapterId(const std::string& __id) const
    {
    #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
        typedef ::IceProxy::Ice::Object _Base;
        return dynamic_cast<ConsumePrescriptionRequest*>(_Base::ice_adapterId(__id).get());
    #else
        return dynamic_cast<ConsumePrescriptionRequest*>(::IceProxy::Ice::Object::ice_adapterId(__id).get());
    #endif
    }
    
    ::IceInternal::ProxyHandle<ConsumePrescriptionRequest> ice_endpoints(const ::Ice::EndpointSeq& __endpoints) const
    {
    #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
        typedef ::IceProxy::Ice::Object _Base;
        return dynamic_cast<ConsumePrescriptionRequest*>(_Base::ice_endpoints(__endpoints).get());
    #else
        return dynamic_cast<ConsumePrescriptionRequest*>(::IceProxy::Ice::Object::ice_endpoints(__endpoints).get());
    #endif
    }
    
    ::IceInternal::ProxyHandle<ConsumePrescriptionRequest> ice_locatorCacheTimeout(int __timeout) const
    {
    #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
        typedef ::IceProxy::Ice::Object _Base;
        return dynamic_cast<ConsumePrescriptionRequest*>(_Base::ice_locatorCacheTimeout(__timeout).get());
    #else
        return dynamic_cast<ConsumePrescriptionRequest*>(::IceProxy::Ice::Object::ice_locatorCacheTimeout(__timeout).get());
    #endif
    }
    
    ::IceInternal::ProxyHandle<ConsumePrescriptionRequest> ice_connectionCached(bool __cached) const
    {
    #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
        typedef ::IceProxy::Ice::Object _Base;
        return dynamic_cast<ConsumePrescriptionRequest*>(_Base::ice_connectionCached(__cached).get());
    #else
        return dynamic_cast<ConsumePrescriptionRequest*>(::IceProxy::Ice::Object::ice_connectionCached(__cached).get());
    #endif
    }
    
    ::IceInternal::ProxyHandle<ConsumePrescriptionRequest> ice_endpointSelection(::Ice::EndpointSelectionType __est) const
    {
    #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
        typedef ::IceProxy::Ice::Object _Base;
        return dynamic_cast<ConsumePrescriptionRequest*>(_Base::ice_endpointSelection(__est).get());
    #else
        return dynamic_cast<ConsumePrescriptionRequest*>(::IceProxy::Ice::Object::ice_endpointSelection(__est).get());
    #endif
    }
    
    ::IceInternal::ProxyHandle<ConsumePrescriptionRequest> ice_secure(bool __secure) const
    {
    #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
        typedef ::IceProxy::Ice::Object _Base;
        return dynamic_cast<ConsumePrescriptionRequest*>(_Base::ice_secure(__secure).get());
    #else
        return dynamic_cast<ConsumePrescriptionRequest*>(::IceProxy::Ice::Object::ice_secure(__secure).get());
    #endif
    }
    
    ::IceInternal::ProxyHandle<ConsumePrescriptionRequest> ice_preferSecure(bool __preferSecure) const
    {
    #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
        typedef ::IceProxy::Ice::Object _Base;
        return dynamic_cast<ConsumePrescriptionRequest*>(_Base::ice_preferSecure(__preferSecure).get());
    #else
        return dynamic_cast<ConsumePrescriptionRequest*>(::IceProxy::Ice::Object::ice_preferSecure(__preferSecure).get());
    #endif
    }
    
    ::IceInternal::ProxyHandle<ConsumePrescriptionRequest> ice_router(const ::Ice::RouterPrx& __router) const
    {
    #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
        typedef ::IceProxy::Ice::Object _Base;
        return dynamic_cast<ConsumePrescriptionRequest*>(_Base::ice_router(__router).get());
    #else
        return dynamic_cast<ConsumePrescriptionRequest*>(::IceProxy::Ice::Object::ice_router(__router).get());
    #endif
    }
    
    ::IceInternal::ProxyHandle<ConsumePrescriptionRequest> ice_locator(const ::Ice::LocatorPrx& __locator) const
    {
    #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
        typedef ::IceProxy::Ice::Object _Base;
        return dynamic_cast<ConsumePrescriptionRequest*>(_Base::ice_locator(__locator).get());
    #else
        return dynamic_cast<ConsumePrescriptionRequest*>(::IceProxy::Ice::Object::ice_locator(__locator).get());
    #endif
    }
    
    ::IceInternal::ProxyHandle<ConsumePrescriptionRequest> ice_collocationOptimized(bool __co) const
    {
    #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
        typedef ::IceProxy::Ice::Object _Base;
        return dynamic_cast<ConsumePrescriptionRequest*>(_Base::ice_collocationOptimized(__co).get());
    #else
        return dynamic_cast<ConsumePrescriptionRequest*>(::IceProxy::Ice::Object::ice_collocationOptimized(__co).get());
    #endif
    }
    
    ::IceInternal::ProxyHandle<ConsumePrescriptionRequest> ice_twoway() const
    {
    #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
        typedef ::IceProxy::Ice::Object _Base;
        return dynamic_cast<ConsumePrescriptionRequest*>(_Base::ice_twoway().get());
    #else
        return dynamic_cast<ConsumePrescriptionRequest*>(::IceProxy::Ice::Object::ice_twoway().get());
    #endif
    }
    
    ::IceInternal::ProxyHandle<ConsumePrescriptionRequest> ice_oneway() const
    {
    #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
        typedef ::IceProxy::Ice::Object _Base;
        return dynamic_cast<ConsumePrescriptionRequest*>(_Base::ice_oneway().get());
    #else
        return dynamic_cast<ConsumePrescriptionRequest*>(::IceProxy::Ice::Object::ice_oneway().get());
    #endif
    }
    
    ::IceInternal::ProxyHandle<ConsumePrescriptionRequest> ice_batchOneway() const
    {
    #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
        typedef ::IceProxy::Ice::Object _Base;
        return dynamic_cast<ConsumePrescriptionRequest*>(_Base::ice_batchOneway().get());
    #else
        return dynamic_cast<ConsumePrescriptionRequest*>(::IceProxy::Ice::Object::ice_batchOneway().get());
    #endif
    }
    
    ::IceInternal::ProxyHandle<ConsumePrescriptionRequest> ice_datagram() const
    {
    #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
        typedef ::IceProxy::Ice::Object _Base;
        return dynamic_cast<ConsumePrescriptionRequest*>(_Base::ice_datagram().get());
    #else
        return dynamic_cast<ConsumePrescriptionRequest*>(::IceProxy::Ice::Object::ice_datagram().get());
    #endif
    }
    
    ::IceInternal::ProxyHandle<ConsumePrescriptionRequest> ice_batchDatagram() const
    {
    #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
        typedef ::IceProxy::Ice::Object _Base;
        return dynamic_cast<ConsumePrescriptionRequest*>(_Base::ice_batchDatagram().get());
    #else
        return dynamic_cast<ConsumePrescriptionRequest*>(::IceProxy::Ice::Object::ice_batchDatagram().get());
    #endif
    }
    
    ::IceInternal::ProxyHandle<ConsumePrescriptionRequest> ice_compress(bool __compress) const
    {
    #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
        typedef ::IceProxy::Ice::Object _Base;
        return dynamic_cast<ConsumePrescriptionRequest*>(_Base::ice_compress(__compress).get());
    #else
        return dynamic_cast<ConsumePrescriptionRequest*>(::IceProxy::Ice::Object::ice_compress(__compress).get());
    #endif
    }
    
    ::IceInternal::ProxyHandle<ConsumePrescriptionRequest> ice_timeout(int __timeout) const
    {
    #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
        typedef ::IceProxy::Ice::Object _Base;
        return dynamic_cast<ConsumePrescriptionRequest*>(_Base::ice_timeout(__timeout).get());
    #else
        return dynamic_cast<ConsumePrescriptionRequest*>(::IceProxy::Ice::Object::ice_timeout(__timeout).get());
    #endif
    }
    
    ::IceInternal::ProxyHandle<ConsumePrescriptionRequest> ice_connectionId(const std::string& __id) const
    {
    #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
        typedef ::IceProxy::Ice::Object _Base;
        return dynamic_cast<ConsumePrescriptionRequest*>(_Base::ice_connectionId(__id).get());
    #else
        return dynamic_cast<ConsumePrescriptionRequest*>(::IceProxy::Ice::Object::ice_connectionId(__id).get());
    #endif
    }
    
    static const ::std::string& ice_staticId();

private: 

    virtual ::IceInternal::Handle< ::IceDelegateM::Ice::Object> __createDelegateM();
    virtual ::IceInternal::Handle< ::IceDelegateD::Ice::Object> __createDelegateD();
    virtual ::IceProxy::Ice::Object* __newInstance() const;
};

class ListDocumentsRequest : virtual public ::IceProxy::Ehr::ThirdPartyRequest
{
public:
    
    ::IceInternal::ProxyHandle<ListDocumentsRequest> ice_context(const ::Ice::Context& __context) const
    {
    #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
        typedef ::IceProxy::Ice::Object _Base;
        return dynamic_cast<ListDocumentsRequest*>(_Base::ice_context(__context).get());
    #else
        return dynamic_cast<ListDocumentsRequest*>(::IceProxy::Ice::Object::ice_context(__context).get());
    #endif
    }
    
    ::IceInternal::ProxyHandle<ListDocumentsRequest> ice_adapterId(const std::string& __id) const
    {
    #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
        typedef ::IceProxy::Ice::Object _Base;
        return dynamic_cast<ListDocumentsRequest*>(_Base::ice_adapterId(__id).get());
    #else
        return dynamic_cast<ListDocumentsRequest*>(::IceProxy::Ice::Object::ice_adapterId(__id).get());
    #endif
    }
    
    ::IceInternal::ProxyHandle<ListDocumentsRequest> ice_endpoints(const ::Ice::EndpointSeq& __endpoints) const
    {
    #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
        typedef ::IceProxy::Ice::Object _Base;
        return dynamic_cast<ListDocumentsRequest*>(_Base::ice_endpoints(__endpoints).get());
    #else
        return dynamic_cast<ListDocumentsRequest*>(::IceProxy::Ice::Object::ice_endpoints(__endpoints).get());
    #endif
    }
    
    ::IceInternal::ProxyHandle<ListDocumentsRequest> ice_locatorCacheTimeout(int __timeout) const
    {
    #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
        typedef ::IceProxy::Ice::Object _Base;
        return dynamic_cast<ListDocumentsRequest*>(_Base::ice_locatorCacheTimeout(__timeout).get());
    #else
        return dynamic_cast<ListDocumentsRequest*>(::IceProxy::Ice::Object::ice_locatorCacheTimeout(__timeout).get());
    #endif
    }
    
    ::IceInternal::ProxyHandle<ListDocumentsRequest> ice_connectionCached(bool __cached) const
    {
    #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
        typedef ::IceProxy::Ice::Object _Base;
        return dynamic_cast<ListDocumentsRequest*>(_Base::ice_connectionCached(__cached).get());
    #else
        return dynamic_cast<ListDocumentsRequest*>(::IceProxy::Ice::Object::ice_connectionCached(__cached).get());
    #endif
    }
    
    ::IceInternal::ProxyHandle<ListDocumentsRequest> ice_endpointSelection(::Ice::EndpointSelectionType __est) const
    {
    #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
        typedef ::IceProxy::Ice::Object _Base;
        return dynamic_cast<ListDocumentsRequest*>(_Base::ice_endpointSelection(__est).get());
    #else
        return dynamic_cast<ListDocumentsRequest*>(::IceProxy::Ice::Object::ice_endpointSelection(__est).get());
    #endif
    }
    
    ::IceInternal::ProxyHandle<ListDocumentsRequest> ice_secure(bool __secure) const
    {
    #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
        typedef ::IceProxy::Ice::Object _Base;
        return dynamic_cast<ListDocumentsRequest*>(_Base::ice_secure(__secure).get());
    #else
        return dynamic_cast<ListDocumentsRequest*>(::IceProxy::Ice::Object::ice_secure(__secure).get());
    #endif
    }
    
    ::IceInternal::ProxyHandle<ListDocumentsRequest> ice_preferSecure(bool __preferSecure) const
    {
    #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
        typedef ::IceProxy::Ice::Object _Base;
        return dynamic_cast<ListDocumentsRequest*>(_Base::ice_preferSecure(__preferSecure).get());
    #else
        return dynamic_cast<ListDocumentsRequest*>(::IceProxy::Ice::Object::ice_preferSecure(__preferSecure).get());
    #endif
    }
    
    ::IceInternal::ProxyHandle<ListDocumentsRequest> ice_router(const ::Ice::RouterPrx& __router) const
    {
    #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
        typedef ::IceProxy::Ice::Object _Base;
        return dynamic_cast<ListDocumentsRequest*>(_Base::ice_router(__router).get());
    #else
        return dynamic_cast<ListDocumentsRequest*>(::IceProxy::Ice::Object::ice_router(__router).get());
    #endif
    }
    
    ::IceInternal::ProxyHandle<ListDocumentsRequest> ice_locator(const ::Ice::LocatorPrx& __locator) const
    {
    #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
        typedef ::IceProxy::Ice::Object _Base;
        return dynamic_cast<ListDocumentsRequest*>(_Base::ice_locator(__locator).get());
    #else
        return dynamic_cast<ListDocumentsRequest*>(::IceProxy::Ice::Object::ice_locator(__locator).get());
    #endif
    }
    
    ::IceInternal::ProxyHandle<ListDocumentsRequest> ice_collocationOptimized(bool __co) const
    {
    #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
        typedef ::IceProxy::Ice::Object _Base;
        return dynamic_cast<ListDocumentsRequest*>(_Base::ice_collocationOptimized(__co).get());
    #else
        return dynamic_cast<ListDocumentsRequest*>(::IceProxy::Ice::Object::ice_collocationOptimized(__co).get());
    #endif
    }
    
    ::IceInternal::ProxyHandle<ListDocumentsRequest> ice_twoway() const
    {
    #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
        typedef ::IceProxy::Ice::Object _Base;
        return dynamic_cast<ListDocumentsRequest*>(_Base::ice_twoway().get());
    #else
        return dynamic_cast<ListDocumentsRequest*>(::IceProxy::Ice::Object::ice_twoway().get());
    #endif
    }
    
    ::IceInternal::ProxyHandle<ListDocumentsRequest> ice_oneway() const
    {
    #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
        typedef ::IceProxy::Ice::Object _Base;
        return dynamic_cast<ListDocumentsRequest*>(_Base::ice_oneway().get());
    #else
        return dynamic_cast<ListDocumentsRequest*>(::IceProxy::Ice::Object::ice_oneway().get());
    #endif
    }
    
    ::IceInternal::ProxyHandle<ListDocumentsRequest> ice_batchOneway() const
    {
    #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
        typedef ::IceProxy::Ice::Object _Base;
        return dynamic_cast<ListDocumentsRequest*>(_Base::ice_batchOneway().get());
    #else
        return dynamic_cast<ListDocumentsRequest*>(::IceProxy::Ice::Object::ice_batchOneway().get());
    #endif
    }
    
    ::IceInternal::ProxyHandle<ListDocumentsRequest> ice_datagram() const
    {
    #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
        typedef ::IceProxy::Ice::Object _Base;
        return dynamic_cast<ListDocumentsRequest*>(_Base::ice_datagram().get());
    #else
        return dynamic_cast<ListDocumentsRequest*>(::IceProxy::Ice::Object::ice_datagram().get());
    #endif
    }
    
    ::IceInternal::ProxyHandle<ListDocumentsRequest> ice_batchDatagram() const
    {
    #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
        typedef ::IceProxy::Ice::Object _Base;
        return dynamic_cast<ListDocumentsRequest*>(_Base::ice_batchDatagram().get());
    #else
        return dynamic_cast<ListDocumentsRequest*>(::IceProxy::Ice::Object::ice_batchDatagram().get());
    #endif
    }
    
    ::IceInternal::ProxyHandle<ListDocumentsRequest> ice_compress(bool __compress) const
    {
    #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
        typedef ::IceProxy::Ice::Object _Base;
        return dynamic_cast<ListDocumentsRequest*>(_Base::ice_compress(__compress).get());
    #else
        return dynamic_cast<ListDocumentsRequest*>(::IceProxy::Ice::Object::ice_compress(__compress).get());
    #endif
    }
    
    ::IceInternal::ProxyHandle<ListDocumentsRequest> ice_timeout(int __timeout) const
    {
    #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
        typedef ::IceProxy::Ice::Object _Base;
        return dynamic_cast<ListDocumentsRequest*>(_Base::ice_timeout(__timeout).get());
    #else
        return dynamic_cast<ListDocumentsRequest*>(::IceProxy::Ice::Object::ice_timeout(__timeout).get());
    #endif
    }
    
    ::IceInternal::ProxyHandle<ListDocumentsRequest> ice_connectionId(const std::string& __id) const
    {
    #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
        typedef ::IceProxy::Ice::Object _Base;
        return dynamic_cast<ListDocumentsRequest*>(_Base::ice_connectionId(__id).get());
    #else
        return dynamic_cast<ListDocumentsRequest*>(::IceProxy::Ice::Object::ice_connectionId(__id).get());
    #endif
    }
    
    static const ::std::string& ice_staticId();

private: 

    virtual ::IceInternal::Handle< ::IceDelegateM::Ice::Object> __createDelegateM();
    virtual ::IceInternal::Handle< ::IceDelegateD::Ice::Object> __createDelegateD();
    virtual ::IceProxy::Ice::Object* __newInstance() const;
};

class FindDocumentsRequest : virtual public ::IceProxy::Ehr::ThirdPartyRequest
{
public:
    
    ::IceInternal::ProxyHandle<FindDocumentsRequest> ice_context(const ::Ice::Context& __context) const
    {
    #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
        typedef ::IceProxy::Ice::Object _Base;
        return dynamic_cast<FindDocumentsRequest*>(_Base::ice_context(__context).get());
    #else
        return dynamic_cast<FindDocumentsRequest*>(::IceProxy::Ice::Object::ice_context(__context).get());
    #endif
    }
    
    ::IceInternal::ProxyHandle<FindDocumentsRequest> ice_adapterId(const std::string& __id) const
    {
    #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
        typedef ::IceProxy::Ice::Object _Base;
        return dynamic_cast<FindDocumentsRequest*>(_Base::ice_adapterId(__id).get());
    #else
        return dynamic_cast<FindDocumentsRequest*>(::IceProxy::Ice::Object::ice_adapterId(__id).get());
    #endif
    }
    
    ::IceInternal::ProxyHandle<FindDocumentsRequest> ice_endpoints(const ::Ice::EndpointSeq& __endpoints) const
    {
    #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
        typedef ::IceProxy::Ice::Object _Base;
        return dynamic_cast<FindDocumentsRequest*>(_Base::ice_endpoints(__endpoints).get());
    #else
        return dynamic_cast<FindDocumentsRequest*>(::IceProxy::Ice::Object::ice_endpoints(__endpoints).get());
    #endif
    }
    
    ::IceInternal::ProxyHandle<FindDocumentsRequest> ice_locatorCacheTimeout(int __timeout) const
    {
    #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
        typedef ::IceProxy::Ice::Object _Base;
        return dynamic_cast<FindDocumentsRequest*>(_Base::ice_locatorCacheTimeout(__timeout).get());
    #else
        return dynamic_cast<FindDocumentsRequest*>(::IceProxy::Ice::Object::ice_locatorCacheTimeout(__timeout).get());
    #endif
    }
    
    ::IceInternal::ProxyHandle<FindDocumentsRequest> ice_connectionCached(bool __cached) const
    {
    #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
        typedef ::IceProxy::Ice::Object _Base;
        return dynamic_cast<FindDocumentsRequest*>(_Base::ice_connectionCached(__cached).get());
    #else
        return dynamic_cast<FindDocumentsRequest*>(::IceProxy::Ice::Object::ice_connectionCached(__cached).get());
    #endif
    }
    
    ::IceInternal::ProxyHandle<FindDocumentsRequest> ice_endpointSelection(::Ice::EndpointSelectionType __est) const
    {
    #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
        typedef ::IceProxy::Ice::Object _Base;
        return dynamic_cast<FindDocumentsRequest*>(_Base::ice_endpointSelection(__est).get());
    #else
        return dynamic_cast<FindDocumentsRequest*>(::IceProxy::Ice::Object::ice_endpointSelection(__est).get());
    #endif
    }
    
    ::IceInternal::ProxyHandle<FindDocumentsRequest> ice_secure(bool __secure) const
    {
    #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
        typedef ::IceProxy::Ice::Object _Base;
        return dynamic_cast<FindDocumentsRequest*>(_Base::ice_secure(__secure).get());
    #else
        return dynamic_cast<FindDocumentsRequest*>(::IceProxy::Ice::Object::ice_secure(__secure).get());
    #endif
    }
    
    ::IceInternal::ProxyHandle<FindDocumentsRequest> ice_preferSecure(bool __preferSecure) const
    {
    #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
        typedef ::IceProxy::Ice::Object _Base;
        return dynamic_cast<FindDocumentsRequest*>(_Base::ice_preferSecure(__preferSecure).get());
    #else
        return dynamic_cast<FindDocumentsRequest*>(::IceProxy::Ice::Object::ice_preferSecure(__preferSecure).get());
    #endif
    }
    
    ::IceInternal::ProxyHandle<FindDocumentsRequest> ice_router(const ::Ice::RouterPrx& __router) const
    {
    #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
        typedef ::IceProxy::Ice::Object _Base;
        return dynamic_cast<FindDocumentsRequest*>(_Base::ice_router(__router).get());
    #else
        return dynamic_cast<FindDocumentsRequest*>(::IceProxy::Ice::Object::ice_router(__router).get());
    #endif
    }
    
    ::IceInternal::ProxyHandle<FindDocumentsRequest> ice_locator(const ::Ice::LocatorPrx& __locator) const
    {
    #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
        typedef ::IceProxy::Ice::Object _Base;
        return dynamic_cast<FindDocumentsRequest*>(_Base::ice_locator(__locator).get());
    #else
        return dynamic_cast<FindDocumentsRequest*>(::IceProxy::Ice::Object::ice_locator(__locator).get());
    #endif
    }
    
    ::IceInternal::ProxyHandle<FindDocumentsRequest> ice_collocationOptimized(bool __co) const
    {
    #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
        typedef ::IceProxy::Ice::Object _Base;
        return dynamic_cast<FindDocumentsRequest*>(_Base::ice_collocationOptimized(__co).get());
    #else
        return dynamic_cast<FindDocumentsRequest*>(::IceProxy::Ice::Object::ice_collocationOptimized(__co).get());
    #endif
    }
    
    ::IceInternal::ProxyHandle<FindDocumentsRequest> ice_twoway() const
    {
    #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
        typedef ::IceProxy::Ice::Object _Base;
        return dynamic_cast<FindDocumentsRequest*>(_Base::ice_twoway().get());
    #else
        return dynamic_cast<FindDocumentsRequest*>(::IceProxy::Ice::Object::ice_twoway().get());
    #endif
    }
    
    ::IceInternal::ProxyHandle<FindDocumentsRequest> ice_oneway() const
    {
    #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
        typedef ::IceProxy::Ice::Object _Base;
        return dynamic_cast<FindDocumentsRequest*>(_Base::ice_oneway().get());
    #else
        return dynamic_cast<FindDocumentsRequest*>(::IceProxy::Ice::Object::ice_oneway().get());
    #endif
    }
    
    ::IceInternal::ProxyHandle<FindDocumentsRequest> ice_batchOneway() const
    {
    #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
        typedef ::IceProxy::Ice::Object _Base;
        return dynamic_cast<FindDocumentsRequest*>(_Base::ice_batchOneway().get());
    #else
        return dynamic_cast<FindDocumentsRequest*>(::IceProxy::Ice::Object::ice_batchOneway().get());
    #endif
    }
    
    ::IceInternal::ProxyHandle<FindDocumentsRequest> ice_datagram() const
    {
    #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
        typedef ::IceProxy::Ice::Object _Base;
        return dynamic_cast<FindDocumentsRequest*>(_Base::ice_datagram().get());
    #else
        return dynamic_cast<FindDocumentsRequest*>(::IceProxy::Ice::Object::ice_datagram().get());
    #endif
    }
    
    ::IceInternal::ProxyHandle<FindDocumentsRequest> ice_batchDatagram() const
    {
    #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
        typedef ::IceProxy::Ice::Object _Base;
        return dynamic_cast<FindDocumentsRequest*>(_Base::ice_batchDatagram().get());
    #else
        return dynamic_cast<FindDocumentsRequest*>(::IceProxy::Ice::Object::ice_batchDatagram().get());
    #endif
    }
    
    ::IceInternal::ProxyHandle<FindDocumentsRequest> ice_compress(bool __compress) const
    {
    #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
        typedef ::IceProxy::Ice::Object _Base;
        return dynamic_cast<FindDocumentsRequest*>(_Base::ice_compress(__compress).get());
    #else
        return dynamic_cast<FindDocumentsRequest*>(::IceProxy::Ice::Object::ice_compress(__compress).get());
    #endif
    }
    
    ::IceInternal::ProxyHandle<FindDocumentsRequest> ice_timeout(int __timeout) const
    {
    #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
        typedef ::IceProxy::Ice::Object _Base;
        return dynamic_cast<FindDocumentsRequest*>(_Base::ice_timeout(__timeout).get());
    #else
        return dynamic_cast<FindDocumentsRequest*>(::IceProxy::Ice::Object::ice_timeout(__timeout).get());
    #endif
    }
    
    ::IceInternal::ProxyHandle<FindDocumentsRequest> ice_connectionId(const std::string& __id) const
    {
    #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
        typedef ::IceProxy::Ice::Object _Base;
        return dynamic_cast<FindDocumentsRequest*>(_Base::ice_connectionId(__id).get());
    #else
        return dynamic_cast<FindDocumentsRequest*>(::IceProxy::Ice::Object::ice_connectionId(__id).get());
    #endif
    }
    
    static const ::std::string& ice_staticId();

private: 

    virtual ::IceInternal::Handle< ::IceDelegateM::Ice::Object> __createDelegateM();
    virtual ::IceInternal::Handle< ::IceDelegateD::Ice::Object> __createDelegateD();
    virtual ::IceProxy::Ice::Object* __newInstance() const;
};

class CreatePermissionRequest : virtual public ::IceProxy::Ehr::Request
{
public:
    
    ::IceInternal::ProxyHandle<CreatePermissionRequest> ice_context(const ::Ice::Context& __context) const
    {
    #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
        typedef ::IceProxy::Ice::Object _Base;
        return dynamic_cast<CreatePermissionRequest*>(_Base::ice_context(__context).get());
    #else
        return dynamic_cast<CreatePermissionRequest*>(::IceProxy::Ice::Object::ice_context(__context).get());
    #endif
    }
    
    ::IceInternal::ProxyHandle<CreatePermissionRequest> ice_adapterId(const std::string& __id) const
    {
    #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
        typedef ::IceProxy::Ice::Object _Base;
        return dynamic_cast<CreatePermissionRequest*>(_Base::ice_adapterId(__id).get());
    #else
        return dynamic_cast<CreatePermissionRequest*>(::IceProxy::Ice::Object::ice_adapterId(__id).get());
    #endif
    }
    
    ::IceInternal::ProxyHandle<CreatePermissionRequest> ice_endpoints(const ::Ice::EndpointSeq& __endpoints) const
    {
    #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
        typedef ::IceProxy::Ice::Object _Base;
        return dynamic_cast<CreatePermissionRequest*>(_Base::ice_endpoints(__endpoints).get());
    #else
        return dynamic_cast<CreatePermissionRequest*>(::IceProxy::Ice::Object::ice_endpoints(__endpoints).get());
    #endif
    }
    
    ::IceInternal::ProxyHandle<CreatePermissionRequest> ice_locatorCacheTimeout(int __timeout) const
    {
    #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
        typedef ::IceProxy::Ice::Object _Base;
        return dynamic_cast<CreatePermissionRequest*>(_Base::ice_locatorCacheTimeout(__timeout).get());
    #else
        return dynamic_cast<CreatePermissionRequest*>(::IceProxy::Ice::Object::ice_locatorCacheTimeout(__timeout).get());
    #endif
    }
    
    ::IceInternal::ProxyHandle<CreatePermissionRequest> ice_connectionCached(bool __cached) const
    {
    #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
        typedef ::IceProxy::Ice::Object _Base;
        return dynamic_cast<CreatePermissionRequest*>(_Base::ice_connectionCached(__cached).get());
    #else
        return dynamic_cast<CreatePermissionRequest*>(::IceProxy::Ice::Object::ice_connectionCached(__cached).get());
    #endif
    }
    
    ::IceInternal::ProxyHandle<CreatePermissionRequest> ice_endpointSelection(::Ice::EndpointSelectionType __est) const
    {
    #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
        typedef ::IceProxy::Ice::Object _Base;
        return dynamic_cast<CreatePermissionRequest*>(_Base::ice_endpointSelection(__est).get());
    #else
        return dynamic_cast<CreatePermissionRequest*>(::IceProxy::Ice::Object::ice_endpointSelection(__est).get());
    #endif
    }
    
    ::IceInternal::ProxyHandle<CreatePermissionRequest> ice_secure(bool __secure) const
    {
    #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
        typedef ::IceProxy::Ice::Object _Base;
        return dynamic_cast<CreatePermissionRequest*>(_Base::ice_secure(__secure).get());
    #else
        return dynamic_cast<CreatePermissionRequest*>(::IceProxy::Ice::Object::ice_secure(__secure).get());
    #endif
    }
    
    ::IceInternal::ProxyHandle<CreatePermissionRequest> ice_preferSecure(bool __preferSecure) const
    {
    #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
        typedef ::IceProxy::Ice::Object _Base;
        return dynamic_cast<CreatePermissionRequest*>(_Base::ice_preferSecure(__preferSecure).get());
    #else
        return dynamic_cast<CreatePermissionRequest*>(::IceProxy::Ice::Object::ice_preferSecure(__preferSecure).get());
    #endif
    }
    
    ::IceInternal::ProxyHandle<CreatePermissionRequest> ice_router(const ::Ice::RouterPrx& __router) const
    {
    #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
        typedef ::IceProxy::Ice::Object _Base;
        return dynamic_cast<CreatePermissionRequest*>(_Base::ice_router(__router).get());
    #else
        return dynamic_cast<CreatePermissionRequest*>(::IceProxy::Ice::Object::ice_router(__router).get());
    #endif
    }
    
    ::IceInternal::ProxyHandle<CreatePermissionRequest> ice_locator(const ::Ice::LocatorPrx& __locator) const
    {
    #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
        typedef ::IceProxy::Ice::Object _Base;
        return dynamic_cast<CreatePermissionRequest*>(_Base::ice_locator(__locator).get());
    #else
        return dynamic_cast<CreatePermissionRequest*>(::IceProxy::Ice::Object::ice_locator(__locator).get());
    #endif
    }
    
    ::IceInternal::ProxyHandle<CreatePermissionRequest> ice_collocationOptimized(bool __co) const
    {
    #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
        typedef ::IceProxy::Ice::Object _Base;
        return dynamic_cast<CreatePermissionRequest*>(_Base::ice_collocationOptimized(__co).get());
    #else
        return dynamic_cast<CreatePermissionRequest*>(::IceProxy::Ice::Object::ice_collocationOptimized(__co).get());
    #endif
    }
    
    ::IceInternal::ProxyHandle<CreatePermissionRequest> ice_twoway() const
    {
    #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
        typedef ::IceProxy::Ice::Object _Base;
        return dynamic_cast<CreatePermissionRequest*>(_Base::ice_twoway().get());
    #else
        return dynamic_cast<CreatePermissionRequest*>(::IceProxy::Ice::Object::ice_twoway().get());
    #endif
    }
    
    ::IceInternal::ProxyHandle<CreatePermissionRequest> ice_oneway() const
    {
    #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
        typedef ::IceProxy::Ice::Object _Base;
        return dynamic_cast<CreatePermissionRequest*>(_Base::ice_oneway().get());
    #else
        return dynamic_cast<CreatePermissionRequest*>(::IceProxy::Ice::Object::ice_oneway().get());
    #endif
    }
    
    ::IceInternal::ProxyHandle<CreatePermissionRequest> ice_batchOneway() const
    {
    #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
        typedef ::IceProxy::Ice::Object _Base;
        return dynamic_cast<CreatePermissionRequest*>(_Base::ice_batchOneway().get());
    #else
        return dynamic_cast<CreatePermissionRequest*>(::IceProxy::Ice::Object::ice_batchOneway().get());
    #endif
    }
    
    ::IceInternal::ProxyHandle<CreatePermissionRequest> ice_datagram() const
    {
    #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
        typedef ::IceProxy::Ice::Object _Base;
        return dynamic_cast<CreatePermissionRequest*>(_Base::ice_datagram().get());
    #else
        return dynamic_cast<CreatePermissionRequest*>(::IceProxy::Ice::Object::ice_datagram().get());
    #endif
    }
    
    ::IceInternal::ProxyHandle<CreatePermissionRequest> ice_batchDatagram() const
    {
    #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
        typedef ::IceProxy::Ice::Object _Base;
        return dynamic_cast<CreatePermissionRequest*>(_Base::ice_batchDatagram().get());
    #else
        return dynamic_cast<CreatePermissionRequest*>(::IceProxy::Ice::Object::ice_batchDatagram().get());
    #endif
    }
    
    ::IceInternal::ProxyHandle<CreatePermissionRequest> ice_compress(bool __compress) const
    {
    #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
        typedef ::IceProxy::Ice::Object _Base;
        return dynamic_cast<CreatePermissionRequest*>(_Base::ice_compress(__compress).get());
    #else
        return dynamic_cast<CreatePermissionRequest*>(::IceProxy::Ice::Object::ice_compress(__compress).get());
    #endif
    }
    
    ::IceInternal::ProxyHandle<CreatePermissionRequest> ice_timeout(int __timeout) const
    {
    #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
        typedef ::IceProxy::Ice::Object _Base;
        return dynamic_cast<CreatePermissionRequest*>(_Base::ice_timeout(__timeout).get());
    #else
        return dynamic_cast<CreatePermissionRequest*>(::IceProxy::Ice::Object::ice_timeout(__timeout).get());
    #endif
    }
    
    ::IceInternal::ProxyHandle<CreatePermissionRequest> ice_connectionId(const std::string& __id) const
    {
    #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
        typedef ::IceProxy::Ice::Object _Base;
        return dynamic_cast<CreatePermissionRequest*>(_Base::ice_connectionId(__id).get());
    #else
        return dynamic_cast<CreatePermissionRequest*>(::IceProxy::Ice::Object::ice_connectionId(__id).get());
    #endif
    }
    
    static const ::std::string& ice_staticId();

private: 

    virtual ::IceInternal::Handle< ::IceDelegateM::Ice::Object> __createDelegateM();
    virtual ::IceInternal::Handle< ::IceDelegateD::Ice::Object> __createDelegateD();
    virtual ::IceProxy::Ice::Object* __newInstance() const;
};

class SetDefaultAccessRequest : virtual public ::IceProxy::Ehr::Request
{
public:
    
    ::IceInternal::ProxyHandle<SetDefaultAccessRequest> ice_context(const ::Ice::Context& __context) const
    {
    #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
        typedef ::IceProxy::Ice::Object _Base;
        return dynamic_cast<SetDefaultAccessRequest*>(_Base::ice_context(__context).get());
    #else
        return dynamic_cast<SetDefaultAccessRequest*>(::IceProxy::Ice::Object::ice_context(__context).get());
    #endif
    }
    
    ::IceInternal::ProxyHandle<SetDefaultAccessRequest> ice_adapterId(const std::string& __id) const
    {
    #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
        typedef ::IceProxy::Ice::Object _Base;
        return dynamic_cast<SetDefaultAccessRequest*>(_Base::ice_adapterId(__id).get());
    #else
        return dynamic_cast<SetDefaultAccessRequest*>(::IceProxy::Ice::Object::ice_adapterId(__id).get());
    #endif
    }
    
    ::IceInternal::ProxyHandle<SetDefaultAccessRequest> ice_endpoints(const ::Ice::EndpointSeq& __endpoints) const
    {
    #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
        typedef ::IceProxy::Ice::Object _Base;
        return dynamic_cast<SetDefaultAccessRequest*>(_Base::ice_endpoints(__endpoints).get());
    #else
        return dynamic_cast<SetDefaultAccessRequest*>(::IceProxy::Ice::Object::ice_endpoints(__endpoints).get());
    #endif
    }
    
    ::IceInternal::ProxyHandle<SetDefaultAccessRequest> ice_locatorCacheTimeout(int __timeout) const
    {
    #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
        typedef ::IceProxy::Ice::Object _Base;
        return dynamic_cast<SetDefaultAccessRequest*>(_Base::ice_locatorCacheTimeout(__timeout).get());
    #else
        return dynamic_cast<SetDefaultAccessRequest*>(::IceProxy::Ice::Object::ice_locatorCacheTimeout(__timeout).get());
    #endif
    }
    
    ::IceInternal::ProxyHandle<SetDefaultAccessRequest> ice_connectionCached(bool __cached) const
    {
    #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
        typedef ::IceProxy::Ice::Object _Base;
        return dynamic_cast<SetDefaultAccessRequest*>(_Base::ice_connectionCached(__cached).get());
    #else
        return dynamic_cast<SetDefaultAccessRequest*>(::IceProxy::Ice::Object::ice_connectionCached(__cached).get());
    #endif
    }
    
    ::IceInternal::ProxyHandle<SetDefaultAccessRequest> ice_endpointSelection(::Ice::EndpointSelectionType __est) const
    {
    #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
        typedef ::IceProxy::Ice::Object _Base;
        return dynamic_cast<SetDefaultAccessRequest*>(_Base::ice_endpointSelection(__est).get());
    #else
        return dynamic_cast<SetDefaultAccessRequest*>(::IceProxy::Ice::Object::ice_endpointSelection(__est).get());
    #endif
    }
    
    ::IceInternal::ProxyHandle<SetDefaultAccessRequest> ice_secure(bool __secure) const
    {
    #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
        typedef ::IceProxy::Ice::Object _Base;
        return dynamic_cast<SetDefaultAccessRequest*>(_Base::ice_secure(__secure).get());
    #else
        return dynamic_cast<SetDefaultAccessRequest*>(::IceProxy::Ice::Object::ice_secure(__secure).get());
    #endif
    }
    
    ::IceInternal::ProxyHandle<SetDefaultAccessRequest> ice_preferSecure(bool __preferSecure) const
    {
    #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
        typedef ::IceProxy::Ice::Object _Base;
        return dynamic_cast<SetDefaultAccessRequest*>(_Base::ice_preferSecure(__preferSecure).get());
    #else
        return dynamic_cast<SetDefaultAccessRequest*>(::IceProxy::Ice::Object::ice_preferSecure(__preferSecure).get());
    #endif
    }
    
    ::IceInternal::ProxyHandle<SetDefaultAccessRequest> ice_router(const ::Ice::RouterPrx& __router) const
    {
    #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
        typedef ::IceProxy::Ice::Object _Base;
        return dynamic_cast<SetDefaultAccessRequest*>(_Base::ice_router(__router).get());
    #else
        return dynamic_cast<SetDefaultAccessRequest*>(::IceProxy::Ice::Object::ice_router(__router).get());
    #endif
    }
    
    ::IceInternal::ProxyHandle<SetDefaultAccessRequest> ice_locator(const ::Ice::LocatorPrx& __locator) const
    {
    #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
        typedef ::IceProxy::Ice::Object _Base;
        return dynamic_cast<SetDefaultAccessRequest*>(_Base::ice_locator(__locator).get());
    #else
        return dynamic_cast<SetDefaultAccessRequest*>(::IceProxy::Ice::Object::ice_locator(__locator).get());
    #endif
    }
    
    ::IceInternal::ProxyHandle<SetDefaultAccessRequest> ice_collocationOptimized(bool __co) const
    {
    #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
        typedef ::IceProxy::Ice::Object _Base;
        return dynamic_cast<SetDefaultAccessRequest*>(_Base::ice_collocationOptimized(__co).get());
    #else
        return dynamic_cast<SetDefaultAccessRequest*>(::IceProxy::Ice::Object::ice_collocationOptimized(__co).get());
    #endif
    }
    
    ::IceInternal::ProxyHandle<SetDefaultAccessRequest> ice_twoway() const
    {
    #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
        typedef ::IceProxy::Ice::Object _Base;
        return dynamic_cast<SetDefaultAccessRequest*>(_Base::ice_twoway().get());
    #else
        return dynamic_cast<SetDefaultAccessRequest*>(::IceProxy::Ice::Object::ice_twoway().get());
    #endif
    }
    
    ::IceInternal::ProxyHandle<SetDefaultAccessRequest> ice_oneway() const
    {
    #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
        typedef ::IceProxy::Ice::Object _Base;
        return dynamic_cast<SetDefaultAccessRequest*>(_Base::ice_oneway().get());
    #else
        return dynamic_cast<SetDefaultAccessRequest*>(::IceProxy::Ice::Object::ice_oneway().get());
    #endif
    }
    
    ::IceInternal::ProxyHandle<SetDefaultAccessRequest> ice_batchOneway() const
    {
    #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
        typedef ::IceProxy::Ice::Object _Base;
        return dynamic_cast<SetDefaultAccessRequest*>(_Base::ice_batchOneway().get());
    #else
        return dynamic_cast<SetDefaultAccessRequest*>(::IceProxy::Ice::Object::ice_batchOneway().get());
    #endif
    }
    
    ::IceInternal::ProxyHandle<SetDefaultAccessRequest> ice_datagram() const
    {
    #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
        typedef ::IceProxy::Ice::Object _Base;
        return dynamic_cast<SetDefaultAccessRequest*>(_Base::ice_datagram().get());
    #else
        return dynamic_cast<SetDefaultAccessRequest*>(::IceProxy::Ice::Object::ice_datagram().get());
    #endif
    }
    
    ::IceInternal::ProxyHandle<SetDefaultAccessRequest> ice_batchDatagram() const
    {
    #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
        typedef ::IceProxy::Ice::Object _Base;
        return dynamic_cast<SetDefaultAccessRequest*>(_Base::ice_batchDatagram().get());
    #else
        return dynamic_cast<SetDefaultAccessRequest*>(::IceProxy::Ice::Object::ice_batchDatagram().get());
    #endif
    }
    
    ::IceInternal::ProxyHandle<SetDefaultAccessRequest> ice_compress(bool __compress) const
    {
    #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
        typedef ::IceProxy::Ice::Object _Base;
        return dynamic_cast<SetDefaultAccessRequest*>(_Base::ice_compress(__compress).get());
    #else
        return dynamic_cast<SetDefaultAccessRequest*>(::IceProxy::Ice::Object::ice_compress(__compress).get());
    #endif
    }
    
    ::IceInternal::ProxyHandle<SetDefaultAccessRequest> ice_timeout(int __timeout) const
    {
    #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
        typedef ::IceProxy::Ice::Object _Base;
        return dynamic_cast<SetDefaultAccessRequest*>(_Base::ice_timeout(__timeout).get());
    #else
        return dynamic_cast<SetDefaultAccessRequest*>(::IceProxy::Ice::Object::ice_timeout(__timeout).get());
    #endif
    }
    
    ::IceInternal::ProxyHandle<SetDefaultAccessRequest> ice_connectionId(const std::string& __id) const
    {
    #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
        typedef ::IceProxy::Ice::Object _Base;
        return dynamic_cast<SetDefaultAccessRequest*>(_Base::ice_connectionId(__id).get());
    #else
        return dynamic_cast<SetDefaultAccessRequest*>(::IceProxy::Ice::Object::ice_connectionId(__id).get());
    #endif
    }
    
    static const ::std::string& ice_staticId();

private: 

    virtual ::IceInternal::Handle< ::IceDelegateM::Ice::Object> __createDelegateM();
    virtual ::IceInternal::Handle< ::IceDelegateD::Ice::Object> __createDelegateD();
    virtual ::IceProxy::Ice::Object* __newInstance() const;
};

class ListPermissionsRequest : virtual public ::IceProxy::Ehr::Request
{
public:
    
    ::IceInternal::ProxyHandle<ListPermissionsRequest> ice_context(const ::Ice::Context& __context) const
    {
    #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
        typedef ::IceProxy::Ice::Object _Base;
        return dynamic_cast<ListPermissionsRequest*>(_Base::ice_context(__context).get());
    #else
        return dynamic_cast<ListPermissionsRequest*>(::IceProxy::Ice::Object::ice_context(__context).get());
    #endif
    }
    
    ::IceInternal::ProxyHandle<ListPermissionsRequest> ice_adapterId(const std::string& __id) const
    {
    #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
        typedef ::IceProxy::Ice::Object _Base;
        return dynamic_cast<ListPermissionsRequest*>(_Base::ice_adapterId(__id).get());
    #else
        return dynamic_cast<ListPermissionsRequest*>(::IceProxy::Ice::Object::ice_adapterId(__id).get());
    #endif
    }
    
    ::IceInternal::ProxyHandle<ListPermissionsRequest> ice_endpoints(const ::Ice::EndpointSeq& __endpoints) const
    {
    #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
        typedef ::IceProxy::Ice::Object _Base;
        return dynamic_cast<ListPermissionsRequest*>(_Base::ice_endpoints(__endpoints).get());
    #else
        return dynamic_cast<ListPermissionsRequest*>(::IceProxy::Ice::Object::ice_endpoints(__endpoints).get());
    #endif
    }
    
    ::IceInternal::ProxyHandle<ListPermissionsRequest> ice_locatorCacheTimeout(int __timeout) const
    {
    #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
        typedef ::IceProxy::Ice::Object _Base;
        return dynamic_cast<ListPermissionsRequest*>(_Base::ice_locatorCacheTimeout(__timeout).get());
    #else
        return dynamic_cast<ListPermissionsRequest*>(::IceProxy::Ice::Object::ice_locatorCacheTimeout(__timeout).get());
    #endif
    }
    
    ::IceInternal::ProxyHandle<ListPermissionsRequest> ice_connectionCached(bool __cached) const
    {
    #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
        typedef ::IceProxy::Ice::Object _Base;
        return dynamic_cast<ListPermissionsRequest*>(_Base::ice_connectionCached(__cached).get());
    #else
        return dynamic_cast<ListPermissionsRequest*>(::IceProxy::Ice::Object::ice_connectionCached(__cached).get());
    #endif
    }
    
    ::IceInternal::ProxyHandle<ListPermissionsRequest> ice_endpointSelection(::Ice::EndpointSelectionType __est) const
    {
    #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
        typedef ::IceProxy::Ice::Object _Base;
        return dynamic_cast<ListPermissionsRequest*>(_Base::ice_endpointSelection(__est).get());
    #else
        return dynamic_cast<ListPermissionsRequest*>(::IceProxy::Ice::Object::ice_endpointSelection(__est).get());
    #endif
    }
    
    ::IceInternal::ProxyHandle<ListPermissionsRequest> ice_secure(bool __secure) const
    {
    #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
        typedef ::IceProxy::Ice::Object _Base;
        return dynamic_cast<ListPermissionsRequest*>(_Base::ice_secure(__secure).get());
    #else
        return dynamic_cast<ListPermissionsRequest*>(::IceProxy::Ice::Object::ice_secure(__secure).get());
    #endif
    }
    
    ::IceInternal::ProxyHandle<ListPermissionsRequest> ice_preferSecure(bool __preferSecure) const
    {
    #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
        typedef ::IceProxy::Ice::Object _Base;
        return dynamic_cast<ListPermissionsRequest*>(_Base::ice_preferSecure(__preferSecure).get());
    #else
        return dynamic_cast<ListPermissionsRequest*>(::IceProxy::Ice::Object::ice_preferSecure(__preferSecure).get());
    #endif
    }
    
    ::IceInternal::ProxyHandle<ListPermissionsRequest> ice_router(const ::Ice::RouterPrx& __router) const
    {
    #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
        typedef ::IceProxy::Ice::Object _Base;
        return dynamic_cast<ListPermissionsRequest*>(_Base::ice_router(__router).get());
    #else
        return dynamic_cast<ListPermissionsRequest*>(::IceProxy::Ice::Object::ice_router(__router).get());
    #endif
    }
    
    ::IceInternal::ProxyHandle<ListPermissionsRequest> ice_locator(const ::Ice::LocatorPrx& __locator) const
    {
    #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
        typedef ::IceProxy::Ice::Object _Base;
        return dynamic_cast<ListPermissionsRequest*>(_Base::ice_locator(__locator).get());
    #else
        return dynamic_cast<ListPermissionsRequest*>(::IceProxy::Ice::Object::ice_locator(__locator).get());
    #endif
    }
    
    ::IceInternal::ProxyHandle<ListPermissionsRequest> ice_collocationOptimized(bool __co) const
    {
    #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
        typedef ::IceProxy::Ice::Object _Base;
        return dynamic_cast<ListPermissionsRequest*>(_Base::ice_collocationOptimized(__co).get());
    #else
        return dynamic_cast<ListPermissionsRequest*>(::IceProxy::Ice::Object::ice_collocationOptimized(__co).get());
    #endif
    }
    
    ::IceInternal::ProxyHandle<ListPermissionsRequest> ice_twoway() const
    {
    #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
        typedef ::IceProxy::Ice::Object _Base;
        return dynamic_cast<ListPermissionsRequest*>(_Base::ice_twoway().get());
    #else
        return dynamic_cast<ListPermissionsRequest*>(::IceProxy::Ice::Object::ice_twoway().get());
    #endif
    }
    
    ::IceInternal::ProxyHandle<ListPermissionsRequest> ice_oneway() const
    {
    #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
        typedef ::IceProxy::Ice::Object _Base;
        return dynamic_cast<ListPermissionsRequest*>(_Base::ice_oneway().get());
    #else
        return dynamic_cast<ListPermissionsRequest*>(::IceProxy::Ice::Object::ice_oneway().get());
    #endif
    }
    
    ::IceInternal::ProxyHandle<ListPermissionsRequest> ice_batchOneway() const
    {
    #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
        typedef ::IceProxy::Ice::Object _Base;
        return dynamic_cast<ListPermissionsRequest*>(_Base::ice_batchOneway().get());
    #else
        return dynamic_cast<ListPermissionsRequest*>(::IceProxy::Ice::Object::ice_batchOneway().get());
    #endif
    }
    
    ::IceInternal::ProxyHandle<ListPermissionsRequest> ice_datagram() const
    {
    #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
        typedef ::IceProxy::Ice::Object _Base;
        return dynamic_cast<ListPermissionsRequest*>(_Base::ice_datagram().get());
    #else
        return dynamic_cast<ListPermissionsRequest*>(::IceProxy::Ice::Object::ice_datagram().get());
    #endif
    }
    
    ::IceInternal::ProxyHandle<ListPermissionsRequest> ice_batchDatagram() const
    {
    #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
        typedef ::IceProxy::Ice::Object _Base;
        return dynamic_cast<ListPermissionsRequest*>(_Base::ice_batchDatagram().get());
    #else
        return dynamic_cast<ListPermissionsRequest*>(::IceProxy::Ice::Object::ice_batchDatagram().get());
    #endif
    }
    
    ::IceInternal::ProxyHandle<ListPermissionsRequest> ice_compress(bool __compress) const
    {
    #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
        typedef ::IceProxy::Ice::Object _Base;
        return dynamic_cast<ListPermissionsRequest*>(_Base::ice_compress(__compress).get());
    #else
        return dynamic_cast<ListPermissionsRequest*>(::IceProxy::Ice::Object::ice_compress(__compress).get());
    #endif
    }
    
    ::IceInternal::ProxyHandle<ListPermissionsRequest> ice_timeout(int __timeout) const
    {
    #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
        typedef ::IceProxy::Ice::Object _Base;
        return dynamic_cast<ListPermissionsRequest*>(_Base::ice_timeout(__timeout).get());
    #else
        return dynamic_cast<ListPermissionsRequest*>(::IceProxy::Ice::Object::ice_timeout(__timeout).get());
    #endif
    }
    
    ::IceInternal::ProxyHandle<ListPermissionsRequest> ice_connectionId(const std::string& __id) const
    {
    #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
        typedef ::IceProxy::Ice::Object _Base;
        return dynamic_cast<ListPermissionsRequest*>(_Base::ice_connectionId(__id).get());
    #else
        return dynamic_cast<ListPermissionsRequest*>(::IceProxy::Ice::Object::ice_connectionId(__id).get());
    #endif
    }
    
    static const ::std::string& ice_staticId();

private: 

    virtual ::IceInternal::Handle< ::IceDelegateM::Ice::Object> __createDelegateM();
    virtual ::IceInternal::Handle< ::IceDelegateD::Ice::Object> __createDelegateD();
    virtual ::IceProxy::Ice::Object* __newInstance() const;
};

class RemovePermissionRequest : virtual public ::IceProxy::Ehr::Request
{
public:
    
    ::IceInternal::ProxyHandle<RemovePermissionRequest> ice_context(const ::Ice::Context& __context) const
    {
    #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
        typedef ::IceProxy::Ice::Object _Base;
        return dynamic_cast<RemovePermissionRequest*>(_Base::ice_context(__context).get());
    #else
        return dynamic_cast<RemovePermissionRequest*>(::IceProxy::Ice::Object::ice_context(__context).get());
    #endif
    }
    
    ::IceInternal::ProxyHandle<RemovePermissionRequest> ice_adapterId(const std::string& __id) const
    {
    #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
        typedef ::IceProxy::Ice::Object _Base;
        return dynamic_cast<RemovePermissionRequest*>(_Base::ice_adapterId(__id).get());
    #else
        return dynamic_cast<RemovePermissionRequest*>(::IceProxy::Ice::Object::ice_adapterId(__id).get());
    #endif
    }
    
    ::IceInternal::ProxyHandle<RemovePermissionRequest> ice_endpoints(const ::Ice::EndpointSeq& __endpoints) const
    {
    #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
        typedef ::IceProxy::Ice::Object _Base;
        return dynamic_cast<RemovePermissionRequest*>(_Base::ice_endpoints(__endpoints).get());
    #else
        return dynamic_cast<RemovePermissionRequest*>(::IceProxy::Ice::Object::ice_endpoints(__endpoints).get());
    #endif
    }
    
    ::IceInternal::ProxyHandle<RemovePermissionRequest> ice_locatorCacheTimeout(int __timeout) const
    {
    #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
        typedef ::IceProxy::Ice::Object _Base;
        return dynamic_cast<RemovePermissionRequest*>(_Base::ice_locatorCacheTimeout(__timeout).get());
    #else
        return dynamic_cast<RemovePermissionRequest*>(::IceProxy::Ice::Object::ice_locatorCacheTimeout(__timeout).get());
    #endif
    }
    
    ::IceInternal::ProxyHandle<RemovePermissionRequest> ice_connectionCached(bool __cached) const
    {
    #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
        typedef ::IceProxy::Ice::Object _Base;
        return dynamic_cast<RemovePermissionRequest*>(_Base::ice_connectionCached(__cached).get());
    #else
        return dynamic_cast<RemovePermissionRequest*>(::IceProxy::Ice::Object::ice_connectionCached(__cached).get());
    #endif
    }
    
    ::IceInternal::ProxyHandle<RemovePermissionRequest> ice_endpointSelection(::Ice::EndpointSelectionType __est) const
    {
    #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
        typedef ::IceProxy::Ice::Object _Base;
        return dynamic_cast<RemovePermissionRequest*>(_Base::ice_endpointSelection(__est).get());
    #else
        return dynamic_cast<RemovePermissionRequest*>(::IceProxy::Ice::Object::ice_endpointSelection(__est).get());
    #endif
    }
    
    ::IceInternal::ProxyHandle<RemovePermissionRequest> ice_secure(bool __secure) const
    {
    #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
        typedef ::IceProxy::Ice::Object _Base;
        return dynamic_cast<RemovePermissionRequest*>(_Base::ice_secure(__secure).get());
    #else
        return dynamic_cast<RemovePermissionRequest*>(::IceProxy::Ice::Object::ice_secure(__secure).get());
    #endif
    }
    
    ::IceInternal::ProxyHandle<RemovePermissionRequest> ice_preferSecure(bool __preferSecure) const
    {
    #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
        typedef ::IceProxy::Ice::Object _Base;
        return dynamic_cast<RemovePermissionRequest*>(_Base::ice_preferSecure(__preferSecure).get());
    #else
        return dynamic_cast<RemovePermissionRequest*>(::IceProxy::Ice::Object::ice_preferSecure(__preferSecure).get());
    #endif
    }
    
    ::IceInternal::ProxyHandle<RemovePermissionRequest> ice_router(const ::Ice::RouterPrx& __router) const
    {
    #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
        typedef ::IceProxy::Ice::Object _Base;
        return dynamic_cast<RemovePermissionRequest*>(_Base::ice_router(__router).get());
    #else
        return dynamic_cast<RemovePermissionRequest*>(::IceProxy::Ice::Object::ice_router(__router).get());
    #endif
    }
    
    ::IceInternal::ProxyHandle<RemovePermissionRequest> ice_locator(const ::Ice::LocatorPrx& __locator) const
    {
    #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
        typedef ::IceProxy::Ice::Object _Base;
        return dynamic_cast<RemovePermissionRequest*>(_Base::ice_locator(__locator).get());
    #else
        return dynamic_cast<RemovePermissionRequest*>(::IceProxy::Ice::Object::ice_locator(__locator).get());
    #endif
    }
    
    ::IceInternal::ProxyHandle<RemovePermissionRequest> ice_collocationOptimized(bool __co) const
    {
    #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
        typedef ::IceProxy::Ice::Object _Base;
        return dynamic_cast<RemovePermissionRequest*>(_Base::ice_collocationOptimized(__co).get());
    #else
        return dynamic_cast<RemovePermissionRequest*>(::IceProxy::Ice::Object::ice_collocationOptimized(__co).get());
    #endif
    }
    
    ::IceInternal::ProxyHandle<RemovePermissionRequest> ice_twoway() const
    {
    #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
        typedef ::IceProxy::Ice::Object _Base;
        return dynamic_cast<RemovePermissionRequest*>(_Base::ice_twoway().get());
    #else
        return dynamic_cast<RemovePermissionRequest*>(::IceProxy::Ice::Object::ice_twoway().get());
    #endif
    }
    
    ::IceInternal::ProxyHandle<RemovePermissionRequest> ice_oneway() const
    {
    #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
        typedef ::IceProxy::Ice::Object _Base;
        return dynamic_cast<RemovePermissionRequest*>(_Base::ice_oneway().get());
    #else
        return dynamic_cast<RemovePermissionRequest*>(::IceProxy::Ice::Object::ice_oneway().get());
    #endif
    }
    
    ::IceInternal::ProxyHandle<RemovePermissionRequest> ice_batchOneway() const
    {
    #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
        typedef ::IceProxy::Ice::Object _Base;
        return dynamic_cast<RemovePermissionRequest*>(_Base::ice_batchOneway().get());
    #else
        return dynamic_cast<RemovePermissionRequest*>(::IceProxy::Ice::Object::ice_batchOneway().get());
    #endif
    }
    
    ::IceInternal::ProxyHandle<RemovePermissionRequest> ice_datagram() const
    {
    #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
        typedef ::IceProxy::Ice::Object _Base;
        return dynamic_cast<RemovePermissionRequest*>(_Base::ice_datagram().get());
    #else
        return dynamic_cast<RemovePermissionRequest*>(::IceProxy::Ice::Object::ice_datagram().get());
    #endif
    }
    
    ::IceInternal::ProxyHandle<RemovePermissionRequest> ice_batchDatagram() const
    {
    #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
        typedef ::IceProxy::Ice::Object _Base;
        return dynamic_cast<RemovePermissionRequest*>(_Base::ice_batchDatagram().get());
    #else
        return dynamic_cast<RemovePermissionRequest*>(::IceProxy::Ice::Object::ice_batchDatagram().get());
    #endif
    }
    
    ::IceInternal::ProxyHandle<RemovePermissionRequest> ice_compress(bool __compress) const
    {
    #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
        typedef ::IceProxy::Ice::Object _Base;
        return dynamic_cast<RemovePermissionRequest*>(_Base::ice_compress(__compress).get());
    #else
        return dynamic_cast<RemovePermissionRequest*>(::IceProxy::Ice::Object::ice_compress(__compress).get());
    #endif
    }
    
    ::IceInternal::ProxyHandle<RemovePermissionRequest> ice_timeout(int __timeout) const
    {
    #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
        typedef ::IceProxy::Ice::Object _Base;
        return dynamic_cast<RemovePermissionRequest*>(_Base::ice_timeout(__timeout).get());
    #else
        return dynamic_cast<RemovePermissionRequest*>(::IceProxy::Ice::Object::ice_timeout(__timeout).get());
    #endif
    }
    
    ::IceInternal::ProxyHandle<RemovePermissionRequest> ice_connectionId(const std::string& __id) const
    {
    #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
        typedef ::IceProxy::Ice::Object _Base;
        return dynamic_cast<RemovePermissionRequest*>(_Base::ice_connectionId(__id).get());
    #else
        return dynamic_cast<RemovePermissionRequest*>(::IceProxy::Ice::Object::ice_connectionId(__id).get());
    #endif
    }
    
    static const ::std::string& ice_staticId();

private: 

    virtual ::IceInternal::Handle< ::IceDelegateM::Ice::Object> __createDelegateM();
    virtual ::IceInternal::Handle< ::IceDelegateD::Ice::Object> __createDelegateD();
    virtual ::IceProxy::Ice::Object* __newInstance() const;
};

class Provider : virtual public ::IceProxy::Ice::Object
{
public:

    void createPrescription(const ::Ehr::CreatePrescriptionRequestPtr& request, const ::Ehr::Signature& requestorSignature, const ::Ehr::Signature& ownerSignature)
    {
        createPrescription(request, requestorSignature, ownerSignature, 0);
    }
    void createPrescription(const ::Ehr::CreatePrescriptionRequestPtr& request, const ::Ehr::Signature& requestorSignature, const ::Ehr::Signature& ownerSignature, const ::Ice::Context& __ctx)
    {
        createPrescription(request, requestorSignature, ownerSignature, &__ctx);
    }
    
private:

    void createPrescription(const ::Ehr::CreatePrescriptionRequestPtr&, const ::Ehr::Signature&, const ::Ehr::Signature&, const ::Ice::Context*);
    
public:

    void consumePrescription(const ::Ehr::ConsumePrescriptionRequestPtr& request, const ::Ehr::Signature& requestorSignature, const ::Ehr::Signature& ownerSignature)
    {
        consumePrescription(request, requestorSignature, ownerSignature, 0);
    }
    void consumePrescription(const ::Ehr::ConsumePrescriptionRequestPtr& request, const ::Ehr::Signature& requestorSignature, const ::Ehr::Signature& ownerSignature, const ::Ice::Context& __ctx)
    {
        consumePrescription(request, requestorSignature, ownerSignature, &__ctx);
    }
    
private:

    void consumePrescription(const ::Ehr::ConsumePrescriptionRequestPtr&, const ::Ehr::Signature&, const ::Ehr::Signature&, const ::Ice::Context*);
    
public:

    ::Ehr::DocumentList listDocuments(const ::Ehr::ListDocumentsRequestPtr& request, const ::Ehr::Signature& requestorSignature, const ::Ehr::Signature& ownerSignature)
    {
        return listDocuments(request, requestorSignature, ownerSignature, 0);
    }
    ::Ehr::DocumentList listDocuments(const ::Ehr::ListDocumentsRequestPtr& request, const ::Ehr::Signature& requestorSignature, const ::Ehr::Signature& ownerSignature, const ::Ice::Context& __ctx)
    {
        return listDocuments(request, requestorSignature, ownerSignature, &__ctx);
    }
    
private:

    ::Ehr::DocumentList listDocuments(const ::Ehr::ListDocumentsRequestPtr&, const ::Ehr::Signature&, const ::Ehr::Signature&, const ::Ice::Context*);
    
public:

    ::Ehr::DocumentList findDocuments(const ::Ehr::FindDocumentsRequestPtr& request, const ::Ehr::Signature& requestorSignature, const ::Ehr::Signature& ownerSignature)
    {
        return findDocuments(request, requestorSignature, ownerSignature, 0);
    }
    ::Ehr::DocumentList findDocuments(const ::Ehr::FindDocumentsRequestPtr& request, const ::Ehr::Signature& requestorSignature, const ::Ehr::Signature& ownerSignature, const ::Ice::Context& __ctx)
    {
        return findDocuments(request, requestorSignature, ownerSignature, &__ctx);
    }
    
private:

    ::Ehr::DocumentList findDocuments(const ::Ehr::FindDocumentsRequestPtr&, const ::Ehr::Signature&, const ::Ehr::Signature&, const ::Ice::Context*);
    
public:

    void setDefaultAccess(const ::Ehr::SetDefaultAccessRequestPtr& request, const ::Ehr::Signature& requestorSignature)
    {
        setDefaultAccess(request, requestorSignature, 0);
    }
    void setDefaultAccess(const ::Ehr::SetDefaultAccessRequestPtr& request, const ::Ehr::Signature& requestorSignature, const ::Ice::Context& __ctx)
    {
        setDefaultAccess(request, requestorSignature, &__ctx);
    }
    
private:

    void setDefaultAccess(const ::Ehr::SetDefaultAccessRequestPtr&, const ::Ehr::Signature&, const ::Ice::Context*);
    
public:

    void createPermission(const ::Ehr::CreatePermissionRequestPtr& request, const ::Ehr::Signature& requestorSignature)
    {
        createPermission(request, requestorSignature, 0);
    }
    void createPermission(const ::Ehr::CreatePermissionRequestPtr& request, const ::Ehr::Signature& requestorSignature, const ::Ice::Context& __ctx)
    {
        createPermission(request, requestorSignature, &__ctx);
    }
    
private:

    void createPermission(const ::Ehr::CreatePermissionRequestPtr&, const ::Ehr::Signature&, const ::Ice::Context*);
    
public:

    ::Ehr::Permissions listPermissions(const ::Ehr::ListPermissionsRequestPtr& request, const ::Ehr::Signature& requestorSignature)
    {
        return listPermissions(request, requestorSignature, 0);
    }
    ::Ehr::Permissions listPermissions(const ::Ehr::ListPermissionsRequestPtr& request, const ::Ehr::Signature& requestorSignature, const ::Ice::Context& __ctx)
    {
        return listPermissions(request, requestorSignature, &__ctx);
    }
    
private:

    ::Ehr::Permissions listPermissions(const ::Ehr::ListPermissionsRequestPtr&, const ::Ehr::Signature&, const ::Ice::Context*);
    
public:

    void removePermission(const ::Ehr::RemovePermissionRequestPtr& request, const ::Ehr::Signature& requestorSignature)
    {
        removePermission(request, requestorSignature, 0);
    }
    void removePermission(const ::Ehr::RemovePermissionRequestPtr& request, const ::Ehr::Signature& requestorSignature, const ::Ice::Context& __ctx)
    {
        removePermission(request, requestorSignature, &__ctx);
    }
    
private:

    void removePermission(const ::Ehr::RemovePermissionRequestPtr&, const ::Ehr::Signature&, const ::Ice::Context*);
    
public:
    
    ::IceInternal::ProxyHandle<Provider> ice_context(const ::Ice::Context& __context) const
    {
    #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
        typedef ::IceProxy::Ice::Object _Base;
        return dynamic_cast<Provider*>(_Base::ice_context(__context).get());
    #else
        return dynamic_cast<Provider*>(::IceProxy::Ice::Object::ice_context(__context).get());
    #endif
    }
    
    ::IceInternal::ProxyHandle<Provider> ice_adapterId(const std::string& __id) const
    {
    #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
        typedef ::IceProxy::Ice::Object _Base;
        return dynamic_cast<Provider*>(_Base::ice_adapterId(__id).get());
    #else
        return dynamic_cast<Provider*>(::IceProxy::Ice::Object::ice_adapterId(__id).get());
    #endif
    }
    
    ::IceInternal::ProxyHandle<Provider> ice_endpoints(const ::Ice::EndpointSeq& __endpoints) const
    {
    #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
        typedef ::IceProxy::Ice::Object _Base;
        return dynamic_cast<Provider*>(_Base::ice_endpoints(__endpoints).get());
    #else
        return dynamic_cast<Provider*>(::IceProxy::Ice::Object::ice_endpoints(__endpoints).get());
    #endif
    }
    
    ::IceInternal::ProxyHandle<Provider> ice_locatorCacheTimeout(int __timeout) const
    {
    #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
        typedef ::IceProxy::Ice::Object _Base;
        return dynamic_cast<Provider*>(_Base::ice_locatorCacheTimeout(__timeout).get());
    #else
        return dynamic_cast<Provider*>(::IceProxy::Ice::Object::ice_locatorCacheTimeout(__timeout).get());
    #endif
    }
    
    ::IceInternal::ProxyHandle<Provider> ice_connectionCached(bool __cached) const
    {
    #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
        typedef ::IceProxy::Ice::Object _Base;
        return dynamic_cast<Provider*>(_Base::ice_connectionCached(__cached).get());
    #else
        return dynamic_cast<Provider*>(::IceProxy::Ice::Object::ice_connectionCached(__cached).get());
    #endif
    }
    
    ::IceInternal::ProxyHandle<Provider> ice_endpointSelection(::Ice::EndpointSelectionType __est) const
    {
    #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
        typedef ::IceProxy::Ice::Object _Base;
        return dynamic_cast<Provider*>(_Base::ice_endpointSelection(__est).get());
    #else
        return dynamic_cast<Provider*>(::IceProxy::Ice::Object::ice_endpointSelection(__est).get());
    #endif
    }
    
    ::IceInternal::ProxyHandle<Provider> ice_secure(bool __secure) const
    {
    #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
        typedef ::IceProxy::Ice::Object _Base;
        return dynamic_cast<Provider*>(_Base::ice_secure(__secure).get());
    #else
        return dynamic_cast<Provider*>(::IceProxy::Ice::Object::ice_secure(__secure).get());
    #endif
    }
    
    ::IceInternal::ProxyHandle<Provider> ice_preferSecure(bool __preferSecure) const
    {
    #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
        typedef ::IceProxy::Ice::Object _Base;
        return dynamic_cast<Provider*>(_Base::ice_preferSecure(__preferSecure).get());
    #else
        return dynamic_cast<Provider*>(::IceProxy::Ice::Object::ice_preferSecure(__preferSecure).get());
    #endif
    }
    
    ::IceInternal::ProxyHandle<Provider> ice_router(const ::Ice::RouterPrx& __router) const
    {
    #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
        typedef ::IceProxy::Ice::Object _Base;
        return dynamic_cast<Provider*>(_Base::ice_router(__router).get());
    #else
        return dynamic_cast<Provider*>(::IceProxy::Ice::Object::ice_router(__router).get());
    #endif
    }
    
    ::IceInternal::ProxyHandle<Provider> ice_locator(const ::Ice::LocatorPrx& __locator) const
    {
    #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
        typedef ::IceProxy::Ice::Object _Base;
        return dynamic_cast<Provider*>(_Base::ice_locator(__locator).get());
    #else
        return dynamic_cast<Provider*>(::IceProxy::Ice::Object::ice_locator(__locator).get());
    #endif
    }
    
    ::IceInternal::ProxyHandle<Provider> ice_collocationOptimized(bool __co) const
    {
    #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
        typedef ::IceProxy::Ice::Object _Base;
        return dynamic_cast<Provider*>(_Base::ice_collocationOptimized(__co).get());
    #else
        return dynamic_cast<Provider*>(::IceProxy::Ice::Object::ice_collocationOptimized(__co).get());
    #endif
    }
    
    ::IceInternal::ProxyHandle<Provider> ice_twoway() const
    {
    #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
        typedef ::IceProxy::Ice::Object _Base;
        return dynamic_cast<Provider*>(_Base::ice_twoway().get());
    #else
        return dynamic_cast<Provider*>(::IceProxy::Ice::Object::ice_twoway().get());
    #endif
    }
    
    ::IceInternal::ProxyHandle<Provider> ice_oneway() const
    {
    #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
        typedef ::IceProxy::Ice::Object _Base;
        return dynamic_cast<Provider*>(_Base::ice_oneway().get());
    #else
        return dynamic_cast<Provider*>(::IceProxy::Ice::Object::ice_oneway().get());
    #endif
    }
    
    ::IceInternal::ProxyHandle<Provider> ice_batchOneway() const
    {
    #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
        typedef ::IceProxy::Ice::Object _Base;
        return dynamic_cast<Provider*>(_Base::ice_batchOneway().get());
    #else
        return dynamic_cast<Provider*>(::IceProxy::Ice::Object::ice_batchOneway().get());
    #endif
    }
    
    ::IceInternal::ProxyHandle<Provider> ice_datagram() const
    {
    #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
        typedef ::IceProxy::Ice::Object _Base;
        return dynamic_cast<Provider*>(_Base::ice_datagram().get());
    #else
        return dynamic_cast<Provider*>(::IceProxy::Ice::Object::ice_datagram().get());
    #endif
    }
    
    ::IceInternal::ProxyHandle<Provider> ice_batchDatagram() const
    {
    #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
        typedef ::IceProxy::Ice::Object _Base;
        return dynamic_cast<Provider*>(_Base::ice_batchDatagram().get());
    #else
        return dynamic_cast<Provider*>(::IceProxy::Ice::Object::ice_batchDatagram().get());
    #endif
    }
    
    ::IceInternal::ProxyHandle<Provider> ice_compress(bool __compress) const
    {
    #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
        typedef ::IceProxy::Ice::Object _Base;
        return dynamic_cast<Provider*>(_Base::ice_compress(__compress).get());
    #else
        return dynamic_cast<Provider*>(::IceProxy::Ice::Object::ice_compress(__compress).get());
    #endif
    }
    
    ::IceInternal::ProxyHandle<Provider> ice_timeout(int __timeout) const
    {
    #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
        typedef ::IceProxy::Ice::Object _Base;
        return dynamic_cast<Provider*>(_Base::ice_timeout(__timeout).get());
    #else
        return dynamic_cast<Provider*>(::IceProxy::Ice::Object::ice_timeout(__timeout).get());
    #endif
    }
    
    ::IceInternal::ProxyHandle<Provider> ice_connectionId(const std::string& __id) const
    {
    #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
        typedef ::IceProxy::Ice::Object _Base;
        return dynamic_cast<Provider*>(_Base::ice_connectionId(__id).get());
    #else
        return dynamic_cast<Provider*>(::IceProxy::Ice::Object::ice_connectionId(__id).get());
    #endif
    }
    
    static const ::std::string& ice_staticId();

private: 

    virtual ::IceInternal::Handle< ::IceDelegateM::Ice::Object> __createDelegateM();
    virtual ::IceInternal::Handle< ::IceDelegateD::Ice::Object> __createDelegateD();
    virtual ::IceProxy::Ice::Object* __newInstance() const;
};

}

}

namespace IceDelegate
{

namespace Ehr
{

class Document : virtual public ::IceDelegate::Ice::Object
{
public:
};

class Prescription : virtual public ::IceDelegate::Ehr::Document
{
public:
};

class ConsumedPrescription : virtual public ::IceDelegate::Ehr::Prescription
{
public:
};

class Request : virtual public ::IceDelegate::Ice::Object
{
public:
};

class ThirdPartyRequest : virtual public ::IceDelegate::Ehr::Request
{
public:
};

class CreatePrescriptionRequest : virtual public ::IceDelegate::Ehr::ThirdPartyRequest
{
public:
};

class ConsumePrescriptionRequest : virtual public ::IceDelegate::Ehr::ThirdPartyRequest
{
public:
};

class ListDocumentsRequest : virtual public ::IceDelegate::Ehr::ThirdPartyRequest
{
public:
};

class FindDocumentsRequest : virtual public ::IceDelegate::Ehr::ThirdPartyRequest
{
public:
};

class CreatePermissionRequest : virtual public ::IceDelegate::Ehr::Request
{
public:
};

class SetDefaultAccessRequest : virtual public ::IceDelegate::Ehr::Request
{
public:
};

class ListPermissionsRequest : virtual public ::IceDelegate::Ehr::Request
{
public:
};

class RemovePermissionRequest : virtual public ::IceDelegate::Ehr::Request
{
public:
};

class Provider : virtual public ::IceDelegate::Ice::Object
{
public:

    virtual void createPrescription(const ::Ehr::CreatePrescriptionRequestPtr&, const ::Ehr::Signature&, const ::Ehr::Signature&, const ::Ice::Context*) = 0;

    virtual void consumePrescription(const ::Ehr::ConsumePrescriptionRequestPtr&, const ::Ehr::Signature&, const ::Ehr::Signature&, const ::Ice::Context*) = 0;

    virtual ::Ehr::DocumentList listDocuments(const ::Ehr::ListDocumentsRequestPtr&, const ::Ehr::Signature&, const ::Ehr::Signature&, const ::Ice::Context*) = 0;

    virtual ::Ehr::DocumentList findDocuments(const ::Ehr::FindDocumentsRequestPtr&, const ::Ehr::Signature&, const ::Ehr::Signature&, const ::Ice::Context*) = 0;

    virtual void setDefaultAccess(const ::Ehr::SetDefaultAccessRequestPtr&, const ::Ehr::Signature&, const ::Ice::Context*) = 0;

    virtual void createPermission(const ::Ehr::CreatePermissionRequestPtr&, const ::Ehr::Signature&, const ::Ice::Context*) = 0;

    virtual ::Ehr::Permissions listPermissions(const ::Ehr::ListPermissionsRequestPtr&, const ::Ehr::Signature&, const ::Ice::Context*) = 0;

    virtual void removePermission(const ::Ehr::RemovePermissionRequestPtr&, const ::Ehr::Signature&, const ::Ice::Context*) = 0;
};

}

}

namespace IceDelegateM
{

namespace Ehr
{

class Document : virtual public ::IceDelegate::Ehr::Document,
                 virtual public ::IceDelegateM::Ice::Object
{
public:
};

class Prescription : virtual public ::IceDelegate::Ehr::Prescription,
                     virtual public ::IceDelegateM::Ehr::Document
{
public:
};

class ConsumedPrescription : virtual public ::IceDelegate::Ehr::ConsumedPrescription,
                             virtual public ::IceDelegateM::Ehr::Prescription
{
public:
};

class Request : virtual public ::IceDelegate::Ehr::Request,
                virtual public ::IceDelegateM::Ice::Object
{
public:
};

class ThirdPartyRequest : virtual public ::IceDelegate::Ehr::ThirdPartyRequest,
                          virtual public ::IceDelegateM::Ehr::Request
{
public:
};

class CreatePrescriptionRequest : virtual public ::IceDelegate::Ehr::CreatePrescriptionRequest,
                                  virtual public ::IceDelegateM::Ehr::ThirdPartyRequest
{
public:
};

class ConsumePrescriptionRequest : virtual public ::IceDelegate::Ehr::ConsumePrescriptionRequest,
                                   virtual public ::IceDelegateM::Ehr::ThirdPartyRequest
{
public:
};

class ListDocumentsRequest : virtual public ::IceDelegate::Ehr::ListDocumentsRequest,
                             virtual public ::IceDelegateM::Ehr::ThirdPartyRequest
{
public:
};

class FindDocumentsRequest : virtual public ::IceDelegate::Ehr::FindDocumentsRequest,
                             virtual public ::IceDelegateM::Ehr::ThirdPartyRequest
{
public:
};

class CreatePermissionRequest : virtual public ::IceDelegate::Ehr::CreatePermissionRequest,
                                virtual public ::IceDelegateM::Ehr::Request
{
public:
};

class SetDefaultAccessRequest : virtual public ::IceDelegate::Ehr::SetDefaultAccessRequest,
                                virtual public ::IceDelegateM::Ehr::Request
{
public:
};

class ListPermissionsRequest : virtual public ::IceDelegate::Ehr::ListPermissionsRequest,
                               virtual public ::IceDelegateM::Ehr::Request
{
public:
};

class RemovePermissionRequest : virtual public ::IceDelegate::Ehr::RemovePermissionRequest,
                                virtual public ::IceDelegateM::Ehr::Request
{
public:
};

class Provider : virtual public ::IceDelegate::Ehr::Provider,
                 virtual public ::IceDelegateM::Ice::Object
{
public:

    virtual void createPrescription(const ::Ehr::CreatePrescriptionRequestPtr&, const ::Ehr::Signature&, const ::Ehr::Signature&, const ::Ice::Context*);

    virtual void consumePrescription(const ::Ehr::ConsumePrescriptionRequestPtr&, const ::Ehr::Signature&, const ::Ehr::Signature&, const ::Ice::Context*);

    virtual ::Ehr::DocumentList listDocuments(const ::Ehr::ListDocumentsRequestPtr&, const ::Ehr::Signature&, const ::Ehr::Signature&, const ::Ice::Context*);

    virtual ::Ehr::DocumentList findDocuments(const ::Ehr::FindDocumentsRequestPtr&, const ::Ehr::Signature&, const ::Ehr::Signature&, const ::Ice::Context*);

    virtual void setDefaultAccess(const ::Ehr::SetDefaultAccessRequestPtr&, const ::Ehr::Signature&, const ::Ice::Context*);

    virtual void createPermission(const ::Ehr::CreatePermissionRequestPtr&, const ::Ehr::Signature&, const ::Ice::Context*);

    virtual ::Ehr::Permissions listPermissions(const ::Ehr::ListPermissionsRequestPtr&, const ::Ehr::Signature&, const ::Ice::Context*);

    virtual void removePermission(const ::Ehr::RemovePermissionRequestPtr&, const ::Ehr::Signature&, const ::Ice::Context*);
};

}

}

namespace IceDelegateD
{

namespace Ehr
{

class Document : virtual public ::IceDelegate::Ehr::Document,
                 virtual public ::IceDelegateD::Ice::Object
{
public:
};

class Prescription : virtual public ::IceDelegate::Ehr::Prescription,
                     virtual public ::IceDelegateD::Ehr::Document
{
public:
};

class ConsumedPrescription : virtual public ::IceDelegate::Ehr::ConsumedPrescription,
                             virtual public ::IceDelegateD::Ehr::Prescription
{
public:
};

class Request : virtual public ::IceDelegate::Ehr::Request,
                virtual public ::IceDelegateD::Ice::Object
{
public:
};

class ThirdPartyRequest : virtual public ::IceDelegate::Ehr::ThirdPartyRequest,
                          virtual public ::IceDelegateD::Ehr::Request
{
public:
};

class CreatePrescriptionRequest : virtual public ::IceDelegate::Ehr::CreatePrescriptionRequest,
                                  virtual public ::IceDelegateD::Ehr::ThirdPartyRequest
{
public:
};

class ConsumePrescriptionRequest : virtual public ::IceDelegate::Ehr::ConsumePrescriptionRequest,
                                   virtual public ::IceDelegateD::Ehr::ThirdPartyRequest
{
public:
};

class ListDocumentsRequest : virtual public ::IceDelegate::Ehr::ListDocumentsRequest,
                             virtual public ::IceDelegateD::Ehr::ThirdPartyRequest
{
public:
};

class FindDocumentsRequest : virtual public ::IceDelegate::Ehr::FindDocumentsRequest,
                             virtual public ::IceDelegateD::Ehr::ThirdPartyRequest
{
public:
};

class CreatePermissionRequest : virtual public ::IceDelegate::Ehr::CreatePermissionRequest,
                                virtual public ::IceDelegateD::Ehr::Request
{
public:
};

class SetDefaultAccessRequest : virtual public ::IceDelegate::Ehr::SetDefaultAccessRequest,
                                virtual public ::IceDelegateD::Ehr::Request
{
public:
};

class ListPermissionsRequest : virtual public ::IceDelegate::Ehr::ListPermissionsRequest,
                               virtual public ::IceDelegateD::Ehr::Request
{
public:
};

class RemovePermissionRequest : virtual public ::IceDelegate::Ehr::RemovePermissionRequest,
                                virtual public ::IceDelegateD::Ehr::Request
{
public:
};

class Provider : virtual public ::IceDelegate::Ehr::Provider,
                 virtual public ::IceDelegateD::Ice::Object
{
public:

    virtual void createPrescription(const ::Ehr::CreatePrescriptionRequestPtr&, const ::Ehr::Signature&, const ::Ehr::Signature&, const ::Ice::Context*);

    virtual void consumePrescription(const ::Ehr::ConsumePrescriptionRequestPtr&, const ::Ehr::Signature&, const ::Ehr::Signature&, const ::Ice::Context*);

    virtual ::Ehr::DocumentList listDocuments(const ::Ehr::ListDocumentsRequestPtr&, const ::Ehr::Signature&, const ::Ehr::Signature&, const ::Ice::Context*);

    virtual ::Ehr::DocumentList findDocuments(const ::Ehr::FindDocumentsRequestPtr&, const ::Ehr::Signature&, const ::Ehr::Signature&, const ::Ice::Context*);

    virtual void setDefaultAccess(const ::Ehr::SetDefaultAccessRequestPtr&, const ::Ehr::Signature&, const ::Ice::Context*);

    virtual void createPermission(const ::Ehr::CreatePermissionRequestPtr&, const ::Ehr::Signature&, const ::Ice::Context*);

    virtual ::Ehr::Permissions listPermissions(const ::Ehr::ListPermissionsRequestPtr&, const ::Ehr::Signature&, const ::Ice::Context*);

    virtual void removePermission(const ::Ehr::RemovePermissionRequestPtr&, const ::Ehr::Signature&, const ::Ice::Context*);
};

}

}

namespace Ehr
{

class Document : virtual public ::Ice::Object
{
public:

    typedef DocumentPrx ProxyType;
    typedef DocumentPtr PointerType;
    
    Document() {}
    explicit Document(::Ehr::DocumentType);
    virtual ::Ice::ObjectPtr ice_clone() const;

    virtual bool ice_isA(const ::std::string&, const ::Ice::Current& = ::Ice::Current()) const;
    virtual ::std::vector< ::std::string> ice_ids(const ::Ice::Current& = ::Ice::Current()) const;
    virtual const ::std::string& ice_id(const ::Ice::Current& = ::Ice::Current()) const;
    static const ::std::string& ice_staticId();


    virtual void __write(::IceInternal::BasicStream*) const;
    virtual void __read(::IceInternal::BasicStream*, bool);
    virtual void __write(const ::Ice::OutputStreamPtr&) const;
    virtual void __read(const ::Ice::InputStreamPtr&, bool);

    static const ::Ice::ObjectFactoryPtr& ice_factory();

protected:

    virtual ~Document() {}

    friend class Document__staticInit;

public:

    ::Ehr::DocumentType type;
};

class Document__staticInit
{
public:

    ::Ehr::Document _init;
};

static Document__staticInit _Document_init;

class Prescription : virtual public ::Ehr::Document
{
public:

    typedef PrescriptionPrx ProxyType;
    typedef PrescriptionPtr PointerType;
    
    Prescription() {}
    Prescription(::Ehr::DocumentType, const ::std::string&, const ::std::string&, const ::std::string&, const ::Ehr::Date&, const ::std::string&, const ::Ehr::Date&, const ::std::string&, const ::std::string&, ::Ice::Int, const ::std::string&, const ::Ehr::Date&, const ::Ehr::Date&);
    virtual ::Ice::ObjectPtr ice_clone() const;

    virtual bool ice_isA(const ::std::string&, const ::Ice::Current& = ::Ice::Current()) const;
    virtual ::std::vector< ::std::string> ice_ids(const ::Ice::Current& = ::Ice::Current()) const;
    virtual const ::std::string& ice_id(const ::Ice::Current& = ::Ice::Current()) const;
    static const ::std::string& ice_staticId();


    virtual void __write(::IceInternal::BasicStream*) const;
    virtual void __read(::IceInternal::BasicStream*, bool);
    virtual void __write(const ::Ice::OutputStreamPtr&) const;
    virtual void __read(const ::Ice::InputStreamPtr&, bool);

    static const ::Ice::ObjectFactoryPtr& ice_factory();

protected:

    virtual ~Prescription() {}

public:

    ::std::string originatorName;

    ::std::string originatorProfession;

    ::std::string originatorAddress;

    ::Ehr::Date creationDate;

    ::std::string consumerName;

    ::Ehr::Date consumerDateOfBirth;

    ::std::string drugDescription;

    ::std::string form;

    ::Ice::Int dosage;

    ::std::string measuringUnit;

    ::Ehr::Date validFrom;

    ::Ehr::Date expires;
};

class ConsumedPrescription : virtual public ::Ehr::Prescription
{
public:

    typedef ConsumedPrescriptionPrx ProxyType;
    typedef ConsumedPrescriptionPtr PointerType;
    
    ConsumedPrescription() {}
    ConsumedPrescription(::Ehr::DocumentType, const ::std::string&, const ::std::string&, const ::std::string&, const ::Ehr::Date&, const ::std::string&, const ::Ehr::Date&, const ::std::string&, const ::std::string&, ::Ice::Int, const ::std::string&, const ::Ehr::Date&, const ::Ehr::Date&, const ::std::string&, const ::std::string&, const ::std::string&, const ::Ehr::Date&);
    virtual ::Ice::ObjectPtr ice_clone() const;

    virtual bool ice_isA(const ::std::string&, const ::Ice::Current& = ::Ice::Current()) const;
    virtual ::std::vector< ::std::string> ice_ids(const ::Ice::Current& = ::Ice::Current()) const;
    virtual const ::std::string& ice_id(const ::Ice::Current& = ::Ice::Current()) const;
    static const ::std::string& ice_staticId();


    virtual void __write(::IceInternal::BasicStream*) const;
    virtual void __read(::IceInternal::BasicStream*, bool);
    virtual void __write(const ::Ice::OutputStreamPtr&) const;
    virtual void __read(const ::Ice::InputStreamPtr&, bool);

    static const ::Ice::ObjectFactoryPtr& ice_factory();

protected:

    virtual ~ConsumedPrescription() {}

public:

    ::std::string dispenserName;

    ::std::string dispenserProfession;

    ::std::string dispenserAddress;

    ::Ehr::Date dispensingDate;
};

class Request : virtual public ::Ice::Object
{
public:

    typedef RequestPrx ProxyType;
    typedef RequestPtr PointerType;
    
    Request() {}
    Request(const ::Ehr::AccountIdentifier&, const ::Ehr::Timestamp&);
    virtual ::Ice::ObjectPtr ice_clone() const;

    virtual bool ice_isA(const ::std::string&, const ::Ice::Current& = ::Ice::Current()) const;
    virtual ::std::vector< ::std::string> ice_ids(const ::Ice::Current& = ::Ice::Current()) const;
    virtual const ::std::string& ice_id(const ::Ice::Current& = ::Ice::Current()) const;
    static const ::std::string& ice_staticId();


    virtual void __write(::IceInternal::BasicStream*) const;
    virtual void __read(::IceInternal::BasicStream*, bool);
    virtual void __write(const ::Ice::OutputStreamPtr&) const;
    virtual void __read(const ::Ice::InputStreamPtr&, bool);

    static const ::Ice::ObjectFactoryPtr& ice_factory();

protected:

    virtual ~Request() {}

public:

    ::Ehr::AccountIdentifier requestor;

    ::Ehr::Timestamp when;
};

class ThirdPartyRequest : virtual public ::Ehr::Request
{
public:

    typedef ThirdPartyRequestPrx ProxyType;
    typedef ThirdPartyRequestPtr PointerType;
    
    ThirdPartyRequest() {}
    ThirdPartyRequest(const ::Ehr::AccountIdentifier&, const ::Ehr::Timestamp&, const ::Ehr::AccountIdentifier&);
    virtual ::Ice::ObjectPtr ice_clone() const;

    virtual bool ice_isA(const ::std::string&, const ::Ice::Current& = ::Ice::Current()) const;
    virtual ::std::vector< ::std::string> ice_ids(const ::Ice::Current& = ::Ice::Current()) const;
    virtual const ::std::string& ice_id(const ::Ice::Current& = ::Ice::Current()) const;
    static const ::std::string& ice_staticId();


    virtual void __write(::IceInternal::BasicStream*) const;
    virtual void __read(::IceInternal::BasicStream*, bool);
    virtual void __write(const ::Ice::OutputStreamPtr&) const;
    virtual void __read(const ::Ice::InputStreamPtr&, bool);

    static const ::Ice::ObjectFactoryPtr& ice_factory();

protected:

    virtual ~ThirdPartyRequest() {}

public:

    ::Ehr::AccountIdentifier owner;
};

class CreatePrescriptionRequest : virtual public ::Ehr::ThirdPartyRequest
{
public:

    typedef CreatePrescriptionRequestPrx ProxyType;
    typedef CreatePrescriptionRequestPtr PointerType;
    
    CreatePrescriptionRequest() {}
    CreatePrescriptionRequest(const ::Ehr::AccountIdentifier&, const ::Ehr::Timestamp&, const ::Ehr::AccountIdentifier&, const ::Ehr::EncryptedDocument&);
    virtual ::Ice::ObjectPtr ice_clone() const;

    virtual bool ice_isA(const ::std::string&, const ::Ice::Current& = ::Ice::Current()) const;
    virtual ::std::vector< ::std::string> ice_ids(const ::Ice::Current& = ::Ice::Current()) const;
    virtual const ::std::string& ice_id(const ::Ice::Current& = ::Ice::Current()) const;
    static const ::std::string& ice_staticId();


    virtual void __write(::IceInternal::BasicStream*) const;
    virtual void __read(::IceInternal::BasicStream*, bool);
    virtual void __write(const ::Ice::OutputStreamPtr&) const;
    virtual void __read(const ::Ice::InputStreamPtr&, bool);

    static const ::Ice::ObjectFactoryPtr& ice_factory();

protected:

    virtual ~CreatePrescriptionRequest() {}

public:

    ::Ehr::EncryptedDocument prescription;
};

class ConsumePrescriptionRequest : virtual public ::Ehr::ThirdPartyRequest
{
public:

    typedef ConsumePrescriptionRequestPrx ProxyType;
    typedef ConsumePrescriptionRequestPtr PointerType;
    
    ConsumePrescriptionRequest() {}
    ConsumePrescriptionRequest(const ::Ehr::AccountIdentifier&, const ::Ehr::Timestamp&, const ::Ehr::AccountIdentifier&, ::Ice::Long, const ::Ehr::EncryptedDocument&);
    virtual ::Ice::ObjectPtr ice_clone() const;

    virtual bool ice_isA(const ::std::string&, const ::Ice::Current& = ::Ice::Current()) const;
    virtual ::std::vector< ::std::string> ice_ids(const ::Ice::Current& = ::Ice::Current()) const;
    virtual const ::std::string& ice_id(const ::Ice::Current& = ::Ice::Current()) const;
    static const ::std::string& ice_staticId();


    virtual void __write(::IceInternal::BasicStream*) const;
    virtual void __read(::IceInternal::BasicStream*, bool);
    virtual void __write(const ::Ice::OutputStreamPtr&) const;
    virtual void __read(const ::Ice::InputStreamPtr&, bool);

    static const ::Ice::ObjectFactoryPtr& ice_factory();

protected:

    virtual ~ConsumePrescriptionRequest() {}

public:

    ::Ice::Long prescriptionId;

    ::Ehr::EncryptedDocument consumedPrescription;
};

class ListDocumentsRequest : virtual public ::Ehr::ThirdPartyRequest
{
public:

    typedef ListDocumentsRequestPrx ProxyType;
    typedef ListDocumentsRequestPtr PointerType;
    
    ListDocumentsRequest() {}
    ListDocumentsRequest(const ::Ehr::AccountIdentifier&, const ::Ehr::Timestamp&, const ::Ehr::AccountIdentifier&);
    virtual ::Ice::ObjectPtr ice_clone() const;

    virtual bool ice_isA(const ::std::string&, const ::Ice::Current& = ::Ice::Current()) const;
    virtual ::std::vector< ::std::string> ice_ids(const ::Ice::Current& = ::Ice::Current()) const;
    virtual const ::std::string& ice_id(const ::Ice::Current& = ::Ice::Current()) const;
    static const ::std::string& ice_staticId();

    virtual void __write(::IceInternal::BasicStream*) const;
    virtual void __read(::IceInternal::BasicStream*, bool);
    virtual void __write(const ::Ice::OutputStreamPtr&) const;
    virtual void __read(const ::Ice::InputStreamPtr&, bool);

    static const ::Ice::ObjectFactoryPtr& ice_factory();

protected:

    virtual ~ListDocumentsRequest() {}
};

class FindDocumentsRequest : virtual public ::Ehr::ThirdPartyRequest
{
public:

    typedef FindDocumentsRequestPrx ProxyType;
    typedef FindDocumentsRequestPtr PointerType;
    
    FindDocumentsRequest() {}
    FindDocumentsRequest(const ::Ehr::AccountIdentifier&, const ::Ehr::Timestamp&, const ::Ehr::AccountIdentifier&, bool, const ::Ehr::Timestamp&, bool, const ::Ehr::Timestamp&, ::Ehr::DocumentType, ::Ice::Long);
    virtual ::Ice::ObjectPtr ice_clone() const;

    virtual bool ice_isA(const ::std::string&, const ::Ice::Current& = ::Ice::Current()) const;
    virtual ::std::vector< ::std::string> ice_ids(const ::Ice::Current& = ::Ice::Current()) const;
    virtual const ::std::string& ice_id(const ::Ice::Current& = ::Ice::Current()) const;
    static const ::std::string& ice_staticId();


    virtual void __write(::IceInternal::BasicStream*) const;
    virtual void __read(::IceInternal::BasicStream*, bool);
    virtual void __write(const ::Ice::OutputStreamPtr&) const;
    virtual void __read(const ::Ice::InputStreamPtr&, bool);

    static const ::Ice::ObjectFactoryPtr& ice_factory();

protected:

    virtual ~FindDocumentsRequest() {}

public:

    bool hasFrom;

    ::Ehr::Timestamp from;

    bool hasTill;

    ::Ehr::Timestamp till;

    ::Ehr::DocumentType type;

    ::Ice::Long documentId;
};

class CreatePermissionRequest : virtual public ::Ehr::Request
{
public:

    typedef CreatePermissionRequestPrx ProxyType;
    typedef CreatePermissionRequestPtr PointerType;
    
    CreatePermissionRequest() {}
    CreatePermissionRequest(const ::Ehr::AccountIdentifier&, const ::Ehr::Timestamp&, ::Ice::Long, const ::Ehr::AccountIdentifier&, ::Ehr::AccessType);
    virtual ::Ice::ObjectPtr ice_clone() const;

    virtual bool ice_isA(const ::std::string&, const ::Ice::Current& = ::Ice::Current()) const;
    virtual ::std::vector< ::std::string> ice_ids(const ::Ice::Current& = ::Ice::Current()) const;
    virtual const ::std::string& ice_id(const ::Ice::Current& = ::Ice::Current()) const;
    static const ::std::string& ice_staticId();


    virtual void __write(::IceInternal::BasicStream*) const;
    virtual void __read(::IceInternal::BasicStream*, bool);
    virtual void __write(const ::Ice::OutputStreamPtr&) const;
    virtual void __read(const ::Ice::InputStreamPtr&, bool);

    static const ::Ice::ObjectFactoryPtr& ice_factory();

protected:

    virtual ~CreatePermissionRequest() {}

public:

    ::Ice::Long documentId;

    ::Ehr::AccountIdentifier account;

    ::Ehr::AccessType access;
};

class SetDefaultAccessRequest : virtual public ::Ehr::Request
{
public:

    typedef SetDefaultAccessRequestPrx ProxyType;
    typedef SetDefaultAccessRequestPtr PointerType;
    
    SetDefaultAccessRequest() {}
    SetDefaultAccessRequest(const ::Ehr::AccountIdentifier&, const ::Ehr::Timestamp&, ::Ice::Long, ::Ehr::AccessType);
    virtual ::Ice::ObjectPtr ice_clone() const;

    virtual bool ice_isA(const ::std::string&, const ::Ice::Current& = ::Ice::Current()) const;
    virtual ::std::vector< ::std::string> ice_ids(const ::Ice::Current& = ::Ice::Current()) const;
    virtual const ::std::string& ice_id(const ::Ice::Current& = ::Ice::Current()) const;
    static const ::std::string& ice_staticId();


    virtual void __write(::IceInternal::BasicStream*) const;
    virtual void __read(::IceInternal::BasicStream*, bool);
    virtual void __write(const ::Ice::OutputStreamPtr&) const;
    virtual void __read(const ::Ice::InputStreamPtr&, bool);

    static const ::Ice::ObjectFactoryPtr& ice_factory();

protected:

    virtual ~SetDefaultAccessRequest() {}

public:

    ::Ice::Long documentId;

    ::Ehr::AccessType access;
};

class ListPermissionsRequest : virtual public ::Ehr::Request
{
public:

    typedef ListPermissionsRequestPrx ProxyType;
    typedef ListPermissionsRequestPtr PointerType;
    
    ListPermissionsRequest() {}
    ListPermissionsRequest(const ::Ehr::AccountIdentifier&, const ::Ehr::Timestamp&, ::Ice::Long);
    virtual ::Ice::ObjectPtr ice_clone() const;

    virtual bool ice_isA(const ::std::string&, const ::Ice::Current& = ::Ice::Current()) const;
    virtual ::std::vector< ::std::string> ice_ids(const ::Ice::Current& = ::Ice::Current()) const;
    virtual const ::std::string& ice_id(const ::Ice::Current& = ::Ice::Current()) const;
    static const ::std::string& ice_staticId();


    virtual void __write(::IceInternal::BasicStream*) const;
    virtual void __read(::IceInternal::BasicStream*, bool);
    virtual void __write(const ::Ice::OutputStreamPtr&) const;
    virtual void __read(const ::Ice::InputStreamPtr&, bool);

    static const ::Ice::ObjectFactoryPtr& ice_factory();

protected:

    virtual ~ListPermissionsRequest() {}

public:

    ::Ice::Long documentId;
};

class RemovePermissionRequest : virtual public ::Ehr::Request
{
public:

    typedef RemovePermissionRequestPrx ProxyType;
    typedef RemovePermissionRequestPtr PointerType;
    
    RemovePermissionRequest() {}
    RemovePermissionRequest(const ::Ehr::AccountIdentifier&, const ::Ehr::Timestamp&, ::Ice::Long, ::Ice::Long);
    virtual ::Ice::ObjectPtr ice_clone() const;

    virtual bool ice_isA(const ::std::string&, const ::Ice::Current& = ::Ice::Current()) const;
    virtual ::std::vector< ::std::string> ice_ids(const ::Ice::Current& = ::Ice::Current()) const;
    virtual const ::std::string& ice_id(const ::Ice::Current& = ::Ice::Current()) const;
    static const ::std::string& ice_staticId();


    virtual void __write(::IceInternal::BasicStream*) const;
    virtual void __read(::IceInternal::BasicStream*, bool);
    virtual void __write(const ::Ice::OutputStreamPtr&) const;
    virtual void __read(const ::Ice::InputStreamPtr&, bool);

    static const ::Ice::ObjectFactoryPtr& ice_factory();

protected:

    virtual ~RemovePermissionRequest() {}

public:

    ::Ice::Long documentId;

    ::Ice::Long permissionId;
};

class Provider : virtual public ::Ice::Object
{
public:

    typedef ProviderPrx ProxyType;
    typedef ProviderPtr PointerType;
    
    virtual ::Ice::ObjectPtr ice_clone() const;

    virtual bool ice_isA(const ::std::string&, const ::Ice::Current& = ::Ice::Current()) const;
    virtual ::std::vector< ::std::string> ice_ids(const ::Ice::Current& = ::Ice::Current()) const;
    virtual const ::std::string& ice_id(const ::Ice::Current& = ::Ice::Current()) const;
    static const ::std::string& ice_staticId();

    virtual void createPrescription(const ::Ehr::CreatePrescriptionRequestPtr&, const ::Ehr::Signature&, const ::Ehr::Signature&, const ::Ice::Current& = ::Ice::Current()) = 0;
    ::Ice::DispatchStatus ___createPrescription(::IceInternal::Incoming&, const ::Ice::Current&);

    virtual void consumePrescription(const ::Ehr::ConsumePrescriptionRequestPtr&, const ::Ehr::Signature&, const ::Ehr::Signature&, const ::Ice::Current& = ::Ice::Current()) = 0;
    ::Ice::DispatchStatus ___consumePrescription(::IceInternal::Incoming&, const ::Ice::Current&);

    virtual ::Ehr::DocumentList listDocuments(const ::Ehr::ListDocumentsRequestPtr&, const ::Ehr::Signature&, const ::Ehr::Signature&, const ::Ice::Current& = ::Ice::Current()) = 0;
    ::Ice::DispatchStatus ___listDocuments(::IceInternal::Incoming&, const ::Ice::Current&);

    virtual ::Ehr::DocumentList findDocuments(const ::Ehr::FindDocumentsRequestPtr&, const ::Ehr::Signature&, const ::Ehr::Signature&, const ::Ice::Current& = ::Ice::Current()) = 0;
    ::Ice::DispatchStatus ___findDocuments(::IceInternal::Incoming&, const ::Ice::Current&);

    virtual void setDefaultAccess(const ::Ehr::SetDefaultAccessRequestPtr&, const ::Ehr::Signature&, const ::Ice::Current& = ::Ice::Current()) = 0;
    ::Ice::DispatchStatus ___setDefaultAccess(::IceInternal::Incoming&, const ::Ice::Current&);

    virtual void createPermission(const ::Ehr::CreatePermissionRequestPtr&, const ::Ehr::Signature&, const ::Ice::Current& = ::Ice::Current()) = 0;
    ::Ice::DispatchStatus ___createPermission(::IceInternal::Incoming&, const ::Ice::Current&);

    virtual ::Ehr::Permissions listPermissions(const ::Ehr::ListPermissionsRequestPtr&, const ::Ehr::Signature&, const ::Ice::Current& = ::Ice::Current()) = 0;
    ::Ice::DispatchStatus ___listPermissions(::IceInternal::Incoming&, const ::Ice::Current&);

    virtual void removePermission(const ::Ehr::RemovePermissionRequestPtr&, const ::Ehr::Signature&, const ::Ice::Current& = ::Ice::Current()) = 0;
    ::Ice::DispatchStatus ___removePermission(::IceInternal::Incoming&, const ::Ice::Current&);

    virtual ::Ice::DispatchStatus __dispatch(::IceInternal::Incoming&, const ::Ice::Current&);

    virtual void __write(::IceInternal::BasicStream*) const;
    virtual void __read(::IceInternal::BasicStream*, bool);
    virtual void __write(const ::Ice::OutputStreamPtr&) const;
    virtual void __read(const ::Ice::InputStreamPtr&, bool);
};

}

#endif