PatientAssessments.hxx

// Copyright (c) 2005-2014 Code Synthesis Tools CC
//
// This program was generated by CodeSynthesis XSD, an XML Schema to
// C++ data binding compiler.
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License version 2 as
// published by the Free Software Foundation.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
//
// In addition, as a special exception, Code Synthesis Tools CC gives
// permission to link this program with the Xerces-C++ library (or with
// modified versions of Xerces-C++ that use the same license as Xerces-C++),
// and distribute linked combinations including the two. You must obey
// the GNU General Public License version 2 in all respects for all of
// the code used other than Xerces-C++. If you modify this copy of the
// program, you may extend this exception to your version of the program,
// but you are not obligated to do so. If you do not wish to do so, delete
// this exception statement from your version.
//
// Furthermore, Code Synthesis Tools CC makes a special exception for
// the Free/Libre and Open Source Software (FLOSS) which is described
// in the accompanying FLOSSE file.
//

#ifndef D__BIOGEARS_CORE_SHARE_XSD__CDM_PATIENT_ASSESSMENTS_HXX
#define D__BIOGEARS_CORE_SHARE_XSD__CDM_PATIENT_ASSESSMENTS_HXX

#ifndef XSD_CXX11
#define XSD_CXX11
#endif

#ifndef XSD_USE_CHAR
#define XSD_USE_CHAR
#endif

#ifndef XSD_CXX_TREE_USE_CHAR
#define XSD_CXX_TREE_USE_CHAR
#endif

// Begin prologue.
//
#include <biogears/cdm-exports.h>
//
// End prologue.

#include <xsd/cxx/config.hxx>

#if (XSD_INT_VERSION != 4000000L)
#error XSD runtime version mismatch
#endif

#include <xsd/cxx/pre.hxx>

#include <xsd/cxx/xml/char-utf8.hxx>

#include <xsd/cxx/tree/exceptions.hxx>
#include <xsd/cxx/tree/elements.hxx>
#include <xsd/cxx/tree/types.hxx>

#include <xsd/cxx/xml/error-handler.hxx>

#include <xsd/cxx/xml/dom/auto-ptr.hxx>

#include <xsd/cxx/tree/parsing.hxx>
#include <xsd/cxx/tree/parsing/byte.hxx>
#include <xsd/cxx/tree/parsing/unsigned-byte.hxx>
#include <xsd/cxx/tree/parsing/short.hxx>
#include <xsd/cxx/tree/parsing/unsigned-short.hxx>
#include <xsd/cxx/tree/parsing/int.hxx>
#include <xsd/cxx/tree/parsing/unsigned-int.hxx>
#include <xsd/cxx/tree/parsing/long.hxx>
#include <xsd/cxx/tree/parsing/unsigned-long.hxx>
#include <xsd/cxx/tree/parsing/boolean.hxx>
#include <xsd/cxx/tree/parsing/float.hxx>
#include <xsd/cxx/tree/parsing/double.hxx>
#include <xsd/cxx/tree/parsing/decimal.hxx>

#include <xsd/cxx/xml/dom/serialization-header.hxx>
#include <xsd/cxx/tree/serialization.hxx>
#include <xsd/cxx/tree/serialization/byte.hxx>
#include <xsd/cxx/tree/serialization/unsigned-byte.hxx>
#include <xsd/cxx/tree/serialization/short.hxx>
#include <xsd/cxx/tree/serialization/unsigned-short.hxx>
#include <xsd/cxx/tree/serialization/int.hxx>
#include <xsd/cxx/tree/serialization/unsigned-int.hxx>
#include <xsd/cxx/tree/serialization/long.hxx>
#include <xsd/cxx/tree/serialization/unsigned-long.hxx>
#include <xsd/cxx/tree/serialization/boolean.hxx>
#include <xsd/cxx/tree/serialization/float.hxx>
#include <xsd/cxx/tree/serialization/double.hxx>
#include <xsd/cxx/tree/serialization/decimal.hxx>

#include <xsd/cxx/tree/std-ostream-operators.hxx>

namespace xml_schema
{
  // anyType and anySimpleType.
  //

  typedef ::xsd::cxx::tree::type type;

  typedef ::xsd::cxx::tree::simple_type< char, type > simple_type;

  typedef ::xsd::cxx::tree::type container;


  // 8-bit
  //

  typedef signed char byte;

  typedef unsigned char unsigned_byte;


  // 16-bit
  //

  typedef short short_;

  typedef unsigned short unsigned_short;


  // 32-bit
  //

  typedef int int_;

  typedef unsigned int unsigned_int;


  // 64-bit
  //

  typedef long long long_;

  typedef unsigned long long unsigned_long;


  // Supposed to be arbitrary-length integral types.
  //

  typedef long long integer;

  typedef long long non_positive_integer;

  typedef unsigned long long non_negative_integer;

  typedef unsigned long long positive_integer;

  typedef long long negative_integer;


  // Boolean.
  //

  typedef bool boolean;


  // Floating-point types.
  //

  typedef float float_;

  typedef double double_;

  typedef double decimal;


  // String types.
  //

  typedef ::xsd::cxx::tree::string< char, simple_type > string;

  typedef ::xsd::cxx::tree::normalized_string< char, string > normalized_string;

  typedef ::xsd::cxx::tree::token< char, normalized_string > token;

  typedef ::xsd::cxx::tree::name< char, token > name;

  typedef ::xsd::cxx::tree::nmtoken< char, token > nmtoken;

  typedef ::xsd::cxx::tree::nmtokens< char, simple_type, nmtoken > nmtokens;

  typedef ::xsd::cxx::tree::ncname< char, name > ncname;

  typedef ::xsd::cxx::tree::language< char, token > language;


  // ID/IDREF.
  //

  typedef ::xsd::cxx::tree::id< char, ncname > id;

  typedef ::xsd::cxx::tree::idref< char, ncname, type > idref;

  typedef ::xsd::cxx::tree::idrefs< char, simple_type, idref > idrefs;


  // URI.
  //

  typedef ::xsd::cxx::tree::uri< char, simple_type > uri;


  // Qualified name.
  //

  typedef ::xsd::cxx::tree::qname< char, simple_type, uri, ncname > qname;


  // Binary.
  //

  typedef ::xsd::cxx::tree::buffer< char > buffer;

  typedef ::xsd::cxx::tree::base64_binary< char, simple_type > base64_binary;

  typedef ::xsd::cxx::tree::hex_binary< char, simple_type > hex_binary;


  // Date/time.
  //

  typedef ::xsd::cxx::tree::time_zone time_zone;

  typedef ::xsd::cxx::tree::date< char, simple_type > date;

  typedef ::xsd::cxx::tree::date_time< char, simple_type > date_time;

  typedef ::xsd::cxx::tree::duration< char, simple_type > duration;

  typedef ::xsd::cxx::tree::gday< char, simple_type > gday;

  typedef ::xsd::cxx::tree::gmonth< char, simple_type > gmonth;

  typedef ::xsd::cxx::tree::gmonth_day< char, simple_type > gmonth_day;

  typedef ::xsd::cxx::tree::gyear< char, simple_type > gyear;

  typedef ::xsd::cxx::tree::gyear_month< char, simple_type > gyear_month;

  typedef ::xsd::cxx::tree::time< char, simple_type > time;


  // Entity.
  //

  typedef ::xsd::cxx::tree::entity< char, ncname > entity;

  typedef ::xsd::cxx::tree::entities< char, simple_type, entity > entities;



  typedef ::xsd::cxx::tree::content_order content_order;
  // Namespace information and list stream. Used in
  // serialization functions.
  //
  typedef ::xsd::cxx::xml::dom::namespace_info< char > namespace_info;

  typedef ::xsd::cxx::xml::dom::namespace_infomap< char > namespace_infomap;

  typedef ::xsd::cxx::tree::list_stream< char > list_stream;

  typedef ::xsd::cxx::tree::as_double< double_ > as_double;

  typedef ::xsd::cxx::tree::as_decimal< decimal > as_decimal;

  typedef ::xsd::cxx::tree::facet facet;

  // Flags and properties.
  //

  typedef ::xsd::cxx::tree::flags flags;

  typedef ::xsd::cxx::tree::properties< char > properties;

  // Parsing/serialization diagnostics.
  //

  typedef ::xsd::cxx::tree::severity severity;

  typedef ::xsd::cxx::tree::error< char > error;

  typedef ::xsd::cxx::tree::diagnostics< char > diagnostics;

  // Exceptions.
  //

  typedef ::xsd::cxx::tree::exception< char > exception;

  typedef ::xsd::cxx::tree::bounds< char > bounds;

  typedef ::xsd::cxx::tree::duplicate_id< char > duplicate_id;

  typedef ::xsd::cxx::tree::parsing< char > parsing;

  typedef ::xsd::cxx::tree::expected_element< char > expected_element;

  typedef ::xsd::cxx::tree::unexpected_element< char > unexpected_element;

  typedef ::xsd::cxx::tree::expected_attribute< char > expected_attribute;

  typedef ::xsd::cxx::tree::unexpected_enumerator< char > unexpected_enumerator;

  typedef ::xsd::cxx::tree::expected_text_content< char > expected_text_content;

  typedef ::xsd::cxx::tree::no_prefix_mapping< char > no_prefix_mapping;

  typedef ::xsd::cxx::tree::no_type_info< char > no_type_info;

  typedef ::xsd::cxx::tree::not_derived< char > not_derived;

  typedef ::xsd::cxx::tree::serialization< char > serialization;

  typedef ::xsd::cxx::xml::error_handler< char > error_handler;

  namespace dom
  {
    using ::xsd::cxx::xml::dom::unique_ptr;

#ifndef XSD_CXX_TREE_TREE_NODE_KEY__XML_SCHEMA
#define XSD_CXX_TREE_TREE_NODE_KEY__XML_SCHEMA

    const XMLCh* const tree_node_key = ::xsd::cxx::tree::user_data_keys::node;
#endif
  }
}

// Forward declarations.
//
namespace mil
{
  namespace tatrc
  {
    namespace physiology
    {
      namespace datamodel
      {
        class PatientAssessmentData;
        class PulmonaryFunctionTestData;
        class SequentialOrganFailureAssessmentData;
        class CompleteBloodCountData;
        class PsychomotorVigilanceTaskData;
        class ComprehensiveMetabolicPanelData;
        class enumPresenceIndicator;
        class enumClarityIndicator;
        class enumUrineColor;
        class enumMicroscopicObservationType;
        class enumMicroscopicObservationAmount;
        class UrinalysisData;
        class UrinalysisMicroscopicData;
      }
    }
  }
}


#include <memory>    // ::std::unique_ptr
#include <limits>    // std::numeric_limits
#include <algorithm> // std::binary_search
#include <utility>   // std::move

#include <xsd/cxx/xml/char-utf8.hxx>

#include <xsd/cxx/tree/exceptions.hxx>
#include <xsd/cxx/tree/elements.hxx>
#include <xsd/cxx/tree/containers.hxx>
#include <xsd/cxx/tree/list.hxx>

#include <xsd/cxx/xml/dom/parsing-header.hxx>

#include "properties.hxx"

namespace mil
{
  namespace tatrc
  {
    namespace physiology
    {
      namespace datamodel
      {
        class BIOGEARS_CDM_API PatientAssessmentData: public ::mil::tatrc::physiology::datamodel::ObjectData
        {
          public:

          PatientAssessmentData ();

          PatientAssessmentData (const ::xercesc::DOMElement& e,
                                 ::xml_schema::flags f = 0,
                                 ::xml_schema::container* c = 0);

          PatientAssessmentData (const PatientAssessmentData& x,
                                 ::xml_schema::flags f = 0,
                                 ::xml_schema::container* c = 0);

          virtual PatientAssessmentData*
          _clone (::xml_schema::flags f = 0,
                  ::xml_schema::container* c = 0) const;


          virtual 
          ~PatientAssessmentData ();
        };

        class BIOGEARS_CDM_API PulmonaryFunctionTestData: public ::mil::tatrc::physiology::datamodel::PatientAssessmentData
        {
          public:

          typedef ::mil::tatrc::physiology::datamodel::ScalarVolumeData ExpiratoryReserveVolume_type;

          typedef ::xsd::cxx::tree::optional< ExpiratoryReserveVolume_type > ExpiratoryReserveVolume_optional;

          typedef ::xsd::cxx::tree::traits< ExpiratoryReserveVolume_type, char > ExpiratoryReserveVolume_traits;

          const ExpiratoryReserveVolume_optional&
          ExpiratoryReserveVolume () const;

          ExpiratoryReserveVolume_optional&
          ExpiratoryReserveVolume ();

          void
          ExpiratoryReserveVolume (const ExpiratoryReserveVolume_type& x);

          void
          ExpiratoryReserveVolume (const ExpiratoryReserveVolume_optional& x);

          void
          ExpiratoryReserveVolume (::std::unique_ptr< ExpiratoryReserveVolume_type > p);



          typedef ::mil::tatrc::physiology::datamodel::ScalarVolumeData ForcedVitalCapacity_type;

          typedef ::xsd::cxx::tree::optional< ForcedVitalCapacity_type > ForcedVitalCapacity_optional;

          typedef ::xsd::cxx::tree::traits< ForcedVitalCapacity_type, char > ForcedVitalCapacity_traits;

          const ForcedVitalCapacity_optional&
          ForcedVitalCapacity () const;

          ForcedVitalCapacity_optional&
          ForcedVitalCapacity ();

          void
          ForcedVitalCapacity (const ForcedVitalCapacity_type& x);

          void
          ForcedVitalCapacity (const ForcedVitalCapacity_optional& x);

          void
          ForcedVitalCapacity (::std::unique_ptr< ForcedVitalCapacity_type > p);



          typedef ::mil::tatrc::physiology::datamodel::ScalarVolumeData ForcedExpiratoryVolume_type;

          typedef ::xsd::cxx::tree::optional< ForcedExpiratoryVolume_type > ForcedExpiratoryVolume_optional;

          typedef ::xsd::cxx::tree::traits< ForcedExpiratoryVolume_type, char > ForcedExpiratoryVolume_traits;

          const ForcedExpiratoryVolume_optional&
          ForcedExpiratoryVolume () const;

          ForcedExpiratoryVolume_optional&
          ForcedExpiratoryVolume ();

          void
          ForcedExpiratoryVolume (const ForcedExpiratoryVolume_type& x);

          void
          ForcedExpiratoryVolume (const ForcedExpiratoryVolume_optional& x);

          void
          ForcedExpiratoryVolume (::std::unique_ptr< ForcedExpiratoryVolume_type > p);



          typedef ::mil::tatrc::physiology::datamodel::ScalarVolumePerTimeData ForcedExpiratoryFlow_type;

          typedef ::xsd::cxx::tree::optional< ForcedExpiratoryFlow_type > ForcedExpiratoryFlow_optional;

          typedef ::xsd::cxx::tree::traits< ForcedExpiratoryFlow_type, char > ForcedExpiratoryFlow_traits;

          const ForcedExpiratoryFlow_optional&
          ForcedExpiratoryFlow () const;

          ForcedExpiratoryFlow_optional&
          ForcedExpiratoryFlow ();

          void
          ForcedExpiratoryFlow (const ForcedExpiratoryFlow_type& x);

          void
          ForcedExpiratoryFlow (const ForcedExpiratoryFlow_optional& x);

          void
          ForcedExpiratoryFlow (::std::unique_ptr< ForcedExpiratoryFlow_type > p);



          typedef ::mil::tatrc::physiology::datamodel::ScalarVolumeData FunctionalResidualCapacity_type;

          typedef ::xsd::cxx::tree::optional< FunctionalResidualCapacity_type > FunctionalResidualCapacity_optional;

          typedef ::xsd::cxx::tree::traits< FunctionalResidualCapacity_type, char > FunctionalResidualCapacity_traits;

          const FunctionalResidualCapacity_optional&
          FunctionalResidualCapacity () const;

          FunctionalResidualCapacity_optional&
          FunctionalResidualCapacity ();

          void
          FunctionalResidualCapacity (const FunctionalResidualCapacity_type& x);

          void
          FunctionalResidualCapacity (const FunctionalResidualCapacity_optional& x);

          void
          FunctionalResidualCapacity (::std::unique_ptr< FunctionalResidualCapacity_type > p);



          typedef ::mil::tatrc::physiology::datamodel::ScalarVolumeData InspiratoryCapacity_type;

          typedef ::xsd::cxx::tree::optional< InspiratoryCapacity_type > InspiratoryCapacity_optional;

          typedef ::xsd::cxx::tree::traits< InspiratoryCapacity_type, char > InspiratoryCapacity_traits;

          const InspiratoryCapacity_optional&
          InspiratoryCapacity () const;

          InspiratoryCapacity_optional&
          InspiratoryCapacity ();

          void
          InspiratoryCapacity (const InspiratoryCapacity_type& x);

          void
          InspiratoryCapacity (const InspiratoryCapacity_optional& x);

          void
          InspiratoryCapacity (::std::unique_ptr< InspiratoryCapacity_type > p);



          typedef ::mil::tatrc::physiology::datamodel::ScalarVolumeData InspiratoryReserveVolume_type;

          typedef ::xsd::cxx::tree::optional< InspiratoryReserveVolume_type > InspiratoryReserveVolume_optional;

          typedef ::xsd::cxx::tree::traits< InspiratoryReserveVolume_type, char > InspiratoryReserveVolume_traits;

          const InspiratoryReserveVolume_optional&
          InspiratoryReserveVolume () const;

          InspiratoryReserveVolume_optional&
          InspiratoryReserveVolume ();

          void
          InspiratoryReserveVolume (const InspiratoryReserveVolume_type& x);

          void
          InspiratoryReserveVolume (const InspiratoryReserveVolume_optional& x);

          void
          InspiratoryReserveVolume (::std::unique_ptr< InspiratoryReserveVolume_type > p);



          typedef ::mil::tatrc::physiology::datamodel::ScalarVolumeData MaximumVoluntaryVentilation_type;

          typedef ::xsd::cxx::tree::optional< MaximumVoluntaryVentilation_type > MaximumVoluntaryVentilation_optional;

          typedef ::xsd::cxx::tree::traits< MaximumVoluntaryVentilation_type, char > MaximumVoluntaryVentilation_traits;

          const MaximumVoluntaryVentilation_optional&
          MaximumVoluntaryVentilation () const;

          MaximumVoluntaryVentilation_optional&
          MaximumVoluntaryVentilation ();

          void
          MaximumVoluntaryVentilation (const MaximumVoluntaryVentilation_type& x);

          void
          MaximumVoluntaryVentilation (const MaximumVoluntaryVentilation_optional& x);

          void
          MaximumVoluntaryVentilation (::std::unique_ptr< MaximumVoluntaryVentilation_type > p);



          typedef ::mil::tatrc::physiology::datamodel::ScalarVolumePerTimeData PeakExpiratoryFlow_type;

          typedef ::xsd::cxx::tree::optional< PeakExpiratoryFlow_type > PeakExpiratoryFlow_optional;

          typedef ::xsd::cxx::tree::traits< PeakExpiratoryFlow_type, char > PeakExpiratoryFlow_traits;

          const PeakExpiratoryFlow_optional&
          PeakExpiratoryFlow () const;

          PeakExpiratoryFlow_optional&
          PeakExpiratoryFlow ();

          void
          PeakExpiratoryFlow (const PeakExpiratoryFlow_type& x);

          void
          PeakExpiratoryFlow (const PeakExpiratoryFlow_optional& x);

          void
          PeakExpiratoryFlow (::std::unique_ptr< PeakExpiratoryFlow_type > p);



          typedef ::mil::tatrc::physiology::datamodel::ScalarVolumeData ResidualVolume_type;

          typedef ::xsd::cxx::tree::optional< ResidualVolume_type > ResidualVolume_optional;

          typedef ::xsd::cxx::tree::traits< ResidualVolume_type, char > ResidualVolume_traits;

          const ResidualVolume_optional&
          ResidualVolume () const;

          ResidualVolume_optional&
          ResidualVolume ();

          void
          ResidualVolume (const ResidualVolume_type& x);

          void
          ResidualVolume (const ResidualVolume_optional& x);

          void
          ResidualVolume (::std::unique_ptr< ResidualVolume_type > p);



          typedef ::mil::tatrc::physiology::datamodel::ScalarVolumeData SlowVitalCapacity_type;

          typedef ::xsd::cxx::tree::optional< SlowVitalCapacity_type > SlowVitalCapacity_optional;

          typedef ::xsd::cxx::tree::traits< SlowVitalCapacity_type, char > SlowVitalCapacity_traits;

          const SlowVitalCapacity_optional&
          SlowVitalCapacity () const;

          SlowVitalCapacity_optional&
          SlowVitalCapacity ();

          void
          SlowVitalCapacity (const SlowVitalCapacity_type& x);

          void
          SlowVitalCapacity (const SlowVitalCapacity_optional& x);

          void
          SlowVitalCapacity (::std::unique_ptr< SlowVitalCapacity_type > p);



          typedef ::mil::tatrc::physiology::datamodel::ScalarVolumeData TotalLungCapacity_type;

          typedef ::xsd::cxx::tree::optional< TotalLungCapacity_type > TotalLungCapacity_optional;

          typedef ::xsd::cxx::tree::traits< TotalLungCapacity_type, char > TotalLungCapacity_traits;

          const TotalLungCapacity_optional&
          TotalLungCapacity () const;

          TotalLungCapacity_optional&
          TotalLungCapacity ();

          void
          TotalLungCapacity (const TotalLungCapacity_type& x);

          void
          TotalLungCapacity (const TotalLungCapacity_optional& x);

          void
          TotalLungCapacity (::std::unique_ptr< TotalLungCapacity_type > p);



          typedef ::mil::tatrc::physiology::datamodel::ScalarVolumeData VitalCapacity_type;

          typedef ::xsd::cxx::tree::optional< VitalCapacity_type > VitalCapacity_optional;

          typedef ::xsd::cxx::tree::traits< VitalCapacity_type, char > VitalCapacity_traits;

          const VitalCapacity_optional&
          VitalCapacity () const;

          VitalCapacity_optional&
          VitalCapacity ();

          void
          VitalCapacity (const VitalCapacity_type& x);

          void
          VitalCapacity (const VitalCapacity_optional& x);

          void
          VitalCapacity (::std::unique_ptr< VitalCapacity_type > p);



          typedef ::mil::tatrc::physiology::datamodel::FunctionVolumeVsTimeData LungVolumePlot_type;

          typedef ::xsd::cxx::tree::optional< LungVolumePlot_type > LungVolumePlot_optional;

          typedef ::xsd::cxx::tree::traits< LungVolumePlot_type, char > LungVolumePlot_traits;

          const LungVolumePlot_optional&
          LungVolumePlot () const;

          LungVolumePlot_optional&
          LungVolumePlot ();

          void
          LungVolumePlot (const LungVolumePlot_type& x);

          void
          LungVolumePlot (const LungVolumePlot_optional& x);

          void
          LungVolumePlot (::std::unique_ptr< LungVolumePlot_type > p);



          PulmonaryFunctionTestData ();

          PulmonaryFunctionTestData (const ::xercesc::DOMElement& e,
                                     ::xml_schema::flags f = 0,
                                     ::xml_schema::container* c = 0);

          PulmonaryFunctionTestData (const PulmonaryFunctionTestData& x,
                                     ::xml_schema::flags f = 0,
                                     ::xml_schema::container* c = 0);

          virtual PulmonaryFunctionTestData*
          _clone (::xml_schema::flags f = 0,
                  ::xml_schema::container* c = 0) const;

          PulmonaryFunctionTestData&
          operator= (const PulmonaryFunctionTestData& x);


          virtual 
          ~PulmonaryFunctionTestData ();

          // Implementation.
          //

          //@cond

          protected:
          void
          parse (::xsd::cxx::xml::dom::parser< char >&,
                 ::xml_schema::flags);

          protected:
          ExpiratoryReserveVolume_optional ExpiratoryReserveVolume_;
          ForcedVitalCapacity_optional ForcedVitalCapacity_;
          ForcedExpiratoryVolume_optional ForcedExpiratoryVolume_;
          ForcedExpiratoryFlow_optional ForcedExpiratoryFlow_;
          FunctionalResidualCapacity_optional FunctionalResidualCapacity_;
          InspiratoryCapacity_optional InspiratoryCapacity_;
          InspiratoryReserveVolume_optional InspiratoryReserveVolume_;
          MaximumVoluntaryVentilation_optional MaximumVoluntaryVentilation_;
          PeakExpiratoryFlow_optional PeakExpiratoryFlow_;
          ResidualVolume_optional ResidualVolume_;
          SlowVitalCapacity_optional SlowVitalCapacity_;
          TotalLungCapacity_optional TotalLungCapacity_;
          VitalCapacity_optional VitalCapacity_;
          LungVolumePlot_optional LungVolumePlot_;

          //@endcond
        };

        class BIOGEARS_CDM_API SequentialOrganFailureAssessmentData: public ::mil::tatrc::physiology::datamodel::PatientAssessmentData
        {
          public:

          typedef ::mil::tatrc::physiology::datamodel::ScalarData RespirationSOFA_type;

          typedef ::xsd::cxx::tree::traits< RespirationSOFA_type, char > RespirationSOFA_traits;

          const RespirationSOFA_type&
          RespirationSOFA () const;

          RespirationSOFA_type&
          RespirationSOFA ();

          void
          RespirationSOFA (const RespirationSOFA_type& x);

          void
          RespirationSOFA (::std::unique_ptr< RespirationSOFA_type > p);



          typedef ::mil::tatrc::physiology::datamodel::ScalarData CoagulationSOFA_type;

          typedef ::xsd::cxx::tree::traits< CoagulationSOFA_type, char > CoagulationSOFA_traits;

          const CoagulationSOFA_type&
          CoagulationSOFA () const;

          CoagulationSOFA_type&
          CoagulationSOFA ();

          void
          CoagulationSOFA (const CoagulationSOFA_type& x);

          void
          CoagulationSOFA (::std::unique_ptr< CoagulationSOFA_type > p);



          typedef ::mil::tatrc::physiology::datamodel::ScalarData LiverSOFA_type;

          typedef ::xsd::cxx::tree::traits< LiverSOFA_type, char > LiverSOFA_traits;

          const LiverSOFA_type&
          LiverSOFA () const;

          LiverSOFA_type&
          LiverSOFA ();

          void
          LiverSOFA (const LiverSOFA_type& x);

          void
          LiverSOFA (::std::unique_ptr< LiverSOFA_type > p);



          typedef ::mil::tatrc::physiology::datamodel::ScalarData CardiovascularSOFA_type;

          typedef ::xsd::cxx::tree::traits< CardiovascularSOFA_type, char > CardiovascularSOFA_traits;

          const CardiovascularSOFA_type&
          CardiovascularSOFA () const;

          CardiovascularSOFA_type&
          CardiovascularSOFA ();

          void
          CardiovascularSOFA (const CardiovascularSOFA_type& x);

          void
          CardiovascularSOFA (::std::unique_ptr< CardiovascularSOFA_type > p);



          typedef ::mil::tatrc::physiology::datamodel::ScalarData CentralNervousSOFA_type;

          typedef ::xsd::cxx::tree::traits< CentralNervousSOFA_type, char > CentralNervousSOFA_traits;

          const CentralNervousSOFA_type&
          CentralNervousSOFA () const;

          CentralNervousSOFA_type&
          CentralNervousSOFA ();

          void
          CentralNervousSOFA (const CentralNervousSOFA_type& x);

          void
          CentralNervousSOFA (::std::unique_ptr< CentralNervousSOFA_type > p);



          typedef ::mil::tatrc::physiology::datamodel::ScalarData RenalSOFA_type;

          typedef ::xsd::cxx::tree::traits< RenalSOFA_type, char > RenalSOFA_traits;

          const RenalSOFA_type&
          RenalSOFA () const;

          RenalSOFA_type&
          RenalSOFA ();

          void
          RenalSOFA (const RenalSOFA_type& x);

          void
          RenalSOFA (::std::unique_ptr< RenalSOFA_type > p);



          SequentialOrganFailureAssessmentData ();

          SequentialOrganFailureAssessmentData (const RespirationSOFA_type&,
                                                const CoagulationSOFA_type&,
                                                const LiverSOFA_type&,
                                                const CardiovascularSOFA_type&,
                                                const CentralNervousSOFA_type&,
                                                const RenalSOFA_type&);

          SequentialOrganFailureAssessmentData (::std::unique_ptr< RespirationSOFA_type >,
                                                ::std::unique_ptr< CoagulationSOFA_type >,
                                                ::std::unique_ptr< LiverSOFA_type >,
                                                ::std::unique_ptr< CardiovascularSOFA_type >,
                                                ::std::unique_ptr< CentralNervousSOFA_type >,
                                                ::std::unique_ptr< RenalSOFA_type >);

          SequentialOrganFailureAssessmentData (const ::xercesc::DOMElement& e,
                                                ::xml_schema::flags f = 0,
                                                ::xml_schema::container* c = 0);

          SequentialOrganFailureAssessmentData (const SequentialOrganFailureAssessmentData& x,
                                                ::xml_schema::flags f = 0,
                                                ::xml_schema::container* c = 0);

          virtual SequentialOrganFailureAssessmentData*
          _clone (::xml_schema::flags f = 0,
                  ::xml_schema::container* c = 0) const;

          SequentialOrganFailureAssessmentData&
          operator= (const SequentialOrganFailureAssessmentData& x);


          virtual 
          ~SequentialOrganFailureAssessmentData ();

          // Implementation.
          //

          //@cond

          protected:
          void
          parse (::xsd::cxx::xml::dom::parser< char >&,
                 ::xml_schema::flags);

          protected:
          ::xsd::cxx::tree::one< RespirationSOFA_type > RespirationSOFA_;
          ::xsd::cxx::tree::one< CoagulationSOFA_type > CoagulationSOFA_;
          ::xsd::cxx::tree::one< LiverSOFA_type > LiverSOFA_;
          ::xsd::cxx::tree::one< CardiovascularSOFA_type > CardiovascularSOFA_;
          ::xsd::cxx::tree::one< CentralNervousSOFA_type > CentralNervousSOFA_;
          ::xsd::cxx::tree::one< RenalSOFA_type > RenalSOFA_;

          //@endcond
        };

        class BIOGEARS_CDM_API CompleteBloodCountData: public ::mil::tatrc::physiology::datamodel::PatientAssessmentData
        {
          public:

          typedef ::mil::tatrc::physiology::datamodel::ScalarFractionData Hematocrit_type;

          typedef ::xsd::cxx::tree::optional< Hematocrit_type > Hematocrit_optional;

          typedef ::xsd::cxx::tree::traits< Hematocrit_type, char > Hematocrit_traits;

          const Hematocrit_optional&
          Hematocrit () const;

          Hematocrit_optional&
          Hematocrit ();

          void
          Hematocrit (const Hematocrit_type& x);

          void
          Hematocrit (const Hematocrit_optional& x);

          void
          Hematocrit (::std::unique_ptr< Hematocrit_type > p);



          typedef ::mil::tatrc::physiology::datamodel::ScalarMassPerVolumeData Hemoglobin_type;

          typedef ::xsd::cxx::tree::optional< Hemoglobin_type > Hemoglobin_optional;

          typedef ::xsd::cxx::tree::traits< Hemoglobin_type, char > Hemoglobin_traits;

          const Hemoglobin_optional&
          Hemoglobin () const;

          Hemoglobin_optional&
          Hemoglobin ();

          void
          Hemoglobin (const Hemoglobin_type& x);

          void
          Hemoglobin (const Hemoglobin_optional& x);

          void
          Hemoglobin (::std::unique_ptr< Hemoglobin_type > p);



          typedef ::mil::tatrc::physiology::datamodel::ScalarAmountPerVolumeData PlateletCount_type;

          typedef ::xsd::cxx::tree::optional< PlateletCount_type > PlateletCount_optional;

          typedef ::xsd::cxx::tree::traits< PlateletCount_type, char > PlateletCount_traits;

          const PlateletCount_optional&
          PlateletCount () const;

          PlateletCount_optional&
          PlateletCount ();

          void
          PlateletCount (const PlateletCount_type& x);

          void
          PlateletCount (const PlateletCount_optional& x);

          void
          PlateletCount (::std::unique_ptr< PlateletCount_type > p);



          typedef ::mil::tatrc::physiology::datamodel::ScalarMassPerAmountData MeanCorpuscularHemoglobin_type;

          typedef ::xsd::cxx::tree::optional< MeanCorpuscularHemoglobin_type > MeanCorpuscularHemoglobin_optional;

          typedef ::xsd::cxx::tree::traits< MeanCorpuscularHemoglobin_type, char > MeanCorpuscularHemoglobin_traits;

          const MeanCorpuscularHemoglobin_optional&
          MeanCorpuscularHemoglobin () const;

          MeanCorpuscularHemoglobin_optional&
          MeanCorpuscularHemoglobin ();

          void
          MeanCorpuscularHemoglobin (const MeanCorpuscularHemoglobin_type& x);

          void
          MeanCorpuscularHemoglobin (const MeanCorpuscularHemoglobin_optional& x);

          void
          MeanCorpuscularHemoglobin (::std::unique_ptr< MeanCorpuscularHemoglobin_type > p);



          typedef ::mil::tatrc::physiology::datamodel::ScalarMassPerVolumeData MeanCorpuscularHemoglobinConcentration_type;

          typedef ::xsd::cxx::tree::optional< MeanCorpuscularHemoglobinConcentration_type > MeanCorpuscularHemoglobinConcentration_optional;

          typedef ::xsd::cxx::tree::traits< MeanCorpuscularHemoglobinConcentration_type, char > MeanCorpuscularHemoglobinConcentration_traits;

          const MeanCorpuscularHemoglobinConcentration_optional&
          MeanCorpuscularHemoglobinConcentration () const;

          MeanCorpuscularHemoglobinConcentration_optional&
          MeanCorpuscularHemoglobinConcentration ();

          void
          MeanCorpuscularHemoglobinConcentration (const MeanCorpuscularHemoglobinConcentration_type& x);

          void
          MeanCorpuscularHemoglobinConcentration (const MeanCorpuscularHemoglobinConcentration_optional& x);

          void
          MeanCorpuscularHemoglobinConcentration (::std::unique_ptr< MeanCorpuscularHemoglobinConcentration_type > p);



          typedef ::mil::tatrc::physiology::datamodel::ScalarVolumeData MeanCorpuscularVolume_type;

          typedef ::xsd::cxx::tree::optional< MeanCorpuscularVolume_type > MeanCorpuscularVolume_optional;

          typedef ::xsd::cxx::tree::traits< MeanCorpuscularVolume_type, char > MeanCorpuscularVolume_traits;

          const MeanCorpuscularVolume_optional&
          MeanCorpuscularVolume () const;

          MeanCorpuscularVolume_optional&
          MeanCorpuscularVolume ();

          void
          MeanCorpuscularVolume (const MeanCorpuscularVolume_type& x);

          void
          MeanCorpuscularVolume (const MeanCorpuscularVolume_optional& x);

          void
          MeanCorpuscularVolume (::std::unique_ptr< MeanCorpuscularVolume_type > p);



          typedef ::mil::tatrc::physiology::datamodel::ScalarAmountPerVolumeData RedBloodCellCount_type;

          typedef ::xsd::cxx::tree::optional< RedBloodCellCount_type > RedBloodCellCount_optional;

          typedef ::xsd::cxx::tree::traits< RedBloodCellCount_type, char > RedBloodCellCount_traits;

          const RedBloodCellCount_optional&
          RedBloodCellCount () const;

          RedBloodCellCount_optional&
          RedBloodCellCount ();

          void
          RedBloodCellCount (const RedBloodCellCount_type& x);

          void
          RedBloodCellCount (const RedBloodCellCount_optional& x);

          void
          RedBloodCellCount (::std::unique_ptr< RedBloodCellCount_type > p);



          typedef ::mil::tatrc::physiology::datamodel::ScalarAmountPerVolumeData WhiteBloodCellCount_type;

          typedef ::xsd::cxx::tree::optional< WhiteBloodCellCount_type > WhiteBloodCellCount_optional;

          typedef ::xsd::cxx::tree::traits< WhiteBloodCellCount_type, char > WhiteBloodCellCount_traits;

          const WhiteBloodCellCount_optional&
          WhiteBloodCellCount () const;

          WhiteBloodCellCount_optional&
          WhiteBloodCellCount ();

          void
          WhiteBloodCellCount (const WhiteBloodCellCount_type& x);

          void
          WhiteBloodCellCount (const WhiteBloodCellCount_optional& x);

          void
          WhiteBloodCellCount (::std::unique_ptr< WhiteBloodCellCount_type > p);



          CompleteBloodCountData ();

          CompleteBloodCountData (const ::xercesc::DOMElement& e,
                                  ::xml_schema::flags f = 0,
                                  ::xml_schema::container* c = 0);

          CompleteBloodCountData (const CompleteBloodCountData& x,
                                  ::xml_schema::flags f = 0,
                                  ::xml_schema::container* c = 0);

          virtual CompleteBloodCountData*
          _clone (::xml_schema::flags f = 0,
                  ::xml_schema::container* c = 0) const;

          CompleteBloodCountData&
          operator= (const CompleteBloodCountData& x);


          virtual 
          ~CompleteBloodCountData ();

          // Implementation.
          //

          //@cond

          protected:
          void
          parse (::xsd::cxx::xml::dom::parser< char >&,
                 ::xml_schema::flags);

          protected:
          Hematocrit_optional Hematocrit_;
          Hemoglobin_optional Hemoglobin_;
          PlateletCount_optional PlateletCount_;
          MeanCorpuscularHemoglobin_optional MeanCorpuscularHemoglobin_;
          MeanCorpuscularHemoglobinConcentration_optional MeanCorpuscularHemoglobinConcentration_;
          MeanCorpuscularVolume_optional MeanCorpuscularVolume_;
          RedBloodCellCount_optional RedBloodCellCount_;
          WhiteBloodCellCount_optional WhiteBloodCellCount_;

          //@endcond
        };

        class BIOGEARS_CDM_API PsychomotorVigilanceTaskData: public ::mil::tatrc::physiology::datamodel::PatientAssessmentData
        {
          public:

          typedef ::mil::tatrc::physiology::datamodel::ScalarTimeData ReactionTime_type;

          typedef ::xsd::cxx::tree::optional< ReactionTime_type > ReactionTime_optional;

          typedef ::xsd::cxx::tree::traits< ReactionTime_type, char > ReactionTime_traits;

          const ReactionTime_optional&
          ReactionTime () const;

          ReactionTime_optional&
          ReactionTime ();

          void
          ReactionTime (const ReactionTime_type& x);

          void
          ReactionTime (const ReactionTime_optional& x);

          void
          ReactionTime (::std::unique_ptr< ReactionTime_type > p);



          typedef ::mil::tatrc::physiology::datamodel::ScalarData AttentionLapses_type;

          typedef ::xsd::cxx::tree::optional< AttentionLapses_type > AttentionLapses_optional;

          typedef ::xsd::cxx::tree::traits< AttentionLapses_type, char > AttentionLapses_traits;

          const AttentionLapses_optional&
          AttentionLapses () const;

          AttentionLapses_optional&
          AttentionLapses ();

          void
          AttentionLapses (const AttentionLapses_type& x);

          void
          AttentionLapses (const AttentionLapses_optional& x);

          void
          AttentionLapses (::std::unique_ptr< AttentionLapses_type > p);



          PsychomotorVigilanceTaskData ();

          PsychomotorVigilanceTaskData (const ::xercesc::DOMElement& e,
                                        ::xml_schema::flags f = 0,
                                        ::xml_schema::container* c = 0);

          PsychomotorVigilanceTaskData (const PsychomotorVigilanceTaskData& x,
                                        ::xml_schema::flags f = 0,
                                        ::xml_schema::container* c = 0);

          virtual PsychomotorVigilanceTaskData*
          _clone (::xml_schema::flags f = 0,
                  ::xml_schema::container* c = 0) const;

          PsychomotorVigilanceTaskData&
          operator= (const PsychomotorVigilanceTaskData& x);


          virtual 
          ~PsychomotorVigilanceTaskData ();

          // Implementation.
          //

          //@cond

          protected:
          void
          parse (::xsd::cxx::xml::dom::parser< char >&,
                 ::xml_schema::flags);

          protected:
          ReactionTime_optional ReactionTime_;
          AttentionLapses_optional AttentionLapses_;

          //@endcond
        };

        class BIOGEARS_CDM_API ComprehensiveMetabolicPanelData: public ::mil::tatrc::physiology::datamodel::PatientAssessmentData
        {
          public:

          typedef ::mil::tatrc::physiology::datamodel::ScalarMassPerVolumeData Albumin_type;

          typedef ::xsd::cxx::tree::optional< Albumin_type > Albumin_optional;

          typedef ::xsd::cxx::tree::traits< Albumin_type, char > Albumin_traits;

          const Albumin_optional&
          Albumin () const;

          Albumin_optional&
          Albumin ();

          void
          Albumin (const Albumin_type& x);

          void
          Albumin (const Albumin_optional& x);

          void
          Albumin (::std::unique_ptr< Albumin_type > p);



          typedef ::mil::tatrc::physiology::datamodel::ScalarMassPerVolumeData ALP_type;

          typedef ::xsd::cxx::tree::optional< ALP_type > ALP_optional;

          typedef ::xsd::cxx::tree::traits< ALP_type, char > ALP_traits;

          const ALP_optional&
          ALP () const;

          ALP_optional&
          ALP ();

          void
          ALP (const ALP_type& x);

          void
          ALP (const ALP_optional& x);

          void
          ALP (::std::unique_ptr< ALP_type > p);



          typedef ::mil::tatrc::physiology::datamodel::ScalarMassPerVolumeData ALT_type;

          typedef ::xsd::cxx::tree::optional< ALT_type > ALT_optional;

          typedef ::xsd::cxx::tree::traits< ALT_type, char > ALT_traits;

          const ALT_optional&
          ALT () const;

          ALT_optional&
          ALT ();

          void
          ALT (const ALT_type& x);

          void
          ALT (const ALT_optional& x);

          void
          ALT (::std::unique_ptr< ALT_type > p);



          typedef ::mil::tatrc::physiology::datamodel::ScalarMassPerVolumeData AST_type;

          typedef ::xsd::cxx::tree::optional< AST_type > AST_optional;

          typedef ::xsd::cxx::tree::traits< AST_type, char > AST_traits;

          const AST_optional&
          AST () const;

          AST_optional&
          AST ();

          void
          AST (const AST_type& x);

          void
          AST (const AST_optional& x);

          void
          AST (::std::unique_ptr< AST_type > p);



          typedef ::mil::tatrc::physiology::datamodel::ScalarMassPerVolumeData BUN_type;

          typedef ::xsd::cxx::tree::optional< BUN_type > BUN_optional;

          typedef ::xsd::cxx::tree::traits< BUN_type, char > BUN_traits;

          const BUN_optional&
          BUN () const;

          BUN_optional&
          BUN ();

          void
          BUN (const BUN_type& x);

          void
          BUN (const BUN_optional& x);

          void
          BUN (::std::unique_ptr< BUN_type > p);



          typedef ::mil::tatrc::physiology::datamodel::ScalarMassPerVolumeData Calcium_type;

          typedef ::xsd::cxx::tree::optional< Calcium_type > Calcium_optional;

          typedef ::xsd::cxx::tree::traits< Calcium_type, char > Calcium_traits;

          const Calcium_optional&
          Calcium () const;

          Calcium_optional&
          Calcium ();

          void
          Calcium (const Calcium_type& x);

          void
          Calcium (const Calcium_optional& x);

          void
          Calcium (::std::unique_ptr< Calcium_type > p);



          typedef ::mil::tatrc::physiology::datamodel::ScalarAmountPerVolumeData Chloride_type;

          typedef ::xsd::cxx::tree::optional< Chloride_type > Chloride_optional;

          typedef ::xsd::cxx::tree::traits< Chloride_type, char > Chloride_traits;

          const Chloride_optional&
          Chloride () const;

          Chloride_optional&
          Chloride ();

          void
          Chloride (const Chloride_type& x);

          void
          Chloride (const Chloride_optional& x);

          void
          Chloride (::std::unique_ptr< Chloride_type > p);



          typedef ::mil::tatrc::physiology::datamodel::ScalarAmountPerVolumeData CO2_type;

          typedef ::xsd::cxx::tree::optional< CO2_type > CO2_optional;

          typedef ::xsd::cxx::tree::traits< CO2_type, char > CO2_traits;

          const CO2_optional&
          CO2 () const;

          CO2_optional&
          CO2 ();

          void
          CO2 (const CO2_type& x);

          void
          CO2 (const CO2_optional& x);

          void
          CO2 (::std::unique_ptr< CO2_type > p);



          typedef ::mil::tatrc::physiology::datamodel::ScalarMassPerVolumeData Creatinine_type;

          typedef ::xsd::cxx::tree::optional< Creatinine_type > Creatinine_optional;

          typedef ::xsd::cxx::tree::traits< Creatinine_type, char > Creatinine_traits;

          const Creatinine_optional&
          Creatinine () const;

          Creatinine_optional&
          Creatinine ();

          void
          Creatinine (const Creatinine_type& x);

          void
          Creatinine (const Creatinine_optional& x);

          void
          Creatinine (::std::unique_ptr< Creatinine_type > p);



          typedef ::mil::tatrc::physiology::datamodel::ScalarMassPerVolumeData Glucose_type;

          typedef ::xsd::cxx::tree::optional< Glucose_type > Glucose_optional;

          typedef ::xsd::cxx::tree::traits< Glucose_type, char > Glucose_traits;

          const Glucose_optional&
          Glucose () const;

          Glucose_optional&
          Glucose ();

          void
          Glucose (const Glucose_type& x);

          void
          Glucose (const Glucose_optional& x);

          void
          Glucose (::std::unique_ptr< Glucose_type > p);



          typedef ::mil::tatrc::physiology::datamodel::ScalarAmountPerVolumeData Potassium_type;

          typedef ::xsd::cxx::tree::optional< Potassium_type > Potassium_optional;

          typedef ::xsd::cxx::tree::traits< Potassium_type, char > Potassium_traits;

          const Potassium_optional&
          Potassium () const;

          Potassium_optional&
          Potassium ();

          void
          Potassium (const Potassium_type& x);

          void
          Potassium (const Potassium_optional& x);

          void
          Potassium (::std::unique_ptr< Potassium_type > p);



          typedef ::mil::tatrc::physiology::datamodel::ScalarAmountPerVolumeData Sodium_type;

          typedef ::xsd::cxx::tree::optional< Sodium_type > Sodium_optional;

          typedef ::xsd::cxx::tree::traits< Sodium_type, char > Sodium_traits;

          const Sodium_optional&
          Sodium () const;

          Sodium_optional&
          Sodium ();

          void
          Sodium (const Sodium_type& x);

          void
          Sodium (const Sodium_optional& x);

          void
          Sodium (::std::unique_ptr< Sodium_type > p);



          typedef ::mil::tatrc::physiology::datamodel::ScalarMassPerVolumeData TotalBilirubin_type;

          typedef ::xsd::cxx::tree::optional< TotalBilirubin_type > TotalBilirubin_optional;

          typedef ::xsd::cxx::tree::traits< TotalBilirubin_type, char > TotalBilirubin_traits;

          const TotalBilirubin_optional&
          TotalBilirubin () const;

          TotalBilirubin_optional&
          TotalBilirubin ();

          void
          TotalBilirubin (const TotalBilirubin_type& x);

          void
          TotalBilirubin (const TotalBilirubin_optional& x);

          void
          TotalBilirubin (::std::unique_ptr< TotalBilirubin_type > p);



          typedef ::mil::tatrc::physiology::datamodel::ScalarMassPerVolumeData TotalProtein_type;

          typedef ::xsd::cxx::tree::optional< TotalProtein_type > TotalProtein_optional;

          typedef ::xsd::cxx::tree::traits< TotalProtein_type, char > TotalProtein_traits;

          const TotalProtein_optional&
          TotalProtein () const;

          TotalProtein_optional&
          TotalProtein ();

          void
          TotalProtein (const TotalProtein_type& x);

          void
          TotalProtein (const TotalProtein_optional& x);

          void
          TotalProtein (::std::unique_ptr< TotalProtein_type > p);



          ComprehensiveMetabolicPanelData ();

          ComprehensiveMetabolicPanelData (const ::xercesc::DOMElement& e,
                                           ::xml_schema::flags f = 0,
                                           ::xml_schema::container* c = 0);

          ComprehensiveMetabolicPanelData (const ComprehensiveMetabolicPanelData& x,
                                           ::xml_schema::flags f = 0,
                                           ::xml_schema::container* c = 0);

          virtual ComprehensiveMetabolicPanelData*
          _clone (::xml_schema::flags f = 0,
                  ::xml_schema::container* c = 0) const;

          ComprehensiveMetabolicPanelData&
          operator= (const ComprehensiveMetabolicPanelData& x);


          virtual 
          ~ComprehensiveMetabolicPanelData ();

          // Implementation.
          //

          //@cond

          protected:
          void
          parse (::xsd::cxx::xml::dom::parser< char >&,
                 ::xml_schema::flags);

          protected:
          Albumin_optional Albumin_;
          ALP_optional ALP_;
          ALT_optional ALT_;
          AST_optional AST_;
          BUN_optional BUN_;
          Calcium_optional Calcium_;
          Chloride_optional Chloride_;
          CO2_optional CO2_;
          Creatinine_optional Creatinine_;
          Glucose_optional Glucose_;
          Potassium_optional Potassium_;
          Sodium_optional Sodium_;
          TotalBilirubin_optional TotalBilirubin_;
          TotalProtein_optional TotalProtein_;

          //@endcond
        };

        class BIOGEARS_CDM_API enumPresenceIndicator: public ::xml_schema::string
        {
          public:

          enum value
          {
            Positive,
            Negative
          };

          enumPresenceIndicator ();

          enumPresenceIndicator (value v);

          enumPresenceIndicator (const char* v);

          enumPresenceIndicator (const ::std::string& v);

          enumPresenceIndicator (const ::xml_schema::string& v);

          enumPresenceIndicator (const ::xercesc::DOMElement& e,
                                 ::xml_schema::flags f = 0,
                                 ::xml_schema::container* c = 0);

          enumPresenceIndicator (const ::xercesc::DOMAttr& a,
                                 ::xml_schema::flags f = 0,
                                 ::xml_schema::container* c = 0);

          enumPresenceIndicator (const ::std::string& s,
                                 const ::xercesc::DOMElement* e,
                                 ::xml_schema::flags f = 0,
                                 ::xml_schema::container* c = 0);

          enumPresenceIndicator (const enumPresenceIndicator& x,
                                 ::xml_schema::flags f = 0,
                                 ::xml_schema::container* c = 0);

          virtual enumPresenceIndicator*
          _clone (::xml_schema::flags f = 0,
                  ::xml_schema::container* c = 0) const;

          enumPresenceIndicator&
          operator= (value v);

          virtual
          operator value () const
          {
            return _xsd_enumPresenceIndicator_convert ();
          }

          //@cond

          protected:
          value
          _xsd_enumPresenceIndicator_convert () const;

          public:
          static const char* const _xsd_enumPresenceIndicator_literals_[2];
          static const value _xsd_enumPresenceIndicator_indexes_[2];

          //@endcond
        };

        class BIOGEARS_CDM_API enumClarityIndicator: public ::xml_schema::string
        {
          public:

          enum value
          {
            Clear,
            SlightlyCloudy,
            Cloudy,
            Turbid
          };

          enumClarityIndicator ();

          enumClarityIndicator (value v);

          enumClarityIndicator (const char* v);

          enumClarityIndicator (const ::std::string& v);

          enumClarityIndicator (const ::xml_schema::string& v);

          enumClarityIndicator (const ::xercesc::DOMElement& e,
                                ::xml_schema::flags f = 0,
                                ::xml_schema::container* c = 0);

          enumClarityIndicator (const ::xercesc::DOMAttr& a,
                                ::xml_schema::flags f = 0,
                                ::xml_schema::container* c = 0);

          enumClarityIndicator (const ::std::string& s,
                                const ::xercesc::DOMElement* e,
                                ::xml_schema::flags f = 0,
                                ::xml_schema::container* c = 0);

          enumClarityIndicator (const enumClarityIndicator& x,
                                ::xml_schema::flags f = 0,
                                ::xml_schema::container* c = 0);

          virtual enumClarityIndicator*
          _clone (::xml_schema::flags f = 0,
                  ::xml_schema::container* c = 0) const;

          enumClarityIndicator&
          operator= (value v);

          virtual
          operator value () const
          {
            return _xsd_enumClarityIndicator_convert ();
          }

          //@cond

          protected:
          value
          _xsd_enumClarityIndicator_convert () const;

          public:
          static const char* const _xsd_enumClarityIndicator_literals_[4];
          static const value _xsd_enumClarityIndicator_indexes_[4];

          //@endcond
        };

        class BIOGEARS_CDM_API enumUrineColor: public ::xml_schema::string
        {
          public:

          enum value
          {
            PaleYellow,
            Yellow,
            DarkYellow,
            Pink
          };

          enumUrineColor ();

          enumUrineColor (value v);

          enumUrineColor (const char* v);

          enumUrineColor (const ::std::string& v);

          enumUrineColor (const ::xml_schema::string& v);

          enumUrineColor (const ::xercesc::DOMElement& e,
                          ::xml_schema::flags f = 0,
                          ::xml_schema::container* c = 0);

          enumUrineColor (const ::xercesc::DOMAttr& a,
                          ::xml_schema::flags f = 0,
                          ::xml_schema::container* c = 0);

          enumUrineColor (const ::std::string& s,
                          const ::xercesc::DOMElement* e,
                          ::xml_schema::flags f = 0,
                          ::xml_schema::container* c = 0);

          enumUrineColor (const enumUrineColor& x,
                          ::xml_schema::flags f = 0,
                          ::xml_schema::container* c = 0);

          virtual enumUrineColor*
          _clone (::xml_schema::flags f = 0,
                  ::xml_schema::container* c = 0) const;

          enumUrineColor&
          operator= (value v);

          virtual
          operator value () const
          {
            return _xsd_enumUrineColor_convert ();
          }

          //@cond

          protected:
          value
          _xsd_enumUrineColor_convert () const;

          public:
          static const char* const _xsd_enumUrineColor_literals_[4];
          static const value _xsd_enumUrineColor_indexes_[4];

          //@endcond
        };

        class BIOGEARS_CDM_API enumMicroscopicObservationType: public ::xml_schema::string
        {
          public:

          enum value
          {
            LowPowerField,
            HighPowerField
          };

          enumMicroscopicObservationType ();

          enumMicroscopicObservationType (value v);

          enumMicroscopicObservationType (const char* v);

          enumMicroscopicObservationType (const ::std::string& v);

          enumMicroscopicObservationType (const ::xml_schema::string& v);

          enumMicroscopicObservationType (const ::xercesc::DOMElement& e,
                                          ::xml_schema::flags f = 0,
                                          ::xml_schema::container* c = 0);

          enumMicroscopicObservationType (const ::xercesc::DOMAttr& a,
                                          ::xml_schema::flags f = 0,
                                          ::xml_schema::container* c = 0);

          enumMicroscopicObservationType (const ::std::string& s,
                                          const ::xercesc::DOMElement* e,
                                          ::xml_schema::flags f = 0,
                                          ::xml_schema::container* c = 0);

          enumMicroscopicObservationType (const enumMicroscopicObservationType& x,
                                          ::xml_schema::flags f = 0,
                                          ::xml_schema::container* c = 0);

          virtual enumMicroscopicObservationType*
          _clone (::xml_schema::flags f = 0,
                  ::xml_schema::container* c = 0) const;

          enumMicroscopicObservationType&
          operator= (value v);

          virtual
          operator value () const
          {
            return _xsd_enumMicroscopicObservationType_convert ();
          }

          //@cond

          protected:
          value
          _xsd_enumMicroscopicObservationType_convert () const;

          public:
          static const char* const _xsd_enumMicroscopicObservationType_literals_[2];
          static const value _xsd_enumMicroscopicObservationType_indexes_[2];

          //@endcond
        };

        class BIOGEARS_CDM_API enumMicroscopicObservationAmount: public ::xml_schema::string
        {
          public:

          enum value
          {
            Few,
            Moderate,
            Many
          };

          enumMicroscopicObservationAmount ();

          enumMicroscopicObservationAmount (value v);

          enumMicroscopicObservationAmount (const char* v);

          enumMicroscopicObservationAmount (const ::std::string& v);

          enumMicroscopicObservationAmount (const ::xml_schema::string& v);

          enumMicroscopicObservationAmount (const ::xercesc::DOMElement& e,
                                            ::xml_schema::flags f = 0,
                                            ::xml_schema::container* c = 0);

          enumMicroscopicObservationAmount (const ::xercesc::DOMAttr& a,
                                            ::xml_schema::flags f = 0,
                                            ::xml_schema::container* c = 0);

          enumMicroscopicObservationAmount (const ::std::string& s,
                                            const ::xercesc::DOMElement* e,
                                            ::xml_schema::flags f = 0,
                                            ::xml_schema::container* c = 0);

          enumMicroscopicObservationAmount (const enumMicroscopicObservationAmount& x,
                                            ::xml_schema::flags f = 0,
                                            ::xml_schema::container* c = 0);

          virtual enumMicroscopicObservationAmount*
          _clone (::xml_schema::flags f = 0,
                  ::xml_schema::container* c = 0) const;

          enumMicroscopicObservationAmount&
          operator= (value v);

          virtual
          operator value () const
          {
            return _xsd_enumMicroscopicObservationAmount_convert ();
          }

          //@cond

          protected:
          value
          _xsd_enumMicroscopicObservationAmount_convert () const;

          public:
          static const char* const _xsd_enumMicroscopicObservationAmount_literals_[3];
          static const value _xsd_enumMicroscopicObservationAmount_indexes_[3];

          //@endcond
        };

        class BIOGEARS_CDM_API UrinalysisData: public ::mil::tatrc::physiology::datamodel::PatientAssessmentData
        {
          public:

          typedef ::mil::tatrc::physiology::datamodel::enumUrineColor Color_type;

          typedef ::xsd::cxx::tree::optional< Color_type > Color_optional;

          typedef ::xsd::cxx::tree::traits< Color_type, char > Color_traits;

          const Color_optional&
          Color () const;

          Color_optional&
          Color ();

          void
          Color (const Color_type& x);

          void
          Color (const Color_optional& x);

          void
          Color (::std::unique_ptr< Color_type > p);



          typedef ::mil::tatrc::physiology::datamodel::enumClarityIndicator Appearance_type;

          typedef ::xsd::cxx::tree::optional< Appearance_type > Appearance_optional;

          typedef ::xsd::cxx::tree::traits< Appearance_type, char > Appearance_traits;

          const Appearance_optional&
          Appearance () const;

          Appearance_optional&
          Appearance ();

          void
          Appearance (const Appearance_type& x);

          void
          Appearance (const Appearance_optional& x);

          void
          Appearance (::std::unique_ptr< Appearance_type > p);



          typedef ::mil::tatrc::physiology::datamodel::enumPresenceIndicator Glucose_type;

          typedef ::xsd::cxx::tree::optional< Glucose_type > Glucose_optional;

          typedef ::xsd::cxx::tree::traits< Glucose_type, char > Glucose_traits;

          const Glucose_optional&
          Glucose () const;

          Glucose_optional&
          Glucose ();

          void
          Glucose (const Glucose_type& x);

          void
          Glucose (const Glucose_optional& x);

          void
          Glucose (::std::unique_ptr< Glucose_type > p);



          typedef ::mil::tatrc::physiology::datamodel::enumPresenceIndicator Ketone_type;

          typedef ::xsd::cxx::tree::optional< Ketone_type > Ketone_optional;

          typedef ::xsd::cxx::tree::traits< Ketone_type, char > Ketone_traits;

          const Ketone_optional&
          Ketone () const;

          Ketone_optional&
          Ketone ();

          void
          Ketone (const Ketone_type& x);

          void
          Ketone (const Ketone_optional& x);

          void
          Ketone (::std::unique_ptr< Ketone_type > p);



          typedef ::mil::tatrc::physiology::datamodel::ScalarData Bilirubin_type;

          typedef ::xsd::cxx::tree::optional< Bilirubin_type > Bilirubin_optional;

          typedef ::xsd::cxx::tree::traits< Bilirubin_type, char > Bilirubin_traits;

          const Bilirubin_optional&
          Bilirubin () const;

          Bilirubin_optional&
          Bilirubin ();

          void
          Bilirubin (const Bilirubin_type& x);

          void
          Bilirubin (const Bilirubin_optional& x);

          void
          Bilirubin (::std::unique_ptr< Bilirubin_type > p);



          typedef ::mil::tatrc::physiology::datamodel::ScalarData SpecificGravity_type;

          typedef ::xsd::cxx::tree::optional< SpecificGravity_type > SpecificGravity_optional;

          typedef ::xsd::cxx::tree::traits< SpecificGravity_type, char > SpecificGravity_traits;

          const SpecificGravity_optional&
          SpecificGravity () const;

          SpecificGravity_optional&
          SpecificGravity ();

          void
          SpecificGravity (const SpecificGravity_type& x);

          void
          SpecificGravity (const SpecificGravity_optional& x);

          void
          SpecificGravity (::std::unique_ptr< SpecificGravity_type > p);



          typedef ::mil::tatrc::physiology::datamodel::enumPresenceIndicator Blood_type;

          typedef ::xsd::cxx::tree::optional< Blood_type > Blood_optional;

          typedef ::xsd::cxx::tree::traits< Blood_type, char > Blood_traits;

          const Blood_optional&
          Blood () const;

          Blood_optional&
          Blood ();

          void
          Blood (const Blood_type& x);

          void
          Blood (const Blood_optional& x);

          void
          Blood (::std::unique_ptr< Blood_type > p);



          typedef ::mil::tatrc::physiology::datamodel::ScalarData pH_type;

          typedef ::xsd::cxx::tree::optional< pH_type > pH_optional;

          typedef ::xsd::cxx::tree::traits< pH_type, char > pH_traits;

          const pH_optional&
          pH () const;

          pH_optional&
          pH ();

          void
          pH (const pH_type& x);

          void
          pH (const pH_optional& x);

          void
          pH (::std::unique_ptr< pH_type > p);



          typedef ::mil::tatrc::physiology::datamodel::enumPresenceIndicator Protein_type;

          typedef ::xsd::cxx::tree::optional< Protein_type > Protein_optional;

          typedef ::xsd::cxx::tree::traits< Protein_type, char > Protein_traits;

          const Protein_optional&
          Protein () const;

          Protein_optional&
          Protein ();

          void
          Protein (const Protein_type& x);

          void
          Protein (const Protein_optional& x);

          void
          Protein (::std::unique_ptr< Protein_type > p);



          typedef ::mil::tatrc::physiology::datamodel::ScalarMassPerVolumeData Urobilinogen_type;

          typedef ::xsd::cxx::tree::optional< Urobilinogen_type > Urobilinogen_optional;

          typedef ::xsd::cxx::tree::traits< Urobilinogen_type, char > Urobilinogen_traits;

          const Urobilinogen_optional&
          Urobilinogen () const;

          Urobilinogen_optional&
          Urobilinogen ();

          void
          Urobilinogen (const Urobilinogen_type& x);

          void
          Urobilinogen (const Urobilinogen_optional& x);

          void
          Urobilinogen (::std::unique_ptr< Urobilinogen_type > p);



          typedef ::mil::tatrc::physiology::datamodel::enumPresenceIndicator Nitrite_type;

          typedef ::xsd::cxx::tree::optional< Nitrite_type > Nitrite_optional;

          typedef ::xsd::cxx::tree::traits< Nitrite_type, char > Nitrite_traits;

          const Nitrite_optional&
          Nitrite () const;

          Nitrite_optional&
          Nitrite ();

          void
          Nitrite (const Nitrite_type& x);

          void
          Nitrite (const Nitrite_optional& x);

          void
          Nitrite (::std::unique_ptr< Nitrite_type > p);



          typedef ::mil::tatrc::physiology::datamodel::enumPresenceIndicator LeukocyteEsterase_type;

          typedef ::xsd::cxx::tree::optional< LeukocyteEsterase_type > LeukocyteEsterase_optional;

          typedef ::xsd::cxx::tree::traits< LeukocyteEsterase_type, char > LeukocyteEsterase_traits;

          const LeukocyteEsterase_optional&
          LeukocyteEsterase () const;

          LeukocyteEsterase_optional&
          LeukocyteEsterase ();

          void
          LeukocyteEsterase (const LeukocyteEsterase_type& x);

          void
          LeukocyteEsterase (const LeukocyteEsterase_optional& x);

          void
          LeukocyteEsterase (::std::unique_ptr< LeukocyteEsterase_type > p);



          typedef ::mil::tatrc::physiology::datamodel::UrinalysisMicroscopicData Microscopic_type;

          typedef ::xsd::cxx::tree::optional< Microscopic_type > Microscopic_optional;

          typedef ::xsd::cxx::tree::traits< Microscopic_type, char > Microscopic_traits;

          const Microscopic_optional&
          Microscopic () const;

          Microscopic_optional&
          Microscopic ();

          void
          Microscopic (const Microscopic_type& x);

          void
          Microscopic (const Microscopic_optional& x);

          void
          Microscopic (::std::unique_ptr< Microscopic_type > p);



          UrinalysisData ();

          UrinalysisData (const ::xercesc::DOMElement& e,
                          ::xml_schema::flags f = 0,
                          ::xml_schema::container* c = 0);

          UrinalysisData (const UrinalysisData& x,
                          ::xml_schema::flags f = 0,
                          ::xml_schema::container* c = 0);

          virtual UrinalysisData*
          _clone (::xml_schema::flags f = 0,
                  ::xml_schema::container* c = 0) const;

          UrinalysisData&
          operator= (const UrinalysisData& x);


          virtual 
          ~UrinalysisData ();

          // Implementation.
          //

          //@cond

          protected:
          void
          parse (::xsd::cxx::xml::dom::parser< char >&,
                 ::xml_schema::flags);

          protected:
          Color_optional Color_;
          Appearance_optional Appearance_;
          Glucose_optional Glucose_;
          Ketone_optional Ketone_;
          Bilirubin_optional Bilirubin_;
          SpecificGravity_optional SpecificGravity_;
          Blood_optional Blood_;
          pH_optional pH_;
          Protein_optional Protein_;
          Urobilinogen_optional Urobilinogen_;
          Nitrite_optional Nitrite_;
          LeukocyteEsterase_optional LeukocyteEsterase_;
          Microscopic_optional Microscopic_;

          //@endcond
        };

        class BIOGEARS_CDM_API UrinalysisMicroscopicData: public ::mil::tatrc::physiology::datamodel::PatientAssessmentData
        {
          public:

          typedef ::mil::tatrc::physiology::datamodel::enumMicroscopicObservationType ObservationType_type;

          typedef ::xsd::cxx::tree::traits< ObservationType_type, char > ObservationType_traits;

          const ObservationType_type&
          ObservationType () const;

          ObservationType_type&
          ObservationType ();

          void
          ObservationType (const ObservationType_type& x);

          void
          ObservationType (::std::unique_ptr< ObservationType_type > p);



          typedef ::mil::tatrc::physiology::datamodel::ScalarAmountData RedBloodCells_type;

          typedef ::xsd::cxx::tree::optional< RedBloodCells_type > RedBloodCells_optional;

          typedef ::xsd::cxx::tree::traits< RedBloodCells_type, char > RedBloodCells_traits;

          const RedBloodCells_optional&
          RedBloodCells () const;

          RedBloodCells_optional&
          RedBloodCells ();

          void
          RedBloodCells (const RedBloodCells_type& x);

          void
          RedBloodCells (const RedBloodCells_optional& x);

          void
          RedBloodCells (::std::unique_ptr< RedBloodCells_type > p);



          typedef ::mil::tatrc::physiology::datamodel::ScalarAmountData WhiteBloodCells_type;

          typedef ::xsd::cxx::tree::optional< WhiteBloodCells_type > WhiteBloodCells_optional;

          typedef ::xsd::cxx::tree::traits< WhiteBloodCells_type, char > WhiteBloodCells_traits;

          const WhiteBloodCells_optional&
          WhiteBloodCells () const;

          WhiteBloodCells_optional&
          WhiteBloodCells ();

          void
          WhiteBloodCells (const WhiteBloodCells_type& x);

          void
          WhiteBloodCells (const WhiteBloodCells_optional& x);

          void
          WhiteBloodCells (::std::unique_ptr< WhiteBloodCells_type > p);



          typedef ::mil::tatrc::physiology::datamodel::enumMicroscopicObservationAmount EpithelialCells_type;

          typedef ::xsd::cxx::tree::optional< EpithelialCells_type > EpithelialCells_optional;

          typedef ::xsd::cxx::tree::traits< EpithelialCells_type, char > EpithelialCells_traits;

          const EpithelialCells_optional&
          EpithelialCells () const;

          EpithelialCells_optional&
          EpithelialCells ();

          void
          EpithelialCells (const EpithelialCells_type& x);

          void
          EpithelialCells (const EpithelialCells_optional& x);

          void
          EpithelialCells (::std::unique_ptr< EpithelialCells_type > p);



          typedef ::mil::tatrc::physiology::datamodel::ScalarAmountData Casts_type;

          typedef ::xsd::cxx::tree::optional< Casts_type > Casts_optional;

          typedef ::xsd::cxx::tree::traits< Casts_type, char > Casts_traits;

          const Casts_optional&
          Casts () const;

          Casts_optional&
          Casts ();

          void
          Casts (const Casts_type& x);

          void
          Casts (const Casts_optional& x);

          void
          Casts (::std::unique_ptr< Casts_type > p);



          typedef ::mil::tatrc::physiology::datamodel::enumMicroscopicObservationAmount Crystals_type;

          typedef ::xsd::cxx::tree::optional< Crystals_type > Crystals_optional;

          typedef ::xsd::cxx::tree::traits< Crystals_type, char > Crystals_traits;

          const Crystals_optional&
          Crystals () const;

          Crystals_optional&
          Crystals ();

          void
          Crystals (const Crystals_type& x);

          void
          Crystals (const Crystals_optional& x);

          void
          Crystals (::std::unique_ptr< Crystals_type > p);



          typedef ::mil::tatrc::physiology::datamodel::enumMicroscopicObservationAmount Bacteria_type;

          typedef ::xsd::cxx::tree::optional< Bacteria_type > Bacteria_optional;

          typedef ::xsd::cxx::tree::traits< Bacteria_type, char > Bacteria_traits;

          const Bacteria_optional&
          Bacteria () const;

          Bacteria_optional&
          Bacteria ();

          void
          Bacteria (const Bacteria_type& x);

          void
          Bacteria (const Bacteria_optional& x);

          void
          Bacteria (::std::unique_ptr< Bacteria_type > p);



          typedef ::mil::tatrc::physiology::datamodel::enumMicroscopicObservationAmount Trichomonads_type;

          typedef ::xsd::cxx::tree::optional< Trichomonads_type > Trichomonads_optional;

          typedef ::xsd::cxx::tree::traits< Trichomonads_type, char > Trichomonads_traits;

          const Trichomonads_optional&
          Trichomonads () const;

          Trichomonads_optional&
          Trichomonads ();

          void
          Trichomonads (const Trichomonads_type& x);

          void
          Trichomonads (const Trichomonads_optional& x);

          void
          Trichomonads (::std::unique_ptr< Trichomonads_type > p);



          typedef ::mil::tatrc::physiology::datamodel::enumMicroscopicObservationAmount Yeast_type;

          typedef ::xsd::cxx::tree::optional< Yeast_type > Yeast_optional;

          typedef ::xsd::cxx::tree::traits< Yeast_type, char > Yeast_traits;

          const Yeast_optional&
          Yeast () const;

          Yeast_optional&
          Yeast ();

          void
          Yeast (const Yeast_type& x);

          void
          Yeast (const Yeast_optional& x);

          void
          Yeast (::std::unique_ptr< Yeast_type > p);



          UrinalysisMicroscopicData ();

          UrinalysisMicroscopicData (const ObservationType_type&);

          UrinalysisMicroscopicData (::std::unique_ptr< ObservationType_type >);

          UrinalysisMicroscopicData (const ::xercesc::DOMElement& e,
                                     ::xml_schema::flags f = 0,
                                     ::xml_schema::container* c = 0);

          UrinalysisMicroscopicData (const UrinalysisMicroscopicData& x,
                                     ::xml_schema::flags f = 0,
                                     ::xml_schema::container* c = 0);

          virtual UrinalysisMicroscopicData*
          _clone (::xml_schema::flags f = 0,
                  ::xml_schema::container* c = 0) const;

          UrinalysisMicroscopicData&
          operator= (const UrinalysisMicroscopicData& x);


          virtual 
          ~UrinalysisMicroscopicData ();

          // Implementation.
          //

          //@cond

          protected:
          void
          parse (::xsd::cxx::xml::dom::parser< char >&,
                 ::xml_schema::flags);

          protected:
          ::xsd::cxx::tree::one< ObservationType_type > ObservationType_;
          RedBloodCells_optional RedBloodCells_;
          WhiteBloodCells_optional WhiteBloodCells_;
          EpithelialCells_optional EpithelialCells_;
          Casts_optional Casts_;
          Crystals_optional Crystals_;
          Bacteria_optional Bacteria_;
          Trichomonads_optional Trichomonads_;
          Yeast_optional Yeast_;

          //@endcond
        };
      }
    }
  }
}

#include <iosfwd>

namespace mil
{
  namespace tatrc
  {
    namespace physiology
    {
      namespace datamodel
      {
        BIOGEARS_CDM_API
        ::std::ostream&
        operator<< (::std::ostream&, const PatientAssessmentData&);

        BIOGEARS_CDM_API
        ::std::ostream&
        operator<< (::std::ostream&, const PulmonaryFunctionTestData&);

        BIOGEARS_CDM_API
        ::std::ostream&
        operator<< (::std::ostream&, const SequentialOrganFailureAssessmentData&);

        BIOGEARS_CDM_API
        ::std::ostream&
        operator<< (::std::ostream&, const CompleteBloodCountData&);

        BIOGEARS_CDM_API
        ::std::ostream&
        operator<< (::std::ostream&, const PsychomotorVigilanceTaskData&);

        BIOGEARS_CDM_API
        ::std::ostream&
        operator<< (::std::ostream&, const ComprehensiveMetabolicPanelData&);

        BIOGEARS_CDM_API
        ::std::ostream&
        operator<< (::std::ostream&, enumPresenceIndicator::value);

        BIOGEARS_CDM_API
        ::std::ostream&
        operator<< (::std::ostream&, const enumPresenceIndicator&);

        BIOGEARS_CDM_API
        ::std::ostream&
        operator<< (::std::ostream&, enumClarityIndicator::value);

        BIOGEARS_CDM_API
        ::std::ostream&
        operator<< (::std::ostream&, const enumClarityIndicator&);

        BIOGEARS_CDM_API
        ::std::ostream&
        operator<< (::std::ostream&, enumUrineColor::value);

        BIOGEARS_CDM_API
        ::std::ostream&
        operator<< (::std::ostream&, const enumUrineColor&);

        BIOGEARS_CDM_API
        ::std::ostream&
        operator<< (::std::ostream&, enumMicroscopicObservationType::value);

        BIOGEARS_CDM_API
        ::std::ostream&
        operator<< (::std::ostream&, const enumMicroscopicObservationType&);

        BIOGEARS_CDM_API
        ::std::ostream&
        operator<< (::std::ostream&, enumMicroscopicObservationAmount::value);

        BIOGEARS_CDM_API
        ::std::ostream&
        operator<< (::std::ostream&, const enumMicroscopicObservationAmount&);

        BIOGEARS_CDM_API
        ::std::ostream&
        operator<< (::std::ostream&, const UrinalysisData&);

        BIOGEARS_CDM_API
        ::std::ostream&
        operator<< (::std::ostream&, const UrinalysisMicroscopicData&);
      }
    }
  }
}

#include <iosfwd>

#include <xercesc/sax/InputSource.hpp>
#include <xercesc/dom/DOMDocument.hpp>
#include <xercesc/dom/DOMErrorHandler.hpp>

namespace mil
{
  namespace tatrc
  {
    namespace physiology
    {
      namespace datamodel
      {

        BIOGEARS_CDM_API
        ::std::unique_ptr< ::mil::tatrc::physiology::datamodel::PulmonaryFunctionTestData >
        PulmonaryFunctionTest (const ::std::string& uri,
                               ::xml_schema::flags f = 0,
                               const ::xml_schema::properties& p = ::xml_schema::properties ());

        BIOGEARS_CDM_API
        ::std::unique_ptr< ::mil::tatrc::physiology::datamodel::PulmonaryFunctionTestData >
        PulmonaryFunctionTest (const ::std::string& uri,
                               ::xml_schema::error_handler& eh,
                               ::xml_schema::flags f = 0,
                               const ::xml_schema::properties& p = ::xml_schema::properties ());

        BIOGEARS_CDM_API
        ::std::unique_ptr< ::mil::tatrc::physiology::datamodel::PulmonaryFunctionTestData >
        PulmonaryFunctionTest (const ::std::string& uri,
                               ::xercesc::DOMErrorHandler& eh,
                               ::xml_schema::flags f = 0,
                               const ::xml_schema::properties& p = ::xml_schema::properties ());

        BIOGEARS_CDM_API
        ::std::unique_ptr< ::mil::tatrc::physiology::datamodel::PulmonaryFunctionTestData >
        PulmonaryFunctionTest (::std::istream& is,
                               ::xml_schema::flags f = 0,
                               const ::xml_schema::properties& p = ::xml_schema::properties ());

        BIOGEARS_CDM_API
        ::std::unique_ptr< ::mil::tatrc::physiology::datamodel::PulmonaryFunctionTestData >
        PulmonaryFunctionTest (::std::istream& is,
                               ::xml_schema::error_handler& eh,
                               ::xml_schema::flags f = 0,
                               const ::xml_schema::properties& p = ::xml_schema::properties ());

        BIOGEARS_CDM_API
        ::std::unique_ptr< ::mil::tatrc::physiology::datamodel::PulmonaryFunctionTestData >
        PulmonaryFunctionTest (::std::istream& is,
                               ::xercesc::DOMErrorHandler& eh,
                               ::xml_schema::flags f = 0,
                               const ::xml_schema::properties& p = ::xml_schema::properties ());

        BIOGEARS_CDM_API
        ::std::unique_ptr< ::mil::tatrc::physiology::datamodel::PulmonaryFunctionTestData >
        PulmonaryFunctionTest (::std::istream& is,
                               const ::std::string& id,
                               ::xml_schema::flags f = 0,
                               const ::xml_schema::properties& p = ::xml_schema::properties ());

        BIOGEARS_CDM_API
        ::std::unique_ptr< ::mil::tatrc::physiology::datamodel::PulmonaryFunctionTestData >
        PulmonaryFunctionTest (::std::istream& is,
                               const ::std::string& id,
                               ::xml_schema::error_handler& eh,
                               ::xml_schema::flags f = 0,
                               const ::xml_schema::properties& p = ::xml_schema::properties ());

        BIOGEARS_CDM_API
        ::std::unique_ptr< ::mil::tatrc::physiology::datamodel::PulmonaryFunctionTestData >
        PulmonaryFunctionTest (::std::istream& is,
                               const ::std::string& id,
                               ::xercesc::DOMErrorHandler& eh,
                               ::xml_schema::flags f = 0,
                               const ::xml_schema::properties& p = ::xml_schema::properties ());

        BIOGEARS_CDM_API
        ::std::unique_ptr< ::mil::tatrc::physiology::datamodel::PulmonaryFunctionTestData >
        PulmonaryFunctionTest (::xercesc::InputSource& is,
                               ::xml_schema::flags f = 0,
                               const ::xml_schema::properties& p = ::xml_schema::properties ());

        BIOGEARS_CDM_API
        ::std::unique_ptr< ::mil::tatrc::physiology::datamodel::PulmonaryFunctionTestData >
        PulmonaryFunctionTest (::xercesc::InputSource& is,
                               ::xml_schema::error_handler& eh,
                               ::xml_schema::flags f = 0,
                               const ::xml_schema::properties& p = ::xml_schema::properties ());

        BIOGEARS_CDM_API
        ::std::unique_ptr< ::mil::tatrc::physiology::datamodel::PulmonaryFunctionTestData >
        PulmonaryFunctionTest (::xercesc::InputSource& is,
                               ::xercesc::DOMErrorHandler& eh,
                               ::xml_schema::flags f = 0,
                               const ::xml_schema::properties& p = ::xml_schema::properties ());

        BIOGEARS_CDM_API
        ::std::unique_ptr< ::mil::tatrc::physiology::datamodel::PulmonaryFunctionTestData >
        PulmonaryFunctionTest (const ::xercesc::DOMDocument& d,
                               ::xml_schema::flags f = 0,
                               const ::xml_schema::properties& p = ::xml_schema::properties ());

        BIOGEARS_CDM_API
        ::std::unique_ptr< ::mil::tatrc::physiology::datamodel::PulmonaryFunctionTestData >
        PulmonaryFunctionTest (::xml_schema::dom::unique_ptr< ::xercesc::DOMDocument > d,
                               ::xml_schema::flags f = 0,
                               const ::xml_schema::properties& p = ::xml_schema::properties ());



        BIOGEARS_CDM_API
        ::std::unique_ptr< ::mil::tatrc::physiology::datamodel::SequentialOrganFailureAssessmentData >
        SequentialOrganFailureAssessment (const ::std::string& uri,
                                          ::xml_schema::flags f = 0,
                                          const ::xml_schema::properties& p = ::xml_schema::properties ());

        BIOGEARS_CDM_API
        ::std::unique_ptr< ::mil::tatrc::physiology::datamodel::SequentialOrganFailureAssessmentData >
        SequentialOrganFailureAssessment (const ::std::string& uri,
                                          ::xml_schema::error_handler& eh,
                                          ::xml_schema::flags f = 0,
                                          const ::xml_schema::properties& p = ::xml_schema::properties ());

        BIOGEARS_CDM_API
        ::std::unique_ptr< ::mil::tatrc::physiology::datamodel::SequentialOrganFailureAssessmentData >
        SequentialOrganFailureAssessment (const ::std::string& uri,
                                          ::xercesc::DOMErrorHandler& eh,
                                          ::xml_schema::flags f = 0,
                                          const ::xml_schema::properties& p = ::xml_schema::properties ());

        BIOGEARS_CDM_API
        ::std::unique_ptr< ::mil::tatrc::physiology::datamodel::SequentialOrganFailureAssessmentData >
        SequentialOrganFailureAssessment (::std::istream& is,
                                          ::xml_schema::flags f = 0,
                                          const ::xml_schema::properties& p = ::xml_schema::properties ());

        BIOGEARS_CDM_API
        ::std::unique_ptr< ::mil::tatrc::physiology::datamodel::SequentialOrganFailureAssessmentData >
        SequentialOrganFailureAssessment (::std::istream& is,
                                          ::xml_schema::error_handler& eh,
                                          ::xml_schema::flags f = 0,
                                          const ::xml_schema::properties& p = ::xml_schema::properties ());

        BIOGEARS_CDM_API
        ::std::unique_ptr< ::mil::tatrc::physiology::datamodel::SequentialOrganFailureAssessmentData >
        SequentialOrganFailureAssessment (::std::istream& is,
                                          ::xercesc::DOMErrorHandler& eh,
                                          ::xml_schema::flags f = 0,
                                          const ::xml_schema::properties& p = ::xml_schema::properties ());

        BIOGEARS_CDM_API
        ::std::unique_ptr< ::mil::tatrc::physiology::datamodel::SequentialOrganFailureAssessmentData >
        SequentialOrganFailureAssessment (::std::istream& is,
                                          const ::std::string& id,
                                          ::xml_schema::flags f = 0,
                                          const ::xml_schema::properties& p = ::xml_schema::properties ());

        BIOGEARS_CDM_API
        ::std::unique_ptr< ::mil::tatrc::physiology::datamodel::SequentialOrganFailureAssessmentData >
        SequentialOrganFailureAssessment (::std::istream& is,
                                          const ::std::string& id,
                                          ::xml_schema::error_handler& eh,
                                          ::xml_schema::flags f = 0,
                                          const ::xml_schema::properties& p = ::xml_schema::properties ());

        BIOGEARS_CDM_API
        ::std::unique_ptr< ::mil::tatrc::physiology::datamodel::SequentialOrganFailureAssessmentData >
        SequentialOrganFailureAssessment (::std::istream& is,
                                          const ::std::string& id,
                                          ::xercesc::DOMErrorHandler& eh,
                                          ::xml_schema::flags f = 0,
                                          const ::xml_schema::properties& p = ::xml_schema::properties ());

        BIOGEARS_CDM_API
        ::std::unique_ptr< ::mil::tatrc::physiology::datamodel::SequentialOrganFailureAssessmentData >
        SequentialOrganFailureAssessment (::xercesc::InputSource& is,
                                          ::xml_schema::flags f = 0,
                                          const ::xml_schema::properties& p = ::xml_schema::properties ());

        BIOGEARS_CDM_API
        ::std::unique_ptr< ::mil::tatrc::physiology::datamodel::SequentialOrganFailureAssessmentData >
        SequentialOrganFailureAssessment (::xercesc::InputSource& is,
                                          ::xml_schema::error_handler& eh,
                                          ::xml_schema::flags f = 0,
                                          const ::xml_schema::properties& p = ::xml_schema::properties ());

        BIOGEARS_CDM_API
        ::std::unique_ptr< ::mil::tatrc::physiology::datamodel::SequentialOrganFailureAssessmentData >
        SequentialOrganFailureAssessment (::xercesc::InputSource& is,
                                          ::xercesc::DOMErrorHandler& eh,
                                          ::xml_schema::flags f = 0,
                                          const ::xml_schema::properties& p = ::xml_schema::properties ());

        BIOGEARS_CDM_API
        ::std::unique_ptr< ::mil::tatrc::physiology::datamodel::SequentialOrganFailureAssessmentData >
        SequentialOrganFailureAssessment (const ::xercesc::DOMDocument& d,
                                          ::xml_schema::flags f = 0,
                                          const ::xml_schema::properties& p = ::xml_schema::properties ());

        BIOGEARS_CDM_API
        ::std::unique_ptr< ::mil::tatrc::physiology::datamodel::SequentialOrganFailureAssessmentData >
        SequentialOrganFailureAssessment (::xml_schema::dom::unique_ptr< ::xercesc::DOMDocument > d,
                                          ::xml_schema::flags f = 0,
                                          const ::xml_schema::properties& p = ::xml_schema::properties ());



        BIOGEARS_CDM_API
        ::std::unique_ptr< ::mil::tatrc::physiology::datamodel::CompleteBloodCountData >
        CompleteBloodCount (const ::std::string& uri,
                            ::xml_schema::flags f = 0,
                            const ::xml_schema::properties& p = ::xml_schema::properties ());

        BIOGEARS_CDM_API
        ::std::unique_ptr< ::mil::tatrc::physiology::datamodel::CompleteBloodCountData >
        CompleteBloodCount (const ::std::string& uri,
                            ::xml_schema::error_handler& eh,
                            ::xml_schema::flags f = 0,
                            const ::xml_schema::properties& p = ::xml_schema::properties ());

        BIOGEARS_CDM_API
        ::std::unique_ptr< ::mil::tatrc::physiology::datamodel::CompleteBloodCountData >
        CompleteBloodCount (const ::std::string& uri,
                            ::xercesc::DOMErrorHandler& eh,
                            ::xml_schema::flags f = 0,
                            const ::xml_schema::properties& p = ::xml_schema::properties ());

        BIOGEARS_CDM_API
        ::std::unique_ptr< ::mil::tatrc::physiology::datamodel::CompleteBloodCountData >
        CompleteBloodCount (::std::istream& is,
                            ::xml_schema::flags f = 0,
                            const ::xml_schema::properties& p = ::xml_schema::properties ());

        BIOGEARS_CDM_API
        ::std::unique_ptr< ::mil::tatrc::physiology::datamodel::CompleteBloodCountData >
        CompleteBloodCount (::std::istream& is,
                            ::xml_schema::error_handler& eh,
                            ::xml_schema::flags f = 0,
                            const ::xml_schema::properties& p = ::xml_schema::properties ());

        BIOGEARS_CDM_API
        ::std::unique_ptr< ::mil::tatrc::physiology::datamodel::CompleteBloodCountData >
        CompleteBloodCount (::std::istream& is,
                            ::xercesc::DOMErrorHandler& eh,
                            ::xml_schema::flags f = 0,
                            const ::xml_schema::properties& p = ::xml_schema::properties ());

        BIOGEARS_CDM_API
        ::std::unique_ptr< ::mil::tatrc::physiology::datamodel::CompleteBloodCountData >
        CompleteBloodCount (::std::istream& is,
                            const ::std::string& id,
                            ::xml_schema::flags f = 0,
                            const ::xml_schema::properties& p = ::xml_schema::properties ());

        BIOGEARS_CDM_API
        ::std::unique_ptr< ::mil::tatrc::physiology::datamodel::CompleteBloodCountData >
        CompleteBloodCount (::std::istream& is,
                            const ::std::string& id,
                            ::xml_schema::error_handler& eh,
                            ::xml_schema::flags f = 0,
                            const ::xml_schema::properties& p = ::xml_schema::properties ());

        BIOGEARS_CDM_API
        ::std::unique_ptr< ::mil::tatrc::physiology::datamodel::CompleteBloodCountData >
        CompleteBloodCount (::std::istream& is,
                            const ::std::string& id,
                            ::xercesc::DOMErrorHandler& eh,
                            ::xml_schema::flags f = 0,
                            const ::xml_schema::properties& p = ::xml_schema::properties ());

        BIOGEARS_CDM_API
        ::std::unique_ptr< ::mil::tatrc::physiology::datamodel::CompleteBloodCountData >
        CompleteBloodCount (::xercesc::InputSource& is,
                            ::xml_schema::flags f = 0,
                            const ::xml_schema::properties& p = ::xml_schema::properties ());

        BIOGEARS_CDM_API
        ::std::unique_ptr< ::mil::tatrc::physiology::datamodel::CompleteBloodCountData >
        CompleteBloodCount (::xercesc::InputSource& is,
                            ::xml_schema::error_handler& eh,
                            ::xml_schema::flags f = 0,
                            const ::xml_schema::properties& p = ::xml_schema::properties ());

        BIOGEARS_CDM_API
        ::std::unique_ptr< ::mil::tatrc::physiology::datamodel::CompleteBloodCountData >
        CompleteBloodCount (::xercesc::InputSource& is,
                            ::xercesc::DOMErrorHandler& eh,
                            ::xml_schema::flags f = 0,
                            const ::xml_schema::properties& p = ::xml_schema::properties ());

        BIOGEARS_CDM_API
        ::std::unique_ptr< ::mil::tatrc::physiology::datamodel::CompleteBloodCountData >
        CompleteBloodCount (const ::xercesc::DOMDocument& d,
                            ::xml_schema::flags f = 0,
                            const ::xml_schema::properties& p = ::xml_schema::properties ());

        BIOGEARS_CDM_API
        ::std::unique_ptr< ::mil::tatrc::physiology::datamodel::CompleteBloodCountData >
        CompleteBloodCount (::xml_schema::dom::unique_ptr< ::xercesc::DOMDocument > d,
                            ::xml_schema::flags f = 0,
                            const ::xml_schema::properties& p = ::xml_schema::properties ());



        BIOGEARS_CDM_API
        ::std::unique_ptr< ::mil::tatrc::physiology::datamodel::PsychomotorVigilanceTaskData >
        PsychomotorVigilanceTask (const ::std::string& uri,
                                  ::xml_schema::flags f = 0,
                                  const ::xml_schema::properties& p = ::xml_schema::properties ());

        BIOGEARS_CDM_API
        ::std::unique_ptr< ::mil::tatrc::physiology::datamodel::PsychomotorVigilanceTaskData >
        PsychomotorVigilanceTask (const ::std::string& uri,
                                  ::xml_schema::error_handler& eh,
                                  ::xml_schema::flags f = 0,
                                  const ::xml_schema::properties& p = ::xml_schema::properties ());

        BIOGEARS_CDM_API
        ::std::unique_ptr< ::mil::tatrc::physiology::datamodel::PsychomotorVigilanceTaskData >
        PsychomotorVigilanceTask (const ::std::string& uri,
                                  ::xercesc::DOMErrorHandler& eh,
                                  ::xml_schema::flags f = 0,
                                  const ::xml_schema::properties& p = ::xml_schema::properties ());

        BIOGEARS_CDM_API
        ::std::unique_ptr< ::mil::tatrc::physiology::datamodel::PsychomotorVigilanceTaskData >
        PsychomotorVigilanceTask (::std::istream& is,
                                  ::xml_schema::flags f = 0,
                                  const ::xml_schema::properties& p = ::xml_schema::properties ());

        BIOGEARS_CDM_API
        ::std::unique_ptr< ::mil::tatrc::physiology::datamodel::PsychomotorVigilanceTaskData >
        PsychomotorVigilanceTask (::std::istream& is,
                                  ::xml_schema::error_handler& eh,
                                  ::xml_schema::flags f = 0,
                                  const ::xml_schema::properties& p = ::xml_schema::properties ());

        BIOGEARS_CDM_API
        ::std::unique_ptr< ::mil::tatrc::physiology::datamodel::PsychomotorVigilanceTaskData >
        PsychomotorVigilanceTask (::std::istream& is,
                                  ::xercesc::DOMErrorHandler& eh,
                                  ::xml_schema::flags f = 0,
                                  const ::xml_schema::properties& p = ::xml_schema::properties ());

        BIOGEARS_CDM_API
        ::std::unique_ptr< ::mil::tatrc::physiology::datamodel::PsychomotorVigilanceTaskData >
        PsychomotorVigilanceTask (::std::istream& is,
                                  const ::std::string& id,
                                  ::xml_schema::flags f = 0,
                                  const ::xml_schema::properties& p = ::xml_schema::properties ());

        BIOGEARS_CDM_API
        ::std::unique_ptr< ::mil::tatrc::physiology::datamodel::PsychomotorVigilanceTaskData >
        PsychomotorVigilanceTask (::std::istream& is,
                                  const ::std::string& id,
                                  ::xml_schema::error_handler& eh,
                                  ::xml_schema::flags f = 0,
                                  const ::xml_schema::properties& p = ::xml_schema::properties ());

        BIOGEARS_CDM_API
        ::std::unique_ptr< ::mil::tatrc::physiology::datamodel::PsychomotorVigilanceTaskData >
        PsychomotorVigilanceTask (::std::istream& is,
                                  const ::std::string& id,
                                  ::xercesc::DOMErrorHandler& eh,
                                  ::xml_schema::flags f = 0,
                                  const ::xml_schema::properties& p = ::xml_schema::properties ());

        BIOGEARS_CDM_API
        ::std::unique_ptr< ::mil::tatrc::physiology::datamodel::PsychomotorVigilanceTaskData >
        PsychomotorVigilanceTask (::xercesc::InputSource& is,
                                  ::xml_schema::flags f = 0,
                                  const ::xml_schema::properties& p = ::xml_schema::properties ());

        BIOGEARS_CDM_API
        ::std::unique_ptr< ::mil::tatrc::physiology::datamodel::PsychomotorVigilanceTaskData >
        PsychomotorVigilanceTask (::xercesc::InputSource& is,
                                  ::xml_schema::error_handler& eh,
                                  ::xml_schema::flags f = 0,
                                  const ::xml_schema::properties& p = ::xml_schema::properties ());

        BIOGEARS_CDM_API
        ::std::unique_ptr< ::mil::tatrc::physiology::datamodel::PsychomotorVigilanceTaskData >
        PsychomotorVigilanceTask (::xercesc::InputSource& is,
                                  ::xercesc::DOMErrorHandler& eh,
                                  ::xml_schema::flags f = 0,
                                  const ::xml_schema::properties& p = ::xml_schema::properties ());

        BIOGEARS_CDM_API
        ::std::unique_ptr< ::mil::tatrc::physiology::datamodel::PsychomotorVigilanceTaskData >
        PsychomotorVigilanceTask (const ::xercesc::DOMDocument& d,
                                  ::xml_schema::flags f = 0,
                                  const ::xml_schema::properties& p = ::xml_schema::properties ());

        BIOGEARS_CDM_API
        ::std::unique_ptr< ::mil::tatrc::physiology::datamodel::PsychomotorVigilanceTaskData >
        PsychomotorVigilanceTask (::xml_schema::dom::unique_ptr< ::xercesc::DOMDocument > d,
                                  ::xml_schema::flags f = 0,
                                  const ::xml_schema::properties& p = ::xml_schema::properties ());



        BIOGEARS_CDM_API
        ::std::unique_ptr< ::mil::tatrc::physiology::datamodel::ComprehensiveMetabolicPanelData >
        ComprehensiveMetabolicPanel (const ::std::string& uri,
                                     ::xml_schema::flags f = 0,
                                     const ::xml_schema::properties& p = ::xml_schema::properties ());

        BIOGEARS_CDM_API
        ::std::unique_ptr< ::mil::tatrc::physiology::datamodel::ComprehensiveMetabolicPanelData >
        ComprehensiveMetabolicPanel (const ::std::string& uri,
                                     ::xml_schema::error_handler& eh,
                                     ::xml_schema::flags f = 0,
                                     const ::xml_schema::properties& p = ::xml_schema::properties ());

        BIOGEARS_CDM_API
        ::std::unique_ptr< ::mil::tatrc::physiology::datamodel::ComprehensiveMetabolicPanelData >
        ComprehensiveMetabolicPanel (const ::std::string& uri,
                                     ::xercesc::DOMErrorHandler& eh,
                                     ::xml_schema::flags f = 0,
                                     const ::xml_schema::properties& p = ::xml_schema::properties ());

        BIOGEARS_CDM_API
        ::std::unique_ptr< ::mil::tatrc::physiology::datamodel::ComprehensiveMetabolicPanelData >
        ComprehensiveMetabolicPanel (::std::istream& is,
                                     ::xml_schema::flags f = 0,
                                     const ::xml_schema::properties& p = ::xml_schema::properties ());

        BIOGEARS_CDM_API
        ::std::unique_ptr< ::mil::tatrc::physiology::datamodel::ComprehensiveMetabolicPanelData >
        ComprehensiveMetabolicPanel (::std::istream& is,
                                     ::xml_schema::error_handler& eh,
                                     ::xml_schema::flags f = 0,
                                     const ::xml_schema::properties& p = ::xml_schema::properties ());

        BIOGEARS_CDM_API
        ::std::unique_ptr< ::mil::tatrc::physiology::datamodel::ComprehensiveMetabolicPanelData >
        ComprehensiveMetabolicPanel (::std::istream& is,
                                     ::xercesc::DOMErrorHandler& eh,
                                     ::xml_schema::flags f = 0,
                                     const ::xml_schema::properties& p = ::xml_schema::properties ());

        BIOGEARS_CDM_API
        ::std::unique_ptr< ::mil::tatrc::physiology::datamodel::ComprehensiveMetabolicPanelData >
        ComprehensiveMetabolicPanel (::std::istream& is,
                                     const ::std::string& id,
                                     ::xml_schema::flags f = 0,
                                     const ::xml_schema::properties& p = ::xml_schema::properties ());

        BIOGEARS_CDM_API
        ::std::unique_ptr< ::mil::tatrc::physiology::datamodel::ComprehensiveMetabolicPanelData >
        ComprehensiveMetabolicPanel (::std::istream& is,
                                     const ::std::string& id,
                                     ::xml_schema::error_handler& eh,
                                     ::xml_schema::flags f = 0,
                                     const ::xml_schema::properties& p = ::xml_schema::properties ());

        BIOGEARS_CDM_API
        ::std::unique_ptr< ::mil::tatrc::physiology::datamodel::ComprehensiveMetabolicPanelData >
        ComprehensiveMetabolicPanel (::std::istream& is,
                                     const ::std::string& id,
                                     ::xercesc::DOMErrorHandler& eh,
                                     ::xml_schema::flags f = 0,
                                     const ::xml_schema::properties& p = ::xml_schema::properties ());

        BIOGEARS_CDM_API
        ::std::unique_ptr< ::mil::tatrc::physiology::datamodel::ComprehensiveMetabolicPanelData >
        ComprehensiveMetabolicPanel (::xercesc::InputSource& is,
                                     ::xml_schema::flags f = 0,
                                     const ::xml_schema::properties& p = ::xml_schema::properties ());

        BIOGEARS_CDM_API
        ::std::unique_ptr< ::mil::tatrc::physiology::datamodel::ComprehensiveMetabolicPanelData >
        ComprehensiveMetabolicPanel (::xercesc::InputSource& is,
                                     ::xml_schema::error_handler& eh,
                                     ::xml_schema::flags f = 0,
                                     const ::xml_schema::properties& p = ::xml_schema::properties ());

        BIOGEARS_CDM_API
        ::std::unique_ptr< ::mil::tatrc::physiology::datamodel::ComprehensiveMetabolicPanelData >
        ComprehensiveMetabolicPanel (::xercesc::InputSource& is,
                                     ::xercesc::DOMErrorHandler& eh,
                                     ::xml_schema::flags f = 0,
                                     const ::xml_schema::properties& p = ::xml_schema::properties ());

        BIOGEARS_CDM_API
        ::std::unique_ptr< ::mil::tatrc::physiology::datamodel::ComprehensiveMetabolicPanelData >
        ComprehensiveMetabolicPanel (const ::xercesc::DOMDocument& d,
                                     ::xml_schema::flags f = 0,
                                     const ::xml_schema::properties& p = ::xml_schema::properties ());

        BIOGEARS_CDM_API
        ::std::unique_ptr< ::mil::tatrc::physiology::datamodel::ComprehensiveMetabolicPanelData >
        ComprehensiveMetabolicPanel (::xml_schema::dom::unique_ptr< ::xercesc::DOMDocument > d,
                                     ::xml_schema::flags f = 0,
                                     const ::xml_schema::properties& p = ::xml_schema::properties ());



        BIOGEARS_CDM_API
        ::std::unique_ptr< ::mil::tatrc::physiology::datamodel::UrinalysisData >
        Urinalysis (const ::std::string& uri,
                    ::xml_schema::flags f = 0,
                    const ::xml_schema::properties& p = ::xml_schema::properties ());

        BIOGEARS_CDM_API
        ::std::unique_ptr< ::mil::tatrc::physiology::datamodel::UrinalysisData >
        Urinalysis (const ::std::string& uri,
                    ::xml_schema::error_handler& eh,
                    ::xml_schema::flags f = 0,
                    const ::xml_schema::properties& p = ::xml_schema::properties ());

        BIOGEARS_CDM_API
        ::std::unique_ptr< ::mil::tatrc::physiology::datamodel::UrinalysisData >
        Urinalysis (const ::std::string& uri,
                    ::xercesc::DOMErrorHandler& eh,
                    ::xml_schema::flags f = 0,
                    const ::xml_schema::properties& p = ::xml_schema::properties ());

        BIOGEARS_CDM_API
        ::std::unique_ptr< ::mil::tatrc::physiology::datamodel::UrinalysisData >
        Urinalysis (::std::istream& is,
                    ::xml_schema::flags f = 0,
                    const ::xml_schema::properties& p = ::xml_schema::properties ());

        BIOGEARS_CDM_API
        ::std::unique_ptr< ::mil::tatrc::physiology::datamodel::UrinalysisData >
        Urinalysis (::std::istream& is,
                    ::xml_schema::error_handler& eh,
                    ::xml_schema::flags f = 0,
                    const ::xml_schema::properties& p = ::xml_schema::properties ());

        BIOGEARS_CDM_API
        ::std::unique_ptr< ::mil::tatrc::physiology::datamodel::UrinalysisData >
        Urinalysis (::std::istream& is,
                    ::xercesc::DOMErrorHandler& eh,
                    ::xml_schema::flags f = 0,
                    const ::xml_schema::properties& p = ::xml_schema::properties ());

        BIOGEARS_CDM_API
        ::std::unique_ptr< ::mil::tatrc::physiology::datamodel::UrinalysisData >
        Urinalysis (::std::istream& is,
                    const ::std::string& id,
                    ::xml_schema::flags f = 0,
                    const ::xml_schema::properties& p = ::xml_schema::properties ());

        BIOGEARS_CDM_API
        ::std::unique_ptr< ::mil::tatrc::physiology::datamodel::UrinalysisData >
        Urinalysis (::std::istream& is,
                    const ::std::string& id,
                    ::xml_schema::error_handler& eh,
                    ::xml_schema::flags f = 0,
                    const ::xml_schema::properties& p = ::xml_schema::properties ());

        BIOGEARS_CDM_API
        ::std::unique_ptr< ::mil::tatrc::physiology::datamodel::UrinalysisData >
        Urinalysis (::std::istream& is,
                    const ::std::string& id,
                    ::xercesc::DOMErrorHandler& eh,
                    ::xml_schema::flags f = 0,
                    const ::xml_schema::properties& p = ::xml_schema::properties ());

        BIOGEARS_CDM_API
        ::std::unique_ptr< ::mil::tatrc::physiology::datamodel::UrinalysisData >
        Urinalysis (::xercesc::InputSource& is,
                    ::xml_schema::flags f = 0,
                    const ::xml_schema::properties& p = ::xml_schema::properties ());

        BIOGEARS_CDM_API
        ::std::unique_ptr< ::mil::tatrc::physiology::datamodel::UrinalysisData >
        Urinalysis (::xercesc::InputSource& is,
                    ::xml_schema::error_handler& eh,
                    ::xml_schema::flags f = 0,
                    const ::xml_schema::properties& p = ::xml_schema::properties ());

        BIOGEARS_CDM_API
        ::std::unique_ptr< ::mil::tatrc::physiology::datamodel::UrinalysisData >
        Urinalysis (::xercesc::InputSource& is,
                    ::xercesc::DOMErrorHandler& eh,
                    ::xml_schema::flags f = 0,
                    const ::xml_schema::properties& p = ::xml_schema::properties ());

        BIOGEARS_CDM_API
        ::std::unique_ptr< ::mil::tatrc::physiology::datamodel::UrinalysisData >
        Urinalysis (const ::xercesc::DOMDocument& d,
                    ::xml_schema::flags f = 0,
                    const ::xml_schema::properties& p = ::xml_schema::properties ());

        BIOGEARS_CDM_API
        ::std::unique_ptr< ::mil::tatrc::physiology::datamodel::UrinalysisData >
        Urinalysis (::xml_schema::dom::unique_ptr< ::xercesc::DOMDocument > d,
                    ::xml_schema::flags f = 0,
                    const ::xml_schema::properties& p = ::xml_schema::properties ());

      }
    }
  }
}

#include <iosfwd>

#include <xercesc/dom/DOMDocument.hpp>
#include <xercesc/dom/DOMErrorHandler.hpp>
#include <xercesc/framework/XMLFormatter.hpp>

#include <xsd/cxx/xml/dom/auto-ptr.hxx>

namespace mil
{
  namespace tatrc
  {
    namespace physiology
    {
      namespace datamodel
      {
        BIOGEARS_CDM_API
        void
        operator<< (::xercesc::DOMElement&, const PatientAssessmentData&);

        BIOGEARS_CDM_API
        void
        operator<< (::xercesc::DOMElement&, const PulmonaryFunctionTestData&);


        BIOGEARS_CDM_API
        void
        PulmonaryFunctionTest (::std::ostream& os,
                               const ::mil::tatrc::physiology::datamodel::PulmonaryFunctionTestData& x, 
                               const ::xml_schema::namespace_infomap& m = ::xml_schema::namespace_infomap (),
                               const ::std::string& e = "UTF-8",
                               ::xml_schema::flags f = 0);

        BIOGEARS_CDM_API
        void
        PulmonaryFunctionTest (::std::ostream& os,
                               const ::mil::tatrc::physiology::datamodel::PulmonaryFunctionTestData& x, 
                               ::xml_schema::error_handler& eh,
                               const ::xml_schema::namespace_infomap& m = ::xml_schema::namespace_infomap (),
                               const ::std::string& e = "UTF-8",
                               ::xml_schema::flags f = 0);

        BIOGEARS_CDM_API
        void
        PulmonaryFunctionTest (::std::ostream& os,
                               const ::mil::tatrc::physiology::datamodel::PulmonaryFunctionTestData& x, 
                               ::xercesc::DOMErrorHandler& eh,
                               const ::xml_schema::namespace_infomap& m = ::xml_schema::namespace_infomap (),
                               const ::std::string& e = "UTF-8",
                               ::xml_schema::flags f = 0);

        BIOGEARS_CDM_API
        void
        PulmonaryFunctionTest (::xercesc::XMLFormatTarget& ft,
                               const ::mil::tatrc::physiology::datamodel::PulmonaryFunctionTestData& x, 
                               const ::xml_schema::namespace_infomap& m = ::xml_schema::namespace_infomap (),
                               const ::std::string& e = "UTF-8",
                               ::xml_schema::flags f = 0);

        BIOGEARS_CDM_API
        void
        PulmonaryFunctionTest (::xercesc::XMLFormatTarget& ft,
                               const ::mil::tatrc::physiology::datamodel::PulmonaryFunctionTestData& x, 
                               ::xml_schema::error_handler& eh,
                               const ::xml_schema::namespace_infomap& m = ::xml_schema::namespace_infomap (),
                               const ::std::string& e = "UTF-8",
                               ::xml_schema::flags f = 0);

        BIOGEARS_CDM_API
        void
        PulmonaryFunctionTest (::xercesc::XMLFormatTarget& ft,
                               const ::mil::tatrc::physiology::datamodel::PulmonaryFunctionTestData& x, 
                               ::xercesc::DOMErrorHandler& eh,
                               const ::xml_schema::namespace_infomap& m = ::xml_schema::namespace_infomap (),
                               const ::std::string& e = "UTF-8",
                               ::xml_schema::flags f = 0);

        BIOGEARS_CDM_API
        void
        PulmonaryFunctionTest (::xercesc::DOMDocument& d,
                               const ::mil::tatrc::physiology::datamodel::PulmonaryFunctionTestData& x,
                               ::xml_schema::flags f = 0);

        BIOGEARS_CDM_API
        ::xml_schema::dom::unique_ptr< ::xercesc::DOMDocument >
        PulmonaryFunctionTest (const ::mil::tatrc::physiology::datamodel::PulmonaryFunctionTestData& x, 
                               const ::xml_schema::namespace_infomap& m = ::xml_schema::namespace_infomap (),
                               ::xml_schema::flags f = 0);


        BIOGEARS_CDM_API
        void
        operator<< (::xercesc::DOMElement&, const SequentialOrganFailureAssessmentData&);


        BIOGEARS_CDM_API
        void
        SequentialOrganFailureAssessment (::std::ostream& os,
                                          const ::mil::tatrc::physiology::datamodel::SequentialOrganFailureAssessmentData& x, 
                                          const ::xml_schema::namespace_infomap& m = ::xml_schema::namespace_infomap (),
                                          const ::std::string& e = "UTF-8",
                                          ::xml_schema::flags f = 0);

        BIOGEARS_CDM_API
        void
        SequentialOrganFailureAssessment (::std::ostream& os,
                                          const ::mil::tatrc::physiology::datamodel::SequentialOrganFailureAssessmentData& x, 
                                          ::xml_schema::error_handler& eh,
                                          const ::xml_schema::namespace_infomap& m = ::xml_schema::namespace_infomap (),
                                          const ::std::string& e = "UTF-8",
                                          ::xml_schema::flags f = 0);

        BIOGEARS_CDM_API
        void
        SequentialOrganFailureAssessment (::std::ostream& os,
                                          const ::mil::tatrc::physiology::datamodel::SequentialOrganFailureAssessmentData& x, 
                                          ::xercesc::DOMErrorHandler& eh,
                                          const ::xml_schema::namespace_infomap& m = ::xml_schema::namespace_infomap (),
                                          const ::std::string& e = "UTF-8",
                                          ::xml_schema::flags f = 0);

        BIOGEARS_CDM_API
        void
        SequentialOrganFailureAssessment (::xercesc::XMLFormatTarget& ft,
                                          const ::mil::tatrc::physiology::datamodel::SequentialOrganFailureAssessmentData& x, 
                                          const ::xml_schema::namespace_infomap& m = ::xml_schema::namespace_infomap (),
                                          const ::std::string& e = "UTF-8",
                                          ::xml_schema::flags f = 0);

        BIOGEARS_CDM_API
        void
        SequentialOrganFailureAssessment (::xercesc::XMLFormatTarget& ft,
                                          const ::mil::tatrc::physiology::datamodel::SequentialOrganFailureAssessmentData& x, 
                                          ::xml_schema::error_handler& eh,
                                          const ::xml_schema::namespace_infomap& m = ::xml_schema::namespace_infomap (),
                                          const ::std::string& e = "UTF-8",
                                          ::xml_schema::flags f = 0);

        BIOGEARS_CDM_API
        void
        SequentialOrganFailureAssessment (::xercesc::XMLFormatTarget& ft,
                                          const ::mil::tatrc::physiology::datamodel::SequentialOrganFailureAssessmentData& x, 
                                          ::xercesc::DOMErrorHandler& eh,
                                          const ::xml_schema::namespace_infomap& m = ::xml_schema::namespace_infomap (),
                                          const ::std::string& e = "UTF-8",
                                          ::xml_schema::flags f = 0);

        BIOGEARS_CDM_API
        void
        SequentialOrganFailureAssessment (::xercesc::DOMDocument& d,
                                          const ::mil::tatrc::physiology::datamodel::SequentialOrganFailureAssessmentData& x,
                                          ::xml_schema::flags f = 0);

        BIOGEARS_CDM_API
        ::xml_schema::dom::unique_ptr< ::xercesc::DOMDocument >
        SequentialOrganFailureAssessment (const ::mil::tatrc::physiology::datamodel::SequentialOrganFailureAssessmentData& x, 
                                          const ::xml_schema::namespace_infomap& m = ::xml_schema::namespace_infomap (),
                                          ::xml_schema::flags f = 0);


        BIOGEARS_CDM_API
        void
        operator<< (::xercesc::DOMElement&, const CompleteBloodCountData&);


        BIOGEARS_CDM_API
        void
        CompleteBloodCount (::std::ostream& os,
                            const ::mil::tatrc::physiology::datamodel::CompleteBloodCountData& x, 
                            const ::xml_schema::namespace_infomap& m = ::xml_schema::namespace_infomap (),
                            const ::std::string& e = "UTF-8",
                            ::xml_schema::flags f = 0);

        BIOGEARS_CDM_API
        void
        CompleteBloodCount (::std::ostream& os,
                            const ::mil::tatrc::physiology::datamodel::CompleteBloodCountData& x, 
                            ::xml_schema::error_handler& eh,
                            const ::xml_schema::namespace_infomap& m = ::xml_schema::namespace_infomap (),
                            const ::std::string& e = "UTF-8",
                            ::xml_schema::flags f = 0);

        BIOGEARS_CDM_API
        void
        CompleteBloodCount (::std::ostream& os,
                            const ::mil::tatrc::physiology::datamodel::CompleteBloodCountData& x, 
                            ::xercesc::DOMErrorHandler& eh,
                            const ::xml_schema::namespace_infomap& m = ::xml_schema::namespace_infomap (),
                            const ::std::string& e = "UTF-8",
                            ::xml_schema::flags f = 0);

        BIOGEARS_CDM_API
        void
        CompleteBloodCount (::xercesc::XMLFormatTarget& ft,
                            const ::mil::tatrc::physiology::datamodel::CompleteBloodCountData& x, 
                            const ::xml_schema::namespace_infomap& m = ::xml_schema::namespace_infomap (),
                            const ::std::string& e = "UTF-8",
                            ::xml_schema::flags f = 0);

        BIOGEARS_CDM_API
        void
        CompleteBloodCount (::xercesc::XMLFormatTarget& ft,
                            const ::mil::tatrc::physiology::datamodel::CompleteBloodCountData& x, 
                            ::xml_schema::error_handler& eh,
                            const ::xml_schema::namespace_infomap& m = ::xml_schema::namespace_infomap (),
                            const ::std::string& e = "UTF-8",
                            ::xml_schema::flags f = 0);

        BIOGEARS_CDM_API
        void
        CompleteBloodCount (::xercesc::XMLFormatTarget& ft,
                            const ::mil::tatrc::physiology::datamodel::CompleteBloodCountData& x, 
                            ::xercesc::DOMErrorHandler& eh,
                            const ::xml_schema::namespace_infomap& m = ::xml_schema::namespace_infomap (),
                            const ::std::string& e = "UTF-8",
                            ::xml_schema::flags f = 0);

        BIOGEARS_CDM_API
        void
        CompleteBloodCount (::xercesc::DOMDocument& d,
                            const ::mil::tatrc::physiology::datamodel::CompleteBloodCountData& x,
                            ::xml_schema::flags f = 0);

        BIOGEARS_CDM_API
        ::xml_schema::dom::unique_ptr< ::xercesc::DOMDocument >
        CompleteBloodCount (const ::mil::tatrc::physiology::datamodel::CompleteBloodCountData& x, 
                            const ::xml_schema::namespace_infomap& m = ::xml_schema::namespace_infomap (),
                            ::xml_schema::flags f = 0);


        BIOGEARS_CDM_API
        void
        operator<< (::xercesc::DOMElement&, const PsychomotorVigilanceTaskData&);


        BIOGEARS_CDM_API
        void
        PsychomotorVigilanceTask (::std::ostream& os,
                                  const ::mil::tatrc::physiology::datamodel::PsychomotorVigilanceTaskData& x, 
                                  const ::xml_schema::namespace_infomap& m = ::xml_schema::namespace_infomap (),
                                  const ::std::string& e = "UTF-8",
                                  ::xml_schema::flags f = 0);

        BIOGEARS_CDM_API
        void
        PsychomotorVigilanceTask (::std::ostream& os,
                                  const ::mil::tatrc::physiology::datamodel::PsychomotorVigilanceTaskData& x, 
                                  ::xml_schema::error_handler& eh,
                                  const ::xml_schema::namespace_infomap& m = ::xml_schema::namespace_infomap (),
                                  const ::std::string& e = "UTF-8",
                                  ::xml_schema::flags f = 0);

        BIOGEARS_CDM_API
        void
        PsychomotorVigilanceTask (::std::ostream& os,
                                  const ::mil::tatrc::physiology::datamodel::PsychomotorVigilanceTaskData& x, 
                                  ::xercesc::DOMErrorHandler& eh,
                                  const ::xml_schema::namespace_infomap& m = ::xml_schema::namespace_infomap (),
                                  const ::std::string& e = "UTF-8",
                                  ::xml_schema::flags f = 0);

        BIOGEARS_CDM_API
        void
        PsychomotorVigilanceTask (::xercesc::XMLFormatTarget& ft,
                                  const ::mil::tatrc::physiology::datamodel::PsychomotorVigilanceTaskData& x, 
                                  const ::xml_schema::namespace_infomap& m = ::xml_schema::namespace_infomap (),
                                  const ::std::string& e = "UTF-8",
                                  ::xml_schema::flags f = 0);

        BIOGEARS_CDM_API
        void
        PsychomotorVigilanceTask (::xercesc::XMLFormatTarget& ft,
                                  const ::mil::tatrc::physiology::datamodel::PsychomotorVigilanceTaskData& x, 
                                  ::xml_schema::error_handler& eh,
                                  const ::xml_schema::namespace_infomap& m = ::xml_schema::namespace_infomap (),
                                  const ::std::string& e = "UTF-8",
                                  ::xml_schema::flags f = 0);

        BIOGEARS_CDM_API
        void
        PsychomotorVigilanceTask (::xercesc::XMLFormatTarget& ft,
                                  const ::mil::tatrc::physiology::datamodel::PsychomotorVigilanceTaskData& x, 
                                  ::xercesc::DOMErrorHandler& eh,
                                  const ::xml_schema::namespace_infomap& m = ::xml_schema::namespace_infomap (),
                                  const ::std::string& e = "UTF-8",
                                  ::xml_schema::flags f = 0);

        BIOGEARS_CDM_API
        void
        PsychomotorVigilanceTask (::xercesc::DOMDocument& d,
                                  const ::mil::tatrc::physiology::datamodel::PsychomotorVigilanceTaskData& x,
                                  ::xml_schema::flags f = 0);

        BIOGEARS_CDM_API
        ::xml_schema::dom::unique_ptr< ::xercesc::DOMDocument >
        PsychomotorVigilanceTask (const ::mil::tatrc::physiology::datamodel::PsychomotorVigilanceTaskData& x, 
                                  const ::xml_schema::namespace_infomap& m = ::xml_schema::namespace_infomap (),
                                  ::xml_schema::flags f = 0);


        BIOGEARS_CDM_API
        void
        operator<< (::xercesc::DOMElement&, const ComprehensiveMetabolicPanelData&);


        BIOGEARS_CDM_API
        void
        ComprehensiveMetabolicPanel (::std::ostream& os,
                                     const ::mil::tatrc::physiology::datamodel::ComprehensiveMetabolicPanelData& x, 
                                     const ::xml_schema::namespace_infomap& m = ::xml_schema::namespace_infomap (),
                                     const ::std::string& e = "UTF-8",
                                     ::xml_schema::flags f = 0);

        BIOGEARS_CDM_API
        void
        ComprehensiveMetabolicPanel (::std::ostream& os,
                                     const ::mil::tatrc::physiology::datamodel::ComprehensiveMetabolicPanelData& x, 
                                     ::xml_schema::error_handler& eh,
                                     const ::xml_schema::namespace_infomap& m = ::xml_schema::namespace_infomap (),
                                     const ::std::string& e = "UTF-8",
                                     ::xml_schema::flags f = 0);

        BIOGEARS_CDM_API
        void
        ComprehensiveMetabolicPanel (::std::ostream& os,
                                     const ::mil::tatrc::physiology::datamodel::ComprehensiveMetabolicPanelData& x, 
                                     ::xercesc::DOMErrorHandler& eh,
                                     const ::xml_schema::namespace_infomap& m = ::xml_schema::namespace_infomap (),
                                     const ::std::string& e = "UTF-8",
                                     ::xml_schema::flags f = 0);

        BIOGEARS_CDM_API
        void
        ComprehensiveMetabolicPanel (::xercesc::XMLFormatTarget& ft,
                                     const ::mil::tatrc::physiology::datamodel::ComprehensiveMetabolicPanelData& x, 
                                     const ::xml_schema::namespace_infomap& m = ::xml_schema::namespace_infomap (),
                                     const ::std::string& e = "UTF-8",
                                     ::xml_schema::flags f = 0);

        BIOGEARS_CDM_API
        void
        ComprehensiveMetabolicPanel (::xercesc::XMLFormatTarget& ft,
                                     const ::mil::tatrc::physiology::datamodel::ComprehensiveMetabolicPanelData& x, 
                                     ::xml_schema::error_handler& eh,
                                     const ::xml_schema::namespace_infomap& m = ::xml_schema::namespace_infomap (),
                                     const ::std::string& e = "UTF-8",
                                     ::xml_schema::flags f = 0);

        BIOGEARS_CDM_API
        void
        ComprehensiveMetabolicPanel (::xercesc::XMLFormatTarget& ft,
                                     const ::mil::tatrc::physiology::datamodel::ComprehensiveMetabolicPanelData& x, 
                                     ::xercesc::DOMErrorHandler& eh,
                                     const ::xml_schema::namespace_infomap& m = ::xml_schema::namespace_infomap (),
                                     const ::std::string& e = "UTF-8",
                                     ::xml_schema::flags f = 0);

        BIOGEARS_CDM_API
        void
        ComprehensiveMetabolicPanel (::xercesc::DOMDocument& d,
                                     const ::mil::tatrc::physiology::datamodel::ComprehensiveMetabolicPanelData& x,
                                     ::xml_schema::flags f = 0);

        BIOGEARS_CDM_API
        ::xml_schema::dom::unique_ptr< ::xercesc::DOMDocument >
        ComprehensiveMetabolicPanel (const ::mil::tatrc::physiology::datamodel::ComprehensiveMetabolicPanelData& x, 
                                     const ::xml_schema::namespace_infomap& m = ::xml_schema::namespace_infomap (),
                                     ::xml_schema::flags f = 0);


        BIOGEARS_CDM_API
        void
        operator<< (::xercesc::DOMElement&, const enumPresenceIndicator&);

        BIOGEARS_CDM_API
        void
        operator<< (::xercesc::DOMAttr&, const enumPresenceIndicator&);

        BIOGEARS_CDM_API
        void
        operator<< (::xml_schema::list_stream&,
                    const enumPresenceIndicator&);

        BIOGEARS_CDM_API
        void
        operator<< (::xercesc::DOMElement&, const enumClarityIndicator&);

        BIOGEARS_CDM_API
        void
        operator<< (::xercesc::DOMAttr&, const enumClarityIndicator&);

        BIOGEARS_CDM_API
        void
        operator<< (::xml_schema::list_stream&,
                    const enumClarityIndicator&);

        BIOGEARS_CDM_API
        void
        operator<< (::xercesc::DOMElement&, const enumUrineColor&);

        BIOGEARS_CDM_API
        void
        operator<< (::xercesc::DOMAttr&, const enumUrineColor&);

        BIOGEARS_CDM_API
        void
        operator<< (::xml_schema::list_stream&,
                    const enumUrineColor&);

        BIOGEARS_CDM_API
        void
        operator<< (::xercesc::DOMElement&, const enumMicroscopicObservationType&);

        BIOGEARS_CDM_API
        void
        operator<< (::xercesc::DOMAttr&, const enumMicroscopicObservationType&);

        BIOGEARS_CDM_API
        void
        operator<< (::xml_schema::list_stream&,
                    const enumMicroscopicObservationType&);

        BIOGEARS_CDM_API
        void
        operator<< (::xercesc::DOMElement&, const enumMicroscopicObservationAmount&);

        BIOGEARS_CDM_API
        void
        operator<< (::xercesc::DOMAttr&, const enumMicroscopicObservationAmount&);

        BIOGEARS_CDM_API
        void
        operator<< (::xml_schema::list_stream&,
                    const enumMicroscopicObservationAmount&);

        BIOGEARS_CDM_API
        void
        operator<< (::xercesc::DOMElement&, const UrinalysisData&);

        BIOGEARS_CDM_API
        void
        operator<< (::xercesc::DOMElement&, const UrinalysisMicroscopicData&);


        BIOGEARS_CDM_API
        void
        Urinalysis (::std::ostream& os,
                    const ::mil::tatrc::physiology::datamodel::UrinalysisData& x, 
                    const ::xml_schema::namespace_infomap& m = ::xml_schema::namespace_infomap (),
                    const ::std::string& e = "UTF-8",
                    ::xml_schema::flags f = 0);

        BIOGEARS_CDM_API
        void
        Urinalysis (::std::ostream& os,
                    const ::mil::tatrc::physiology::datamodel::UrinalysisData& x, 
                    ::xml_schema::error_handler& eh,
                    const ::xml_schema::namespace_infomap& m = ::xml_schema::namespace_infomap (),
                    const ::std::string& e = "UTF-8",
                    ::xml_schema::flags f = 0);

        BIOGEARS_CDM_API
        void
        Urinalysis (::std::ostream& os,
                    const ::mil::tatrc::physiology::datamodel::UrinalysisData& x, 
                    ::xercesc::DOMErrorHandler& eh,
                    const ::xml_schema::namespace_infomap& m = ::xml_schema::namespace_infomap (),
                    const ::std::string& e = "UTF-8",
                    ::xml_schema::flags f = 0);

        BIOGEARS_CDM_API
        void
        Urinalysis (::xercesc::XMLFormatTarget& ft,
                    const ::mil::tatrc::physiology::datamodel::UrinalysisData& x, 
                    const ::xml_schema::namespace_infomap& m = ::xml_schema::namespace_infomap (),
                    const ::std::string& e = "UTF-8",
                    ::xml_schema::flags f = 0);

        BIOGEARS_CDM_API
        void
        Urinalysis (::xercesc::XMLFormatTarget& ft,
                    const ::mil::tatrc::physiology::datamodel::UrinalysisData& x, 
                    ::xml_schema::error_handler& eh,
                    const ::xml_schema::namespace_infomap& m = ::xml_schema::namespace_infomap (),
                    const ::std::string& e = "UTF-8",
                    ::xml_schema::flags f = 0);

        BIOGEARS_CDM_API
        void
        Urinalysis (::xercesc::XMLFormatTarget& ft,
                    const ::mil::tatrc::physiology::datamodel::UrinalysisData& x, 
                    ::xercesc::DOMErrorHandler& eh,
                    const ::xml_schema::namespace_infomap& m = ::xml_schema::namespace_infomap (),
                    const ::std::string& e = "UTF-8",
                    ::xml_schema::flags f = 0);

        BIOGEARS_CDM_API
        void
        Urinalysis (::xercesc::DOMDocument& d,
                    const ::mil::tatrc::physiology::datamodel::UrinalysisData& x,
                    ::xml_schema::flags f = 0);

        BIOGEARS_CDM_API
        ::xml_schema::dom::unique_ptr< ::xercesc::DOMDocument >
        Urinalysis (const ::mil::tatrc::physiology::datamodel::UrinalysisData& x, 
                    const ::xml_schema::namespace_infomap& m = ::xml_schema::namespace_infomap (),
                    ::xml_schema::flags f = 0);

      }
    }
  }
}

#include <xsd/cxx/post.hxx>

// Begin epilogue.
//
//
// End epilogue.

#endif // D__BIOGEARS_CORE_SHARE_XSD__CDM_PATIENT_ASSESSMENTS_HXX