PatientActions.hxx

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

#ifndef D__BIOGEARS_CORE_SHARE_XSD__CDM_PATIENT_ACTIONS_HXX
#define D__BIOGEARS_CORE_SHARE_XSD__CDM_PATIENT_ACTIONS_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 PatientActionData;
        class enumPatientAssessment;
        class PatientAssessmentRequestData;
        class AcuteRespiratoryDistressData;
        class AcuteStressData;
        class AirwayObstructionData;
        class ApneaData;
        class AsthmaAttackData;
        class enumBrainInjuryType;
        class BrainInjuryData;
        class BronchoconstrictionData;
        class BurnWoundData;
        class CardiacArrestData;
        class ChestCompressionData;
        class ChestCompressionForceData;
        class ChestCompressionForceScaleData;
        class ChestOcclusiveDressingData;
        class ConsciousRespirationCommandData;
        class ForcedInhaleData;
        class ForcedExhaleData;
        class BreathHoldData;
        class UseInhalerData;
        class ConsciousRespirationData;
        class ConsumeNutrientsData;
        class GenericExerciseData;
        class RunningExerciseData;
        class CyclingExerciseData;
        class StrengthExerciseData;
        class ExerciseData;
        class HemorrhageData;
        class enumInfectionSeverity;
        class InfectionData;
        class enumIntubationType;
        class IntubationData;
        class MechanicalVentilationData;
        class NeedleDecompressionData;
        class NasalStateData;
        class PainStimulusData;
        class PericardialEffusionData;
        class enumPneumothoraxType;
        class TensionPneumothoraxData;
        class SleepData;
        class enumBolusAdministration;
        class enumOralAdministration;
        class SubstanceAdministrationData;
        class SubstanceBolusData;
        class SubstanceBolusStateData;
        class SubstanceCompoundInfusionData;
        class SubstanceInfusionData;
        class SubstanceNasalDoseData;
        class SubstanceOralDoseData;
        class enumTourniquetApplicationLevel;
        class TourniquetData;
        class TransmucosalStateData;
        class UrinateData;
        class OverrideData;
      }
    }
  }
}


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

#include "patientnutrition.hxx"

#include "substance.hxx"

namespace mil
{
  namespace tatrc
  {
    namespace physiology
    {
      namespace datamodel
      {
        class BIOGEARS_CDM_API PatientActionData: public ::mil::tatrc::physiology::datamodel::ActionData
        {
          public:

          PatientActionData ();

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

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

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


          virtual 
          ~PatientActionData ();
        };

        class BIOGEARS_CDM_API enumPatientAssessment: public ::xml_schema::string
        {
          public:

          enum value
          {
            PulmonaryFunctionTest,
            CompleteBloodCount,
            ComprehensiveMetabolicPanel,
            SequentialOrganFailureAssessment,
            Urinalysis
          };

          enumPatientAssessment ();

          enumPatientAssessment (value v);

          enumPatientAssessment (const char* v);

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

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

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

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

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

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

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

          enumPatientAssessment&
          operator= (value v);

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

          //@cond

          protected:
          value
          _xsd_enumPatientAssessment_convert () const;

          public:
          static const char* const _xsd_enumPatientAssessment_literals_[5];
          static const value _xsd_enumPatientAssessment_indexes_[5];

          //@endcond
        };

        class BIOGEARS_CDM_API PatientAssessmentRequestData: public ::mil::tatrc::physiology::datamodel::PatientActionData
        {
          public:

          typedef ::mil::tatrc::physiology::datamodel::enumPatientAssessment Type_type;

          typedef ::xsd::cxx::tree::traits< Type_type, char > Type_traits;

          const Type_type&
          Type () const;

          Type_type&
          Type ();

          void
          Type (const Type_type& x);

          void
          Type (::std::unique_ptr< Type_type > p);



          PatientAssessmentRequestData ();

          PatientAssessmentRequestData (const Type_type&);

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

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

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

          PatientAssessmentRequestData&
          operator= (const PatientAssessmentRequestData& x);


          virtual 
          ~PatientAssessmentRequestData ();

          // Implementation.
          //

          //@cond

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

          protected:
          ::xsd::cxx::tree::one< Type_type > Type_;

          //@endcond
        };

        class BIOGEARS_CDM_API AcuteRespiratoryDistressData: public ::mil::tatrc::physiology::datamodel::PatientActionData
        {
          public:

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

          typedef ::xsd::cxx::tree::traits< Severity_type, char > Severity_traits;

          const Severity_type&
          Severity () const;

          Severity_type&
          Severity ();

          void
          Severity (const Severity_type& x);

          void
          Severity (::std::unique_ptr< Severity_type > p);



          AcuteRespiratoryDistressData ();

          AcuteRespiratoryDistressData (const Severity_type&);

          AcuteRespiratoryDistressData (::std::unique_ptr< Severity_type >);

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

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

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

          AcuteRespiratoryDistressData&
          operator= (const AcuteRespiratoryDistressData& x);


          virtual 
          ~AcuteRespiratoryDistressData ();

          // Implementation.
          //

          //@cond

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

          protected:
          ::xsd::cxx::tree::one< Severity_type > Severity_;

          //@endcond
        };

        class BIOGEARS_CDM_API AcuteStressData: public ::mil::tatrc::physiology::datamodel::PatientActionData
        {
          public:

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

          typedef ::xsd::cxx::tree::traits< Severity_type, char > Severity_traits;

          const Severity_type&
          Severity () const;

          Severity_type&
          Severity ();

          void
          Severity (const Severity_type& x);

          void
          Severity (::std::unique_ptr< Severity_type > p);



          AcuteStressData ();

          AcuteStressData (const Severity_type&);

          AcuteStressData (::std::unique_ptr< Severity_type >);

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

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

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

          AcuteStressData&
          operator= (const AcuteStressData& x);


          virtual 
          ~AcuteStressData ();

          // Implementation.
          //

          //@cond

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

          protected:
          ::xsd::cxx::tree::one< Severity_type > Severity_;

          //@endcond
        };

        class BIOGEARS_CDM_API AirwayObstructionData: public ::mil::tatrc::physiology::datamodel::PatientActionData
        {
          public:

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

          typedef ::xsd::cxx::tree::traits< Severity_type, char > Severity_traits;

          const Severity_type&
          Severity () const;

          Severity_type&
          Severity ();

          void
          Severity (const Severity_type& x);

          void
          Severity (::std::unique_ptr< Severity_type > p);



          AirwayObstructionData ();

          AirwayObstructionData (const Severity_type&);

          AirwayObstructionData (::std::unique_ptr< Severity_type >);

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

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

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

          AirwayObstructionData&
          operator= (const AirwayObstructionData& x);


          virtual 
          ~AirwayObstructionData ();

          // Implementation.
          //

          //@cond

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

          protected:
          ::xsd::cxx::tree::one< Severity_type > Severity_;

          //@endcond
        };

        class BIOGEARS_CDM_API ApneaData: public ::mil::tatrc::physiology::datamodel::PatientActionData
        {
          public:

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

          typedef ::xsd::cxx::tree::traits< Severity_type, char > Severity_traits;

          const Severity_type&
          Severity () const;

          Severity_type&
          Severity ();

          void
          Severity (const Severity_type& x);

          void
          Severity (::std::unique_ptr< Severity_type > p);



          ApneaData ();

          ApneaData (const Severity_type&);

          ApneaData (::std::unique_ptr< Severity_type >);

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

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

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

          ApneaData&
          operator= (const ApneaData& x);


          virtual 
          ~ApneaData ();

          // Implementation.
          //

          //@cond

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

          protected:
          ::xsd::cxx::tree::one< Severity_type > Severity_;

          //@endcond
        };

        class BIOGEARS_CDM_API AsthmaAttackData: public ::mil::tatrc::physiology::datamodel::PatientActionData
        {
          public:

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

          typedef ::xsd::cxx::tree::traits< Severity_type, char > Severity_traits;

          const Severity_type&
          Severity () const;

          Severity_type&
          Severity ();

          void
          Severity (const Severity_type& x);

          void
          Severity (::std::unique_ptr< Severity_type > p);



          AsthmaAttackData ();

          AsthmaAttackData (const Severity_type&);

          AsthmaAttackData (::std::unique_ptr< Severity_type >);

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

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

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

          AsthmaAttackData&
          operator= (const AsthmaAttackData& x);


          virtual 
          ~AsthmaAttackData ();

          // Implementation.
          //

          //@cond

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

          protected:
          ::xsd::cxx::tree::one< Severity_type > Severity_;

          //@endcond
        };

        class BIOGEARS_CDM_API enumBrainInjuryType: public ::xml_schema::string
        {
          public:

          enum value
          {
            Diffuse,
            LeftFocal,
            RightFocal
          };

          enumBrainInjuryType ();

          enumBrainInjuryType (value v);

          enumBrainInjuryType (const char* v);

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

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

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

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

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

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

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

          enumBrainInjuryType&
          operator= (value v);

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

          //@cond

          protected:
          value
          _xsd_enumBrainInjuryType_convert () const;

          public:
          static const char* const _xsd_enumBrainInjuryType_literals_[3];
          static const value _xsd_enumBrainInjuryType_indexes_[3];

          //@endcond
        };

        class BIOGEARS_CDM_API BrainInjuryData: public ::mil::tatrc::physiology::datamodel::PatientActionData
        {
          public:

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

          typedef ::xsd::cxx::tree::traits< Severity_type, char > Severity_traits;

          const Severity_type&
          Severity () const;

          Severity_type&
          Severity ();

          void
          Severity (const Severity_type& x);

          void
          Severity (::std::unique_ptr< Severity_type > p);



          typedef ::mil::tatrc::physiology::datamodel::enumBrainInjuryType Type_type;

          typedef ::xsd::cxx::tree::traits< Type_type, char > Type_traits;

          const Type_type&
          Type () const;

          Type_type&
          Type ();

          void
          Type (const Type_type& x);

          void
          Type (::std::unique_ptr< Type_type > p);



          BrainInjuryData ();

          BrainInjuryData (const Severity_type&,
                           const Type_type&);

          BrainInjuryData (::std::unique_ptr< Severity_type >,
                           const Type_type&);

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

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

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

          BrainInjuryData&
          operator= (const BrainInjuryData& x);


          virtual 
          ~BrainInjuryData ();

          // Implementation.
          //

          //@cond

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

          protected:
          ::xsd::cxx::tree::one< Severity_type > Severity_;
          ::xsd::cxx::tree::one< Type_type > Type_;

          //@endcond
        };

        class BIOGEARS_CDM_API BronchoconstrictionData: public ::mil::tatrc::physiology::datamodel::PatientActionData
        {
          public:

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

          typedef ::xsd::cxx::tree::traits< Severity_type, char > Severity_traits;

          const Severity_type&
          Severity () const;

          Severity_type&
          Severity ();

          void
          Severity (const Severity_type& x);

          void
          Severity (::std::unique_ptr< Severity_type > p);



          BronchoconstrictionData ();

          BronchoconstrictionData (const Severity_type&);

          BronchoconstrictionData (::std::unique_ptr< Severity_type >);

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

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

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

          BronchoconstrictionData&
          operator= (const BronchoconstrictionData& x);


          virtual 
          ~BronchoconstrictionData ();

          // Implementation.
          //

          //@cond

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

          protected:
          ::xsd::cxx::tree::one< Severity_type > Severity_;

          //@endcond
        };

        class BIOGEARS_CDM_API BurnWoundData: public ::mil::tatrc::physiology::datamodel::PatientActionData
        {
          public:

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

          typedef ::xsd::cxx::tree::traits< TotalBodySurfaceArea_type, char > TotalBodySurfaceArea_traits;

          const TotalBodySurfaceArea_type&
          TotalBodySurfaceArea () const;

          TotalBodySurfaceArea_type&
          TotalBodySurfaceArea ();

          void
          TotalBodySurfaceArea (const TotalBodySurfaceArea_type& x);

          void
          TotalBodySurfaceArea (::std::unique_ptr< TotalBodySurfaceArea_type > p);



          BurnWoundData ();

          BurnWoundData (const TotalBodySurfaceArea_type&);

          BurnWoundData (::std::unique_ptr< TotalBodySurfaceArea_type >);

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

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

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

          BurnWoundData&
          operator= (const BurnWoundData& x);


          virtual 
          ~BurnWoundData ();

          // Implementation.
          //

          //@cond

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

          protected:
          ::xsd::cxx::tree::one< TotalBodySurfaceArea_type > TotalBodySurfaceArea_;

          //@endcond
        };

        class BIOGEARS_CDM_API CardiacArrestData: public ::mil::tatrc::physiology::datamodel::PatientActionData
        {
          public:

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

          typedef ::xsd::cxx::tree::traits< State_type, char > State_traits;

          const State_type&
          State () const;

          State_type&
          State ();

          void
          State (const State_type& x);

          void
          State (::std::unique_ptr< State_type > p);



          CardiacArrestData ();

          CardiacArrestData (const State_type&);

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

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

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

          CardiacArrestData&
          operator= (const CardiacArrestData& x);


          virtual 
          ~CardiacArrestData ();

          // Implementation.
          //

          //@cond

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

          protected:
          ::xsd::cxx::tree::one< State_type > State_;

          //@endcond
        };

        class BIOGEARS_CDM_API ChestCompressionData: public ::mil::tatrc::physiology::datamodel::PatientActionData
        {
          public:

          ChestCompressionData ();

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

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

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


          virtual 
          ~ChestCompressionData ();
        };

        class BIOGEARS_CDM_API ChestCompressionForceData: public ::mil::tatrc::physiology::datamodel::ChestCompressionData
        {
          public:

          typedef ::mil::tatrc::physiology::datamodel::ScalarForceData Force_type;

          typedef ::xsd::cxx::tree::traits< Force_type, char > Force_traits;

          const Force_type&
          Force () const;

          Force_type&
          Force ();

          void
          Force (const Force_type& x);

          void
          Force (::std::unique_ptr< Force_type > p);



          ChestCompressionForceData ();

          ChestCompressionForceData (const Force_type&);

          ChestCompressionForceData (::std::unique_ptr< Force_type >);

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

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

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

          ChestCompressionForceData&
          operator= (const ChestCompressionForceData& x);


          virtual 
          ~ChestCompressionForceData ();

          // Implementation.
          //

          //@cond

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

          protected:
          ::xsd::cxx::tree::one< Force_type > Force_;

          //@endcond
        };

        class BIOGEARS_CDM_API ChestCompressionForceScaleData: public ::mil::tatrc::physiology::datamodel::ChestCompressionData
        {
          public:

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

          typedef ::xsd::cxx::tree::traits< ForceScale_type, char > ForceScale_traits;

          const ForceScale_type&
          ForceScale () const;

          ForceScale_type&
          ForceScale ();

          void
          ForceScale (const ForceScale_type& x);

          void
          ForceScale (::std::unique_ptr< ForceScale_type > p);



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

          typedef ::xsd::cxx::tree::optional< ForcePeriod_type > ForcePeriod_optional;

          typedef ::xsd::cxx::tree::traits< ForcePeriod_type, char > ForcePeriod_traits;

          const ForcePeriod_optional&
          ForcePeriod () const;

          ForcePeriod_optional&
          ForcePeriod ();

          void
          ForcePeriod (const ForcePeriod_type& x);

          void
          ForcePeriod (const ForcePeriod_optional& x);

          void
          ForcePeriod (::std::unique_ptr< ForcePeriod_type > p);



          ChestCompressionForceScaleData ();

          ChestCompressionForceScaleData (const ForceScale_type&);

          ChestCompressionForceScaleData (::std::unique_ptr< ForceScale_type >);

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

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

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

          ChestCompressionForceScaleData&
          operator= (const ChestCompressionForceScaleData& x);


          virtual 
          ~ChestCompressionForceScaleData ();

          // Implementation.
          //

          //@cond

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

          protected:
          ::xsd::cxx::tree::one< ForceScale_type > ForceScale_;
          ForcePeriod_optional ForcePeriod_;

          //@endcond
        };

        class BIOGEARS_CDM_API ChestOcclusiveDressingData: public ::mil::tatrc::physiology::datamodel::PatientActionData
        {
          public:

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

          typedef ::xsd::cxx::tree::traits< State_type, char > State_traits;

          const State_type&
          State () const;

          State_type&
          State ();

          void
          State (const State_type& x);

          void
          State (::std::unique_ptr< State_type > p);



          typedef ::mil::tatrc::physiology::datamodel::enumSide Side_type;

          typedef ::xsd::cxx::tree::traits< Side_type, char > Side_traits;

          const Side_type&
          Side () const;

          Side_type&
          Side ();

          void
          Side (const Side_type& x);

          void
          Side (::std::unique_ptr< Side_type > p);



          ChestOcclusiveDressingData ();

          ChestOcclusiveDressingData (const State_type&,
                                      const Side_type&);

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

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

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

          ChestOcclusiveDressingData&
          operator= (const ChestOcclusiveDressingData& x);


          virtual 
          ~ChestOcclusiveDressingData ();

          // Implementation.
          //

          //@cond

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

          protected:
          ::xsd::cxx::tree::one< State_type > State_;
          ::xsd::cxx::tree::one< Side_type > Side_;

          //@endcond
        };

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

          typedef ::xml_schema::string Comment_type;

          typedef ::xsd::cxx::tree::optional< Comment_type > Comment_optional;

          typedef ::xsd::cxx::tree::traits< Comment_type, char > Comment_traits;

          const Comment_optional&
          Comment () const;

          Comment_optional&
          Comment ();

          void
          Comment (const Comment_type& x);

          void
          Comment (const Comment_optional& x);

          void
          Comment (::std::unique_ptr< Comment_type > p);



          ConsciousRespirationCommandData ();

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

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

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

          ConsciousRespirationCommandData&
          operator= (const ConsciousRespirationCommandData& x);


          virtual 
          ~ConsciousRespirationCommandData ();

          // Implementation.
          //

          //@cond

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

          protected:
          Comment_optional Comment_;

          //@endcond
        };

        class BIOGEARS_CDM_API ForcedInhaleData: public ::mil::tatrc::physiology::datamodel::ConsciousRespirationCommandData
        {
          public:

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

          typedef ::xsd::cxx::tree::traits< InspiratoryCapacityFraction_type, char > InspiratoryCapacityFraction_traits;

          const InspiratoryCapacityFraction_type&
          InspiratoryCapacityFraction () const;

          InspiratoryCapacityFraction_type&
          InspiratoryCapacityFraction ();

          void
          InspiratoryCapacityFraction (const InspiratoryCapacityFraction_type& x);

          void
          InspiratoryCapacityFraction (::std::unique_ptr< InspiratoryCapacityFraction_type > p);



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

          typedef ::xsd::cxx::tree::traits< Period_type, char > Period_traits;

          const Period_type&
          Period () const;

          Period_type&
          Period ();

          void
          Period (const Period_type& x);

          void
          Period (::std::unique_ptr< Period_type > p);



          ForcedInhaleData ();

          ForcedInhaleData (const InspiratoryCapacityFraction_type&,
                            const Period_type&);

          ForcedInhaleData (::std::unique_ptr< InspiratoryCapacityFraction_type >,
                            ::std::unique_ptr< Period_type >);

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

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

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

          ForcedInhaleData&
          operator= (const ForcedInhaleData& x);


          virtual 
          ~ForcedInhaleData ();

          // Implementation.
          //

          //@cond

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

          protected:
          ::xsd::cxx::tree::one< InspiratoryCapacityFraction_type > InspiratoryCapacityFraction_;
          ::xsd::cxx::tree::one< Period_type > Period_;

          //@endcond
        };

        class BIOGEARS_CDM_API ForcedExhaleData: public ::mil::tatrc::physiology::datamodel::ConsciousRespirationCommandData
        {
          public:

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

          typedef ::xsd::cxx::tree::traits< ExpiratoryReserveVolumeFraction_type, char > ExpiratoryReserveVolumeFraction_traits;

          const ExpiratoryReserveVolumeFraction_type&
          ExpiratoryReserveVolumeFraction () const;

          ExpiratoryReserveVolumeFraction_type&
          ExpiratoryReserveVolumeFraction ();

          void
          ExpiratoryReserveVolumeFraction (const ExpiratoryReserveVolumeFraction_type& x);

          void
          ExpiratoryReserveVolumeFraction (::std::unique_ptr< ExpiratoryReserveVolumeFraction_type > p);



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

          typedef ::xsd::cxx::tree::traits< Period_type, char > Period_traits;

          const Period_type&
          Period () const;

          Period_type&
          Period ();

          void
          Period (const Period_type& x);

          void
          Period (::std::unique_ptr< Period_type > p);



          ForcedExhaleData ();

          ForcedExhaleData (const ExpiratoryReserveVolumeFraction_type&,
                            const Period_type&);

          ForcedExhaleData (::std::unique_ptr< ExpiratoryReserveVolumeFraction_type >,
                            ::std::unique_ptr< Period_type >);

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

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

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

          ForcedExhaleData&
          operator= (const ForcedExhaleData& x);


          virtual 
          ~ForcedExhaleData ();

          // Implementation.
          //

          //@cond

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

          protected:
          ::xsd::cxx::tree::one< ExpiratoryReserveVolumeFraction_type > ExpiratoryReserveVolumeFraction_;
          ::xsd::cxx::tree::one< Period_type > Period_;

          //@endcond
        };

        class BIOGEARS_CDM_API BreathHoldData: public ::mil::tatrc::physiology::datamodel::ConsciousRespirationCommandData
        {
          public:

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

          typedef ::xsd::cxx::tree::traits< Period_type, char > Period_traits;

          const Period_type&
          Period () const;

          Period_type&
          Period ();

          void
          Period (const Period_type& x);

          void
          Period (::std::unique_ptr< Period_type > p);



          BreathHoldData ();

          BreathHoldData (const Period_type&);

          BreathHoldData (::std::unique_ptr< Period_type >);

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

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

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

          BreathHoldData&
          operator= (const BreathHoldData& x);


          virtual 
          ~BreathHoldData ();

          // Implementation.
          //

          //@cond

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

          protected:
          ::xsd::cxx::tree::one< Period_type > Period_;

          //@endcond
        };

        class BIOGEARS_CDM_API UseInhalerData: public ::mil::tatrc::physiology::datamodel::ConsciousRespirationCommandData
        {
          public:

          UseInhalerData ();

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

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

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


          virtual 
          ~UseInhalerData ();
        };

        class BIOGEARS_CDM_API ConsciousRespirationData: public ::mil::tatrc::physiology::datamodel::PatientActionData
        {
          public:

          typedef ::mil::tatrc::physiology::datamodel::ConsciousRespirationCommandData Command_type;

          typedef ::xsd::cxx::tree::sequence< Command_type > Command_sequence;

          typedef Command_sequence::iterator Command_iterator;

          typedef Command_sequence::const_iterator Command_const_iterator;

          typedef ::xsd::cxx::tree::traits< Command_type, char > Command_traits;

          const Command_sequence&
          Command () const;

          Command_sequence&
          Command ();

          void
          Command (const Command_sequence& s);



          typedef ::xml_schema::boolean AppendToPrevious_type;

          typedef ::xsd::cxx::tree::traits< AppendToPrevious_type, char > AppendToPrevious_traits;

          const AppendToPrevious_type&
          AppendToPrevious () const;

          AppendToPrevious_type&
          AppendToPrevious ();

          void
          AppendToPrevious (const AppendToPrevious_type& x);



          ConsciousRespirationData ();

          ConsciousRespirationData (const AppendToPrevious_type&);

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

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

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

          ConsciousRespirationData&
          operator= (const ConsciousRespirationData& x);


          virtual 
          ~ConsciousRespirationData ();

          // Implementation.
          //

          //@cond

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

          protected:
          Command_sequence Command_;
          ::xsd::cxx::tree::one< AppendToPrevious_type > AppendToPrevious_;

          //@endcond
        };

        class BIOGEARS_CDM_API ConsumeNutrientsData: public ::mil::tatrc::physiology::datamodel::PatientActionData
        {
          public:

          typedef ::xml_schema::string NutritionFile_type;

          typedef ::xsd::cxx::tree::optional< NutritionFile_type > NutritionFile_optional;

          typedef ::xsd::cxx::tree::traits< NutritionFile_type, char > NutritionFile_traits;

          const NutritionFile_optional&
          NutritionFile () const;

          NutritionFile_optional&
          NutritionFile ();

          void
          NutritionFile (const NutritionFile_type& x);

          void
          NutritionFile (const NutritionFile_optional& x);

          void
          NutritionFile (::std::unique_ptr< NutritionFile_type > p);



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

          typedef ::xsd::cxx::tree::optional< Nutrition_type > Nutrition_optional;

          typedef ::xsd::cxx::tree::traits< Nutrition_type, char > Nutrition_traits;

          const Nutrition_optional&
          Nutrition () const;

          Nutrition_optional&
          Nutrition ();

          void
          Nutrition (const Nutrition_type& x);

          void
          Nutrition (const Nutrition_optional& x);

          void
          Nutrition (::std::unique_ptr< Nutrition_type > p);



          ConsumeNutrientsData ();

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

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

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

          ConsumeNutrientsData&
          operator= (const ConsumeNutrientsData& x);


          virtual 
          ~ConsumeNutrientsData ();

          // Implementation.
          //

          //@cond

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

          protected:
          NutritionFile_optional NutritionFile_;
          Nutrition_optional Nutrition_;

          //@endcond
        };

        class BIOGEARS_CDM_API GenericExerciseData: public ::mil::tatrc::physiology::datamodel::PatientActionData
        {
          public:

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

          typedef ::xsd::cxx::tree::optional< Intensity_type > Intensity_optional;

          typedef ::xsd::cxx::tree::traits< Intensity_type, char > Intensity_traits;

          const Intensity_optional&
          Intensity () const;

          Intensity_optional&
          Intensity ();

          void
          Intensity (const Intensity_type& x);

          void
          Intensity (const Intensity_optional& x);

          void
          Intensity (::std::unique_ptr< Intensity_type > p);



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

          typedef ::xsd::cxx::tree::optional< DesiredWorkRate_type > DesiredWorkRate_optional;

          typedef ::xsd::cxx::tree::traits< DesiredWorkRate_type, char > DesiredWorkRate_traits;

          const DesiredWorkRate_optional&
          DesiredWorkRate () const;

          DesiredWorkRate_optional&
          DesiredWorkRate ();

          void
          DesiredWorkRate (const DesiredWorkRate_type& x);

          void
          DesiredWorkRate (const DesiredWorkRate_optional& x);

          void
          DesiredWorkRate (::std::unique_ptr< DesiredWorkRate_type > p);



          GenericExerciseData ();

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

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

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

          GenericExerciseData&
          operator= (const GenericExerciseData& x);


          virtual 
          ~GenericExerciseData ();

          // Implementation.
          //

          //@cond

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

          protected:
          Intensity_optional Intensity_;
          DesiredWorkRate_optional DesiredWorkRate_;

          //@endcond
        };

        class BIOGEARS_CDM_API RunningExerciseData: public ::mil::tatrc::physiology::datamodel::PatientActionData
        {
          public:

          typedef ::mil::tatrc::physiology::datamodel::ScalarLengthPerTimeData Speed_type;

          typedef ::xsd::cxx::tree::traits< Speed_type, char > Speed_traits;

          const Speed_type&
          Speed () const;

          Speed_type&
          Speed ();

          void
          Speed (const Speed_type& x);

          void
          Speed (::std::unique_ptr< Speed_type > p);



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

          typedef ::xsd::cxx::tree::traits< Incline_type, char > Incline_traits;

          const Incline_type&
          Incline () const;

          Incline_type&
          Incline ();

          void
          Incline (const Incline_type& x);

          void
          Incline (::std::unique_ptr< Incline_type > p);



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

          typedef ::xsd::cxx::tree::optional< AddedWeight_type > AddedWeight_optional;

          typedef ::xsd::cxx::tree::traits< AddedWeight_type, char > AddedWeight_traits;

          const AddedWeight_optional&
          AddedWeight () const;

          AddedWeight_optional&
          AddedWeight ();

          void
          AddedWeight (const AddedWeight_type& x);

          void
          AddedWeight (const AddedWeight_optional& x);

          void
          AddedWeight (::std::unique_ptr< AddedWeight_type > p);



          RunningExerciseData ();

          RunningExerciseData (const Speed_type&,
                               const Incline_type&);

          RunningExerciseData (::std::unique_ptr< Speed_type >,
                               ::std::unique_ptr< Incline_type >);

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

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

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

          RunningExerciseData&
          operator= (const RunningExerciseData& x);


          virtual 
          ~RunningExerciseData ();

          // Implementation.
          //

          //@cond

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

          protected:
          ::xsd::cxx::tree::one< Speed_type > Speed_;
          ::xsd::cxx::tree::one< Incline_type > Incline_;
          AddedWeight_optional AddedWeight_;

          //@endcond
        };

        class BIOGEARS_CDM_API CyclingExerciseData: public ::mil::tatrc::physiology::datamodel::PatientActionData
        {
          public:

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

          typedef ::xsd::cxx::tree::traits< Cadence_type, char > Cadence_traits;

          const Cadence_type&
          Cadence () const;

          Cadence_type&
          Cadence ();

          void
          Cadence (const Cadence_type& x);

          void
          Cadence (::std::unique_ptr< Cadence_type > p);



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

          typedef ::xsd::cxx::tree::traits< Power_type, char > Power_traits;

          const Power_type&
          Power () const;

          Power_type&
          Power ();

          void
          Power (const Power_type& x);

          void
          Power (::std::unique_ptr< Power_type > p);



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

          typedef ::xsd::cxx::tree::optional< AddedWeight_type > AddedWeight_optional;

          typedef ::xsd::cxx::tree::traits< AddedWeight_type, char > AddedWeight_traits;

          const AddedWeight_optional&
          AddedWeight () const;

          AddedWeight_optional&
          AddedWeight ();

          void
          AddedWeight (const AddedWeight_type& x);

          void
          AddedWeight (const AddedWeight_optional& x);

          void
          AddedWeight (::std::unique_ptr< AddedWeight_type > p);



          CyclingExerciseData ();

          CyclingExerciseData (const Cadence_type&,
                               const Power_type&);

          CyclingExerciseData (::std::unique_ptr< Cadence_type >,
                               ::std::unique_ptr< Power_type >);

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

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

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

          CyclingExerciseData&
          operator= (const CyclingExerciseData& x);


          virtual 
          ~CyclingExerciseData ();

          // Implementation.
          //

          //@cond

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

          protected:
          ::xsd::cxx::tree::one< Cadence_type > Cadence_;
          ::xsd::cxx::tree::one< Power_type > Power_;
          AddedWeight_optional AddedWeight_;

          //@endcond
        };

        class BIOGEARS_CDM_API StrengthExerciseData: public ::mil::tatrc::physiology::datamodel::PatientActionData
        {
          public:

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

          typedef ::xsd::cxx::tree::traits< Weight_type, char > Weight_traits;

          const Weight_type&
          Weight () const;

          Weight_type&
          Weight ();

          void
          Weight (const Weight_type& x);

          void
          Weight (::std::unique_ptr< Weight_type > p);



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

          typedef ::xsd::cxx::tree::traits< Repetitions_type, char > Repetitions_traits;

          const Repetitions_type&
          Repetitions () const;

          Repetitions_type&
          Repetitions ();

          void
          Repetitions (const Repetitions_type& x);

          void
          Repetitions (::std::unique_ptr< Repetitions_type > p);



          StrengthExerciseData ();

          StrengthExerciseData (const Weight_type&,
                                const Repetitions_type&);

          StrengthExerciseData (::std::unique_ptr< Weight_type >,
                                ::std::unique_ptr< Repetitions_type >);

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

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

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

          StrengthExerciseData&
          operator= (const StrengthExerciseData& x);


          virtual 
          ~StrengthExerciseData ();

          // Implementation.
          //

          //@cond

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

          protected:
          ::xsd::cxx::tree::one< Weight_type > Weight_;
          ::xsd::cxx::tree::one< Repetitions_type > Repetitions_;

          //@endcond
        };

        class BIOGEARS_CDM_API ExerciseData: public ::mil::tatrc::physiology::datamodel::PatientActionData
        {
          public:

          typedef ::mil::tatrc::physiology::datamodel::GenericExerciseData GenericExercise_type;

          typedef ::xsd::cxx::tree::optional< GenericExercise_type > GenericExercise_optional;

          typedef ::xsd::cxx::tree::traits< GenericExercise_type, char > GenericExercise_traits;

          const GenericExercise_optional&
          GenericExercise () const;

          GenericExercise_optional&
          GenericExercise ();

          void
          GenericExercise (const GenericExercise_type& x);

          void
          GenericExercise (const GenericExercise_optional& x);

          void
          GenericExercise (::std::unique_ptr< GenericExercise_type > p);



          typedef ::mil::tatrc::physiology::datamodel::RunningExerciseData RunningExercise_type;

          typedef ::xsd::cxx::tree::optional< RunningExercise_type > RunningExercise_optional;

          typedef ::xsd::cxx::tree::traits< RunningExercise_type, char > RunningExercise_traits;

          const RunningExercise_optional&
          RunningExercise () const;

          RunningExercise_optional&
          RunningExercise ();

          void
          RunningExercise (const RunningExercise_type& x);

          void
          RunningExercise (const RunningExercise_optional& x);

          void
          RunningExercise (::std::unique_ptr< RunningExercise_type > p);



          typedef ::mil::tatrc::physiology::datamodel::CyclingExerciseData CyclingExercise_type;

          typedef ::xsd::cxx::tree::optional< CyclingExercise_type > CyclingExercise_optional;

          typedef ::xsd::cxx::tree::traits< CyclingExercise_type, char > CyclingExercise_traits;

          const CyclingExercise_optional&
          CyclingExercise () const;

          CyclingExercise_optional&
          CyclingExercise ();

          void
          CyclingExercise (const CyclingExercise_type& x);

          void
          CyclingExercise (const CyclingExercise_optional& x);

          void
          CyclingExercise (::std::unique_ptr< CyclingExercise_type > p);



          typedef ::mil::tatrc::physiology::datamodel::StrengthExerciseData StrengthExercise_type;

          typedef ::xsd::cxx::tree::optional< StrengthExercise_type > StrengthExercise_optional;

          typedef ::xsd::cxx::tree::traits< StrengthExercise_type, char > StrengthExercise_traits;

          const StrengthExercise_optional&
          StrengthExercise () const;

          StrengthExercise_optional&
          StrengthExercise ();

          void
          StrengthExercise (const StrengthExercise_type& x);

          void
          StrengthExercise (const StrengthExercise_optional& x);

          void
          StrengthExercise (::std::unique_ptr< StrengthExercise_type > p);



          ExerciseData ();

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

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

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

          ExerciseData&
          operator= (const ExerciseData& x);


          virtual 
          ~ExerciseData ();

          // Implementation.
          //

          //@cond

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

          protected:
          GenericExercise_optional GenericExercise_;
          RunningExercise_optional RunningExercise_;
          CyclingExercise_optional CyclingExercise_;
          StrengthExercise_optional StrengthExercise_;

          //@endcond
        };

        class BIOGEARS_CDM_API HemorrhageData: public ::mil::tatrc::physiology::datamodel::PatientActionData
        {
          public:

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

          typedef ::xsd::cxx::tree::traits< InitialRate_type, char > InitialRate_traits;

          const InitialRate_type&
          InitialRate () const;

          InitialRate_type&
          InitialRate ();

          void
          InitialRate (const InitialRate_type& x);

          void
          InitialRate (::std::unique_ptr< InitialRate_type > p);



          typedef ::xml_schema::string Compartment_type;

          typedef ::xsd::cxx::tree::traits< Compartment_type, char > Compartment_traits;

          const Compartment_type&
          Compartment () const;

          Compartment_type&
          Compartment ();

          void
          Compartment (const Compartment_type& x);

          void
          Compartment (::std::unique_ptr< Compartment_type > p);



          HemorrhageData ();

          HemorrhageData (const InitialRate_type&,
                          const Compartment_type&);

          HemorrhageData (::std::unique_ptr< InitialRate_type >,
                          const Compartment_type&);

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

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

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

          HemorrhageData&
          operator= (const HemorrhageData& x);


          virtual 
          ~HemorrhageData ();

          // Implementation.
          //

          //@cond

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

          protected:
          ::xsd::cxx::tree::one< InitialRate_type > InitialRate_;
          ::xsd::cxx::tree::one< Compartment_type > Compartment_;

          //@endcond
        };

        class BIOGEARS_CDM_API enumInfectionSeverity: public ::xml_schema::string
        {
          public:

          enum value
          {
            Eliminated,
            Mild,
            Moderate,
            Severe
          };

          enumInfectionSeverity ();

          enumInfectionSeverity (value v);

          enumInfectionSeverity (const char* v);

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

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

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

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

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

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

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

          enumInfectionSeverity&
          operator= (value v);

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

          //@cond

          protected:
          value
          _xsd_enumInfectionSeverity_convert () const;

          public:
          static const char* const _xsd_enumInfectionSeverity_literals_[4];
          static const value _xsd_enumInfectionSeverity_indexes_[4];

          //@endcond
        };

        class BIOGEARS_CDM_API InfectionData: public ::mil::tatrc::physiology::datamodel::PatientActionData
        {
          public:

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

          typedef ::xsd::cxx::tree::traits< MinimumInhibitoryConcentration_type, char > MinimumInhibitoryConcentration_traits;

          const MinimumInhibitoryConcentration_type&
          MinimumInhibitoryConcentration () const;

          MinimumInhibitoryConcentration_type&
          MinimumInhibitoryConcentration ();

          void
          MinimumInhibitoryConcentration (const MinimumInhibitoryConcentration_type& x);

          void
          MinimumInhibitoryConcentration (::std::unique_ptr< MinimumInhibitoryConcentration_type > p);



          typedef ::xml_schema::string Location_type;

          typedef ::xsd::cxx::tree::traits< Location_type, char > Location_traits;

          const Location_type&
          Location () const;

          Location_type&
          Location ();

          void
          Location (const Location_type& x);

          void
          Location (::std::unique_ptr< Location_type > p);



          typedef ::mil::tatrc::physiology::datamodel::enumInfectionSeverity Severity_type;

          typedef ::xsd::cxx::tree::traits< Severity_type, char > Severity_traits;

          const Severity_type&
          Severity () const;

          Severity_type&
          Severity ();

          void
          Severity (const Severity_type& x);

          void
          Severity (::std::unique_ptr< Severity_type > p);



          InfectionData ();

          InfectionData (const MinimumInhibitoryConcentration_type&,
                         const Location_type&,
                         const Severity_type&);

          InfectionData (::std::unique_ptr< MinimumInhibitoryConcentration_type >,
                         const Location_type&,
                         const Severity_type&);

          InfectionData (::std::unique_ptr< MinimumInhibitoryConcentration_type >,
                         ::std::unique_ptr< Location_type >,
                         const Severity_type&);

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

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

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

          InfectionData&
          operator= (const InfectionData& x);


          virtual 
          ~InfectionData ();

          // Implementation.
          //

          //@cond

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

          protected:
          ::xsd::cxx::tree::one< MinimumInhibitoryConcentration_type > MinimumInhibitoryConcentration_;
          ::xsd::cxx::tree::one< Location_type > Location_;
          ::xsd::cxx::tree::one< Severity_type > Severity_;

          //@endcond
        };

        class BIOGEARS_CDM_API enumIntubationType: public ::xml_schema::string
        {
          public:

          enum value
          {
            Off,
            Esophageal,
            LeftMainstem,
            RightMainstem,
            Tracheal
          };

          enumIntubationType ();

          enumIntubationType (value v);

          enumIntubationType (const char* v);

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

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

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

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

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

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

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

          enumIntubationType&
          operator= (value v);

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

          //@cond

          protected:
          value
          _xsd_enumIntubationType_convert () const;

          public:
          static const char* const _xsd_enumIntubationType_literals_[5];
          static const value _xsd_enumIntubationType_indexes_[5];

          //@endcond
        };

        class BIOGEARS_CDM_API IntubationData: public ::mil::tatrc::physiology::datamodel::PatientActionData
        {
          public:

          typedef ::mil::tatrc::physiology::datamodel::enumIntubationType Type_type;

          typedef ::xsd::cxx::tree::traits< Type_type, char > Type_traits;

          const Type_type&
          Type () const;

          Type_type&
          Type ();

          void
          Type (const Type_type& x);

          void
          Type (::std::unique_ptr< Type_type > p);



          IntubationData ();

          IntubationData (const Type_type&);

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

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

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

          IntubationData&
          operator= (const IntubationData& x);


          virtual 
          ~IntubationData ();

          // Implementation.
          //

          //@cond

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

          protected:
          ::xsd::cxx::tree::one< Type_type > Type_;

          //@endcond
        };

        class BIOGEARS_CDM_API MechanicalVentilationData: public ::mil::tatrc::physiology::datamodel::PatientActionData
        {
          public:

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

          typedef ::xsd::cxx::tree::optional< Pressure_type > Pressure_optional;

          typedef ::xsd::cxx::tree::traits< Pressure_type, char > Pressure_traits;

          const Pressure_optional&
          Pressure () const;

          Pressure_optional&
          Pressure ();

          void
          Pressure (const Pressure_type& x);

          void
          Pressure (const Pressure_optional& x);

          void
          Pressure (::std::unique_ptr< Pressure_type > p);



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

          typedef ::xsd::cxx::tree::optional< Flow_type > Flow_optional;

          typedef ::xsd::cxx::tree::traits< Flow_type, char > Flow_traits;

          const Flow_optional&
          Flow () const;

          Flow_optional&
          Flow ();

          void
          Flow (const Flow_type& x);

          void
          Flow (const Flow_optional& x);

          void
          Flow (::std::unique_ptr< Flow_type > p);



          typedef ::mil::tatrc::physiology::datamodel::SubstanceFractionData GasFraction_type;

          typedef ::xsd::cxx::tree::sequence< GasFraction_type > GasFraction_sequence;

          typedef GasFraction_sequence::iterator GasFraction_iterator;

          typedef GasFraction_sequence::const_iterator GasFraction_const_iterator;

          typedef ::xsd::cxx::tree::traits< GasFraction_type, char > GasFraction_traits;

          const GasFraction_sequence&
          GasFraction () const;

          GasFraction_sequence&
          GasFraction ();

          void
          GasFraction (const GasFraction_sequence& s);



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

          typedef ::xsd::cxx::tree::traits< State_type, char > State_traits;

          const State_type&
          State () const;

          State_type&
          State ();

          void
          State (const State_type& x);

          void
          State (::std::unique_ptr< State_type > p);



          MechanicalVentilationData ();

          MechanicalVentilationData (const State_type&);

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

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

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

          MechanicalVentilationData&
          operator= (const MechanicalVentilationData& x);


          virtual 
          ~MechanicalVentilationData ();

          // Implementation.
          //

          //@cond

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

          protected:
          Pressure_optional Pressure_;
          Flow_optional Flow_;
          GasFraction_sequence GasFraction_;
          ::xsd::cxx::tree::one< State_type > State_;

          //@endcond
        };

        class BIOGEARS_CDM_API NeedleDecompressionData: public ::mil::tatrc::physiology::datamodel::PatientActionData
        {
          public:

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

          typedef ::xsd::cxx::tree::traits< State_type, char > State_traits;

          const State_type&
          State () const;

          State_type&
          State ();

          void
          State (const State_type& x);

          void
          State (::std::unique_ptr< State_type > p);



          typedef ::mil::tatrc::physiology::datamodel::enumSide Side_type;

          typedef ::xsd::cxx::tree::traits< Side_type, char > Side_traits;

          const Side_type&
          Side () const;

          Side_type&
          Side ();

          void
          Side (const Side_type& x);

          void
          Side (::std::unique_ptr< Side_type > p);



          NeedleDecompressionData ();

          NeedleDecompressionData (const State_type&,
                                   const Side_type&);

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

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

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

          NeedleDecompressionData&
          operator= (const NeedleDecompressionData& x);


          virtual 
          ~NeedleDecompressionData ();

          // Implementation.
          //

          //@cond

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

          protected:
          ::xsd::cxx::tree::one< State_type > State_;
          ::xsd::cxx::tree::one< Side_type > Side_;

          //@endcond
        };

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

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

          typedef ::xsd::cxx::tree::traits< TotalNasalDose_type, char > TotalNasalDose_traits;

          const TotalNasalDose_type&
          TotalNasalDose () const;

          TotalNasalDose_type&
          TotalNasalDose ();

          void
          TotalNasalDose (const TotalNasalDose_type& x);

          void
          TotalNasalDose (::std::unique_ptr< TotalNasalDose_type > p);



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

          typedef ::xsd::cxx::tree::sequence< UnreleasedDrugMasses_type > UnreleasedDrugMasses_sequence;

          typedef UnreleasedDrugMasses_sequence::iterator UnreleasedDrugMasses_iterator;

          typedef UnreleasedDrugMasses_sequence::const_iterator UnreleasedDrugMasses_const_iterator;

          typedef ::xsd::cxx::tree::traits< UnreleasedDrugMasses_type, char > UnreleasedDrugMasses_traits;

          const UnreleasedDrugMasses_sequence&
          UnreleasedDrugMasses () const;

          UnreleasedDrugMasses_sequence&
          UnreleasedDrugMasses ();

          void
          UnreleasedDrugMasses (const UnreleasedDrugMasses_sequence& s);



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

          typedef ::xsd::cxx::tree::sequence< ReleasedDrugMasses_type > ReleasedDrugMasses_sequence;

          typedef ReleasedDrugMasses_sequence::iterator ReleasedDrugMasses_iterator;

          typedef ReleasedDrugMasses_sequence::const_iterator ReleasedDrugMasses_const_iterator;

          typedef ::xsd::cxx::tree::traits< ReleasedDrugMasses_type, char > ReleasedDrugMasses_traits;

          const ReleasedDrugMasses_sequence&
          ReleasedDrugMasses () const;

          ReleasedDrugMasses_sequence&
          ReleasedDrugMasses ();

          void
          ReleasedDrugMasses (const ReleasedDrugMasses_sequence& s);



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



          NasalStateData ();

          NasalStateData (const TotalNasalDose_type&,
                          const Substance_type&);

          NasalStateData (::std::unique_ptr< TotalNasalDose_type >,
                          const Substance_type&);

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

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

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

          NasalStateData&
          operator= (const NasalStateData& x);


          virtual 
          ~NasalStateData ();

          // Implementation.
          //

          //@cond

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

          protected:
          ::xsd::cxx::tree::one< TotalNasalDose_type > TotalNasalDose_;
          UnreleasedDrugMasses_sequence UnreleasedDrugMasses_;
          ReleasedDrugMasses_sequence ReleasedDrugMasses_;
          ::xsd::cxx::tree::one< Substance_type > Substance_;

          //@endcond
        };

        class BIOGEARS_CDM_API PainStimulusData: public ::mil::tatrc::physiology::datamodel::PatientActionData
        {
          public:

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

          typedef ::xsd::cxx::tree::traits< Severity_type, char > Severity_traits;

          const Severity_type&
          Severity () const;

          Severity_type&
          Severity ();

          void
          Severity (const Severity_type& x);

          void
          Severity (::std::unique_ptr< Severity_type > p);



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

          typedef ::xsd::cxx::tree::optional< HalfLife_type > HalfLife_optional;

          typedef ::xsd::cxx::tree::traits< HalfLife_type, char > HalfLife_traits;

          const HalfLife_optional&
          HalfLife () const;

          HalfLife_optional&
          HalfLife ();

          void
          HalfLife (const HalfLife_type& x);

          void
          HalfLife (const HalfLife_optional& x);

          void
          HalfLife (::std::unique_ptr< HalfLife_type > p);



          typedef ::xml_schema::string Location_type;

          typedef ::xsd::cxx::tree::traits< Location_type, char > Location_traits;

          const Location_type&
          Location () const;

          Location_type&
          Location ();

          void
          Location (const Location_type& x);

          void
          Location (::std::unique_ptr< Location_type > p);



          PainStimulusData ();

          PainStimulusData (const Severity_type&,
                            const Location_type&);

          PainStimulusData (::std::unique_ptr< Severity_type >,
                            const Location_type&);

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

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

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

          PainStimulusData&
          operator= (const PainStimulusData& x);


          virtual 
          ~PainStimulusData ();

          // Implementation.
          //

          //@cond

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

          protected:
          ::xsd::cxx::tree::one< Severity_type > Severity_;
          HalfLife_optional HalfLife_;
          ::xsd::cxx::tree::one< Location_type > Location_;

          //@endcond
        };

        class BIOGEARS_CDM_API PericardialEffusionData: public ::mil::tatrc::physiology::datamodel::PatientActionData
        {
          public:

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

          typedef ::xsd::cxx::tree::traits< EffusionRate_type, char > EffusionRate_traits;

          const EffusionRate_type&
          EffusionRate () const;

          EffusionRate_type&
          EffusionRate ();

          void
          EffusionRate (const EffusionRate_type& x);

          void
          EffusionRate (::std::unique_ptr< EffusionRate_type > p);



          PericardialEffusionData ();

          PericardialEffusionData (const EffusionRate_type&);

          PericardialEffusionData (::std::unique_ptr< EffusionRate_type >);

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

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

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

          PericardialEffusionData&
          operator= (const PericardialEffusionData& x);


          virtual 
          ~PericardialEffusionData ();

          // Implementation.
          //

          //@cond

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

          protected:
          ::xsd::cxx::tree::one< EffusionRate_type > EffusionRate_;

          //@endcond
        };

        class BIOGEARS_CDM_API enumPneumothoraxType: public ::xml_schema::string
        {
          public:

          enum value
          {
            Open,
            Closed
          };

          enumPneumothoraxType ();

          enumPneumothoraxType (value v);

          enumPneumothoraxType (const char* v);

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

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

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

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

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

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

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

          enumPneumothoraxType&
          operator= (value v);

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

          //@cond

          protected:
          value
          _xsd_enumPneumothoraxType_convert () const;

          public:
          static const char* const _xsd_enumPneumothoraxType_literals_[2];
          static const value _xsd_enumPneumothoraxType_indexes_[2];

          //@endcond
        };

        class BIOGEARS_CDM_API TensionPneumothoraxData: public ::mil::tatrc::physiology::datamodel::PatientActionData
        {
          public:

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

          typedef ::xsd::cxx::tree::traits< Severity_type, char > Severity_traits;

          const Severity_type&
          Severity () const;

          Severity_type&
          Severity ();

          void
          Severity (const Severity_type& x);

          void
          Severity (::std::unique_ptr< Severity_type > p);



          typedef ::mil::tatrc::physiology::datamodel::enumPneumothoraxType Type_type;

          typedef ::xsd::cxx::tree::traits< Type_type, char > Type_traits;

          const Type_type&
          Type () const;

          Type_type&
          Type ();

          void
          Type (const Type_type& x);

          void
          Type (::std::unique_ptr< Type_type > p);



          typedef ::mil::tatrc::physiology::datamodel::enumSide Side_type;

          typedef ::xsd::cxx::tree::traits< Side_type, char > Side_traits;

          const Side_type&
          Side () const;

          Side_type&
          Side ();

          void
          Side (const Side_type& x);

          void
          Side (::std::unique_ptr< Side_type > p);



          TensionPneumothoraxData ();

          TensionPneumothoraxData (const Severity_type&,
                                   const Type_type&,
                                   const Side_type&);

          TensionPneumothoraxData (::std::unique_ptr< Severity_type >,
                                   const Type_type&,
                                   const Side_type&);

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

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

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

          TensionPneumothoraxData&
          operator= (const TensionPneumothoraxData& x);


          virtual 
          ~TensionPneumothoraxData ();

          // Implementation.
          //

          //@cond

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

          protected:
          ::xsd::cxx::tree::one< Severity_type > Severity_;
          ::xsd::cxx::tree::one< Type_type > Type_;
          ::xsd::cxx::tree::one< Side_type > Side_;

          //@endcond
        };

        class BIOGEARS_CDM_API SleepData: public ::mil::tatrc::physiology::datamodel::PatientActionData
        {
          public:

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

          typedef ::xsd::cxx::tree::traits< Sleep_type, char > Sleep_traits;

          const Sleep_type&
          Sleep () const;

          Sleep_type&
          Sleep ();

          void
          Sleep (const Sleep_type& x);

          void
          Sleep (::std::unique_ptr< Sleep_type > p);



          SleepData ();

          SleepData (const Sleep_type&);

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

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

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

          SleepData&
          operator= (const SleepData& x);


          virtual 
          ~SleepData ();

          // Implementation.
          //

          //@cond

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

          protected:
          ::xsd::cxx::tree::one< Sleep_type > Sleep_;

          //@endcond
        };

        class BIOGEARS_CDM_API enumBolusAdministration: public ::xml_schema::string
        {
          public:

          enum value
          {
            Intraarterial,
            Intramuscular,
            Intravenous
          };

          enumBolusAdministration ();

          enumBolusAdministration (value v);

          enumBolusAdministration (const char* v);

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

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

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

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

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

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

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

          enumBolusAdministration&
          operator= (value v);

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

          //@cond

          protected:
          value
          _xsd_enumBolusAdministration_convert () const;

          public:
          static const char* const _xsd_enumBolusAdministration_literals_[3];
          static const value _xsd_enumBolusAdministration_indexes_[3];

          //@endcond
        };

        class BIOGEARS_CDM_API enumOralAdministration: public ::xml_schema::string
        {
          public:

          enum value
          {
            Transmucosal,
            Gastrointestinal
          };

          enumOralAdministration ();

          enumOralAdministration (value v);

          enumOralAdministration (const char* v);

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

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

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

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

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

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

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

          enumOralAdministration&
          operator= (value v);

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

          //@cond

          protected:
          value
          _xsd_enumOralAdministration_convert () const;

          public:
          static const char* const _xsd_enumOralAdministration_literals_[2];
          static const value _xsd_enumOralAdministration_indexes_[2];

          //@endcond
        };

        class BIOGEARS_CDM_API SubstanceAdministrationData: public ::mil::tatrc::physiology::datamodel::PatientActionData
        {
          public:

          SubstanceAdministrationData ();

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

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

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


          virtual 
          ~SubstanceAdministrationData ();
        };

        class BIOGEARS_CDM_API SubstanceBolusData: public ::mil::tatrc::physiology::datamodel::SubstanceAdministrationData
        {
          public:

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



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

          typedef ::xsd::cxx::tree::traits< Concentration_type, char > Concentration_traits;

          const Concentration_type&
          Concentration () const;

          Concentration_type&
          Concentration ();

          void
          Concentration (const Concentration_type& x);

          void
          Concentration (::std::unique_ptr< Concentration_type > p);



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

          typedef ::xsd::cxx::tree::traits< Dose_type, char > Dose_traits;

          const Dose_type&
          Dose () const;

          Dose_type&
          Dose ();

          void
          Dose (const Dose_type& x);

          void
          Dose (::std::unique_ptr< Dose_type > p);



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

          typedef ::xsd::cxx::tree::optional< AdminTime_type > AdminTime_optional;

          typedef ::xsd::cxx::tree::traits< AdminTime_type, char > AdminTime_traits;

          const AdminTime_optional&
          AdminTime () const;

          AdminTime_optional&
          AdminTime ();

          void
          AdminTime (const AdminTime_type& x);

          void
          AdminTime (const AdminTime_optional& x);

          void
          AdminTime (::std::unique_ptr< AdminTime_type > p);



          typedef ::mil::tatrc::physiology::datamodel::enumBolusAdministration AdminRoute_type;

          typedef ::xsd::cxx::tree::traits< AdminRoute_type, char > AdminRoute_traits;

          const AdminRoute_type&
          AdminRoute () const;

          AdminRoute_type&
          AdminRoute ();

          void
          AdminRoute (const AdminRoute_type& x);

          void
          AdminRoute (::std::unique_ptr< AdminRoute_type > p);



          SubstanceBolusData ();

          SubstanceBolusData (const Substance_type&,
                              const Concentration_type&,
                              const Dose_type&,
                              const AdminRoute_type&);

          SubstanceBolusData (const Substance_type&,
                              ::std::unique_ptr< Concentration_type >,
                              ::std::unique_ptr< Dose_type >,
                              const AdminRoute_type&);

          SubstanceBolusData (::std::unique_ptr< Substance_type >,
                              ::std::unique_ptr< Concentration_type >,
                              ::std::unique_ptr< Dose_type >,
                              const AdminRoute_type&);

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

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

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

          SubstanceBolusData&
          operator= (const SubstanceBolusData& x);


          virtual 
          ~SubstanceBolusData ();

          // Implementation.
          //

          //@cond

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

          protected:
          ::xsd::cxx::tree::one< Substance_type > Substance_;
          ::xsd::cxx::tree::one< Concentration_type > Concentration_;
          ::xsd::cxx::tree::one< Dose_type > Dose_;
          AdminTime_optional AdminTime_;
          ::xsd::cxx::tree::one< AdminRoute_type > AdminRoute_;

          //@endcond
        };

        class BIOGEARS_CDM_API SubstanceBolusStateData: public ::xml_schema::type
        {
          public:

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

          typedef ::xsd::cxx::tree::traits< ElapsedTime_type, char > ElapsedTime_traits;

          const ElapsedTime_type&
          ElapsedTime () const;

          ElapsedTime_type&
          ElapsedTime ();

          void
          ElapsedTime (const ElapsedTime_type& x);

          void
          ElapsedTime (::std::unique_ptr< ElapsedTime_type > p);



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

          typedef ::xsd::cxx::tree::traits< AdministeredDose_type, char > AdministeredDose_traits;

          const AdministeredDose_type&
          AdministeredDose () const;

          AdministeredDose_type&
          AdministeredDose ();

          void
          AdministeredDose (const AdministeredDose_type& x);

          void
          AdministeredDose (::std::unique_ptr< AdministeredDose_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);



          SubstanceBolusStateData ();

          SubstanceBolusStateData (const ElapsedTime_type&,
                                   const AdministeredDose_type&,
                                   const Substance_type&);

          SubstanceBolusStateData (::std::unique_ptr< ElapsedTime_type >,
                                   ::std::unique_ptr< AdministeredDose_type >,
                                   const Substance_type&);

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

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

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

          SubstanceBolusStateData&
          operator= (const SubstanceBolusStateData& x);


          virtual 
          ~SubstanceBolusStateData ();

          // Implementation.
          //

          //@cond

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

          protected:
          ::xsd::cxx::tree::one< ElapsedTime_type > ElapsedTime_;
          ::xsd::cxx::tree::one< AdministeredDose_type > AdministeredDose_;
          ::xsd::cxx::tree::one< Substance_type > Substance_;

          //@endcond
        };

        class BIOGEARS_CDM_API SubstanceCompoundInfusionData: public ::mil::tatrc::physiology::datamodel::SubstanceAdministrationData
        {
          public:

          typedef ::xml_schema::string SubstanceCompound_type;

          typedef ::xsd::cxx::tree::traits< SubstanceCompound_type, char > SubstanceCompound_traits;

          const SubstanceCompound_type&
          SubstanceCompound () const;

          SubstanceCompound_type&
          SubstanceCompound ();

          void
          SubstanceCompound (const SubstanceCompound_type& x);

          void
          SubstanceCompound (::std::unique_ptr< SubstanceCompound_type > p);



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

          typedef ::xsd::cxx::tree::traits< BagVolume_type, char > BagVolume_traits;

          const BagVolume_type&
          BagVolume () const;

          BagVolume_type&
          BagVolume ();

          void
          BagVolume (const BagVolume_type& x);

          void
          BagVolume (::std::unique_ptr< BagVolume_type > p);



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

          typedef ::xsd::cxx::tree::traits< Rate_type, char > Rate_traits;

          const Rate_type&
          Rate () const;

          Rate_type&
          Rate ();

          void
          Rate (const Rate_type& x);

          void
          Rate (::std::unique_ptr< Rate_type > p);



          SubstanceCompoundInfusionData ();

          SubstanceCompoundInfusionData (const SubstanceCompound_type&,
                                         const BagVolume_type&,
                                         const Rate_type&);

          SubstanceCompoundInfusionData (const SubstanceCompound_type&,
                                         ::std::unique_ptr< BagVolume_type >,
                                         ::std::unique_ptr< Rate_type >);

          SubstanceCompoundInfusionData (::std::unique_ptr< SubstanceCompound_type >,
                                         ::std::unique_ptr< BagVolume_type >,
                                         ::std::unique_ptr< Rate_type >);

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

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

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

          SubstanceCompoundInfusionData&
          operator= (const SubstanceCompoundInfusionData& x);


          virtual 
          ~SubstanceCompoundInfusionData ();

          // Implementation.
          //

          //@cond

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

          protected:
          ::xsd::cxx::tree::one< SubstanceCompound_type > SubstanceCompound_;
          ::xsd::cxx::tree::one< BagVolume_type > BagVolume_;
          ::xsd::cxx::tree::one< Rate_type > Rate_;

          //@endcond
        };

        class BIOGEARS_CDM_API SubstanceInfusionData: public ::mil::tatrc::physiology::datamodel::SubstanceAdministrationData
        {
          public:

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



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

          typedef ::xsd::cxx::tree::traits< Concentration_type, char > Concentration_traits;

          const Concentration_type&
          Concentration () const;

          Concentration_type&
          Concentration ();

          void
          Concentration (const Concentration_type& x);

          void
          Concentration (::std::unique_ptr< Concentration_type > p);



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

          typedef ::xsd::cxx::tree::traits< Rate_type, char > Rate_traits;

          const Rate_type&
          Rate () const;

          Rate_type&
          Rate ();

          void
          Rate (const Rate_type& x);

          void
          Rate (::std::unique_ptr< Rate_type > p);



          SubstanceInfusionData ();

          SubstanceInfusionData (const Substance_type&,
                                 const Concentration_type&,
                                 const Rate_type&);

          SubstanceInfusionData (const Substance_type&,
                                 ::std::unique_ptr< Concentration_type >,
                                 ::std::unique_ptr< Rate_type >);

          SubstanceInfusionData (::std::unique_ptr< Substance_type >,
                                 ::std::unique_ptr< Concentration_type >,
                                 ::std::unique_ptr< Rate_type >);

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

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

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

          SubstanceInfusionData&
          operator= (const SubstanceInfusionData& x);


          virtual 
          ~SubstanceInfusionData ();

          // Implementation.
          //

          //@cond

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

          protected:
          ::xsd::cxx::tree::one< Substance_type > Substance_;
          ::xsd::cxx::tree::one< Concentration_type > Concentration_;
          ::xsd::cxx::tree::one< Rate_type > Rate_;

          //@endcond
        };

        class BIOGEARS_CDM_API SubstanceNasalDoseData: public ::mil::tatrc::physiology::datamodel::SubstanceAdministrationData
        {
          public:

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



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

          typedef ::xsd::cxx::tree::traits< Dose_type, char > Dose_traits;

          const Dose_type&
          Dose () const;

          Dose_type&
          Dose ();

          void
          Dose (const Dose_type& x);

          void
          Dose (::std::unique_ptr< Dose_type > p);



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

          typedef ::xsd::cxx::tree::optional< ElapsedTime_type > ElapsedTime_optional;

          typedef ::xsd::cxx::tree::traits< ElapsedTime_type, char > ElapsedTime_traits;

          const ElapsedTime_optional&
          ElapsedTime () const;

          ElapsedTime_optional&
          ElapsedTime ();

          void
          ElapsedTime (const ElapsedTime_type& x);

          void
          ElapsedTime (const ElapsedTime_optional& x);

          void
          ElapsedTime (::std::unique_ptr< ElapsedTime_type > p);



          SubstanceNasalDoseData ();

          SubstanceNasalDoseData (const Substance_type&,
                                  const Dose_type&);

          SubstanceNasalDoseData (const Substance_type&,
                                  ::std::unique_ptr< Dose_type >);

          SubstanceNasalDoseData (::std::unique_ptr< Substance_type >,
                                  ::std::unique_ptr< Dose_type >);

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

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

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

          SubstanceNasalDoseData&
          operator= (const SubstanceNasalDoseData& x);


          virtual 
          ~SubstanceNasalDoseData ();

          // Implementation.
          //

          //@cond

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

          protected:
          ::xsd::cxx::tree::one< Substance_type > Substance_;
          ::xsd::cxx::tree::one< Dose_type > Dose_;
          ElapsedTime_optional ElapsedTime_;

          //@endcond
        };

        class BIOGEARS_CDM_API SubstanceOralDoseData: public ::mil::tatrc::physiology::datamodel::SubstanceAdministrationData
        {
          public:

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



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

          typedef ::xsd::cxx::tree::traits< Dose_type, char > Dose_traits;

          const Dose_type&
          Dose () const;

          Dose_type&
          Dose ();

          void
          Dose (const Dose_type& x);

          void
          Dose (::std::unique_ptr< Dose_type > p);



          typedef ::mil::tatrc::physiology::datamodel::enumOralAdministration AdminRoute_type;

          typedef ::xsd::cxx::tree::traits< AdminRoute_type, char > AdminRoute_traits;

          const AdminRoute_type&
          AdminRoute () const;

          AdminRoute_type&
          AdminRoute ();

          void
          AdminRoute (const AdminRoute_type& x);

          void
          AdminRoute (::std::unique_ptr< AdminRoute_type > p);



          SubstanceOralDoseData ();

          SubstanceOralDoseData (const Substance_type&,
                                 const Dose_type&,
                                 const AdminRoute_type&);

          SubstanceOralDoseData (const Substance_type&,
                                 ::std::unique_ptr< Dose_type >,
                                 const AdminRoute_type&);

          SubstanceOralDoseData (::std::unique_ptr< Substance_type >,
                                 ::std::unique_ptr< Dose_type >,
                                 const AdminRoute_type&);

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

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

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

          SubstanceOralDoseData&
          operator= (const SubstanceOralDoseData& x);


          virtual 
          ~SubstanceOralDoseData ();

          // Implementation.
          //

          //@cond

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

          protected:
          ::xsd::cxx::tree::one< Substance_type > Substance_;
          ::xsd::cxx::tree::one< Dose_type > Dose_;
          ::xsd::cxx::tree::one< AdminRoute_type > AdminRoute_;

          //@endcond
        };

        class BIOGEARS_CDM_API enumTourniquetApplicationLevel: public ::xml_schema::string
        {
          public:

          enum value
          {
            Applied,
            Misapplied,
            None
          };

          enumTourniquetApplicationLevel ();

          enumTourniquetApplicationLevel (value v);

          enumTourniquetApplicationLevel (const char* v);

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

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

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

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

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

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

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

          enumTourniquetApplicationLevel&
          operator= (value v);

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

          //@cond

          protected:
          value
          _xsd_enumTourniquetApplicationLevel_convert () const;

          public:
          static const char* const _xsd_enumTourniquetApplicationLevel_literals_[3];
          static const value _xsd_enumTourniquetApplicationLevel_indexes_[3];

          //@endcond
        };

        class BIOGEARS_CDM_API TourniquetData: public ::mil::tatrc::physiology::datamodel::PatientActionData
        {
          public:

          typedef ::xml_schema::string Compartment_type;

          typedef ::xsd::cxx::tree::traits< Compartment_type, char > Compartment_traits;

          const Compartment_type&
          Compartment () const;

          Compartment_type&
          Compartment ();

          void
          Compartment (const Compartment_type& x);

          void
          Compartment (::std::unique_ptr< Compartment_type > p);



          typedef ::mil::tatrc::physiology::datamodel::enumTourniquetApplicationLevel TourniquetLevel_type;

          typedef ::xsd::cxx::tree::traits< TourniquetLevel_type, char > TourniquetLevel_traits;

          const TourniquetLevel_type&
          TourniquetLevel () const;

          TourniquetLevel_type&
          TourniquetLevel ();

          void
          TourniquetLevel (const TourniquetLevel_type& x);

          void
          TourniquetLevel (::std::unique_ptr< TourniquetLevel_type > p);



          TourniquetData ();

          TourniquetData (const Compartment_type&,
                          const TourniquetLevel_type&);

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

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

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

          TourniquetData&
          operator= (const TourniquetData& x);


          virtual 
          ~TourniquetData ();

          // Implementation.
          //

          //@cond

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

          protected:
          ::xsd::cxx::tree::one< Compartment_type > Compartment_;
          ::xsd::cxx::tree::one< TourniquetLevel_type > TourniquetLevel_;

          //@endcond
        };

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

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

          typedef ::xsd::cxx::tree::traits< MouthSolidMass_type, char > MouthSolidMass_traits;

          const MouthSolidMass_type&
          MouthSolidMass () const;

          MouthSolidMass_type&
          MouthSolidMass ();

          void
          MouthSolidMass (const MouthSolidMass_type& x);

          void
          MouthSolidMass (::std::unique_ptr< MouthSolidMass_type > p);



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

          typedef ::xsd::cxx::tree::traits< SalivaConcentration_type, char > SalivaConcentration_traits;

          const SalivaConcentration_type&
          SalivaConcentration () const;

          SalivaConcentration_type&
          SalivaConcentration ();

          void
          SalivaConcentration (const SalivaConcentration_type& x);

          void
          SalivaConcentration (::std::unique_ptr< SalivaConcentration_type > p);



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

          typedef ::xsd::cxx::tree::sequence< BuccalConcentrations_type > BuccalConcentrations_sequence;

          typedef BuccalConcentrations_sequence::iterator BuccalConcentrations_iterator;

          typedef BuccalConcentrations_sequence::const_iterator BuccalConcentrations_const_iterator;

          typedef ::xsd::cxx::tree::traits< BuccalConcentrations_type, char > BuccalConcentrations_traits;

          const BuccalConcentrations_sequence&
          BuccalConcentrations () const;

          BuccalConcentrations_sequence&
          BuccalConcentrations ();

          void
          BuccalConcentrations (const BuccalConcentrations_sequence& s);



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

          typedef ::xsd::cxx::tree::sequence< SublingualConcentrations_type > SublingualConcentrations_sequence;

          typedef SublingualConcentrations_sequence::iterator SublingualConcentrations_iterator;

          typedef SublingualConcentrations_sequence::const_iterator SublingualConcentrations_const_iterator;

          typedef ::xsd::cxx::tree::traits< SublingualConcentrations_type, char > SublingualConcentrations_traits;

          const SublingualConcentrations_sequence&
          SublingualConcentrations () const;

          SublingualConcentrations_sequence&
          SublingualConcentrations ();

          void
          SublingualConcentrations (const SublingualConcentrations_sequence& s);



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



          TransmucosalStateData ();

          TransmucosalStateData (const MouthSolidMass_type&,
                                 const SalivaConcentration_type&,
                                 const Substance_type&);

          TransmucosalStateData (::std::unique_ptr< MouthSolidMass_type >,
                                 ::std::unique_ptr< SalivaConcentration_type >,
                                 const Substance_type&);

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

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

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

          TransmucosalStateData&
          operator= (const TransmucosalStateData& x);


          virtual 
          ~TransmucosalStateData ();

          // Implementation.
          //

          //@cond

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

          protected:
          ::xsd::cxx::tree::one< MouthSolidMass_type > MouthSolidMass_;
          ::xsd::cxx::tree::one< SalivaConcentration_type > SalivaConcentration_;
          BuccalConcentrations_sequence BuccalConcentrations_;
          SublingualConcentrations_sequence SublingualConcentrations_;
          ::xsd::cxx::tree::one< Substance_type > Substance_;

          //@endcond
        };

        class BIOGEARS_CDM_API UrinateData: public ::mil::tatrc::physiology::datamodel::PatientActionData
        {
          public:

          UrinateData ();

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

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

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


          virtual 
          ~UrinateData ();
        };

        class BIOGEARS_CDM_API OverrideData: public ::mil::tatrc::physiology::datamodel::PatientActionData
        {
          public:

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

          typedef ::xsd::cxx::tree::optional< ArterialBloodPHOverride_type > ArterialBloodPHOverride_optional;

          typedef ::xsd::cxx::tree::traits< ArterialBloodPHOverride_type, char > ArterialBloodPHOverride_traits;

          const ArterialBloodPHOverride_optional&
          ArterialBloodPHOverride () const;

          ArterialBloodPHOverride_optional&
          ArterialBloodPHOverride ();

          void
          ArterialBloodPHOverride (const ArterialBloodPHOverride_type& x);

          void
          ArterialBloodPHOverride (const ArterialBloodPHOverride_optional& x);

          void
          ArterialBloodPHOverride (::std::unique_ptr< ArterialBloodPHOverride_type > p);



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

          typedef ::xsd::cxx::tree::optional< CalciumConcentrationOverride_type > CalciumConcentrationOverride_optional;

          typedef ::xsd::cxx::tree::traits< CalciumConcentrationOverride_type, char > CalciumConcentrationOverride_traits;

          const CalciumConcentrationOverride_optional&
          CalciumConcentrationOverride () const;

          CalciumConcentrationOverride_optional&
          CalciumConcentrationOverride ();

          void
          CalciumConcentrationOverride (const CalciumConcentrationOverride_type& x);

          void
          CalciumConcentrationOverride (const CalciumConcentrationOverride_optional& x);

          void
          CalciumConcentrationOverride (::std::unique_ptr< CalciumConcentrationOverride_type > p);



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

          typedef ::xsd::cxx::tree::optional< CarbonDioxideSaturationOverride_type > CarbonDioxideSaturationOverride_optional;

          typedef ::xsd::cxx::tree::traits< CarbonDioxideSaturationOverride_type, char > CarbonDioxideSaturationOverride_traits;

          const CarbonDioxideSaturationOverride_optional&
          CarbonDioxideSaturationOverride () const;

          CarbonDioxideSaturationOverride_optional&
          CarbonDioxideSaturationOverride ();

          void
          CarbonDioxideSaturationOverride (const CarbonDioxideSaturationOverride_type& x);

          void
          CarbonDioxideSaturationOverride (const CarbonDioxideSaturationOverride_optional& x);

          void
          CarbonDioxideSaturationOverride (::std::unique_ptr< CarbonDioxideSaturationOverride_type > p);



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

          typedef ::xsd::cxx::tree::optional< CarbonMonoxideSaturationOverride_type > CarbonMonoxideSaturationOverride_optional;

          typedef ::xsd::cxx::tree::traits< CarbonMonoxideSaturationOverride_type, char > CarbonMonoxideSaturationOverride_traits;

          const CarbonMonoxideSaturationOverride_optional&
          CarbonMonoxideSaturationOverride () const;

          CarbonMonoxideSaturationOverride_optional&
          CarbonMonoxideSaturationOverride ();

          void
          CarbonMonoxideSaturationOverride (const CarbonMonoxideSaturationOverride_type& x);

          void
          CarbonMonoxideSaturationOverride (const CarbonMonoxideSaturationOverride_optional& x);

          void
          CarbonMonoxideSaturationOverride (::std::unique_ptr< CarbonMonoxideSaturationOverride_type > p);



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

          typedef ::xsd::cxx::tree::optional< GlucoseConcentrationOverride_type > GlucoseConcentrationOverride_optional;

          typedef ::xsd::cxx::tree::traits< GlucoseConcentrationOverride_type, char > GlucoseConcentrationOverride_traits;

          const GlucoseConcentrationOverride_optional&
          GlucoseConcentrationOverride () const;

          GlucoseConcentrationOverride_optional&
          GlucoseConcentrationOverride ();

          void
          GlucoseConcentrationOverride (const GlucoseConcentrationOverride_type& x);

          void
          GlucoseConcentrationOverride (const GlucoseConcentrationOverride_optional& x);

          void
          GlucoseConcentrationOverride (::std::unique_ptr< GlucoseConcentrationOverride_type > p);



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

          typedef ::xsd::cxx::tree::optional< LactateConcentrationOverride_type > LactateConcentrationOverride_optional;

          typedef ::xsd::cxx::tree::traits< LactateConcentrationOverride_type, char > LactateConcentrationOverride_traits;

          const LactateConcentrationOverride_optional&
          LactateConcentrationOverride () const;

          LactateConcentrationOverride_optional&
          LactateConcentrationOverride ();

          void
          LactateConcentrationOverride (const LactateConcentrationOverride_type& x);

          void
          LactateConcentrationOverride (const LactateConcentrationOverride_optional& x);

          void
          LactateConcentrationOverride (::std::unique_ptr< LactateConcentrationOverride_type > p);



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

          typedef ::xsd::cxx::tree::optional< OxygenSaturationOverride_type > OxygenSaturationOverride_optional;

          typedef ::xsd::cxx::tree::traits< OxygenSaturationOverride_type, char > OxygenSaturationOverride_traits;

          const OxygenSaturationOverride_optional&
          OxygenSaturationOverride () const;

          OxygenSaturationOverride_optional&
          OxygenSaturationOverride ();

          void
          OxygenSaturationOverride (const OxygenSaturationOverride_type& x);

          void
          OxygenSaturationOverride (const OxygenSaturationOverride_optional& x);

          void
          OxygenSaturationOverride (::std::unique_ptr< OxygenSaturationOverride_type > p);



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

          typedef ::xsd::cxx::tree::optional< PhosphateOverride_type > PhosphateOverride_optional;

          typedef ::xsd::cxx::tree::traits< PhosphateOverride_type, char > PhosphateOverride_traits;

          const PhosphateOverride_optional&
          PhosphateOverride () const;

          PhosphateOverride_optional&
          PhosphateOverride ();

          void
          PhosphateOverride (const PhosphateOverride_type& x);

          void
          PhosphateOverride (const PhosphateOverride_optional& x);

          void
          PhosphateOverride (::std::unique_ptr< PhosphateOverride_type > p);



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

          typedef ::xsd::cxx::tree::optional< PotassiumConcentrationOverride_type > PotassiumConcentrationOverride_optional;

          typedef ::xsd::cxx::tree::traits< PotassiumConcentrationOverride_type, char > PotassiumConcentrationOverride_traits;

          const PotassiumConcentrationOverride_optional&
          PotassiumConcentrationOverride () const;

          PotassiumConcentrationOverride_optional&
          PotassiumConcentrationOverride ();

          void
          PotassiumConcentrationOverride (const PotassiumConcentrationOverride_type& x);

          void
          PotassiumConcentrationOverride (const PotassiumConcentrationOverride_optional& x);

          void
          PotassiumConcentrationOverride (::std::unique_ptr< PotassiumConcentrationOverride_type > p);



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

          typedef ::xsd::cxx::tree::optional< SodiumConcentrationOverride_type > SodiumConcentrationOverride_optional;

          typedef ::xsd::cxx::tree::traits< SodiumConcentrationOverride_type, char > SodiumConcentrationOverride_traits;

          const SodiumConcentrationOverride_optional&
          SodiumConcentrationOverride () const;

          SodiumConcentrationOverride_optional&
          SodiumConcentrationOverride ();

          void
          SodiumConcentrationOverride (const SodiumConcentrationOverride_type& x);

          void
          SodiumConcentrationOverride (const SodiumConcentrationOverride_optional& x);

          void
          SodiumConcentrationOverride (::std::unique_ptr< SodiumConcentrationOverride_type > p);



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

          typedef ::xsd::cxx::tree::optional< TotalBilirubinOverride_type > TotalBilirubinOverride_optional;

          typedef ::xsd::cxx::tree::traits< TotalBilirubinOverride_type, char > TotalBilirubinOverride_traits;

          const TotalBilirubinOverride_optional&
          TotalBilirubinOverride () const;

          TotalBilirubinOverride_optional&
          TotalBilirubinOverride ();

          void
          TotalBilirubinOverride (const TotalBilirubinOverride_type& x);

          void
          TotalBilirubinOverride (const TotalBilirubinOverride_optional& x);

          void
          TotalBilirubinOverride (::std::unique_ptr< TotalBilirubinOverride_type > p);



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

          typedef ::xsd::cxx::tree::optional< VenousBloodPHOverride_type > VenousBloodPHOverride_optional;

          typedef ::xsd::cxx::tree::traits< VenousBloodPHOverride_type, char > VenousBloodPHOverride_traits;

          const VenousBloodPHOverride_optional&
          VenousBloodPHOverride () const;

          VenousBloodPHOverride_optional&
          VenousBloodPHOverride ();

          void
          VenousBloodPHOverride (const VenousBloodPHOverride_type& x);

          void
          VenousBloodPHOverride (const VenousBloodPHOverride_optional& x);

          void
          VenousBloodPHOverride (::std::unique_ptr< VenousBloodPHOverride_type > p);



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

          typedef ::xsd::cxx::tree::optional< WhiteBloodCellCountOverride_type > WhiteBloodCellCountOverride_optional;

          typedef ::xsd::cxx::tree::traits< WhiteBloodCellCountOverride_type, char > WhiteBloodCellCountOverride_traits;

          const WhiteBloodCellCountOverride_optional&
          WhiteBloodCellCountOverride () const;

          WhiteBloodCellCountOverride_optional&
          WhiteBloodCellCountOverride ();

          void
          WhiteBloodCellCountOverride (const WhiteBloodCellCountOverride_type& x);

          void
          WhiteBloodCellCountOverride (const WhiteBloodCellCountOverride_optional& x);

          void
          WhiteBloodCellCountOverride (::std::unique_ptr< WhiteBloodCellCountOverride_type > p);



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

          typedef ::xsd::cxx::tree::optional< BloodVolumeOverride_type > BloodVolumeOverride_optional;

          typedef ::xsd::cxx::tree::traits< BloodVolumeOverride_type, char > BloodVolumeOverride_traits;

          const BloodVolumeOverride_optional&
          BloodVolumeOverride () const;

          BloodVolumeOverride_optional&
          BloodVolumeOverride ();

          void
          BloodVolumeOverride (const BloodVolumeOverride_type& x);

          void
          BloodVolumeOverride (const BloodVolumeOverride_optional& x);

          void
          BloodVolumeOverride (::std::unique_ptr< BloodVolumeOverride_type > p);



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

          typedef ::xsd::cxx::tree::optional< CardiacOutputOverride_type > CardiacOutputOverride_optional;

          typedef ::xsd::cxx::tree::traits< CardiacOutputOverride_type, char > CardiacOutputOverride_traits;

          const CardiacOutputOverride_optional&
          CardiacOutputOverride () const;

          CardiacOutputOverride_optional&
          CardiacOutputOverride ();

          void
          CardiacOutputOverride (const CardiacOutputOverride_type& x);

          void
          CardiacOutputOverride (const CardiacOutputOverride_optional& x);

          void
          CardiacOutputOverride (::std::unique_ptr< CardiacOutputOverride_type > p);



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

          typedef ::xsd::cxx::tree::optional< DiastolicArterialPressureOverride_type > DiastolicArterialPressureOverride_optional;

          typedef ::xsd::cxx::tree::traits< DiastolicArterialPressureOverride_type, char > DiastolicArterialPressureOverride_traits;

          const DiastolicArterialPressureOverride_optional&
          DiastolicArterialPressureOverride () const;

          DiastolicArterialPressureOverride_optional&
          DiastolicArterialPressureOverride ();

          void
          DiastolicArterialPressureOverride (const DiastolicArterialPressureOverride_type& x);

          void
          DiastolicArterialPressureOverride (const DiastolicArterialPressureOverride_optional& x);

          void
          DiastolicArterialPressureOverride (::std::unique_ptr< DiastolicArterialPressureOverride_type > p);



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

          typedef ::xsd::cxx::tree::optional< HeartRateOverride_type > HeartRateOverride_optional;

          typedef ::xsd::cxx::tree::traits< HeartRateOverride_type, char > HeartRateOverride_traits;

          const HeartRateOverride_optional&
          HeartRateOverride () const;

          HeartRateOverride_optional&
          HeartRateOverride ();

          void
          HeartRateOverride (const HeartRateOverride_type& x);

          void
          HeartRateOverride (const HeartRateOverride_optional& x);

          void
          HeartRateOverride (::std::unique_ptr< HeartRateOverride_type > p);



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

          typedef ::xsd::cxx::tree::optional< HeartStrokeVolumeOverride_type > HeartStrokeVolumeOverride_optional;

          typedef ::xsd::cxx::tree::traits< HeartStrokeVolumeOverride_type, char > HeartStrokeVolumeOverride_traits;

          const HeartStrokeVolumeOverride_optional&
          HeartStrokeVolumeOverride () const;

          HeartStrokeVolumeOverride_optional&
          HeartStrokeVolumeOverride ();

          void
          HeartStrokeVolumeOverride (const HeartStrokeVolumeOverride_type& x);

          void
          HeartStrokeVolumeOverride (const HeartStrokeVolumeOverride_optional& x);

          void
          HeartStrokeVolumeOverride (::std::unique_ptr< HeartStrokeVolumeOverride_type > p);



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

          typedef ::xsd::cxx::tree::optional< MeanArterialPressureOverride_type > MeanArterialPressureOverride_optional;

          typedef ::xsd::cxx::tree::traits< MeanArterialPressureOverride_type, char > MeanArterialPressureOverride_traits;

          const MeanArterialPressureOverride_optional&
          MeanArterialPressureOverride () const;

          MeanArterialPressureOverride_optional&
          MeanArterialPressureOverride ();

          void
          MeanArterialPressureOverride (const MeanArterialPressureOverride_type& x);

          void
          MeanArterialPressureOverride (const MeanArterialPressureOverride_optional& x);

          void
          MeanArterialPressureOverride (::std::unique_ptr< MeanArterialPressureOverride_type > p);



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

          typedef ::xsd::cxx::tree::optional< SystolicArterialPressureOverride_type > SystolicArterialPressureOverride_optional;

          typedef ::xsd::cxx::tree::traits< SystolicArterialPressureOverride_type, char > SystolicArterialPressureOverride_traits;

          const SystolicArterialPressureOverride_optional&
          SystolicArterialPressureOverride () const;

          SystolicArterialPressureOverride_optional&
          SystolicArterialPressureOverride ();

          void
          SystolicArterialPressureOverride (const SystolicArterialPressureOverride_type& x);

          void
          SystolicArterialPressureOverride (const SystolicArterialPressureOverride_optional& x);

          void
          SystolicArterialPressureOverride (::std::unique_ptr< SystolicArterialPressureOverride_type > p);



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

          typedef ::xsd::cxx::tree::optional< InsulinSynthesisRateOverride_type > InsulinSynthesisRateOverride_optional;

          typedef ::xsd::cxx::tree::traits< InsulinSynthesisRateOverride_type, char > InsulinSynthesisRateOverride_traits;

          const InsulinSynthesisRateOverride_optional&
          InsulinSynthesisRateOverride () const;

          InsulinSynthesisRateOverride_optional&
          InsulinSynthesisRateOverride ();

          void
          InsulinSynthesisRateOverride (const InsulinSynthesisRateOverride_type& x);

          void
          InsulinSynthesisRateOverride (const InsulinSynthesisRateOverride_optional& x);

          void
          InsulinSynthesisRateOverride (::std::unique_ptr< InsulinSynthesisRateOverride_type > p);



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

          typedef ::xsd::cxx::tree::optional< GlucagonSynthesisRateOverride_type > GlucagonSynthesisRateOverride_optional;

          typedef ::xsd::cxx::tree::traits< GlucagonSynthesisRateOverride_type, char > GlucagonSynthesisRateOverride_traits;

          const GlucagonSynthesisRateOverride_optional&
          GlucagonSynthesisRateOverride () const;

          GlucagonSynthesisRateOverride_optional&
          GlucagonSynthesisRateOverride ();

          void
          GlucagonSynthesisRateOverride (const GlucagonSynthesisRateOverride_type& x);

          void
          GlucagonSynthesisRateOverride (const GlucagonSynthesisRateOverride_optional& x);

          void
          GlucagonSynthesisRateOverride (::std::unique_ptr< GlucagonSynthesisRateOverride_type > p);



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

          typedef ::xsd::cxx::tree::optional< AchievedExerciseLevelOverride_type > AchievedExerciseLevelOverride_optional;

          typedef ::xsd::cxx::tree::traits< AchievedExerciseLevelOverride_type, char > AchievedExerciseLevelOverride_traits;

          const AchievedExerciseLevelOverride_optional&
          AchievedExerciseLevelOverride () const;

          AchievedExerciseLevelOverride_optional&
          AchievedExerciseLevelOverride ();

          void
          AchievedExerciseLevelOverride (const AchievedExerciseLevelOverride_type& x);

          void
          AchievedExerciseLevelOverride (const AchievedExerciseLevelOverride_optional& x);

          void
          AchievedExerciseLevelOverride (::std::unique_ptr< AchievedExerciseLevelOverride_type > p);



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

          typedef ::xsd::cxx::tree::optional< ChlorideLostToSweatOverride_type > ChlorideLostToSweatOverride_optional;

          typedef ::xsd::cxx::tree::traits< ChlorideLostToSweatOverride_type, char > ChlorideLostToSweatOverride_traits;

          const ChlorideLostToSweatOverride_optional&
          ChlorideLostToSweatOverride () const;

          ChlorideLostToSweatOverride_optional&
          ChlorideLostToSweatOverride ();

          void
          ChlorideLostToSweatOverride (const ChlorideLostToSweatOverride_type& x);

          void
          ChlorideLostToSweatOverride (const ChlorideLostToSweatOverride_optional& x);

          void
          ChlorideLostToSweatOverride (::std::unique_ptr< ChlorideLostToSweatOverride_type > p);



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

          typedef ::xsd::cxx::tree::optional< CoreTemperatureOverride_type > CoreTemperatureOverride_optional;

          typedef ::xsd::cxx::tree::traits< CoreTemperatureOverride_type, char > CoreTemperatureOverride_traits;

          const CoreTemperatureOverride_optional&
          CoreTemperatureOverride () const;

          CoreTemperatureOverride_optional&
          CoreTemperatureOverride ();

          void
          CoreTemperatureOverride (const CoreTemperatureOverride_type& x);

          void
          CoreTemperatureOverride (const CoreTemperatureOverride_optional& x);

          void
          CoreTemperatureOverride (::std::unique_ptr< CoreTemperatureOverride_type > p);



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

          typedef ::xsd::cxx::tree::optional< CreatinineProductionRateOverride_type > CreatinineProductionRateOverride_optional;

          typedef ::xsd::cxx::tree::traits< CreatinineProductionRateOverride_type, char > CreatinineProductionRateOverride_traits;

          const CreatinineProductionRateOverride_optional&
          CreatinineProductionRateOverride () const;

          CreatinineProductionRateOverride_optional&
          CreatinineProductionRateOverride ();

          void
          CreatinineProductionRateOverride (const CreatinineProductionRateOverride_type& x);

          void
          CreatinineProductionRateOverride (const CreatinineProductionRateOverride_optional& x);

          void
          CreatinineProductionRateOverride (::std::unique_ptr< CreatinineProductionRateOverride_type > p);



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

          typedef ::xsd::cxx::tree::optional< ExerciseMeanArterialPressureDeltaOverride_type > ExerciseMeanArterialPressureDeltaOverride_optional;

          typedef ::xsd::cxx::tree::traits< ExerciseMeanArterialPressureDeltaOverride_type, char > ExerciseMeanArterialPressureDeltaOverride_traits;

          const ExerciseMeanArterialPressureDeltaOverride_optional&
          ExerciseMeanArterialPressureDeltaOverride () const;

          ExerciseMeanArterialPressureDeltaOverride_optional&
          ExerciseMeanArterialPressureDeltaOverride ();

          void
          ExerciseMeanArterialPressureDeltaOverride (const ExerciseMeanArterialPressureDeltaOverride_type& x);

          void
          ExerciseMeanArterialPressureDeltaOverride (const ExerciseMeanArterialPressureDeltaOverride_optional& x);

          void
          ExerciseMeanArterialPressureDeltaOverride (::std::unique_ptr< ExerciseMeanArterialPressureDeltaOverride_type > p);



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

          typedef ::xsd::cxx::tree::optional< FatigueLevelOverride_type > FatigueLevelOverride_optional;

          typedef ::xsd::cxx::tree::traits< FatigueLevelOverride_type, char > FatigueLevelOverride_traits;

          const FatigueLevelOverride_optional&
          FatigueLevelOverride () const;

          FatigueLevelOverride_optional&
          FatigueLevelOverride ();

          void
          FatigueLevelOverride (const FatigueLevelOverride_type& x);

          void
          FatigueLevelOverride (const FatigueLevelOverride_optional& x);

          void
          FatigueLevelOverride (::std::unique_ptr< FatigueLevelOverride_type > p);



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

          typedef ::xsd::cxx::tree::optional< LactateProductionRateOverride_type > LactateProductionRateOverride_optional;

          typedef ::xsd::cxx::tree::traits< LactateProductionRateOverride_type, char > LactateProductionRateOverride_traits;

          const LactateProductionRateOverride_optional&
          LactateProductionRateOverride () const;

          LactateProductionRateOverride_optional&
          LactateProductionRateOverride ();

          void
          LactateProductionRateOverride (const LactateProductionRateOverride_type& x);

          void
          LactateProductionRateOverride (const LactateProductionRateOverride_optional& x);

          void
          LactateProductionRateOverride (::std::unique_ptr< LactateProductionRateOverride_type > p);



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

          typedef ::xsd::cxx::tree::optional< PotassiumLostToSweatOverride_type > PotassiumLostToSweatOverride_optional;

          typedef ::xsd::cxx::tree::traits< PotassiumLostToSweatOverride_type, char > PotassiumLostToSweatOverride_traits;

          const PotassiumLostToSweatOverride_optional&
          PotassiumLostToSweatOverride () const;

          PotassiumLostToSweatOverride_optional&
          PotassiumLostToSweatOverride ();

          void
          PotassiumLostToSweatOverride (const PotassiumLostToSweatOverride_type& x);

          void
          PotassiumLostToSweatOverride (const PotassiumLostToSweatOverride_optional& x);

          void
          PotassiumLostToSweatOverride (::std::unique_ptr< PotassiumLostToSweatOverride_type > p);



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

          typedef ::xsd::cxx::tree::optional< SkinTemperatureOverride_type > SkinTemperatureOverride_optional;

          typedef ::xsd::cxx::tree::traits< SkinTemperatureOverride_type, char > SkinTemperatureOverride_traits;

          const SkinTemperatureOverride_optional&
          SkinTemperatureOverride () const;

          SkinTemperatureOverride_optional&
          SkinTemperatureOverride ();

          void
          SkinTemperatureOverride (const SkinTemperatureOverride_type& x);

          void
          SkinTemperatureOverride (const SkinTemperatureOverride_optional& x);

          void
          SkinTemperatureOverride (::std::unique_ptr< SkinTemperatureOverride_type > p);



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

          typedef ::xsd::cxx::tree::optional< SodiumLostToSweatOverride_type > SodiumLostToSweatOverride_optional;

          typedef ::xsd::cxx::tree::traits< SodiumLostToSweatOverride_type, char > SodiumLostToSweatOverride_traits;

          const SodiumLostToSweatOverride_optional&
          SodiumLostToSweatOverride () const;

          SodiumLostToSweatOverride_optional&
          SodiumLostToSweatOverride ();

          void
          SodiumLostToSweatOverride (const SodiumLostToSweatOverride_type& x);

          void
          SodiumLostToSweatOverride (const SodiumLostToSweatOverride_optional& x);

          void
          SodiumLostToSweatOverride (::std::unique_ptr< SodiumLostToSweatOverride_type > p);



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

          typedef ::xsd::cxx::tree::optional< SweatRateOverride_type > SweatRateOverride_optional;

          typedef ::xsd::cxx::tree::traits< SweatRateOverride_type, char > SweatRateOverride_traits;

          const SweatRateOverride_optional&
          SweatRateOverride () const;

          SweatRateOverride_optional&
          SweatRateOverride ();

          void
          SweatRateOverride (const SweatRateOverride_type& x);

          void
          SweatRateOverride (const SweatRateOverride_optional& x);

          void
          SweatRateOverride (::std::unique_ptr< SweatRateOverride_type > p);



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

          typedef ::xsd::cxx::tree::optional< TotalMetabolicRateOverride_type > TotalMetabolicRateOverride_optional;

          typedef ::xsd::cxx::tree::traits< TotalMetabolicRateOverride_type, char > TotalMetabolicRateOverride_traits;

          const TotalMetabolicRateOverride_optional&
          TotalMetabolicRateOverride () const;

          TotalMetabolicRateOverride_optional&
          TotalMetabolicRateOverride ();

          void
          TotalMetabolicRateOverride (const TotalMetabolicRateOverride_type& x);

          void
          TotalMetabolicRateOverride (const TotalMetabolicRateOverride_optional& x);

          void
          TotalMetabolicRateOverride (::std::unique_ptr< TotalMetabolicRateOverride_type > p);



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

          typedef ::xsd::cxx::tree::optional< TotalWorkRateLevelOverride_type > TotalWorkRateLevelOverride_optional;

          typedef ::xsd::cxx::tree::traits< TotalWorkRateLevelOverride_type, char > TotalWorkRateLevelOverride_traits;

          const TotalWorkRateLevelOverride_optional&
          TotalWorkRateLevelOverride () const;

          TotalWorkRateLevelOverride_optional&
          TotalWorkRateLevelOverride ();

          void
          TotalWorkRateLevelOverride (const TotalWorkRateLevelOverride_type& x);

          void
          TotalWorkRateLevelOverride (const TotalWorkRateLevelOverride_optional& x);

          void
          TotalWorkRateLevelOverride (::std::unique_ptr< TotalWorkRateLevelOverride_type > p);



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

          typedef ::xsd::cxx::tree::optional< LeftAfferentArterioleResistanceOverride_type > LeftAfferentArterioleResistanceOverride_optional;

          typedef ::xsd::cxx::tree::traits< LeftAfferentArterioleResistanceOverride_type, char > LeftAfferentArterioleResistanceOverride_traits;

          const LeftAfferentArterioleResistanceOverride_optional&
          LeftAfferentArterioleResistanceOverride () const;

          LeftAfferentArterioleResistanceOverride_optional&
          LeftAfferentArterioleResistanceOverride ();

          void
          LeftAfferentArterioleResistanceOverride (const LeftAfferentArterioleResistanceOverride_type& x);

          void
          LeftAfferentArterioleResistanceOverride (const LeftAfferentArterioleResistanceOverride_optional& x);

          void
          LeftAfferentArterioleResistanceOverride (::std::unique_ptr< LeftAfferentArterioleResistanceOverride_type > p);



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

          typedef ::xsd::cxx::tree::optional< LeftGlomerularFiltrationRateOverride_type > LeftGlomerularFiltrationRateOverride_optional;

          typedef ::xsd::cxx::tree::traits< LeftGlomerularFiltrationRateOverride_type, char > LeftGlomerularFiltrationRateOverride_traits;

          const LeftGlomerularFiltrationRateOverride_optional&
          LeftGlomerularFiltrationRateOverride () const;

          LeftGlomerularFiltrationRateOverride_optional&
          LeftGlomerularFiltrationRateOverride ();

          void
          LeftGlomerularFiltrationRateOverride (const LeftGlomerularFiltrationRateOverride_type& x);

          void
          LeftGlomerularFiltrationRateOverride (const LeftGlomerularFiltrationRateOverride_optional& x);

          void
          LeftGlomerularFiltrationRateOverride (::std::unique_ptr< LeftGlomerularFiltrationRateOverride_type > p);



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

          typedef ::xsd::cxx::tree::optional< LeftReabsorptionRateOverride_type > LeftReabsorptionRateOverride_optional;

          typedef ::xsd::cxx::tree::traits< LeftReabsorptionRateOverride_type, char > LeftReabsorptionRateOverride_traits;

          const LeftReabsorptionRateOverride_optional&
          LeftReabsorptionRateOverride () const;

          LeftReabsorptionRateOverride_optional&
          LeftReabsorptionRateOverride ();

          void
          LeftReabsorptionRateOverride (const LeftReabsorptionRateOverride_type& x);

          void
          LeftReabsorptionRateOverride (const LeftReabsorptionRateOverride_optional& x);

          void
          LeftReabsorptionRateOverride (::std::unique_ptr< LeftReabsorptionRateOverride_type > p);



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

          typedef ::xsd::cxx::tree::optional< RenalBloodFlowOverride_type > RenalBloodFlowOverride_optional;

          typedef ::xsd::cxx::tree::traits< RenalBloodFlowOverride_type, char > RenalBloodFlowOverride_traits;

          const RenalBloodFlowOverride_optional&
          RenalBloodFlowOverride () const;

          RenalBloodFlowOverride_optional&
          RenalBloodFlowOverride ();

          void
          RenalBloodFlowOverride (const RenalBloodFlowOverride_type& x);

          void
          RenalBloodFlowOverride (const RenalBloodFlowOverride_optional& x);

          void
          RenalBloodFlowOverride (::std::unique_ptr< RenalBloodFlowOverride_type > p);



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

          typedef ::xsd::cxx::tree::optional< RenalPlasmaFlowOverride_type > RenalPlasmaFlowOverride_optional;

          typedef ::xsd::cxx::tree::traits< RenalPlasmaFlowOverride_type, char > RenalPlasmaFlowOverride_traits;

          const RenalPlasmaFlowOverride_optional&
          RenalPlasmaFlowOverride () const;

          RenalPlasmaFlowOverride_optional&
          RenalPlasmaFlowOverride ();

          void
          RenalPlasmaFlowOverride (const RenalPlasmaFlowOverride_type& x);

          void
          RenalPlasmaFlowOverride (const RenalPlasmaFlowOverride_optional& x);

          void
          RenalPlasmaFlowOverride (::std::unique_ptr< RenalPlasmaFlowOverride_type > p);



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

          typedef ::xsd::cxx::tree::optional< RightAfferentArterioleResistanceOverride_type > RightAfferentArterioleResistanceOverride_optional;

          typedef ::xsd::cxx::tree::traits< RightAfferentArterioleResistanceOverride_type, char > RightAfferentArterioleResistanceOverride_traits;

          const RightAfferentArterioleResistanceOverride_optional&
          RightAfferentArterioleResistanceOverride () const;

          RightAfferentArterioleResistanceOverride_optional&
          RightAfferentArterioleResistanceOverride ();

          void
          RightAfferentArterioleResistanceOverride (const RightAfferentArterioleResistanceOverride_type& x);

          void
          RightAfferentArterioleResistanceOverride (const RightAfferentArterioleResistanceOverride_optional& x);

          void
          RightAfferentArterioleResistanceOverride (::std::unique_ptr< RightAfferentArterioleResistanceOverride_type > p);



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

          typedef ::xsd::cxx::tree::optional< RightGlomerularFiltrationRateOverride_type > RightGlomerularFiltrationRateOverride_optional;

          typedef ::xsd::cxx::tree::traits< RightGlomerularFiltrationRateOverride_type, char > RightGlomerularFiltrationRateOverride_traits;

          const RightGlomerularFiltrationRateOverride_optional&
          RightGlomerularFiltrationRateOverride () const;

          RightGlomerularFiltrationRateOverride_optional&
          RightGlomerularFiltrationRateOverride ();

          void
          RightGlomerularFiltrationRateOverride (const RightGlomerularFiltrationRateOverride_type& x);

          void
          RightGlomerularFiltrationRateOverride (const RightGlomerularFiltrationRateOverride_optional& x);

          void
          RightGlomerularFiltrationRateOverride (::std::unique_ptr< RightGlomerularFiltrationRateOverride_type > p);



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

          typedef ::xsd::cxx::tree::optional< RightReabsorptionRateOverride_type > RightReabsorptionRateOverride_optional;

          typedef ::xsd::cxx::tree::traits< RightReabsorptionRateOverride_type, char > RightReabsorptionRateOverride_traits;

          const RightReabsorptionRateOverride_optional&
          RightReabsorptionRateOverride () const;

          RightReabsorptionRateOverride_optional&
          RightReabsorptionRateOverride ();

          void
          RightReabsorptionRateOverride (const RightReabsorptionRateOverride_type& x);

          void
          RightReabsorptionRateOverride (const RightReabsorptionRateOverride_optional& x);

          void
          RightReabsorptionRateOverride (::std::unique_ptr< RightReabsorptionRateOverride_type > p);



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

          typedef ::xsd::cxx::tree::optional< UrinationRateOverride_type > UrinationRateOverride_optional;

          typedef ::xsd::cxx::tree::traits< UrinationRateOverride_type, char > UrinationRateOverride_traits;

          const UrinationRateOverride_optional&
          UrinationRateOverride () const;

          UrinationRateOverride_optional&
          UrinationRateOverride ();

          void
          UrinationRateOverride (const UrinationRateOverride_type& x);

          void
          UrinationRateOverride (const UrinationRateOverride_optional& x);

          void
          UrinationRateOverride (::std::unique_ptr< UrinationRateOverride_type > p);



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

          typedef ::xsd::cxx::tree::optional< UrineProductionRateOverride_type > UrineProductionRateOverride_optional;

          typedef ::xsd::cxx::tree::traits< UrineProductionRateOverride_type, char > UrineProductionRateOverride_traits;

          const UrineProductionRateOverride_optional&
          UrineProductionRateOverride () const;

          UrineProductionRateOverride_optional&
          UrineProductionRateOverride ();

          void
          UrineProductionRateOverride (const UrineProductionRateOverride_type& x);

          void
          UrineProductionRateOverride (const UrineProductionRateOverride_optional& x);

          void
          UrineProductionRateOverride (::std::unique_ptr< UrineProductionRateOverride_type > p);



          typedef ::mil::tatrc::physiology::datamodel::ScalarOsmolalityData UrineOsmolalityOverride_type;

          typedef ::xsd::cxx::tree::optional< UrineOsmolalityOverride_type > UrineOsmolalityOverride_optional;

          typedef ::xsd::cxx::tree::traits< UrineOsmolalityOverride_type, char > UrineOsmolalityOverride_traits;

          const UrineOsmolalityOverride_optional&
          UrineOsmolalityOverride () const;

          UrineOsmolalityOverride_optional&
          UrineOsmolalityOverride ();

          void
          UrineOsmolalityOverride (const UrineOsmolalityOverride_type& x);

          void
          UrineOsmolalityOverride (const UrineOsmolalityOverride_optional& x);

          void
          UrineOsmolalityOverride (::std::unique_ptr< UrineOsmolalityOverride_type > p);



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

          typedef ::xsd::cxx::tree::optional< UrineVolumeOverride_type > UrineVolumeOverride_optional;

          typedef ::xsd::cxx::tree::traits< UrineVolumeOverride_type, char > UrineVolumeOverride_traits;

          const UrineVolumeOverride_optional&
          UrineVolumeOverride () const;

          UrineVolumeOverride_optional&
          UrineVolumeOverride ();

          void
          UrineVolumeOverride (const UrineVolumeOverride_type& x);

          void
          UrineVolumeOverride (const UrineVolumeOverride_optional& x);

          void
          UrineVolumeOverride (::std::unique_ptr< UrineVolumeOverride_type > p);



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

          typedef ::xsd::cxx::tree::optional< UrineUreaNitrogenConcentrationOverride_type > UrineUreaNitrogenConcentrationOverride_optional;

          typedef ::xsd::cxx::tree::traits< UrineUreaNitrogenConcentrationOverride_type, char > UrineUreaNitrogenConcentrationOverride_traits;

          const UrineUreaNitrogenConcentrationOverride_optional&
          UrineUreaNitrogenConcentrationOverride () const;

          UrineUreaNitrogenConcentrationOverride_optional&
          UrineUreaNitrogenConcentrationOverride ();

          void
          UrineUreaNitrogenConcentrationOverride (const UrineUreaNitrogenConcentrationOverride_type& x);

          void
          UrineUreaNitrogenConcentrationOverride (const UrineUreaNitrogenConcentrationOverride_optional& x);

          void
          UrineUreaNitrogenConcentrationOverride (::std::unique_ptr< UrineUreaNitrogenConcentrationOverride_type > p);



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

          typedef ::xsd::cxx::tree::optional< ExpiratoryFlowOverride_type > ExpiratoryFlowOverride_optional;

          typedef ::xsd::cxx::tree::traits< ExpiratoryFlowOverride_type, char > ExpiratoryFlowOverride_traits;

          const ExpiratoryFlowOverride_optional&
          ExpiratoryFlowOverride () const;

          ExpiratoryFlowOverride_optional&
          ExpiratoryFlowOverride ();

          void
          ExpiratoryFlowOverride (const ExpiratoryFlowOverride_type& x);

          void
          ExpiratoryFlowOverride (const ExpiratoryFlowOverride_optional& x);

          void
          ExpiratoryFlowOverride (::std::unique_ptr< ExpiratoryFlowOverride_type > p);



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

          typedef ::xsd::cxx::tree::optional< InspiratoryFlowOverride_type > InspiratoryFlowOverride_optional;

          typedef ::xsd::cxx::tree::traits< InspiratoryFlowOverride_type, char > InspiratoryFlowOverride_traits;

          const InspiratoryFlowOverride_optional&
          InspiratoryFlowOverride () const;

          InspiratoryFlowOverride_optional&
          InspiratoryFlowOverride ();

          void
          InspiratoryFlowOverride (const InspiratoryFlowOverride_type& x);

          void
          InspiratoryFlowOverride (const InspiratoryFlowOverride_optional& x);

          void
          InspiratoryFlowOverride (::std::unique_ptr< InspiratoryFlowOverride_type > p);



          typedef ::mil::tatrc::physiology::datamodel::ScalarFlowComplianceData PulmonaryComplianceOverride_type;

          typedef ::xsd::cxx::tree::optional< PulmonaryComplianceOverride_type > PulmonaryComplianceOverride_optional;

          typedef ::xsd::cxx::tree::traits< PulmonaryComplianceOverride_type, char > PulmonaryComplianceOverride_traits;

          const PulmonaryComplianceOverride_optional&
          PulmonaryComplianceOverride () const;

          PulmonaryComplianceOverride_optional&
          PulmonaryComplianceOverride ();

          void
          PulmonaryComplianceOverride (const PulmonaryComplianceOverride_type& x);

          void
          PulmonaryComplianceOverride (const PulmonaryComplianceOverride_optional& x);

          void
          PulmonaryComplianceOverride (::std::unique_ptr< PulmonaryComplianceOverride_type > p);



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

          typedef ::xsd::cxx::tree::optional< PulmonaryResistanceOverride_type > PulmonaryResistanceOverride_optional;

          typedef ::xsd::cxx::tree::traits< PulmonaryResistanceOverride_type, char > PulmonaryResistanceOverride_traits;

          const PulmonaryResistanceOverride_optional&
          PulmonaryResistanceOverride () const;

          PulmonaryResistanceOverride_optional&
          PulmonaryResistanceOverride ();

          void
          PulmonaryResistanceOverride (const PulmonaryResistanceOverride_type& x);

          void
          PulmonaryResistanceOverride (const PulmonaryResistanceOverride_optional& x);

          void
          PulmonaryResistanceOverride (::std::unique_ptr< PulmonaryResistanceOverride_type > p);



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

          typedef ::xsd::cxx::tree::optional< RespirationRateOverride_type > RespirationRateOverride_optional;

          typedef ::xsd::cxx::tree::traits< RespirationRateOverride_type, char > RespirationRateOverride_traits;

          const RespirationRateOverride_optional&
          RespirationRateOverride () const;

          RespirationRateOverride_optional&
          RespirationRateOverride ();

          void
          RespirationRateOverride (const RespirationRateOverride_type& x);

          void
          RespirationRateOverride (const RespirationRateOverride_optional& x);

          void
          RespirationRateOverride (::std::unique_ptr< RespirationRateOverride_type > p);



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

          typedef ::xsd::cxx::tree::optional< TargetPulmonaryVentilationOverride_type > TargetPulmonaryVentilationOverride_optional;

          typedef ::xsd::cxx::tree::traits< TargetPulmonaryVentilationOverride_type, char > TargetPulmonaryVentilationOverride_traits;

          const TargetPulmonaryVentilationOverride_optional&
          TargetPulmonaryVentilationOverride () const;

          TargetPulmonaryVentilationOverride_optional&
          TargetPulmonaryVentilationOverride ();

          void
          TargetPulmonaryVentilationOverride (const TargetPulmonaryVentilationOverride_type& x);

          void
          TargetPulmonaryVentilationOverride (const TargetPulmonaryVentilationOverride_optional& x);

          void
          TargetPulmonaryVentilationOverride (::std::unique_ptr< TargetPulmonaryVentilationOverride_type > p);



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

          typedef ::xsd::cxx::tree::optional< TidalVolumeOverride_type > TidalVolumeOverride_optional;

          typedef ::xsd::cxx::tree::traits< TidalVolumeOverride_type, char > TidalVolumeOverride_traits;

          const TidalVolumeOverride_optional&
          TidalVolumeOverride () const;

          TidalVolumeOverride_optional&
          TidalVolumeOverride ();

          void
          TidalVolumeOverride (const TidalVolumeOverride_type& x);

          void
          TidalVolumeOverride (const TidalVolumeOverride_optional& x);

          void
          TidalVolumeOverride (::std::unique_ptr< TidalVolumeOverride_type > p);



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

          typedef ::xsd::cxx::tree::optional< TotalAlveolarVentilationOverride_type > TotalAlveolarVentilationOverride_optional;

          typedef ::xsd::cxx::tree::traits< TotalAlveolarVentilationOverride_type, char > TotalAlveolarVentilationOverride_traits;

          const TotalAlveolarVentilationOverride_optional&
          TotalAlveolarVentilationOverride () const;

          TotalAlveolarVentilationOverride_optional&
          TotalAlveolarVentilationOverride ();

          void
          TotalAlveolarVentilationOverride (const TotalAlveolarVentilationOverride_type& x);

          void
          TotalAlveolarVentilationOverride (const TotalAlveolarVentilationOverride_optional& x);

          void
          TotalAlveolarVentilationOverride (::std::unique_ptr< TotalAlveolarVentilationOverride_type > p);



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

          typedef ::xsd::cxx::tree::optional< TotalLungVolumeOverride_type > TotalLungVolumeOverride_optional;

          typedef ::xsd::cxx::tree::traits< TotalLungVolumeOverride_type, char > TotalLungVolumeOverride_traits;

          const TotalLungVolumeOverride_optional&
          TotalLungVolumeOverride () const;

          TotalLungVolumeOverride_optional&
          TotalLungVolumeOverride ();

          void
          TotalLungVolumeOverride (const TotalLungVolumeOverride_type& x);

          void
          TotalLungVolumeOverride (const TotalLungVolumeOverride_optional& x);

          void
          TotalLungVolumeOverride (::std::unique_ptr< TotalLungVolumeOverride_type > p);



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

          typedef ::xsd::cxx::tree::optional< TotalPulmonaryVentilationOverride_type > TotalPulmonaryVentilationOverride_optional;

          typedef ::xsd::cxx::tree::traits< TotalPulmonaryVentilationOverride_type, char > TotalPulmonaryVentilationOverride_traits;

          const TotalPulmonaryVentilationOverride_optional&
          TotalPulmonaryVentilationOverride () const;

          TotalPulmonaryVentilationOverride_optional&
          TotalPulmonaryVentilationOverride ();

          void
          TotalPulmonaryVentilationOverride (const TotalPulmonaryVentilationOverride_type& x);

          void
          TotalPulmonaryVentilationOverride (const TotalPulmonaryVentilationOverride_optional& x);

          void
          TotalPulmonaryVentilationOverride (::std::unique_ptr< TotalPulmonaryVentilationOverride_type > p);



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

          typedef ::xsd::cxx::tree::optional< ExtravascularFluidVolumeOverride_type > ExtravascularFluidVolumeOverride_optional;

          typedef ::xsd::cxx::tree::traits< ExtravascularFluidVolumeOverride_type, char > ExtravascularFluidVolumeOverride_traits;

          const ExtravascularFluidVolumeOverride_optional&
          ExtravascularFluidVolumeOverride () const;

          ExtravascularFluidVolumeOverride_optional&
          ExtravascularFluidVolumeOverride ();

          void
          ExtravascularFluidVolumeOverride (const ExtravascularFluidVolumeOverride_type& x);

          void
          ExtravascularFluidVolumeOverride (const ExtravascularFluidVolumeOverride_optional& x);

          void
          ExtravascularFluidVolumeOverride (::std::unique_ptr< ExtravascularFluidVolumeOverride_type > p);



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

          typedef ::xsd::cxx::tree::optional< IntracellularFluidVolumeOverride_type > IntracellularFluidVolumeOverride_optional;

          typedef ::xsd::cxx::tree::traits< IntracellularFluidVolumeOverride_type, char > IntracellularFluidVolumeOverride_traits;

          const IntracellularFluidVolumeOverride_optional&
          IntracellularFluidVolumeOverride () const;

          IntracellularFluidVolumeOverride_optional&
          IntracellularFluidVolumeOverride ();

          void
          IntracellularFluidVolumeOverride (const IntracellularFluidVolumeOverride_type& x);

          void
          IntracellularFluidVolumeOverride (const IntracellularFluidVolumeOverride_optional& x);

          void
          IntracellularFluidVolumeOverride (::std::unique_ptr< IntracellularFluidVolumeOverride_type > p);



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

          typedef ::xsd::cxx::tree::optional< LiverGlycogenOverride_type > LiverGlycogenOverride_optional;

          typedef ::xsd::cxx::tree::traits< LiverGlycogenOverride_type, char > LiverGlycogenOverride_traits;

          const LiverGlycogenOverride_optional&
          LiverGlycogenOverride () const;

          LiverGlycogenOverride_optional&
          LiverGlycogenOverride ();

          void
          LiverGlycogenOverride (const LiverGlycogenOverride_type& x);

          void
          LiverGlycogenOverride (const LiverGlycogenOverride_optional& x);

          void
          LiverGlycogenOverride (::std::unique_ptr< LiverGlycogenOverride_type > p);



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

          typedef ::xsd::cxx::tree::optional< MuscleGlycogenOverride_type > MuscleGlycogenOverride_optional;

          typedef ::xsd::cxx::tree::traits< MuscleGlycogenOverride_type, char > MuscleGlycogenOverride_traits;

          const MuscleGlycogenOverride_optional&
          MuscleGlycogenOverride () const;

          MuscleGlycogenOverride_optional&
          MuscleGlycogenOverride ();

          void
          MuscleGlycogenOverride (const MuscleGlycogenOverride_type& x);

          void
          MuscleGlycogenOverride (const MuscleGlycogenOverride_optional& x);

          void
          MuscleGlycogenOverride (::std::unique_ptr< MuscleGlycogenOverride_type > p);



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

          typedef ::xsd::cxx::tree::optional< StoredFatOverride_type > StoredFatOverride_optional;

          typedef ::xsd::cxx::tree::traits< StoredFatOverride_type, char > StoredFatOverride_traits;

          const StoredFatOverride_optional&
          StoredFatOverride () const;

          StoredFatOverride_optional&
          StoredFatOverride ();

          void
          StoredFatOverride (const StoredFatOverride_type& x);

          void
          StoredFatOverride (const StoredFatOverride_optional& x);

          void
          StoredFatOverride (::std::unique_ptr< StoredFatOverride_type > p);



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

          typedef ::xsd::cxx::tree::optional< StoredProteinOverride_type > StoredProteinOverride_optional;

          typedef ::xsd::cxx::tree::traits< StoredProteinOverride_type, char > StoredProteinOverride_traits;

          const StoredProteinOverride_optional&
          StoredProteinOverride () const;

          StoredProteinOverride_optional&
          StoredProteinOverride ();

          void
          StoredProteinOverride (const StoredProteinOverride_type& x);

          void
          StoredProteinOverride (const StoredProteinOverride_optional& x);

          void
          StoredProteinOverride (::std::unique_ptr< StoredProteinOverride_type > p);



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

          typedef ::xsd::cxx::tree::traits< State_type, char > State_traits;

          const State_type&
          State () const;

          State_type&
          State ();

          void
          State (const State_type& x);

          void
          State (::std::unique_ptr< State_type > p);



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

          typedef ::xsd::cxx::tree::traits< Conformant_type, char > Conformant_traits;

          const Conformant_type&
          Conformant () const;

          Conformant_type&
          Conformant ();

          void
          Conformant (const Conformant_type& x);

          void
          Conformant (::std::unique_ptr< Conformant_type > p);



          OverrideData ();

          OverrideData (const State_type&,
                        const Conformant_type&);

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

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

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

          OverrideData&
          operator= (const OverrideData& x);


          virtual 
          ~OverrideData ();

          // Implementation.
          //

          //@cond

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

          protected:
          ArterialBloodPHOverride_optional ArterialBloodPHOverride_;
          CalciumConcentrationOverride_optional CalciumConcentrationOverride_;
          CarbonDioxideSaturationOverride_optional CarbonDioxideSaturationOverride_;
          CarbonMonoxideSaturationOverride_optional CarbonMonoxideSaturationOverride_;
          GlucoseConcentrationOverride_optional GlucoseConcentrationOverride_;
          LactateConcentrationOverride_optional LactateConcentrationOverride_;
          OxygenSaturationOverride_optional OxygenSaturationOverride_;
          PhosphateOverride_optional PhosphateOverride_;
          PotassiumConcentrationOverride_optional PotassiumConcentrationOverride_;
          SodiumConcentrationOverride_optional SodiumConcentrationOverride_;
          TotalBilirubinOverride_optional TotalBilirubinOverride_;
          VenousBloodPHOverride_optional VenousBloodPHOverride_;
          WhiteBloodCellCountOverride_optional WhiteBloodCellCountOverride_;
          BloodVolumeOverride_optional BloodVolumeOverride_;
          CardiacOutputOverride_optional CardiacOutputOverride_;
          DiastolicArterialPressureOverride_optional DiastolicArterialPressureOverride_;
          HeartRateOverride_optional HeartRateOverride_;
          HeartStrokeVolumeOverride_optional HeartStrokeVolumeOverride_;
          MeanArterialPressureOverride_optional MeanArterialPressureOverride_;
          SystolicArterialPressureOverride_optional SystolicArterialPressureOverride_;
          InsulinSynthesisRateOverride_optional InsulinSynthesisRateOverride_;
          GlucagonSynthesisRateOverride_optional GlucagonSynthesisRateOverride_;
          AchievedExerciseLevelOverride_optional AchievedExerciseLevelOverride_;
          ChlorideLostToSweatOverride_optional ChlorideLostToSweatOverride_;
          CoreTemperatureOverride_optional CoreTemperatureOverride_;
          CreatinineProductionRateOverride_optional CreatinineProductionRateOverride_;
          ExerciseMeanArterialPressureDeltaOverride_optional ExerciseMeanArterialPressureDeltaOverride_;
          FatigueLevelOverride_optional FatigueLevelOverride_;
          LactateProductionRateOverride_optional LactateProductionRateOverride_;
          PotassiumLostToSweatOverride_optional PotassiumLostToSweatOverride_;
          SkinTemperatureOverride_optional SkinTemperatureOverride_;
          SodiumLostToSweatOverride_optional SodiumLostToSweatOverride_;
          SweatRateOverride_optional SweatRateOverride_;
          TotalMetabolicRateOverride_optional TotalMetabolicRateOverride_;
          TotalWorkRateLevelOverride_optional TotalWorkRateLevelOverride_;
          LeftAfferentArterioleResistanceOverride_optional LeftAfferentArterioleResistanceOverride_;
          LeftGlomerularFiltrationRateOverride_optional LeftGlomerularFiltrationRateOverride_;
          LeftReabsorptionRateOverride_optional LeftReabsorptionRateOverride_;
          RenalBloodFlowOverride_optional RenalBloodFlowOverride_;
          RenalPlasmaFlowOverride_optional RenalPlasmaFlowOverride_;
          RightAfferentArterioleResistanceOverride_optional RightAfferentArterioleResistanceOverride_;
          RightGlomerularFiltrationRateOverride_optional RightGlomerularFiltrationRateOverride_;
          RightReabsorptionRateOverride_optional RightReabsorptionRateOverride_;
          UrinationRateOverride_optional UrinationRateOverride_;
          UrineProductionRateOverride_optional UrineProductionRateOverride_;
          UrineOsmolalityOverride_optional UrineOsmolalityOverride_;
          UrineVolumeOverride_optional UrineVolumeOverride_;
          UrineUreaNitrogenConcentrationOverride_optional UrineUreaNitrogenConcentrationOverride_;
          ExpiratoryFlowOverride_optional ExpiratoryFlowOverride_;
          InspiratoryFlowOverride_optional InspiratoryFlowOverride_;
          PulmonaryComplianceOverride_optional PulmonaryComplianceOverride_;
          PulmonaryResistanceOverride_optional PulmonaryResistanceOverride_;
          RespirationRateOverride_optional RespirationRateOverride_;
          TargetPulmonaryVentilationOverride_optional TargetPulmonaryVentilationOverride_;
          TidalVolumeOverride_optional TidalVolumeOverride_;
          TotalAlveolarVentilationOverride_optional TotalAlveolarVentilationOverride_;
          TotalLungVolumeOverride_optional TotalLungVolumeOverride_;
          TotalPulmonaryVentilationOverride_optional TotalPulmonaryVentilationOverride_;
          ExtravascularFluidVolumeOverride_optional ExtravascularFluidVolumeOverride_;
          IntracellularFluidVolumeOverride_optional IntracellularFluidVolumeOverride_;
          LiverGlycogenOverride_optional LiverGlycogenOverride_;
          MuscleGlycogenOverride_optional MuscleGlycogenOverride_;
          StoredFatOverride_optional StoredFatOverride_;
          StoredProteinOverride_optional StoredProteinOverride_;
          ::xsd::cxx::tree::one< State_type > State_;
          ::xsd::cxx::tree::one< Conformant_type > Conformant_;

          //@endcond
        };
      }
    }
  }
}

#include <iosfwd>

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

#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
      {
      }
    }
  }
}

#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 PatientActionData&);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

#include <xsd/cxx/post.hxx>

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

#endif // D__BIOGEARS_CORE_SHARE_XSD__CDM_PATIENT_ACTIONS_HXX