From 1d8445b8461f558987067d870f0f11cdc84b4f35 Mon Sep 17 00:00:00 2001
From: manuel <manuel@nc8430.lan>
Date: Sat, 31 Oct 2009 16:11:26 +0100
Subject: pushing task1 to repo

---
 task1/ehr.h | 4594 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 4594 insertions(+)
 create mode 100644 task1/ehr.h

(limited to 'task1/ehr.h')

diff --git a/task1/ehr.h b/task1/ehr.h
new file mode 100644
index 0000000..7473373
--- /dev/null
+++ b/task1/ehr.h
@@ -0,0 +1,4594 @@
+// **********************************************************************
+//
+// 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
-- 
cgit v1.2.3