    /* -*- c++ -*- */
    #ifndef xiso_h__
    #define xiso_h__

    #include "element.h"
    #include <akaxiso/content_model.h>

    namespace xml {

      typedef xiso::leaf< ::xs::NCName> space_leaf;

    }
    namespace xs {

      typedef xiso::leaf< ::std::string> allNNI_leaf;
      typedef xiso::leaf< ::std::string> blockSet_leaf;
      typedef xiso::leaf< ::xs::NMTOKEN> derivationControl_leaf;
      typedef xiso::leaf< ::std::string> derivationSet_leaf;
      typedef xiso::leaf< ::xs::NMTOKEN> formChoice_leaf;
      typedef xiso::leaf< ::std::string> fullDerivationSet_leaf;
      typedef xiso::leaf< ::std::string> namespaceList_leaf;
      typedef xiso::leaf< ::xs::token> _public_leaf;
      typedef xiso::leaf< ::xs::derivationControl> reducedDerivationControl_leaf;
      typedef xiso::leaf< ::std::string> simpleDerivationSet_leaf;
      typedef xiso::leaf< ::xs::derivationControl> typeDerivationControl_leaf;
      struct appinfo_sequence_leaf : aka::sequence< ::xs::appinfo_sequence, appinfo_sequence_leaf> {
        void model();
      };

      struct appinfo_sequence;
      typedef aka::sequential_array< ::xs::appinfo_sequence_holder, ::xs::appinfo_sequence_leaf> appinfo_sequence_holder_leaf;

      struct appinfo_leaf : aka::sequence< ::xs::appinfo, appinfo_leaf> {
        void model();
      };

      struct documentation_sequence_leaf : aka::sequence< ::xs::documentation_sequence, documentation_sequence_leaf> {
        void model();
      };

      struct documentation_sequence;
      typedef aka::sequential_array< ::xs::documentation_sequence_holder, ::xs::documentation_sequence_leaf> documentation_sequence_holder_leaf;

      struct documentation_leaf : aka::sequence< ::xs::documentation, documentation_leaf> {
        void model();
      };

      struct annotation_choice_leaf : aka::sequential_choice< ::xs::annotation_choice, annotation_choice_leaf> {
        void model();
      };

      struct annotation_leaf : aka::sequence< ::xs::annotation, annotation_leaf> {
        void model();
      };

      struct annotated_sequence_leaf : aka::sequence< ::xs::annotated_sequence, annotated_sequence_leaf> {
        void model();
      };

      struct allModel_c0_leaf : aka::sequential_choice< ::xs::allModel_c0, allModel_c0_leaf> {
        void model();
      };

      struct allModel_leaf : aka::sequence< ::xs::allModel, allModel_leaf> {
        void model();
      };

      struct all_leaf : aka::sequence< ::xs::all, all_leaf> {
        void model();
      };

      struct annotated_leaf : aka::sequence< ::xs::annotated, annotated_leaf> {
        void model();
      };

      typedef xiso::leaf< ::xs::NMTOKEN> wildcard_processContents_leaf;
      struct any_leaf : aka::sequence< ::xs::any, any_leaf> {
        void model();
      };

      struct anyType_leaf : aka::sequence< ::xs::anyType, anyType_leaf> {
        void model();
      };

      struct attrDecls_c0_leaf : aka::sequential_choice< ::xs::attrDecls_c0, attrDecls_c0_leaf> {
        void model();
      };

      struct wildcard_leaf : aka::sequence< ::xs::wildcard, wildcard_leaf> {
        void model();
      };

      struct attrDecls_leaf : aka::sequence< ::xs::attrDecls, attrDecls_leaf> {
        void model();
      };

      struct simpleDerivation_leaf : aka::sequential_choice< ::xs::simpleDerivation, simpleDerivation_leaf> {
        void model();
      };

      struct localSimpleType_leaf : aka::sequence< ::xs::localSimpleType, localSimpleType_leaf> {
        void model();
      };

      struct attribute_sequence_leaf : aka::sequence< ::xs::attribute_sequence, attribute_sequence_leaf> {
        void model();
      };

      typedef xiso::leaf< ::xs::NMTOKEN> attribute_use_leaf;
      struct attribute_leaf : aka::sequence< ::xs::attribute, attribute_leaf> {
        void model();
      };

      struct attributeGroup_leaf : aka::sequence< ::xs::attributeGroup, attributeGroup_leaf> {
        void model();
      };

      struct attributeGroupRef_leaf : aka::sequence< ::xs::attributeGroupRef, attributeGroupRef_leaf> {
        void model();
      };

      struct groupRef_leaf : aka::sequence< ::xs::groupRef, groupRef_leaf> {
        void model();
      };

      struct facet_leaf : aka::sequence< ::xs::facet, facet_leaf> {
        void model();
      };

      struct totalDigits_leaf : aka::sequence< ::xs::totalDigits, totalDigits_leaf> {
        void model();
      };

      struct numFacet_leaf : aka::sequence< ::xs::numFacet, numFacet_leaf> {
        void model();
      };

      struct noFixedFacet_leaf : aka::sequence< ::xs::noFixedFacet, noFixedFacet_leaf> {
        void model();
      };

      struct whiteSpace_leaf : aka::sequence< ::xs::whiteSpace, whiteSpace_leaf> {
        void model();
      };

      struct pattern_leaf : aka::sequence< ::xs::pattern, pattern_leaf> {
        void model();
      };

      struct facets_leaf : aka::sequential_choice< ::xs::facets, facets_leaf> {
        void model();
      };

      struct simpleRestrictionModel_leaf : aka::sequence< ::xs::simpleRestrictionModel, simpleRestrictionModel_leaf> {
        void model();
      };

      struct simpleRestrictionType_sequence_c0_leaf : aka::sequential_choice< ::xs::simpleRestrictionType_sequence_c0, simpleRestrictionType_sequence_c0_leaf> {
        void model();
      };

      struct simpleRestrictionType_leaf : aka::sequence< ::xs::simpleRestrictionType, simpleRestrictionType_leaf> {
        void model();
      };

      struct simpleExtensionType_leaf : aka::sequence< ::xs::simpleExtensionType, simpleExtensionType_leaf> {
        void model();
      };

      struct simpleContent_choice_leaf : aka::sequential_choice< ::xs::simpleContent_choice, simpleContent_choice_leaf> {
        void model();
      };

      struct simpleContent_leaf : aka::sequence< ::xs::simpleContent, simpleContent_leaf> {
        void model();
      };

      struct complexContent_choice_leaf : aka::sequential_choice< ::xs::complexContent_choice, complexContent_choice_leaf> {
        void model();
      };

      struct complexContent_leaf : aka::sequence< ::xs::complexContent, complexContent_leaf> {
        void model();
      };

      struct complexRestrictionType_sequence_c0_leaf : aka::sequential_choice< ::xs::complexRestrictionType_sequence_c0, complexRestrictionType_sequence_c0_leaf> {
        void model();
      };

      struct complexRestrictionType_leaf : aka::sequence< ::xs::complexRestrictionType, complexRestrictionType_leaf> {
        void model();
      };

      struct complexTypeModel_leaf : aka::sequential_choice< ::xs::complexTypeModel, complexTypeModel_leaf> {
        void model();
      };

      struct complexType_leaf : aka::sequence< ::xs::complexType, complexType_leaf> {
        void model();
      };

      struct localComplexType_leaf : aka::sequence< ::xs::localComplexType, localComplexType_leaf> {
        void model();
      };

      struct localElement_sequence_c0_leaf : aka::sequential_choice< ::xs::localElement_sequence_c0, localElement_sequence_c0_leaf> {
        void model();
      };

      typedef xiso::leaf< ::xs::token> selector_xpath_leaf;
      struct selector_leaf : aka::sequence< ::xs::selector, selector_leaf> {
        void model();
      };

      typedef xiso::leaf< ::xs::token> field_xpath_leaf;
      struct field_leaf : aka::sequence< ::xs::field, field_leaf> {
        void model();
      };

      struct field;
      typedef aka::sequential_array< ::xs::field_array, ::xs::field_leaf> field_array_leaf;

      struct keybase_sequence_leaf : aka::sequence< ::xs::keybase_sequence, keybase_sequence_leaf> {
        void model();
      };

      struct keybase_leaf : aka::sequence< ::xs::keybase, keybase_leaf> {
        void model();
      };

      struct keyref_leaf : aka::sequence< ::xs::keyref, keyref_leaf> {
        void model();
      };

      struct identityConstraint_leaf : aka::sequential_choice< ::xs::identityConstraint, identityConstraint_leaf> {
        void model();
      };

      struct localElement_leaf : aka::sequence< ::xs::localElement, localElement_leaf> {
        void model();
      };

      struct typeDefParticle_leaf : aka::sequential_choice< ::xs::typeDefParticle, typeDefParticle_leaf> {
        void model();
      };

      struct complexTypeModel_s0_leaf : aka::sequence< ::xs::complexTypeModel_s0, complexTypeModel_s0_leaf> {
        void model();
      };

      struct element_sequence_c0_leaf : aka::sequential_choice< ::xs::element_sequence_c0, element_sequence_c0_leaf> {
        void model();
      };

      struct element_sequence_leaf : aka::sequence< ::xs::element_sequence, element_sequence_leaf> {
        void model();
      };

      struct element_leaf : aka::sequence< ::xs::element, element_leaf> {
        void model();
      };

      struct nestedParticle_leaf : aka::sequential_choice< ::xs::nestedParticle, nestedParticle_leaf> {
        void model();
      };

      struct explicitGroup_leaf : aka::sequence< ::xs::explicitGroup, explicitGroup_leaf> {
        void model();
      };

      struct extensionType_sequence_leaf : aka::sequence< ::xs::extensionType_sequence, extensionType_sequence_leaf> {
        void model();
      };

      struct extensionType_leaf : aka::sequence< ::xs::extensionType, extensionType_leaf> {
        void model();
      };

      struct particle_leaf : aka::sequential_choice< ::xs::particle, particle_leaf> {
        void model();
      };

      struct group_leaf : aka::sequence< ::xs::group, group_leaf> {
        void model();
      };

      struct import_leaf : aka::sequence< ::xs::import, import_leaf> {
        void model();
      };

      struct include_leaf : aka::sequence< ::xs::include, include_leaf> {
        void model();
      };

      struct list_sequence_leaf : aka::sequence< ::xs::list_sequence, list_sequence_leaf> {
        void model();
      };

      struct list_leaf : aka::sequence< ::xs::list, list_leaf> {
        void model();
      };

      struct namedAttributeGroup_leaf : aka::sequence< ::xs::namedAttributeGroup, namedAttributeGroup_leaf> {
        void model();
      };

      struct namedGroup_sequence_c0_all_leaf : aka::sequence< ::xs::namedGroup_sequence_c0_all, namedGroup_sequence_c0_all_leaf> {
        void model();
      };

      struct simpleExplicitGroup_leaf : aka::sequence< ::xs::simpleExplicitGroup, simpleExplicitGroup_leaf> {
        void model();
      };

      struct namedGroup_sequence_c0_leaf : aka::sequential_choice< ::xs::namedGroup_sequence_c0, namedGroup_sequence_c0_leaf> {
        void model();
      };

      struct namedGroup_leaf : aka::sequence< ::xs::namedGroup, namedGroup_leaf> {
        void model();
      };

      struct narrowMaxMin_sequence_c0_leaf : aka::sequential_choice< ::xs::narrowMaxMin_sequence_c0, narrowMaxMin_sequence_c0_leaf> {
        void model();
      };

      struct narrowMaxMin_leaf : aka::sequence< ::xs::narrowMaxMin, narrowMaxMin_leaf> {
        void model();
      };

      struct notation_leaf : aka::sequence< ::xs::notation, notation_leaf> {
        void model();
      };

      struct openAttrs_leaf : aka::sequence< ::xs::openAttrs, openAttrs_leaf> {
        void model();
      };

      struct realGroup_sequence_c0_leaf : aka::sequential_choice< ::xs::realGroup_sequence_c0, realGroup_sequence_c0_leaf> {
        void model();
      };

      struct realGroup_leaf : aka::sequence< ::xs::realGroup, realGroup_leaf> {
        void model();
      };

      struct topLevelSimpleType_leaf : aka::sequence< ::xs::topLevelSimpleType, topLevelSimpleType_leaf> {
        void model();
      };

      struct topLevelComplexType_leaf : aka::sequence< ::xs::topLevelComplexType, topLevelComplexType_leaf> {
        void model();
      };

      struct redefinable_leaf : aka::sequential_choice< ::xs::redefinable, redefinable_leaf> {
        void model();
      };

      struct redefine_choice_leaf : aka::sequential_choice< ::xs::redefine_choice, redefine_choice_leaf> {
        void model();
      };

      struct redefine_leaf : aka::sequence< ::xs::redefine, redefine_leaf> {
        void model();
      };

      struct restriction_leaf : aka::sequence< ::xs::restriction, restriction_leaf> {
        void model();
      };

      struct restrictionType_sequence_c0_leaf : aka::sequential_choice< ::xs::restrictionType_sequence_c0, restrictionType_sequence_c0_leaf> {
        void model();
      };

      struct restrictionType_sequence_leaf : aka::sequence< ::xs::restrictionType_sequence, restrictionType_sequence_leaf> {
        void model();
      };

      struct restrictionType_leaf : aka::sequence< ::xs::restrictionType, restrictionType_leaf> {
        void model();
      };

      struct schema_sequence_c0_leaf : aka::sequential_choice< ::xs::schema_sequence_c0, schema_sequence_c0_leaf> {
        void model();
      };

      struct topLevelElement_sequence_c0_leaf : aka::sequential_choice< ::xs::topLevelElement_sequence_c0, topLevelElement_sequence_c0_leaf> {
        void model();
      };

      struct topLevelElement_leaf : aka::sequence< ::xs::topLevelElement, topLevelElement_leaf> {
        void model();
      };

      struct topLevelAttribute_leaf : aka::sequence< ::xs::topLevelAttribute, topLevelAttribute_leaf> {
        void model();
      };

      struct schemaTop_leaf : aka::sequential_choice< ::xs::schemaTop, schemaTop_leaf> {
        void model();
      };

      struct annotation;
      typedef aka::sequential_array< ::xs::annotation_array, ::xs::annotation_leaf> annotation_array_leaf;

      struct schema_sequence_s0_leaf : aka::sequence< ::xs::schema_sequence_s0, schema_sequence_s0_leaf> {
        void model();
      };

      struct schema_sequence_s0;
      typedef aka::sequential_array< ::xs::schema_sequence_s0_holder, ::xs::schema_sequence_s0_leaf> schema_sequence_s0_holder_leaf;

      struct schema_leaf : aka::sequence< ::xs::schema, schema_leaf> {
        void model();
      };

      struct simpleType_leaf : aka::sequence< ::xs::simpleType, simpleType_leaf> {
        void model();
      };

      struct localSimpleType;
      typedef aka::sequential_array< ::xs::localSimpleType_array, ::xs::localSimpleType_leaf> localSimpleType_array_leaf;

      struct union_sequence_leaf : aka::sequence< ::xs::union_sequence, union_sequence_leaf> {
        void model();
      };

      typedef xiso::leaf< ::std::string> union_memberTypes_leaf;
      struct _union_leaf : aka::sequence< ::xs::_union, _union_leaf> {
        void model();
      };

    }
    #endif // #ifndef xiso_h__