Physiology.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_PHYSIOLOGY_HXX
#define D__BIOGEARS_CORE_SHARE_XSD__CDM_PHYSIOLOGY_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 PupillaryResponseData;
        class enumInflammationSource;
        class InflammatoryResponseData;
        class BloodChemistrySystemData;
        class enumHeartRhythm;
        class CardiovascularSystemData;
        class DrugSystemData;
        class EndocrineSystemData;
        class EnergySystemData;
        class DrugTransitStateData;
        class GastrointestinalSystemData;
        class HepaticSystemData;
        class enumSleepState;
        class NervousSystemData;
        class RenalSystemData;
        class RespiratorySystemData;
        class TissueSystemData;
      }
    }
  }
}


#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 "system.hxx"

#include "patientnutrition.hxx"

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

          typedef ::mil::tatrc::physiology::datamodel::ScalarNeg1To1Data ReactivityModifier_type;

          typedef ::xsd::cxx::tree::optional< ReactivityModifier_type > ReactivityModifier_optional;

          typedef ::xsd::cxx::tree::traits< ReactivityModifier_type, char > ReactivityModifier_traits;

          const ReactivityModifier_optional&
          ReactivityModifier () const;

          ReactivityModifier_optional&
          ReactivityModifier ();

          void
          ReactivityModifier (const ReactivityModifier_type& x);

          void
          ReactivityModifier (const ReactivityModifier_optional& x);

          void
          ReactivityModifier (::std::unique_ptr< ReactivityModifier_type > p);



          typedef ::mil::tatrc::physiology::datamodel::ScalarNeg1To1Data ShapeModifier_type;

          typedef ::xsd::cxx::tree::optional< ShapeModifier_type > ShapeModifier_optional;

          typedef ::xsd::cxx::tree::traits< ShapeModifier_type, char > ShapeModifier_traits;

          const ShapeModifier_optional&
          ShapeModifier () const;

          ShapeModifier_optional&
          ShapeModifier ();

          void
          ShapeModifier (const ShapeModifier_type& x);

          void
          ShapeModifier (const ShapeModifier_optional& x);

          void
          ShapeModifier (::std::unique_ptr< ShapeModifier_type > p);



          typedef ::mil::tatrc::physiology::datamodel::ScalarNeg1To1Data SizeModifier_type;

          typedef ::xsd::cxx::tree::optional< SizeModifier_type > SizeModifier_optional;

          typedef ::xsd::cxx::tree::traits< SizeModifier_type, char > SizeModifier_traits;

          const SizeModifier_optional&
          SizeModifier () const;

          SizeModifier_optional&
          SizeModifier ();

          void
          SizeModifier (const SizeModifier_type& x);

          void
          SizeModifier (const SizeModifier_optional& x);

          void
          SizeModifier (::std::unique_ptr< SizeModifier_type > p);



          PupillaryResponseData ();

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

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

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

          PupillaryResponseData&
          operator= (const PupillaryResponseData& x);


          virtual 
          ~PupillaryResponseData ();

          // Implementation.
          //

          //@cond

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

          protected:
          ReactivityModifier_optional ReactivityModifier_;
          ShapeModifier_optional ShapeModifier_;
          SizeModifier_optional SizeModifier_;

          //@endcond
        };

        class BIOGEARS_CDM_API enumInflammationSource: public ::xml_schema::string
        {
          public:

          enum value
          {
            Burn,
            Hemorrhage,
            Infection
          };

          enumInflammationSource ();

          enumInflammationSource (value v);

          enumInflammationSource (const char* v);

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

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

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

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

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

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

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

          enumInflammationSource&
          operator= (value v);

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

          //@cond

          protected:
          value
          _xsd_enumInflammationSource_convert () const;

          public:
          static const char* const _xsd_enumInflammationSource_literals_[3];
          static const value _xsd_enumInflammationSource_indexes_[3];

          //@endcond
        };

        class BIOGEARS_CDM_API InflammatoryResponseData: public ::mil::tatrc::physiology::datamodel::ObjectData
        {
          public:

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

          typedef ::xsd::cxx::tree::traits< LocalPathogen_type, char > LocalPathogen_traits;

          const LocalPathogen_type&
          LocalPathogen () const;

          LocalPathogen_type&
          LocalPathogen ();

          void
          LocalPathogen (const LocalPathogen_type& x);

          void
          LocalPathogen (::std::unique_ptr< LocalPathogen_type > p);



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

          typedef ::xsd::cxx::tree::traits< LocalMacrophage_type, char > LocalMacrophage_traits;

          const LocalMacrophage_type&
          LocalMacrophage () const;

          LocalMacrophage_type&
          LocalMacrophage ();

          void
          LocalMacrophage (const LocalMacrophage_type& x);

          void
          LocalMacrophage (::std::unique_ptr< LocalMacrophage_type > p);



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

          typedef ::xsd::cxx::tree::traits< LocalNeutrophil_type, char > LocalNeutrophil_traits;

          const LocalNeutrophil_type&
          LocalNeutrophil () const;

          LocalNeutrophil_type&
          LocalNeutrophil ();

          void
          LocalNeutrophil (const LocalNeutrophil_type& x);

          void
          LocalNeutrophil (::std::unique_ptr< LocalNeutrophil_type > p);



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

          typedef ::xsd::cxx::tree::traits< LocalBarrier_type, char > LocalBarrier_traits;

          const LocalBarrier_type&
          LocalBarrier () const;

          LocalBarrier_type&
          LocalBarrier ();

          void
          LocalBarrier (const LocalBarrier_type& x);

          void
          LocalBarrier (::std::unique_ptr< LocalBarrier_type > p);



          typedef ::mil::tatrc::physiology::datamodel::enumOnOff ActiveTLR_type;

          typedef ::xsd::cxx::tree::traits< ActiveTLR_type, char > ActiveTLR_traits;

          const ActiveTLR_type&
          ActiveTLR () const;

          ActiveTLR_type&
          ActiveTLR ();

          void
          ActiveTLR (const ActiveTLR_type& x);

          void
          ActiveTLR (::std::unique_ptr< ActiveTLR_type > p);



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

          typedef ::xsd::cxx::tree::traits< AutonomicResponseLevel_type, char > AutonomicResponseLevel_traits;

          const AutonomicResponseLevel_type&
          AutonomicResponseLevel () const;

          AutonomicResponseLevel_type&
          AutonomicResponseLevel ();

          void
          AutonomicResponseLevel (const AutonomicResponseLevel_type& x);

          void
          AutonomicResponseLevel (::std::unique_ptr< AutonomicResponseLevel_type > p);



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

          typedef ::xsd::cxx::tree::traits< BloodPathogen_type, char > BloodPathogen_traits;

          const BloodPathogen_type&
          BloodPathogen () const;

          BloodPathogen_type&
          BloodPathogen ();

          void
          BloodPathogen (const BloodPathogen_type& x);

          void
          BloodPathogen (::std::unique_ptr< BloodPathogen_type > p);



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

          typedef ::xsd::cxx::tree::traits< Trauma_type, char > Trauma_traits;

          const Trauma_type&
          Trauma () const;

          Trauma_type&
          Trauma ();

          void
          Trauma (const Trauma_type& x);

          void
          Trauma (::std::unique_ptr< Trauma_type > p);



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

          typedef ::xsd::cxx::tree::traits< MacrophageResting_type, char > MacrophageResting_traits;

          const MacrophageResting_type&
          MacrophageResting () const;

          MacrophageResting_type&
          MacrophageResting ();

          void
          MacrophageResting (const MacrophageResting_type& x);

          void
          MacrophageResting (::std::unique_ptr< MacrophageResting_type > p);



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

          typedef ::xsd::cxx::tree::traits< MacrophageActive_type, char > MacrophageActive_traits;

          const MacrophageActive_type&
          MacrophageActive () const;

          MacrophageActive_type&
          MacrophageActive ();

          void
          MacrophageActive (const MacrophageActive_type& x);

          void
          MacrophageActive (::std::unique_ptr< MacrophageActive_type > p);



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

          typedef ::xsd::cxx::tree::traits< NeutrophilResting_type, char > NeutrophilResting_traits;

          const NeutrophilResting_type&
          NeutrophilResting () const;

          NeutrophilResting_type&
          NeutrophilResting ();

          void
          NeutrophilResting (const NeutrophilResting_type& x);

          void
          NeutrophilResting (::std::unique_ptr< NeutrophilResting_type > p);



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

          typedef ::xsd::cxx::tree::traits< NeutrophilActive_type, char > NeutrophilActive_traits;

          const NeutrophilActive_type&
          NeutrophilActive () const;

          NeutrophilActive_type&
          NeutrophilActive ();

          void
          NeutrophilActive (const NeutrophilActive_type& x);

          void
          NeutrophilActive (::std::unique_ptr< NeutrophilActive_type > p);



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

          typedef ::xsd::cxx::tree::traits< TumorNecrosisFactor_type, char > TumorNecrosisFactor_traits;

          const TumorNecrosisFactor_type&
          TumorNecrosisFactor () const;

          TumorNecrosisFactor_type&
          TumorNecrosisFactor ();

          void
          TumorNecrosisFactor (const TumorNecrosisFactor_type& x);

          void
          TumorNecrosisFactor (::std::unique_ptr< TumorNecrosisFactor_type > p);



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

          typedef ::xsd::cxx::tree::traits< Interleukin6_type, char > Interleukin6_traits;

          const Interleukin6_type&
          Interleukin6 () const;

          Interleukin6_type&
          Interleukin6 ();

          void
          Interleukin6 (const Interleukin6_type& x);

          void
          Interleukin6 (::std::unique_ptr< Interleukin6_type > p);



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

          typedef ::xsd::cxx::tree::traits< Interleukin10_type, char > Interleukin10_traits;

          const Interleukin10_type&
          Interleukin10 () const;

          Interleukin10_type&
          Interleukin10 ();

          void
          Interleukin10 (const Interleukin10_type& x);

          void
          Interleukin10 (::std::unique_ptr< Interleukin10_type > p);



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

          typedef ::xsd::cxx::tree::traits< Interleukin12_type, char > Interleukin12_traits;

          const Interleukin12_type&
          Interleukin12 () const;

          Interleukin12_type&
          Interleukin12 ();

          void
          Interleukin12 (const Interleukin12_type& x);

          void
          Interleukin12 (::std::unique_ptr< Interleukin12_type > p);



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

          typedef ::xsd::cxx::tree::traits< InducibleNOSPre_type, char > InducibleNOSPre_traits;

          const InducibleNOSPre_type&
          InducibleNOSPre () const;

          InducibleNOSPre_type&
          InducibleNOSPre ();

          void
          InducibleNOSPre (const InducibleNOSPre_type& x);

          void
          InducibleNOSPre (::std::unique_ptr< InducibleNOSPre_type > p);



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

          typedef ::xsd::cxx::tree::traits< InducibleNOS_type, char > InducibleNOS_traits;

          const InducibleNOS_type&
          InducibleNOS () const;

          InducibleNOS_type&
          InducibleNOS ();

          void
          InducibleNOS (const InducibleNOS_type& x);

          void
          InducibleNOS (::std::unique_ptr< InducibleNOS_type > p);



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

          typedef ::xsd::cxx::tree::traits< ConstitutiveNOS_type, char > ConstitutiveNOS_traits;

          const ConstitutiveNOS_type&
          ConstitutiveNOS () const;

          ConstitutiveNOS_type&
          ConstitutiveNOS ();

          void
          ConstitutiveNOS (const ConstitutiveNOS_type& x);

          void
          ConstitutiveNOS (::std::unique_ptr< ConstitutiveNOS_type > p);



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

          typedef ::xsd::cxx::tree::traits< Nitrate_type, char > Nitrate_traits;

          const Nitrate_type&
          Nitrate () const;

          Nitrate_type&
          Nitrate ();

          void
          Nitrate (const Nitrate_type& x);

          void
          Nitrate (::std::unique_ptr< Nitrate_type > p);



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

          typedef ::xsd::cxx::tree::traits< NitricOxide_type, char > NitricOxide_traits;

          const NitricOxide_type&
          NitricOxide () const;

          NitricOxide_type&
          NitricOxide ();

          void
          NitricOxide (const NitricOxide_type& x);

          void
          NitricOxide (::std::unique_ptr< NitricOxide_type > p);



          typedef ::mil::tatrc::physiology::datamodel::Scalar0To1Data TissueIntegrity_type;

          typedef ::xsd::cxx::tree::traits< TissueIntegrity_type, char > TissueIntegrity_traits;

          const TissueIntegrity_type&
          TissueIntegrity () const;

          TissueIntegrity_type&
          TissueIntegrity ();

          void
          TissueIntegrity (const TissueIntegrity_type& x);

          void
          TissueIntegrity (::std::unique_ptr< TissueIntegrity_type > p);



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

          typedef ::xsd::cxx::tree::traits< Catecholamines_type, char > Catecholamines_traits;

          const Catecholamines_type&
          Catecholamines () const;

          Catecholamines_type&
          Catecholamines ();

          void
          Catecholamines (const Catecholamines_type& x);

          void
          Catecholamines (::std::unique_ptr< Catecholamines_type > p);



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

          typedef ::xsd::cxx::tree::traits< InflammationTime_type, char > InflammationTime_traits;

          const InflammationTime_type&
          InflammationTime () const;

          InflammationTime_type&
          InflammationTime ();

          void
          InflammationTime (const InflammationTime_type& x);

          void
          InflammationTime (::std::unique_ptr< InflammationTime_type > p);



          typedef ::mil::tatrc::physiology::datamodel::enumInflammationSource Source_type;

          typedef ::xsd::cxx::tree::sequence< Source_type > Source_sequence;

          typedef Source_sequence::iterator Source_iterator;

          typedef Source_sequence::const_iterator Source_const_iterator;

          typedef ::xsd::cxx::tree::traits< Source_type, char > Source_traits;

          const Source_sequence&
          Source () const;

          Source_sequence&
          Source ();

          void
          Source (const Source_sequence& s);



          InflammatoryResponseData ();

          InflammatoryResponseData (const LocalPathogen_type&,
                                    const LocalMacrophage_type&,
                                    const LocalNeutrophil_type&,
                                    const LocalBarrier_type&,
                                    const ActiveTLR_type&,
                                    const AutonomicResponseLevel_type&,
                                    const BloodPathogen_type&,
                                    const Trauma_type&,
                                    const MacrophageResting_type&,
                                    const MacrophageActive_type&,
                                    const NeutrophilResting_type&,
                                    const NeutrophilActive_type&,
                                    const TumorNecrosisFactor_type&,
                                    const Interleukin6_type&,
                                    const Interleukin10_type&,
                                    const Interleukin12_type&,
                                    const InducibleNOSPre_type&,
                                    const InducibleNOS_type&,
                                    const ConstitutiveNOS_type&,
                                    const Nitrate_type&,
                                    const NitricOxide_type&,
                                    const TissueIntegrity_type&,
                                    const Catecholamines_type&,
                                    const InflammationTime_type&);

          InflammatoryResponseData (::std::unique_ptr< LocalPathogen_type >,
                                    ::std::unique_ptr< LocalMacrophage_type >,
                                    ::std::unique_ptr< LocalNeutrophil_type >,
                                    ::std::unique_ptr< LocalBarrier_type >,
                                    const ActiveTLR_type&,
                                    ::std::unique_ptr< AutonomicResponseLevel_type >,
                                    ::std::unique_ptr< BloodPathogen_type >,
                                    ::std::unique_ptr< Trauma_type >,
                                    ::std::unique_ptr< MacrophageResting_type >,
                                    ::std::unique_ptr< MacrophageActive_type >,
                                    ::std::unique_ptr< NeutrophilResting_type >,
                                    ::std::unique_ptr< NeutrophilActive_type >,
                                    ::std::unique_ptr< TumorNecrosisFactor_type >,
                                    ::std::unique_ptr< Interleukin6_type >,
                                    ::std::unique_ptr< Interleukin10_type >,
                                    ::std::unique_ptr< Interleukin12_type >,
                                    ::std::unique_ptr< InducibleNOSPre_type >,
                                    ::std::unique_ptr< InducibleNOS_type >,
                                    ::std::unique_ptr< ConstitutiveNOS_type >,
                                    ::std::unique_ptr< Nitrate_type >,
                                    ::std::unique_ptr< NitricOxide_type >,
                                    ::std::unique_ptr< TissueIntegrity_type >,
                                    ::std::unique_ptr< Catecholamines_type >,
                                    ::std::unique_ptr< InflammationTime_type >);

          InflammatoryResponseData (::std::unique_ptr< LocalPathogen_type >,
                                    ::std::unique_ptr< LocalMacrophage_type >,
                                    ::std::unique_ptr< LocalNeutrophil_type >,
                                    ::std::unique_ptr< LocalBarrier_type >,
                                    ::std::unique_ptr< ActiveTLR_type >,
                                    ::std::unique_ptr< AutonomicResponseLevel_type >,
                                    ::std::unique_ptr< BloodPathogen_type >,
                                    ::std::unique_ptr< Trauma_type >,
                                    ::std::unique_ptr< MacrophageResting_type >,
                                    ::std::unique_ptr< MacrophageActive_type >,
                                    ::std::unique_ptr< NeutrophilResting_type >,
                                    ::std::unique_ptr< NeutrophilActive_type >,
                                    ::std::unique_ptr< TumorNecrosisFactor_type >,
                                    ::std::unique_ptr< Interleukin6_type >,
                                    ::std::unique_ptr< Interleukin10_type >,
                                    ::std::unique_ptr< Interleukin12_type >,
                                    ::std::unique_ptr< InducibleNOSPre_type >,
                                    ::std::unique_ptr< InducibleNOS_type >,
                                    ::std::unique_ptr< ConstitutiveNOS_type >,
                                    ::std::unique_ptr< Nitrate_type >,
                                    ::std::unique_ptr< NitricOxide_type >,
                                    ::std::unique_ptr< TissueIntegrity_type >,
                                    ::std::unique_ptr< Catecholamines_type >,
                                    ::std::unique_ptr< InflammationTime_type >);

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

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

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

          InflammatoryResponseData&
          operator= (const InflammatoryResponseData& x);


          virtual 
          ~InflammatoryResponseData ();

          // Implementation.
          //

          //@cond

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

          protected:
          ::xsd::cxx::tree::one< LocalPathogen_type > LocalPathogen_;
          ::xsd::cxx::tree::one< LocalMacrophage_type > LocalMacrophage_;
          ::xsd::cxx::tree::one< LocalNeutrophil_type > LocalNeutrophil_;
          ::xsd::cxx::tree::one< LocalBarrier_type > LocalBarrier_;
          ::xsd::cxx::tree::one< ActiveTLR_type > ActiveTLR_;
          ::xsd::cxx::tree::one< AutonomicResponseLevel_type > AutonomicResponseLevel_;
          ::xsd::cxx::tree::one< BloodPathogen_type > BloodPathogen_;
          ::xsd::cxx::tree::one< Trauma_type > Trauma_;
          ::xsd::cxx::tree::one< MacrophageResting_type > MacrophageResting_;
          ::xsd::cxx::tree::one< MacrophageActive_type > MacrophageActive_;
          ::xsd::cxx::tree::one< NeutrophilResting_type > NeutrophilResting_;
          ::xsd::cxx::tree::one< NeutrophilActive_type > NeutrophilActive_;
          ::xsd::cxx::tree::one< TumorNecrosisFactor_type > TumorNecrosisFactor_;
          ::xsd::cxx::tree::one< Interleukin6_type > Interleukin6_;
          ::xsd::cxx::tree::one< Interleukin10_type > Interleukin10_;
          ::xsd::cxx::tree::one< Interleukin12_type > Interleukin12_;
          ::xsd::cxx::tree::one< InducibleNOSPre_type > InducibleNOSPre_;
          ::xsd::cxx::tree::one< InducibleNOS_type > InducibleNOS_;
          ::xsd::cxx::tree::one< ConstitutiveNOS_type > ConstitutiveNOS_;
          ::xsd::cxx::tree::one< Nitrate_type > Nitrate_;
          ::xsd::cxx::tree::one< NitricOxide_type > NitricOxide_;
          ::xsd::cxx::tree::one< TissueIntegrity_type > TissueIntegrity_;
          ::xsd::cxx::tree::one< Catecholamines_type > Catecholamines_;
          ::xsd::cxx::tree::one< InflammationTime_type > InflammationTime_;
          Source_sequence Source_;

          //@endcond
        };

        class BIOGEARS_CDM_API BloodChemistrySystemData: public ::mil::tatrc::physiology::datamodel::SystemData
        {
          public:

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

          typedef ::xsd::cxx::tree::optional< BloodDensity_type > BloodDensity_optional;

          typedef ::xsd::cxx::tree::traits< BloodDensity_type, char > BloodDensity_traits;

          const BloodDensity_optional&
          BloodDensity () const;

          BloodDensity_optional&
          BloodDensity ();

          void
          BloodDensity (const BloodDensity_type& x);

          void
          BloodDensity (const BloodDensity_optional& x);

          void
          BloodDensity (::std::unique_ptr< BloodDensity_type > p);



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

          typedef ::xsd::cxx::tree::optional< ArterialBloodPH_type > ArterialBloodPH_optional;

          typedef ::xsd::cxx::tree::traits< ArterialBloodPH_type, char > ArterialBloodPH_traits;

          const ArterialBloodPH_optional&
          ArterialBloodPH () const;

          ArterialBloodPH_optional&
          ArterialBloodPH ();

          void
          ArterialBloodPH (const ArterialBloodPH_type& x);

          void
          ArterialBloodPH (const ArterialBloodPH_optional& x);

          void
          ArterialBloodPH (::std::unique_ptr< ArterialBloodPH_type > p);



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

          typedef ::xsd::cxx::tree::optional< ArterialBloodPHBaseline_type > ArterialBloodPHBaseline_optional;

          typedef ::xsd::cxx::tree::traits< ArterialBloodPHBaseline_type, char > ArterialBloodPHBaseline_traits;

          const ArterialBloodPHBaseline_optional&
          ArterialBloodPHBaseline () const;

          ArterialBloodPHBaseline_optional&
          ArterialBloodPHBaseline ();

          void
          ArterialBloodPHBaseline (const ArterialBloodPHBaseline_type& x);

          void
          ArterialBloodPHBaseline (const ArterialBloodPHBaseline_optional& x);

          void
          ArterialBloodPHBaseline (::std::unique_ptr< ArterialBloodPHBaseline_type > p);



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

          typedef ::xsd::cxx::tree::optional< VenousBloodPH_type > VenousBloodPH_optional;

          typedef ::xsd::cxx::tree::traits< VenousBloodPH_type, char > VenousBloodPH_traits;

          const VenousBloodPH_optional&
          VenousBloodPH () const;

          VenousBloodPH_optional&
          VenousBloodPH ();

          void
          VenousBloodPH (const VenousBloodPH_type& x);

          void
          VenousBloodPH (const VenousBloodPH_optional& x);

          void
          VenousBloodPH (::std::unique_ptr< VenousBloodPH_type > p);



          typedef ::mil::tatrc::physiology::datamodel::ScalarHeatCapacitancePerMassData BloodSpecificHeat_type;

          typedef ::xsd::cxx::tree::optional< BloodSpecificHeat_type > BloodSpecificHeat_optional;

          typedef ::xsd::cxx::tree::traits< BloodSpecificHeat_type, char > BloodSpecificHeat_traits;

          const BloodSpecificHeat_optional&
          BloodSpecificHeat () const;

          BloodSpecificHeat_optional&
          BloodSpecificHeat ();

          void
          BloodSpecificHeat (const BloodSpecificHeat_type& x);

          void
          BloodSpecificHeat (const BloodSpecificHeat_optional& x);

          void
          BloodSpecificHeat (::std::unique_ptr< BloodSpecificHeat_type > p);



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

          typedef ::xsd::cxx::tree::optional< BloodUreaNitrogenConcentration_type > BloodUreaNitrogenConcentration_optional;

          typedef ::xsd::cxx::tree::traits< BloodUreaNitrogenConcentration_type, char > BloodUreaNitrogenConcentration_traits;

          const BloodUreaNitrogenConcentration_optional&
          BloodUreaNitrogenConcentration () const;

          BloodUreaNitrogenConcentration_optional&
          BloodUreaNitrogenConcentration ();

          void
          BloodUreaNitrogenConcentration (const BloodUreaNitrogenConcentration_type& x);

          void
          BloodUreaNitrogenConcentration (const BloodUreaNitrogenConcentration_optional& x);

          void
          BloodUreaNitrogenConcentration (::std::unique_ptr< BloodUreaNitrogenConcentration_type > p);



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

          typedef ::xsd::cxx::tree::optional< CarbonDioxideSaturation_type > CarbonDioxideSaturation_optional;

          typedef ::xsd::cxx::tree::traits< CarbonDioxideSaturation_type, char > CarbonDioxideSaturation_traits;

          const CarbonDioxideSaturation_optional&
          CarbonDioxideSaturation () const;

          CarbonDioxideSaturation_optional&
          CarbonDioxideSaturation ();

          void
          CarbonDioxideSaturation (const CarbonDioxideSaturation_type& x);

          void
          CarbonDioxideSaturation (const CarbonDioxideSaturation_optional& x);

          void
          CarbonDioxideSaturation (::std::unique_ptr< CarbonDioxideSaturation_type > p);



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

          typedef ::xsd::cxx::tree::optional< CarbonMonoxideSaturation_type > CarbonMonoxideSaturation_optional;

          typedef ::xsd::cxx::tree::traits< CarbonMonoxideSaturation_type, char > CarbonMonoxideSaturation_traits;

          const CarbonMonoxideSaturation_optional&
          CarbonMonoxideSaturation () const;

          CarbonMonoxideSaturation_optional&
          CarbonMonoxideSaturation ();

          void
          CarbonMonoxideSaturation (const CarbonMonoxideSaturation_type& x);

          void
          CarbonMonoxideSaturation (const CarbonMonoxideSaturation_optional& x);

          void
          CarbonMonoxideSaturation (::std::unique_ptr< CarbonMonoxideSaturation_type > p);



          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::ScalarMassData HemoglobinContent_type;

          typedef ::xsd::cxx::tree::optional< HemoglobinContent_type > HemoglobinContent_optional;

          typedef ::xsd::cxx::tree::traits< HemoglobinContent_type, char > HemoglobinContent_traits;

          const HemoglobinContent_optional&
          HemoglobinContent () const;

          HemoglobinContent_optional&
          HemoglobinContent ();

          void
          HemoglobinContent (const HemoglobinContent_type& x);

          void
          HemoglobinContent (const HemoglobinContent_optional& x);

          void
          HemoglobinContent (::std::unique_ptr< HemoglobinContent_type > p);



          typedef ::mil::tatrc::physiology::datamodel::ScalarMassData HemoglobinLostToUrine_type;

          typedef ::xsd::cxx::tree::optional< HemoglobinLostToUrine_type > HemoglobinLostToUrine_optional;

          typedef ::xsd::cxx::tree::traits< HemoglobinLostToUrine_type, char > HemoglobinLostToUrine_traits;

          const HemoglobinLostToUrine_optional&
          HemoglobinLostToUrine () const;

          HemoglobinLostToUrine_optional&
          HemoglobinLostToUrine ();

          void
          HemoglobinLostToUrine (const HemoglobinLostToUrine_type& x);

          void
          HemoglobinLostToUrine (const HemoglobinLostToUrine_optional& x);

          void
          HemoglobinLostToUrine (::std::unique_ptr< HemoglobinLostToUrine_type > p);



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

          typedef ::xsd::cxx::tree::optional< OxygenSaturation_type > OxygenSaturation_optional;

          typedef ::xsd::cxx::tree::traits< OxygenSaturation_type, char > OxygenSaturation_traits;

          const OxygenSaturation_optional&
          OxygenSaturation () const;

          OxygenSaturation_optional&
          OxygenSaturation ();

          void
          OxygenSaturation (const OxygenSaturation_type& x);

          void
          OxygenSaturation (const OxygenSaturation_optional& x);

          void
          OxygenSaturation (::std::unique_ptr< OxygenSaturation_type > p);



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

          typedef ::xsd::cxx::tree::optional< OxygenVenousSaturation_type > OxygenVenousSaturation_optional;

          typedef ::xsd::cxx::tree::traits< OxygenVenousSaturation_type, char > OxygenVenousSaturation_traits;

          const OxygenVenousSaturation_optional&
          OxygenVenousSaturation () const;

          OxygenVenousSaturation_optional&
          OxygenVenousSaturation ();

          void
          OxygenVenousSaturation (const OxygenVenousSaturation_type& x);

          void
          OxygenVenousSaturation (const OxygenVenousSaturation_optional& x);

          void
          OxygenVenousSaturation (::std::unique_ptr< OxygenVenousSaturation_type > p);



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

          typedef ::xsd::cxx::tree::optional< Phosphate_type > Phosphate_optional;

          typedef ::xsd::cxx::tree::traits< Phosphate_type, char > Phosphate_traits;

          const Phosphate_optional&
          Phosphate () const;

          Phosphate_optional&
          Phosphate ();

          void
          Phosphate (const Phosphate_type& x);

          void
          Phosphate (const Phosphate_optional& x);

          void
          Phosphate (::std::unique_ptr< Phosphate_type > p);



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

          typedef ::xsd::cxx::tree::optional< PlasmaVolume_type > PlasmaVolume_optional;

          typedef ::xsd::cxx::tree::traits< PlasmaVolume_type, char > PlasmaVolume_traits;

          const PlasmaVolume_optional&
          PlasmaVolume () const;

          PlasmaVolume_optional&
          PlasmaVolume ();

          void
          PlasmaVolume (const PlasmaVolume_type& x);

          void
          PlasmaVolume (const PlasmaVolume_optional& x);

          void
          PlasmaVolume (::std::unique_ptr< PlasmaVolume_type > p);



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

          typedef ::xsd::cxx::tree::optional< PulseOximetry_type > PulseOximetry_optional;

          typedef ::xsd::cxx::tree::traits< PulseOximetry_type, char > PulseOximetry_traits;

          const PulseOximetry_optional&
          PulseOximetry () const;

          PulseOximetry_optional&
          PulseOximetry ();

          void
          PulseOximetry (const PulseOximetry_type& x);

          void
          PulseOximetry (const PulseOximetry_optional& x);

          void
          PulseOximetry (::std::unique_ptr< PulseOximetry_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::ScalarVolumeData RhTransfusionReactionVolume_type;

          typedef ::xsd::cxx::tree::optional< RhTransfusionReactionVolume_type > RhTransfusionReactionVolume_optional;

          typedef ::xsd::cxx::tree::traits< RhTransfusionReactionVolume_type, char > RhTransfusionReactionVolume_traits;

          const RhTransfusionReactionVolume_optional&
          RhTransfusionReactionVolume () const;

          RhTransfusionReactionVolume_optional&
          RhTransfusionReactionVolume ();

          void
          RhTransfusionReactionVolume (const RhTransfusionReactionVolume_type& x);

          void
          RhTransfusionReactionVolume (const RhTransfusionReactionVolume_optional& x);

          void
          RhTransfusionReactionVolume (::std::unique_ptr< RhTransfusionReactionVolume_type > p);



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

          typedef ::xsd::cxx::tree::optional< ShuntFraction_type > ShuntFraction_optional;

          typedef ::xsd::cxx::tree::traits< ShuntFraction_type, char > ShuntFraction_traits;

          const ShuntFraction_optional&
          ShuntFraction () const;

          ShuntFraction_optional&
          ShuntFraction ();

          void
          ShuntFraction (const ShuntFraction_type& x);

          void
          ShuntFraction (const ShuntFraction_optional& x);

          void
          ShuntFraction (::std::unique_ptr< ShuntFraction_type > p);



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

          typedef ::xsd::cxx::tree::optional< StrongIonDifference_type > StrongIonDifference_optional;

          typedef ::xsd::cxx::tree::traits< StrongIonDifference_type, char > StrongIonDifference_traits;

          const StrongIonDifference_optional&
          StrongIonDifference () const;

          StrongIonDifference_optional&
          StrongIonDifference ();

          void
          StrongIonDifference (const StrongIonDifference_type& x);

          void
          StrongIonDifference (const StrongIonDifference_optional& x);

          void
          StrongIonDifference (::std::unique_ptr< StrongIonDifference_type > p);



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

          typedef ::xsd::cxx::tree::optional< TotalProteinConcentration_type > TotalProteinConcentration_optional;

          typedef ::xsd::cxx::tree::traits< TotalProteinConcentration_type, char > TotalProteinConcentration_traits;

          const TotalProteinConcentration_optional&
          TotalProteinConcentration () const;

          TotalProteinConcentration_optional&
          TotalProteinConcentration ();

          void
          TotalProteinConcentration (const TotalProteinConcentration_type& x);

          void
          TotalProteinConcentration (const TotalProteinConcentration_optional& x);

          void
          TotalProteinConcentration (::std::unique_ptr< TotalProteinConcentration_type > p);



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

          typedef ::xsd::cxx::tree::optional< VolumeFractionNeutralLipidInPlasma_type > VolumeFractionNeutralLipidInPlasma_optional;

          typedef ::xsd::cxx::tree::traits< VolumeFractionNeutralLipidInPlasma_type, char > VolumeFractionNeutralLipidInPlasma_traits;

          const VolumeFractionNeutralLipidInPlasma_optional&
          VolumeFractionNeutralLipidInPlasma () const;

          VolumeFractionNeutralLipidInPlasma_optional&
          VolumeFractionNeutralLipidInPlasma ();

          void
          VolumeFractionNeutralLipidInPlasma (const VolumeFractionNeutralLipidInPlasma_type& x);

          void
          VolumeFractionNeutralLipidInPlasma (const VolumeFractionNeutralLipidInPlasma_optional& x);

          void
          VolumeFractionNeutralLipidInPlasma (::std::unique_ptr< VolumeFractionNeutralLipidInPlasma_type > p);



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

          typedef ::xsd::cxx::tree::optional< VolumeFractionNeutralPhospholipidInPlasma_type > VolumeFractionNeutralPhospholipidInPlasma_optional;

          typedef ::xsd::cxx::tree::traits< VolumeFractionNeutralPhospholipidInPlasma_type, char > VolumeFractionNeutralPhospholipidInPlasma_traits;

          const VolumeFractionNeutralPhospholipidInPlasma_optional&
          VolumeFractionNeutralPhospholipidInPlasma () const;

          VolumeFractionNeutralPhospholipidInPlasma_optional&
          VolumeFractionNeutralPhospholipidInPlasma ();

          void
          VolumeFractionNeutralPhospholipidInPlasma (const VolumeFractionNeutralPhospholipidInPlasma_type& x);

          void
          VolumeFractionNeutralPhospholipidInPlasma (const VolumeFractionNeutralPhospholipidInPlasma_optional& x);

          void
          VolumeFractionNeutralPhospholipidInPlasma (::std::unique_ptr< VolumeFractionNeutralPhospholipidInPlasma_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);



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

          typedef ::xsd::cxx::tree::optional< RedBloodCellAcetylcholinesterase_type > RedBloodCellAcetylcholinesterase_optional;

          typedef ::xsd::cxx::tree::traits< RedBloodCellAcetylcholinesterase_type, char > RedBloodCellAcetylcholinesterase_traits;

          const RedBloodCellAcetylcholinesterase_optional&
          RedBloodCellAcetylcholinesterase () const;

          RedBloodCellAcetylcholinesterase_optional&
          RedBloodCellAcetylcholinesterase ();

          void
          RedBloodCellAcetylcholinesterase (const RedBloodCellAcetylcholinesterase_type& x);

          void
          RedBloodCellAcetylcholinesterase (const RedBloodCellAcetylcholinesterase_optional& x);

          void
          RedBloodCellAcetylcholinesterase (::std::unique_ptr< RedBloodCellAcetylcholinesterase_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::InflammatoryResponseData InflammatoryResponse_type;

          typedef ::xsd::cxx::tree::optional< InflammatoryResponse_type > InflammatoryResponse_optional;

          typedef ::xsd::cxx::tree::traits< InflammatoryResponse_type, char > InflammatoryResponse_traits;

          const InflammatoryResponse_optional&
          InflammatoryResponse () const;

          InflammatoryResponse_optional&
          InflammatoryResponse ();

          void
          InflammatoryResponse (const InflammatoryResponse_type& x);

          void
          InflammatoryResponse (const InflammatoryResponse_optional& x);

          void
          InflammatoryResponse (::std::unique_ptr< InflammatoryResponse_type > p);



          typedef ::mil::tatrc::physiology::datamodel::ScalarPressureData ArterialCarbonDioxidePressure_type;

          typedef ::xsd::cxx::tree::optional< ArterialCarbonDioxidePressure_type > ArterialCarbonDioxidePressure_optional;

          typedef ::xsd::cxx::tree::traits< ArterialCarbonDioxidePressure_type, char > ArterialCarbonDioxidePressure_traits;

          const ArterialCarbonDioxidePressure_optional&
          ArterialCarbonDioxidePressure () const;

          ArterialCarbonDioxidePressure_optional&
          ArterialCarbonDioxidePressure ();

          void
          ArterialCarbonDioxidePressure (const ArterialCarbonDioxidePressure_type& x);

          void
          ArterialCarbonDioxidePressure (const ArterialCarbonDioxidePressure_optional& x);

          void
          ArterialCarbonDioxidePressure (::std::unique_ptr< ArterialCarbonDioxidePressure_type > p);



          typedef ::mil::tatrc::physiology::datamodel::ScalarPressureData ArterialOxygenPressure_type;

          typedef ::xsd::cxx::tree::optional< ArterialOxygenPressure_type > ArterialOxygenPressure_optional;

          typedef ::xsd::cxx::tree::traits< ArterialOxygenPressure_type, char > ArterialOxygenPressure_traits;

          const ArterialOxygenPressure_optional&
          ArterialOxygenPressure () const;

          ArterialOxygenPressure_optional&
          ArterialOxygenPressure ();

          void
          ArterialOxygenPressure (const ArterialOxygenPressure_type& x);

          void
          ArterialOxygenPressure (const ArterialOxygenPressure_optional& x);

          void
          ArterialOxygenPressure (::std::unique_ptr< ArterialOxygenPressure_type > p);



          typedef ::mil::tatrc::physiology::datamodel::ScalarPressureData PulmonaryArterialCarbonDioxidePressure_type;

          typedef ::xsd::cxx::tree::optional< PulmonaryArterialCarbonDioxidePressure_type > PulmonaryArterialCarbonDioxidePressure_optional;

          typedef ::xsd::cxx::tree::traits< PulmonaryArterialCarbonDioxidePressure_type, char > PulmonaryArterialCarbonDioxidePressure_traits;

          const PulmonaryArterialCarbonDioxidePressure_optional&
          PulmonaryArterialCarbonDioxidePressure () const;

          PulmonaryArterialCarbonDioxidePressure_optional&
          PulmonaryArterialCarbonDioxidePressure ();

          void
          PulmonaryArterialCarbonDioxidePressure (const PulmonaryArterialCarbonDioxidePressure_type& x);

          void
          PulmonaryArterialCarbonDioxidePressure (const PulmonaryArterialCarbonDioxidePressure_optional& x);

          void
          PulmonaryArterialCarbonDioxidePressure (::std::unique_ptr< PulmonaryArterialCarbonDioxidePressure_type > p);



          typedef ::mil::tatrc::physiology::datamodel::ScalarPressureData PulmonaryArterialOxygenPressure_type;

          typedef ::xsd::cxx::tree::optional< PulmonaryArterialOxygenPressure_type > PulmonaryArterialOxygenPressure_optional;

          typedef ::xsd::cxx::tree::traits< PulmonaryArterialOxygenPressure_type, char > PulmonaryArterialOxygenPressure_traits;

          const PulmonaryArterialOxygenPressure_optional&
          PulmonaryArterialOxygenPressure () const;

          PulmonaryArterialOxygenPressure_optional&
          PulmonaryArterialOxygenPressure ();

          void
          PulmonaryArterialOxygenPressure (const PulmonaryArterialOxygenPressure_type& x);

          void
          PulmonaryArterialOxygenPressure (const PulmonaryArterialOxygenPressure_optional& x);

          void
          PulmonaryArterialOxygenPressure (::std::unique_ptr< PulmonaryArterialOxygenPressure_type > p);



          typedef ::mil::tatrc::physiology::datamodel::ScalarPressureData PulmonaryVenousCarbonDioxidePressure_type;

          typedef ::xsd::cxx::tree::optional< PulmonaryVenousCarbonDioxidePressure_type > PulmonaryVenousCarbonDioxidePressure_optional;

          typedef ::xsd::cxx::tree::traits< PulmonaryVenousCarbonDioxidePressure_type, char > PulmonaryVenousCarbonDioxidePressure_traits;

          const PulmonaryVenousCarbonDioxidePressure_optional&
          PulmonaryVenousCarbonDioxidePressure () const;

          PulmonaryVenousCarbonDioxidePressure_optional&
          PulmonaryVenousCarbonDioxidePressure ();

          void
          PulmonaryVenousCarbonDioxidePressure (const PulmonaryVenousCarbonDioxidePressure_type& x);

          void
          PulmonaryVenousCarbonDioxidePressure (const PulmonaryVenousCarbonDioxidePressure_optional& x);

          void
          PulmonaryVenousCarbonDioxidePressure (::std::unique_ptr< PulmonaryVenousCarbonDioxidePressure_type > p);



          typedef ::mil::tatrc::physiology::datamodel::ScalarPressureData PulmonaryVenousOxygenPressure_type;

          typedef ::xsd::cxx::tree::optional< PulmonaryVenousOxygenPressure_type > PulmonaryVenousOxygenPressure_optional;

          typedef ::xsd::cxx::tree::traits< PulmonaryVenousOxygenPressure_type, char > PulmonaryVenousOxygenPressure_traits;

          const PulmonaryVenousOxygenPressure_optional&
          PulmonaryVenousOxygenPressure () const;

          PulmonaryVenousOxygenPressure_optional&
          PulmonaryVenousOxygenPressure ();

          void
          PulmonaryVenousOxygenPressure (const PulmonaryVenousOxygenPressure_type& x);

          void
          PulmonaryVenousOxygenPressure (const PulmonaryVenousOxygenPressure_optional& x);

          void
          PulmonaryVenousOxygenPressure (::std::unique_ptr< PulmonaryVenousOxygenPressure_type > p);



          typedef ::mil::tatrc::physiology::datamodel::ScalarPressureData VenousCarbonDioxidePressure_type;

          typedef ::xsd::cxx::tree::optional< VenousCarbonDioxidePressure_type > VenousCarbonDioxidePressure_optional;

          typedef ::xsd::cxx::tree::traits< VenousCarbonDioxidePressure_type, char > VenousCarbonDioxidePressure_traits;

          const VenousCarbonDioxidePressure_optional&
          VenousCarbonDioxidePressure () const;

          VenousCarbonDioxidePressure_optional&
          VenousCarbonDioxidePressure ();

          void
          VenousCarbonDioxidePressure (const VenousCarbonDioxidePressure_type& x);

          void
          VenousCarbonDioxidePressure (const VenousCarbonDioxidePressure_optional& x);

          void
          VenousCarbonDioxidePressure (::std::unique_ptr< VenousCarbonDioxidePressure_type > p);



          typedef ::mil::tatrc::physiology::datamodel::ScalarPressureData VenousOxygenPressure_type;

          typedef ::xsd::cxx::tree::optional< VenousOxygenPressure_type > VenousOxygenPressure_optional;

          typedef ::xsd::cxx::tree::traits< VenousOxygenPressure_type, char > VenousOxygenPressure_traits;

          const VenousOxygenPressure_optional&
          VenousOxygenPressure () const;

          VenousOxygenPressure_optional&
          VenousOxygenPressure ();

          void
          VenousOxygenPressure (const VenousOxygenPressure_type& x);

          void
          VenousOxygenPressure (const VenousOxygenPressure_optional& x);

          void
          VenousOxygenPressure (::std::unique_ptr< VenousOxygenPressure_type > p);



          BloodChemistrySystemData ();

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

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

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

          BloodChemistrySystemData&
          operator= (const BloodChemistrySystemData& x);


          virtual 
          ~BloodChemistrySystemData ();

          // Implementation.
          //

          //@cond

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

          protected:
          BloodDensity_optional BloodDensity_;
          ArterialBloodPH_optional ArterialBloodPH_;
          ArterialBloodPHBaseline_optional ArterialBloodPHBaseline_;
          VenousBloodPH_optional VenousBloodPH_;
          BloodSpecificHeat_optional BloodSpecificHeat_;
          BloodUreaNitrogenConcentration_optional BloodUreaNitrogenConcentration_;
          CarbonDioxideSaturation_optional CarbonDioxideSaturation_;
          CarbonMonoxideSaturation_optional CarbonMonoxideSaturation_;
          Hematocrit_optional Hematocrit_;
          HemoglobinContent_optional HemoglobinContent_;
          HemoglobinLostToUrine_optional HemoglobinLostToUrine_;
          OxygenSaturation_optional OxygenSaturation_;
          OxygenVenousSaturation_optional OxygenVenousSaturation_;
          Phosphate_optional Phosphate_;
          PlasmaVolume_optional PlasmaVolume_;
          PulseOximetry_optional PulseOximetry_;
          RedBloodCellCount_optional RedBloodCellCount_;
          RhTransfusionReactionVolume_optional RhTransfusionReactionVolume_;
          ShuntFraction_optional ShuntFraction_;
          StrongIonDifference_optional StrongIonDifference_;
          TotalProteinConcentration_optional TotalProteinConcentration_;
          VolumeFractionNeutralLipidInPlasma_optional VolumeFractionNeutralLipidInPlasma_;
          VolumeFractionNeutralPhospholipidInPlasma_optional VolumeFractionNeutralPhospholipidInPlasma_;
          WhiteBloodCellCount_optional WhiteBloodCellCount_;
          RedBloodCellAcetylcholinesterase_optional RedBloodCellAcetylcholinesterase_;
          TotalBilirubin_optional TotalBilirubin_;
          InflammatoryResponse_optional InflammatoryResponse_;
          ArterialCarbonDioxidePressure_optional ArterialCarbonDioxidePressure_;
          ArterialOxygenPressure_optional ArterialOxygenPressure_;
          PulmonaryArterialCarbonDioxidePressure_optional PulmonaryArterialCarbonDioxidePressure_;
          PulmonaryArterialOxygenPressure_optional PulmonaryArterialOxygenPressure_;
          PulmonaryVenousCarbonDioxidePressure_optional PulmonaryVenousCarbonDioxidePressure_;
          PulmonaryVenousOxygenPressure_optional PulmonaryVenousOxygenPressure_;
          VenousCarbonDioxidePressure_optional VenousCarbonDioxidePressure_;
          VenousOxygenPressure_optional VenousOxygenPressure_;

          //@endcond
        };

        class BIOGEARS_CDM_API enumHeartRhythm: public ::xml_schema::string
        {
          public:

          enum value
          {
            Asystole,
            NormalSinus
          };

          enumHeartRhythm ();

          enumHeartRhythm (value v);

          enumHeartRhythm (const char* v);

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

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

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

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

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

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

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

          enumHeartRhythm&
          operator= (value v);

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

          //@cond

          protected:
          value
          _xsd_enumHeartRhythm_convert () const;

          public:
          static const char* const _xsd_enumHeartRhythm_literals_[2];
          static const value _xsd_enumHeartRhythm_indexes_[2];

          //@endcond
        };

        class BIOGEARS_CDM_API CardiovascularSystemData: public ::mil::tatrc::physiology::datamodel::SystemData
        {
          public:

          typedef ::mil::tatrc::physiology::datamodel::ScalarPressureData ArterialPressure_type;

          typedef ::xsd::cxx::tree::optional< ArterialPressure_type > ArterialPressure_optional;

          typedef ::xsd::cxx::tree::traits< ArterialPressure_type, char > ArterialPressure_traits;

          const ArterialPressure_optional&
          ArterialPressure () const;

          ArterialPressure_optional&
          ArterialPressure ();

          void
          ArterialPressure (const ArterialPressure_type& x);

          void
          ArterialPressure (const ArterialPressure_optional& x);

          void
          ArterialPressure (::std::unique_ptr< ArterialPressure_type > p);



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

          typedef ::xsd::cxx::tree::optional< BloodVolume_type > BloodVolume_optional;

          typedef ::xsd::cxx::tree::traits< BloodVolume_type, char > BloodVolume_traits;

          const BloodVolume_optional&
          BloodVolume () const;

          BloodVolume_optional&
          BloodVolume ();

          void
          BloodVolume (const BloodVolume_type& x);

          void
          BloodVolume (const BloodVolume_optional& x);

          void
          BloodVolume (::std::unique_ptr< BloodVolume_type > p);



          typedef ::mil::tatrc::physiology::datamodel::ScalarVolumePerTimeAreaData CardiacIndex_type;

          typedef ::xsd::cxx::tree::optional< CardiacIndex_type > CardiacIndex_optional;

          typedef ::xsd::cxx::tree::traits< CardiacIndex_type, char > CardiacIndex_traits;

          const CardiacIndex_optional&
          CardiacIndex () const;

          CardiacIndex_optional&
          CardiacIndex ();

          void
          CardiacIndex (const CardiacIndex_type& x);

          void
          CardiacIndex (const CardiacIndex_optional& x);

          void
          CardiacIndex (::std::unique_ptr< CardiacIndex_type > p);



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

          typedef ::xsd::cxx::tree::optional< CardiacOutput_type > CardiacOutput_optional;

          typedef ::xsd::cxx::tree::traits< CardiacOutput_type, char > CardiacOutput_traits;

          const CardiacOutput_optional&
          CardiacOutput () const;

          CardiacOutput_optional&
          CardiacOutput ();

          void
          CardiacOutput (const CardiacOutput_type& x);

          void
          CardiacOutput (const CardiacOutput_optional& x);

          void
          CardiacOutput (::std::unique_ptr< CardiacOutput_type > p);



          typedef ::mil::tatrc::physiology::datamodel::ScalarPressureData CentralVenousPressure_type;

          typedef ::xsd::cxx::tree::optional< CentralVenousPressure_type > CentralVenousPressure_optional;

          typedef ::xsd::cxx::tree::traits< CentralVenousPressure_type, char > CentralVenousPressure_traits;

          const CentralVenousPressure_optional&
          CentralVenousPressure () const;

          CentralVenousPressure_optional&
          CentralVenousPressure ();

          void
          CentralVenousPressure (const CentralVenousPressure_type& x);

          void
          CentralVenousPressure (const CentralVenousPressure_optional& x);

          void
          CentralVenousPressure (::std::unique_ptr< CentralVenousPressure_type > p);



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

          typedef ::xsd::cxx::tree::optional< CerebralBloodFlow_type > CerebralBloodFlow_optional;

          typedef ::xsd::cxx::tree::traits< CerebralBloodFlow_type, char > CerebralBloodFlow_traits;

          const CerebralBloodFlow_optional&
          CerebralBloodFlow () const;

          CerebralBloodFlow_optional&
          CerebralBloodFlow ();

          void
          CerebralBloodFlow (const CerebralBloodFlow_type& x);

          void
          CerebralBloodFlow (const CerebralBloodFlow_optional& x);

          void
          CerebralBloodFlow (::std::unique_ptr< CerebralBloodFlow_type > p);



          typedef ::mil::tatrc::physiology::datamodel::ScalarPressureData CerebralPerfusionPressure_type;

          typedef ::xsd::cxx::tree::optional< CerebralPerfusionPressure_type > CerebralPerfusionPressure_optional;

          typedef ::xsd::cxx::tree::traits< CerebralPerfusionPressure_type, char > CerebralPerfusionPressure_traits;

          const CerebralPerfusionPressure_optional&
          CerebralPerfusionPressure () const;

          CerebralPerfusionPressure_optional&
          CerebralPerfusionPressure ();

          void
          CerebralPerfusionPressure (const CerebralPerfusionPressure_type& x);

          void
          CerebralPerfusionPressure (const CerebralPerfusionPressure_optional& x);

          void
          CerebralPerfusionPressure (::std::unique_ptr< CerebralPerfusionPressure_type > p);



          typedef ::mil::tatrc::physiology::datamodel::ScalarPressureData DiastolicArterialPressure_type;

          typedef ::xsd::cxx::tree::optional< DiastolicArterialPressure_type > DiastolicArterialPressure_optional;

          typedef ::xsd::cxx::tree::traits< DiastolicArterialPressure_type, char > DiastolicArterialPressure_traits;

          const DiastolicArterialPressure_optional&
          DiastolicArterialPressure () const;

          DiastolicArterialPressure_optional&
          DiastolicArterialPressure ();

          void
          DiastolicArterialPressure (const DiastolicArterialPressure_type& x);

          void
          DiastolicArterialPressure (const DiastolicArterialPressure_optional& x);

          void
          DiastolicArterialPressure (::std::unique_ptr< DiastolicArterialPressure_type > p);



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

          typedef ::xsd::cxx::tree::optional< HeartEjectionFraction_type > HeartEjectionFraction_optional;

          typedef ::xsd::cxx::tree::traits< HeartEjectionFraction_type, char > HeartEjectionFraction_traits;

          const HeartEjectionFraction_optional&
          HeartEjectionFraction () const;

          HeartEjectionFraction_optional&
          HeartEjectionFraction ();

          void
          HeartEjectionFraction (const HeartEjectionFraction_type& x);

          void
          HeartEjectionFraction (const HeartEjectionFraction_optional& x);

          void
          HeartEjectionFraction (::std::unique_ptr< HeartEjectionFraction_type > p);



          typedef ::mil::tatrc::physiology::datamodel::ScalarFrequencyData HeartRate_type;

          typedef ::xsd::cxx::tree::optional< HeartRate_type > HeartRate_optional;

          typedef ::xsd::cxx::tree::traits< HeartRate_type, char > HeartRate_traits;

          const HeartRate_optional&
          HeartRate () const;

          HeartRate_optional&
          HeartRate ();

          void
          HeartRate (const HeartRate_type& x);

          void
          HeartRate (const HeartRate_optional& x);

          void
          HeartRate (::std::unique_ptr< HeartRate_type > p);



          typedef ::mil::tatrc::physiology::datamodel::enumHeartRhythm HeartRhythm_type;

          typedef ::xsd::cxx::tree::optional< HeartRhythm_type > HeartRhythm_optional;

          typedef ::xsd::cxx::tree::traits< HeartRhythm_type, char > HeartRhythm_traits;

          const HeartRhythm_optional&
          HeartRhythm () const;

          HeartRhythm_optional&
          HeartRhythm ();

          void
          HeartRhythm (const HeartRhythm_type& x);

          void
          HeartRhythm (const HeartRhythm_optional& x);

          void
          HeartRhythm (::std::unique_ptr< HeartRhythm_type > p);



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

          typedef ::xsd::cxx::tree::optional< HeartStrokeVolume_type > HeartStrokeVolume_optional;

          typedef ::xsd::cxx::tree::traits< HeartStrokeVolume_type, char > HeartStrokeVolume_traits;

          const HeartStrokeVolume_optional&
          HeartStrokeVolume () const;

          HeartStrokeVolume_optional&
          HeartStrokeVolume ();

          void
          HeartStrokeVolume (const HeartStrokeVolume_type& x);

          void
          HeartStrokeVolume (const HeartStrokeVolume_optional& x);

          void
          HeartStrokeVolume (::std::unique_ptr< HeartStrokeVolume_type > p);



          typedef ::mil::tatrc::physiology::datamodel::ScalarPressureData IntracranialPressure_type;

          typedef ::xsd::cxx::tree::optional< IntracranialPressure_type > IntracranialPressure_optional;

          typedef ::xsd::cxx::tree::traits< IntracranialPressure_type, char > IntracranialPressure_traits;

          const IntracranialPressure_optional&
          IntracranialPressure () const;

          IntracranialPressure_optional&
          IntracranialPressure ();

          void
          IntracranialPressure (const IntracranialPressure_type& x);

          void
          IntracranialPressure (const IntracranialPressure_optional& x);

          void
          IntracranialPressure (::std::unique_ptr< IntracranialPressure_type > p);



          typedef ::mil::tatrc::physiology::datamodel::ScalarPressureData MeanArterialPressure_type;

          typedef ::xsd::cxx::tree::optional< MeanArterialPressure_type > MeanArterialPressure_optional;

          typedef ::xsd::cxx::tree::traits< MeanArterialPressure_type, char > MeanArterialPressure_traits;

          const MeanArterialPressure_optional&
          MeanArterialPressure () const;

          MeanArterialPressure_optional&
          MeanArterialPressure ();

          void
          MeanArterialPressure (const MeanArterialPressure_type& x);

          void
          MeanArterialPressure (const MeanArterialPressure_optional& x);

          void
          MeanArterialPressure (::std::unique_ptr< MeanArterialPressure_type > p);



          typedef ::mil::tatrc::physiology::datamodel::ScalarPressureData MeanArterialCarbonDioxidePartialPressure_type;

          typedef ::xsd::cxx::tree::optional< MeanArterialCarbonDioxidePartialPressure_type > MeanArterialCarbonDioxidePartialPressure_optional;

          typedef ::xsd::cxx::tree::traits< MeanArterialCarbonDioxidePartialPressure_type, char > MeanArterialCarbonDioxidePartialPressure_traits;

          const MeanArterialCarbonDioxidePartialPressure_optional&
          MeanArterialCarbonDioxidePartialPressure () const;

          MeanArterialCarbonDioxidePartialPressure_optional&
          MeanArterialCarbonDioxidePartialPressure ();

          void
          MeanArterialCarbonDioxidePartialPressure (const MeanArterialCarbonDioxidePartialPressure_type& x);

          void
          MeanArterialCarbonDioxidePartialPressure (const MeanArterialCarbonDioxidePartialPressure_optional& x);

          void
          MeanArterialCarbonDioxidePartialPressure (::std::unique_ptr< MeanArterialCarbonDioxidePartialPressure_type > p);



          typedef ::mil::tatrc::physiology::datamodel::ScalarPressureData MeanArterialCarbonDioxidePartialPressureDelta_type;

          typedef ::xsd::cxx::tree::optional< MeanArterialCarbonDioxidePartialPressureDelta_type > MeanArterialCarbonDioxidePartialPressureDelta_optional;

          typedef ::xsd::cxx::tree::traits< MeanArterialCarbonDioxidePartialPressureDelta_type, char > MeanArterialCarbonDioxidePartialPressureDelta_traits;

          const MeanArterialCarbonDioxidePartialPressureDelta_optional&
          MeanArterialCarbonDioxidePartialPressureDelta () const;

          MeanArterialCarbonDioxidePartialPressureDelta_optional&
          MeanArterialCarbonDioxidePartialPressureDelta ();

          void
          MeanArterialCarbonDioxidePartialPressureDelta (const MeanArterialCarbonDioxidePartialPressureDelta_type& x);

          void
          MeanArterialCarbonDioxidePartialPressureDelta (const MeanArterialCarbonDioxidePartialPressureDelta_optional& x);

          void
          MeanArterialCarbonDioxidePartialPressureDelta (::std::unique_ptr< MeanArterialCarbonDioxidePartialPressureDelta_type > p);



          typedef ::mil::tatrc::physiology::datamodel::ScalarPressureData MeanCentralVenousPressure_type;

          typedef ::xsd::cxx::tree::optional< MeanCentralVenousPressure_type > MeanCentralVenousPressure_optional;

          typedef ::xsd::cxx::tree::traits< MeanCentralVenousPressure_type, char > MeanCentralVenousPressure_traits;

          const MeanCentralVenousPressure_optional&
          MeanCentralVenousPressure () const;

          MeanCentralVenousPressure_optional&
          MeanCentralVenousPressure ();

          void
          MeanCentralVenousPressure (const MeanCentralVenousPressure_type& x);

          void
          MeanCentralVenousPressure (const MeanCentralVenousPressure_optional& x);

          void
          MeanCentralVenousPressure (::std::unique_ptr< MeanCentralVenousPressure_type > p);



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

          typedef ::xsd::cxx::tree::optional< MeanSkinFlow_type > MeanSkinFlow_optional;

          typedef ::xsd::cxx::tree::traits< MeanSkinFlow_type, char > MeanSkinFlow_traits;

          const MeanSkinFlow_optional&
          MeanSkinFlow () const;

          MeanSkinFlow_optional&
          MeanSkinFlow ();

          void
          MeanSkinFlow (const MeanSkinFlow_type& x);

          void
          MeanSkinFlow (const MeanSkinFlow_optional& x);

          void
          MeanSkinFlow (::std::unique_ptr< MeanSkinFlow_type > p);



          typedef ::mil::tatrc::physiology::datamodel::ScalarPressureData PulmonaryArterialPressure_type;

          typedef ::xsd::cxx::tree::optional< PulmonaryArterialPressure_type > PulmonaryArterialPressure_optional;

          typedef ::xsd::cxx::tree::traits< PulmonaryArterialPressure_type, char > PulmonaryArterialPressure_traits;

          const PulmonaryArterialPressure_optional&
          PulmonaryArterialPressure () const;

          PulmonaryArterialPressure_optional&
          PulmonaryArterialPressure ();

          void
          PulmonaryArterialPressure (const PulmonaryArterialPressure_type& x);

          void
          PulmonaryArterialPressure (const PulmonaryArterialPressure_optional& x);

          void
          PulmonaryArterialPressure (::std::unique_ptr< PulmonaryArterialPressure_type > p);



          typedef ::mil::tatrc::physiology::datamodel::ScalarPressureData PulmonaryCapillariesWedgePressure_type;

          typedef ::xsd::cxx::tree::optional< PulmonaryCapillariesWedgePressure_type > PulmonaryCapillariesWedgePressure_optional;

          typedef ::xsd::cxx::tree::traits< PulmonaryCapillariesWedgePressure_type, char > PulmonaryCapillariesWedgePressure_traits;

          const PulmonaryCapillariesWedgePressure_optional&
          PulmonaryCapillariesWedgePressure () const;

          PulmonaryCapillariesWedgePressure_optional&
          PulmonaryCapillariesWedgePressure ();

          void
          PulmonaryCapillariesWedgePressure (const PulmonaryCapillariesWedgePressure_type& x);

          void
          PulmonaryCapillariesWedgePressure (const PulmonaryCapillariesWedgePressure_optional& x);

          void
          PulmonaryCapillariesWedgePressure (::std::unique_ptr< PulmonaryCapillariesWedgePressure_type > p);



          typedef ::mil::tatrc::physiology::datamodel::ScalarPressureData PulmonaryDiastolicArterialPressure_type;

          typedef ::xsd::cxx::tree::optional< PulmonaryDiastolicArterialPressure_type > PulmonaryDiastolicArterialPressure_optional;

          typedef ::xsd::cxx::tree::traits< PulmonaryDiastolicArterialPressure_type, char > PulmonaryDiastolicArterialPressure_traits;

          const PulmonaryDiastolicArterialPressure_optional&
          PulmonaryDiastolicArterialPressure () const;

          PulmonaryDiastolicArterialPressure_optional&
          PulmonaryDiastolicArterialPressure ();

          void
          PulmonaryDiastolicArterialPressure (const PulmonaryDiastolicArterialPressure_type& x);

          void
          PulmonaryDiastolicArterialPressure (const PulmonaryDiastolicArterialPressure_optional& x);

          void
          PulmonaryDiastolicArterialPressure (::std::unique_ptr< PulmonaryDiastolicArterialPressure_type > p);



          typedef ::mil::tatrc::physiology::datamodel::ScalarPressureData PulmonaryMeanArterialPressure_type;

          typedef ::xsd::cxx::tree::optional< PulmonaryMeanArterialPressure_type > PulmonaryMeanArterialPressure_optional;

          typedef ::xsd::cxx::tree::traits< PulmonaryMeanArterialPressure_type, char > PulmonaryMeanArterialPressure_traits;

          const PulmonaryMeanArterialPressure_optional&
          PulmonaryMeanArterialPressure () const;

          PulmonaryMeanArterialPressure_optional&
          PulmonaryMeanArterialPressure ();

          void
          PulmonaryMeanArterialPressure (const PulmonaryMeanArterialPressure_type& x);

          void
          PulmonaryMeanArterialPressure (const PulmonaryMeanArterialPressure_optional& x);

          void
          PulmonaryMeanArterialPressure (::std::unique_ptr< PulmonaryMeanArterialPressure_type > p);



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

          typedef ::xsd::cxx::tree::optional< PulmonaryMeanCapillaryFlow_type > PulmonaryMeanCapillaryFlow_optional;

          typedef ::xsd::cxx::tree::traits< PulmonaryMeanCapillaryFlow_type, char > PulmonaryMeanCapillaryFlow_traits;

          const PulmonaryMeanCapillaryFlow_optional&
          PulmonaryMeanCapillaryFlow () const;

          PulmonaryMeanCapillaryFlow_optional&
          PulmonaryMeanCapillaryFlow ();

          void
          PulmonaryMeanCapillaryFlow (const PulmonaryMeanCapillaryFlow_type& x);

          void
          PulmonaryMeanCapillaryFlow (const PulmonaryMeanCapillaryFlow_optional& x);

          void
          PulmonaryMeanCapillaryFlow (::std::unique_ptr< PulmonaryMeanCapillaryFlow_type > p);



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

          typedef ::xsd::cxx::tree::optional< PulmonaryMeanShuntFlow_type > PulmonaryMeanShuntFlow_optional;

          typedef ::xsd::cxx::tree::traits< PulmonaryMeanShuntFlow_type, char > PulmonaryMeanShuntFlow_traits;

          const PulmonaryMeanShuntFlow_optional&
          PulmonaryMeanShuntFlow () const;

          PulmonaryMeanShuntFlow_optional&
          PulmonaryMeanShuntFlow ();

          void
          PulmonaryMeanShuntFlow (const PulmonaryMeanShuntFlow_type& x);

          void
          PulmonaryMeanShuntFlow (const PulmonaryMeanShuntFlow_optional& x);

          void
          PulmonaryMeanShuntFlow (::std::unique_ptr< PulmonaryMeanShuntFlow_type > p);



          typedef ::mil::tatrc::physiology::datamodel::ScalarPressureData PulmonarySystolicArterialPressure_type;

          typedef ::xsd::cxx::tree::optional< PulmonarySystolicArterialPressure_type > PulmonarySystolicArterialPressure_optional;

          typedef ::xsd::cxx::tree::traits< PulmonarySystolicArterialPressure_type, char > PulmonarySystolicArterialPressure_traits;

          const PulmonarySystolicArterialPressure_optional&
          PulmonarySystolicArterialPressure () const;

          PulmonarySystolicArterialPressure_optional&
          PulmonarySystolicArterialPressure ();

          void
          PulmonarySystolicArterialPressure (const PulmonarySystolicArterialPressure_type& x);

          void
          PulmonarySystolicArterialPressure (const PulmonarySystolicArterialPressure_optional& x);

          void
          PulmonarySystolicArterialPressure (::std::unique_ptr< PulmonarySystolicArterialPressure_type > p);



          typedef ::mil::tatrc::physiology::datamodel::ScalarFlowResistanceData PulmonaryVascularResistance_type;

          typedef ::xsd::cxx::tree::optional< PulmonaryVascularResistance_type > PulmonaryVascularResistance_optional;

          typedef ::xsd::cxx::tree::traits< PulmonaryVascularResistance_type, char > PulmonaryVascularResistance_traits;

          const PulmonaryVascularResistance_optional&
          PulmonaryVascularResistance () const;

          PulmonaryVascularResistance_optional&
          PulmonaryVascularResistance ();

          void
          PulmonaryVascularResistance (const PulmonaryVascularResistance_type& x);

          void
          PulmonaryVascularResistance (const PulmonaryVascularResistance_optional& x);

          void
          PulmonaryVascularResistance (::std::unique_ptr< PulmonaryVascularResistance_type > p);



          typedef ::mil::tatrc::physiology::datamodel::ScalarPressureTimePerVolumeAreaData PulmonaryVascularResistanceIndex_type;

          typedef ::xsd::cxx::tree::optional< PulmonaryVascularResistanceIndex_type > PulmonaryVascularResistanceIndex_optional;

          typedef ::xsd::cxx::tree::traits< PulmonaryVascularResistanceIndex_type, char > PulmonaryVascularResistanceIndex_traits;

          const PulmonaryVascularResistanceIndex_optional&
          PulmonaryVascularResistanceIndex () const;

          PulmonaryVascularResistanceIndex_optional&
          PulmonaryVascularResistanceIndex ();

          void
          PulmonaryVascularResistanceIndex (const PulmonaryVascularResistanceIndex_type& x);

          void
          PulmonaryVascularResistanceIndex (const PulmonaryVascularResistanceIndex_optional& x);

          void
          PulmonaryVascularResistanceIndex (::std::unique_ptr< PulmonaryVascularResistanceIndex_type > p);



          typedef ::mil::tatrc::physiology::datamodel::ScalarPressureData PulsePressure_type;

          typedef ::xsd::cxx::tree::optional< PulsePressure_type > PulsePressure_optional;

          typedef ::xsd::cxx::tree::traits< PulsePressure_type, char > PulsePressure_traits;

          const PulsePressure_optional&
          PulsePressure () const;

          PulsePressure_optional&
          PulsePressure ();

          void
          PulsePressure (const PulsePressure_type& x);

          void
          PulsePressure (const PulsePressure_optional& x);

          void
          PulsePressure (::std::unique_ptr< PulsePressure_type > p);



          typedef ::mil::tatrc::physiology::datamodel::ScalarFlowResistanceData SystemicVascularResistance_type;

          typedef ::xsd::cxx::tree::optional< SystemicVascularResistance_type > SystemicVascularResistance_optional;

          typedef ::xsd::cxx::tree::traits< SystemicVascularResistance_type, char > SystemicVascularResistance_traits;

          const SystemicVascularResistance_optional&
          SystemicVascularResistance () const;

          SystemicVascularResistance_optional&
          SystemicVascularResistance ();

          void
          SystemicVascularResistance (const SystemicVascularResistance_type& x);

          void
          SystemicVascularResistance (const SystemicVascularResistance_optional& x);

          void
          SystemicVascularResistance (::std::unique_ptr< SystemicVascularResistance_type > p);



          typedef ::mil::tatrc::physiology::datamodel::ScalarPressureData SystolicArterialPressure_type;

          typedef ::xsd::cxx::tree::optional< SystolicArterialPressure_type > SystolicArterialPressure_optional;

          typedef ::xsd::cxx::tree::traits< SystolicArterialPressure_type, char > SystolicArterialPressure_traits;

          const SystolicArterialPressure_optional&
          SystolicArterialPressure () const;

          SystolicArterialPressure_optional&
          SystolicArterialPressure ();

          void
          SystolicArterialPressure (const SystolicArterialPressure_type& x);

          void
          SystolicArterialPressure (const SystolicArterialPressure_optional& x);

          void
          SystolicArterialPressure (::std::unique_ptr< SystolicArterialPressure_type > p);



          CardiovascularSystemData ();

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

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

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

          CardiovascularSystemData&
          operator= (const CardiovascularSystemData& x);


          virtual 
          ~CardiovascularSystemData ();

          // Implementation.
          //

          //@cond

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

          protected:
          ArterialPressure_optional ArterialPressure_;
          BloodVolume_optional BloodVolume_;
          CardiacIndex_optional CardiacIndex_;
          CardiacOutput_optional CardiacOutput_;
          CentralVenousPressure_optional CentralVenousPressure_;
          CerebralBloodFlow_optional CerebralBloodFlow_;
          CerebralPerfusionPressure_optional CerebralPerfusionPressure_;
          DiastolicArterialPressure_optional DiastolicArterialPressure_;
          HeartEjectionFraction_optional HeartEjectionFraction_;
          HeartRate_optional HeartRate_;
          HeartRhythm_optional HeartRhythm_;
          HeartStrokeVolume_optional HeartStrokeVolume_;
          IntracranialPressure_optional IntracranialPressure_;
          MeanArterialPressure_optional MeanArterialPressure_;
          MeanArterialCarbonDioxidePartialPressure_optional MeanArterialCarbonDioxidePartialPressure_;
          MeanArterialCarbonDioxidePartialPressureDelta_optional MeanArterialCarbonDioxidePartialPressureDelta_;
          MeanCentralVenousPressure_optional MeanCentralVenousPressure_;
          MeanSkinFlow_optional MeanSkinFlow_;
          PulmonaryArterialPressure_optional PulmonaryArterialPressure_;
          PulmonaryCapillariesWedgePressure_optional PulmonaryCapillariesWedgePressure_;
          PulmonaryDiastolicArterialPressure_optional PulmonaryDiastolicArterialPressure_;
          PulmonaryMeanArterialPressure_optional PulmonaryMeanArterialPressure_;
          PulmonaryMeanCapillaryFlow_optional PulmonaryMeanCapillaryFlow_;
          PulmonaryMeanShuntFlow_optional PulmonaryMeanShuntFlow_;
          PulmonarySystolicArterialPressure_optional PulmonarySystolicArterialPressure_;
          PulmonaryVascularResistance_optional PulmonaryVascularResistance_;
          PulmonaryVascularResistanceIndex_optional PulmonaryVascularResistanceIndex_;
          PulsePressure_optional PulsePressure_;
          SystemicVascularResistance_optional SystemicVascularResistance_;
          SystolicArterialPressure_optional SystolicArterialPressure_;

          //@endcond
        };

        class BIOGEARS_CDM_API DrugSystemData: public ::mil::tatrc::physiology::datamodel::SystemData
        {
          public:

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

          typedef ::xsd::cxx::tree::optional< AntibioticActivity_type > AntibioticActivity_optional;

          typedef ::xsd::cxx::tree::traits< AntibioticActivity_type, char > AntibioticActivity_traits;

          const AntibioticActivity_optional&
          AntibioticActivity () const;

          AntibioticActivity_optional&
          AntibioticActivity ();

          void
          AntibioticActivity (const AntibioticActivity_type& x);

          void
          AntibioticActivity (const AntibioticActivity_optional& x);

          void
          AntibioticActivity (::std::unique_ptr< AntibioticActivity_type > p);



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

          typedef ::xsd::cxx::tree::optional< BronchodilationLevel_type > BronchodilationLevel_optional;

          typedef ::xsd::cxx::tree::traits< BronchodilationLevel_type, char > BronchodilationLevel_traits;

          const BronchodilationLevel_optional&
          BronchodilationLevel () const;

          BronchodilationLevel_optional&
          BronchodilationLevel ();

          void
          BronchodilationLevel (const BronchodilationLevel_type& x);

          void
          BronchodilationLevel (const BronchodilationLevel_optional& x);

          void
          BronchodilationLevel (::std::unique_ptr< BronchodilationLevel_type > p);



          typedef ::mil::tatrc::physiology::datamodel::ScalarTemperatureData FeverChange_type;

          typedef ::xsd::cxx::tree::optional< FeverChange_type > FeverChange_optional;

          typedef ::xsd::cxx::tree::traits< FeverChange_type, char > FeverChange_traits;

          const FeverChange_optional&
          FeverChange () const;

          FeverChange_optional&
          FeverChange ();

          void
          FeverChange (const FeverChange_type& x);

          void
          FeverChange (const FeverChange_optional& x);

          void
          FeverChange (::std::unique_ptr< FeverChange_type > p);



          typedef ::mil::tatrc::physiology::datamodel::ScalarFrequencyData HeartRateChange_type;

          typedef ::xsd::cxx::tree::optional< HeartRateChange_type > HeartRateChange_optional;

          typedef ::xsd::cxx::tree::traits< HeartRateChange_type, char > HeartRateChange_traits;

          const HeartRateChange_optional&
          HeartRateChange () const;

          HeartRateChange_optional&
          HeartRateChange ();

          void
          HeartRateChange (const HeartRateChange_type& x);

          void
          HeartRateChange (const HeartRateChange_optional& x);

          void
          HeartRateChange (::std::unique_ptr< HeartRateChange_type > p);



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

          typedef ::xsd::cxx::tree::optional< HemorrhageChange_type > HemorrhageChange_optional;

          typedef ::xsd::cxx::tree::traits< HemorrhageChange_type, char > HemorrhageChange_traits;

          const HemorrhageChange_optional&
          HemorrhageChange () const;

          HemorrhageChange_optional&
          HemorrhageChange ();

          void
          HemorrhageChange (const HemorrhageChange_type& x);

          void
          HemorrhageChange (const HemorrhageChange_optional& x);

          void
          HemorrhageChange (::std::unique_ptr< HemorrhageChange_type > p);



          typedef ::mil::tatrc::physiology::datamodel::ScalarPressureData MeanBloodPressureChange_type;

          typedef ::xsd::cxx::tree::optional< MeanBloodPressureChange_type > MeanBloodPressureChange_optional;

          typedef ::xsd::cxx::tree::traits< MeanBloodPressureChange_type, char > MeanBloodPressureChange_traits;

          const MeanBloodPressureChange_optional&
          MeanBloodPressureChange () const;

          MeanBloodPressureChange_optional&
          MeanBloodPressureChange ();

          void
          MeanBloodPressureChange (const MeanBloodPressureChange_type& x);

          void
          MeanBloodPressureChange (const MeanBloodPressureChange_optional& x);

          void
          MeanBloodPressureChange (::std::unique_ptr< MeanBloodPressureChange_type > p);



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

          typedef ::xsd::cxx::tree::optional< NeuromuscularBlockLevel_type > NeuromuscularBlockLevel_optional;

          typedef ::xsd::cxx::tree::traits< NeuromuscularBlockLevel_type, char > NeuromuscularBlockLevel_traits;

          const NeuromuscularBlockLevel_optional&
          NeuromuscularBlockLevel () const;

          NeuromuscularBlockLevel_optional&
          NeuromuscularBlockLevel ();

          void
          NeuromuscularBlockLevel (const NeuromuscularBlockLevel_type& x);

          void
          NeuromuscularBlockLevel (const NeuromuscularBlockLevel_optional& x);

          void
          NeuromuscularBlockLevel (::std::unique_ptr< NeuromuscularBlockLevel_type > p);



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

          typedef ::xsd::cxx::tree::optional< PainToleranceChange_type > PainToleranceChange_optional;

          typedef ::xsd::cxx::tree::traits< PainToleranceChange_type, char > PainToleranceChange_traits;

          const PainToleranceChange_optional&
          PainToleranceChange () const;

          PainToleranceChange_optional&
          PainToleranceChange ();

          void
          PainToleranceChange (const PainToleranceChange_type& x);

          void
          PainToleranceChange (const PainToleranceChange_optional& x);

          void
          PainToleranceChange (::std::unique_ptr< PainToleranceChange_type > p);



          typedef ::mil::tatrc::physiology::datamodel::ScalarPressureData PulsePressureChange_type;

          typedef ::xsd::cxx::tree::optional< PulsePressureChange_type > PulsePressureChange_optional;

          typedef ::xsd::cxx::tree::traits< PulsePressureChange_type, char > PulsePressureChange_traits;

          const PulsePressureChange_optional&
          PulsePressureChange () const;

          PulsePressureChange_optional&
          PulsePressureChange ();

          void
          PulsePressureChange (const PulsePressureChange_type& x);

          void
          PulsePressureChange (const PulsePressureChange_optional& x);

          void
          PulsePressureChange (::std::unique_ptr< PulsePressureChange_type > p);



          typedef ::mil::tatrc::physiology::datamodel::ScalarFrequencyData RespirationRateChange_type;

          typedef ::xsd::cxx::tree::optional< RespirationRateChange_type > RespirationRateChange_optional;

          typedef ::xsd::cxx::tree::traits< RespirationRateChange_type, char > RespirationRateChange_traits;

          const RespirationRateChange_optional&
          RespirationRateChange () const;

          RespirationRateChange_optional&
          RespirationRateChange ();

          void
          RespirationRateChange (const RespirationRateChange_type& x);

          void
          RespirationRateChange (const RespirationRateChange_optional& x);

          void
          RespirationRateChange (::std::unique_ptr< RespirationRateChange_type > p);



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

          typedef ::xsd::cxx::tree::optional< SedationLevel_type > SedationLevel_optional;

          typedef ::xsd::cxx::tree::traits< SedationLevel_type, char > SedationLevel_traits;

          const SedationLevel_optional&
          SedationLevel () const;

          SedationLevel_optional&
          SedationLevel ();

          void
          SedationLevel (const SedationLevel_type& x);

          void
          SedationLevel (const SedationLevel_optional& x);

          void
          SedationLevel (::std::unique_ptr< SedationLevel_type > p);



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

          typedef ::xsd::cxx::tree::optional< TidalVolumeChange_type > TidalVolumeChange_optional;

          typedef ::xsd::cxx::tree::traits< TidalVolumeChange_type, char > TidalVolumeChange_traits;

          const TidalVolumeChange_optional&
          TidalVolumeChange () const;

          TidalVolumeChange_optional&
          TidalVolumeChange ();

          void
          TidalVolumeChange (const TidalVolumeChange_type& x);

          void
          TidalVolumeChange (const TidalVolumeChange_optional& x);

          void
          TidalVolumeChange (::std::unique_ptr< TidalVolumeChange_type > p);



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

          typedef ::xsd::cxx::tree::optional< TubularPermeabilityChange_type > TubularPermeabilityChange_optional;

          typedef ::xsd::cxx::tree::traits< TubularPermeabilityChange_type, char > TubularPermeabilityChange_traits;

          const TubularPermeabilityChange_optional&
          TubularPermeabilityChange () const;

          TubularPermeabilityChange_optional&
          TubularPermeabilityChange ();

          void
          TubularPermeabilityChange (const TubularPermeabilityChange_type& x);

          void
          TubularPermeabilityChange (const TubularPermeabilityChange_optional& x);

          void
          TubularPermeabilityChange (::std::unique_ptr< TubularPermeabilityChange_type > p);



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

          typedef ::xsd::cxx::tree::optional< CentralNervousResponse_type > CentralNervousResponse_optional;

          typedef ::xsd::cxx::tree::traits< CentralNervousResponse_type, char > CentralNervousResponse_traits;

          const CentralNervousResponse_optional&
          CentralNervousResponse () const;

          CentralNervousResponse_optional&
          CentralNervousResponse ();

          void
          CentralNervousResponse (const CentralNervousResponse_type& x);

          void
          CentralNervousResponse (const CentralNervousResponse_optional& x);

          void
          CentralNervousResponse (::std::unique_ptr< CentralNervousResponse_type > p);



          DrugSystemData ();

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

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

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

          DrugSystemData&
          operator= (const DrugSystemData& x);


          virtual 
          ~DrugSystemData ();

          // Implementation.
          //

          //@cond

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

          protected:
          AntibioticActivity_optional AntibioticActivity_;
          BronchodilationLevel_optional BronchodilationLevel_;
          FeverChange_optional FeverChange_;
          HeartRateChange_optional HeartRateChange_;
          HemorrhageChange_optional HemorrhageChange_;
          MeanBloodPressureChange_optional MeanBloodPressureChange_;
          NeuromuscularBlockLevel_optional NeuromuscularBlockLevel_;
          PainToleranceChange_optional PainToleranceChange_;
          PulsePressureChange_optional PulsePressureChange_;
          RespirationRateChange_optional RespirationRateChange_;
          SedationLevel_optional SedationLevel_;
          TidalVolumeChange_optional TidalVolumeChange_;
          TubularPermeabilityChange_optional TubularPermeabilityChange_;
          CentralNervousResponse_optional CentralNervousResponse_;

          //@endcond
        };

        class BIOGEARS_CDM_API EndocrineSystemData: public ::mil::tatrc::physiology::datamodel::SystemData
        {
          public:

          typedef ::mil::tatrc::physiology::datamodel::ScalarAmountPerTimeData InsulinSynthesisRate_type;

          typedef ::xsd::cxx::tree::optional< InsulinSynthesisRate_type > InsulinSynthesisRate_optional;

          typedef ::xsd::cxx::tree::traits< InsulinSynthesisRate_type, char > InsulinSynthesisRate_traits;

          const InsulinSynthesisRate_optional&
          InsulinSynthesisRate () const;

          InsulinSynthesisRate_optional&
          InsulinSynthesisRate ();

          void
          InsulinSynthesisRate (const InsulinSynthesisRate_type& x);

          void
          InsulinSynthesisRate (const InsulinSynthesisRate_optional& x);

          void
          InsulinSynthesisRate (::std::unique_ptr< InsulinSynthesisRate_type > p);



          typedef ::mil::tatrc::physiology::datamodel::ScalarAmountPerTimeData GlucagonSynthesisRate_type;

          typedef ::xsd::cxx::tree::optional< GlucagonSynthesisRate_type > GlucagonSynthesisRate_optional;

          typedef ::xsd::cxx::tree::traits< GlucagonSynthesisRate_type, char > GlucagonSynthesisRate_traits;

          const GlucagonSynthesisRate_optional&
          GlucagonSynthesisRate () const;

          GlucagonSynthesisRate_optional&
          GlucagonSynthesisRate ();

          void
          GlucagonSynthesisRate (const GlucagonSynthesisRate_type& x);

          void
          GlucagonSynthesisRate (const GlucagonSynthesisRate_optional& x);

          void
          GlucagonSynthesisRate (::std::unique_ptr< GlucagonSynthesisRate_type > p);



          EndocrineSystemData ();

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

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

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

          EndocrineSystemData&
          operator= (const EndocrineSystemData& x);


          virtual 
          ~EndocrineSystemData ();

          // Implementation.
          //

          //@cond

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

          protected:
          InsulinSynthesisRate_optional InsulinSynthesisRate_;
          GlucagonSynthesisRate_optional GlucagonSynthesisRate_;

          //@endcond
        };

        class BIOGEARS_CDM_API EnergySystemData: public ::mil::tatrc::physiology::datamodel::SystemData
        {
          public:

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

          typedef ::xsd::cxx::tree::optional< AchievedExerciseLevel_type > AchievedExerciseLevel_optional;

          typedef ::xsd::cxx::tree::traits< AchievedExerciseLevel_type, char > AchievedExerciseLevel_traits;

          const AchievedExerciseLevel_optional&
          AchievedExerciseLevel () const;

          AchievedExerciseLevel_optional&
          AchievedExerciseLevel ();

          void
          AchievedExerciseLevel (const AchievedExerciseLevel_type& x);

          void
          AchievedExerciseLevel (const AchievedExerciseLevel_optional& x);

          void
          AchievedExerciseLevel (::std::unique_ptr< AchievedExerciseLevel_type > p);



          typedef ::mil::tatrc::physiology::datamodel::ScalarTemperatureData CoreTemperature_type;

          typedef ::xsd::cxx::tree::optional< CoreTemperature_type > CoreTemperature_optional;

          typedef ::xsd::cxx::tree::traits< CoreTemperature_type, char > CoreTemperature_traits;

          const CoreTemperature_optional&
          CoreTemperature () const;

          CoreTemperature_optional&
          CoreTemperature ();

          void
          CoreTemperature (const CoreTemperature_type& x);

          void
          CoreTemperature (const CoreTemperature_optional& x);

          void
          CoreTemperature (::std::unique_ptr< CoreTemperature_type > p);



          typedef ::mil::tatrc::physiology::datamodel::ScalarAmountPerTimeData CreatinineProductionRate_type;

          typedef ::xsd::cxx::tree::optional< CreatinineProductionRate_type > CreatinineProductionRate_optional;

          typedef ::xsd::cxx::tree::traits< CreatinineProductionRate_type, char > CreatinineProductionRate_traits;

          const CreatinineProductionRate_optional&
          CreatinineProductionRate () const;

          CreatinineProductionRate_optional&
          CreatinineProductionRate ();

          void
          CreatinineProductionRate (const CreatinineProductionRate_type& x);

          void
          CreatinineProductionRate (const CreatinineProductionRate_optional& x);

          void
          CreatinineProductionRate (::std::unique_ptr< CreatinineProductionRate_type > p);



          typedef ::mil::tatrc::physiology::datamodel::ScalarPowerData ExerciseEnergyDemand_type;

          typedef ::xsd::cxx::tree::optional< ExerciseEnergyDemand_type > ExerciseEnergyDemand_optional;

          typedef ::xsd::cxx::tree::traits< ExerciseEnergyDemand_type, char > ExerciseEnergyDemand_traits;

          const ExerciseEnergyDemand_optional&
          ExerciseEnergyDemand () const;

          ExerciseEnergyDemand_optional&
          ExerciseEnergyDemand ();

          void
          ExerciseEnergyDemand (const ExerciseEnergyDemand_type& x);

          void
          ExerciseEnergyDemand (const ExerciseEnergyDemand_optional& x);

          void
          ExerciseEnergyDemand (::std::unique_ptr< ExerciseEnergyDemand_type > p);



          typedef ::mil::tatrc::physiology::datamodel::ScalarPressureData ExerciseMeanArterialPressureDelta_type;

          typedef ::xsd::cxx::tree::optional< ExerciseMeanArterialPressureDelta_type > ExerciseMeanArterialPressureDelta_optional;

          typedef ::xsd::cxx::tree::traits< ExerciseMeanArterialPressureDelta_type, char > ExerciseMeanArterialPressureDelta_traits;

          const ExerciseMeanArterialPressureDelta_optional&
          ExerciseMeanArterialPressureDelta () const;

          ExerciseMeanArterialPressureDelta_optional&
          ExerciseMeanArterialPressureDelta ();

          void
          ExerciseMeanArterialPressureDelta (const ExerciseMeanArterialPressureDelta_type& x);

          void
          ExerciseMeanArterialPressureDelta (const ExerciseMeanArterialPressureDelta_optional& x);

          void
          ExerciseMeanArterialPressureDelta (::std::unique_ptr< ExerciseMeanArterialPressureDelta_type > p);



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

          typedef ::xsd::cxx::tree::optional< FatigueLevel_type > FatigueLevel_optional;

          typedef ::xsd::cxx::tree::traits< FatigueLevel_type, char > FatigueLevel_traits;

          const FatigueLevel_optional&
          FatigueLevel () const;

          FatigueLevel_optional&
          FatigueLevel ();

          void
          FatigueLevel (const FatigueLevel_type& x);

          void
          FatigueLevel (const FatigueLevel_optional& x);

          void
          FatigueLevel (::std::unique_ptr< FatigueLevel_type > p);



          typedef ::mil::tatrc::physiology::datamodel::ScalarAmountPerTimeData LactateProductionRate_type;

          typedef ::xsd::cxx::tree::optional< LactateProductionRate_type > LactateProductionRate_optional;

          typedef ::xsd::cxx::tree::traits< LactateProductionRate_type, char > LactateProductionRate_traits;

          const LactateProductionRate_optional&
          LactateProductionRate () const;

          LactateProductionRate_optional&
          LactateProductionRate ();

          void
          LactateProductionRate (const LactateProductionRate_type& x);

          void
          LactateProductionRate (const LactateProductionRate_optional& x);

          void
          LactateProductionRate (::std::unique_ptr< LactateProductionRate_type > p);



          typedef ::mil::tatrc::physiology::datamodel::ScalarTemperatureData SkinTemperature_type;

          typedef ::xsd::cxx::tree::optional< SkinTemperature_type > SkinTemperature_optional;

          typedef ::xsd::cxx::tree::traits< SkinTemperature_type, char > SkinTemperature_traits;

          const SkinTemperature_optional&
          SkinTemperature () const;

          SkinTemperature_optional&
          SkinTemperature ();

          void
          SkinTemperature (const SkinTemperature_type& x);

          void
          SkinTemperature (const SkinTemperature_optional& x);

          void
          SkinTemperature (::std::unique_ptr< SkinTemperature_type > p);



          typedef ::mil::tatrc::physiology::datamodel::ScalarMassPerTimeData SweatRate_type;

          typedef ::xsd::cxx::tree::optional< SweatRate_type > SweatRate_optional;

          typedef ::xsd::cxx::tree::traits< SweatRate_type, char > SweatRate_traits;

          const SweatRate_optional&
          SweatRate () const;

          SweatRate_optional&
          SweatRate ();

          void
          SweatRate (const SweatRate_type& x);

          void
          SweatRate (const SweatRate_optional& x);

          void
          SweatRate (::std::unique_ptr< SweatRate_type > p);



          typedef ::mil::tatrc::physiology::datamodel::ScalarPowerData TotalMetabolicRate_type;

          typedef ::xsd::cxx::tree::optional< TotalMetabolicRate_type > TotalMetabolicRate_optional;

          typedef ::xsd::cxx::tree::traits< TotalMetabolicRate_type, char > TotalMetabolicRate_traits;

          const TotalMetabolicRate_optional&
          TotalMetabolicRate () const;

          TotalMetabolicRate_optional&
          TotalMetabolicRate ();

          void
          TotalMetabolicRate (const TotalMetabolicRate_type& x);

          void
          TotalMetabolicRate (const TotalMetabolicRate_optional& x);

          void
          TotalMetabolicRate (::std::unique_ptr< TotalMetabolicRate_type > p);



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

          typedef ::xsd::cxx::tree::optional< TotalWorkRateLevel_type > TotalWorkRateLevel_optional;

          typedef ::xsd::cxx::tree::traits< TotalWorkRateLevel_type, char > TotalWorkRateLevel_traits;

          const TotalWorkRateLevel_optional&
          TotalWorkRateLevel () const;

          TotalWorkRateLevel_optional&
          TotalWorkRateLevel ();

          void
          TotalWorkRateLevel (const TotalWorkRateLevel_type& x);

          void
          TotalWorkRateLevel (const TotalWorkRateLevel_optional& x);

          void
          TotalWorkRateLevel (::std::unique_ptr< TotalWorkRateLevel_type > p);



          typedef ::mil::tatrc::physiology::datamodel::ScalarMassData SodiumLostToSweat_type;

          typedef ::xsd::cxx::tree::optional< SodiumLostToSweat_type > SodiumLostToSweat_optional;

          typedef ::xsd::cxx::tree::traits< SodiumLostToSweat_type, char > SodiumLostToSweat_traits;

          const SodiumLostToSweat_optional&
          SodiumLostToSweat () const;

          SodiumLostToSweat_optional&
          SodiumLostToSweat ();

          void
          SodiumLostToSweat (const SodiumLostToSweat_type& x);

          void
          SodiumLostToSweat (const SodiumLostToSweat_optional& x);

          void
          SodiumLostToSweat (::std::unique_ptr< SodiumLostToSweat_type > p);



          typedef ::mil::tatrc::physiology::datamodel::ScalarMassData PotassiumLostToSweat_type;

          typedef ::xsd::cxx::tree::optional< PotassiumLostToSweat_type > PotassiumLostToSweat_optional;

          typedef ::xsd::cxx::tree::traits< PotassiumLostToSweat_type, char > PotassiumLostToSweat_traits;

          const PotassiumLostToSweat_optional&
          PotassiumLostToSweat () const;

          PotassiumLostToSweat_optional&
          PotassiumLostToSweat ();

          void
          PotassiumLostToSweat (const PotassiumLostToSweat_type& x);

          void
          PotassiumLostToSweat (const PotassiumLostToSweat_optional& x);

          void
          PotassiumLostToSweat (::std::unique_ptr< PotassiumLostToSweat_type > p);



          typedef ::mil::tatrc::physiology::datamodel::ScalarMassData ChlorideLostToSweat_type;

          typedef ::xsd::cxx::tree::optional< ChlorideLostToSweat_type > ChlorideLostToSweat_optional;

          typedef ::xsd::cxx::tree::traits< ChlorideLostToSweat_type, char > ChlorideLostToSweat_traits;

          const ChlorideLostToSweat_optional&
          ChlorideLostToSweat () const;

          ChlorideLostToSweat_optional&
          ChlorideLostToSweat ();

          void
          ChlorideLostToSweat (const ChlorideLostToSweat_type& x);

          void
          ChlorideLostToSweat (const ChlorideLostToSweat_optional& x);

          void
          ChlorideLostToSweat (::std::unique_ptr< ChlorideLostToSweat_type > p);



          typedef ::mil::tatrc::physiology::datamodel::ScalarPowerData EnergyDeficit_type;

          typedef ::xsd::cxx::tree::optional< EnergyDeficit_type > EnergyDeficit_optional;

          typedef ::xsd::cxx::tree::traits< EnergyDeficit_type, char > EnergyDeficit_traits;

          const EnergyDeficit_optional&
          EnergyDeficit () const;

          EnergyDeficit_optional&
          EnergyDeficit ();

          void
          EnergyDeficit (const EnergyDeficit_type& x);

          void
          EnergyDeficit (const EnergyDeficit_optional& x);

          void
          EnergyDeficit (::std::unique_ptr< EnergyDeficit_type > p);



          EnergySystemData ();

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

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

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

          EnergySystemData&
          operator= (const EnergySystemData& x);


          virtual 
          ~EnergySystemData ();

          // Implementation.
          //

          //@cond

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

          protected:
          AchievedExerciseLevel_optional AchievedExerciseLevel_;
          CoreTemperature_optional CoreTemperature_;
          CreatinineProductionRate_optional CreatinineProductionRate_;
          ExerciseEnergyDemand_optional ExerciseEnergyDemand_;
          ExerciseMeanArterialPressureDelta_optional ExerciseMeanArterialPressureDelta_;
          FatigueLevel_optional FatigueLevel_;
          LactateProductionRate_optional LactateProductionRate_;
          SkinTemperature_optional SkinTemperature_;
          SweatRate_optional SweatRate_;
          TotalMetabolicRate_optional TotalMetabolicRate_;
          TotalWorkRateLevel_optional TotalWorkRateLevel_;
          SodiumLostToSweat_optional SodiumLostToSweat_;
          PotassiumLostToSweat_optional PotassiumLostToSweat_;
          ChlorideLostToSweat_optional ChlorideLostToSweat_;
          EnergyDeficit_optional EnergyDeficit_;

          //@endcond
        };

        class BIOGEARS_CDM_API DrugTransitStateData: public ::mil::tatrc::physiology::datamodel::ObjectData
        {
          public:

          typedef ::mil::tatrc::physiology::datamodel::ScalarMassData LumenSolidMasses_type;

          typedef ::xsd::cxx::tree::sequence< LumenSolidMasses_type > LumenSolidMasses_sequence;

          typedef LumenSolidMasses_sequence::iterator LumenSolidMasses_iterator;

          typedef LumenSolidMasses_sequence::const_iterator LumenSolidMasses_const_iterator;

          typedef ::xsd::cxx::tree::traits< LumenSolidMasses_type, char > LumenSolidMasses_traits;

          const LumenSolidMasses_sequence&
          LumenSolidMasses () const;

          LumenSolidMasses_sequence&
          LumenSolidMasses ();

          void
          LumenSolidMasses (const LumenSolidMasses_sequence& s);



          typedef ::mil::tatrc::physiology::datamodel::ScalarMassData LumenDissolvedMasses_type;

          typedef ::xsd::cxx::tree::sequence< LumenDissolvedMasses_type > LumenDissolvedMasses_sequence;

          typedef LumenDissolvedMasses_sequence::iterator LumenDissolvedMasses_iterator;

          typedef LumenDissolvedMasses_sequence::const_iterator LumenDissolvedMasses_const_iterator;

          typedef ::xsd::cxx::tree::traits< LumenDissolvedMasses_type, char > LumenDissolvedMasses_traits;

          const LumenDissolvedMasses_sequence&
          LumenDissolvedMasses () const;

          LumenDissolvedMasses_sequence&
          LumenDissolvedMasses ();

          void
          LumenDissolvedMasses (const LumenDissolvedMasses_sequence& s);



          typedef ::mil::tatrc::physiology::datamodel::ScalarMassData EnterocyteMasses_type;

          typedef ::xsd::cxx::tree::sequence< EnterocyteMasses_type > EnterocyteMasses_sequence;

          typedef EnterocyteMasses_sequence::iterator EnterocyteMasses_iterator;

          typedef EnterocyteMasses_sequence::const_iterator EnterocyteMasses_const_iterator;

          typedef ::xsd::cxx::tree::traits< EnterocyteMasses_type, char > EnterocyteMasses_traits;

          const EnterocyteMasses_sequence&
          EnterocyteMasses () const;

          EnterocyteMasses_sequence&
          EnterocyteMasses ();

          void
          EnterocyteMasses (const EnterocyteMasses_sequence& s);



          typedef ::mil::tatrc::physiology::datamodel::ScalarMassData MassMetabolized_type;

          typedef ::xsd::cxx::tree::traits< MassMetabolized_type, char > MassMetabolized_traits;

          const MassMetabolized_type&
          MassMetabolized () const;

          MassMetabolized_type&
          MassMetabolized ();

          void
          MassMetabolized (const MassMetabolized_type& x);

          void
          MassMetabolized (::std::unique_ptr< MassMetabolized_type > p);



          typedef ::mil::tatrc::physiology::datamodel::ScalarMassData MassExcreted_type;

          typedef ::xsd::cxx::tree::traits< MassExcreted_type, char > MassExcreted_traits;

          const MassExcreted_type&
          MassExcreted () const;

          MassExcreted_type&
          MassExcreted ();

          void
          MassExcreted (const MassExcreted_type& x);

          void
          MassExcreted (::std::unique_ptr< MassExcreted_type > p);



          typedef ::xml_schema::string Substance_type;

          typedef ::xsd::cxx::tree::traits< Substance_type, char > Substance_traits;

          const Substance_type&
          Substance () const;

          Substance_type&
          Substance ();

          void
          Substance (const Substance_type& x);

          void
          Substance (::std::unique_ptr< Substance_type > p);



          DrugTransitStateData ();

          DrugTransitStateData (const MassMetabolized_type&,
                                const MassExcreted_type&,
                                const Substance_type&);

          DrugTransitStateData (::std::unique_ptr< MassMetabolized_type >,
                                ::std::unique_ptr< MassExcreted_type >,
                                const Substance_type&);

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

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

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

          DrugTransitStateData&
          operator= (const DrugTransitStateData& x);


          virtual 
          ~DrugTransitStateData ();

          // Implementation.
          //

          //@cond

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

          protected:
          LumenSolidMasses_sequence LumenSolidMasses_;
          LumenDissolvedMasses_sequence LumenDissolvedMasses_;
          EnterocyteMasses_sequence EnterocyteMasses_;
          ::xsd::cxx::tree::one< MassMetabolized_type > MassMetabolized_;
          ::xsd::cxx::tree::one< MassExcreted_type > MassExcreted_;
          ::xsd::cxx::tree::one< Substance_type > Substance_;

          //@endcond
        };

        class BIOGEARS_CDM_API GastrointestinalSystemData: public ::mil::tatrc::physiology::datamodel::SystemData
        {
          public:

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

          typedef ::xsd::cxx::tree::optional< ChymeAbsorptionRate_type > ChymeAbsorptionRate_optional;

          typedef ::xsd::cxx::tree::traits< ChymeAbsorptionRate_type, char > ChymeAbsorptionRate_traits;

          const ChymeAbsorptionRate_optional&
          ChymeAbsorptionRate () const;

          ChymeAbsorptionRate_optional&
          ChymeAbsorptionRate ();

          void
          ChymeAbsorptionRate (const ChymeAbsorptionRate_type& x);

          void
          ChymeAbsorptionRate (const ChymeAbsorptionRate_optional& x);

          void
          ChymeAbsorptionRate (::std::unique_ptr< ChymeAbsorptionRate_type > p);



          typedef ::mil::tatrc::physiology::datamodel::NutritionData StomachContents_type;

          typedef ::xsd::cxx::tree::optional< StomachContents_type > StomachContents_optional;

          typedef ::xsd::cxx::tree::traits< StomachContents_type, char > StomachContents_traits;

          const StomachContents_optional&
          StomachContents () const;

          StomachContents_optional&
          StomachContents ();

          void
          StomachContents (const StomachContents_type& x);

          void
          StomachContents (const StomachContents_optional& x);

          void
          StomachContents (::std::unique_ptr< StomachContents_type > p);



          typedef ::mil::tatrc::physiology::datamodel::DrugTransitStateData DrugTransitStates_type;

          typedef ::xsd::cxx::tree::sequence< DrugTransitStates_type > DrugTransitStates_sequence;

          typedef DrugTransitStates_sequence::iterator DrugTransitStates_iterator;

          typedef DrugTransitStates_sequence::const_iterator DrugTransitStates_const_iterator;

          typedef ::xsd::cxx::tree::traits< DrugTransitStates_type, char > DrugTransitStates_traits;

          const DrugTransitStates_sequence&
          DrugTransitStates () const;

          DrugTransitStates_sequence&
          DrugTransitStates ();

          void
          DrugTransitStates (const DrugTransitStates_sequence& s);



          GastrointestinalSystemData ();

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

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

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

          GastrointestinalSystemData&
          operator= (const GastrointestinalSystemData& x);


          virtual 
          ~GastrointestinalSystemData ();

          // Implementation.
          //

          //@cond

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

          protected:
          ChymeAbsorptionRate_optional ChymeAbsorptionRate_;
          StomachContents_optional StomachContents_;
          DrugTransitStates_sequence DrugTransitStates_;

          //@endcond
        };

        class BIOGEARS_CDM_API HepaticSystemData: public ::mil::tatrc::physiology::datamodel::SystemData
        {
          public:

          typedef ::mil::tatrc::physiology::datamodel::ScalarAmountPerTimeData KetoneProductionRate_type;

          typedef ::xsd::cxx::tree::optional< KetoneProductionRate_type > KetoneProductionRate_optional;

          typedef ::xsd::cxx::tree::traits< KetoneProductionRate_type, char > KetoneProductionRate_traits;

          const KetoneProductionRate_optional&
          KetoneProductionRate () const;

          KetoneProductionRate_optional&
          KetoneProductionRate ();

          void
          KetoneProductionRate (const KetoneProductionRate_type& x);

          void
          KetoneProductionRate (const KetoneProductionRate_optional& x);

          void
          KetoneProductionRate (::std::unique_ptr< KetoneProductionRate_type > p);



          typedef ::mil::tatrc::physiology::datamodel::ScalarMassPerTimeData HepaticGluconeogenesisRate_type;

          typedef ::xsd::cxx::tree::optional< HepaticGluconeogenesisRate_type > HepaticGluconeogenesisRate_optional;

          typedef ::xsd::cxx::tree::traits< HepaticGluconeogenesisRate_type, char > HepaticGluconeogenesisRate_traits;

          const HepaticGluconeogenesisRate_optional&
          HepaticGluconeogenesisRate () const;

          HepaticGluconeogenesisRate_optional&
          HepaticGluconeogenesisRate ();

          void
          HepaticGluconeogenesisRate (const HepaticGluconeogenesisRate_type& x);

          void
          HepaticGluconeogenesisRate (const HepaticGluconeogenesisRate_optional& x);

          void
          HepaticGluconeogenesisRate (::std::unique_ptr< HepaticGluconeogenesisRate_type > p);



          HepaticSystemData ();

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

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

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

          HepaticSystemData&
          operator= (const HepaticSystemData& x);


          virtual 
          ~HepaticSystemData ();

          // Implementation.
          //

          //@cond

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

          protected:
          KetoneProductionRate_optional KetoneProductionRate_;
          HepaticGluconeogenesisRate_optional HepaticGluconeogenesisRate_;

          //@endcond
        };

        class BIOGEARS_CDM_API enumSleepState: public ::xml_schema::string
        {
          public:

          enum value
          {
            Awake,
            Asleep
          };

          enumSleepState ();

          enumSleepState (value v);

          enumSleepState (const char* v);

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

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

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

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

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

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

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

          enumSleepState&
          operator= (value v);

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

          //@cond

          protected:
          value
          _xsd_enumSleepState_convert () const;

          public:
          static const char* const _xsd_enumSleepState_literals_[2];
          static const value _xsd_enumSleepState_indexes_[2];

          //@endcond
        };

        class BIOGEARS_CDM_API NervousSystemData: public ::mil::tatrc::physiology::datamodel::SystemData
        {
          public:

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

          typedef ::xsd::cxx::tree::optional< HeartRateScale_type > HeartRateScale_optional;

          typedef ::xsd::cxx::tree::traits< HeartRateScale_type, char > HeartRateScale_traits;

          const HeartRateScale_optional&
          HeartRateScale () const;

          HeartRateScale_optional&
          HeartRateScale ();

          void
          HeartRateScale (const HeartRateScale_type& x);

          void
          HeartRateScale (const HeartRateScale_optional& x);

          void
          HeartRateScale (::std::unique_ptr< HeartRateScale_type > p);



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

          typedef ::xsd::cxx::tree::optional< HeartElastanceScale_type > HeartElastanceScale_optional;

          typedef ::xsd::cxx::tree::traits< HeartElastanceScale_type, char > HeartElastanceScale_traits;

          const HeartElastanceScale_optional&
          HeartElastanceScale () const;

          HeartElastanceScale_optional&
          HeartElastanceScale ();

          void
          HeartElastanceScale (const HeartElastanceScale_type& x);

          void
          HeartElastanceScale (const HeartElastanceScale_optional& x);

          void
          HeartElastanceScale (::std::unique_ptr< HeartElastanceScale_type > p);



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

          typedef ::xsd::cxx::tree::optional< ResistanceScaleExtrasplanchnic_type > ResistanceScaleExtrasplanchnic_optional;

          typedef ::xsd::cxx::tree::traits< ResistanceScaleExtrasplanchnic_type, char > ResistanceScaleExtrasplanchnic_traits;

          const ResistanceScaleExtrasplanchnic_optional&
          ResistanceScaleExtrasplanchnic () const;

          ResistanceScaleExtrasplanchnic_optional&
          ResistanceScaleExtrasplanchnic ();

          void
          ResistanceScaleExtrasplanchnic (const ResistanceScaleExtrasplanchnic_type& x);

          void
          ResistanceScaleExtrasplanchnic (const ResistanceScaleExtrasplanchnic_optional& x);

          void
          ResistanceScaleExtrasplanchnic (::std::unique_ptr< ResistanceScaleExtrasplanchnic_type > p);



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

          typedef ::xsd::cxx::tree::optional< ResistanceScaleMuscle_type > ResistanceScaleMuscle_optional;

          typedef ::xsd::cxx::tree::traits< ResistanceScaleMuscle_type, char > ResistanceScaleMuscle_traits;

          const ResistanceScaleMuscle_optional&
          ResistanceScaleMuscle () const;

          ResistanceScaleMuscle_optional&
          ResistanceScaleMuscle ();

          void
          ResistanceScaleMuscle (const ResistanceScaleMuscle_type& x);

          void
          ResistanceScaleMuscle (const ResistanceScaleMuscle_optional& x);

          void
          ResistanceScaleMuscle (::std::unique_ptr< ResistanceScaleMuscle_type > p);



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

          typedef ::xsd::cxx::tree::optional< ResistanceScaleMyocardium_type > ResistanceScaleMyocardium_optional;

          typedef ::xsd::cxx::tree::traits< ResistanceScaleMyocardium_type, char > ResistanceScaleMyocardium_traits;

          const ResistanceScaleMyocardium_optional&
          ResistanceScaleMyocardium () const;

          ResistanceScaleMyocardium_optional&
          ResistanceScaleMyocardium ();

          void
          ResistanceScaleMyocardium (const ResistanceScaleMyocardium_type& x);

          void
          ResistanceScaleMyocardium (const ResistanceScaleMyocardium_optional& x);

          void
          ResistanceScaleMyocardium (::std::unique_ptr< ResistanceScaleMyocardium_type > p);



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

          typedef ::xsd::cxx::tree::optional< ResistanceScaleSplanchnic_type > ResistanceScaleSplanchnic_optional;

          typedef ::xsd::cxx::tree::traits< ResistanceScaleSplanchnic_type, char > ResistanceScaleSplanchnic_traits;

          const ResistanceScaleSplanchnic_optional&
          ResistanceScaleSplanchnic () const;

          ResistanceScaleSplanchnic_optional&
          ResistanceScaleSplanchnic ();

          void
          ResistanceScaleSplanchnic (const ResistanceScaleSplanchnic_type& x);

          void
          ResistanceScaleSplanchnic (const ResistanceScaleSplanchnic_optional& x);

          void
          ResistanceScaleSplanchnic (::std::unique_ptr< ResistanceScaleSplanchnic_type > p);



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

          typedef ::xsd::cxx::tree::optional< ComplianceScale_type > ComplianceScale_optional;

          typedef ::xsd::cxx::tree::traits< ComplianceScale_type, char > ComplianceScale_traits;

          const ComplianceScale_optional&
          ComplianceScale () const;

          ComplianceScale_optional&
          ComplianceScale ();

          void
          ComplianceScale (const ComplianceScale_type& x);

          void
          ComplianceScale (const ComplianceScale_optional& x);

          void
          ComplianceScale (::std::unique_ptr< ComplianceScale_type > p);



          typedef ::mil::tatrc::physiology::datamodel::PupillaryResponseData LeftEyePupillaryResponse_type;

          typedef ::xsd::cxx::tree::optional< LeftEyePupillaryResponse_type > LeftEyePupillaryResponse_optional;

          typedef ::xsd::cxx::tree::traits< LeftEyePupillaryResponse_type, char > LeftEyePupillaryResponse_traits;

          const LeftEyePupillaryResponse_optional&
          LeftEyePupillaryResponse () const;

          LeftEyePupillaryResponse_optional&
          LeftEyePupillaryResponse ();

          void
          LeftEyePupillaryResponse (const LeftEyePupillaryResponse_type& x);

          void
          LeftEyePupillaryResponse (const LeftEyePupillaryResponse_optional& x);

          void
          LeftEyePupillaryResponse (::std::unique_ptr< LeftEyePupillaryResponse_type > p);



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

          typedef ::xsd::cxx::tree::optional< PainVisualAnalogueScale_type > PainVisualAnalogueScale_optional;

          typedef ::xsd::cxx::tree::traits< PainVisualAnalogueScale_type, char > PainVisualAnalogueScale_traits;

          const PainVisualAnalogueScale_optional&
          PainVisualAnalogueScale () const;

          PainVisualAnalogueScale_optional&
          PainVisualAnalogueScale ();

          void
          PainVisualAnalogueScale (const PainVisualAnalogueScale_type& x);

          void
          PainVisualAnalogueScale (const PainVisualAnalogueScale_optional& x);

          void
          PainVisualAnalogueScale (::std::unique_ptr< PainVisualAnalogueScale_type > p);



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

          typedef ::xsd::cxx::tree::optional< RichmondAgitationSedationScale_type > RichmondAgitationSedationScale_optional;

          typedef ::xsd::cxx::tree::traits< RichmondAgitationSedationScale_type, char > RichmondAgitationSedationScale_traits;

          const RichmondAgitationSedationScale_optional&
          RichmondAgitationSedationScale () const;

          RichmondAgitationSedationScale_optional&
          RichmondAgitationSedationScale ();

          void
          RichmondAgitationSedationScale (const RichmondAgitationSedationScale_type& x);

          void
          RichmondAgitationSedationScale (const RichmondAgitationSedationScale_optional& x);

          void
          RichmondAgitationSedationScale (::std::unique_ptr< RichmondAgitationSedationScale_type > p);



          typedef ::mil::tatrc::physiology::datamodel::PupillaryResponseData RightEyePupillaryResponse_type;

          typedef ::xsd::cxx::tree::optional< RightEyePupillaryResponse_type > RightEyePupillaryResponse_optional;

          typedef ::xsd::cxx::tree::traits< RightEyePupillaryResponse_type, char > RightEyePupillaryResponse_traits;

          const RightEyePupillaryResponse_optional&
          RightEyePupillaryResponse () const;

          RightEyePupillaryResponse_optional&
          RightEyePupillaryResponse ();

          void
          RightEyePupillaryResponse (const RightEyePupillaryResponse_type& x);

          void
          RightEyePupillaryResponse (const RightEyePupillaryResponse_optional& x);

          void
          RightEyePupillaryResponse (::std::unique_ptr< RightEyePupillaryResponse_type > p);



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

          typedef ::xsd::cxx::tree::optional< SleepTime_type > SleepTime_optional;

          typedef ::xsd::cxx::tree::traits< SleepTime_type, char > SleepTime_traits;

          const SleepTime_optional&
          SleepTime () const;

          SleepTime_optional&
          SleepTime ();

          void
          SleepTime (const SleepTime_type& x);

          void
          SleepTime (const SleepTime_optional& x);

          void
          SleepTime (::std::unique_ptr< SleepTime_type > p);



          typedef ::mil::tatrc::physiology::datamodel::enumSleepState SleepState_type;

          typedef ::xsd::cxx::tree::optional< SleepState_type > SleepState_optional;

          typedef ::xsd::cxx::tree::traits< SleepState_type, char > SleepState_traits;

          const SleepState_optional&
          SleepState () const;

          SleepState_optional&
          SleepState ();

          void
          SleepState (const SleepState_type& x);

          void
          SleepState (const SleepState_optional& x);

          void
          SleepState (::std::unique_ptr< SleepState_type > p);



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

          typedef ::xsd::cxx::tree::optional< WakeTime_type > WakeTime_optional;

          typedef ::xsd::cxx::tree::traits< WakeTime_type, char > WakeTime_traits;

          const WakeTime_optional&
          WakeTime () const;

          WakeTime_optional&
          WakeTime ();

          void
          WakeTime (const WakeTime_type& x);

          void
          WakeTime (const WakeTime_optional& x);

          void
          WakeTime (::std::unique_ptr< WakeTime_type > p);



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

          typedef ::xsd::cxx::tree::optional< BiologicalDebt_type > BiologicalDebt_optional;

          typedef ::xsd::cxx::tree::traits< BiologicalDebt_type, char > BiologicalDebt_traits;

          const BiologicalDebt_optional&
          BiologicalDebt () const;

          BiologicalDebt_optional&
          BiologicalDebt ();

          void
          BiologicalDebt (const BiologicalDebt_type& x);

          void
          BiologicalDebt (const BiologicalDebt_optional& x);

          void
          BiologicalDebt (::std::unique_ptr< BiologicalDebt_type > p);



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



          NervousSystemData ();

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

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

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

          NervousSystemData&
          operator= (const NervousSystemData& x);


          virtual 
          ~NervousSystemData ();

          // Implementation.
          //

          //@cond

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

          protected:
          HeartRateScale_optional HeartRateScale_;
          HeartElastanceScale_optional HeartElastanceScale_;
          ResistanceScaleExtrasplanchnic_optional ResistanceScaleExtrasplanchnic_;
          ResistanceScaleMuscle_optional ResistanceScaleMuscle_;
          ResistanceScaleMyocardium_optional ResistanceScaleMyocardium_;
          ResistanceScaleSplanchnic_optional ResistanceScaleSplanchnic_;
          ComplianceScale_optional ComplianceScale_;
          LeftEyePupillaryResponse_optional LeftEyePupillaryResponse_;
          PainVisualAnalogueScale_optional PainVisualAnalogueScale_;
          RichmondAgitationSedationScale_optional RichmondAgitationSedationScale_;
          RightEyePupillaryResponse_optional RightEyePupillaryResponse_;
          SleepTime_optional SleepTime_;
          SleepState_optional SleepState_;
          WakeTime_optional WakeTime_;
          BiologicalDebt_optional BiologicalDebt_;
          ReactionTime_optional ReactionTime_;
          AttentionLapses_optional AttentionLapses_;

          //@endcond
        };

        class BIOGEARS_CDM_API RenalSystemData: public ::mil::tatrc::physiology::datamodel::SystemData
        {
          public:

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

          typedef ::xsd::cxx::tree::optional< FiltrationFraction_type > FiltrationFraction_optional;

          typedef ::xsd::cxx::tree::traits< FiltrationFraction_type, char > FiltrationFraction_traits;

          const FiltrationFraction_optional&
          FiltrationFraction () const;

          FiltrationFraction_optional&
          FiltrationFraction ();

          void
          FiltrationFraction (const FiltrationFraction_type& x);

          void
          FiltrationFraction (const FiltrationFraction_optional& x);

          void
          FiltrationFraction (::std::unique_ptr< FiltrationFraction_type > p);



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

          typedef ::xsd::cxx::tree::optional< GlomerularFiltrationRate_type > GlomerularFiltrationRate_optional;

          typedef ::xsd::cxx::tree::traits< GlomerularFiltrationRate_type, char > GlomerularFiltrationRate_traits;

          const GlomerularFiltrationRate_optional&
          GlomerularFiltrationRate () const;

          GlomerularFiltrationRate_optional&
          GlomerularFiltrationRate ();

          void
          GlomerularFiltrationRate (const GlomerularFiltrationRate_type& x);

          void
          GlomerularFiltrationRate (const GlomerularFiltrationRate_optional& x);

          void
          GlomerularFiltrationRate (::std::unique_ptr< GlomerularFiltrationRate_type > p);



          typedef ::mil::tatrc::physiology::datamodel::ScalarFlowResistanceData LeftAfferentArterioleResistance_type;

          typedef ::xsd::cxx::tree::optional< LeftAfferentArterioleResistance_type > LeftAfferentArterioleResistance_optional;

          typedef ::xsd::cxx::tree::traits< LeftAfferentArterioleResistance_type, char > LeftAfferentArterioleResistance_traits;

          const LeftAfferentArterioleResistance_optional&
          LeftAfferentArterioleResistance () const;

          LeftAfferentArterioleResistance_optional&
          LeftAfferentArterioleResistance ();

          void
          LeftAfferentArterioleResistance (const LeftAfferentArterioleResistance_type& x);

          void
          LeftAfferentArterioleResistance (const LeftAfferentArterioleResistance_optional& x);

          void
          LeftAfferentArterioleResistance (::std::unique_ptr< LeftAfferentArterioleResistance_type > p);



          typedef ::mil::tatrc::physiology::datamodel::ScalarPressureData LeftBowmansCapsulesHydrostaticPressure_type;

          typedef ::xsd::cxx::tree::optional< LeftBowmansCapsulesHydrostaticPressure_type > LeftBowmansCapsulesHydrostaticPressure_optional;

          typedef ::xsd::cxx::tree::traits< LeftBowmansCapsulesHydrostaticPressure_type, char > LeftBowmansCapsulesHydrostaticPressure_traits;

          const LeftBowmansCapsulesHydrostaticPressure_optional&
          LeftBowmansCapsulesHydrostaticPressure () const;

          LeftBowmansCapsulesHydrostaticPressure_optional&
          LeftBowmansCapsulesHydrostaticPressure ();

          void
          LeftBowmansCapsulesHydrostaticPressure (const LeftBowmansCapsulesHydrostaticPressure_type& x);

          void
          LeftBowmansCapsulesHydrostaticPressure (const LeftBowmansCapsulesHydrostaticPressure_optional& x);

          void
          LeftBowmansCapsulesHydrostaticPressure (::std::unique_ptr< LeftBowmansCapsulesHydrostaticPressure_type > p);



          typedef ::mil::tatrc::physiology::datamodel::ScalarPressureData LeftBowmansCapsulesOsmoticPressure_type;

          typedef ::xsd::cxx::tree::optional< LeftBowmansCapsulesOsmoticPressure_type > LeftBowmansCapsulesOsmoticPressure_optional;

          typedef ::xsd::cxx::tree::traits< LeftBowmansCapsulesOsmoticPressure_type, char > LeftBowmansCapsulesOsmoticPressure_traits;

          const LeftBowmansCapsulesOsmoticPressure_optional&
          LeftBowmansCapsulesOsmoticPressure () const;

          LeftBowmansCapsulesOsmoticPressure_optional&
          LeftBowmansCapsulesOsmoticPressure ();

          void
          LeftBowmansCapsulesOsmoticPressure (const LeftBowmansCapsulesOsmoticPressure_type& x);

          void
          LeftBowmansCapsulesOsmoticPressure (const LeftBowmansCapsulesOsmoticPressure_optional& x);

          void
          LeftBowmansCapsulesOsmoticPressure (::std::unique_ptr< LeftBowmansCapsulesOsmoticPressure_type > p);



          typedef ::mil::tatrc::physiology::datamodel::ScalarFlowResistanceData LeftEfferentArterioleResistance_type;

          typedef ::xsd::cxx::tree::optional< LeftEfferentArterioleResistance_type > LeftEfferentArterioleResistance_optional;

          typedef ::xsd::cxx::tree::traits< LeftEfferentArterioleResistance_type, char > LeftEfferentArterioleResistance_traits;

          const LeftEfferentArterioleResistance_optional&
          LeftEfferentArterioleResistance () const;

          LeftEfferentArterioleResistance_optional&
          LeftEfferentArterioleResistance ();

          void
          LeftEfferentArterioleResistance (const LeftEfferentArterioleResistance_type& x);

          void
          LeftEfferentArterioleResistance (const LeftEfferentArterioleResistance_optional& x);

          void
          LeftEfferentArterioleResistance (::std::unique_ptr< LeftEfferentArterioleResistance_type > p);



          typedef ::mil::tatrc::physiology::datamodel::ScalarPressureData LeftGlomerularCapillariesHydrostaticPressure_type;

          typedef ::xsd::cxx::tree::optional< LeftGlomerularCapillariesHydrostaticPressure_type > LeftGlomerularCapillariesHydrostaticPressure_optional;

          typedef ::xsd::cxx::tree::traits< LeftGlomerularCapillariesHydrostaticPressure_type, char > LeftGlomerularCapillariesHydrostaticPressure_traits;

          const LeftGlomerularCapillariesHydrostaticPressure_optional&
          LeftGlomerularCapillariesHydrostaticPressure () const;

          LeftGlomerularCapillariesHydrostaticPressure_optional&
          LeftGlomerularCapillariesHydrostaticPressure ();

          void
          LeftGlomerularCapillariesHydrostaticPressure (const LeftGlomerularCapillariesHydrostaticPressure_type& x);

          void
          LeftGlomerularCapillariesHydrostaticPressure (const LeftGlomerularCapillariesHydrostaticPressure_optional& x);

          void
          LeftGlomerularCapillariesHydrostaticPressure (::std::unique_ptr< LeftGlomerularCapillariesHydrostaticPressure_type > p);



          typedef ::mil::tatrc::physiology::datamodel::ScalarPressureData LeftGlomerularCapillariesOsmoticPressure_type;

          typedef ::xsd::cxx::tree::optional< LeftGlomerularCapillariesOsmoticPressure_type > LeftGlomerularCapillariesOsmoticPressure_optional;

          typedef ::xsd::cxx::tree::traits< LeftGlomerularCapillariesOsmoticPressure_type, char > LeftGlomerularCapillariesOsmoticPressure_traits;

          const LeftGlomerularCapillariesOsmoticPressure_optional&
          LeftGlomerularCapillariesOsmoticPressure () const;

          LeftGlomerularCapillariesOsmoticPressure_optional&
          LeftGlomerularCapillariesOsmoticPressure ();

          void
          LeftGlomerularCapillariesOsmoticPressure (const LeftGlomerularCapillariesOsmoticPressure_type& x);

          void
          LeftGlomerularCapillariesOsmoticPressure (const LeftGlomerularCapillariesOsmoticPressure_optional& x);

          void
          LeftGlomerularCapillariesOsmoticPressure (::std::unique_ptr< LeftGlomerularCapillariesOsmoticPressure_type > p);



          typedef ::mil::tatrc::physiology::datamodel::ScalarVolumePerTimePressureData LeftGlomerularFiltrationCoefficient_type;

          typedef ::xsd::cxx::tree::optional< LeftGlomerularFiltrationCoefficient_type > LeftGlomerularFiltrationCoefficient_optional;

          typedef ::xsd::cxx::tree::traits< LeftGlomerularFiltrationCoefficient_type, char > LeftGlomerularFiltrationCoefficient_traits;

          const LeftGlomerularFiltrationCoefficient_optional&
          LeftGlomerularFiltrationCoefficient () const;

          LeftGlomerularFiltrationCoefficient_optional&
          LeftGlomerularFiltrationCoefficient ();

          void
          LeftGlomerularFiltrationCoefficient (const LeftGlomerularFiltrationCoefficient_type& x);

          void
          LeftGlomerularFiltrationCoefficient (const LeftGlomerularFiltrationCoefficient_optional& x);

          void
          LeftGlomerularFiltrationCoefficient (::std::unique_ptr< LeftGlomerularFiltrationCoefficient_type > p);



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

          typedef ::xsd::cxx::tree::optional< LeftGlomerularFiltrationRate_type > LeftGlomerularFiltrationRate_optional;

          typedef ::xsd::cxx::tree::traits< LeftGlomerularFiltrationRate_type, char > LeftGlomerularFiltrationRate_traits;

          const LeftGlomerularFiltrationRate_optional&
          LeftGlomerularFiltrationRate () const;

          LeftGlomerularFiltrationRate_optional&
          LeftGlomerularFiltrationRate ();

          void
          LeftGlomerularFiltrationRate (const LeftGlomerularFiltrationRate_type& x);

          void
          LeftGlomerularFiltrationRate (const LeftGlomerularFiltrationRate_optional& x);

          void
          LeftGlomerularFiltrationRate (::std::unique_ptr< LeftGlomerularFiltrationRate_type > p);



          typedef ::mil::tatrc::physiology::datamodel::ScalarAreaData LeftGlomerularFiltrationSurfaceArea_type;

          typedef ::xsd::cxx::tree::optional< LeftGlomerularFiltrationSurfaceArea_type > LeftGlomerularFiltrationSurfaceArea_optional;

          typedef ::xsd::cxx::tree::traits< LeftGlomerularFiltrationSurfaceArea_type, char > LeftGlomerularFiltrationSurfaceArea_traits;

          const LeftGlomerularFiltrationSurfaceArea_optional&
          LeftGlomerularFiltrationSurfaceArea () const;

          LeftGlomerularFiltrationSurfaceArea_optional&
          LeftGlomerularFiltrationSurfaceArea ();

          void
          LeftGlomerularFiltrationSurfaceArea (const LeftGlomerularFiltrationSurfaceArea_type& x);

          void
          LeftGlomerularFiltrationSurfaceArea (const LeftGlomerularFiltrationSurfaceArea_optional& x);

          void
          LeftGlomerularFiltrationSurfaceArea (::std::unique_ptr< LeftGlomerularFiltrationSurfaceArea_type > p);



          typedef ::mil::tatrc::physiology::datamodel::ScalarVolumePerTimePressureAreaData LeftGlomerularFluidPermeability_type;

          typedef ::xsd::cxx::tree::optional< LeftGlomerularFluidPermeability_type > LeftGlomerularFluidPermeability_optional;

          typedef ::xsd::cxx::tree::traits< LeftGlomerularFluidPermeability_type, char > LeftGlomerularFluidPermeability_traits;

          const LeftGlomerularFluidPermeability_optional&
          LeftGlomerularFluidPermeability () const;

          LeftGlomerularFluidPermeability_optional&
          LeftGlomerularFluidPermeability ();

          void
          LeftGlomerularFluidPermeability (const LeftGlomerularFluidPermeability_type& x);

          void
          LeftGlomerularFluidPermeability (const LeftGlomerularFluidPermeability_optional& x);

          void
          LeftGlomerularFluidPermeability (::std::unique_ptr< LeftGlomerularFluidPermeability_type > p);



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

          typedef ::xsd::cxx::tree::optional< LeftFiltrationFraction_type > LeftFiltrationFraction_optional;

          typedef ::xsd::cxx::tree::traits< LeftFiltrationFraction_type, char > LeftFiltrationFraction_traits;

          const LeftFiltrationFraction_optional&
          LeftFiltrationFraction () const;

          LeftFiltrationFraction_optional&
          LeftFiltrationFraction ();

          void
          LeftFiltrationFraction (const LeftFiltrationFraction_type& x);

          void
          LeftFiltrationFraction (const LeftFiltrationFraction_optional& x);

          void
          LeftFiltrationFraction (::std::unique_ptr< LeftFiltrationFraction_type > p);



          typedef ::mil::tatrc::physiology::datamodel::ScalarPressureData LeftNetFiltrationPressure_type;

          typedef ::xsd::cxx::tree::optional< LeftNetFiltrationPressure_type > LeftNetFiltrationPressure_optional;

          typedef ::xsd::cxx::tree::traits< LeftNetFiltrationPressure_type, char > LeftNetFiltrationPressure_traits;

          const LeftNetFiltrationPressure_optional&
          LeftNetFiltrationPressure () const;

          LeftNetFiltrationPressure_optional&
          LeftNetFiltrationPressure ();

          void
          LeftNetFiltrationPressure (const LeftNetFiltrationPressure_type& x);

          void
          LeftNetFiltrationPressure (const LeftNetFiltrationPressure_optional& x);

          void
          LeftNetFiltrationPressure (::std::unique_ptr< LeftNetFiltrationPressure_type > p);



          typedef ::mil::tatrc::physiology::datamodel::ScalarPressureData LeftNetReabsorptionPressure_type;

          typedef ::xsd::cxx::tree::optional< LeftNetReabsorptionPressure_type > LeftNetReabsorptionPressure_optional;

          typedef ::xsd::cxx::tree::traits< LeftNetReabsorptionPressure_type, char > LeftNetReabsorptionPressure_traits;

          const LeftNetReabsorptionPressure_optional&
          LeftNetReabsorptionPressure () const;

          LeftNetReabsorptionPressure_optional&
          LeftNetReabsorptionPressure ();

          void
          LeftNetReabsorptionPressure (const LeftNetReabsorptionPressure_type& x);

          void
          LeftNetReabsorptionPressure (const LeftNetReabsorptionPressure_optional& x);

          void
          LeftNetReabsorptionPressure (::std::unique_ptr< LeftNetReabsorptionPressure_type > p);



          typedef ::mil::tatrc::physiology::datamodel::ScalarPressureData LeftPeritubularCapillariesHydrostaticPressure_type;

          typedef ::xsd::cxx::tree::optional< LeftPeritubularCapillariesHydrostaticPressure_type > LeftPeritubularCapillariesHydrostaticPressure_optional;

          typedef ::xsd::cxx::tree::traits< LeftPeritubularCapillariesHydrostaticPressure_type, char > LeftPeritubularCapillariesHydrostaticPressure_traits;

          const LeftPeritubularCapillariesHydrostaticPressure_optional&
          LeftPeritubularCapillariesHydrostaticPressure () const;

          LeftPeritubularCapillariesHydrostaticPressure_optional&
          LeftPeritubularCapillariesHydrostaticPressure ();

          void
          LeftPeritubularCapillariesHydrostaticPressure (const LeftPeritubularCapillariesHydrostaticPressure_type& x);

          void
          LeftPeritubularCapillariesHydrostaticPressure (const LeftPeritubularCapillariesHydrostaticPressure_optional& x);

          void
          LeftPeritubularCapillariesHydrostaticPressure (::std::unique_ptr< LeftPeritubularCapillariesHydrostaticPressure_type > p);



          typedef ::mil::tatrc::physiology::datamodel::ScalarPressureData LeftPeritubularCapillariesOsmoticPressure_type;

          typedef ::xsd::cxx::tree::optional< LeftPeritubularCapillariesOsmoticPressure_type > LeftPeritubularCapillariesOsmoticPressure_optional;

          typedef ::xsd::cxx::tree::traits< LeftPeritubularCapillariesOsmoticPressure_type, char > LeftPeritubularCapillariesOsmoticPressure_traits;

          const LeftPeritubularCapillariesOsmoticPressure_optional&
          LeftPeritubularCapillariesOsmoticPressure () const;

          LeftPeritubularCapillariesOsmoticPressure_optional&
          LeftPeritubularCapillariesOsmoticPressure ();

          void
          LeftPeritubularCapillariesOsmoticPressure (const LeftPeritubularCapillariesOsmoticPressure_type& x);

          void
          LeftPeritubularCapillariesOsmoticPressure (const LeftPeritubularCapillariesOsmoticPressure_optional& x);

          void
          LeftPeritubularCapillariesOsmoticPressure (::std::unique_ptr< LeftPeritubularCapillariesOsmoticPressure_type > p);



          typedef ::mil::tatrc::physiology::datamodel::ScalarVolumePerTimePressureData LeftReabsorptionFiltrationCoefficient_type;

          typedef ::xsd::cxx::tree::optional< LeftReabsorptionFiltrationCoefficient_type > LeftReabsorptionFiltrationCoefficient_optional;

          typedef ::xsd::cxx::tree::traits< LeftReabsorptionFiltrationCoefficient_type, char > LeftReabsorptionFiltrationCoefficient_traits;

          const LeftReabsorptionFiltrationCoefficient_optional&
          LeftReabsorptionFiltrationCoefficient () const;

          LeftReabsorptionFiltrationCoefficient_optional&
          LeftReabsorptionFiltrationCoefficient ();

          void
          LeftReabsorptionFiltrationCoefficient (const LeftReabsorptionFiltrationCoefficient_type& x);

          void
          LeftReabsorptionFiltrationCoefficient (const LeftReabsorptionFiltrationCoefficient_optional& x);

          void
          LeftReabsorptionFiltrationCoefficient (::std::unique_ptr< LeftReabsorptionFiltrationCoefficient_type > p);



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

          typedef ::xsd::cxx::tree::optional< LeftReabsorptionRate_type > LeftReabsorptionRate_optional;

          typedef ::xsd::cxx::tree::traits< LeftReabsorptionRate_type, char > LeftReabsorptionRate_traits;

          const LeftReabsorptionRate_optional&
          LeftReabsorptionRate () const;

          LeftReabsorptionRate_optional&
          LeftReabsorptionRate ();

          void
          LeftReabsorptionRate (const LeftReabsorptionRate_type& x);

          void
          LeftReabsorptionRate (const LeftReabsorptionRate_optional& x);

          void
          LeftReabsorptionRate (::std::unique_ptr< LeftReabsorptionRate_type > p);



          typedef ::mil::tatrc::physiology::datamodel::ScalarPressureData LeftTubularOsmoticPressure_type;

          typedef ::xsd::cxx::tree::optional< LeftTubularOsmoticPressure_type > LeftTubularOsmoticPressure_optional;

          typedef ::xsd::cxx::tree::traits< LeftTubularOsmoticPressure_type, char > LeftTubularOsmoticPressure_traits;

          const LeftTubularOsmoticPressure_optional&
          LeftTubularOsmoticPressure () const;

          LeftTubularOsmoticPressure_optional&
          LeftTubularOsmoticPressure ();

          void
          LeftTubularOsmoticPressure (const LeftTubularOsmoticPressure_type& x);

          void
          LeftTubularOsmoticPressure (const LeftTubularOsmoticPressure_optional& x);

          void
          LeftTubularOsmoticPressure (::std::unique_ptr< LeftTubularOsmoticPressure_type > p);



          typedef ::mil::tatrc::physiology::datamodel::ScalarPressureData LeftTubularHydrostaticPressure_type;

          typedef ::xsd::cxx::tree::optional< LeftTubularHydrostaticPressure_type > LeftTubularHydrostaticPressure_optional;

          typedef ::xsd::cxx::tree::traits< LeftTubularHydrostaticPressure_type, char > LeftTubularHydrostaticPressure_traits;

          const LeftTubularHydrostaticPressure_optional&
          LeftTubularHydrostaticPressure () const;

          LeftTubularHydrostaticPressure_optional&
          LeftTubularHydrostaticPressure ();

          void
          LeftTubularHydrostaticPressure (const LeftTubularHydrostaticPressure_type& x);

          void
          LeftTubularHydrostaticPressure (const LeftTubularHydrostaticPressure_optional& x);

          void
          LeftTubularHydrostaticPressure (::std::unique_ptr< LeftTubularHydrostaticPressure_type > p);



          typedef ::mil::tatrc::physiology::datamodel::ScalarAreaData LeftTubularReabsorptionFiltrationSurfaceArea_type;

          typedef ::xsd::cxx::tree::optional< LeftTubularReabsorptionFiltrationSurfaceArea_type > LeftTubularReabsorptionFiltrationSurfaceArea_optional;

          typedef ::xsd::cxx::tree::traits< LeftTubularReabsorptionFiltrationSurfaceArea_type, char > LeftTubularReabsorptionFiltrationSurfaceArea_traits;

          const LeftTubularReabsorptionFiltrationSurfaceArea_optional&
          LeftTubularReabsorptionFiltrationSurfaceArea () const;

          LeftTubularReabsorptionFiltrationSurfaceArea_optional&
          LeftTubularReabsorptionFiltrationSurfaceArea ();

          void
          LeftTubularReabsorptionFiltrationSurfaceArea (const LeftTubularReabsorptionFiltrationSurfaceArea_type& x);

          void
          LeftTubularReabsorptionFiltrationSurfaceArea (const LeftTubularReabsorptionFiltrationSurfaceArea_optional& x);

          void
          LeftTubularReabsorptionFiltrationSurfaceArea (::std::unique_ptr< LeftTubularReabsorptionFiltrationSurfaceArea_type > p);



          typedef ::mil::tatrc::physiology::datamodel::ScalarVolumePerTimePressureAreaData LeftTubularReabsorptionFluidPermeability_type;

          typedef ::xsd::cxx::tree::optional< LeftTubularReabsorptionFluidPermeability_type > LeftTubularReabsorptionFluidPermeability_optional;

          typedef ::xsd::cxx::tree::traits< LeftTubularReabsorptionFluidPermeability_type, char > LeftTubularReabsorptionFluidPermeability_traits;

          const LeftTubularReabsorptionFluidPermeability_optional&
          LeftTubularReabsorptionFluidPermeability () const;

          LeftTubularReabsorptionFluidPermeability_optional&
          LeftTubularReabsorptionFluidPermeability ();

          void
          LeftTubularReabsorptionFluidPermeability (const LeftTubularReabsorptionFluidPermeability_type& x);

          void
          LeftTubularReabsorptionFluidPermeability (const LeftTubularReabsorptionFluidPermeability_optional& x);

          void
          LeftTubularReabsorptionFluidPermeability (::std::unique_ptr< LeftTubularReabsorptionFluidPermeability_type > p);



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

          typedef ::xsd::cxx::tree::optional< RenalBloodFlow_type > RenalBloodFlow_optional;

          typedef ::xsd::cxx::tree::traits< RenalBloodFlow_type, char > RenalBloodFlow_traits;

          const RenalBloodFlow_optional&
          RenalBloodFlow () const;

          RenalBloodFlow_optional&
          RenalBloodFlow ();

          void
          RenalBloodFlow (const RenalBloodFlow_type& x);

          void
          RenalBloodFlow (const RenalBloodFlow_optional& x);

          void
          RenalBloodFlow (::std::unique_ptr< RenalBloodFlow_type > p);



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

          typedef ::xsd::cxx::tree::optional< RenalPlasmaFlow_type > RenalPlasmaFlow_optional;

          typedef ::xsd::cxx::tree::traits< RenalPlasmaFlow_type, char > RenalPlasmaFlow_traits;

          const RenalPlasmaFlow_optional&
          RenalPlasmaFlow () const;

          RenalPlasmaFlow_optional&
          RenalPlasmaFlow ();

          void
          RenalPlasmaFlow (const RenalPlasmaFlow_type& x);

          void
          RenalPlasmaFlow (const RenalPlasmaFlow_optional& x);

          void
          RenalPlasmaFlow (::std::unique_ptr< RenalPlasmaFlow_type > p);



          typedef ::mil::tatrc::physiology::datamodel::ScalarFlowResistanceData RenalVascularResistance_type;

          typedef ::xsd::cxx::tree::optional< RenalVascularResistance_type > RenalVascularResistance_optional;

          typedef ::xsd::cxx::tree::traits< RenalVascularResistance_type, char > RenalVascularResistance_traits;

          const RenalVascularResistance_optional&
          RenalVascularResistance () const;

          RenalVascularResistance_optional&
          RenalVascularResistance ();

          void
          RenalVascularResistance (const RenalVascularResistance_type& x);

          void
          RenalVascularResistance (const RenalVascularResistance_optional& x);

          void
          RenalVascularResistance (::std::unique_ptr< RenalVascularResistance_type > p);



          typedef ::mil::tatrc::physiology::datamodel::ScalarFlowResistanceData RightAfferentArterioleResistance_type;

          typedef ::xsd::cxx::tree::optional< RightAfferentArterioleResistance_type > RightAfferentArterioleResistance_optional;

          typedef ::xsd::cxx::tree::traits< RightAfferentArterioleResistance_type, char > RightAfferentArterioleResistance_traits;

          const RightAfferentArterioleResistance_optional&
          RightAfferentArterioleResistance () const;

          RightAfferentArterioleResistance_optional&
          RightAfferentArterioleResistance ();

          void
          RightAfferentArterioleResistance (const RightAfferentArterioleResistance_type& x);

          void
          RightAfferentArterioleResistance (const RightAfferentArterioleResistance_optional& x);

          void
          RightAfferentArterioleResistance (::std::unique_ptr< RightAfferentArterioleResistance_type > p);



          typedef ::mil::tatrc::physiology::datamodel::ScalarPressureData RightBowmansCapsulesHydrostaticPressure_type;

          typedef ::xsd::cxx::tree::optional< RightBowmansCapsulesHydrostaticPressure_type > RightBowmansCapsulesHydrostaticPressure_optional;

          typedef ::xsd::cxx::tree::traits< RightBowmansCapsulesHydrostaticPressure_type, char > RightBowmansCapsulesHydrostaticPressure_traits;

          const RightBowmansCapsulesHydrostaticPressure_optional&
          RightBowmansCapsulesHydrostaticPressure () const;

          RightBowmansCapsulesHydrostaticPressure_optional&
          RightBowmansCapsulesHydrostaticPressure ();

          void
          RightBowmansCapsulesHydrostaticPressure (const RightBowmansCapsulesHydrostaticPressure_type& x);

          void
          RightBowmansCapsulesHydrostaticPressure (const RightBowmansCapsulesHydrostaticPressure_optional& x);

          void
          RightBowmansCapsulesHydrostaticPressure (::std::unique_ptr< RightBowmansCapsulesHydrostaticPressure_type > p);



          typedef ::mil::tatrc::physiology::datamodel::ScalarPressureData RightBowmansCapsulesOsmoticPressure_type;

          typedef ::xsd::cxx::tree::optional< RightBowmansCapsulesOsmoticPressure_type > RightBowmansCapsulesOsmoticPressure_optional;

          typedef ::xsd::cxx::tree::traits< RightBowmansCapsulesOsmoticPressure_type, char > RightBowmansCapsulesOsmoticPressure_traits;

          const RightBowmansCapsulesOsmoticPressure_optional&
          RightBowmansCapsulesOsmoticPressure () const;

          RightBowmansCapsulesOsmoticPressure_optional&
          RightBowmansCapsulesOsmoticPressure ();

          void
          RightBowmansCapsulesOsmoticPressure (const RightBowmansCapsulesOsmoticPressure_type& x);

          void
          RightBowmansCapsulesOsmoticPressure (const RightBowmansCapsulesOsmoticPressure_optional& x);

          void
          RightBowmansCapsulesOsmoticPressure (::std::unique_ptr< RightBowmansCapsulesOsmoticPressure_type > p);



          typedef ::mil::tatrc::physiology::datamodel::ScalarFlowResistanceData RightEfferentArterioleResistance_type;

          typedef ::xsd::cxx::tree::optional< RightEfferentArterioleResistance_type > RightEfferentArterioleResistance_optional;

          typedef ::xsd::cxx::tree::traits< RightEfferentArterioleResistance_type, char > RightEfferentArterioleResistance_traits;

          const RightEfferentArterioleResistance_optional&
          RightEfferentArterioleResistance () const;

          RightEfferentArterioleResistance_optional&
          RightEfferentArterioleResistance ();

          void
          RightEfferentArterioleResistance (const RightEfferentArterioleResistance_type& x);

          void
          RightEfferentArterioleResistance (const RightEfferentArterioleResistance_optional& x);

          void
          RightEfferentArterioleResistance (::std::unique_ptr< RightEfferentArterioleResistance_type > p);



          typedef ::mil::tatrc::physiology::datamodel::ScalarPressureData RightGlomerularCapillariesHydrostaticPressure_type;

          typedef ::xsd::cxx::tree::optional< RightGlomerularCapillariesHydrostaticPressure_type > RightGlomerularCapillariesHydrostaticPressure_optional;

          typedef ::xsd::cxx::tree::traits< RightGlomerularCapillariesHydrostaticPressure_type, char > RightGlomerularCapillariesHydrostaticPressure_traits;

          const RightGlomerularCapillariesHydrostaticPressure_optional&
          RightGlomerularCapillariesHydrostaticPressure () const;

          RightGlomerularCapillariesHydrostaticPressure_optional&
          RightGlomerularCapillariesHydrostaticPressure ();

          void
          RightGlomerularCapillariesHydrostaticPressure (const RightGlomerularCapillariesHydrostaticPressure_type& x);

          void
          RightGlomerularCapillariesHydrostaticPressure (const RightGlomerularCapillariesHydrostaticPressure_optional& x);

          void
          RightGlomerularCapillariesHydrostaticPressure (::std::unique_ptr< RightGlomerularCapillariesHydrostaticPressure_type > p);



          typedef ::mil::tatrc::physiology::datamodel::ScalarPressureData RightGlomerularCapillariesOsmoticPressure_type;

          typedef ::xsd::cxx::tree::optional< RightGlomerularCapillariesOsmoticPressure_type > RightGlomerularCapillariesOsmoticPressure_optional;

          typedef ::xsd::cxx::tree::traits< RightGlomerularCapillariesOsmoticPressure_type, char > RightGlomerularCapillariesOsmoticPressure_traits;

          const RightGlomerularCapillariesOsmoticPressure_optional&
          RightGlomerularCapillariesOsmoticPressure () const;

          RightGlomerularCapillariesOsmoticPressure_optional&
          RightGlomerularCapillariesOsmoticPressure ();

          void
          RightGlomerularCapillariesOsmoticPressure (const RightGlomerularCapillariesOsmoticPressure_type& x);

          void
          RightGlomerularCapillariesOsmoticPressure (const RightGlomerularCapillariesOsmoticPressure_optional& x);

          void
          RightGlomerularCapillariesOsmoticPressure (::std::unique_ptr< RightGlomerularCapillariesOsmoticPressure_type > p);



          typedef ::mil::tatrc::physiology::datamodel::ScalarVolumePerTimePressureData RightGlomerularFiltrationCoefficient_type;

          typedef ::xsd::cxx::tree::optional< RightGlomerularFiltrationCoefficient_type > RightGlomerularFiltrationCoefficient_optional;

          typedef ::xsd::cxx::tree::traits< RightGlomerularFiltrationCoefficient_type, char > RightGlomerularFiltrationCoefficient_traits;

          const RightGlomerularFiltrationCoefficient_optional&
          RightGlomerularFiltrationCoefficient () const;

          RightGlomerularFiltrationCoefficient_optional&
          RightGlomerularFiltrationCoefficient ();

          void
          RightGlomerularFiltrationCoefficient (const RightGlomerularFiltrationCoefficient_type& x);

          void
          RightGlomerularFiltrationCoefficient (const RightGlomerularFiltrationCoefficient_optional& x);

          void
          RightGlomerularFiltrationCoefficient (::std::unique_ptr< RightGlomerularFiltrationCoefficient_type > p);



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

          typedef ::xsd::cxx::tree::optional< RightGlomerularFiltrationRate_type > RightGlomerularFiltrationRate_optional;

          typedef ::xsd::cxx::tree::traits< RightGlomerularFiltrationRate_type, char > RightGlomerularFiltrationRate_traits;

          const RightGlomerularFiltrationRate_optional&
          RightGlomerularFiltrationRate () const;

          RightGlomerularFiltrationRate_optional&
          RightGlomerularFiltrationRate ();

          void
          RightGlomerularFiltrationRate (const RightGlomerularFiltrationRate_type& x);

          void
          RightGlomerularFiltrationRate (const RightGlomerularFiltrationRate_optional& x);

          void
          RightGlomerularFiltrationRate (::std::unique_ptr< RightGlomerularFiltrationRate_type > p);



          typedef ::mil::tatrc::physiology::datamodel::ScalarAreaData RightGlomerularFiltrationSurfaceArea_type;

          typedef ::xsd::cxx::tree::optional< RightGlomerularFiltrationSurfaceArea_type > RightGlomerularFiltrationSurfaceArea_optional;

          typedef ::xsd::cxx::tree::traits< RightGlomerularFiltrationSurfaceArea_type, char > RightGlomerularFiltrationSurfaceArea_traits;

          const RightGlomerularFiltrationSurfaceArea_optional&
          RightGlomerularFiltrationSurfaceArea () const;

          RightGlomerularFiltrationSurfaceArea_optional&
          RightGlomerularFiltrationSurfaceArea ();

          void
          RightGlomerularFiltrationSurfaceArea (const RightGlomerularFiltrationSurfaceArea_type& x);

          void
          RightGlomerularFiltrationSurfaceArea (const RightGlomerularFiltrationSurfaceArea_optional& x);

          void
          RightGlomerularFiltrationSurfaceArea (::std::unique_ptr< RightGlomerularFiltrationSurfaceArea_type > p);



          typedef ::mil::tatrc::physiology::datamodel::ScalarVolumePerTimePressureAreaData RightGlomerularFluidPermeability_type;

          typedef ::xsd::cxx::tree::optional< RightGlomerularFluidPermeability_type > RightGlomerularFluidPermeability_optional;

          typedef ::xsd::cxx::tree::traits< RightGlomerularFluidPermeability_type, char > RightGlomerularFluidPermeability_traits;

          const RightGlomerularFluidPermeability_optional&
          RightGlomerularFluidPermeability () const;

          RightGlomerularFluidPermeability_optional&
          RightGlomerularFluidPermeability ();

          void
          RightGlomerularFluidPermeability (const RightGlomerularFluidPermeability_type& x);

          void
          RightGlomerularFluidPermeability (const RightGlomerularFluidPermeability_optional& x);

          void
          RightGlomerularFluidPermeability (::std::unique_ptr< RightGlomerularFluidPermeability_type > p);



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

          typedef ::xsd::cxx::tree::optional< RightFiltrationFraction_type > RightFiltrationFraction_optional;

          typedef ::xsd::cxx::tree::traits< RightFiltrationFraction_type, char > RightFiltrationFraction_traits;

          const RightFiltrationFraction_optional&
          RightFiltrationFraction () const;

          RightFiltrationFraction_optional&
          RightFiltrationFraction ();

          void
          RightFiltrationFraction (const RightFiltrationFraction_type& x);

          void
          RightFiltrationFraction (const RightFiltrationFraction_optional& x);

          void
          RightFiltrationFraction (::std::unique_ptr< RightFiltrationFraction_type > p);



          typedef ::mil::tatrc::physiology::datamodel::ScalarPressureData RightNetFiltrationPressure_type;

          typedef ::xsd::cxx::tree::optional< RightNetFiltrationPressure_type > RightNetFiltrationPressure_optional;

          typedef ::xsd::cxx::tree::traits< RightNetFiltrationPressure_type, char > RightNetFiltrationPressure_traits;

          const RightNetFiltrationPressure_optional&
          RightNetFiltrationPressure () const;

          RightNetFiltrationPressure_optional&
          RightNetFiltrationPressure ();

          void
          RightNetFiltrationPressure (const RightNetFiltrationPressure_type& x);

          void
          RightNetFiltrationPressure (const RightNetFiltrationPressure_optional& x);

          void
          RightNetFiltrationPressure (::std::unique_ptr< RightNetFiltrationPressure_type > p);



          typedef ::mil::tatrc::physiology::datamodel::ScalarPressureData RightNetReabsorptionPressure_type;

          typedef ::xsd::cxx::tree::optional< RightNetReabsorptionPressure_type > RightNetReabsorptionPressure_optional;

          typedef ::xsd::cxx::tree::traits< RightNetReabsorptionPressure_type, char > RightNetReabsorptionPressure_traits;

          const RightNetReabsorptionPressure_optional&
          RightNetReabsorptionPressure () const;

          RightNetReabsorptionPressure_optional&
          RightNetReabsorptionPressure ();

          void
          RightNetReabsorptionPressure (const RightNetReabsorptionPressure_type& x);

          void
          RightNetReabsorptionPressure (const RightNetReabsorptionPressure_optional& x);

          void
          RightNetReabsorptionPressure (::std::unique_ptr< RightNetReabsorptionPressure_type > p);



          typedef ::mil::tatrc::physiology::datamodel::ScalarPressureData RightPeritubularCapillariesHydrostaticPressure_type;

          typedef ::xsd::cxx::tree::optional< RightPeritubularCapillariesHydrostaticPressure_type > RightPeritubularCapillariesHydrostaticPressure_optional;

          typedef ::xsd::cxx::tree::traits< RightPeritubularCapillariesHydrostaticPressure_type, char > RightPeritubularCapillariesHydrostaticPressure_traits;

          const RightPeritubularCapillariesHydrostaticPressure_optional&
          RightPeritubularCapillariesHydrostaticPressure () const;

          RightPeritubularCapillariesHydrostaticPressure_optional&
          RightPeritubularCapillariesHydrostaticPressure ();

          void
          RightPeritubularCapillariesHydrostaticPressure (const RightPeritubularCapillariesHydrostaticPressure_type& x);

          void
          RightPeritubularCapillariesHydrostaticPressure (const RightPeritubularCapillariesHydrostaticPressure_optional& x);

          void
          RightPeritubularCapillariesHydrostaticPressure (::std::unique_ptr< RightPeritubularCapillariesHydrostaticPressure_type > p);



          typedef ::mil::tatrc::physiology::datamodel::ScalarPressureData RightPeritubularCapillariesOsmoticPressure_type;

          typedef ::xsd::cxx::tree::optional< RightPeritubularCapillariesOsmoticPressure_type > RightPeritubularCapillariesOsmoticPressure_optional;

          typedef ::xsd::cxx::tree::traits< RightPeritubularCapillariesOsmoticPressure_type, char > RightPeritubularCapillariesOsmoticPressure_traits;

          const RightPeritubularCapillariesOsmoticPressure_optional&
          RightPeritubularCapillariesOsmoticPressure () const;

          RightPeritubularCapillariesOsmoticPressure_optional&
          RightPeritubularCapillariesOsmoticPressure ();

          void
          RightPeritubularCapillariesOsmoticPressure (const RightPeritubularCapillariesOsmoticPressure_type& x);

          void
          RightPeritubularCapillariesOsmoticPressure (const RightPeritubularCapillariesOsmoticPressure_optional& x);

          void
          RightPeritubularCapillariesOsmoticPressure (::std::unique_ptr< RightPeritubularCapillariesOsmoticPressure_type > p);



          typedef ::mil::tatrc::physiology::datamodel::ScalarVolumePerTimePressureData RightReabsorptionFiltrationCoefficient_type;

          typedef ::xsd::cxx::tree::optional< RightReabsorptionFiltrationCoefficient_type > RightReabsorptionFiltrationCoefficient_optional;

          typedef ::xsd::cxx::tree::traits< RightReabsorptionFiltrationCoefficient_type, char > RightReabsorptionFiltrationCoefficient_traits;

          const RightReabsorptionFiltrationCoefficient_optional&
          RightReabsorptionFiltrationCoefficient () const;

          RightReabsorptionFiltrationCoefficient_optional&
          RightReabsorptionFiltrationCoefficient ();

          void
          RightReabsorptionFiltrationCoefficient (const RightReabsorptionFiltrationCoefficient_type& x);

          void
          RightReabsorptionFiltrationCoefficient (const RightReabsorptionFiltrationCoefficient_optional& x);

          void
          RightReabsorptionFiltrationCoefficient (::std::unique_ptr< RightReabsorptionFiltrationCoefficient_type > p);



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

          typedef ::xsd::cxx::tree::optional< RightReabsorptionRate_type > RightReabsorptionRate_optional;

          typedef ::xsd::cxx::tree::traits< RightReabsorptionRate_type, char > RightReabsorptionRate_traits;

          const RightReabsorptionRate_optional&
          RightReabsorptionRate () const;

          RightReabsorptionRate_optional&
          RightReabsorptionRate ();

          void
          RightReabsorptionRate (const RightReabsorptionRate_type& x);

          void
          RightReabsorptionRate (const RightReabsorptionRate_optional& x);

          void
          RightReabsorptionRate (::std::unique_ptr< RightReabsorptionRate_type > p);



          typedef ::mil::tatrc::physiology::datamodel::ScalarPressureData RightTubularOsmoticPressure_type;

          typedef ::xsd::cxx::tree::optional< RightTubularOsmoticPressure_type > RightTubularOsmoticPressure_optional;

          typedef ::xsd::cxx::tree::traits< RightTubularOsmoticPressure_type, char > RightTubularOsmoticPressure_traits;

          const RightTubularOsmoticPressure_optional&
          RightTubularOsmoticPressure () const;

          RightTubularOsmoticPressure_optional&
          RightTubularOsmoticPressure ();

          void
          RightTubularOsmoticPressure (const RightTubularOsmoticPressure_type& x);

          void
          RightTubularOsmoticPressure (const RightTubularOsmoticPressure_optional& x);

          void
          RightTubularOsmoticPressure (::std::unique_ptr< RightTubularOsmoticPressure_type > p);



          typedef ::mil::tatrc::physiology::datamodel::ScalarPressureData RightTubularHydrostaticPressure_type;

          typedef ::xsd::cxx::tree::optional< RightTubularHydrostaticPressure_type > RightTubularHydrostaticPressure_optional;

          typedef ::xsd::cxx::tree::traits< RightTubularHydrostaticPressure_type, char > RightTubularHydrostaticPressure_traits;

          const RightTubularHydrostaticPressure_optional&
          RightTubularHydrostaticPressure () const;

          RightTubularHydrostaticPressure_optional&
          RightTubularHydrostaticPressure ();

          void
          RightTubularHydrostaticPressure (const RightTubularHydrostaticPressure_type& x);

          void
          RightTubularHydrostaticPressure (const RightTubularHydrostaticPressure_optional& x);

          void
          RightTubularHydrostaticPressure (::std::unique_ptr< RightTubularHydrostaticPressure_type > p);



          typedef ::mil::tatrc::physiology::datamodel::ScalarAreaData RightTubularReabsorptionFiltrationSurfaceArea_type;

          typedef ::xsd::cxx::tree::optional< RightTubularReabsorptionFiltrationSurfaceArea_type > RightTubularReabsorptionFiltrationSurfaceArea_optional;

          typedef ::xsd::cxx::tree::traits< RightTubularReabsorptionFiltrationSurfaceArea_type, char > RightTubularReabsorptionFiltrationSurfaceArea_traits;

          const RightTubularReabsorptionFiltrationSurfaceArea_optional&
          RightTubularReabsorptionFiltrationSurfaceArea () const;

          RightTubularReabsorptionFiltrationSurfaceArea_optional&
          RightTubularReabsorptionFiltrationSurfaceArea ();

          void
          RightTubularReabsorptionFiltrationSurfaceArea (const RightTubularReabsorptionFiltrationSurfaceArea_type& x);

          void
          RightTubularReabsorptionFiltrationSurfaceArea (const RightTubularReabsorptionFiltrationSurfaceArea_optional& x);

          void
          RightTubularReabsorptionFiltrationSurfaceArea (::std::unique_ptr< RightTubularReabsorptionFiltrationSurfaceArea_type > p);



          typedef ::mil::tatrc::physiology::datamodel::ScalarVolumePerTimePressureAreaData RightTubularReabsorptionFluidPermeability_type;

          typedef ::xsd::cxx::tree::optional< RightTubularReabsorptionFluidPermeability_type > RightTubularReabsorptionFluidPermeability_optional;

          typedef ::xsd::cxx::tree::traits< RightTubularReabsorptionFluidPermeability_type, char > RightTubularReabsorptionFluidPermeability_traits;

          const RightTubularReabsorptionFluidPermeability_optional&
          RightTubularReabsorptionFluidPermeability () const;

          RightTubularReabsorptionFluidPermeability_optional&
          RightTubularReabsorptionFluidPermeability ();

          void
          RightTubularReabsorptionFluidPermeability (const RightTubularReabsorptionFluidPermeability_type& x);

          void
          RightTubularReabsorptionFluidPermeability (const RightTubularReabsorptionFluidPermeability_optional& x);

          void
          RightTubularReabsorptionFluidPermeability (::std::unique_ptr< RightTubularReabsorptionFluidPermeability_type > p);



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

          typedef ::xsd::cxx::tree::optional< UrinationRate_type > UrinationRate_optional;

          typedef ::xsd::cxx::tree::traits< UrinationRate_type, char > UrinationRate_traits;

          const UrinationRate_optional&
          UrinationRate () const;

          UrinationRate_optional&
          UrinationRate ();

          void
          UrinationRate (const UrinationRate_type& x);

          void
          UrinationRate (const UrinationRate_optional& x);

          void
          UrinationRate (::std::unique_ptr< UrinationRate_type > p);



          typedef ::mil::tatrc::physiology::datamodel::ScalarOsmolalityData UrineOsmolality_type;

          typedef ::xsd::cxx::tree::optional< UrineOsmolality_type > UrineOsmolality_optional;

          typedef ::xsd::cxx::tree::traits< UrineOsmolality_type, char > UrineOsmolality_traits;

          const UrineOsmolality_optional&
          UrineOsmolality () const;

          UrineOsmolality_optional&
          UrineOsmolality ();

          void
          UrineOsmolality (const UrineOsmolality_type& x);

          void
          UrineOsmolality (const UrineOsmolality_optional& x);

          void
          UrineOsmolality (::std::unique_ptr< UrineOsmolality_type > p);



          typedef ::mil::tatrc::physiology::datamodel::ScalarOsmolarityData UrineOsmolarity_type;

          typedef ::xsd::cxx::tree::optional< UrineOsmolarity_type > UrineOsmolarity_optional;

          typedef ::xsd::cxx::tree::traits< UrineOsmolarity_type, char > UrineOsmolarity_traits;

          const UrineOsmolarity_optional&
          UrineOsmolarity () const;

          UrineOsmolarity_optional&
          UrineOsmolarity ();

          void
          UrineOsmolarity (const UrineOsmolarity_type& x);

          void
          UrineOsmolarity (const UrineOsmolarity_optional& x);

          void
          UrineOsmolarity (::std::unique_ptr< UrineOsmolarity_type > p);



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

          typedef ::xsd::cxx::tree::optional< UrineProductionRate_type > UrineProductionRate_optional;

          typedef ::xsd::cxx::tree::traits< UrineProductionRate_type, char > UrineProductionRate_traits;

          const UrineProductionRate_optional&
          UrineProductionRate () const;

          UrineProductionRate_optional&
          UrineProductionRate ();

          void
          UrineProductionRate (const UrineProductionRate_type& x);

          void
          UrineProductionRate (const UrineProductionRate_optional& x);

          void
          UrineProductionRate (::std::unique_ptr< UrineProductionRate_type > p);



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

          typedef ::xsd::cxx::tree::optional< MeanUrineOutput_type > MeanUrineOutput_optional;

          typedef ::xsd::cxx::tree::traits< MeanUrineOutput_type, char > MeanUrineOutput_traits;

          const MeanUrineOutput_optional&
          MeanUrineOutput () const;

          MeanUrineOutput_optional&
          MeanUrineOutput ();

          void
          MeanUrineOutput (const MeanUrineOutput_type& x);

          void
          MeanUrineOutput (const MeanUrineOutput_optional& x);

          void
          MeanUrineOutput (::std::unique_ptr< MeanUrineOutput_type > p);



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

          typedef ::xsd::cxx::tree::optional< UrineSpecificGravity_type > UrineSpecificGravity_optional;

          typedef ::xsd::cxx::tree::traits< UrineSpecificGravity_type, char > UrineSpecificGravity_traits;

          const UrineSpecificGravity_optional&
          UrineSpecificGravity () const;

          UrineSpecificGravity_optional&
          UrineSpecificGravity ();

          void
          UrineSpecificGravity (const UrineSpecificGravity_type& x);

          void
          UrineSpecificGravity (const UrineSpecificGravity_optional& x);

          void
          UrineSpecificGravity (::std::unique_ptr< UrineSpecificGravity_type > p);



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

          typedef ::xsd::cxx::tree::optional< UrineVolume_type > UrineVolume_optional;

          typedef ::xsd::cxx::tree::traits< UrineVolume_type, char > UrineVolume_traits;

          const UrineVolume_optional&
          UrineVolume () const;

          UrineVolume_optional&
          UrineVolume ();

          void
          UrineVolume (const UrineVolume_type& x);

          void
          UrineVolume (const UrineVolume_optional& x);

          void
          UrineVolume (::std::unique_ptr< UrineVolume_type > p);



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

          typedef ::xsd::cxx::tree::optional< UrineUreaNitrogenConcentration_type > UrineUreaNitrogenConcentration_optional;

          typedef ::xsd::cxx::tree::traits< UrineUreaNitrogenConcentration_type, char > UrineUreaNitrogenConcentration_traits;

          const UrineUreaNitrogenConcentration_optional&
          UrineUreaNitrogenConcentration () const;

          UrineUreaNitrogenConcentration_optional&
          UrineUreaNitrogenConcentration ();

          void
          UrineUreaNitrogenConcentration (const UrineUreaNitrogenConcentration_type& x);

          void
          UrineUreaNitrogenConcentration (const UrineUreaNitrogenConcentration_optional& x);

          void
          UrineUreaNitrogenConcentration (::std::unique_ptr< UrineUreaNitrogenConcentration_type > p);



          RenalSystemData ();

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

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

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

          RenalSystemData&
          operator= (const RenalSystemData& x);


          virtual 
          ~RenalSystemData ();

          // Implementation.
          //

          //@cond

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

          protected:
          FiltrationFraction_optional FiltrationFraction_;
          GlomerularFiltrationRate_optional GlomerularFiltrationRate_;
          LeftAfferentArterioleResistance_optional LeftAfferentArterioleResistance_;
          LeftBowmansCapsulesHydrostaticPressure_optional LeftBowmansCapsulesHydrostaticPressure_;
          LeftBowmansCapsulesOsmoticPressure_optional LeftBowmansCapsulesOsmoticPressure_;
          LeftEfferentArterioleResistance_optional LeftEfferentArterioleResistance_;
          LeftGlomerularCapillariesHydrostaticPressure_optional LeftGlomerularCapillariesHydrostaticPressure_;
          LeftGlomerularCapillariesOsmoticPressure_optional LeftGlomerularCapillariesOsmoticPressure_;
          LeftGlomerularFiltrationCoefficient_optional LeftGlomerularFiltrationCoefficient_;
          LeftGlomerularFiltrationRate_optional LeftGlomerularFiltrationRate_;
          LeftGlomerularFiltrationSurfaceArea_optional LeftGlomerularFiltrationSurfaceArea_;
          LeftGlomerularFluidPermeability_optional LeftGlomerularFluidPermeability_;
          LeftFiltrationFraction_optional LeftFiltrationFraction_;
          LeftNetFiltrationPressure_optional LeftNetFiltrationPressure_;
          LeftNetReabsorptionPressure_optional LeftNetReabsorptionPressure_;
          LeftPeritubularCapillariesHydrostaticPressure_optional LeftPeritubularCapillariesHydrostaticPressure_;
          LeftPeritubularCapillariesOsmoticPressure_optional LeftPeritubularCapillariesOsmoticPressure_;
          LeftReabsorptionFiltrationCoefficient_optional LeftReabsorptionFiltrationCoefficient_;
          LeftReabsorptionRate_optional LeftReabsorptionRate_;
          LeftTubularOsmoticPressure_optional LeftTubularOsmoticPressure_;
          LeftTubularHydrostaticPressure_optional LeftTubularHydrostaticPressure_;
          LeftTubularReabsorptionFiltrationSurfaceArea_optional LeftTubularReabsorptionFiltrationSurfaceArea_;
          LeftTubularReabsorptionFluidPermeability_optional LeftTubularReabsorptionFluidPermeability_;
          RenalBloodFlow_optional RenalBloodFlow_;
          RenalPlasmaFlow_optional RenalPlasmaFlow_;
          RenalVascularResistance_optional RenalVascularResistance_;
          RightAfferentArterioleResistance_optional RightAfferentArterioleResistance_;
          RightBowmansCapsulesHydrostaticPressure_optional RightBowmansCapsulesHydrostaticPressure_;
          RightBowmansCapsulesOsmoticPressure_optional RightBowmansCapsulesOsmoticPressure_;
          RightEfferentArterioleResistance_optional RightEfferentArterioleResistance_;
          RightGlomerularCapillariesHydrostaticPressure_optional RightGlomerularCapillariesHydrostaticPressure_;
          RightGlomerularCapillariesOsmoticPressure_optional RightGlomerularCapillariesOsmoticPressure_;
          RightGlomerularFiltrationCoefficient_optional RightGlomerularFiltrationCoefficient_;
          RightGlomerularFiltrationRate_optional RightGlomerularFiltrationRate_;
          RightGlomerularFiltrationSurfaceArea_optional RightGlomerularFiltrationSurfaceArea_;
          RightGlomerularFluidPermeability_optional RightGlomerularFluidPermeability_;
          RightFiltrationFraction_optional RightFiltrationFraction_;
          RightNetFiltrationPressure_optional RightNetFiltrationPressure_;
          RightNetReabsorptionPressure_optional RightNetReabsorptionPressure_;
          RightPeritubularCapillariesHydrostaticPressure_optional RightPeritubularCapillariesHydrostaticPressure_;
          RightPeritubularCapillariesOsmoticPressure_optional RightPeritubularCapillariesOsmoticPressure_;
          RightReabsorptionFiltrationCoefficient_optional RightReabsorptionFiltrationCoefficient_;
          RightReabsorptionRate_optional RightReabsorptionRate_;
          RightTubularOsmoticPressure_optional RightTubularOsmoticPressure_;
          RightTubularHydrostaticPressure_optional RightTubularHydrostaticPressure_;
          RightTubularReabsorptionFiltrationSurfaceArea_optional RightTubularReabsorptionFiltrationSurfaceArea_;
          RightTubularReabsorptionFluidPermeability_optional RightTubularReabsorptionFluidPermeability_;
          UrinationRate_optional UrinationRate_;
          UrineOsmolality_optional UrineOsmolality_;
          UrineOsmolarity_optional UrineOsmolarity_;
          UrineProductionRate_optional UrineProductionRate_;
          MeanUrineOutput_optional MeanUrineOutput_;
          UrineSpecificGravity_optional UrineSpecificGravity_;
          UrineVolume_optional UrineVolume_;
          UrineUreaNitrogenConcentration_optional UrineUreaNitrogenConcentration_;

          //@endcond
        };

        class BIOGEARS_CDM_API RespiratorySystemData: public ::mil::tatrc::physiology::datamodel::SystemData
        {
          public:

          typedef ::mil::tatrc::physiology::datamodel::ScalarPressureData AlveolarArterialGradient_type;

          typedef ::xsd::cxx::tree::optional< AlveolarArterialGradient_type > AlveolarArterialGradient_optional;

          typedef ::xsd::cxx::tree::traits< AlveolarArterialGradient_type, char > AlveolarArterialGradient_traits;

          const AlveolarArterialGradient_optional&
          AlveolarArterialGradient () const;

          AlveolarArterialGradient_optional&
          AlveolarArterialGradient ();

          void
          AlveolarArterialGradient (const AlveolarArterialGradient_type& x);

          void
          AlveolarArterialGradient (const AlveolarArterialGradient_optional& x);

          void
          AlveolarArterialGradient (::std::unique_ptr< AlveolarArterialGradient_type > p);



          typedef ::mil::tatrc::physiology::datamodel::ScalarPressureData CarricoIndex_type;

          typedef ::xsd::cxx::tree::optional< CarricoIndex_type > CarricoIndex_optional;

          typedef ::xsd::cxx::tree::traits< CarricoIndex_type, char > CarricoIndex_traits;

          const CarricoIndex_optional&
          CarricoIndex () const;

          CarricoIndex_optional&
          CarricoIndex ();

          void
          CarricoIndex (const CarricoIndex_type& x);

          void
          CarricoIndex (const CarricoIndex_optional& x);

          void
          CarricoIndex (::std::unique_ptr< CarricoIndex_type > p);



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

          typedef ::xsd::cxx::tree::optional< EndTidalCarbonDioxideFraction_type > EndTidalCarbonDioxideFraction_optional;

          typedef ::xsd::cxx::tree::traits< EndTidalCarbonDioxideFraction_type, char > EndTidalCarbonDioxideFraction_traits;

          const EndTidalCarbonDioxideFraction_optional&
          EndTidalCarbonDioxideFraction () const;

          EndTidalCarbonDioxideFraction_optional&
          EndTidalCarbonDioxideFraction ();

          void
          EndTidalCarbonDioxideFraction (const EndTidalCarbonDioxideFraction_type& x);

          void
          EndTidalCarbonDioxideFraction (const EndTidalCarbonDioxideFraction_optional& x);

          void
          EndTidalCarbonDioxideFraction (::std::unique_ptr< EndTidalCarbonDioxideFraction_type > p);



          typedef ::mil::tatrc::physiology::datamodel::ScalarPressureData EndTidalCarbonDioxidePressure_type;

          typedef ::xsd::cxx::tree::optional< EndTidalCarbonDioxidePressure_type > EndTidalCarbonDioxidePressure_optional;

          typedef ::xsd::cxx::tree::traits< EndTidalCarbonDioxidePressure_type, char > EndTidalCarbonDioxidePressure_traits;

          const EndTidalCarbonDioxidePressure_optional&
          EndTidalCarbonDioxidePressure () const;

          EndTidalCarbonDioxidePressure_optional&
          EndTidalCarbonDioxidePressure ();

          void
          EndTidalCarbonDioxidePressure (const EndTidalCarbonDioxidePressure_type& x);

          void
          EndTidalCarbonDioxidePressure (const EndTidalCarbonDioxidePressure_optional& x);

          void
          EndTidalCarbonDioxidePressure (::std::unique_ptr< EndTidalCarbonDioxidePressure_type > p);



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

          typedef ::xsd::cxx::tree::optional< ExpiratoryFlow_type > ExpiratoryFlow_optional;

          typedef ::xsd::cxx::tree::traits< ExpiratoryFlow_type, char > ExpiratoryFlow_traits;

          const ExpiratoryFlow_optional&
          ExpiratoryFlow () const;

          ExpiratoryFlow_optional&
          ExpiratoryFlow ();

          void
          ExpiratoryFlow (const ExpiratoryFlow_type& x);

          void
          ExpiratoryFlow (const ExpiratoryFlow_optional& x);

          void
          ExpiratoryFlow (::std::unique_ptr< ExpiratoryFlow_type > p);



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

          typedef ::xsd::cxx::tree::optional< InspiratoryExpiratoryRatio_type > InspiratoryExpiratoryRatio_optional;

          typedef ::xsd::cxx::tree::traits< InspiratoryExpiratoryRatio_type, char > InspiratoryExpiratoryRatio_traits;

          const InspiratoryExpiratoryRatio_optional&
          InspiratoryExpiratoryRatio () const;

          InspiratoryExpiratoryRatio_optional&
          InspiratoryExpiratoryRatio ();

          void
          InspiratoryExpiratoryRatio (const InspiratoryExpiratoryRatio_type& x);

          void
          InspiratoryExpiratoryRatio (const InspiratoryExpiratoryRatio_optional& x);

          void
          InspiratoryExpiratoryRatio (::std::unique_ptr< InspiratoryExpiratoryRatio_type > p);



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

          typedef ::xsd::cxx::tree::optional< InspiratoryFlow_type > InspiratoryFlow_optional;

          typedef ::xsd::cxx::tree::traits< InspiratoryFlow_type, char > InspiratoryFlow_traits;

          const InspiratoryFlow_optional&
          InspiratoryFlow () const;

          InspiratoryFlow_optional&
          InspiratoryFlow ();

          void
          InspiratoryFlow (const InspiratoryFlow_type& x);

          void
          InspiratoryFlow (const InspiratoryFlow_optional& x);

          void
          InspiratoryFlow (::std::unique_ptr< InspiratoryFlow_type > p);



          typedef ::mil::tatrc::physiology::datamodel::ScalarPressureData MeanPleuralPressure_type;

          typedef ::xsd::cxx::tree::optional< MeanPleuralPressure_type > MeanPleuralPressure_optional;

          typedef ::xsd::cxx::tree::traits< MeanPleuralPressure_type, char > MeanPleuralPressure_traits;

          const MeanPleuralPressure_optional&
          MeanPleuralPressure () const;

          MeanPleuralPressure_optional&
          MeanPleuralPressure ();

          void
          MeanPleuralPressure (const MeanPleuralPressure_type& x);

          void
          MeanPleuralPressure (const MeanPleuralPressure_optional& x);

          void
          MeanPleuralPressure (::std::unique_ptr< MeanPleuralPressure_type > p);



          typedef ::mil::tatrc::physiology::datamodel::ScalarFlowComplianceData PulmonaryCompliance_type;

          typedef ::xsd::cxx::tree::optional< PulmonaryCompliance_type > PulmonaryCompliance_optional;

          typedef ::xsd::cxx::tree::traits< PulmonaryCompliance_type, char > PulmonaryCompliance_traits;

          const PulmonaryCompliance_optional&
          PulmonaryCompliance () const;

          PulmonaryCompliance_optional&
          PulmonaryCompliance ();

          void
          PulmonaryCompliance (const PulmonaryCompliance_type& x);

          void
          PulmonaryCompliance (const PulmonaryCompliance_optional& x);

          void
          PulmonaryCompliance (::std::unique_ptr< PulmonaryCompliance_type > p);



          typedef ::mil::tatrc::physiology::datamodel::ScalarFlowResistanceData PulmonaryResistance_type;

          typedef ::xsd::cxx::tree::optional< PulmonaryResistance_type > PulmonaryResistance_optional;

          typedef ::xsd::cxx::tree::traits< PulmonaryResistance_type, char > PulmonaryResistance_traits;

          const PulmonaryResistance_optional&
          PulmonaryResistance () const;

          PulmonaryResistance_optional&
          PulmonaryResistance ();

          void
          PulmonaryResistance (const PulmonaryResistance_type& x);

          void
          PulmonaryResistance (const PulmonaryResistance_optional& x);

          void
          PulmonaryResistance (::std::unique_ptr< PulmonaryResistance_type > p);



          typedef ::mil::tatrc::physiology::datamodel::ScalarFrequencyData RespirationDriverFrequency_type;

          typedef ::xsd::cxx::tree::optional< RespirationDriverFrequency_type > RespirationDriverFrequency_optional;

          typedef ::xsd::cxx::tree::traits< RespirationDriverFrequency_type, char > RespirationDriverFrequency_traits;

          const RespirationDriverFrequency_optional&
          RespirationDriverFrequency () const;

          RespirationDriverFrequency_optional&
          RespirationDriverFrequency ();

          void
          RespirationDriverFrequency (const RespirationDriverFrequency_type& x);

          void
          RespirationDriverFrequency (const RespirationDriverFrequency_optional& x);

          void
          RespirationDriverFrequency (::std::unique_ptr< RespirationDriverFrequency_type > p);



          typedef ::mil::tatrc::physiology::datamodel::ScalarPressureData RespirationDriverPressure_type;

          typedef ::xsd::cxx::tree::optional< RespirationDriverPressure_type > RespirationDriverPressure_optional;

          typedef ::xsd::cxx::tree::traits< RespirationDriverPressure_type, char > RespirationDriverPressure_traits;

          const RespirationDriverPressure_optional&
          RespirationDriverPressure () const;

          RespirationDriverPressure_optional&
          RespirationDriverPressure ();

          void
          RespirationDriverPressure (const RespirationDriverPressure_type& x);

          void
          RespirationDriverPressure (const RespirationDriverPressure_optional& x);

          void
          RespirationDriverPressure (::std::unique_ptr< RespirationDriverPressure_type > p);



          typedef ::mil::tatrc::physiology::datamodel::ScalarPressureData RespirationMusclePressure_type;

          typedef ::xsd::cxx::tree::optional< RespirationMusclePressure_type > RespirationMusclePressure_optional;

          typedef ::xsd::cxx::tree::traits< RespirationMusclePressure_type, char > RespirationMusclePressure_traits;

          const RespirationMusclePressure_optional&
          RespirationMusclePressure () const;

          RespirationMusclePressure_optional&
          RespirationMusclePressure ();

          void
          RespirationMusclePressure (const RespirationMusclePressure_type& x);

          void
          RespirationMusclePressure (const RespirationMusclePressure_optional& x);

          void
          RespirationMusclePressure (::std::unique_ptr< RespirationMusclePressure_type > p);



          typedef ::mil::tatrc::physiology::datamodel::ScalarFrequencyData RespirationRate_type;

          typedef ::xsd::cxx::tree::optional< RespirationRate_type > RespirationRate_optional;

          typedef ::xsd::cxx::tree::traits< RespirationRate_type, char > RespirationRate_traits;

          const RespirationRate_optional&
          RespirationRate () const;

          RespirationRate_optional&
          RespirationRate ();

          void
          RespirationRate (const RespirationRate_type& x);

          void
          RespirationRate (const RespirationRate_optional& x);

          void
          RespirationRate (::std::unique_ptr< RespirationRate_type > p);



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

          typedef ::xsd::cxx::tree::optional< SpecificVentilation_type > SpecificVentilation_optional;

          typedef ::xsd::cxx::tree::traits< SpecificVentilation_type, char > SpecificVentilation_traits;

          const SpecificVentilation_optional&
          SpecificVentilation () const;

          SpecificVentilation_optional&
          SpecificVentilation ();

          void
          SpecificVentilation (const SpecificVentilation_type& x);

          void
          SpecificVentilation (const SpecificVentilation_optional& x);

          void
          SpecificVentilation (::std::unique_ptr< SpecificVentilation_type > p);



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

          typedef ::xsd::cxx::tree::optional< TidalVolume_type > TidalVolume_optional;

          typedef ::xsd::cxx::tree::traits< TidalVolume_type, char > TidalVolume_traits;

          const TidalVolume_optional&
          TidalVolume () const;

          TidalVolume_optional&
          TidalVolume ();

          void
          TidalVolume (const TidalVolume_type& x);

          void
          TidalVolume (const TidalVolume_optional& x);

          void
          TidalVolume (::std::unique_ptr< TidalVolume_type > p);



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

          typedef ::xsd::cxx::tree::optional< TargetPulmonaryVentilation_type > TargetPulmonaryVentilation_optional;

          typedef ::xsd::cxx::tree::traits< TargetPulmonaryVentilation_type, char > TargetPulmonaryVentilation_traits;

          const TargetPulmonaryVentilation_optional&
          TargetPulmonaryVentilation () const;

          TargetPulmonaryVentilation_optional&
          TargetPulmonaryVentilation ();

          void
          TargetPulmonaryVentilation (const TargetPulmonaryVentilation_type& x);

          void
          TargetPulmonaryVentilation (const TargetPulmonaryVentilation_optional& x);

          void
          TargetPulmonaryVentilation (::std::unique_ptr< TargetPulmonaryVentilation_type > p);



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

          typedef ::xsd::cxx::tree::optional< TotalAlveolarVentilation_type > TotalAlveolarVentilation_optional;

          typedef ::xsd::cxx::tree::traits< TotalAlveolarVentilation_type, char > TotalAlveolarVentilation_traits;

          const TotalAlveolarVentilation_optional&
          TotalAlveolarVentilation () const;

          TotalAlveolarVentilation_optional&
          TotalAlveolarVentilation ();

          void
          TotalAlveolarVentilation (const TotalAlveolarVentilation_type& x);

          void
          TotalAlveolarVentilation (const TotalAlveolarVentilation_optional& x);

          void
          TotalAlveolarVentilation (::std::unique_ptr< TotalAlveolarVentilation_type > p);



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

          typedef ::xsd::cxx::tree::optional< TotalDeadSpaceVentilation_type > TotalDeadSpaceVentilation_optional;

          typedef ::xsd::cxx::tree::traits< TotalDeadSpaceVentilation_type, char > TotalDeadSpaceVentilation_traits;

          const TotalDeadSpaceVentilation_optional&
          TotalDeadSpaceVentilation () const;

          TotalDeadSpaceVentilation_optional&
          TotalDeadSpaceVentilation ();

          void
          TotalDeadSpaceVentilation (const TotalDeadSpaceVentilation_type& x);

          void
          TotalDeadSpaceVentilation (const TotalDeadSpaceVentilation_optional& x);

          void
          TotalDeadSpaceVentilation (::std::unique_ptr< TotalDeadSpaceVentilation_type > p);



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

          typedef ::xsd::cxx::tree::optional< TotalLungVolume_type > TotalLungVolume_optional;

          typedef ::xsd::cxx::tree::traits< TotalLungVolume_type, char > TotalLungVolume_traits;

          const TotalLungVolume_optional&
          TotalLungVolume () const;

          TotalLungVolume_optional&
          TotalLungVolume ();

          void
          TotalLungVolume (const TotalLungVolume_type& x);

          void
          TotalLungVolume (const TotalLungVolume_optional& x);

          void
          TotalLungVolume (::std::unique_ptr< TotalLungVolume_type > p);



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

          typedef ::xsd::cxx::tree::optional< TotalPulmonaryVentilation_type > TotalPulmonaryVentilation_optional;

          typedef ::xsd::cxx::tree::traits< TotalPulmonaryVentilation_type, char > TotalPulmonaryVentilation_traits;

          const TotalPulmonaryVentilation_optional&
          TotalPulmonaryVentilation () const;

          TotalPulmonaryVentilation_optional&
          TotalPulmonaryVentilation ();

          void
          TotalPulmonaryVentilation (const TotalPulmonaryVentilation_type& x);

          void
          TotalPulmonaryVentilation (const TotalPulmonaryVentilation_optional& x);

          void
          TotalPulmonaryVentilation (::std::unique_ptr< TotalPulmonaryVentilation_type > p);



          typedef ::mil::tatrc::physiology::datamodel::ScalarPressureData TranspulmonaryPressure_type;

          typedef ::xsd::cxx::tree::optional< TranspulmonaryPressure_type > TranspulmonaryPressure_optional;

          typedef ::xsd::cxx::tree::traits< TranspulmonaryPressure_type, char > TranspulmonaryPressure_traits;

          const TranspulmonaryPressure_optional&
          TranspulmonaryPressure () const;

          TranspulmonaryPressure_optional&
          TranspulmonaryPressure ();

          void
          TranspulmonaryPressure (const TranspulmonaryPressure_type& x);

          void
          TranspulmonaryPressure (const TranspulmonaryPressure_optional& x);

          void
          TranspulmonaryPressure (::std::unique_ptr< TranspulmonaryPressure_type > p);



          RespiratorySystemData ();

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

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

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

          RespiratorySystemData&
          operator= (const RespiratorySystemData& x);


          virtual 
          ~RespiratorySystemData ();

          // Implementation.
          //

          //@cond

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

          protected:
          AlveolarArterialGradient_optional AlveolarArterialGradient_;
          CarricoIndex_optional CarricoIndex_;
          EndTidalCarbonDioxideFraction_optional EndTidalCarbonDioxideFraction_;
          EndTidalCarbonDioxidePressure_optional EndTidalCarbonDioxidePressure_;
          ExpiratoryFlow_optional ExpiratoryFlow_;
          InspiratoryExpiratoryRatio_optional InspiratoryExpiratoryRatio_;
          InspiratoryFlow_optional InspiratoryFlow_;
          MeanPleuralPressure_optional MeanPleuralPressure_;
          PulmonaryCompliance_optional PulmonaryCompliance_;
          PulmonaryResistance_optional PulmonaryResistance_;
          RespirationDriverFrequency_optional RespirationDriverFrequency_;
          RespirationDriverPressure_optional RespirationDriverPressure_;
          RespirationMusclePressure_optional RespirationMusclePressure_;
          RespirationRate_optional RespirationRate_;
          SpecificVentilation_optional SpecificVentilation_;
          TidalVolume_optional TidalVolume_;
          TargetPulmonaryVentilation_optional TargetPulmonaryVentilation_;
          TotalAlveolarVentilation_optional TotalAlveolarVentilation_;
          TotalDeadSpaceVentilation_optional TotalDeadSpaceVentilation_;
          TotalLungVolume_optional TotalLungVolume_;
          TotalPulmonaryVentilation_optional TotalPulmonaryVentilation_;
          TranspulmonaryPressure_optional TranspulmonaryPressure_;

          //@endcond
        };

        class BIOGEARS_CDM_API TissueSystemData: public ::mil::tatrc::physiology::datamodel::SystemData
        {
          public:

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

          typedef ::xsd::cxx::tree::optional< CarbonDioxideProductionRate_type > CarbonDioxideProductionRate_optional;

          typedef ::xsd::cxx::tree::traits< CarbonDioxideProductionRate_type, char > CarbonDioxideProductionRate_traits;

          const CarbonDioxideProductionRate_optional&
          CarbonDioxideProductionRate () const;

          CarbonDioxideProductionRate_optional&
          CarbonDioxideProductionRate ();

          void
          CarbonDioxideProductionRate (const CarbonDioxideProductionRate_type& x);

          void
          CarbonDioxideProductionRate (const CarbonDioxideProductionRate_optional& x);

          void
          CarbonDioxideProductionRate (::std::unique_ptr< CarbonDioxideProductionRate_type > p);



          typedef ::mil::tatrc::physiology::datamodel::Scalar0To1Data DehydrationFraction_type;

          typedef ::xsd::cxx::tree::optional< DehydrationFraction_type > DehydrationFraction_optional;

          typedef ::xsd::cxx::tree::traits< DehydrationFraction_type, char > DehydrationFraction_traits;

          const DehydrationFraction_optional&
          DehydrationFraction () const;

          DehydrationFraction_optional&
          DehydrationFraction ();

          void
          DehydrationFraction (const DehydrationFraction_type& x);

          void
          DehydrationFraction (const DehydrationFraction_optional& x);

          void
          DehydrationFraction (::std::unique_ptr< DehydrationFraction_type > p);



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

          typedef ::xsd::cxx::tree::optional< ExtracellularFluidVolume_type > ExtracellularFluidVolume_optional;

          typedef ::xsd::cxx::tree::traits< ExtracellularFluidVolume_type, char > ExtracellularFluidVolume_traits;

          const ExtracellularFluidVolume_optional&
          ExtracellularFluidVolume () const;

          ExtracellularFluidVolume_optional&
          ExtracellularFluidVolume ();

          void
          ExtracellularFluidVolume (const ExtracellularFluidVolume_type& x);

          void
          ExtracellularFluidVolume (const ExtracellularFluidVolume_optional& x);

          void
          ExtracellularFluidVolume (::std::unique_ptr< ExtracellularFluidVolume_type > p);



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

          typedef ::xsd::cxx::tree::optional< ExtravascularFluidVolume_type > ExtravascularFluidVolume_optional;

          typedef ::xsd::cxx::tree::traits< ExtravascularFluidVolume_type, char > ExtravascularFluidVolume_traits;

          const ExtravascularFluidVolume_optional&
          ExtravascularFluidVolume () const;

          ExtravascularFluidVolume_optional&
          ExtravascularFluidVolume ();

          void
          ExtravascularFluidVolume (const ExtravascularFluidVolume_type& x);

          void
          ExtravascularFluidVolume (const ExtravascularFluidVolume_optional& x);

          void
          ExtravascularFluidVolume (::std::unique_ptr< ExtravascularFluidVolume_type > p);



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

          typedef ::xsd::cxx::tree::optional< IntracellularFluidPH_type > IntracellularFluidPH_optional;

          typedef ::xsd::cxx::tree::traits< IntracellularFluidPH_type, char > IntracellularFluidPH_traits;

          const IntracellularFluidPH_optional&
          IntracellularFluidPH () const;

          IntracellularFluidPH_optional&
          IntracellularFluidPH ();

          void
          IntracellularFluidPH (const IntracellularFluidPH_type& x);

          void
          IntracellularFluidPH (const IntracellularFluidPH_optional& x);

          void
          IntracellularFluidPH (::std::unique_ptr< IntracellularFluidPH_type > p);



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

          typedef ::xsd::cxx::tree::optional< IntracellularFluidVolume_type > IntracellularFluidVolume_optional;

          typedef ::xsd::cxx::tree::traits< IntracellularFluidVolume_type, char > IntracellularFluidVolume_traits;

          const IntracellularFluidVolume_optional&
          IntracellularFluidVolume () const;

          IntracellularFluidVolume_optional&
          IntracellularFluidVolume ();

          void
          IntracellularFluidVolume (const IntracellularFluidVolume_type& x);

          void
          IntracellularFluidVolume (const IntracellularFluidVolume_optional& x);

          void
          IntracellularFluidVolume (::std::unique_ptr< IntracellularFluidVolume_type > p);



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

          typedef ::xsd::cxx::tree::optional< TotalBodyFluidVolume_type > TotalBodyFluidVolume_optional;

          typedef ::xsd::cxx::tree::traits< TotalBodyFluidVolume_type, char > TotalBodyFluidVolume_traits;

          const TotalBodyFluidVolume_optional&
          TotalBodyFluidVolume () const;

          TotalBodyFluidVolume_optional&
          TotalBodyFluidVolume ();

          void
          TotalBodyFluidVolume (const TotalBodyFluidVolume_type& x);

          void
          TotalBodyFluidVolume (const TotalBodyFluidVolume_optional& x);

          void
          TotalBodyFluidVolume (::std::unique_ptr< TotalBodyFluidVolume_type > p);



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

          typedef ::xsd::cxx::tree::optional< OxygenConsumptionRate_type > OxygenConsumptionRate_optional;

          typedef ::xsd::cxx::tree::traits< OxygenConsumptionRate_type, char > OxygenConsumptionRate_traits;

          const OxygenConsumptionRate_optional&
          OxygenConsumptionRate () const;

          OxygenConsumptionRate_optional&
          OxygenConsumptionRate ();

          void
          OxygenConsumptionRate (const OxygenConsumptionRate_type& x);

          void
          OxygenConsumptionRate (const OxygenConsumptionRate_optional& x);

          void
          OxygenConsumptionRate (::std::unique_ptr< OxygenConsumptionRate_type > p);



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

          typedef ::xsd::cxx::tree::optional< RespiratoryExchangeRatio_type > RespiratoryExchangeRatio_optional;

          typedef ::xsd::cxx::tree::traits< RespiratoryExchangeRatio_type, char > RespiratoryExchangeRatio_traits;

          const RespiratoryExchangeRatio_optional&
          RespiratoryExchangeRatio () const;

          RespiratoryExchangeRatio_optional&
          RespiratoryExchangeRatio ();

          void
          RespiratoryExchangeRatio (const RespiratoryExchangeRatio_type& x);

          void
          RespiratoryExchangeRatio (const RespiratoryExchangeRatio_optional& x);

          void
          RespiratoryExchangeRatio (::std::unique_ptr< RespiratoryExchangeRatio_type > p);



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

          typedef ::xsd::cxx::tree::optional< LiverInsulinSetPoint_type > LiverInsulinSetPoint_optional;

          typedef ::xsd::cxx::tree::traits< LiverInsulinSetPoint_type, char > LiverInsulinSetPoint_traits;

          const LiverInsulinSetPoint_optional&
          LiverInsulinSetPoint () const;

          LiverInsulinSetPoint_optional&
          LiverInsulinSetPoint ();

          void
          LiverInsulinSetPoint (const LiverInsulinSetPoint_type& x);

          void
          LiverInsulinSetPoint (const LiverInsulinSetPoint_optional& x);

          void
          LiverInsulinSetPoint (::std::unique_ptr< LiverInsulinSetPoint_type > p);



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

          typedef ::xsd::cxx::tree::optional< LiverGlucagonSetPoint_type > LiverGlucagonSetPoint_optional;

          typedef ::xsd::cxx::tree::traits< LiverGlucagonSetPoint_type, char > LiverGlucagonSetPoint_traits;

          const LiverGlucagonSetPoint_optional&
          LiverGlucagonSetPoint () const;

          LiverGlucagonSetPoint_optional&
          LiverGlucagonSetPoint ();

          void
          LiverGlucagonSetPoint (const LiverGlucagonSetPoint_type& x);

          void
          LiverGlucagonSetPoint (const LiverGlucagonSetPoint_optional& x);

          void
          LiverGlucagonSetPoint (::std::unique_ptr< LiverGlucagonSetPoint_type > p);



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

          typedef ::xsd::cxx::tree::optional< MuscleInsulinSetPoint_type > MuscleInsulinSetPoint_optional;

          typedef ::xsd::cxx::tree::traits< MuscleInsulinSetPoint_type, char > MuscleInsulinSetPoint_traits;

          const MuscleInsulinSetPoint_optional&
          MuscleInsulinSetPoint () const;

          MuscleInsulinSetPoint_optional&
          MuscleInsulinSetPoint ();

          void
          MuscleInsulinSetPoint (const MuscleInsulinSetPoint_type& x);

          void
          MuscleInsulinSetPoint (const MuscleInsulinSetPoint_optional& x);

          void
          MuscleInsulinSetPoint (::std::unique_ptr< MuscleInsulinSetPoint_type > p);



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

          typedef ::xsd::cxx::tree::optional< MuscleGlucagonSetPoint_type > MuscleGlucagonSetPoint_optional;

          typedef ::xsd::cxx::tree::traits< MuscleGlucagonSetPoint_type, char > MuscleGlucagonSetPoint_traits;

          const MuscleGlucagonSetPoint_optional&
          MuscleGlucagonSetPoint () const;

          MuscleGlucagonSetPoint_optional&
          MuscleGlucagonSetPoint ();

          void
          MuscleGlucagonSetPoint (const MuscleGlucagonSetPoint_type& x);

          void
          MuscleGlucagonSetPoint (const MuscleGlucagonSetPoint_optional& x);

          void
          MuscleGlucagonSetPoint (::std::unique_ptr< MuscleGlucagonSetPoint_type > p);



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

          typedef ::xsd::cxx::tree::optional< FatInsulinSetPoint_type > FatInsulinSetPoint_optional;

          typedef ::xsd::cxx::tree::traits< FatInsulinSetPoint_type, char > FatInsulinSetPoint_traits;

          const FatInsulinSetPoint_optional&
          FatInsulinSetPoint () const;

          FatInsulinSetPoint_optional&
          FatInsulinSetPoint ();

          void
          FatInsulinSetPoint (const FatInsulinSetPoint_type& x);

          void
          FatInsulinSetPoint (const FatInsulinSetPoint_optional& x);

          void
          FatInsulinSetPoint (::std::unique_ptr< FatInsulinSetPoint_type > p);



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

          typedef ::xsd::cxx::tree::optional< FatGlucagonSetPoint_type > FatGlucagonSetPoint_optional;

          typedef ::xsd::cxx::tree::traits< FatGlucagonSetPoint_type, char > FatGlucagonSetPoint_traits;

          const FatGlucagonSetPoint_optional&
          FatGlucagonSetPoint () const;

          FatGlucagonSetPoint_optional&
          FatGlucagonSetPoint ();

          void
          FatGlucagonSetPoint (const FatGlucagonSetPoint_type& x);

          void
          FatGlucagonSetPoint (const FatGlucagonSetPoint_optional& x);

          void
          FatGlucagonSetPoint (::std::unique_ptr< FatGlucagonSetPoint_type > p);



          typedef ::mil::tatrc::physiology::datamodel::ScalarMassData LiverGlycogen_type;

          typedef ::xsd::cxx::tree::optional< LiverGlycogen_type > LiverGlycogen_optional;

          typedef ::xsd::cxx::tree::traits< LiverGlycogen_type, char > LiverGlycogen_traits;

          const LiverGlycogen_optional&
          LiverGlycogen () const;

          LiverGlycogen_optional&
          LiverGlycogen ();

          void
          LiverGlycogen (const LiverGlycogen_type& x);

          void
          LiverGlycogen (const LiverGlycogen_optional& x);

          void
          LiverGlycogen (::std::unique_ptr< LiverGlycogen_type > p);



          typedef ::mil::tatrc::physiology::datamodel::ScalarMassData MuscleGlycogen_type;

          typedef ::xsd::cxx::tree::optional< MuscleGlycogen_type > MuscleGlycogen_optional;

          typedef ::xsd::cxx::tree::traits< MuscleGlycogen_type, char > MuscleGlycogen_traits;

          const MuscleGlycogen_optional&
          MuscleGlycogen () const;

          MuscleGlycogen_optional&
          MuscleGlycogen ();

          void
          MuscleGlycogen (const MuscleGlycogen_type& x);

          void
          MuscleGlycogen (const MuscleGlycogen_optional& x);

          void
          MuscleGlycogen (::std::unique_ptr< MuscleGlycogen_type > p);



          typedef ::mil::tatrc::physiology::datamodel::ScalarMassData StoredProtein_type;

          typedef ::xsd::cxx::tree::optional< StoredProtein_type > StoredProtein_optional;

          typedef ::xsd::cxx::tree::traits< StoredProtein_type, char > StoredProtein_traits;

          const StoredProtein_optional&
          StoredProtein () const;

          StoredProtein_optional&
          StoredProtein ();

          void
          StoredProtein (const StoredProtein_type& x);

          void
          StoredProtein (const StoredProtein_optional& x);

          void
          StoredProtein (::std::unique_ptr< StoredProtein_type > p);



          typedef ::mil::tatrc::physiology::datamodel::ScalarMassData StoredFat_type;

          typedef ::xsd::cxx::tree::optional< StoredFat_type > StoredFat_optional;

          typedef ::xsd::cxx::tree::traits< StoredFat_type, char > StoredFat_traits;

          const StoredFat_optional&
          StoredFat () const;

          StoredFat_optional&
          StoredFat ();

          void
          StoredFat (const StoredFat_type& x);

          void
          StoredFat (const StoredFat_optional& x);

          void
          StoredFat (::std::unique_ptr< StoredFat_type > p);



          TissueSystemData ();

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

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

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

          TissueSystemData&
          operator= (const TissueSystemData& x);


          virtual 
          ~TissueSystemData ();

          // Implementation.
          //

          //@cond

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

          protected:
          CarbonDioxideProductionRate_optional CarbonDioxideProductionRate_;
          DehydrationFraction_optional DehydrationFraction_;
          ExtracellularFluidVolume_optional ExtracellularFluidVolume_;
          ExtravascularFluidVolume_optional ExtravascularFluidVolume_;
          IntracellularFluidPH_optional IntracellularFluidPH_;
          IntracellularFluidVolume_optional IntracellularFluidVolume_;
          TotalBodyFluidVolume_optional TotalBodyFluidVolume_;
          OxygenConsumptionRate_optional OxygenConsumptionRate_;
          RespiratoryExchangeRatio_optional RespiratoryExchangeRatio_;
          LiverInsulinSetPoint_optional LiverInsulinSetPoint_;
          LiverGlucagonSetPoint_optional LiverGlucagonSetPoint_;
          MuscleInsulinSetPoint_optional MuscleInsulinSetPoint_;
          MuscleGlucagonSetPoint_optional MuscleGlucagonSetPoint_;
          FatInsulinSetPoint_optional FatInsulinSetPoint_;
          FatGlucagonSetPoint_optional FatGlucagonSetPoint_;
          LiverGlycogen_optional LiverGlycogen_;
          MuscleGlycogen_optional MuscleGlycogen_;
          StoredProtein_optional StoredProtein_;
          StoredFat_optional StoredFat_;

          //@endcond
        };
      }
    }
  }
}

#include <iosfwd>

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

#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::BloodChemistrySystemData >
        BloodChemistrySystem (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::BloodChemistrySystemData >
        BloodChemistrySystem (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::BloodChemistrySystemData >
        BloodChemistrySystem (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::BloodChemistrySystemData >
        BloodChemistrySystem (::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::BloodChemistrySystemData >
        BloodChemistrySystem (::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::BloodChemistrySystemData >
        BloodChemistrySystem (::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::BloodChemistrySystemData >
        BloodChemistrySystem (::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::BloodChemistrySystemData >
        BloodChemistrySystem (::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::BloodChemistrySystemData >
        BloodChemistrySystem (::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::BloodChemistrySystemData >
        BloodChemistrySystem (::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::BloodChemistrySystemData >
        BloodChemistrySystem (::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::BloodChemistrySystemData >
        BloodChemistrySystem (::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::BloodChemistrySystemData >
        BloodChemistrySystem (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::BloodChemistrySystemData >
        BloodChemistrySystem (::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::CardiovascularSystemData >
        CardiovascularSystem (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::CardiovascularSystemData >
        CardiovascularSystem (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::CardiovascularSystemData >
        CardiovascularSystem (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::CardiovascularSystemData >
        CardiovascularSystem (::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::CardiovascularSystemData >
        CardiovascularSystem (::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::CardiovascularSystemData >
        CardiovascularSystem (::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::CardiovascularSystemData >
        CardiovascularSystem (::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::CardiovascularSystemData >
        CardiovascularSystem (::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::CardiovascularSystemData >
        CardiovascularSystem (::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::CardiovascularSystemData >
        CardiovascularSystem (::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::CardiovascularSystemData >
        CardiovascularSystem (::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::CardiovascularSystemData >
        CardiovascularSystem (::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::CardiovascularSystemData >
        CardiovascularSystem (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::CardiovascularSystemData >
        CardiovascularSystem (::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::DrugSystemData >
        DrugSystem (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::DrugSystemData >
        DrugSystem (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::DrugSystemData >
        DrugSystem (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::DrugSystemData >
        DrugSystem (::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::DrugSystemData >
        DrugSystem (::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::DrugSystemData >
        DrugSystem (::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::DrugSystemData >
        DrugSystem (::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::DrugSystemData >
        DrugSystem (::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::DrugSystemData >
        DrugSystem (::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::DrugSystemData >
        DrugSystem (::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::DrugSystemData >
        DrugSystem (::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::DrugSystemData >
        DrugSystem (::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::DrugSystemData >
        DrugSystem (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::DrugSystemData >
        DrugSystem (::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::EndocrineSystemData >
        EndocrineSystem (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::EndocrineSystemData >
        EndocrineSystem (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::EndocrineSystemData >
        EndocrineSystem (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::EndocrineSystemData >
        EndocrineSystem (::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::EndocrineSystemData >
        EndocrineSystem (::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::EndocrineSystemData >
        EndocrineSystem (::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::EndocrineSystemData >
        EndocrineSystem (::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::EndocrineSystemData >
        EndocrineSystem (::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::EndocrineSystemData >
        EndocrineSystem (::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::EndocrineSystemData >
        EndocrineSystem (::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::EndocrineSystemData >
        EndocrineSystem (::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::EndocrineSystemData >
        EndocrineSystem (::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::EndocrineSystemData >
        EndocrineSystem (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::EndocrineSystemData >
        EndocrineSystem (::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::EnergySystemData >
        EnergySystemData_ (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::EnergySystemData >
        EnergySystemData_ (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::EnergySystemData >
        EnergySystemData_ (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::EnergySystemData >
        EnergySystemData_ (::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::EnergySystemData >
        EnergySystemData_ (::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::EnergySystemData >
        EnergySystemData_ (::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::EnergySystemData >
        EnergySystemData_ (::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::EnergySystemData >
        EnergySystemData_ (::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::EnergySystemData >
        EnergySystemData_ (::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::EnergySystemData >
        EnergySystemData_ (::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::EnergySystemData >
        EnergySystemData_ (::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::EnergySystemData >
        EnergySystemData_ (::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::EnergySystemData >
        EnergySystemData_ (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::EnergySystemData >
        EnergySystemData_ (::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::GastrointestinalSystemData >
        GastrointestinalSystem (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::GastrointestinalSystemData >
        GastrointestinalSystem (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::GastrointestinalSystemData >
        GastrointestinalSystem (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::GastrointestinalSystemData >
        GastrointestinalSystem (::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::GastrointestinalSystemData >
        GastrointestinalSystem (::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::GastrointestinalSystemData >
        GastrointestinalSystem (::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::GastrointestinalSystemData >
        GastrointestinalSystem (::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::GastrointestinalSystemData >
        GastrointestinalSystem (::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::GastrointestinalSystemData >
        GastrointestinalSystem (::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::GastrointestinalSystemData >
        GastrointestinalSystem (::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::GastrointestinalSystemData >
        GastrointestinalSystem (::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::GastrointestinalSystemData >
        GastrointestinalSystem (::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::GastrointestinalSystemData >
        GastrointestinalSystem (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::GastrointestinalSystemData >
        GastrointestinalSystem (::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::HepaticSystemData >
        HepaticSystem (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::HepaticSystemData >
        HepaticSystem (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::HepaticSystemData >
        HepaticSystem (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::HepaticSystemData >
        HepaticSystem (::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::HepaticSystemData >
        HepaticSystem (::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::HepaticSystemData >
        HepaticSystem (::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::HepaticSystemData >
        HepaticSystem (::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::HepaticSystemData >
        HepaticSystem (::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::HepaticSystemData >
        HepaticSystem (::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::HepaticSystemData >
        HepaticSystem (::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::HepaticSystemData >
        HepaticSystem (::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::HepaticSystemData >
        HepaticSystem (::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::HepaticSystemData >
        HepaticSystem (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::HepaticSystemData >
        HepaticSystem (::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::NervousSystemData >
        NervousSystem (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::NervousSystemData >
        NervousSystem (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::NervousSystemData >
        NervousSystem (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::NervousSystemData >
        NervousSystem (::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::NervousSystemData >
        NervousSystem (::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::NervousSystemData >
        NervousSystem (::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::NervousSystemData >
        NervousSystem (::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::NervousSystemData >
        NervousSystem (::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::NervousSystemData >
        NervousSystem (::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::NervousSystemData >
        NervousSystem (::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::NervousSystemData >
        NervousSystem (::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::NervousSystemData >
        NervousSystem (::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::NervousSystemData >
        NervousSystem (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::NervousSystemData >
        NervousSystem (::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::RenalSystemData >
        RenalSystem (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::RenalSystemData >
        RenalSystem (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::RenalSystemData >
        RenalSystem (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::RenalSystemData >
        RenalSystem (::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::RenalSystemData >
        RenalSystem (::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::RenalSystemData >
        RenalSystem (::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::RenalSystemData >
        RenalSystem (::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::RenalSystemData >
        RenalSystem (::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::RenalSystemData >
        RenalSystem (::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::RenalSystemData >
        RenalSystem (::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::RenalSystemData >
        RenalSystem (::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::RenalSystemData >
        RenalSystem (::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::RenalSystemData >
        RenalSystem (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::RenalSystemData >
        RenalSystem (::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::RespiratorySystemData >
        RespiratorySystem (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::RespiratorySystemData >
        RespiratorySystem (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::RespiratorySystemData >
        RespiratorySystem (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::RespiratorySystemData >
        RespiratorySystem (::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::RespiratorySystemData >
        RespiratorySystem (::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::RespiratorySystemData >
        RespiratorySystem (::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::RespiratorySystemData >
        RespiratorySystem (::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::RespiratorySystemData >
        RespiratorySystem (::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::RespiratorySystemData >
        RespiratorySystem (::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::RespiratorySystemData >
        RespiratorySystem (::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::RespiratorySystemData >
        RespiratorySystem (::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::RespiratorySystemData >
        RespiratorySystem (::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::RespiratorySystemData >
        RespiratorySystem (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::RespiratorySystemData >
        RespiratorySystem (::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::TissueSystemData >
        TissueSystem (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::TissueSystemData >
        TissueSystem (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::TissueSystemData >
        TissueSystem (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::TissueSystemData >
        TissueSystem (::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::TissueSystemData >
        TissueSystem (::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::TissueSystemData >
        TissueSystem (::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::TissueSystemData >
        TissueSystem (::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::TissueSystemData >
        TissueSystem (::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::TissueSystemData >
        TissueSystem (::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::TissueSystemData >
        TissueSystem (::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::TissueSystemData >
        TissueSystem (::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::TissueSystemData >
        TissueSystem (::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::TissueSystemData >
        TissueSystem (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::TissueSystemData >
        TissueSystem (::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 PupillaryResponseData&);

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

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

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

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

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


        BIOGEARS_CDM_API
        void
        BloodChemistrySystem (::std::ostream& os,
                              const ::mil::tatrc::physiology::datamodel::BloodChemistrySystemData& 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
        BloodChemistrySystem (::std::ostream& os,
                              const ::mil::tatrc::physiology::datamodel::BloodChemistrySystemData& 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
        BloodChemistrySystem (::std::ostream& os,
                              const ::mil::tatrc::physiology::datamodel::BloodChemistrySystemData& 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
        BloodChemistrySystem (::xercesc::XMLFormatTarget& ft,
                              const ::mil::tatrc::physiology::datamodel::BloodChemistrySystemData& 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
        BloodChemistrySystem (::xercesc::XMLFormatTarget& ft,
                              const ::mil::tatrc::physiology::datamodel::BloodChemistrySystemData& 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
        BloodChemistrySystem (::xercesc::XMLFormatTarget& ft,
                              const ::mil::tatrc::physiology::datamodel::BloodChemistrySystemData& 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
        BloodChemistrySystem (::xercesc::DOMDocument& d,
                              const ::mil::tatrc::physiology::datamodel::BloodChemistrySystemData& x,
                              ::xml_schema::flags f = 0);

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


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

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

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

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


        BIOGEARS_CDM_API
        void
        CardiovascularSystem (::std::ostream& os,
                              const ::mil::tatrc::physiology::datamodel::CardiovascularSystemData& 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
        CardiovascularSystem (::std::ostream& os,
                              const ::mil::tatrc::physiology::datamodel::CardiovascularSystemData& 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
        CardiovascularSystem (::std::ostream& os,
                              const ::mil::tatrc::physiology::datamodel::CardiovascularSystemData& 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
        CardiovascularSystem (::xercesc::XMLFormatTarget& ft,
                              const ::mil::tatrc::physiology::datamodel::CardiovascularSystemData& 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
        CardiovascularSystem (::xercesc::XMLFormatTarget& ft,
                              const ::mil::tatrc::physiology::datamodel::CardiovascularSystemData& 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
        CardiovascularSystem (::xercesc::XMLFormatTarget& ft,
                              const ::mil::tatrc::physiology::datamodel::CardiovascularSystemData& 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
        CardiovascularSystem (::xercesc::DOMDocument& d,
                              const ::mil::tatrc::physiology::datamodel::CardiovascularSystemData& x,
                              ::xml_schema::flags f = 0);

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


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


        BIOGEARS_CDM_API
        void
        DrugSystem (::std::ostream& os,
                    const ::mil::tatrc::physiology::datamodel::DrugSystemData& 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
        DrugSystem (::std::ostream& os,
                    const ::mil::tatrc::physiology::datamodel::DrugSystemData& 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
        DrugSystem (::std::ostream& os,
                    const ::mil::tatrc::physiology::datamodel::DrugSystemData& 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
        DrugSystem (::xercesc::XMLFormatTarget& ft,
                    const ::mil::tatrc::physiology::datamodel::DrugSystemData& 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
        DrugSystem (::xercesc::XMLFormatTarget& ft,
                    const ::mil::tatrc::physiology::datamodel::DrugSystemData& 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
        DrugSystem (::xercesc::XMLFormatTarget& ft,
                    const ::mil::tatrc::physiology::datamodel::DrugSystemData& 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
        DrugSystem (::xercesc::DOMDocument& d,
                    const ::mil::tatrc::physiology::datamodel::DrugSystemData& x,
                    ::xml_schema::flags f = 0);

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


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


        BIOGEARS_CDM_API
        void
        EndocrineSystem (::std::ostream& os,
                         const ::mil::tatrc::physiology::datamodel::EndocrineSystemData& 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
        EndocrineSystem (::std::ostream& os,
                         const ::mil::tatrc::physiology::datamodel::EndocrineSystemData& 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
        EndocrineSystem (::std::ostream& os,
                         const ::mil::tatrc::physiology::datamodel::EndocrineSystemData& 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
        EndocrineSystem (::xercesc::XMLFormatTarget& ft,
                         const ::mil::tatrc::physiology::datamodel::EndocrineSystemData& 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
        EndocrineSystem (::xercesc::XMLFormatTarget& ft,
                         const ::mil::tatrc::physiology::datamodel::EndocrineSystemData& 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
        EndocrineSystem (::xercesc::XMLFormatTarget& ft,
                         const ::mil::tatrc::physiology::datamodel::EndocrineSystemData& 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
        EndocrineSystem (::xercesc::DOMDocument& d,
                         const ::mil::tatrc::physiology::datamodel::EndocrineSystemData& x,
                         ::xml_schema::flags f = 0);

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


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


        BIOGEARS_CDM_API
        void
        EnergySystemData_ (::std::ostream& os,
                           const ::mil::tatrc::physiology::datamodel::EnergySystemData& 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
        EnergySystemData_ (::std::ostream& os,
                           const ::mil::tatrc::physiology::datamodel::EnergySystemData& 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
        EnergySystemData_ (::std::ostream& os,
                           const ::mil::tatrc::physiology::datamodel::EnergySystemData& 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
        EnergySystemData_ (::xercesc::XMLFormatTarget& ft,
                           const ::mil::tatrc::physiology::datamodel::EnergySystemData& 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
        EnergySystemData_ (::xercesc::XMLFormatTarget& ft,
                           const ::mil::tatrc::physiology::datamodel::EnergySystemData& 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
        EnergySystemData_ (::xercesc::XMLFormatTarget& ft,
                           const ::mil::tatrc::physiology::datamodel::EnergySystemData& 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
        EnergySystemData_ (::xercesc::DOMDocument& d,
                           const ::mil::tatrc::physiology::datamodel::EnergySystemData& x,
                           ::xml_schema::flags f = 0);

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


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

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


        BIOGEARS_CDM_API
        void
        GastrointestinalSystem (::std::ostream& os,
                                const ::mil::tatrc::physiology::datamodel::GastrointestinalSystemData& 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
        GastrointestinalSystem (::std::ostream& os,
                                const ::mil::tatrc::physiology::datamodel::GastrointestinalSystemData& 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
        GastrointestinalSystem (::std::ostream& os,
                                const ::mil::tatrc::physiology::datamodel::GastrointestinalSystemData& 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
        GastrointestinalSystem (::xercesc::XMLFormatTarget& ft,
                                const ::mil::tatrc::physiology::datamodel::GastrointestinalSystemData& 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
        GastrointestinalSystem (::xercesc::XMLFormatTarget& ft,
                                const ::mil::tatrc::physiology::datamodel::GastrointestinalSystemData& 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
        GastrointestinalSystem (::xercesc::XMLFormatTarget& ft,
                                const ::mil::tatrc::physiology::datamodel::GastrointestinalSystemData& 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
        GastrointestinalSystem (::xercesc::DOMDocument& d,
                                const ::mil::tatrc::physiology::datamodel::GastrointestinalSystemData& x,
                                ::xml_schema::flags f = 0);

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


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


        BIOGEARS_CDM_API
        void
        HepaticSystem (::std::ostream& os,
                       const ::mil::tatrc::physiology::datamodel::HepaticSystemData& 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
        HepaticSystem (::std::ostream& os,
                       const ::mil::tatrc::physiology::datamodel::HepaticSystemData& 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
        HepaticSystem (::std::ostream& os,
                       const ::mil::tatrc::physiology::datamodel::HepaticSystemData& 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
        HepaticSystem (::xercesc::XMLFormatTarget& ft,
                       const ::mil::tatrc::physiology::datamodel::HepaticSystemData& 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
        HepaticSystem (::xercesc::XMLFormatTarget& ft,
                       const ::mil::tatrc::physiology::datamodel::HepaticSystemData& 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
        HepaticSystem (::xercesc::XMLFormatTarget& ft,
                       const ::mil::tatrc::physiology::datamodel::HepaticSystemData& 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
        HepaticSystem (::xercesc::DOMDocument& d,
                       const ::mil::tatrc::physiology::datamodel::HepaticSystemData& x,
                       ::xml_schema::flags f = 0);

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


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

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

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

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


        BIOGEARS_CDM_API
        void
        NervousSystem (::std::ostream& os,
                       const ::mil::tatrc::physiology::datamodel::NervousSystemData& 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
        NervousSystem (::std::ostream& os,
                       const ::mil::tatrc::physiology::datamodel::NervousSystemData& 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
        NervousSystem (::std::ostream& os,
                       const ::mil::tatrc::physiology::datamodel::NervousSystemData& 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
        NervousSystem (::xercesc::XMLFormatTarget& ft,
                       const ::mil::tatrc::physiology::datamodel::NervousSystemData& 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
        NervousSystem (::xercesc::XMLFormatTarget& ft,
                       const ::mil::tatrc::physiology::datamodel::NervousSystemData& 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
        NervousSystem (::xercesc::XMLFormatTarget& ft,
                       const ::mil::tatrc::physiology::datamodel::NervousSystemData& 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
        NervousSystem (::xercesc::DOMDocument& d,
                       const ::mil::tatrc::physiology::datamodel::NervousSystemData& x,
                       ::xml_schema::flags f = 0);

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


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


        BIOGEARS_CDM_API
        void
        RenalSystem (::std::ostream& os,
                     const ::mil::tatrc::physiology::datamodel::RenalSystemData& 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
        RenalSystem (::std::ostream& os,
                     const ::mil::tatrc::physiology::datamodel::RenalSystemData& 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
        RenalSystem (::std::ostream& os,
                     const ::mil::tatrc::physiology::datamodel::RenalSystemData& 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
        RenalSystem (::xercesc::XMLFormatTarget& ft,
                     const ::mil::tatrc::physiology::datamodel::RenalSystemData& 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
        RenalSystem (::xercesc::XMLFormatTarget& ft,
                     const ::mil::tatrc::physiology::datamodel::RenalSystemData& 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
        RenalSystem (::xercesc::XMLFormatTarget& ft,
                     const ::mil::tatrc::physiology::datamodel::RenalSystemData& 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
        RenalSystem (::xercesc::DOMDocument& d,
                     const ::mil::tatrc::physiology::datamodel::RenalSystemData& x,
                     ::xml_schema::flags f = 0);

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


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


        BIOGEARS_CDM_API
        void
        RespiratorySystem (::std::ostream& os,
                           const ::mil::tatrc::physiology::datamodel::RespiratorySystemData& 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
        RespiratorySystem (::std::ostream& os,
                           const ::mil::tatrc::physiology::datamodel::RespiratorySystemData& 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
        RespiratorySystem (::std::ostream& os,
                           const ::mil::tatrc::physiology::datamodel::RespiratorySystemData& 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
        RespiratorySystem (::xercesc::XMLFormatTarget& ft,
                           const ::mil::tatrc::physiology::datamodel::RespiratorySystemData& 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
        RespiratorySystem (::xercesc::XMLFormatTarget& ft,
                           const ::mil::tatrc::physiology::datamodel::RespiratorySystemData& 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
        RespiratorySystem (::xercesc::XMLFormatTarget& ft,
                           const ::mil::tatrc::physiology::datamodel::RespiratorySystemData& 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
        RespiratorySystem (::xercesc::DOMDocument& d,
                           const ::mil::tatrc::physiology::datamodel::RespiratorySystemData& x,
                           ::xml_schema::flags f = 0);

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


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


        BIOGEARS_CDM_API
        void
        TissueSystem (::std::ostream& os,
                      const ::mil::tatrc::physiology::datamodel::TissueSystemData& 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
        TissueSystem (::std::ostream& os,
                      const ::mil::tatrc::physiology::datamodel::TissueSystemData& 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
        TissueSystem (::std::ostream& os,
                      const ::mil::tatrc::physiology::datamodel::TissueSystemData& 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
        TissueSystem (::xercesc::XMLFormatTarget& ft,
                      const ::mil::tatrc::physiology::datamodel::TissueSystemData& 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
        TissueSystem (::xercesc::XMLFormatTarget& ft,
                      const ::mil::tatrc::physiology::datamodel::TissueSystemData& 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
        TissueSystem (::xercesc::XMLFormatTarget& ft,
                      const ::mil::tatrc::physiology::datamodel::TissueSystemData& 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
        TissueSystem (::xercesc::DOMDocument& d,
                      const ::mil::tatrc::physiology::datamodel::TissueSystemData& x,
                      ::xml_schema::flags f = 0);

        BIOGEARS_CDM_API
        ::xml_schema::dom::unique_ptr< ::xercesc::DOMDocument >
        TissueSystem (const ::mil::tatrc::physiology::datamodel::TissueSystemData& 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_PHYSIOLOGY_HXX