text: // 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 SIM_SPATIAL_ZONE_THERMAL_ZONE_DEFAULT_HXX
  #define SIM_SPATIAL_ZONE_THERMAL_ZONE_DEFAULT_HXX
  
  #ifndef XSD_USE_CHAR
  #define XSD_USE_CHAR
  #endif
  
  #ifndef XSD_CXX_TREE_USE_CHAR
  #define XSD_CXX_TREE_USE_CHAR
  #endif
  
  // Begin prologue.
  //
  //
  // 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>
  
  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;
    // 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;
  
    // Error handler callback interface.
    //
    typedef ::xsd::cxx::xml::error_handler< char > error_handler;
  
    // DOM interaction.
    //
    namespace dom
    {
      // Automatic pointer for DOMDocument.
      //
      using ::xsd::cxx::xml::dom::auto_ptr;
  
  #ifndef XSD_CXX_TREE_TREE_NODE_KEY__XML_SCHEMA
  #define XSD_CXX_TREE_TREE_NODE_KEY__XML_SCHEMA
      // DOM user data key for back pointers to tree nodes.
      //
      const XMLCh* const tree_node_key = ::xsd::cxx::tree::user_data_keys::node;
  #endif
    }
  }
  
  // Forward declarations.
  //
  namespace schema
  {
    namespace simxml
    {
      namespace BuildingModel
      {
        class SimSpatialZone_ThermalZone_Default;
      }
    }
  }
  
  
  #include <memory>    // ::std::auto_ptr
  #include <limits>    // std::numeric_limits
  #include <algorithm> // std::binary_search
  
  #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 "simspatialzone_thermalzone.hxx"
  
  namespace schema
  {
    namespace simxml
    {
      namespace SimModelCore
      {
        class doubleList;
      }
    }
  }
  
  namespace schema
  {
    namespace simxml
    {
      namespace BuildingModel
      {
        class SimSpatialZone_ThermalZone_Default: public ::schema::simxml::BuildingModel::SimSpatialZone_ThermalZone
        {
          public:
          // ZoneConditioningRequirement
          //
          typedef ::xml_schema::string ZoneConditioningRequirement_type;
          typedef ::xsd::cxx::tree::optional< ZoneConditioningRequirement_type, false > ZoneConditioningRequirement_optional;
          typedef ::xsd::cxx::tree::traits< ZoneConditioningRequirement_type, char > ZoneConditioningRequirement_traits;
  
          const ZoneConditioningRequirement_optional&
          ZoneConditioningRequirement () const;
  
          ZoneConditioningRequirement_optional&
          ZoneConditioningRequirement ();
  
          void
          ZoneConditioningRequirement (const ZoneConditioningRequirement_type& x);
  
          void
          ZoneConditioningRequirement (const ZoneConditioningRequirement_optional& x);
  
          void
          ZoneConditioningRequirement (::std::auto_ptr< ZoneConditioningRequirement_type > p);
  
          // HVACSystemType
          //
          typedef ::xml_schema::string HVACSystemType_type;
          typedef ::xsd::cxx::tree::optional< HVACSystemType_type, false > HVACSystemType_optional;
          typedef ::xsd::cxx::tree::traits< HVACSystemType_type, char > HVACSystemType_traits;
  
          const HVACSystemType_optional&
          HVACSystemType () const;
  
          HVACSystemType_optional&
          HVACSystemType ();
  
          void
          HVACSystemType (const HVACSystemType_type& x);
  
          void
          HVACSystemType (const HVACSystemType_optional& x);
  
          void
          HVACSystemType (::std::auto_ptr< HVACSystemType_type > p);
  
          // UserDefinedHVACSystemType
          //
          typedef ::xml_schema::string UserDefinedHVACSystemType_type;
          typedef ::xsd::cxx::tree::optional< UserDefinedHVACSystemType_type, false > UserDefinedHVACSystemType_optional;
          typedef ::xsd::cxx::tree::traits< UserDefinedHVACSystemType_type, char > UserDefinedHVACSystemType_traits;
  
          const UserDefinedHVACSystemType_optional&
          UserDefinedHVACSystemType () const;
  
          UserDefinedHVACSystemType_optional&
          UserDefinedHVACSystemType ();
  
          void
          UserDefinedHVACSystemType (const UserDefinedHVACSystemType_type& x);
  
          void
          UserDefinedHVACSystemType (const UserDefinedHVACSystemType_optional& x);
  
          void
          UserDefinedHVACSystemType (::std::auto_ptr< UserDefinedHVACSystemType_type > p);
  
          // InfiltrationRate
          //
          typedef ::xml_schema::double_ InfiltrationRate_type;
          typedef ::xsd::cxx::tree::optional< InfiltrationRate_type, true > InfiltrationRate_optional;
          typedef ::xsd::cxx::tree::traits< InfiltrationRate_type, char, ::xsd::cxx::tree::schema_type::double_ > InfiltrationRate_traits;
  
          const InfiltrationRate_optional&
          InfiltrationRate () const;
  
          InfiltrationRate_optional&
          InfiltrationRate ();
  
          void
          InfiltrationRate (const InfiltrationRate_type& x);
  
          void
          InfiltrationRate (const InfiltrationRate_optional& x);
  
          // IsDaylitZone
          //
          typedef ::xml_schema::boolean IsDaylitZone_type;
          typedef ::xsd::cxx::tree::optional< IsDaylitZone_type > IsDaylitZone_optional;
          typedef ::xsd::cxx::tree::traits< IsDaylitZone_type, char > IsDaylitZone_traits;
  
          const IsDaylitZone_optional&
          IsDaylitZone () const;
  
          IsDaylitZone_optional&
          IsDaylitZone ();
  
          void
          IsDaylitZone (const IsDaylitZone_type& x);
  
          void
          IsDaylitZone (const IsDaylitZone_optional& x);
  
          // NumberOfDaylightingSensors
          //
          typedef ::xml_schema::double_ NumberOfDaylightingSensors_type;
          typedef ::xsd::cxx::tree::optional< NumberOfDaylightingSensors_type, true > NumberOfDaylightingSensors_optional;
          typedef ::xsd::cxx::tree::traits< NumberOfDaylightingSensors_type, char, ::xsd::cxx::tree::schema_type::double_ > NumberOfDaylightingSensors_traits;
  
          const NumberOfDaylightingSensors_optional&
          NumberOfDaylightingSensors () const;
  
          NumberOfDaylightingSensors_optional&
          NumberOfDaylightingSensors ();
  
          void
          NumberOfDaylightingSensors (const NumberOfDaylightingSensors_type& x);
  
          void
          NumberOfDaylightingSensors (const NumberOfDaylightingSensors_optional& x);
  
          // DesignIlluminance
          //
          typedef ::xml_schema::double_ DesignIlluminance_type;
          typedef ::xsd::cxx::tree::optional< DesignIlluminance_type, true > DesignIlluminance_optional;
          typedef ::xsd::cxx::tree::traits< DesignIlluminance_type, char, ::xsd::cxx::tree::schema_type::double_ > DesignIlluminance_traits;
  
          const DesignIlluminance_optional&
          DesignIlluminance () const;
  
          DesignIlluminance_optional&
          DesignIlluminance ();
  
          void
          DesignIlluminance (const DesignIlluminance_type& x);
  
          void
          DesignIlluminance (const DesignIlluminance_optional& x);
  
          // LightingControlsType
          //
          typedef ::xml_schema::string LightingControlsType_type;
          typedef ::xsd::cxx::tree::optional< LightingControlsType_type, false > LightingControlsType_optional;
          typedef ::xsd::cxx::tree::traits< LightingControlsType_type, char > LightingControlsType_traits;
  
          const LightingControlsType_optional&
          LightingControlsType () const;
  
          LightingControlsType_optional&
          LightingControlsType ();
  
          void
          LightingControlsType (const LightingControlsType_type& x);
  
          void
          LightingControlsType (const LightingControlsType_optional& x);
  
          void
          LightingControlsType (::std::auto_ptr< LightingControlsType_type > p);
  
          // ClassRef_ZoneTypeEnergy
          //
          typedef ::xml_schema::idref ClassRef_ZoneTypeEnergy_type;
          typedef ::xsd::cxx::tree::optional< ClassRef_ZoneTypeEnergy_type, false > ClassRef_ZoneTypeEnergy_optional;
          typedef ::xsd::cxx::tree::traits< ClassRef_ZoneTypeEnergy_type, char > ClassRef_ZoneTypeEnergy_traits;
  
          const ClassRef_ZoneTypeEnergy_optional&
          ClassRef_ZoneTypeEnergy () const;
  
          ClassRef_ZoneTypeEnergy_optional&
          ClassRef_ZoneTypeEnergy ();
  
          void
          ClassRef_ZoneTypeEnergy (const ClassRef_ZoneTypeEnergy_type& x);
  
          void
          ClassRef_ZoneTypeEnergy (const ClassRef_ZoneTypeEnergy_optional& x);
  
          void
          ClassRef_ZoneTypeEnergy (::std::auto_ptr< ClassRef_ZoneTypeEnergy_type > p);
  
          // AssignedSchedule
          //
          typedef ::xml_schema::idref AssignedSchedule_type;
          typedef ::xsd::cxx::tree::optional< AssignedSchedule_type, false > AssignedSchedule_optional;
          typedef ::xsd::cxx::tree::traits< AssignedSchedule_type, char > AssignedSchedule_traits;
  
          const AssignedSchedule_optional&
          AssignedSchedule () const;
  
          AssignedSchedule_optional&
          AssignedSchedule ();
  
          void
          AssignedSchedule (const AssignedSchedule_type& x);
  
          void
          AssignedSchedule (const AssignedSchedule_optional& x);
  
          void
          AssignedSchedule (::std::auto_ptr< AssignedSchedule_type > p);
  
          // SimSpatialZone_DirRelNorth
          //
          typedef ::xml_schema::double_ SimSpatialZone_DirRelNorth_type;
          typedef ::xsd::cxx::tree::optional< SimSpatialZone_DirRelNorth_type, true > SimSpatialZone_DirRelNorth_optional;
          typedef ::xsd::cxx::tree::traits< SimSpatialZone_DirRelNorth_type, char, ::xsd::cxx::tree::schema_type::double_ > SimSpatialZone_DirRelNorth_traits;
  
          const SimSpatialZone_DirRelNorth_optional&
          SimSpatialZone_DirRelNorth () const;
  
          SimSpatialZone_DirRelNorth_optional&
          SimSpatialZone_DirRelNorth ();
  
          void
          SimSpatialZone_DirRelNorth (const SimSpatialZone_DirRelNorth_type& x);
  
          void
          SimSpatialZone_DirRelNorth (const SimSpatialZone_DirRelNorth_optional& x);
  
          // SimSpatialZone_XOrigin
          //
          typedef ::xml_schema::double_ SimSpatialZone_XOrigin_type;
          typedef ::xsd::cxx::tree::optional< SimSpatialZone_XOrigin_type, true > SimSpatialZone_XOrigin_optional;
          typedef ::xsd::cxx::tree::traits< SimSpatialZone_XOrigin_type, char, ::xsd::cxx::tree::schema_type::double_ > SimSpatialZone_XOrigin_traits;
  
          const SimSpatialZone_XOrigin_optional&
          SimSpatialZone_XOrigin () const;
  
          SimSpatialZone_XOrigin_optional&
          SimSpatialZone_XOrigin ();
  
          void
          SimSpatialZone_XOrigin (const SimSpatialZone_XOrigin_type& x);
  
          void
          SimSpatialZone_XOrigin (const SimSpatialZone_XOrigin_optional& x);
  
          // SimSpatialZone_YOrigin
          //
          typedef ::xml_schema::double_ SimSpatialZone_YOrigin_type;
          typedef ::xsd::cxx::tree::optional< SimSpatialZone_YOrigin_type, true > SimSpatialZone_YOrigin_optional;
          typedef ::xsd::cxx::tree::traits< SimSpatialZone_YOrigin_type, char, ::xsd::cxx::tree::schema_type::double_ > SimSpatialZone_YOrigin_traits;
  
          const SimSpatialZone_YOrigin_optional&
          SimSpatialZone_YOrigin () const;
  
          SimSpatialZone_YOrigin_optional&
          SimSpatialZone_YOrigin ();
  
          void
          SimSpatialZone_YOrigin (const SimSpatialZone_YOrigin_type& x);
  
          void
          SimSpatialZone_YOrigin (const SimSpatialZone_YOrigin_optional& x);
  
          // SimSpatialZone_ZOrigin
          //
          typedef ::xml_schema::double_ SimSpatialZone_ZOrigin_type;
          typedef ::xsd::cxx::tree::optional< SimSpatialZone_ZOrigin_type, true > SimSpatialZone_ZOrigin_optional;
          typedef ::xsd::cxx::tree::traits< SimSpatialZone_ZOrigin_type, char, ::xsd::cxx::tree::schema_type::double_ > SimSpatialZone_ZOrigin_traits;
  
          const SimSpatialZone_ZOrigin_optional&
          SimSpatialZone_ZOrigin () const;
  
          SimSpatialZone_ZOrigin_optional&
          SimSpatialZone_ZOrigin ();
  
          void
          SimSpatialZone_ZOrigin (const SimSpatialZone_ZOrigin_type& x);
  
          void
          SimSpatialZone_ZOrigin (const SimSpatialZone_ZOrigin_optional& x);
  
          // SimSpatialZone_Type
          //
          typedef ::xml_schema::int_ SimSpatialZone_Type_type;
          typedef ::xsd::cxx::tree::optional< SimSpatialZone_Type_type, true > SimSpatialZone_Type_optional;
          typedef ::xsd::cxx::tree::traits< SimSpatialZone_Type_type, char > SimSpatialZone_Type_traits;
  
          const SimSpatialZone_Type_optional&
          SimSpatialZone_Type () const;
  
          SimSpatialZone_Type_optional&
          SimSpatialZone_Type ();
  
          void
          SimSpatialZone_Type (const SimSpatialZone_Type_type& x);
  
          void
          SimSpatialZone_Type (const SimSpatialZone_Type_optional& x);
  
          // SimSpatialZone_Mult
          //
          typedef ::xml_schema::int_ SimSpatialZone_Mult_type;
          typedef ::xsd::cxx::tree::optional< SimSpatialZone_Mult_type, true > SimSpatialZone_Mult_optional;
          typedef ::xsd::cxx::tree::traits< SimSpatialZone_Mult_type, char > SimSpatialZone_Mult_traits;
  
          const SimSpatialZone_Mult_optional&
          SimSpatialZone_Mult () const;
  
          SimSpatialZone_Mult_optional&
          SimSpatialZone_Mult ();
  
          void
          SimSpatialZone_Mult (const SimSpatialZone_Mult_type& x);
  
          void
          SimSpatialZone_Mult (const SimSpatialZone_Mult_optional& x);
  
          // SimSpatialZone_CeilingHt
          //
          typedef ::xml_schema::double_ SimSpatialZone_CeilingHt_type;
          typedef ::xsd::cxx::tree::optional< SimSpatialZone_CeilingHt_type, true > SimSpatialZone_CeilingHt_optional;
          typedef ::xsd::cxx::tree::traits< SimSpatialZone_CeilingHt_type, char, ::xsd::cxx::tree::schema_type::double_ > SimSpatialZone_CeilingHt_traits;
  
          const SimSpatialZone_CeilingHt_optional&
          SimSpatialZone_CeilingHt () const;
  
          SimSpatialZone_CeilingHt_optional&
          SimSpatialZone_CeilingHt ();
  
          void
          SimSpatialZone_CeilingHt (const SimSpatialZone_CeilingHt_type& x);
  
          void
          SimSpatialZone_CeilingHt (const SimSpatialZone_CeilingHt_optional& x);
  
          // SimSpatialZone_Volume
          //
          typedef ::xml_schema::double_ SimSpatialZone_Volume_type;
          typedef ::xsd::cxx::tree::optional< SimSpatialZone_Volume_type, true > SimSpatialZone_Volume_optional;
          typedef ::xsd::cxx::tree::traits< SimSpatialZone_Volume_type, char, ::xsd::cxx::tree::schema_type::double_ > SimSpatialZone_Volume_traits;
  
          const SimSpatialZone_Volume_optional&
          SimSpatialZone_Volume () const;
  
          SimSpatialZone_Volume_optional&
          SimSpatialZone_Volume ();
  
          void
          SimSpatialZone_Volume (const SimSpatialZone_Volume_type& x);
  
          void
          SimSpatialZone_Volume (const SimSpatialZone_Volume_optional& x);
  
          // SimSpatialZone_FloorArea
          //
          typedef ::xml_schema::double_ SimSpatialZone_FloorArea_type;
          typedef ::xsd::cxx::tree::optional< SimSpatialZone_FloorArea_type, true > SimSpatialZone_FloorArea_optional;
          typedef ::xsd::cxx::tree::traits< SimSpatialZone_FloorArea_type, char, ::xsd::cxx::tree::schema_type::double_ > SimSpatialZone_FloorArea_traits;
  
          const SimSpatialZone_FloorArea_optional&
          SimSpatialZone_FloorArea () const;
  
          SimSpatialZone_FloorArea_optional&
          SimSpatialZone_FloorArea ();
  
          void
          SimSpatialZone_FloorArea (const SimSpatialZone_FloorArea_type& x);
  
          void
          SimSpatialZone_FloorArea (const SimSpatialZone_FloorArea_optional& x);
  
          // SimSpatialZone_ZoneInsideConvAlgo
          //
          typedef ::xml_schema::string SimSpatialZone_ZoneInsideConvAlgo_type;
          typedef ::xsd::cxx::tree::optional< SimSpatialZone_ZoneInsideConvAlgo_type, false > SimSpatialZone_ZoneInsideConvAlgo_optional;
          typedef ::xsd::cxx::tree::traits< SimSpatialZone_ZoneInsideConvAlgo_type, char > SimSpatialZone_ZoneInsideConvAlgo_traits;
  
          const SimSpatialZone_ZoneInsideConvAlgo_optional&
          SimSpatialZone_ZoneInsideConvAlgo () const;
  
          SimSpatialZone_ZoneInsideConvAlgo_optional&
          SimSpatialZone_ZoneInsideConvAlgo ();
  
          void
          SimSpatialZone_ZoneInsideConvAlgo (const SimSpatialZone_ZoneInsideConvAlgo_type& x);
  
          void
          SimSpatialZone_ZoneInsideConvAlgo (const SimSpatialZone_ZoneInsideConvAlgo_optional& x);
  
          void
          SimSpatialZone_ZoneInsideConvAlgo (::std::auto_ptr< SimSpatialZone_ZoneInsideConvAlgo_type > p);
  
          // SimSpatialZone_ZoneOutsdConvAlgo
          //
          typedef ::xml_schema::string SimSpatialZone_ZoneOutsdConvAlgo_type;
          typedef ::xsd::cxx::tree::optional< SimSpatialZone_ZoneOutsdConvAlgo_type, false > SimSpatialZone_ZoneOutsdConvAlgo_optional;
          typedef ::xsd::cxx::tree::traits< SimSpatialZone_ZoneOutsdConvAlgo_type, char > SimSpatialZone_ZoneOutsdConvAlgo_traits;
  
          const SimSpatialZone_ZoneOutsdConvAlgo_optional&
          SimSpatialZone_ZoneOutsdConvAlgo () const;
  
          SimSpatialZone_ZoneOutsdConvAlgo_optional&
          SimSpatialZone_ZoneOutsdConvAlgo ();
  
          void
          SimSpatialZone_ZoneOutsdConvAlgo (const SimSpatialZone_ZoneOutsdConvAlgo_type& x);
  
          void
          SimSpatialZone_ZoneOutsdConvAlgo (const SimSpatialZone_ZoneOutsdConvAlgo_optional& x);
  
          void
          SimSpatialZone_ZoneOutsdConvAlgo (::std::auto_ptr< SimSpatialZone_ZoneOutsdConvAlgo_type > p);
  
          // SimSpatialZone_PartTotalFlrArea
          //
          typedef ::xml_schema::string SimSpatialZone_PartTotalFlrArea_type;
          typedef ::xsd::cxx::tree::optional< SimSpatialZone_PartTotalFlrArea_type, false > SimSpatialZone_PartTotalFlrArea_optional;
          typedef ::xsd::cxx::tree::traits< SimSpatialZone_PartTotalFlrArea_type, char > SimSpatialZone_PartTotalFlrArea_traits;
  
          const SimSpatialZone_PartTotalFlrArea_optional&
          SimSpatialZone_PartTotalFlrArea () const;
  
          SimSpatialZone_PartTotalFlrArea_optional&
          SimSpatialZone_PartTotalFlrArea ();
  
          void
          SimSpatialZone_PartTotalFlrArea (const SimSpatialZone_PartTotalFlrArea_type& x);
  
          void
          SimSpatialZone_PartTotalFlrArea (const SimSpatialZone_PartTotalFlrArea_optional& x);
  
          void
          SimSpatialZone_PartTotalFlrArea (::std::auto_ptr< SimSpatialZone_PartTotalFlrArea_type > p);
  
          // ZoneProp_UserViewFactors_bySurfName_ZoneName
          //
          typedef ::xml_schema::idref ZoneProp_UserViewFactors_bySurfName_ZoneName_type;
          typedef ::xsd::cxx::tree::optional< ZoneProp_UserViewFactors_bySurfName_ZoneName_type, false > ZoneProp_UserViewFactors_bySurfName_ZoneName_optional;
          typedef ::xsd::cxx::tree::traits< ZoneProp_UserViewFactors_bySurfName_ZoneName_type, char > ZoneProp_UserViewFactors_bySurfName_ZoneName_traits;
  
          const ZoneProp_UserViewFactors_bySurfName_ZoneName_optional&
          ZoneProp_UserViewFactors_bySurfName_ZoneName () const;
  
          ZoneProp_UserViewFactors_bySurfName_ZoneName_optional&
          ZoneProp_UserViewFactors_bySurfName_ZoneName ();
  
          void
          ZoneProp_UserViewFactors_bySurfName_ZoneName (const ZoneProp_UserViewFactors_bySurfName_ZoneName_type& x);
  
          void
          ZoneProp_UserViewFactors_bySurfName_ZoneName (const ZoneProp_UserViewFactors_bySurfName_ZoneName_optional& x);
  
          void
          ZoneProp_UserViewFactors_bySurfName_ZoneName (::std::auto_ptr< ZoneProp_UserViewFactors_bySurfName_ZoneName_type > p);
  
          // ZoneProp_UserViewFactors_bySurfName_FromSurface_1_121
          //
          typedef ::xml_schema::idrefs ZoneProp_UserViewFactors_bySurfName_FromSurface_1_121_type;
          typedef ::xsd::cxx::tree::optional< ZoneProp_UserViewFactors_bySurfName_FromSurface_1_121_type > ZoneProp_UserViewFactors_bySurfName_FromSurface_1_121_optional;
          typedef ::xsd::cxx::tree::traits< ZoneProp_UserViewFactors_bySurfName_FromSurface_1_121_type, char > ZoneProp_UserViewFactors_bySurfName_FromSurface_1_121_traits;
  
          const ZoneProp_UserViewFactors_bySurfName_FromSurface_1_121_optional&
          ZoneProp_UserViewFactors_bySurfName_FromSurface_1_121 () const;
  
          ZoneProp_UserViewFactors_bySurfName_FromSurface_1_121_optional&
          ZoneProp_UserViewFactors_bySurfName_FromSurface_1_121 ();
  
          void
          ZoneProp_UserViewFactors_bySurfName_FromSurface_1_121 (const ZoneProp_UserViewFactors_bySurfName_FromSurface_1_121_type& x);
  
          void
          ZoneProp_UserViewFactors_bySurfName_FromSurface_1_121 (const ZoneProp_UserViewFactors_bySurfName_FromSurface_1_121_optional& x);
  
          void
          ZoneProp_UserViewFactors_bySurfName_FromSurface_1_121 (::std::auto_ptr< ZoneProp_UserViewFactors_bySurfName_FromSurface_1_121_type > p);
  
          // ZoneProp_UserViewFactors_bySurfName_ToSurface_1_121
          //
          typedef ::xml_schema::idrefs ZoneProp_UserViewFactors_bySurfName_ToSurface_1_121_type;
          typedef ::xsd::cxx::tree::optional< ZoneProp_UserViewFactors_bySurfName_ToSurface_1_121_type > ZoneProp_UserViewFactors_bySurfName_ToSurface_1_121_optional;
          typedef ::xsd::cxx::tree::traits< ZoneProp_UserViewFactors_bySurfName_ToSurface_1_121_type, char > ZoneProp_UserViewFactors_bySurfName_ToSurface_1_121_traits;
  
          const ZoneProp_UserViewFactors_bySurfName_ToSurface_1_121_optional&
          ZoneProp_UserViewFactors_bySurfName_ToSurface_1_121 () const;
  
          ZoneProp_UserViewFactors_bySurfName_ToSurface_1_121_optional&
          ZoneProp_UserViewFactors_bySurfName_ToSurface_1_121 ();
  
          void
          ZoneProp_UserViewFactors_bySurfName_ToSurface_1_121 (const ZoneProp_UserViewFactors_bySurfName_ToSurface_1_121_type& x);
  
          void
          ZoneProp_UserViewFactors_bySurfName_ToSurface_1_121 (const ZoneProp_UserViewFactors_bySurfName_ToSurface_1_121_optional& x);
  
          void
          ZoneProp_UserViewFactors_bySurfName_ToSurface_1_121 (::std::auto_ptr< ZoneProp_UserViewFactors_bySurfName_ToSurface_1_121_type > p);
  
          // ZoneProp_UserViewFactors_bySurfName_ViewFactor_1_121
          //
          typedef ::schema::simxml::SimModelCore::doubleList ZoneProp_UserViewFactors_bySurfName_ViewFactor_1_121_type;
          typedef ::xsd::cxx::tree::optional< ZoneProp_UserViewFactors_bySurfName_ViewFactor_1_121_type > ZoneProp_UserViewFactors_bySurfName_ViewFactor_1_121_optional;
          typedef ::xsd::cxx::tree::traits< ZoneProp_UserViewFactors_bySurfName_ViewFactor_1_121_type, char > ZoneProp_UserViewFactors_bySurfName_ViewFactor_1_121_traits;
  
          const ZoneProp_UserViewFactors_bySurfName_ViewFactor_1_121_optional&
          ZoneProp_UserViewFactors_bySurfName_ViewFactor_1_121 () const;
  
          ZoneProp_UserViewFactors_bySurfName_ViewFactor_1_121_optional&
          ZoneProp_UserViewFactors_bySurfName_ViewFactor_1_121 ();
  
          void
          ZoneProp_UserViewFactors_bySurfName_ViewFactor_1_121 (const ZoneProp_UserViewFactors_bySurfName_ViewFactor_1_121_type& x);
  
          void
          ZoneProp_UserViewFactors_bySurfName_ViewFactor_1_121 (const ZoneProp_UserViewFactors_bySurfName_ViewFactor_1_121_optional& x);
  
          void
          ZoneProp_UserViewFactors_bySurfName_ViewFactor_1_121 (::std::auto_ptr< ZoneProp_UserViewFactors_bySurfName_ViewFactor_1_121_type > p);
  
          // RmAirModelType_ZoneName
          //
          typedef ::xml_schema::idref RmAirModelType_ZoneName_type;
          typedef ::xsd::cxx::tree::optional< RmAirModelType_ZoneName_type, false > RmAirModelType_ZoneName_optional;
          typedef ::xsd::cxx::tree::traits< RmAirModelType_ZoneName_type, char > RmAirModelType_ZoneName_traits;
  
          const RmAirModelType_ZoneName_optional&
          RmAirModelType_ZoneName () const;
  
          RmAirModelType_ZoneName_optional&
          RmAirModelType_ZoneName ();
  
          void
          RmAirModelType_ZoneName (const RmAirModelType_ZoneName_type& x);
  
          void
          RmAirModelType_ZoneName (const RmAirModelType_ZoneName_optional& x);
  
          void
          RmAirModelType_ZoneName (::std::auto_ptr< RmAirModelType_ZoneName_type > p);
  
          // RmAirModelType_RoomAirModType
          //
          typedef ::xml_schema::string RmAirModelType_RoomAirModType_type;
          typedef ::xsd::cxx::tree::optional< RmAirModelType_RoomAirModType_type, false > RmAirModelType_RoomAirModType_optional;
          typedef ::xsd::cxx::tree::traits< RmAirModelType_RoomAirModType_type, char > RmAirModelType_RoomAirModType_traits;
  
          const RmAirModelType_RoomAirModType_optional&
          RmAirModelType_RoomAirModType () const;
  
          RmAirModelType_RoomAirModType_optional&
          RmAirModelType_RoomAirModType ();
  
          void
          RmAirModelType_RoomAirModType (const RmAirModelType_RoomAirModType_type& x);
  
          void
          RmAirModelType_RoomAirModType (const RmAirModelType_RoomAirModType_optional& x);
  
          void
          RmAirModelType_RoomAirModType (::std::auto_ptr< RmAirModelType_RoomAirModType_type > p);
  
          // RmAirModelType_AirTempCplngStrat
          //
          typedef ::xml_schema::string RmAirModelType_AirTempCplngStrat_type;
          typedef ::xsd::cxx::tree::optional< RmAirModelType_AirTempCplngStrat_type, false > RmAirModelType_AirTempCplngStrat_optional;
          typedef ::xsd::cxx::tree::traits< RmAirModelType_AirTempCplngStrat_type, char > RmAirModelType_AirTempCplngStrat_traits;
  
          const RmAirModelType_AirTempCplngStrat_optional&
          RmAirModelType_AirTempCplngStrat () const;
  
          RmAirModelType_AirTempCplngStrat_optional&
          RmAirModelType_AirTempCplngStrat ();
  
          void
          RmAirModelType_AirTempCplngStrat (const RmAirModelType_AirTempCplngStrat_type& x);
  
          void
          RmAirModelType_AirTempCplngStrat (const RmAirModelType_AirTempCplngStrat_optional& x);
  
          void
          RmAirModelType_AirTempCplngStrat (::std::auto_ptr< RmAirModelType_AirTempCplngStrat_type > p);
  
          // ZoneAirBalance_OutdoorAir_ZoneName
          //
          typedef ::xml_schema::idref ZoneAirBalance_OutdoorAir_ZoneName_type;
          typedef ::xsd::cxx::tree::optional< ZoneAirBalance_OutdoorAir_ZoneName_type, false > ZoneAirBalance_OutdoorAir_ZoneName_optional;
          typedef ::xsd::cxx::tree::traits< ZoneAirBalance_OutdoorAir_ZoneName_type, char > ZoneAirBalance_OutdoorAir_ZoneName_traits;
  
          const ZoneAirBalance_OutdoorAir_ZoneName_optional&
          ZoneAirBalance_OutdoorAir_ZoneName () const;
  
          ZoneAirBalance_OutdoorAir_ZoneName_optional&
          ZoneAirBalance_OutdoorAir_ZoneName ();
  
          void
          ZoneAirBalance_OutdoorAir_ZoneName (const ZoneAirBalance_OutdoorAir_ZoneName_type& x);
  
          void
          ZoneAirBalance_OutdoorAir_ZoneName (const ZoneAirBalance_OutdoorAir_ZoneName_optional& x);
  
          void
          ZoneAirBalance_OutdoorAir_ZoneName (::std::auto_ptr< ZoneAirBalance_OutdoorAir_ZoneName_type > p);
  
          // ZoneAirBalance_OutdoorAir_AirBalanceMethod
          //
          typedef ::xml_schema::string ZoneAirBalance_OutdoorAir_AirBalanceMethod_type;
          typedef ::xsd::cxx::tree::optional< ZoneAirBalance_OutdoorAir_AirBalanceMethod_type, false > ZoneAirBalance_OutdoorAir_AirBalanceMethod_optional;
          typedef ::xsd::cxx::tree::traits< ZoneAirBalance_OutdoorAir_AirBalanceMethod_type, char > ZoneAirBalance_OutdoorAir_AirBalanceMethod_traits;
  
          const ZoneAirBalance_OutdoorAir_AirBalanceMethod_optional&
          ZoneAirBalance_OutdoorAir_AirBalanceMethod () const;
  
          ZoneAirBalance_OutdoorAir_AirBalanceMethod_optional&
          ZoneAirBalance_OutdoorAir_AirBalanceMethod ();
  
          void
          ZoneAirBalance_OutdoorAir_AirBalanceMethod (const ZoneAirBalance_OutdoorAir_AirBalanceMethod_type& x);
  
          void
          ZoneAirBalance_OutdoorAir_AirBalanceMethod (const ZoneAirBalance_OutdoorAir_AirBalanceMethod_optional& x);
  
          void
          ZoneAirBalance_OutdoorAir_AirBalanceMethod (::std::auto_ptr< ZoneAirBalance_OutdoorAir_AirBalanceMethod_type > p);
  
          // ZoneAirBalance_OutdoorAir_InducedOutdrAirDueToUnbalDuctLeak
          //
          typedef ::xml_schema::double_ ZoneAirBalance_OutdoorAir_InducedOutdrAirDueToUnbalDuctLeak_type;
          typedef ::xsd::cxx::tree::optional< ZoneAirBalance_OutdoorAir_InducedOutdrAirDueToUnbalDuctLeak_type, true > ZoneAirBalance_OutdoorAir_InducedOutdrAirDueToUnbalDuctLeak_optional;
          typedef ::xsd::cxx::tree::traits< ZoneAirBalance_OutdoorAir_InducedOutdrAirDueToUnbalDuctLeak_type, char, ::xsd::cxx::tree::schema_type::double_ > ZoneAirBalance_OutdoorAir_InducedOutdrAirDueToUnbalDuctLeak_traits;
  
          const ZoneAirBalance_OutdoorAir_InducedOutdrAirDueToUnbalDuctLeak_optional&
          ZoneAirBalance_OutdoorAir_InducedOutdrAirDueToUnbalDuctLeak () const;
  
          ZoneAirBalance_OutdoorAir_InducedOutdrAirDueToUnbalDuctLeak_optional&
          ZoneAirBalance_OutdoorAir_InducedOutdrAirDueToUnbalDuctLeak ();
  
          void
          ZoneAirBalance_OutdoorAir_InducedOutdrAirDueToUnbalDuctLeak (const ZoneAirBalance_OutdoorAir_InducedOutdrAirDueToUnbalDuctLeak_type& x);
  
          void
          ZoneAirBalance_OutdoorAir_InducedOutdrAirDueToUnbalDuctLeak (const ZoneAirBalance_OutdoorAir_InducedOutdrAirDueToUnbalDuctLeak_optional& x);
  
          // ZoneAirBalance_OutdoorAir_InducedOutdrAirScheduleName
          //
          typedef ::xml_schema::idref ZoneAirBalance_OutdoorAir_InducedOutdrAirScheduleName_type;
          typedef ::xsd::cxx::tree::optional< ZoneAirBalance_OutdoorAir_InducedOutdrAirScheduleName_type, false > ZoneAirBalance_OutdoorAir_InducedOutdrAirScheduleName_optional;
          typedef ::xsd::cxx::tree::traits< ZoneAirBalance_OutdoorAir_InducedOutdrAirScheduleName_type, char > ZoneAirBalance_OutdoorAir_InducedOutdrAirScheduleName_traits;
  
          const ZoneAirBalance_OutdoorAir_InducedOutdrAirScheduleName_optional&
          ZoneAirBalance_OutdoorAir_InducedOutdrAirScheduleName () const;
  
          ZoneAirBalance_OutdoorAir_InducedOutdrAirScheduleName_optional&
          ZoneAirBalance_OutdoorAir_InducedOutdrAirScheduleName ();
  
          void
          ZoneAirBalance_OutdoorAir_InducedOutdrAirScheduleName (const ZoneAirBalance_OutdoorAir_InducedOutdrAirScheduleName_type& x);
  
          void
          ZoneAirBalance_OutdoorAir_InducedOutdrAirScheduleName (const ZoneAirBalance_OutdoorAir_InducedOutdrAirScheduleName_optional& x);
  
          void
          ZoneAirBalance_OutdoorAir_InducedOutdrAirScheduleName (::std::auto_ptr< ZoneAirBalance_OutdoorAir_InducedOutdrAirScheduleName_type > p);
  
          // ZoneHVAC_EquipConnections_ZoneName
          //
          typedef ::xml_schema::idref ZoneHVAC_EquipConnections_ZoneName_type;
          typedef ::xsd::cxx::tree::optional< ZoneHVAC_EquipConnections_ZoneName_type, false > ZoneHVAC_EquipConnections_ZoneName_optional;
          typedef ::xsd::cxx::tree::traits< ZoneHVAC_EquipConnections_ZoneName_type, char > ZoneHVAC_EquipConnections_ZoneName_traits;
  
          const ZoneHVAC_EquipConnections_ZoneName_optional&
          ZoneHVAC_EquipConnections_ZoneName () const;
  
          ZoneHVAC_EquipConnections_ZoneName_optional&
          ZoneHVAC_EquipConnections_ZoneName ();
  
          void
          ZoneHVAC_EquipConnections_ZoneName (const ZoneHVAC_EquipConnections_ZoneName_type& x);
  
          void
          ZoneHVAC_EquipConnections_ZoneName (const ZoneHVAC_EquipConnections_ZoneName_optional& x);
  
          void
          ZoneHVAC_EquipConnections_ZoneName (::std::auto_ptr< ZoneHVAC_EquipConnections_ZoneName_type > p);
  
          // ZoneHVAC_EquipConnections_ZoneCondEqmtListName
          //
          typedef ::xml_schema::idref ZoneHVAC_EquipConnections_ZoneCondEqmtListName_type;
          typedef ::xsd::cxx::tree::optional< ZoneHVAC_EquipConnections_ZoneCondEqmtListName_type, false > ZoneHVAC_EquipConnections_ZoneCondEqmtListName_optional;
          typedef ::xsd::cxx::tree::traits< ZoneHVAC_EquipConnections_ZoneCondEqmtListName_type, char > ZoneHVAC_EquipConnections_ZoneCondEqmtListName_traits;
  
          const ZoneHVAC_EquipConnections_ZoneCondEqmtListName_optional&
          ZoneHVAC_EquipConnections_ZoneCondEqmtListName () const;
  
          ZoneHVAC_EquipConnections_ZoneCondEqmtListName_optional&
          ZoneHVAC_EquipConnections_ZoneCondEqmtListName ();
  
          void
          ZoneHVAC_EquipConnections_ZoneCondEqmtListName (const ZoneHVAC_EquipConnections_ZoneCondEqmtListName_type& x);
  
          void
          ZoneHVAC_EquipConnections_ZoneCondEqmtListName (const ZoneHVAC_EquipConnections_ZoneCondEqmtListName_optional& x);
  
          void
          ZoneHVAC_EquipConnections_ZoneCondEqmtListName (::std::auto_ptr< ZoneHVAC_EquipConnections_ZoneCondEqmtListName_type > p);
  
          // ZoneHVAC_EquipConnections_ZoneAirInletNodeOrNodeListName
          //
          typedef ::xml_schema::string ZoneHVAC_EquipConnections_ZoneAirInletNodeOrNodeListName_type;
          typedef ::xsd::cxx::tree::optional< ZoneHVAC_EquipConnections_ZoneAirInletNodeOrNodeListName_type, false > ZoneHVAC_EquipConnections_ZoneAirInletNodeOrNodeListName_optional;
          typedef ::xsd::cxx::tree::traits< ZoneHVAC_EquipConnections_ZoneAirInletNodeOrNodeListName_type, char > ZoneHVAC_EquipConnections_ZoneAirInletNodeOrNodeListName_traits;
  
          const ZoneHVAC_EquipConnections_ZoneAirInletNodeOrNodeListName_optional&
          ZoneHVAC_EquipConnections_ZoneAirInletNodeOrNodeListName () const;
  
          ZoneHVAC_EquipConnections_ZoneAirInletNodeOrNodeListName_optional&
          ZoneHVAC_EquipConnections_ZoneAirInletNodeOrNodeListName ();
  
          void
          ZoneHVAC_EquipConnections_ZoneAirInletNodeOrNodeListName (const ZoneHVAC_EquipConnections_ZoneAirInletNodeOrNodeListName_type& x);
  
          void
          ZoneHVAC_EquipConnections_ZoneAirInletNodeOrNodeListName (const ZoneHVAC_EquipConnections_ZoneAirInletNodeOrNodeListName_optional& x);
  
          void
          ZoneHVAC_EquipConnections_ZoneAirInletNodeOrNodeListName (::std::auto_ptr< ZoneHVAC_EquipConnections_ZoneAirInletNodeOrNodeListName_type > p);
  
          // ZoneHVAC_EquipConnections_ZoneAirExhaustNodeOrNodeListName
          //
          typedef ::xml_schema::string ZoneHVAC_EquipConnections_ZoneAirExhaustNodeOrNodeListName_type;
          typedef ::xsd::cxx::tree::optional< ZoneHVAC_EquipConnections_ZoneAirExhaustNodeOrNodeListName_type, false > ZoneHVAC_EquipConnections_ZoneAirExhaustNodeOrNodeListName_optional;
          typedef ::xsd::cxx::tree::traits< ZoneHVAC_EquipConnections_ZoneAirExhaustNodeOrNodeListName_type, char > ZoneHVAC_EquipConnections_ZoneAirExhaustNodeOrNodeListName_traits;
  
          const ZoneHVAC_EquipConnections_ZoneAirExhaustNodeOrNodeListName_optional&
          ZoneHVAC_EquipConnections_ZoneAirExhaustNodeOrNodeListName () const;
  
          ZoneHVAC_EquipConnections_ZoneAirExhaustNodeOrNodeListName_optional&
          ZoneHVAC_EquipConnections_ZoneAirExhaustNodeOrNodeListName ();
  
          void
          ZoneHVAC_EquipConnections_ZoneAirExhaustNodeOrNodeListName (const ZoneHVAC_EquipConnections_ZoneAirExhaustNodeOrNodeListName_type& x);
  
          void
          ZoneHVAC_EquipConnections_ZoneAirExhaustNodeOrNodeListName (const ZoneHVAC_EquipConnections_ZoneAirExhaustNodeOrNodeListName_optional& x);
  
          void
          ZoneHVAC_EquipConnections_ZoneAirExhaustNodeOrNodeListName (::std::auto_ptr< ZoneHVAC_EquipConnections_ZoneAirExhaustNodeOrNodeListName_type > p);
  
          // ZoneHVAC_EquipConnections_ZoneAirNodeName
          //
          typedef ::xml_schema::string ZoneHVAC_EquipConnections_ZoneAirNodeName_type;
          typedef ::xsd::cxx::tree::optional< ZoneHVAC_EquipConnections_ZoneAirNodeName_type, false > ZoneHVAC_EquipConnections_ZoneAirNodeName_optional;
          typedef ::xsd::cxx::tree::traits< ZoneHVAC_EquipConnections_ZoneAirNodeName_type, char > ZoneHVAC_EquipConnections_ZoneAirNodeName_traits;
  
          const ZoneHVAC_EquipConnections_ZoneAirNodeName_optional&
          ZoneHVAC_EquipConnections_ZoneAirNodeName () const;
  
          ZoneHVAC_EquipConnections_ZoneAirNodeName_optional&
          ZoneHVAC_EquipConnections_ZoneAirNodeName ();
  
          void
          ZoneHVAC_EquipConnections_ZoneAirNodeName (const ZoneHVAC_EquipConnections_ZoneAirNodeName_type& x);
  
          void
          ZoneHVAC_EquipConnections_ZoneAirNodeName (const ZoneHVAC_EquipConnections_ZoneAirNodeName_optional& x);
  
          void
          ZoneHVAC_EquipConnections_ZoneAirNodeName (::std::auto_ptr< ZoneHVAC_EquipConnections_ZoneAirNodeName_type > p);
  
          // ZoneHVAC_EquipConnections_ZoneReturnAirNodeName
          //
          typedef ::xml_schema::string ZoneHVAC_EquipConnections_ZoneReturnAirNodeName_type;
          typedef ::xsd::cxx::tree::optional< ZoneHVAC_EquipConnections_ZoneReturnAirNodeName_type, false > ZoneHVAC_EquipConnections_ZoneReturnAirNodeName_optional;
          typedef ::xsd::cxx::tree::traits< ZoneHVAC_EquipConnections_ZoneReturnAirNodeName_type, char > ZoneHVAC_EquipConnections_ZoneReturnAirNodeName_traits;
  
          const ZoneHVAC_EquipConnections_ZoneReturnAirNodeName_optional&
          ZoneHVAC_EquipConnections_ZoneReturnAirNodeName () const;
  
          ZoneHVAC_EquipConnections_ZoneReturnAirNodeName_optional&
          ZoneHVAC_EquipConnections_ZoneReturnAirNodeName ();
  
          void
          ZoneHVAC_EquipConnections_ZoneReturnAirNodeName (const ZoneHVAC_EquipConnections_ZoneReturnAirNodeName_type& x);
  
          void
          ZoneHVAC_EquipConnections_ZoneReturnAirNodeName (const ZoneHVAC_EquipConnections_ZoneReturnAirNodeName_optional& x);
  
          void
          ZoneHVAC_EquipConnections_ZoneReturnAirNodeName (::std::auto_ptr< ZoneHVAC_EquipConnections_ZoneReturnAirNodeName_type > p);
  
          // Constructors.
          //
          SimSpatialZone_ThermalZone_Default ();
  
          SimSpatialZone_ThermalZone_Default (const RefId_type&);
  
          SimSpatialZone_ThermalZone_Default (const ::xercesc::DOMElement& e,
                                              ::xml_schema::flags f = 0,
                                              ::xml_schema::container* c = 0);
  
          SimSpatialZone_ThermalZone_Default (const SimSpatialZone_ThermalZone_Default& x,
                                              ::xml_schema::flags f = 0,
                                              ::xml_schema::container* c = 0);
  
          virtual SimSpatialZone_ThermalZone_Default*
          _clone (::xml_schema::flags f = 0,
                  ::xml_schema::container* c = 0) const;
  
          SimSpatialZone_ThermalZone_Default&
          operator= (const SimSpatialZone_ThermalZone_Default& x);
  
          virtual 
          ~SimSpatialZone_ThermalZone_Default ();
  
          // Implementation.
          //
          protected:
          void
          parse (::xsd::cxx::xml::dom::parser< char >&,
                 ::xml_schema::flags);
  
          protected:
          ZoneConditioningRequirement_optional ZoneConditioningRequirement_;
          HVACSystemType_optional HVACSystemType_;
          UserDefinedHVACSystemType_optional UserDefinedHVACSystemType_;
          InfiltrationRate_optional InfiltrationRate_;
          IsDaylitZone_optional IsDaylitZone_;
          NumberOfDaylightingSensors_optional NumberOfDaylightingSensors_;
          DesignIlluminance_optional DesignIlluminance_;
          LightingControlsType_optional LightingControlsType_;
          ClassRef_ZoneTypeEnergy_optional ClassRef_ZoneTypeEnergy_;
          AssignedSchedule_optional AssignedSchedule_;
          SimSpatialZone_DirRelNorth_optional SimSpatialZone_DirRelNorth_;
          SimSpatialZone_XOrigin_optional SimSpatialZone_XOrigin_;
          SimSpatialZone_YOrigin_optional SimSpatialZone_YOrigin_;
          SimSpatialZone_ZOrigin_optional SimSpatialZone_ZOrigin_;
          SimSpatialZone_Type_optional SimSpatialZone_Type_;
          SimSpatialZone_Mult_optional SimSpatialZone_Mult_;
          SimSpatialZone_CeilingHt_optional SimSpatialZone_CeilingHt_;
          SimSpatialZone_Volume_optional SimSpatialZone_Volume_;
          SimSpatialZone_FloorArea_optional SimSpatialZone_FloorArea_;
          SimSpatialZone_ZoneInsideConvAlgo_optional SimSpatialZone_ZoneInsideConvAlgo_;
          SimSpatialZone_ZoneOutsdConvAlgo_optional SimSpatialZone_ZoneOutsdConvAlgo_;
          SimSpatialZone_PartTotalFlrArea_optional SimSpatialZone_PartTotalFlrArea_;
          ZoneProp_UserViewFactors_bySurfName_ZoneName_optional ZoneProp_UserViewFactors_bySurfName_ZoneName_;
          ZoneProp_UserViewFactors_bySurfName_FromSurface_1_121_optional ZoneProp_UserViewFactors_bySurfName_FromSurface_1_121_;
          ZoneProp_UserViewFactors_bySurfName_ToSurface_1_121_optional ZoneProp_UserViewFactors_bySurfName_ToSurface_1_121_;
          ZoneProp_UserViewFactors_bySurfName_ViewFactor_1_121_optional ZoneProp_UserViewFactors_bySurfName_ViewFactor_1_121_;
          RmAirModelType_ZoneName_optional RmAirModelType_ZoneName_;
          RmAirModelType_RoomAirModType_optional RmAirModelType_RoomAirModType_;
          RmAirModelType_AirTempCplngStrat_optional RmAirModelType_AirTempCplngStrat_;
          ZoneAirBalance_OutdoorAir_ZoneName_optional ZoneAirBalance_OutdoorAir_ZoneName_;
          ZoneAirBalance_OutdoorAir_AirBalanceMethod_optional ZoneAirBalance_OutdoorAir_AirBalanceMethod_;
          ZoneAirBalance_OutdoorAir_InducedOutdrAirDueToUnbalDuctLeak_optional ZoneAirBalance_OutdoorAir_InducedOutdrAirDueToUnbalDuctLeak_;
          ZoneAirBalance_OutdoorAir_InducedOutdrAirScheduleName_optional ZoneAirBalance_OutdoorAir_InducedOutdrAirScheduleName_;
          ZoneHVAC_EquipConnections_ZoneName_optional ZoneHVAC_EquipConnections_ZoneName_;
          ZoneHVAC_EquipConnections_ZoneCondEqmtListName_optional ZoneHVAC_EquipConnections_ZoneCondEqmtListName_;
          ZoneHVAC_EquipConnections_ZoneAirInletNodeOrNodeListName_optional ZoneHVAC_EquipConnections_ZoneAirInletNodeOrNodeListName_;
          ZoneHVAC_EquipConnections_ZoneAirExhaustNodeOrNodeListName_optional ZoneHVAC_EquipConnections_ZoneAirExhaustNodeOrNodeListName_;
          ZoneHVAC_EquipConnections_ZoneAirNodeName_optional ZoneHVAC_EquipConnections_ZoneAirNodeName_;
          ZoneHVAC_EquipConnections_ZoneReturnAirNodeName_optional ZoneHVAC_EquipConnections_ZoneReturnAirNodeName_;
        };
      }
    }
  }
  
  #include <iosfwd>
  
  #include <xercesc/sax/InputSource.hpp>
  #include <xercesc/dom/DOMDocument.hpp>
  #include <xercesc/dom/DOMErrorHandler.hpp>
  
  namespace schema
  {
    namespace simxml
    {
      namespace BuildingModel
      {
      }
    }
  }
  
  #include <xsd/cxx/post.hxx>
  
  // Begin epilogue.
  //
  //
  // End epilogue.
  
  #endif // SIM_SPATIAL_ZONE_THERMAL_ZONE_DEFAULT_HXX
  