BioGearsConfiguration.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__BIOGEARS_BIO_GEARS_CONFIGURATION_HXX
#define D__BIOGEARS_CORE_SHARE_XSD__BIOGEARS_BIO_GEARS_CONFIGURATION_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 BloodChemistryConfigurationData;
        class CardiovascularConfigurationData;
        class CircuitConfigurationData;
        class ConstantsConfigurationData;
        class DrugsConfigurationData;
        class EnergyConfigurationData;
        class EnvironmentConfigurationData;
        class GastrointestinalConfigurationData;
        class NervousConfigurationData;
        class RenalConfigurationData;
        class RespiratoryConfigurationData;
        class TissueConfigurationData;
        class BioGearsConfigurationData;
      }
    }
  }
}


#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 "../cdm/environment.hxx"

#include "../cdm/engineconfiguration.hxx"

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

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

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

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

          const MeanCorpuscularHemoglobin_optional&
          MeanCorpuscularHemoglobin () const;

          MeanCorpuscularHemoglobin_optional&
          MeanCorpuscularHemoglobin ();

          void
          MeanCorpuscularHemoglobin (const MeanCorpuscularHemoglobin_type& x);

          void
          MeanCorpuscularHemoglobin (const MeanCorpuscularHemoglobin_optional& x);

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



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

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

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

          const MeanCorpuscularVolume_optional&
          MeanCorpuscularVolume () const;

          MeanCorpuscularVolume_optional&
          MeanCorpuscularVolume ();

          void
          MeanCorpuscularVolume (const MeanCorpuscularVolume_type& x);

          void
          MeanCorpuscularVolume (const MeanCorpuscularVolume_optional& x);

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



          typedef ::mil::tatrc::physiology::datamodel::ScalarLengthData StandardDiffusionDistance_type;

          typedef ::xsd::cxx::tree::optional< StandardDiffusionDistance_type > StandardDiffusionDistance_optional;

          typedef ::xsd::cxx::tree::traits< StandardDiffusionDistance_type, char > StandardDiffusionDistance_traits;

          const StandardDiffusionDistance_optional&
          StandardDiffusionDistance () const;

          StandardDiffusionDistance_optional&
          StandardDiffusionDistance ();

          void
          StandardDiffusionDistance (const StandardDiffusionDistance_type& x);

          void
          StandardDiffusionDistance (const StandardDiffusionDistance_optional& x);

          void
          StandardDiffusionDistance (::std::unique_ptr< StandardDiffusionDistance_type > p);



          typedef ::mil::tatrc::physiology::datamodel::ScalarAreaPerTimePressureData StandardOxygenDiffusionCoefficient_type;

          typedef ::xsd::cxx::tree::optional< StandardOxygenDiffusionCoefficient_type > StandardOxygenDiffusionCoefficient_optional;

          typedef ::xsd::cxx::tree::traits< StandardOxygenDiffusionCoefficient_type, char > StandardOxygenDiffusionCoefficient_traits;

          const StandardOxygenDiffusionCoefficient_optional&
          StandardOxygenDiffusionCoefficient () const;

          StandardOxygenDiffusionCoefficient_optional&
          StandardOxygenDiffusionCoefficient ();

          void
          StandardOxygenDiffusionCoefficient (const StandardOxygenDiffusionCoefficient_type& x);

          void
          StandardOxygenDiffusionCoefficient (const StandardOxygenDiffusionCoefficient_optional& x);

          void
          StandardOxygenDiffusionCoefficient (::std::unique_ptr< StandardOxygenDiffusionCoefficient_type > p);



          BloodChemistryConfigurationData ();

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

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

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

          BloodChemistryConfigurationData&
          operator= (const BloodChemistryConfigurationData& x);


          virtual 
          ~BloodChemistryConfigurationData ();

          // Implementation.
          //

          //@cond

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

          protected:
          MeanCorpuscularHemoglobin_optional MeanCorpuscularHemoglobin_;
          MeanCorpuscularVolume_optional MeanCorpuscularVolume_;
          StandardDiffusionDistance_optional StandardDiffusionDistance_;
          StandardOxygenDiffusionCoefficient_optional StandardOxygenDiffusionCoefficient_;

          //@endcond
        };

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

          typedef ::mil::tatrc::physiology::datamodel::ScalarFlowElastanceData LeftHeartElastanceMaximum_type;

          typedef ::xsd::cxx::tree::optional< LeftHeartElastanceMaximum_type > LeftHeartElastanceMaximum_optional;

          typedef ::xsd::cxx::tree::traits< LeftHeartElastanceMaximum_type, char > LeftHeartElastanceMaximum_traits;

          const LeftHeartElastanceMaximum_optional&
          LeftHeartElastanceMaximum () const;

          LeftHeartElastanceMaximum_optional&
          LeftHeartElastanceMaximum ();

          void
          LeftHeartElastanceMaximum (const LeftHeartElastanceMaximum_type& x);

          void
          LeftHeartElastanceMaximum (const LeftHeartElastanceMaximum_optional& x);

          void
          LeftHeartElastanceMaximum (::std::unique_ptr< LeftHeartElastanceMaximum_type > p);



          typedef ::mil::tatrc::physiology::datamodel::ScalarFlowElastanceData LeftHeartElastanceMinimum_type;

          typedef ::xsd::cxx::tree::optional< LeftHeartElastanceMinimum_type > LeftHeartElastanceMinimum_optional;

          typedef ::xsd::cxx::tree::traits< LeftHeartElastanceMinimum_type, char > LeftHeartElastanceMinimum_traits;

          const LeftHeartElastanceMinimum_optional&
          LeftHeartElastanceMinimum () const;

          LeftHeartElastanceMinimum_optional&
          LeftHeartElastanceMinimum ();

          void
          LeftHeartElastanceMinimum (const LeftHeartElastanceMinimum_type& x);

          void
          LeftHeartElastanceMinimum (const LeftHeartElastanceMinimum_optional& x);

          void
          LeftHeartElastanceMinimum (::std::unique_ptr< LeftHeartElastanceMinimum_type > p);



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

          typedef ::xsd::cxx::tree::optional< MinimumBloodVolumeFraction_type > MinimumBloodVolumeFraction_optional;

          typedef ::xsd::cxx::tree::traits< MinimumBloodVolumeFraction_type, char > MinimumBloodVolumeFraction_traits;

          const MinimumBloodVolumeFraction_optional&
          MinimumBloodVolumeFraction () const;

          MinimumBloodVolumeFraction_optional&
          MinimumBloodVolumeFraction ();

          void
          MinimumBloodVolumeFraction (const MinimumBloodVolumeFraction_type& x);

          void
          MinimumBloodVolumeFraction (const MinimumBloodVolumeFraction_optional& x);

          void
          MinimumBloodVolumeFraction (::std::unique_ptr< MinimumBloodVolumeFraction_type > p);



          typedef ::mil::tatrc::physiology::datamodel::ScalarFlowElastanceData RightHeartElastanceMaximum_type;

          typedef ::xsd::cxx::tree::optional< RightHeartElastanceMaximum_type > RightHeartElastanceMaximum_optional;

          typedef ::xsd::cxx::tree::traits< RightHeartElastanceMaximum_type, char > RightHeartElastanceMaximum_traits;

          const RightHeartElastanceMaximum_optional&
          RightHeartElastanceMaximum () const;

          RightHeartElastanceMaximum_optional&
          RightHeartElastanceMaximum ();

          void
          RightHeartElastanceMaximum (const RightHeartElastanceMaximum_type& x);

          void
          RightHeartElastanceMaximum (const RightHeartElastanceMaximum_optional& x);

          void
          RightHeartElastanceMaximum (::std::unique_ptr< RightHeartElastanceMaximum_type > p);



          typedef ::mil::tatrc::physiology::datamodel::ScalarFlowElastanceData RightHeartElastanceMinimum_type;

          typedef ::xsd::cxx::tree::optional< RightHeartElastanceMinimum_type > RightHeartElastanceMinimum_optional;

          typedef ::xsd::cxx::tree::traits< RightHeartElastanceMinimum_type, char > RightHeartElastanceMinimum_traits;

          const RightHeartElastanceMinimum_optional&
          RightHeartElastanceMinimum () const;

          RightHeartElastanceMinimum_optional&
          RightHeartElastanceMinimum ();

          void
          RightHeartElastanceMinimum (const RightHeartElastanceMinimum_type& x);

          void
          RightHeartElastanceMinimum (const RightHeartElastanceMinimum_optional& x);

          void
          RightHeartElastanceMinimum (::std::unique_ptr< RightHeartElastanceMinimum_type > p);



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

          typedef ::xsd::cxx::tree::optional< StandardPulmonaryCapillaryCoverage_type > StandardPulmonaryCapillaryCoverage_optional;

          typedef ::xsd::cxx::tree::traits< StandardPulmonaryCapillaryCoverage_type, char > StandardPulmonaryCapillaryCoverage_traits;

          const StandardPulmonaryCapillaryCoverage_optional&
          StandardPulmonaryCapillaryCoverage () const;

          StandardPulmonaryCapillaryCoverage_optional&
          StandardPulmonaryCapillaryCoverage ();

          void
          StandardPulmonaryCapillaryCoverage (const StandardPulmonaryCapillaryCoverage_type& x);

          void
          StandardPulmonaryCapillaryCoverage (const StandardPulmonaryCapillaryCoverage_optional& x);

          void
          StandardPulmonaryCapillaryCoverage (::std::unique_ptr< StandardPulmonaryCapillaryCoverage_type > p);



          CardiovascularConfigurationData ();

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

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

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

          CardiovascularConfigurationData&
          operator= (const CardiovascularConfigurationData& x);


          virtual 
          ~CardiovascularConfigurationData ();

          // Implementation.
          //

          //@cond

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

          protected:
          LeftHeartElastanceMaximum_optional LeftHeartElastanceMaximum_;
          LeftHeartElastanceMinimum_optional LeftHeartElastanceMinimum_;
          MinimumBloodVolumeFraction_optional MinimumBloodVolumeFraction_;
          RightHeartElastanceMaximum_optional RightHeartElastanceMaximum_;
          RightHeartElastanceMinimum_optional RightHeartElastanceMinimum_;
          StandardPulmonaryCapillaryCoverage_optional StandardPulmonaryCapillaryCoverage_;

          //@endcond
        };

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

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

          typedef ::xsd::cxx::tree::optional< CardiovascularOpenResistance_type > CardiovascularOpenResistance_optional;

          typedef ::xsd::cxx::tree::traits< CardiovascularOpenResistance_type, char > CardiovascularOpenResistance_traits;

          const CardiovascularOpenResistance_optional&
          CardiovascularOpenResistance () const;

          CardiovascularOpenResistance_optional&
          CardiovascularOpenResistance ();

          void
          CardiovascularOpenResistance (const CardiovascularOpenResistance_type& x);

          void
          CardiovascularOpenResistance (const CardiovascularOpenResistance_optional& x);

          void
          CardiovascularOpenResistance (::std::unique_ptr< CardiovascularOpenResistance_type > p);



          typedef ::mil::tatrc::physiology::datamodel::ScalarElectricResistanceData DefaultClosedElectricResistance_type;

          typedef ::xsd::cxx::tree::optional< DefaultClosedElectricResistance_type > DefaultClosedElectricResistance_optional;

          typedef ::xsd::cxx::tree::traits< DefaultClosedElectricResistance_type, char > DefaultClosedElectricResistance_traits;

          const DefaultClosedElectricResistance_optional&
          DefaultClosedElectricResistance () const;

          DefaultClosedElectricResistance_optional&
          DefaultClosedElectricResistance ();

          void
          DefaultClosedElectricResistance (const DefaultClosedElectricResistance_type& x);

          void
          DefaultClosedElectricResistance (const DefaultClosedElectricResistance_optional& x);

          void
          DefaultClosedElectricResistance (::std::unique_ptr< DefaultClosedElectricResistance_type > p);



          typedef ::mil::tatrc::physiology::datamodel::ScalarElectricResistanceData DefaultOpenElectricResistance_type;

          typedef ::xsd::cxx::tree::optional< DefaultOpenElectricResistance_type > DefaultOpenElectricResistance_optional;

          typedef ::xsd::cxx::tree::traits< DefaultOpenElectricResistance_type, char > DefaultOpenElectricResistance_traits;

          const DefaultOpenElectricResistance_optional&
          DefaultOpenElectricResistance () const;

          DefaultOpenElectricResistance_optional&
          DefaultOpenElectricResistance ();

          void
          DefaultOpenElectricResistance (const DefaultOpenElectricResistance_type& x);

          void
          DefaultOpenElectricResistance (const DefaultOpenElectricResistance_optional& x);

          void
          DefaultOpenElectricResistance (::std::unique_ptr< DefaultOpenElectricResistance_type > p);



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

          typedef ::xsd::cxx::tree::optional< DefaultClosedFlowResistance_type > DefaultClosedFlowResistance_optional;

          typedef ::xsd::cxx::tree::traits< DefaultClosedFlowResistance_type, char > DefaultClosedFlowResistance_traits;

          const DefaultClosedFlowResistance_optional&
          DefaultClosedFlowResistance () const;

          DefaultClosedFlowResistance_optional&
          DefaultClosedFlowResistance ();

          void
          DefaultClosedFlowResistance (const DefaultClosedFlowResistance_type& x);

          void
          DefaultClosedFlowResistance (const DefaultClosedFlowResistance_optional& x);

          void
          DefaultClosedFlowResistance (::std::unique_ptr< DefaultClosedFlowResistance_type > p);



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

          typedef ::xsd::cxx::tree::optional< DefaultOpenFlowResistance_type > DefaultOpenFlowResistance_optional;

          typedef ::xsd::cxx::tree::traits< DefaultOpenFlowResistance_type, char > DefaultOpenFlowResistance_traits;

          const DefaultOpenFlowResistance_optional&
          DefaultOpenFlowResistance () const;

          DefaultOpenFlowResistance_optional&
          DefaultOpenFlowResistance ();

          void
          DefaultOpenFlowResistance (const DefaultOpenFlowResistance_type& x);

          void
          DefaultOpenFlowResistance (const DefaultOpenFlowResistance_optional& x);

          void
          DefaultOpenFlowResistance (::std::unique_ptr< DefaultOpenFlowResistance_type > p);



          typedef ::mil::tatrc::physiology::datamodel::ScalarHeatResistanceData DefaultClosedHeatResistance_type;

          typedef ::xsd::cxx::tree::optional< DefaultClosedHeatResistance_type > DefaultClosedHeatResistance_optional;

          typedef ::xsd::cxx::tree::traits< DefaultClosedHeatResistance_type, char > DefaultClosedHeatResistance_traits;

          const DefaultClosedHeatResistance_optional&
          DefaultClosedHeatResistance () const;

          DefaultClosedHeatResistance_optional&
          DefaultClosedHeatResistance ();

          void
          DefaultClosedHeatResistance (const DefaultClosedHeatResistance_type& x);

          void
          DefaultClosedHeatResistance (const DefaultClosedHeatResistance_optional& x);

          void
          DefaultClosedHeatResistance (::std::unique_ptr< DefaultClosedHeatResistance_type > p);



          typedef ::mil::tatrc::physiology::datamodel::ScalarHeatResistanceData DefaultOpenHeatResistance_type;

          typedef ::xsd::cxx::tree::optional< DefaultOpenHeatResistance_type > DefaultOpenHeatResistance_optional;

          typedef ::xsd::cxx::tree::traits< DefaultOpenHeatResistance_type, char > DefaultOpenHeatResistance_traits;

          const DefaultOpenHeatResistance_optional&
          DefaultOpenHeatResistance () const;

          DefaultOpenHeatResistance_optional&
          DefaultOpenHeatResistance ();

          void
          DefaultOpenHeatResistance (const DefaultOpenHeatResistance_type& x);

          void
          DefaultOpenHeatResistance (const DefaultOpenHeatResistance_optional& x);

          void
          DefaultOpenHeatResistance (::std::unique_ptr< DefaultOpenHeatResistance_type > p);



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

          typedef ::xsd::cxx::tree::optional< MachineClosedResistance_type > MachineClosedResistance_optional;

          typedef ::xsd::cxx::tree::traits< MachineClosedResistance_type, char > MachineClosedResistance_traits;

          const MachineClosedResistance_optional&
          MachineClosedResistance () const;

          MachineClosedResistance_optional&
          MachineClosedResistance ();

          void
          MachineClosedResistance (const MachineClosedResistance_type& x);

          void
          MachineClosedResistance (const MachineClosedResistance_optional& x);

          void
          MachineClosedResistance (::std::unique_ptr< MachineClosedResistance_type > p);



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

          typedef ::xsd::cxx::tree::optional< MachineOpenResistance_type > MachineOpenResistance_optional;

          typedef ::xsd::cxx::tree::traits< MachineOpenResistance_type, char > MachineOpenResistance_traits;

          const MachineOpenResistance_optional&
          MachineOpenResistance () const;

          MachineOpenResistance_optional&
          MachineOpenResistance ();

          void
          MachineOpenResistance (const MachineOpenResistance_type& x);

          void
          MachineOpenResistance (const MachineOpenResistance_optional& x);

          void
          MachineOpenResistance (::std::unique_ptr< MachineOpenResistance_type > p);



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

          typedef ::xsd::cxx::tree::optional< RespiratoryClosedResistance_type > RespiratoryClosedResistance_optional;

          typedef ::xsd::cxx::tree::traits< RespiratoryClosedResistance_type, char > RespiratoryClosedResistance_traits;

          const RespiratoryClosedResistance_optional&
          RespiratoryClosedResistance () const;

          RespiratoryClosedResistance_optional&
          RespiratoryClosedResistance ();

          void
          RespiratoryClosedResistance (const RespiratoryClosedResistance_type& x);

          void
          RespiratoryClosedResistance (const RespiratoryClosedResistance_optional& x);

          void
          RespiratoryClosedResistance (::std::unique_ptr< RespiratoryClosedResistance_type > p);



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

          typedef ::xsd::cxx::tree::optional< RespiratoryOpenResistance_type > RespiratoryOpenResistance_optional;

          typedef ::xsd::cxx::tree::traits< RespiratoryOpenResistance_type, char > RespiratoryOpenResistance_traits;

          const RespiratoryOpenResistance_optional&
          RespiratoryOpenResistance () const;

          RespiratoryOpenResistance_optional&
          RespiratoryOpenResistance ();

          void
          RespiratoryOpenResistance (const RespiratoryOpenResistance_type& x);

          void
          RespiratoryOpenResistance (const RespiratoryOpenResistance_optional& x);

          void
          RespiratoryOpenResistance (::std::unique_ptr< RespiratoryOpenResistance_type > p);



          CircuitConfigurationData ();

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

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

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

          CircuitConfigurationData&
          operator= (const CircuitConfigurationData& x);


          virtual 
          ~CircuitConfigurationData ();

          // Implementation.
          //

          //@cond

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

          protected:
          CardiovascularOpenResistance_optional CardiovascularOpenResistance_;
          DefaultClosedElectricResistance_optional DefaultClosedElectricResistance_;
          DefaultOpenElectricResistance_optional DefaultOpenElectricResistance_;
          DefaultClosedFlowResistance_optional DefaultClosedFlowResistance_;
          DefaultOpenFlowResistance_optional DefaultOpenFlowResistance_;
          DefaultClosedHeatResistance_optional DefaultClosedHeatResistance_;
          DefaultOpenHeatResistance_optional DefaultOpenHeatResistance_;
          MachineClosedResistance_optional MachineClosedResistance_;
          MachineOpenResistance_optional MachineOpenResistance_;
          RespiratoryClosedResistance_optional RespiratoryClosedResistance_;
          RespiratoryOpenResistance_optional RespiratoryOpenResistance_;

          //@endcond
        };

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

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

          typedef ::xsd::cxx::tree::optional< OxygenMetabolicConstant_type > OxygenMetabolicConstant_optional;

          typedef ::xsd::cxx::tree::traits< OxygenMetabolicConstant_type, char > OxygenMetabolicConstant_traits;

          const OxygenMetabolicConstant_optional&
          OxygenMetabolicConstant () const;

          OxygenMetabolicConstant_optional&
          OxygenMetabolicConstant ();

          void
          OxygenMetabolicConstant (const OxygenMetabolicConstant_type& x);

          void
          OxygenMetabolicConstant (const OxygenMetabolicConstant_optional& x);

          void
          OxygenMetabolicConstant (::std::unique_ptr< OxygenMetabolicConstant_type > p);



          typedef ::mil::tatrc::physiology::datamodel::ScalarPowerPerAreaTemperatureToTheFourthData StefanBoltzmann_type;

          typedef ::xsd::cxx::tree::optional< StefanBoltzmann_type > StefanBoltzmann_optional;

          typedef ::xsd::cxx::tree::traits< StefanBoltzmann_type, char > StefanBoltzmann_traits;

          const StefanBoltzmann_optional&
          StefanBoltzmann () const;

          StefanBoltzmann_optional&
          StefanBoltzmann ();

          void
          StefanBoltzmann (const StefanBoltzmann_type& x);

          void
          StefanBoltzmann (const StefanBoltzmann_optional& x);

          void
          StefanBoltzmann (::std::unique_ptr< StefanBoltzmann_type > p);



          typedef ::mil::tatrc::physiology::datamodel::ScalarHeatCapacitancePerAmountData UniversalGasConstant_type;

          typedef ::xsd::cxx::tree::optional< UniversalGasConstant_type > UniversalGasConstant_optional;

          typedef ::xsd::cxx::tree::traits< UniversalGasConstant_type, char > UniversalGasConstant_traits;

          const UniversalGasConstant_optional&
          UniversalGasConstant () const;

          UniversalGasConstant_optional&
          UniversalGasConstant ();

          void
          UniversalGasConstant (const UniversalGasConstant_type& x);

          void
          UniversalGasConstant (const UniversalGasConstant_optional& x);

          void
          UniversalGasConstant (::std::unique_ptr< UniversalGasConstant_type > p);



          ConstantsConfigurationData ();

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

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

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

          ConstantsConfigurationData&
          operator= (const ConstantsConfigurationData& x);


          virtual 
          ~ConstantsConfigurationData ();

          // Implementation.
          //

          //@cond

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

          protected:
          OxygenMetabolicConstant_optional OxygenMetabolicConstant_;
          StefanBoltzmann_optional StefanBoltzmann_;
          UniversalGasConstant_optional UniversalGasConstant_;

          //@endcond
        };

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

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

          typedef ::xsd::cxx::tree::optional< PDModel_type > PDModel_optional;

          typedef ::xsd::cxx::tree::traits< PDModel_type, char > PDModel_traits;

          const PDModel_optional&
          PDModel () const;

          PDModel_optional&
          PDModel ();

          void
          PDModel (const PDModel_type& x);

          void
          PDModel (const PDModel_optional& x);

          void
          PDModel (::std::unique_ptr< PDModel_type > p);



          DrugsConfigurationData ();

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

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

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

          DrugsConfigurationData&
          operator= (const DrugsConfigurationData& x);


          virtual 
          ~DrugsConfigurationData ();

          // Implementation.
          //

          //@cond

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

          protected:
          PDModel_optional PDModel_;

          //@endcond
        };

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

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

          typedef ::xsd::cxx::tree::optional< BodySpecificHeat_type > BodySpecificHeat_optional;

          typedef ::xsd::cxx::tree::traits< BodySpecificHeat_type, char > BodySpecificHeat_traits;

          const BodySpecificHeat_optional&
          BodySpecificHeat () const;

          BodySpecificHeat_optional&
          BodySpecificHeat ();

          void
          BodySpecificHeat (const BodySpecificHeat_type& x);

          void
          BodySpecificHeat (const BodySpecificHeat_optional& x);

          void
          BodySpecificHeat (::std::unique_ptr< BodySpecificHeat_type > p);



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

          typedef ::xsd::cxx::tree::optional< CoreTemperatureLow_type > CoreTemperatureLow_optional;

          typedef ::xsd::cxx::tree::traits< CoreTemperatureLow_type, char > CoreTemperatureLow_traits;

          const CoreTemperatureLow_optional&
          CoreTemperatureLow () const;

          CoreTemperatureLow_optional&
          CoreTemperatureLow ();

          void
          CoreTemperatureLow (const CoreTemperatureLow_type& x);

          void
          CoreTemperatureLow (const CoreTemperatureLow_optional& x);

          void
          CoreTemperatureLow (::std::unique_ptr< CoreTemperatureLow_type > p);



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

          typedef ::xsd::cxx::tree::optional< CoreTemperatureHigh_type > CoreTemperatureHigh_optional;

          typedef ::xsd::cxx::tree::traits< CoreTemperatureHigh_type, char > CoreTemperatureHigh_traits;

          const CoreTemperatureHigh_optional&
          CoreTemperatureHigh () const;

          CoreTemperatureHigh_optional&
          CoreTemperatureHigh ();

          void
          CoreTemperatureHigh (const CoreTemperatureHigh_type& x);

          void
          CoreTemperatureHigh (const CoreTemperatureHigh_optional& x);

          void
          CoreTemperatureHigh (::std::unique_ptr< CoreTemperatureHigh_type > p);



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

          typedef ::xsd::cxx::tree::optional< DeltaCoreTemperatureLow_type > DeltaCoreTemperatureLow_optional;

          typedef ::xsd::cxx::tree::traits< DeltaCoreTemperatureLow_type, char > DeltaCoreTemperatureLow_traits;

          const DeltaCoreTemperatureLow_optional&
          DeltaCoreTemperatureLow () const;

          DeltaCoreTemperatureLow_optional&
          DeltaCoreTemperatureLow ();

          void
          DeltaCoreTemperatureLow (const DeltaCoreTemperatureLow_type& x);

          void
          DeltaCoreTemperatureLow (const DeltaCoreTemperatureLow_optional& x);

          void
          DeltaCoreTemperatureLow (::std::unique_ptr< DeltaCoreTemperatureLow_type > p);



          typedef ::mil::tatrc::physiology::datamodel::ScalarEnergyPerAmountData EnergyPerATP_type;

          typedef ::xsd::cxx::tree::optional< EnergyPerATP_type > EnergyPerATP_optional;

          typedef ::xsd::cxx::tree::traits< EnergyPerATP_type, char > EnergyPerATP_traits;

          const EnergyPerATP_optional&
          EnergyPerATP () const;

          EnergyPerATP_optional&
          EnergyPerATP ();

          void
          EnergyPerATP (const EnergyPerATP_type& x);

          void
          EnergyPerATP (const EnergyPerATP_optional& x);

          void
          EnergyPerATP (::std::unique_ptr< EnergyPerATP_type > p);



          typedef ::mil::tatrc::physiology::datamodel::ScalarHeatConductanceData SweatHeatTransfer_type;

          typedef ::xsd::cxx::tree::optional< SweatHeatTransfer_type > SweatHeatTransfer_optional;

          typedef ::xsd::cxx::tree::traits< SweatHeatTransfer_type, char > SweatHeatTransfer_traits;

          const SweatHeatTransfer_optional&
          SweatHeatTransfer () const;

          SweatHeatTransfer_optional&
          SweatHeatTransfer ();

          void
          SweatHeatTransfer (const SweatHeatTransfer_type& x);

          void
          SweatHeatTransfer (const SweatHeatTransfer_optional& x);

          void
          SweatHeatTransfer (::std::unique_ptr< SweatHeatTransfer_type > p);



          typedef ::mil::tatrc::physiology::datamodel::ScalarEnergyPerMassData VaporizationEnergy_type;

          typedef ::xsd::cxx::tree::optional< VaporizationEnergy_type > VaporizationEnergy_optional;

          typedef ::xsd::cxx::tree::traits< VaporizationEnergy_type, char > VaporizationEnergy_traits;

          const VaporizationEnergy_optional&
          VaporizationEnergy () const;

          VaporizationEnergy_optional&
          VaporizationEnergy ();

          void
          VaporizationEnergy (const VaporizationEnergy_type& x);

          void
          VaporizationEnergy (const VaporizationEnergy_optional& x);

          void
          VaporizationEnergy (::std::unique_ptr< VaporizationEnergy_type > p);



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

          typedef ::xsd::cxx::tree::optional< VaporSpecificHeat_type > VaporSpecificHeat_optional;

          typedef ::xsd::cxx::tree::traits< VaporSpecificHeat_type, char > VaporSpecificHeat_traits;

          const VaporSpecificHeat_optional&
          VaporSpecificHeat () const;

          VaporSpecificHeat_optional&
          VaporSpecificHeat ();

          void
          VaporSpecificHeat (const VaporSpecificHeat_type& x);

          void
          VaporSpecificHeat (const VaporSpecificHeat_optional& x);

          void
          VaporSpecificHeat (::std::unique_ptr< VaporSpecificHeat_type > p);



          EnergyConfigurationData ();

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

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

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

          EnergyConfigurationData&
          operator= (const EnergyConfigurationData& x);


          virtual 
          ~EnergyConfigurationData ();

          // Implementation.
          //

          //@cond

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

          protected:
          BodySpecificHeat_optional BodySpecificHeat_;
          CoreTemperatureLow_optional CoreTemperatureLow_;
          CoreTemperatureHigh_optional CoreTemperatureHigh_;
          DeltaCoreTemperatureLow_optional DeltaCoreTemperatureLow_;
          EnergyPerATP_optional EnergyPerATP_;
          SweatHeatTransfer_optional SweatHeatTransfer_;
          VaporizationEnergy_optional VaporizationEnergy_;
          VaporSpecificHeat_optional VaporSpecificHeat_;

          //@endcond
        };

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

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

          typedef ::xsd::cxx::tree::optional< AirDensity_type > AirDensity_optional;

          typedef ::xsd::cxx::tree::traits< AirDensity_type, char > AirDensity_traits;

          const AirDensity_optional&
          AirDensity () const;

          AirDensity_optional&
          AirDensity ();

          void
          AirDensity (const AirDensity_type& x);

          void
          AirDensity (const AirDensity_optional& x);

          void
          AirDensity (::std::unique_ptr< AirDensity_type > p);



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

          typedef ::xsd::cxx::tree::optional< AirSpecificHeat_type > AirSpecificHeat_optional;

          typedef ::xsd::cxx::tree::traits< AirSpecificHeat_type, char > AirSpecificHeat_traits;

          const AirSpecificHeat_optional&
          AirSpecificHeat () const;

          AirSpecificHeat_optional&
          AirSpecificHeat ();

          void
          AirSpecificHeat (const AirSpecificHeat_type& x);

          void
          AirSpecificHeat (const AirSpecificHeat_optional& x);

          void
          AirSpecificHeat (::std::unique_ptr< AirSpecificHeat_type > p);



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

          typedef ::xsd::cxx::tree::optional< MolarMassOfDryAir_type > MolarMassOfDryAir_optional;

          typedef ::xsd::cxx::tree::traits< MolarMassOfDryAir_type, char > MolarMassOfDryAir_traits;

          const MolarMassOfDryAir_optional&
          MolarMassOfDryAir () const;

          MolarMassOfDryAir_optional&
          MolarMassOfDryAir ();

          void
          MolarMassOfDryAir (const MolarMassOfDryAir_type& x);

          void
          MolarMassOfDryAir (const MolarMassOfDryAir_optional& x);

          void
          MolarMassOfDryAir (::std::unique_ptr< MolarMassOfDryAir_type > p);



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

          typedef ::xsd::cxx::tree::optional< MolarMassOfWaterVapor_type > MolarMassOfWaterVapor_optional;

          typedef ::xsd::cxx::tree::traits< MolarMassOfWaterVapor_type, char > MolarMassOfWaterVapor_traits;

          const MolarMassOfWaterVapor_optional&
          MolarMassOfWaterVapor () const;

          MolarMassOfWaterVapor_optional&
          MolarMassOfWaterVapor ();

          void
          MolarMassOfWaterVapor (const MolarMassOfWaterVapor_type& x);

          void
          MolarMassOfWaterVapor (const MolarMassOfWaterVapor_optional& x);

          void
          MolarMassOfWaterVapor (::std::unique_ptr< MolarMassOfWaterVapor_type > p);



          typedef ::mil::tatrc::physiology::datamodel::EnvironmentalConditionsData InitialEnvironmentalConditions_type;

          typedef ::xsd::cxx::tree::optional< InitialEnvironmentalConditions_type > InitialEnvironmentalConditions_optional;

          typedef ::xsd::cxx::tree::traits< InitialEnvironmentalConditions_type, char > InitialEnvironmentalConditions_traits;

          const InitialEnvironmentalConditions_optional&
          InitialEnvironmentalConditions () const;

          InitialEnvironmentalConditions_optional&
          InitialEnvironmentalConditions ();

          void
          InitialEnvironmentalConditions (const InitialEnvironmentalConditions_type& x);

          void
          InitialEnvironmentalConditions (const InitialEnvironmentalConditions_optional& x);

          void
          InitialEnvironmentalConditions (::std::unique_ptr< InitialEnvironmentalConditions_type > p);



          typedef ::xml_schema::string InitialEnvironmentalConditionsFile_type;

          typedef ::xsd::cxx::tree::optional< InitialEnvironmentalConditionsFile_type > InitialEnvironmentalConditionsFile_optional;

          typedef ::xsd::cxx::tree::traits< InitialEnvironmentalConditionsFile_type, char > InitialEnvironmentalConditionsFile_traits;

          const InitialEnvironmentalConditionsFile_optional&
          InitialEnvironmentalConditionsFile () const;

          InitialEnvironmentalConditionsFile_optional&
          InitialEnvironmentalConditionsFile ();

          void
          InitialEnvironmentalConditionsFile (const InitialEnvironmentalConditionsFile_type& x);

          void
          InitialEnvironmentalConditionsFile (const InitialEnvironmentalConditionsFile_optional& x);

          void
          InitialEnvironmentalConditionsFile (::std::unique_ptr< InitialEnvironmentalConditionsFile_type > p);



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

          typedef ::xsd::cxx::tree::optional< WaterDensity_type > WaterDensity_optional;

          typedef ::xsd::cxx::tree::traits< WaterDensity_type, char > WaterDensity_traits;

          const WaterDensity_optional&
          WaterDensity () const;

          WaterDensity_optional&
          WaterDensity ();

          void
          WaterDensity (const WaterDensity_type& x);

          void
          WaterDensity (const WaterDensity_optional& x);

          void
          WaterDensity (::std::unique_ptr< WaterDensity_type > p);



          EnvironmentConfigurationData ();

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

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

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

          EnvironmentConfigurationData&
          operator= (const EnvironmentConfigurationData& x);


          virtual 
          ~EnvironmentConfigurationData ();

          // Implementation.
          //

          //@cond

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

          protected:
          AirDensity_optional AirDensity_;
          AirSpecificHeat_optional AirSpecificHeat_;
          MolarMassOfDryAir_optional MolarMassOfDryAir_;
          MolarMassOfWaterVapor_optional MolarMassOfWaterVapor_;
          InitialEnvironmentalConditions_optional InitialEnvironmentalConditions_;
          InitialEnvironmentalConditionsFile_optional InitialEnvironmentalConditionsFile_;
          WaterDensity_optional WaterDensity_;

          //@endcond
        };

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

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

          typedef ::xsd::cxx::tree::optional< CalciumAbsorptionFraction_type > CalciumAbsorptionFraction_optional;

          typedef ::xsd::cxx::tree::traits< CalciumAbsorptionFraction_type, char > CalciumAbsorptionFraction_traits;

          const CalciumAbsorptionFraction_optional&
          CalciumAbsorptionFraction () const;

          CalciumAbsorptionFraction_optional&
          CalciumAbsorptionFraction ();

          void
          CalciumAbsorptionFraction (const CalciumAbsorptionFraction_type& x);

          void
          CalciumAbsorptionFraction (const CalciumAbsorptionFraction_optional& x);

          void
          CalciumAbsorptionFraction (::std::unique_ptr< CalciumAbsorptionFraction_type > p);



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

          typedef ::xsd::cxx::tree::optional< CalciumDigestionRate_type > CalciumDigestionRate_optional;

          typedef ::xsd::cxx::tree::traits< CalciumDigestionRate_type, char > CalciumDigestionRate_traits;

          const CalciumDigestionRate_optional&
          CalciumDigestionRate () const;

          CalciumDigestionRate_optional&
          CalciumDigestionRate ();

          void
          CalciumDigestionRate (const CalciumDigestionRate_type& x);

          void
          CalciumDigestionRate (const CalciumDigestionRate_optional& x);

          void
          CalciumDigestionRate (::std::unique_ptr< CalciumDigestionRate_type > p);



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

          typedef ::xsd::cxx::tree::optional< CarbohydrateAbsorptionFraction_type > CarbohydrateAbsorptionFraction_optional;

          typedef ::xsd::cxx::tree::traits< CarbohydrateAbsorptionFraction_type, char > CarbohydrateAbsorptionFraction_traits;

          const CarbohydrateAbsorptionFraction_optional&
          CarbohydrateAbsorptionFraction () const;

          CarbohydrateAbsorptionFraction_optional&
          CarbohydrateAbsorptionFraction ();

          void
          CarbohydrateAbsorptionFraction (const CarbohydrateAbsorptionFraction_type& x);

          void
          CarbohydrateAbsorptionFraction (const CarbohydrateAbsorptionFraction_optional& x);

          void
          CarbohydrateAbsorptionFraction (::std::unique_ptr< CarbohydrateAbsorptionFraction_type > p);



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

          typedef ::xsd::cxx::tree::optional< DefaultStomachContents_type > DefaultStomachContents_optional;

          typedef ::xsd::cxx::tree::traits< DefaultStomachContents_type, char > DefaultStomachContents_traits;

          const DefaultStomachContents_optional&
          DefaultStomachContents () const;

          DefaultStomachContents_optional&
          DefaultStomachContents ();

          void
          DefaultStomachContents (const DefaultStomachContents_type& x);

          void
          DefaultStomachContents (const DefaultStomachContents_optional& x);

          void
          DefaultStomachContents (::std::unique_ptr< DefaultStomachContents_type > p);



          typedef ::xml_schema::string DefaultStomachContentsFile_type;

          typedef ::xsd::cxx::tree::optional< DefaultStomachContentsFile_type > DefaultStomachContentsFile_optional;

          typedef ::xsd::cxx::tree::traits< DefaultStomachContentsFile_type, char > DefaultStomachContentsFile_traits;

          const DefaultStomachContentsFile_optional&
          DefaultStomachContentsFile () const;

          DefaultStomachContentsFile_optional&
          DefaultStomachContentsFile ();

          void
          DefaultStomachContentsFile (const DefaultStomachContentsFile_type& x);

          void
          DefaultStomachContentsFile (const DefaultStomachContentsFile_optional& x);

          void
          DefaultStomachContentsFile (::std::unique_ptr< DefaultStomachContentsFile_type > p);



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

          typedef ::xsd::cxx::tree::optional< FatAbsorptionFraction_type > FatAbsorptionFraction_optional;

          typedef ::xsd::cxx::tree::traits< FatAbsorptionFraction_type, char > FatAbsorptionFraction_traits;

          const FatAbsorptionFraction_optional&
          FatAbsorptionFraction () const;

          FatAbsorptionFraction_optional&
          FatAbsorptionFraction ();

          void
          FatAbsorptionFraction (const FatAbsorptionFraction_type& x);

          void
          FatAbsorptionFraction (const FatAbsorptionFraction_optional& x);

          void
          FatAbsorptionFraction (::std::unique_ptr< FatAbsorptionFraction_type > p);



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

          typedef ::xsd::cxx::tree::optional< ProteinToUreaFraction_type > ProteinToUreaFraction_optional;

          typedef ::xsd::cxx::tree::traits< ProteinToUreaFraction_type, char > ProteinToUreaFraction_traits;

          const ProteinToUreaFraction_optional&
          ProteinToUreaFraction () const;

          ProteinToUreaFraction_optional&
          ProteinToUreaFraction ();

          void
          ProteinToUreaFraction (const ProteinToUreaFraction_type& x);

          void
          ProteinToUreaFraction (const ProteinToUreaFraction_optional& x);

          void
          ProteinToUreaFraction (::std::unique_ptr< ProteinToUreaFraction_type > p);



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

          typedef ::xsd::cxx::tree::optional< WaterDigestionRate_type > WaterDigestionRate_optional;

          typedef ::xsd::cxx::tree::traits< WaterDigestionRate_type, char > WaterDigestionRate_traits;

          const WaterDigestionRate_optional&
          WaterDigestionRate () const;

          WaterDigestionRate_optional&
          WaterDigestionRate ();

          void
          WaterDigestionRate (const WaterDigestionRate_type& x);

          void
          WaterDigestionRate (const WaterDigestionRate_optional& x);

          void
          WaterDigestionRate (::std::unique_ptr< WaterDigestionRate_type > p);



          GastrointestinalConfigurationData ();

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

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

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

          GastrointestinalConfigurationData&
          operator= (const GastrointestinalConfigurationData& x);


          virtual 
          ~GastrointestinalConfigurationData ();

          // Implementation.
          //

          //@cond

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

          protected:
          CalciumAbsorptionFraction_optional CalciumAbsorptionFraction_;
          CalciumDigestionRate_optional CalciumDigestionRate_;
          CarbohydrateAbsorptionFraction_optional CarbohydrateAbsorptionFraction_;
          DefaultStomachContents_optional DefaultStomachContents_;
          DefaultStomachContentsFile_optional DefaultStomachContentsFile_;
          FatAbsorptionFraction_optional FatAbsorptionFraction_;
          ProteinToUreaFraction_optional ProteinToUreaFraction_;
          WaterDigestionRate_optional WaterDigestionRate_;

          //@endcond
        };

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

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

          typedef ::xsd::cxx::tree::optional< EnableCerebral_type > EnableCerebral_optional;

          typedef ::xsd::cxx::tree::traits< EnableCerebral_type, char > EnableCerebral_traits;

          const EnableCerebral_optional&
          EnableCerebral () const;

          EnableCerebral_optional&
          EnableCerebral ();

          void
          EnableCerebral (const EnableCerebral_type& x);

          void
          EnableCerebral (const EnableCerebral_optional& x);

          void
          EnableCerebral (::std::unique_ptr< EnableCerebral_type > p);



          typedef ::mil::tatrc::physiology::datamodel::ScalarLengthData PupilDiameterBaseline_type;

          typedef ::xsd::cxx::tree::optional< PupilDiameterBaseline_type > PupilDiameterBaseline_optional;

          typedef ::xsd::cxx::tree::traits< PupilDiameterBaseline_type, char > PupilDiameterBaseline_traits;

          const PupilDiameterBaseline_optional&
          PupilDiameterBaseline () const;

          PupilDiameterBaseline_optional&
          PupilDiameterBaseline ();

          void
          PupilDiameterBaseline (const PupilDiameterBaseline_type& x);

          void
          PupilDiameterBaseline (const PupilDiameterBaseline_optional& x);

          void
          PupilDiameterBaseline (::std::unique_ptr< PupilDiameterBaseline_type > p);



          NervousConfigurationData ();

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

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

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

          NervousConfigurationData&
          operator= (const NervousConfigurationData& x);


          virtual 
          ~NervousConfigurationData ();

          // Implementation.
          //

          //@cond

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

          protected:
          EnableCerebral_optional EnableCerebral_;
          PupilDiameterBaseline_optional PupilDiameterBaseline_;

          //@endcond
        };

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

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

          typedef ::xsd::cxx::tree::optional< EnableRenal_type > EnableRenal_optional;

          typedef ::xsd::cxx::tree::traits< EnableRenal_type, char > EnableRenal_traits;

          const EnableRenal_optional&
          EnableRenal () const;

          EnableRenal_optional&
          EnableRenal ();

          void
          EnableRenal (const EnableRenal_type& x);

          void
          EnableRenal (const EnableRenal_optional& x);

          void
          EnableRenal (::std::unique_ptr< EnableRenal_type > p);



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

          typedef ::xsd::cxx::tree::optional< PlasmaSodiumConcentrationSetPoint_type > PlasmaSodiumConcentrationSetPoint_optional;

          typedef ::xsd::cxx::tree::traits< PlasmaSodiumConcentrationSetPoint_type, char > PlasmaSodiumConcentrationSetPoint_traits;

          const PlasmaSodiumConcentrationSetPoint_optional&
          PlasmaSodiumConcentrationSetPoint () const;

          PlasmaSodiumConcentrationSetPoint_optional&
          PlasmaSodiumConcentrationSetPoint ();

          void
          PlasmaSodiumConcentrationSetPoint (const PlasmaSodiumConcentrationSetPoint_type& x);

          void
          PlasmaSodiumConcentrationSetPoint (const PlasmaSodiumConcentrationSetPoint_optional& x);

          void
          PlasmaSodiumConcentrationSetPoint (::std::unique_ptr< PlasmaSodiumConcentrationSetPoint_type > p);



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

          typedef ::xsd::cxx::tree::optional< LeftGlomerularFilteringSurfaceAreaBaseline_type > LeftGlomerularFilteringSurfaceAreaBaseline_optional;

          typedef ::xsd::cxx::tree::traits< LeftGlomerularFilteringSurfaceAreaBaseline_type, char > LeftGlomerularFilteringSurfaceAreaBaseline_traits;

          const LeftGlomerularFilteringSurfaceAreaBaseline_optional&
          LeftGlomerularFilteringSurfaceAreaBaseline () const;

          LeftGlomerularFilteringSurfaceAreaBaseline_optional&
          LeftGlomerularFilteringSurfaceAreaBaseline ();

          void
          LeftGlomerularFilteringSurfaceAreaBaseline (const LeftGlomerularFilteringSurfaceAreaBaseline_type& x);

          void
          LeftGlomerularFilteringSurfaceAreaBaseline (const LeftGlomerularFilteringSurfaceAreaBaseline_optional& x);

          void
          LeftGlomerularFilteringSurfaceAreaBaseline (::std::unique_ptr< LeftGlomerularFilteringSurfaceAreaBaseline_type > p);



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

          typedef ::xsd::cxx::tree::optional< LeftGlomerularFluidPermeabilityBaseline_type > LeftGlomerularFluidPermeabilityBaseline_optional;

          typedef ::xsd::cxx::tree::traits< LeftGlomerularFluidPermeabilityBaseline_type, char > LeftGlomerularFluidPermeabilityBaseline_traits;

          const LeftGlomerularFluidPermeabilityBaseline_optional&
          LeftGlomerularFluidPermeabilityBaseline () const;

          LeftGlomerularFluidPermeabilityBaseline_optional&
          LeftGlomerularFluidPermeabilityBaseline ();

          void
          LeftGlomerularFluidPermeabilityBaseline (const LeftGlomerularFluidPermeabilityBaseline_type& x);

          void
          LeftGlomerularFluidPermeabilityBaseline (const LeftGlomerularFluidPermeabilityBaseline_optional& x);

          void
          LeftGlomerularFluidPermeabilityBaseline (::std::unique_ptr< LeftGlomerularFluidPermeabilityBaseline_type > p);



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

          typedef ::xsd::cxx::tree::optional< LeftTubularReabsorptionFilteringSurfaceAreaBaseline_type > LeftTubularReabsorptionFilteringSurfaceAreaBaseline_optional;

          typedef ::xsd::cxx::tree::traits< LeftTubularReabsorptionFilteringSurfaceAreaBaseline_type, char > LeftTubularReabsorptionFilteringSurfaceAreaBaseline_traits;

          const LeftTubularReabsorptionFilteringSurfaceAreaBaseline_optional&
          LeftTubularReabsorptionFilteringSurfaceAreaBaseline () const;

          LeftTubularReabsorptionFilteringSurfaceAreaBaseline_optional&
          LeftTubularReabsorptionFilteringSurfaceAreaBaseline ();

          void
          LeftTubularReabsorptionFilteringSurfaceAreaBaseline (const LeftTubularReabsorptionFilteringSurfaceAreaBaseline_type& x);

          void
          LeftTubularReabsorptionFilteringSurfaceAreaBaseline (const LeftTubularReabsorptionFilteringSurfaceAreaBaseline_optional& x);

          void
          LeftTubularReabsorptionFilteringSurfaceAreaBaseline (::std::unique_ptr< LeftTubularReabsorptionFilteringSurfaceAreaBaseline_type > p);



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

          typedef ::xsd::cxx::tree::optional< LeftTubularReabsorptionFluidPermeabilityBaseline_type > LeftTubularReabsorptionFluidPermeabilityBaseline_optional;

          typedef ::xsd::cxx::tree::traits< LeftTubularReabsorptionFluidPermeabilityBaseline_type, char > LeftTubularReabsorptionFluidPermeabilityBaseline_traits;

          const LeftTubularReabsorptionFluidPermeabilityBaseline_optional&
          LeftTubularReabsorptionFluidPermeabilityBaseline () const;

          LeftTubularReabsorptionFluidPermeabilityBaseline_optional&
          LeftTubularReabsorptionFluidPermeabilityBaseline ();

          void
          LeftTubularReabsorptionFluidPermeabilityBaseline (const LeftTubularReabsorptionFluidPermeabilityBaseline_type& x);

          void
          LeftTubularReabsorptionFluidPermeabilityBaseline (const LeftTubularReabsorptionFluidPermeabilityBaseline_optional& x);

          void
          LeftTubularReabsorptionFluidPermeabilityBaseline (::std::unique_ptr< LeftTubularReabsorptionFluidPermeabilityBaseline_type > p);



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

          typedef ::xsd::cxx::tree::optional< MaximumAfferentResistance_type > MaximumAfferentResistance_optional;

          typedef ::xsd::cxx::tree::traits< MaximumAfferentResistance_type, char > MaximumAfferentResistance_traits;

          const MaximumAfferentResistance_optional&
          MaximumAfferentResistance () const;

          MaximumAfferentResistance_optional&
          MaximumAfferentResistance ();

          void
          MaximumAfferentResistance (const MaximumAfferentResistance_type& x);

          void
          MaximumAfferentResistance (const MaximumAfferentResistance_optional& x);

          void
          MaximumAfferentResistance (::std::unique_ptr< MaximumAfferentResistance_type > p);



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

          typedef ::xsd::cxx::tree::optional< MinimumAfferentResistance_type > MinimumAfferentResistance_optional;

          typedef ::xsd::cxx::tree::traits< MinimumAfferentResistance_type, char > MinimumAfferentResistance_traits;

          const MinimumAfferentResistance_optional&
          MinimumAfferentResistance () const;

          MinimumAfferentResistance_optional&
          MinimumAfferentResistance ();

          void
          MinimumAfferentResistance (const MinimumAfferentResistance_type& x);

          void
          MinimumAfferentResistance (const MinimumAfferentResistance_optional& x);

          void
          MinimumAfferentResistance (::std::unique_ptr< MinimumAfferentResistance_type > p);



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

          typedef ::xsd::cxx::tree::optional< RightGlomerularFilteringSurfaceAreaBaseline_type > RightGlomerularFilteringSurfaceAreaBaseline_optional;

          typedef ::xsd::cxx::tree::traits< RightGlomerularFilteringSurfaceAreaBaseline_type, char > RightGlomerularFilteringSurfaceAreaBaseline_traits;

          const RightGlomerularFilteringSurfaceAreaBaseline_optional&
          RightGlomerularFilteringSurfaceAreaBaseline () const;

          RightGlomerularFilteringSurfaceAreaBaseline_optional&
          RightGlomerularFilteringSurfaceAreaBaseline ();

          void
          RightGlomerularFilteringSurfaceAreaBaseline (const RightGlomerularFilteringSurfaceAreaBaseline_type& x);

          void
          RightGlomerularFilteringSurfaceAreaBaseline (const RightGlomerularFilteringSurfaceAreaBaseline_optional& x);

          void
          RightGlomerularFilteringSurfaceAreaBaseline (::std::unique_ptr< RightGlomerularFilteringSurfaceAreaBaseline_type > p);



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

          typedef ::xsd::cxx::tree::optional< RightGlomerularFluidPermeabilityBaseline_type > RightGlomerularFluidPermeabilityBaseline_optional;

          typedef ::xsd::cxx::tree::traits< RightGlomerularFluidPermeabilityBaseline_type, char > RightGlomerularFluidPermeabilityBaseline_traits;

          const RightGlomerularFluidPermeabilityBaseline_optional&
          RightGlomerularFluidPermeabilityBaseline () const;

          RightGlomerularFluidPermeabilityBaseline_optional&
          RightGlomerularFluidPermeabilityBaseline ();

          void
          RightGlomerularFluidPermeabilityBaseline (const RightGlomerularFluidPermeabilityBaseline_type& x);

          void
          RightGlomerularFluidPermeabilityBaseline (const RightGlomerularFluidPermeabilityBaseline_optional& x);

          void
          RightGlomerularFluidPermeabilityBaseline (::std::unique_ptr< RightGlomerularFluidPermeabilityBaseline_type > p);



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

          typedef ::xsd::cxx::tree::optional< RightTubularReabsorptionFilteringSurfaceAreaBaseline_type > RightTubularReabsorptionFilteringSurfaceAreaBaseline_optional;

          typedef ::xsd::cxx::tree::traits< RightTubularReabsorptionFilteringSurfaceAreaBaseline_type, char > RightTubularReabsorptionFilteringSurfaceAreaBaseline_traits;

          const RightTubularReabsorptionFilteringSurfaceAreaBaseline_optional&
          RightTubularReabsorptionFilteringSurfaceAreaBaseline () const;

          RightTubularReabsorptionFilteringSurfaceAreaBaseline_optional&
          RightTubularReabsorptionFilteringSurfaceAreaBaseline ();

          void
          RightTubularReabsorptionFilteringSurfaceAreaBaseline (const RightTubularReabsorptionFilteringSurfaceAreaBaseline_type& x);

          void
          RightTubularReabsorptionFilteringSurfaceAreaBaseline (const RightTubularReabsorptionFilteringSurfaceAreaBaseline_optional& x);

          void
          RightTubularReabsorptionFilteringSurfaceAreaBaseline (::std::unique_ptr< RightTubularReabsorptionFilteringSurfaceAreaBaseline_type > p);



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

          typedef ::xsd::cxx::tree::optional< RightTubularReabsorptionFluidPermeabilityBaseline_type > RightTubularReabsorptionFluidPermeabilityBaseline_optional;

          typedef ::xsd::cxx::tree::traits< RightTubularReabsorptionFluidPermeabilityBaseline_type, char > RightTubularReabsorptionFluidPermeabilityBaseline_traits;

          const RightTubularReabsorptionFluidPermeabilityBaseline_optional&
          RightTubularReabsorptionFluidPermeabilityBaseline () const;

          RightTubularReabsorptionFluidPermeabilityBaseline_optional&
          RightTubularReabsorptionFluidPermeabilityBaseline ();

          void
          RightTubularReabsorptionFluidPermeabilityBaseline (const RightTubularReabsorptionFluidPermeabilityBaseline_type& x);

          void
          RightTubularReabsorptionFluidPermeabilityBaseline (const RightTubularReabsorptionFluidPermeabilityBaseline_optional& x);

          void
          RightTubularReabsorptionFluidPermeabilityBaseline (::std::unique_ptr< RightTubularReabsorptionFluidPermeabilityBaseline_type > p);



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

          typedef ::xsd::cxx::tree::optional< TargetSodiumDelivery_type > TargetSodiumDelivery_optional;

          typedef ::xsd::cxx::tree::traits< TargetSodiumDelivery_type, char > TargetSodiumDelivery_traits;

          const TargetSodiumDelivery_optional&
          TargetSodiumDelivery () const;

          TargetSodiumDelivery_optional&
          TargetSodiumDelivery ();

          void
          TargetSodiumDelivery (const TargetSodiumDelivery_type& x);

          void
          TargetSodiumDelivery (const TargetSodiumDelivery_optional& x);

          void
          TargetSodiumDelivery (::std::unique_ptr< TargetSodiumDelivery_type > p);



          RenalConfigurationData ();

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

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

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

          RenalConfigurationData&
          operator= (const RenalConfigurationData& x);


          virtual 
          ~RenalConfigurationData ();

          // Implementation.
          //

          //@cond

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

          protected:
          EnableRenal_optional EnableRenal_;
          PlasmaSodiumConcentrationSetPoint_optional PlasmaSodiumConcentrationSetPoint_;
          LeftGlomerularFilteringSurfaceAreaBaseline_optional LeftGlomerularFilteringSurfaceAreaBaseline_;
          LeftGlomerularFluidPermeabilityBaseline_optional LeftGlomerularFluidPermeabilityBaseline_;
          LeftTubularReabsorptionFilteringSurfaceAreaBaseline_optional LeftTubularReabsorptionFilteringSurfaceAreaBaseline_;
          LeftTubularReabsorptionFluidPermeabilityBaseline_optional LeftTubularReabsorptionFluidPermeabilityBaseline_;
          MaximumAfferentResistance_optional MaximumAfferentResistance_;
          MinimumAfferentResistance_optional MinimumAfferentResistance_;
          RightGlomerularFilteringSurfaceAreaBaseline_optional RightGlomerularFilteringSurfaceAreaBaseline_;
          RightGlomerularFluidPermeabilityBaseline_optional RightGlomerularFluidPermeabilityBaseline_;
          RightTubularReabsorptionFilteringSurfaceAreaBaseline_optional RightTubularReabsorptionFilteringSurfaceAreaBaseline_;
          RightTubularReabsorptionFluidPermeabilityBaseline_optional RightTubularReabsorptionFluidPermeabilityBaseline_;
          TargetSodiumDelivery_optional TargetSodiumDelivery_;

          //@endcond
        };

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

          typedef ::mil::tatrc::physiology::datamodel::ScalarInverseVolumeData PleuralComplianceSensitivity_type;

          typedef ::xsd::cxx::tree::optional< PleuralComplianceSensitivity_type > PleuralComplianceSensitivity_optional;

          typedef ::xsd::cxx::tree::traits< PleuralComplianceSensitivity_type, char > PleuralComplianceSensitivity_traits;

          const PleuralComplianceSensitivity_optional&
          PleuralComplianceSensitivity () const;

          PleuralComplianceSensitivity_optional&
          PleuralComplianceSensitivity ();

          void
          PleuralComplianceSensitivity (const PleuralComplianceSensitivity_type& x);

          void
          PleuralComplianceSensitivity (const PleuralComplianceSensitivity_optional& x);

          void
          PleuralComplianceSensitivity (::std::unique_ptr< PleuralComplianceSensitivity_type > p);



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

          typedef ::xsd::cxx::tree::optional< PulmonaryVentilationRateMaximum_type > PulmonaryVentilationRateMaximum_optional;

          typedef ::xsd::cxx::tree::traits< PulmonaryVentilationRateMaximum_type, char > PulmonaryVentilationRateMaximum_traits;

          const PulmonaryVentilationRateMaximum_optional&
          PulmonaryVentilationRateMaximum () const;

          PulmonaryVentilationRateMaximum_optional&
          PulmonaryVentilationRateMaximum ();

          void
          PulmonaryVentilationRateMaximum (const PulmonaryVentilationRateMaximum_type& x);

          void
          PulmonaryVentilationRateMaximum (const PulmonaryVentilationRateMaximum_optional& x);

          void
          PulmonaryVentilationRateMaximum (::std::unique_ptr< PulmonaryVentilationRateMaximum_type > p);



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

          typedef ::xsd::cxx::tree::optional< VentilatoryOcclusionPressure_type > VentilatoryOcclusionPressure_optional;

          typedef ::xsd::cxx::tree::traits< VentilatoryOcclusionPressure_type, char > VentilatoryOcclusionPressure_traits;

          const VentilatoryOcclusionPressure_optional&
          VentilatoryOcclusionPressure () const;

          VentilatoryOcclusionPressure_optional&
          VentilatoryOcclusionPressure ();

          void
          VentilatoryOcclusionPressure (const VentilatoryOcclusionPressure_type& x);

          void
          VentilatoryOcclusionPressure (const VentilatoryOcclusionPressure_optional& x);

          void
          VentilatoryOcclusionPressure (::std::unique_ptr< VentilatoryOcclusionPressure_type > p);



          RespiratoryConfigurationData ();

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

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

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

          RespiratoryConfigurationData&
          operator= (const RespiratoryConfigurationData& x);


          virtual 
          ~RespiratoryConfigurationData ();

          // Implementation.
          //

          //@cond

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

          protected:
          PleuralComplianceSensitivity_optional PleuralComplianceSensitivity_;
          PulmonaryVentilationRateMaximum_optional PulmonaryVentilationRateMaximum_;
          VentilatoryOcclusionPressure_optional VentilatoryOcclusionPressure_;

          //@endcond
        };

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

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

          typedef ::xsd::cxx::tree::optional< EnableTissue_type > EnableTissue_optional;

          typedef ::xsd::cxx::tree::traits< EnableTissue_type, char > EnableTissue_traits;

          const EnableTissue_optional&
          EnableTissue () const;

          EnableTissue_optional&
          EnableTissue ();

          void
          EnableTissue (const EnableTissue_type& x);

          void
          EnableTissue (const EnableTissue_optional& x);

          void
          EnableTissue (::std::unique_ptr< EnableTissue_type > p);



          TissueConfigurationData ();

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

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

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

          TissueConfigurationData&
          operator= (const TissueConfigurationData& x);


          virtual 
          ~TissueConfigurationData ();

          // Implementation.
          //

          //@cond

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

          protected:
          EnableTissue_optional EnableTissue_;

          //@endcond
        };

        class BIOGEARS_CDM_API BioGearsConfigurationData: public ::mil::tatrc::physiology::datamodel::PhysiologyEngineConfigurationData
        {
          public:

          typedef ::mil::tatrc::physiology::datamodel::BloodChemistryConfigurationData BloodChemistryConfiguration_type;

          typedef ::xsd::cxx::tree::optional< BloodChemistryConfiguration_type > BloodChemistryConfiguration_optional;

          typedef ::xsd::cxx::tree::traits< BloodChemistryConfiguration_type, char > BloodChemistryConfiguration_traits;

          const BloodChemistryConfiguration_optional&
          BloodChemistryConfiguration () const;

          BloodChemistryConfiguration_optional&
          BloodChemistryConfiguration ();

          void
          BloodChemistryConfiguration (const BloodChemistryConfiguration_type& x);

          void
          BloodChemistryConfiguration (const BloodChemistryConfiguration_optional& x);

          void
          BloodChemistryConfiguration (::std::unique_ptr< BloodChemistryConfiguration_type > p);



          typedef ::mil::tatrc::physiology::datamodel::CardiovascularConfigurationData CardiovascularConfiguration_type;

          typedef ::xsd::cxx::tree::optional< CardiovascularConfiguration_type > CardiovascularConfiguration_optional;

          typedef ::xsd::cxx::tree::traits< CardiovascularConfiguration_type, char > CardiovascularConfiguration_traits;

          const CardiovascularConfiguration_optional&
          CardiovascularConfiguration () const;

          CardiovascularConfiguration_optional&
          CardiovascularConfiguration ();

          void
          CardiovascularConfiguration (const CardiovascularConfiguration_type& x);

          void
          CardiovascularConfiguration (const CardiovascularConfiguration_optional& x);

          void
          CardiovascularConfiguration (::std::unique_ptr< CardiovascularConfiguration_type > p);



          typedef ::mil::tatrc::physiology::datamodel::CircuitConfigurationData CircuitConfiguration_type;

          typedef ::xsd::cxx::tree::optional< CircuitConfiguration_type > CircuitConfiguration_optional;

          typedef ::xsd::cxx::tree::traits< CircuitConfiguration_type, char > CircuitConfiguration_traits;

          const CircuitConfiguration_optional&
          CircuitConfiguration () const;

          CircuitConfiguration_optional&
          CircuitConfiguration ();

          void
          CircuitConfiguration (const CircuitConfiguration_type& x);

          void
          CircuitConfiguration (const CircuitConfiguration_optional& x);

          void
          CircuitConfiguration (::std::unique_ptr< CircuitConfiguration_type > p);



          typedef ::mil::tatrc::physiology::datamodel::ConstantsConfigurationData ConstantsConfiguration_type;

          typedef ::xsd::cxx::tree::optional< ConstantsConfiguration_type > ConstantsConfiguration_optional;

          typedef ::xsd::cxx::tree::traits< ConstantsConfiguration_type, char > ConstantsConfiguration_traits;

          const ConstantsConfiguration_optional&
          ConstantsConfiguration () const;

          ConstantsConfiguration_optional&
          ConstantsConfiguration ();

          void
          ConstantsConfiguration (const ConstantsConfiguration_type& x);

          void
          ConstantsConfiguration (const ConstantsConfiguration_optional& x);

          void
          ConstantsConfiguration (::std::unique_ptr< ConstantsConfiguration_type > p);



          typedef ::mil::tatrc::physiology::datamodel::DrugsConfigurationData DrugsConfiguration_type;

          typedef ::xsd::cxx::tree::optional< DrugsConfiguration_type > DrugsConfiguration_optional;

          typedef ::xsd::cxx::tree::traits< DrugsConfiguration_type, char > DrugsConfiguration_traits;

          const DrugsConfiguration_optional&
          DrugsConfiguration () const;

          DrugsConfiguration_optional&
          DrugsConfiguration ();

          void
          DrugsConfiguration (const DrugsConfiguration_type& x);

          void
          DrugsConfiguration (const DrugsConfiguration_optional& x);

          void
          DrugsConfiguration (::std::unique_ptr< DrugsConfiguration_type > p);



          typedef ::mil::tatrc::physiology::datamodel::EnergyConfigurationData EnergyConfiguration_type;

          typedef ::xsd::cxx::tree::optional< EnergyConfiguration_type > EnergyConfiguration_optional;

          typedef ::xsd::cxx::tree::traits< EnergyConfiguration_type, char > EnergyConfiguration_traits;

          const EnergyConfiguration_optional&
          EnergyConfiguration () const;

          EnergyConfiguration_optional&
          EnergyConfiguration ();

          void
          EnergyConfiguration (const EnergyConfiguration_type& x);

          void
          EnergyConfiguration (const EnergyConfiguration_optional& x);

          void
          EnergyConfiguration (::std::unique_ptr< EnergyConfiguration_type > p);



          typedef ::mil::tatrc::physiology::datamodel::EnvironmentConfigurationData EnvironmentConfiguration_type;

          typedef ::xsd::cxx::tree::optional< EnvironmentConfiguration_type > EnvironmentConfiguration_optional;

          typedef ::xsd::cxx::tree::traits< EnvironmentConfiguration_type, char > EnvironmentConfiguration_traits;

          const EnvironmentConfiguration_optional&
          EnvironmentConfiguration () const;

          EnvironmentConfiguration_optional&
          EnvironmentConfiguration ();

          void
          EnvironmentConfiguration (const EnvironmentConfiguration_type& x);

          void
          EnvironmentConfiguration (const EnvironmentConfiguration_optional& x);

          void
          EnvironmentConfiguration (::std::unique_ptr< EnvironmentConfiguration_type > p);



          typedef ::mil::tatrc::physiology::datamodel::GastrointestinalConfigurationData GastrointestinalConfiguration_type;

          typedef ::xsd::cxx::tree::optional< GastrointestinalConfiguration_type > GastrointestinalConfiguration_optional;

          typedef ::xsd::cxx::tree::traits< GastrointestinalConfiguration_type, char > GastrointestinalConfiguration_traits;

          const GastrointestinalConfiguration_optional&
          GastrointestinalConfiguration () const;

          GastrointestinalConfiguration_optional&
          GastrointestinalConfiguration ();

          void
          GastrointestinalConfiguration (const GastrointestinalConfiguration_type& x);

          void
          GastrointestinalConfiguration (const GastrointestinalConfiguration_optional& x);

          void
          GastrointestinalConfiguration (::std::unique_ptr< GastrointestinalConfiguration_type > p);



          typedef ::mil::tatrc::physiology::datamodel::NervousConfigurationData NervousConfiguration_type;

          typedef ::xsd::cxx::tree::optional< NervousConfiguration_type > NervousConfiguration_optional;

          typedef ::xsd::cxx::tree::traits< NervousConfiguration_type, char > NervousConfiguration_traits;

          const NervousConfiguration_optional&
          NervousConfiguration () const;

          NervousConfiguration_optional&
          NervousConfiguration ();

          void
          NervousConfiguration (const NervousConfiguration_type& x);

          void
          NervousConfiguration (const NervousConfiguration_optional& x);

          void
          NervousConfiguration (::std::unique_ptr< NervousConfiguration_type > p);



          typedef ::mil::tatrc::physiology::datamodel::RenalConfigurationData RenalConfiguration_type;

          typedef ::xsd::cxx::tree::optional< RenalConfiguration_type > RenalConfiguration_optional;

          typedef ::xsd::cxx::tree::traits< RenalConfiguration_type, char > RenalConfiguration_traits;

          const RenalConfiguration_optional&
          RenalConfiguration () const;

          RenalConfiguration_optional&
          RenalConfiguration ();

          void
          RenalConfiguration (const RenalConfiguration_type& x);

          void
          RenalConfiguration (const RenalConfiguration_optional& x);

          void
          RenalConfiguration (::std::unique_ptr< RenalConfiguration_type > p);



          typedef ::mil::tatrc::physiology::datamodel::RespiratoryConfigurationData RespiratoryConfiguration_type;

          typedef ::xsd::cxx::tree::optional< RespiratoryConfiguration_type > RespiratoryConfiguration_optional;

          typedef ::xsd::cxx::tree::traits< RespiratoryConfiguration_type, char > RespiratoryConfiguration_traits;

          const RespiratoryConfiguration_optional&
          RespiratoryConfiguration () const;

          RespiratoryConfiguration_optional&
          RespiratoryConfiguration ();

          void
          RespiratoryConfiguration (const RespiratoryConfiguration_type& x);

          void
          RespiratoryConfiguration (const RespiratoryConfiguration_optional& x);

          void
          RespiratoryConfiguration (::std::unique_ptr< RespiratoryConfiguration_type > p);



          typedef ::mil::tatrc::physiology::datamodel::TissueConfigurationData TissueConfiguration_type;

          typedef ::xsd::cxx::tree::optional< TissueConfiguration_type > TissueConfiguration_optional;

          typedef ::xsd::cxx::tree::traits< TissueConfiguration_type, char > TissueConfiguration_traits;

          const TissueConfiguration_optional&
          TissueConfiguration () const;

          TissueConfiguration_optional&
          TissueConfiguration ();

          void
          TissueConfiguration (const TissueConfiguration_type& x);

          void
          TissueConfiguration (const TissueConfiguration_optional& x);

          void
          TissueConfiguration (::std::unique_ptr< TissueConfiguration_type > p);



          BioGearsConfigurationData ();

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

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

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

          BioGearsConfigurationData&
          operator= (const BioGearsConfigurationData& x);


          virtual 
          ~BioGearsConfigurationData ();

          // Implementation.
          //

          //@cond

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

          protected:
          BloodChemistryConfiguration_optional BloodChemistryConfiguration_;
          CardiovascularConfiguration_optional CardiovascularConfiguration_;
          CircuitConfiguration_optional CircuitConfiguration_;
          ConstantsConfiguration_optional ConstantsConfiguration_;
          DrugsConfiguration_optional DrugsConfiguration_;
          EnergyConfiguration_optional EnergyConfiguration_;
          EnvironmentConfiguration_optional EnvironmentConfiguration_;
          GastrointestinalConfiguration_optional GastrointestinalConfiguration_;
          NervousConfiguration_optional NervousConfiguration_;
          RenalConfiguration_optional RenalConfiguration_;
          RespiratoryConfiguration_optional RespiratoryConfiguration_;
          TissueConfiguration_optional TissueConfiguration_;

          //@endcond
        };
      }
    }
  }
}

#include <iosfwd>

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

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

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

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

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

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

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

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

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

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

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

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

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

#include <iosfwd>

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

      }
    }
  }
}

#include <iosfwd>

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


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

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

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

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

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

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

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

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

      }
    }
  }
}

#include <xsd/cxx/post.hxx>

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

#endif // D__BIOGEARS_CORE_SHARE_XSD__BIOGEARS_BIO_GEARS_CONFIGURATION_HXX