    #include "xiso.h"
    #include <akaxiso/akaxiso.h>
    #include <akaxiso/schema/schema_builtin_xiso.h>

    namespace xml {

      void instantiate_xiso() {
      }

    }

    namespace xs {

      void appinfo_sequence_leaf::model() {
      /** element member definitions */
        any("&any", &::xs::appinfo_sequence::any_);
      }

      void appinfo_leaf::model() {
      /** element member definitions */
        member("&s0", &::xs::appinfo::s0_, ::xs::appinfo_sequence_holder_leaf(), 0, aka::unbounded);
        /** attribute member definition. */
        attribute("source", &::xs::appinfo::source_, xiso::leaf<std::string>());
        any_attribute(&::xs::appinfo::attributes_);
      }

      void documentation_sequence_leaf::model() {
      /** element member definitions */
        any("&any", &::xs::documentation_sequence::any_);
      }

      void documentation_leaf::model() {
      /** element member definitions */
        member("&s0", &::xs::documentation::s0_, ::xs::documentation_sequence_holder_leaf(), 0, aka::unbounded);
        /** attribute member definition. */
        attribute("source", &::xs::documentation::source_, xiso::leaf<std::string>());
        attribute("xml:lang", &::xs::documentation::lang_, xiso::leaf<std::string>());
        any_attribute(&::xs::documentation::attributes_);
      }

      void annotation_choice_leaf::model() {
      /** element member definitions */
        item("xs:appinfo", ::xs::appinfo_leaf());
        item("xs:documentation", ::xs::documentation_leaf());
      }

      void annotation_leaf::model() {
      /** element member definitions */
        member("&c0", &::xs::annotation::c0_, ::xs::annotation_choice_leaf(), 0, aka::unbounded);
        /** attribute member definition. */
        attribute("id", &::xs::annotation::id_, xiso::leaf<std::string>());
        any_attribute(&::xs::annotation::attributes_);
      }

      void annotated_sequence_leaf::model() {
      /** element member definitions */
        ptrmember("xs:annotation", &::xs::annotated_sequence::annotation_, ::xs::annotation_leaf());
      }

      void allModel_c0_leaf::model() {
      /** element member definitions */
        item("xs:element", ::xs::narrowMaxMin_leaf());
      }

      void allModel_leaf::model() {
      /** element member definitions */
        ptrmember("xs:annotation", &::xs::allModel::annotation_, ::xs::annotation_leaf());
        member("&c0", &::xs::allModel::c0_, ::xs::allModel_c0_leaf(), 0, aka::unbounded);
      }

      void all_leaf::model() {
      /** element member definitions */
        member("&allModel", &::xs::all::allModel_, ::xs::allModel_leaf());
        /** attribute member definition. */
        attribute("id", &::xs::all::id_, xiso::leaf<std::string>());
        attribute("name", &::xs::all::name_, xiso::leaf<std::string>());
        attribute("ref", &::xs::all::ref_, xs::QNameLeaf());
        attribute("minOccurs", &::xs::all::minOccurs_, xiso::leaf<long>()).set_default("1");
        attribute("maxOccurs", &::xs::all::maxOccurs_, ::xs::allNNI_leaf()).set_default("1");
        any_attribute(&::xs::all::attributes_);
      }

      void annotated_leaf::model() {
      /** element member definitions */
        ptrmember("xs:annotation", &::xs::annotated::annotation_, ::xs::annotation_leaf());
        /** attribute member definition. */
        attribute("id", &::xs::annotated::id_, xiso::leaf<std::string>());
        any_attribute(&::xs::annotated::attributes_);
      }

      void any_leaf::model() {
      /** element member definitions */
        ptrmember("xs:annotation", &::xs::any::annotation_, ::xs::annotation_leaf());
        /** attribute member definition. */
        attribute("id", &::xs::any::id_, xiso::leaf<std::string>());
        attribute("namespace", &::xs::any::namespace_, ::xs::namespaceList_leaf()).set_default("##any");
        attribute("processContents", &::xs::any::processContents_, ::xs::wildcard_processContents_leaf()).set_default("strict");
        attribute("minOccurs", &::xs::any::minOccurs_, xiso::leaf<long>()).set_default("1");
        attribute("maxOccurs", &::xs::any::maxOccurs_, ::xs::allNNI_leaf()).set_default("1");
        any_attribute(&::xs::any::attributes_);
      }

      void anyType_leaf::model() {
      /** element member definitions */
        any("&any", &::xs::anyType::any_, 0, aka::unbounded);
        /** attribute member definition. */
        any_attribute(&::xs::anyType::attributes_);
      }

      void attrDecls_c0_leaf::model() {
      /** element member definitions */
        item("xs:attribute", ::xs::attribute_leaf());
        item("xs:attributeGroup", ::xs::attributeGroupRef_leaf());
      }

      void wildcard_leaf::model() {
      /** element member definitions */
        ptrmember("xs:annotation", &::xs::wildcard::annotation_, ::xs::annotation_leaf());
        /** attribute member definition. */
        attribute("id", &::xs::wildcard::id_, xiso::leaf<std::string>());
        attribute("namespace", &::xs::wildcard::namespace_, ::xs::namespaceList_leaf()).set_default("##any");
        attribute("processContents", &::xs::wildcard::processContents_, ::xs::wildcard_processContents_leaf()).set_default("strict");
        any_attribute(&::xs::wildcard::attributes_);
      }

      void attrDecls_leaf::model() {
      /** element member definitions */
        member("&c0", &::xs::attrDecls::c0_, ::xs::attrDecls_c0_leaf(), 0, aka::unbounded);
        ptrmember("xs:anyAttribute", &::xs::attrDecls::anyAttribute_, ::xs::wildcard_leaf());
      }

      void simpleDerivation_leaf::model() {
      /** element member definitions */
        item("xs:restriction", ::xs::restriction_leaf());
        item("xs:list", ::xs::list_leaf());
        item("xs:union", ::xs::_union_leaf());
      }

      void localSimpleType_leaf::model() {
      /** element member definitions */
        ptrmember("xs:annotation", &::xs::localSimpleType::annotation_, ::xs::annotation_leaf());
        member("&simpleDerivation", &::xs::localSimpleType::simpleDerivation_, ::xs::simpleDerivation_leaf());
        /** attribute member definition. */
        attribute("id", &::xs::localSimpleType::id_, xiso::leaf<std::string>());
        attribute("final", &::xs::localSimpleType::final_, ::xs::simpleDerivationSet_leaf());
        attribute("name", &::xs::localSimpleType::name_, xiso::leaf<std::string>());
        any_attribute(&::xs::localSimpleType::attributes_);
      }

      void attribute_sequence_leaf::model() {
      /** element member definitions */
        ptrmember("xs:simpleType", &::xs::attribute_sequence::simpleType_, ::xs::localSimpleType_leaf());
      }

      void attribute_leaf::model() {
      /** element member definitions */
        member("&s0", &::xs::attribute::s0_, ::xs::annotated_sequence_leaf());
        member("&s1", &::xs::attribute::s1_, ::xs::attribute_sequence_leaf());
        /** attribute member definition. */
        attribute("id", &::xs::attribute::id_, xiso::leaf<std::string>());
        attribute("name", &::xs::attribute::name_, xiso::leaf<std::string>());
        attribute("ref", &::xs::attribute::ref_, xs::QNameLeaf());
        attribute("type", &::xs::attribute::type_, xs::QNameLeaf());
        attribute("use", &::xs::attribute::use_, ::xs::attribute_use_leaf()).set_default("optional");
        attribute("default", &::xs::attribute::default_, xiso::leaf<std::string>());
        attribute("fixed", &::xs::attribute::fixed_, xiso::leaf<std::string>());
        attribute("form", &::xs::attribute::form_, ::xs::formChoice_leaf());
        any_attribute(&::xs::attribute::attributes_);
      }

      void attributeGroup_leaf::model() {
      /** element member definitions */
        member("&s0", &::xs::attributeGroup::s0_, ::xs::annotated_sequence_leaf());
        member("&attrDecls", &::xs::attributeGroup::attrDecls_, ::xs::attrDecls_leaf());
        /** attribute member definition. */
        attribute("id", &::xs::attributeGroup::id_, xiso::leaf<std::string>());
        attribute("name", &::xs::attributeGroup::name_, xiso::leaf<std::string>());
        attribute("ref", &::xs::attributeGroup::ref_, xs::QNameLeaf());
        any_attribute(&::xs::attributeGroup::attributes_);
      }

      void attributeGroupRef_leaf::model() {
      /** element member definitions */
        ptrmember("xs:annotation", &::xs::attributeGroupRef::annotation_, ::xs::annotation_leaf());
        /** attribute member definition. */
        attribute("id", &::xs::attributeGroupRef::id_, xiso::leaf<std::string>());
        attribute("name", &::xs::attributeGroupRef::name_, xiso::leaf<std::string>());
        attribute("ref", &::xs::attributeGroupRef::ref_, xs::QNameLeaf()).required(true);
        any_attribute(&::xs::attributeGroupRef::attributes_);
      }

      void groupRef_leaf::model() {
      /** element member definitions */
        ptrmember("xs:annotation", &::xs::groupRef::annotation_, ::xs::annotation_leaf());
        /** attribute member definition. */
        attribute("id", &::xs::groupRef::id_, xiso::leaf<std::string>());
        attribute("name", &::xs::groupRef::name_, xiso::leaf<std::string>());
        attribute("ref", &::xs::groupRef::ref_, xs::QNameLeaf()).required(true);
        attribute("minOccurs", &::xs::groupRef::minOccurs_, xiso::leaf<long>()).set_default("1");
        attribute("maxOccurs", &::xs::groupRef::maxOccurs_, ::xs::allNNI_leaf()).set_default("1");
        any_attribute(&::xs::groupRef::attributes_);
      }

      void facet_leaf::model() {
      /** element member definitions */
        ptrmember("xs:annotation", &::xs::facet::annotation_, ::xs::annotation_leaf());
        /** attribute member definition. */
        attribute("id", &::xs::facet::id_, xiso::leaf<std::string>());
        attribute("value", &::xs::facet::value_, xiso::leaf<std::string>());
        attribute("fixed", &::xs::facet::fixed_, xiso::leaf<bool>()).set_default("false");
        any_attribute(&::xs::facet::attributes_);
      }

      void totalDigits_leaf::model() {
      /** element member definitions */
        ptrmember("xs:annotation", &::xs::totalDigits::annotation_, ::xs::annotation_leaf());
        /** attribute member definition. */
        attribute("id", &::xs::totalDigits::id_, xiso::leaf<std::string>());
        attribute("value", &::xs::totalDigits::value_, xiso::leaf<std::string>()).required(true);
        attribute("fixed", &::xs::totalDigits::fixed_, xiso::leaf<bool>()).set_default("false");
        any_attribute(&::xs::totalDigits::attributes_);
      }

      void numFacet_leaf::model() {
      /** element member definitions */
        ptrmember("xs:annotation", &::xs::numFacet::annotation_, ::xs::annotation_leaf());
        /** attribute member definition. */
        attribute("id", &::xs::numFacet::id_, xiso::leaf<std::string>());
        attribute("value", &::xs::numFacet::value_, xiso::leaf<std::string>()).required(true);
        attribute("fixed", &::xs::numFacet::fixed_, xiso::leaf<bool>()).set_default("false");
        any_attribute(&::xs::numFacet::attributes_);
      }

      void noFixedFacet_leaf::model() {
      /** element member definitions */
        ptrmember("xs:annotation", &::xs::noFixedFacet::annotation_, ::xs::annotation_leaf());
        /** attribute member definition. */
        attribute("id", &::xs::noFixedFacet::id_, xiso::leaf<std::string>());
        attribute("value", &::xs::noFixedFacet::value_, xiso::leaf<std::string>());
        attribute("fixed", &::xs::noFixedFacet::fixed_, xiso::leaf<bool>()).set_default("false");
        any_attribute(&::xs::noFixedFacet::attributes_);
      }

      void whiteSpace_leaf::model() {
      /** element member definitions */
        ptrmember("xs:annotation", &::xs::whiteSpace::annotation_, ::xs::annotation_leaf());
        /** attribute member definition. */
        attribute("id", &::xs::whiteSpace::id_, xiso::leaf<std::string>());
        attribute("value", &::xs::whiteSpace::value_, xiso::leaf<std::string>()).required(true);
        attribute("fixed", &::xs::whiteSpace::fixed_, xiso::leaf<bool>()).set_default("false");
        any_attribute(&::xs::whiteSpace::attributes_);
      }

      void pattern_leaf::model() {
      /** element member definitions */
        ptrmember("xs:annotation", &::xs::pattern::annotation_, ::xs::annotation_leaf());
        /** attribute member definition. */
        attribute("id", &::xs::pattern::id_, xiso::leaf<std::string>());
        attribute("value", &::xs::pattern::value_, xiso::leaf<std::string>()).required(true);
        attribute("fixed", &::xs::pattern::fixed_, xiso::leaf<bool>()).set_default("false");
        any_attribute(&::xs::pattern::attributes_);
      }

      void facets_leaf::model() {
      /** element member definitions */
        item("xs:minExclusive", ::xs::facet_leaf());
        item("xs:minInclusive", ::xs::facet_leaf());
        item("xs:maxExclusive", ::xs::facet_leaf());
        item("xs:maxInclusive", ::xs::facet_leaf());
        item("xs:totalDigits", ::xs::totalDigits_leaf());
        item("xs:fractionDigits", ::xs::numFacet_leaf());
        item("xs:length", ::xs::numFacet_leaf());
        item("xs:minLength", ::xs::numFacet_leaf());
        item("xs:maxLength", ::xs::numFacet_leaf());
        item("xs:enumeration", ::xs::noFixedFacet_leaf());
        item("xs:whiteSpace", ::xs::whiteSpace_leaf());
        item("xs:pattern", ::xs::pattern_leaf());
      }

      void simpleRestrictionModel_leaf::model() {
      /** element member definitions */
        ptrmember("xs:simpleType", &::xs::simpleRestrictionModel::simpleType_, ::xs::localSimpleType_leaf());
        member("&facets", &::xs::simpleRestrictionModel::facets_, ::xs::facets_leaf(), 0, aka::unbounded);
      }

      void simpleRestrictionType_sequence_c0_leaf::model() {
      /** element member definitions */
        item("&simpleRestrictionModel", ::xs::simpleRestrictionModel_leaf());
      }

      void simpleRestrictionType_leaf::model() {
      /** element member definitions */
        ptrmember("xs:annotation", &::xs::simpleRestrictionType::annotation_, ::xs::annotation_leaf());
        ptrmember("&c0", &::xs::simpleRestrictionType::c0_, ::xs::simpleRestrictionType_sequence_c0_leaf());
        member("&attrDecls", &::xs::simpleRestrictionType::attrDecls_, ::xs::attrDecls_leaf());
        /** attribute member definition. */
        attribute("id", &::xs::simpleRestrictionType::id_, xiso::leaf<std::string>());
        attribute("base", &::xs::simpleRestrictionType::base_, xs::QNameLeaf());
        any_attribute(&::xs::simpleRestrictionType::attributes_);
      }

      void simpleExtensionType_leaf::model() {
      /** element member definitions */
        ptrmember("xs:annotation", &::xs::simpleExtensionType::annotation_, ::xs::annotation_leaf());
        member("&attrDecls", &::xs::simpleExtensionType::attrDecls_, ::xs::attrDecls_leaf());
        /** attribute member definition. */
        attribute("id", &::xs::simpleExtensionType::id_, xiso::leaf<std::string>());
        attribute("base", &::xs::simpleExtensionType::base_, xs::QNameLeaf());
        any_attribute(&::xs::simpleExtensionType::attributes_);
      }

      void simpleContent_choice_leaf::model() {
      /** element member definitions */
        item("xs:restriction", ::xs::simpleRestrictionType_leaf());
        item("xs:extension", ::xs::simpleExtensionType_leaf());
      }

      void simpleContent_leaf::model() {
      /** element member definitions */
        member("&s0", &::xs::simpleContent::s0_, ::xs::annotated_sequence_leaf());
        member("&c0", &::xs::simpleContent::c0_, ::xs::simpleContent_choice_leaf());
        /** attribute member definition. */
        attribute("id", &::xs::simpleContent::id_, xiso::leaf<std::string>());
        any_attribute(&::xs::simpleContent::attributes_);
      }

      void complexContent_choice_leaf::model() {
      /** element member definitions */
        item("xs:restriction", ::xs::complexRestrictionType_leaf());
        item("xs:extension", ::xs::extensionType_leaf());
      }

      void complexContent_leaf::model() {
      /** element member definitions */
        member("&s0", &::xs::complexContent::s0_, ::xs::annotated_sequence_leaf());
        member("&c0", &::xs::complexContent::c0_, ::xs::complexContent_choice_leaf());
        /** attribute member definition. */
        attribute("id", &::xs::complexContent::id_, xiso::leaf<std::string>());
        attribute("mixed", &::xs::complexContent::mixed_, xiso::leaf<bool>());
        any_attribute(&::xs::complexContent::attributes_);
      }

      void complexRestrictionType_sequence_c0_leaf::model() {
      /** element member definitions */
        item("&typeDefParticle", ::xs::typeDefParticle_leaf());
      }

      void complexRestrictionType_leaf::model() {
      /** element member definitions */
        ptrmember("xs:annotation", &::xs::complexRestrictionType::annotation_, ::xs::annotation_leaf());
        ptrmember("&c0", &::xs::complexRestrictionType::c0_, ::xs::complexRestrictionType_sequence_c0_leaf());
        member("&attrDecls", &::xs::complexRestrictionType::attrDecls_, ::xs::attrDecls_leaf());
        /** attribute member definition. */
        attribute("id", &::xs::complexRestrictionType::id_, xiso::leaf<std::string>());
        attribute("base", &::xs::complexRestrictionType::base_, xs::QNameLeaf());
        any_attribute(&::xs::complexRestrictionType::attributes_);
      }

      void complexTypeModel_leaf::model() {
      /** element member definitions */
        item("xs:simpleContent", ::xs::simpleContent_leaf());
        item("xs:complexContent", ::xs::complexContent_leaf());
        item("&s0", ::xs::complexTypeModel_s0_leaf());
      }

      void complexType_leaf::model() {
      /** element member definitions */
        member("&s0", &::xs::complexType::s0_, ::xs::annotated_sequence_leaf());
        member("&complexTypeModel", &::xs::complexType::complexTypeModel_, ::xs::complexTypeModel_leaf());
        /** attribute member definition. */
        attribute("id", &::xs::complexType::id_, xiso::leaf<std::string>());
        attribute("name", &::xs::complexType::name_, xiso::leaf<std::string>());
        attribute("mixed", &::xs::complexType::mixed_, xiso::leaf<bool>()).set_default("false");
        attribute("abstract", &::xs::complexType::abstract_, xiso::leaf<bool>()).set_default("false");
        attribute("final", &::xs::complexType::final_, ::xs::derivationSet_leaf());
        attribute("block", &::xs::complexType::block_, ::xs::derivationSet_leaf());
        any_attribute(&::xs::complexType::attributes_);
      }

      void localComplexType_leaf::model() {
      /** element member definitions */
        ptrmember("xs:annotation", &::xs::localComplexType::annotation_, ::xs::annotation_leaf());
        member("&complexTypeModel", &::xs::localComplexType::complexTypeModel_, ::xs::complexTypeModel_leaf());
        /** attribute member definition. */
        attribute("id", &::xs::localComplexType::id_, xiso::leaf<std::string>());
        attribute("name", &::xs::localComplexType::name_, xiso::leaf<std::string>());
        attribute("mixed", &::xs::localComplexType::mixed_, xiso::leaf<bool>()).set_default("false");
        attribute("abstract", &::xs::localComplexType::abstract_, xiso::leaf<bool>()).set_default("false");
        attribute("final", &::xs::localComplexType::final_, ::xs::derivationSet_leaf());
        attribute("block", &::xs::localComplexType::block_, ::xs::derivationSet_leaf());
        any_attribute(&::xs::localComplexType::attributes_);
      }

      void localElement_sequence_c0_leaf::model() {
      /** element member definitions */
        item("xs:simpleType", ::xs::localSimpleType_leaf());
        item("xs:complexType", ::xs::localComplexType_leaf());
      }

      void selector_leaf::model() {
      /** element member definitions */
        ptrmember("xs:annotation", &::xs::selector::annotation_, ::xs::annotation_leaf());
        /** attribute member definition. */
        attribute("id", &::xs::selector::id_, xiso::leaf<std::string>());
        attribute("xpath", &::xs::selector::xpath_, ::xs::selector_xpath_leaf());
        any_attribute(&::xs::selector::attributes_);
      }

      void field_leaf::model() {
      /** element member definitions */
        ptrmember("xs:annotation", &::xs::field::annotation_, ::xs::annotation_leaf());
        /** attribute member definition. */
        attribute("id", &::xs::field::id_, xiso::leaf<std::string>());
        attribute("xpath", &::xs::field::xpath_, ::xs::field_xpath_leaf());
        any_attribute(&::xs::field::attributes_);
      }

      void keybase_sequence_leaf::model() {
      /** element member definitions */
        member("xs:selector", &::xs::keybase_sequence::selector_, ::xs::selector_leaf());
        member("xs:field", &::xs::keybase_sequence::field_, ::xs::field_array_leaf(), 1, aka::unbounded);
      }

      void keybase_leaf::model() {
      /** element member definitions */
        member("&s0", &::xs::keybase::s0_, ::xs::annotated_sequence_leaf());
        member("&s1", &::xs::keybase::s1_, ::xs::keybase_sequence_leaf());
        /** attribute member definition. */
        attribute("id", &::xs::keybase::id_, xiso::leaf<std::string>());
        attribute("name", &::xs::keybase::name_, xiso::leaf<std::string>());
        any_attribute(&::xs::keybase::attributes_);
      }

      void keyref_leaf::model() {
      /** element member definitions */
        member("&s0", &::xs::keyref::s0_, ::xs::annotated_sequence_leaf());
        member("&s1", &::xs::keyref::s1_, ::xs::keybase_sequence_leaf());
        /** attribute member definition. */
        attribute("id", &::xs::keyref::id_, xiso::leaf<std::string>());
        attribute("name", &::xs::keyref::name_, xiso::leaf<std::string>());
        attribute("refer", &::xs::keyref::refer_, xs::QNameLeaf());
        any_attribute(&::xs::keyref::attributes_);
      }

      void identityConstraint_leaf::model() {
      /** element member definitions */
        item("xs:unique", ::xs::keybase_leaf());
        item("xs:key", ::xs::keybase_leaf());
        item("xs:keyref", ::xs::keyref_leaf());
      }

      void localElement_leaf::model() {
      /** element member definitions */
        ptrmember("xs:annotation", &::xs::localElement::annotation_, ::xs::annotation_leaf());
        ptrmember("&c0", &::xs::localElement::c0_, ::xs::localElement_sequence_c0_leaf());
        member("&identityConstraint", &::xs::localElement::identityConstraint_, ::xs::identityConstraint_leaf(), 0, aka::unbounded);
        /** attribute member definition. */
        attribute("id", &::xs::localElement::id_, xiso::leaf<std::string>());
        attribute("name", &::xs::localElement::name_, xiso::leaf<std::string>());
        attribute("ref", &::xs::localElement::ref_, xs::QNameLeaf());
        attribute("type", &::xs::localElement::type_, xs::QNameLeaf());
        attribute("substitutionGroup", &::xs::localElement::substitutionGroup_, xs::QNameLeaf());
        attribute("minOccurs", &::xs::localElement::minOccurs_, xiso::leaf<long>()).set_default("1");
        attribute("maxOccurs", &::xs::localElement::maxOccurs_, ::xs::allNNI_leaf()).set_default("1");
        attribute("default", &::xs::localElement::default_, xiso::leaf<std::string>());
        attribute("fixed", &::xs::localElement::fixed_, xiso::leaf<std::string>());
        attribute("nillable", &::xs::localElement::nillable_, xiso::leaf<bool>()).set_default("false");
        attribute("abstract", &::xs::localElement::abstract_, xiso::leaf<bool>()).set_default("false");
        attribute("final", &::xs::localElement::final_, ::xs::derivationSet_leaf());
        attribute("block", &::xs::localElement::block_, ::xs::blockSet_leaf());
        attribute("form", &::xs::localElement::form_, ::xs::formChoice_leaf());
        any_attribute(&::xs::localElement::attributes_);
      }

      void typeDefParticle_leaf::model() {
      /** element member definitions */
        item("xs:group", ::xs::groupRef_leaf());
        item("xs:all", ::xs::all_leaf());
        item("xs:choice", ::xs::explicitGroup_leaf());
        item("xs:sequence", ::xs::explicitGroup_leaf());
      }

      void complexTypeModel_s0_leaf::model() {
      /** element member definitions */
        ptrmember("&typeDefParticle", &::xs::complexTypeModel_s0::typeDefParticle_, ::xs::typeDefParticle_leaf());
        member("&attrDecls", &::xs::complexTypeModel_s0::attrDecls_, ::xs::attrDecls_leaf());
      }

      void element_sequence_c0_leaf::model() {
      /** element member definitions */
        item("xs:simpleType", ::xs::localSimpleType_leaf());
        item("xs:complexType", ::xs::localComplexType_leaf());
      }

      void element_sequence_leaf::model() {
      /** element member definitions */
        ptrmember("&c0", &::xs::element_sequence::c0_, ::xs::element_sequence_c0_leaf());
        member("&identityConstraint", &::xs::element_sequence::identityConstraint_, ::xs::identityConstraint_leaf(), 0, aka::unbounded);
      }

      void element_leaf::model() {
      /** element member definitions */
        member("&s0", &::xs::element::s0_, ::xs::annotated_sequence_leaf());
        member("&s1", &::xs::element::s1_, ::xs::element_sequence_leaf());
        /** attribute member definition. */
        attribute("id", &::xs::element::id_, xiso::leaf<std::string>());
        attribute("name", &::xs::element::name_, xiso::leaf<std::string>());
        attribute("ref", &::xs::element::ref_, xs::QNameLeaf());
        attribute("type", &::xs::element::type_, xs::QNameLeaf());
        attribute("substitutionGroup", &::xs::element::substitutionGroup_, xs::QNameLeaf());
        attribute("minOccurs", &::xs::element::minOccurs_, xiso::leaf<long>()).set_default("1");
        attribute("maxOccurs", &::xs::element::maxOccurs_, ::xs::allNNI_leaf()).set_default("1");
        attribute("default", &::xs::element::default_, xiso::leaf<std::string>());
        attribute("fixed", &::xs::element::fixed_, xiso::leaf<std::string>());
        attribute("nillable", &::xs::element::nillable_, xiso::leaf<bool>()).set_default("false");
        attribute("abstract", &::xs::element::abstract_, xiso::leaf<bool>()).set_default("false");
        attribute("final", &::xs::element::final_, ::xs::derivationSet_leaf());
        attribute("block", &::xs::element::block_, ::xs::blockSet_leaf());
        attribute("form", &::xs::element::form_, ::xs::formChoice_leaf());
        any_attribute(&::xs::element::attributes_);
      }

      void nestedParticle_leaf::model() {
      /** element member definitions */
        item("xs:element", ::xs::localElement_leaf());
        item("xs:group", ::xs::groupRef_leaf());
        item("xs:choice", ::xs::explicitGroup_leaf());
        item("xs:sequence", ::xs::explicitGroup_leaf());
        item("xs:any", ::xs::any_leaf());
      }

      void explicitGroup_leaf::model() {
      /** element member definitions */
        ptrmember("xs:annotation", &::xs::explicitGroup::annotation_, ::xs::annotation_leaf());
        member("&nestedParticle", &::xs::explicitGroup::nestedParticle_, ::xs::nestedParticle_leaf(), 0, aka::unbounded);
        /** attribute member definition. */
        attribute("id", &::xs::explicitGroup::id_, xiso::leaf<std::string>());
        attribute("name", &::xs::explicitGroup::name_, xiso::leaf<std::string>());
        attribute("ref", &::xs::explicitGroup::ref_, xs::QNameLeaf());
        attribute("minOccurs", &::xs::explicitGroup::minOccurs_, xiso::leaf<long>()).set_default("1");
        attribute("maxOccurs", &::xs::explicitGroup::maxOccurs_, ::xs::allNNI_leaf()).set_default("1");
        any_attribute(&::xs::explicitGroup::attributes_);
      }

      void extensionType_sequence_leaf::model() {
      /** element member definitions */
        ptrmember("&typeDefParticle", &::xs::extensionType_sequence::typeDefParticle_, ::xs::typeDefParticle_leaf());
        member("&attrDecls", &::xs::extensionType_sequence::attrDecls_, ::xs::attrDecls_leaf());
      }

      void extensionType_leaf::model() {
      /** element member definitions */
        member("&s0", &::xs::extensionType::s0_, ::xs::annotated_sequence_leaf());
        member("&s1", &::xs::extensionType::s1_, ::xs::extensionType_sequence_leaf());
        /** attribute member definition. */
        attribute("id", &::xs::extensionType::id_, xiso::leaf<std::string>());
        attribute("base", &::xs::extensionType::base_, xs::QNameLeaf());
        any_attribute(&::xs::extensionType::attributes_);
      }

      void particle_leaf::model() {
      /** element member definitions */
        item("xs:element", ::xs::localElement_leaf());
        item("xs:group", ::xs::groupRef_leaf());
        item("xs:all", ::xs::all_leaf());
        item("xs:choice", ::xs::explicitGroup_leaf());
        item("xs:sequence", ::xs::explicitGroup_leaf());
        item("xs:any", ::xs::any_leaf());
      }

      void group_leaf::model() {
      /** element member definitions */
        member("&s0", &::xs::group::s0_, ::xs::annotated_sequence_leaf());
        member("&particle", &::xs::group::particle_, ::xs::particle_leaf(), 0, aka::unbounded);
        /** attribute member definition. */
        attribute("id", &::xs::group::id_, xiso::leaf<std::string>());
        attribute("name", &::xs::group::name_, xiso::leaf<std::string>());
        attribute("ref", &::xs::group::ref_, xs::QNameLeaf());
        attribute("minOccurs", &::xs::group::minOccurs_, xiso::leaf<long>()).set_default("1");
        attribute("maxOccurs", &::xs::group::maxOccurs_, ::xs::allNNI_leaf()).set_default("1");
        any_attribute(&::xs::group::attributes_);
      }

      void import_leaf::model() {
      /** element member definitions */
        ptrmember("xs:annotation", &::xs::import::annotation_, ::xs::annotation_leaf());
        /** attribute member definition. */
        attribute("id", &::xs::import::id_, xiso::leaf<std::string>());
        attribute("namespace", &::xs::import::namespace_, xiso::leaf<std::string>());
        attribute("schemaLocation", &::xs::import::schemaLocation_, xiso::leaf<std::string>());
        any_attribute(&::xs::import::attributes_);
      }

      void include_leaf::model() {
      /** element member definitions */
        ptrmember("xs:annotation", &::xs::include::annotation_, ::xs::annotation_leaf());
        /** attribute member definition. */
        attribute("id", &::xs::include::id_, xiso::leaf<std::string>());
        attribute("schemaLocation", &::xs::include::schemaLocation_, xiso::leaf<std::string>());
        any_attribute(&::xs::include::attributes_);
      }

      void list_sequence_leaf::model() {
      /** element member definitions */
        ptrmember("xs:simpleType", &::xs::list_sequence::simpleType_, ::xs::localSimpleType_leaf());
      }

      void list_leaf::model() {
      /** element member definitions */
        member("&s0", &::xs::list::s0_, ::xs::annotated_sequence_leaf());
        member("&s1", &::xs::list::s1_, ::xs::list_sequence_leaf());
        /** attribute member definition. */
        attribute("id", &::xs::list::id_, xiso::leaf<std::string>());
        attribute("itemType", &::xs::list::itemType_, xs::QNameLeaf());
        any_attribute(&::xs::list::attributes_);
      }

      void namedAttributeGroup_leaf::model() {
      /** element member definitions */
        ptrmember("xs:annotation", &::xs::namedAttributeGroup::annotation_, ::xs::annotation_leaf());
        member("&attrDecls", &::xs::namedAttributeGroup::attrDecls_, ::xs::attrDecls_leaf());
        /** attribute member definition. */
        attribute("id", &::xs::namedAttributeGroup::id_, xiso::leaf<std::string>());
        attribute("name", &::xs::namedAttributeGroup::name_, xiso::leaf<std::string>()).required(true);
        attribute("ref", &::xs::namedAttributeGroup::ref_, xs::QNameLeaf());
        any_attribute(&::xs::namedAttributeGroup::attributes_);
      }

      void namedGroup_sequence_c0_all_leaf::model() {
      /** element member definitions */
        member("&allModel", &::xs::namedGroup_sequence_c0_all::allModel_, ::xs::allModel_leaf());
        /** attribute member definition. */
        attribute("id", &::xs::namedGroup_sequence_c0_all::id_, xiso::leaf<std::string>());
        attribute("name", &::xs::namedGroup_sequence_c0_all::name_, xiso::leaf<std::string>());
        attribute("ref", &::xs::namedGroup_sequence_c0_all::ref_, xs::QNameLeaf());
        attribute("minOccurs", &::xs::namedGroup_sequence_c0_all::minOccurs_, xiso::leaf<long>()).set_default("1");
        attribute("maxOccurs", &::xs::namedGroup_sequence_c0_all::maxOccurs_, ::xs::allNNI_leaf()).set_default("1");
        any_attribute(&::xs::namedGroup_sequence_c0_all::attributes_);
      }

      void simpleExplicitGroup_leaf::model() {
      /** element member definitions */
        ptrmember("xs:annotation", &::xs::simpleExplicitGroup::annotation_, ::xs::annotation_leaf());
        member("&nestedParticle", &::xs::simpleExplicitGroup::nestedParticle_, ::xs::nestedParticle_leaf(), 0, aka::unbounded);
        /** attribute member definition. */
        attribute("id", &::xs::simpleExplicitGroup::id_, xiso::leaf<std::string>());
        attribute("name", &::xs::simpleExplicitGroup::name_, xiso::leaf<std::string>());
        attribute("ref", &::xs::simpleExplicitGroup::ref_, xs::QNameLeaf());
        attribute("minOccurs", &::xs::simpleExplicitGroup::minOccurs_, xiso::leaf<long>()).set_default("1");
        attribute("maxOccurs", &::xs::simpleExplicitGroup::maxOccurs_, ::xs::allNNI_leaf()).set_default("1");
        any_attribute(&::xs::simpleExplicitGroup::attributes_);
      }

      void namedGroup_sequence_c0_leaf::model() {
      /** element member definitions */
        item("xs:all", ::xs::namedGroup_sequence_c0_all_leaf());
        item("xs:choice", ::xs::simpleExplicitGroup_leaf());
        item("xs:sequence", ::xs::simpleExplicitGroup_leaf());
      }

      void namedGroup_leaf::model() {
      /** element member definitions */
        ptrmember("xs:annotation", &::xs::namedGroup::annotation_, ::xs::annotation_leaf());
        member("&c0", &::xs::namedGroup::c0_, ::xs::namedGroup_sequence_c0_leaf());
        /** attribute member definition. */
        attribute("id", &::xs::namedGroup::id_, xiso::leaf<std::string>());
        attribute("name", &::xs::namedGroup::name_, xiso::leaf<std::string>()).required(true);
        attribute("ref", &::xs::namedGroup::ref_, xs::QNameLeaf());
        attribute("minOccurs", &::xs::namedGroup::minOccurs_, xiso::leaf<long>()).set_default("1");
        attribute("maxOccurs", &::xs::namedGroup::maxOccurs_, ::xs::allNNI_leaf()).set_default("1");
        any_attribute(&::xs::namedGroup::attributes_);
      }

      void narrowMaxMin_sequence_c0_leaf::model() {
      /** element member definitions */
        item("xs:simpleType", ::xs::localSimpleType_leaf());
        item("xs:complexType", ::xs::localComplexType_leaf());
      }

      void narrowMaxMin_leaf::model() {
      /** element member definitions */
        ptrmember("xs:annotation", &::xs::narrowMaxMin::annotation_, ::xs::annotation_leaf());
        ptrmember("&c0", &::xs::narrowMaxMin::c0_, ::xs::narrowMaxMin_sequence_c0_leaf());
        member("&identityConstraint", &::xs::narrowMaxMin::identityConstraint_, ::xs::identityConstraint_leaf(), 0, aka::unbounded);
        /** attribute member definition. */
        attribute("id", &::xs::narrowMaxMin::id_, xiso::leaf<std::string>());
        attribute("name", &::xs::narrowMaxMin::name_, xiso::leaf<std::string>());
        attribute("ref", &::xs::narrowMaxMin::ref_, xs::QNameLeaf());
        attribute("type", &::xs::narrowMaxMin::type_, xs::QNameLeaf());
        attribute("substitutionGroup", &::xs::narrowMaxMin::substitutionGroup_, xs::QNameLeaf());
        attribute("minOccurs", &::xs::narrowMaxMin::minOccurs_, xiso::leaf<long>()).set_default("1");
        attribute("maxOccurs", &::xs::narrowMaxMin::maxOccurs_, ::xs::allNNI_leaf()).set_default("1");
        attribute("default", &::xs::narrowMaxMin::default_, xiso::leaf<std::string>());
        attribute("fixed", &::xs::narrowMaxMin::fixed_, xiso::leaf<std::string>());
        attribute("nillable", &::xs::narrowMaxMin::nillable_, xiso::leaf<bool>()).set_default("false");
        attribute("abstract", &::xs::narrowMaxMin::abstract_, xiso::leaf<bool>()).set_default("false");
        attribute("final", &::xs::narrowMaxMin::final_, ::xs::derivationSet_leaf());
        attribute("block", &::xs::narrowMaxMin::block_, ::xs::blockSet_leaf());
        attribute("form", &::xs::narrowMaxMin::form_, ::xs::formChoice_leaf());
        any_attribute(&::xs::narrowMaxMin::attributes_);
      }

      void notation_leaf::model() {
      /** element member definitions */
        ptrmember("xs:annotation", &::xs::notation::annotation_, ::xs::annotation_leaf());
        /** attribute member definition. */
        attribute("id", &::xs::notation::id_, xiso::leaf<std::string>());
        attribute("name", &::xs::notation::name_, xiso::leaf<std::string>());
        attribute("public", &::xs::notation::public_, ::xs::_public_leaf());
        attribute("system", &::xs::notation::system_, xiso::leaf<std::string>());
        any_attribute(&::xs::notation::attributes_);
      }

      void openAttrs_leaf::model() {
        /** attribute member definition. */
        any_attribute(&::xs::openAttrs::attributes_);
      }

      void realGroup_sequence_c0_leaf::model() {
      /** element member definitions */
        item("xs:all", ::xs::all_leaf());
        item("xs:choice", ::xs::explicitGroup_leaf());
        item("xs:sequence", ::xs::explicitGroup_leaf());
      }

      void realGroup_leaf::model() {
      /** element member definitions */
        ptrmember("xs:annotation", &::xs::realGroup::annotation_, ::xs::annotation_leaf());
        ptrmember("&c0", &::xs::realGroup::c0_, ::xs::realGroup_sequence_c0_leaf());
        /** attribute member definition. */
        attribute("id", &::xs::realGroup::id_, xiso::leaf<std::string>());
        attribute("name", &::xs::realGroup::name_, xiso::leaf<std::string>());
        attribute("ref", &::xs::realGroup::ref_, xs::QNameLeaf());
        attribute("minOccurs", &::xs::realGroup::minOccurs_, xiso::leaf<long>()).set_default("1");
        attribute("maxOccurs", &::xs::realGroup::maxOccurs_, ::xs::allNNI_leaf()).set_default("1");
        any_attribute(&::xs::realGroup::attributes_);
      }

      void topLevelSimpleType_leaf::model() {
      /** element member definitions */
        ptrmember("xs:annotation", &::xs::topLevelSimpleType::annotation_, ::xs::annotation_leaf());
        member("&simpleDerivation", &::xs::topLevelSimpleType::simpleDerivation_, ::xs::simpleDerivation_leaf());
        /** attribute member definition. */
        attribute("id", &::xs::topLevelSimpleType::id_, xiso::leaf<std::string>());
        attribute("final", &::xs::topLevelSimpleType::final_, ::xs::simpleDerivationSet_leaf());
        attribute("name", &::xs::topLevelSimpleType::name_, xiso::leaf<std::string>()).required(true);
        any_attribute(&::xs::topLevelSimpleType::attributes_);
      }

      void topLevelComplexType_leaf::model() {
      /** element member definitions */
        ptrmember("xs:annotation", &::xs::topLevelComplexType::annotation_, ::xs::annotation_leaf());
        member("&complexTypeModel", &::xs::topLevelComplexType::complexTypeModel_, ::xs::complexTypeModel_leaf());
        /** attribute member definition. */
        attribute("id", &::xs::topLevelComplexType::id_, xiso::leaf<std::string>());
        attribute("name", &::xs::topLevelComplexType::name_, xiso::leaf<std::string>()).required(true);
        attribute("mixed", &::xs::topLevelComplexType::mixed_, xiso::leaf<bool>()).set_default("false");
        attribute("abstract", &::xs::topLevelComplexType::abstract_, xiso::leaf<bool>()).set_default("false");
        attribute("final", &::xs::topLevelComplexType::final_, ::xs::derivationSet_leaf());
        attribute("block", &::xs::topLevelComplexType::block_, ::xs::derivationSet_leaf());
        any_attribute(&::xs::topLevelComplexType::attributes_);
      }

      void redefinable_leaf::model() {
      /** element member definitions */
        item("xs:simpleType", ::xs::topLevelSimpleType_leaf());
        item("xs:complexType", ::xs::topLevelComplexType_leaf());
        item("xs:group", ::xs::namedGroup_leaf());
        item("xs:attributeGroup", ::xs::namedAttributeGroup_leaf());
      }

      void redefine_choice_leaf::model() {
      /** element member definitions */
        item("xs:annotation", ::xs::annotation_leaf());
        item("&redefinable", ::xs::redefinable_leaf());
      }

      void redefine_leaf::model() {
      /** element member definitions */
        member("&c0", &::xs::redefine::c0_, ::xs::redefine_choice_leaf(), 0, aka::unbounded);
        /** attribute member definition. */
        attribute("schemaLocation", &::xs::redefine::schemaLocation_, xiso::leaf<std::string>());
        attribute("id", &::xs::redefine::id_, xiso::leaf<std::string>());
        any_attribute(&::xs::redefine::attributes_);
      }

      void restriction_leaf::model() {
      /** element member definitions */
        member("&s0", &::xs::restriction::s0_, ::xs::annotated_sequence_leaf());
        member("&simpleRestrictionModel", &::xs::restriction::simpleRestrictionModel_, ::xs::simpleRestrictionModel_leaf());
        /** attribute member definition. */
        attribute("id", &::xs::restriction::id_, xiso::leaf<std::string>());
        attribute("base", &::xs::restriction::base_, xs::QNameLeaf());
        any_attribute(&::xs::restriction::attributes_);
      }

      void restrictionType_sequence_c0_leaf::model() {
      /** element member definitions */
        item("&typeDefParticle", ::xs::typeDefParticle_leaf());
        item("&simpleRestrictionModel", ::xs::simpleRestrictionModel_leaf());
      }

      void restrictionType_sequence_leaf::model() {
      /** element member definitions */
        ptrmember("&c0", &::xs::restrictionType_sequence::c0_, ::xs::restrictionType_sequence_c0_leaf());
        member("&attrDecls", &::xs::restrictionType_sequence::attrDecls_, ::xs::attrDecls_leaf());
      }

      void restrictionType_leaf::model() {
      /** element member definitions */
        member("&s0", &::xs::restrictionType::s0_, ::xs::annotated_sequence_leaf());
        member("&s1", &::xs::restrictionType::s1_, ::xs::restrictionType_sequence_leaf());
        /** attribute member definition. */
        attribute("id", &::xs::restrictionType::id_, xiso::leaf<std::string>());
        attribute("base", &::xs::restrictionType::base_, xs::QNameLeaf());
        any_attribute(&::xs::restrictionType::attributes_);
      }

      void schema_sequence_c0_leaf::model() {
      /** element member definitions */
        item("xs:include", ::xs::include_leaf());
        item("xs:import", ::xs::import_leaf());
        item("xs:redefine", ::xs::redefine_leaf());
        item("xs:annotation", ::xs::annotation_leaf());
      }

      void topLevelElement_sequence_c0_leaf::model() {
      /** element member definitions */
        item("xs:simpleType", ::xs::localSimpleType_leaf());
        item("xs:complexType", ::xs::localComplexType_leaf());
      }

      void topLevelElement_leaf::model() {
      /** element member definitions */
        ptrmember("xs:annotation", &::xs::topLevelElement::annotation_, ::xs::annotation_leaf());
        ptrmember("&c0", &::xs::topLevelElement::c0_, ::xs::topLevelElement_sequence_c0_leaf());
        member("&identityConstraint", &::xs::topLevelElement::identityConstraint_, ::xs::identityConstraint_leaf(), 0, aka::unbounded);
        /** attribute member definition. */
        attribute("id", &::xs::topLevelElement::id_, xiso::leaf<std::string>());
        attribute("name", &::xs::topLevelElement::name_, xiso::leaf<std::string>()).required(true);
        attribute("ref", &::xs::topLevelElement::ref_, xs::QNameLeaf());
        attribute("type", &::xs::topLevelElement::type_, xs::QNameLeaf());
        attribute("substitutionGroup", &::xs::topLevelElement::substitutionGroup_, xs::QNameLeaf());
        attribute("minOccurs", &::xs::topLevelElement::minOccurs_, xiso::leaf<long>()).set_default("1");
        attribute("maxOccurs", &::xs::topLevelElement::maxOccurs_, ::xs::allNNI_leaf()).set_default("1");
        attribute("default", &::xs::topLevelElement::default_, xiso::leaf<std::string>());
        attribute("fixed", &::xs::topLevelElement::fixed_, xiso::leaf<std::string>());
        attribute("nillable", &::xs::topLevelElement::nillable_, xiso::leaf<bool>()).set_default("false");
        attribute("abstract", &::xs::topLevelElement::abstract_, xiso::leaf<bool>()).set_default("false");
        attribute("final", &::xs::topLevelElement::final_, ::xs::derivationSet_leaf());
        attribute("block", &::xs::topLevelElement::block_, ::xs::blockSet_leaf());
        attribute("form", &::xs::topLevelElement::form_, ::xs::formChoice_leaf());
        any_attribute(&::xs::topLevelElement::attributes_);
      }

      void topLevelAttribute_leaf::model() {
      /** element member definitions */
        ptrmember("xs:annotation", &::xs::topLevelAttribute::annotation_, ::xs::annotation_leaf());
        ptrmember("xs:simpleType", &::xs::topLevelAttribute::simpleType_, ::xs::localSimpleType_leaf());
        /** attribute member definition. */
        attribute("id", &::xs::topLevelAttribute::id_, xiso::leaf<std::string>());
        attribute("name", &::xs::topLevelAttribute::name_, xiso::leaf<std::string>()).required(true);
        attribute("ref", &::xs::topLevelAttribute::ref_, xs::QNameLeaf());
        attribute("type", &::xs::topLevelAttribute::type_, xs::QNameLeaf());
        attribute("use", &::xs::topLevelAttribute::use_, ::xs::attribute_use_leaf()).set_default("optional");
        attribute("default", &::xs::topLevelAttribute::default_, xiso::leaf<std::string>());
        attribute("fixed", &::xs::topLevelAttribute::fixed_, xiso::leaf<std::string>());
        attribute("form", &::xs::topLevelAttribute::form_, ::xs::formChoice_leaf());
        any_attribute(&::xs::topLevelAttribute::attributes_);
      }

      void schemaTop_leaf::model() {
      /** element member definitions */
        item("&redefinable", ::xs::redefinable_leaf());
        item("xs:element", ::xs::topLevelElement_leaf());
        item("xs:attribute", ::xs::topLevelAttribute_leaf());
        item("xs:notation", ::xs::notation_leaf());
      }

      void schema_sequence_s0_leaf::model() {
      /** element member definitions */
        member("&schemaTop", &::xs::schema_sequence_s0::schemaTop_, ::xs::schemaTop_leaf());
        member("xs:annotation", &::xs::schema_sequence_s0::annotation_, ::xs::annotation_array_leaf(), 0, aka::unbounded);
      }

      void schema_leaf::model() {
      /** element member definitions */
        member("&c0", &::xs::schema::c0_, ::xs::schema_sequence_c0_leaf(), 0, aka::unbounded);
        member("&s0", &::xs::schema::s0_, ::xs::schema_sequence_s0_holder_leaf(), 0, aka::unbounded);
        /** attribute member definition. */
        attribute("targetNamespace", &::xs::schema::targetNamespace_, xiso::leaf<std::string>());
        attribute("version", &::xs::schema::version_, xiso::leaf<std::string>());
        attribute("finalDefault", &::xs::schema::finalDefault_, ::xs::fullDerivationSet_leaf());
        attribute("blockDefault", &::xs::schema::blockDefault_, ::xs::blockSet_leaf());
        attribute("attributeFormDefault", &::xs::schema::attributeFormDefault_, ::xs::formChoice_leaf()).set_default("unqualified");
        attribute("elementFormDefault", &::xs::schema::elementFormDefault_, ::xs::formChoice_leaf()).set_default("unqualified");
        attribute("id", &::xs::schema::id_, xiso::leaf<std::string>());
        attribute("xml:lang", &::xs::schema::lang_, xiso::leaf<std::string>());
        any_attribute(&::xs::schema::attributes_);
      }

      void simpleType_leaf::model() {
      /** element member definitions */
        member("&s0", &::xs::simpleType::s0_, ::xs::annotated_sequence_leaf());
        member("&simpleDerivation", &::xs::simpleType::simpleDerivation_, ::xs::simpleDerivation_leaf());
        /** attribute member definition. */
        attribute("id", &::xs::simpleType::id_, xiso::leaf<std::string>());
        attribute("final", &::xs::simpleType::final_, ::xs::simpleDerivationSet_leaf());
        attribute("name", &::xs::simpleType::name_, xiso::leaf<std::string>());
        any_attribute(&::xs::simpleType::attributes_);
      }

      void union_sequence_leaf::model() {
      /** element member definitions */
        member("xs:simpleType", &::xs::union_sequence::simpleType_, ::xs::localSimpleType_array_leaf(), 0, aka::unbounded);
      }

      void _union_leaf::model() {
      /** element member definitions */
        member("&s0", &::xs::_union::s0_, ::xs::annotated_sequence_leaf());
        member("&s1", &::xs::_union::s1_, ::xs::union_sequence_leaf());
        /** attribute member definition. */
        attribute("id", &::xs::_union::id_, xiso::leaf<std::string>());
        attribute("memberTypes", &::xs::_union::memberTypes_, ::xs::union_memberTypes_leaf());
        any_attribute(&::xs::_union::attributes_);
      }

      void instantiate_xiso() {
        aka::xmlns("xs", "http://www.w3.org/2001/XMLSchema");
        aka::doctype("xs:all", ::xs::all_leaf());
        aka::doctype("xs:annotation", ::xs::annotation_leaf());
        aka::doctype("xs:any", ::xs::any_leaf());
        aka::doctype("xs:anyAttribute", ::xs::wildcard_leaf());
        aka::doctype("xs:appinfo", ::xs::appinfo_leaf());
        aka::doctype("xs:attribute", ::xs::topLevelAttribute_leaf());
        aka::doctype("xs:attributeGroup", ::xs::namedAttributeGroup_leaf());
        aka::doctype("xs:choice", ::xs::explicitGroup_leaf());
        aka::doctype("xs:complexContent", ::xs::complexContent_leaf());
        aka::doctype("xs:complexType", ::xs::topLevelComplexType_leaf());
        aka::doctype("xs:documentation", ::xs::documentation_leaf());
        aka::doctype("xs:element", ::xs::topLevelElement_leaf());
        aka::doctype("xs:enumeration", ::xs::noFixedFacet_leaf());
        aka::doctype("xs:field", ::xs::field_leaf());
        aka::doctype("xs:fractionDigits", ::xs::numFacet_leaf());
        aka::doctype("xs:group", ::xs::namedGroup_leaf());
        aka::doctype("xs:import", ::xs::import_leaf());
        aka::doctype("xs:include", ::xs::include_leaf());
        aka::doctype("xs:key", ::xs::keybase_leaf());
        aka::doctype("xs:keyref", ::xs::keyref_leaf());
        aka::doctype("xs:length", ::xs::numFacet_leaf());
        aka::doctype("xs:list", ::xs::list_leaf());
        aka::doctype("xs:maxExclusive", ::xs::facet_leaf());
        aka::doctype("xs:maxInclusive", ::xs::facet_leaf());
        aka::doctype("xs:maxLength", ::xs::numFacet_leaf());
        aka::doctype("xs:minExclusive", ::xs::facet_leaf());
        aka::doctype("xs:minInclusive", ::xs::facet_leaf());
        aka::doctype("xs:minLength", ::xs::numFacet_leaf());
        aka::doctype("xs:notation", ::xs::notation_leaf());
        aka::doctype("xs:pattern", ::xs::pattern_leaf());
        aka::doctype("xs:redefine", ::xs::redefine_leaf());
        aka::doctype("xs:restriction", ::xs::restriction_leaf());
        aka::doctype("xs:schema", ::xs::schema_leaf());
        aka::doctype("xs:selector", ::xs::selector_leaf());
        aka::doctype("xs:sequence", ::xs::explicitGroup_leaf());
        aka::doctype("xs:simpleContent", ::xs::simpleContent_leaf());
        aka::doctype("xs:simpleType", ::xs::topLevelSimpleType_leaf());
        aka::doctype("xs:totalDigits", ::xs::totalDigits_leaf());
        aka::doctype("xs:union", ::xs::_union_leaf());
        aka::doctype("xs:unique", ::xs::keybase_leaf());
        aka::doctype("xs:whiteSpace", ::xs::whiteSpace_leaf());
      }

    }

    void serialize(const ::xs::all& root, std::ostream &ostm) {
      aka::xml_serializer ser;
      ser.serialize(root, "xs:all", ostm);
    }

    void serialize(const ::xs::annotation& root, std::ostream &ostm) {
      aka::xml_serializer ser;
      ser.serialize(root, "xs:annotation", ostm);
    }

    void serialize(const ::xs::any& root, std::ostream &ostm) {
      aka::xml_serializer ser;
      ser.serialize(root, "xs:any", ostm);
    }

    void serialize(const ::xs::appinfo& root, std::ostream &ostm) {
      aka::xml_serializer ser;
      ser.serialize(root, "xs:appinfo", ostm);
    }

    void serialize(const ::xs::complexContent& root, std::ostream &ostm) {
      aka::xml_serializer ser;
      ser.serialize(root, "xs:complexContent", ostm);
    }

    void serialize(const ::xs::documentation& root, std::ostream &ostm) {
      aka::xml_serializer ser;
      ser.serialize(root, "xs:documentation", ostm);
    }

    void serialize(const ::xs::explicitGroup& root, const std::string &tagname, std::ostream &ostm) {
      aka::xml_serializer ser;
      ser.serialize(root, tagname, ostm);
    }

    void serialize(const ::xs::facet& root, const std::string &tagname, std::ostream &ostm) {
      aka::xml_serializer ser;
      ser.serialize(root, tagname, ostm);
    }

    void serialize(const ::xs::field& root, std::ostream &ostm) {
      aka::xml_serializer ser;
      ser.serialize(root, "xs:field", ostm);
    }

    void serialize(const ::xs::import& root, std::ostream &ostm) {
      aka::xml_serializer ser;
      ser.serialize(root, "xs:import", ostm);
    }

    void serialize(const ::xs::include& root, std::ostream &ostm) {
      aka::xml_serializer ser;
      ser.serialize(root, "xs:include", ostm);
    }

    void serialize(const ::xs::keybase& root, const std::string &tagname, std::ostream &ostm) {
      aka::xml_serializer ser;
      ser.serialize(root, tagname, ostm);
    }

    void serialize(const ::xs::keyref& root, std::ostream &ostm) {
      aka::xml_serializer ser;
      ser.serialize(root, "xs:keyref", ostm);
    }

    void serialize(const ::xs::list& root, std::ostream &ostm) {
      aka::xml_serializer ser;
      ser.serialize(root, "xs:list", ostm);
    }

    void serialize(const ::xs::namedAttributeGroup& root, std::ostream &ostm) {
      aka::xml_serializer ser;
      ser.serialize(root, "xs:attributeGroup", ostm);
    }

    void serialize(const ::xs::namedGroup& root, std::ostream &ostm) {
      aka::xml_serializer ser;
      ser.serialize(root, "xs:group", ostm);
    }

    void serialize(const ::xs::noFixedFacet& root, std::ostream &ostm) {
      aka::xml_serializer ser;
      ser.serialize(root, "xs:enumeration", ostm);
    }

    void serialize(const ::xs::notation& root, std::ostream &ostm) {
      aka::xml_serializer ser;
      ser.serialize(root, "xs:notation", ostm);
    }

    void serialize(const ::xs::numFacet& root, const std::string &tagname, std::ostream &ostm) {
      aka::xml_serializer ser;
      ser.serialize(root, tagname, ostm);
    }

    void serialize(const ::xs::pattern& root, std::ostream &ostm) {
      aka::xml_serializer ser;
      ser.serialize(root, "xs:pattern", ostm);
    }

    void serialize(const ::xs::redefine& root, std::ostream &ostm) {
      aka::xml_serializer ser;
      ser.serialize(root, "xs:redefine", ostm);
    }

    void serialize(const ::xs::restriction& root, std::ostream &ostm) {
      aka::xml_serializer ser;
      ser.serialize(root, "xs:restriction", ostm);
    }

    void serialize(const ::xs::schema& root, std::ostream &ostm) {
      aka::xml_serializer ser;
      ser.serialize(root, "xs:schema", ostm);
    }

    void serialize(const ::xs::selector& root, std::ostream &ostm) {
      aka::xml_serializer ser;
      ser.serialize(root, "xs:selector", ostm);
    }

    void serialize(const ::xs::simpleContent& root, std::ostream &ostm) {
      aka::xml_serializer ser;
      ser.serialize(root, "xs:simpleContent", ostm);
    }

    void serialize(const ::xs::topLevelAttribute& root, std::ostream &ostm) {
      aka::xml_serializer ser;
      ser.serialize(root, "xs:attribute", ostm);
    }

    void serialize(const ::xs::topLevelComplexType& root, std::ostream &ostm) {
      aka::xml_serializer ser;
      ser.serialize(root, "xs:complexType", ostm);
    }

    void serialize(const ::xs::topLevelElement& root, std::ostream &ostm) {
      aka::xml_serializer ser;
      ser.serialize(root, "xs:element", ostm);
    }

    void serialize(const ::xs::topLevelSimpleType& root, std::ostream &ostm) {
      aka::xml_serializer ser;
      ser.serialize(root, "xs:simpleType", ostm);
    }

    void serialize(const ::xs::totalDigits& root, std::ostream &ostm) {
      aka::xml_serializer ser;
      ser.serialize(root, "xs:totalDigits", ostm);
    }

    void serialize(const ::xs::_union& root, std::ostream &ostm) {
      aka::xml_serializer ser;
      ser.serialize(root, "xs:union", ostm);
    }

    void serialize(const ::xs::whiteSpace& root, std::ostream &ostm) {
      aka::xml_serializer ser;
      ser.serialize(root, "xs:whiteSpace", ostm);
    }

    void serialize(const ::xs::wildcard& root, std::ostream &ostm) {
      aka::xml_serializer ser;
      ser.serialize(root, "xs:anyAttribute", ostm);
    }