/* -*- 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__