mod UNQUAL {
    struct restrictionType__extension__restrictionType__extension__anonymous0__item0 {
        openContent: super::UNQUAL::openContent,
        restrictionType__extension__restrictionType__extension__anonymous0__item0__anonymous1: super::UNQUAL::typeDefParticle,
    }

    enum restrictionType__extension__restrictionType__extension__anonymous0 {
        item0(Box<restrictionType__extension__restrictionType__extension__anonymous0__item0>),
        item1(Box<super::UNQUAL::simpleRestrictionModel>),
    }

    struct restrictionType__extension {
        restrictionType__extension__anonymous0: restrictionType__extension__restrictionType__extension__anonymous0,
        restrictionType__extension__anonymous1: super::UNQUAL::attrDecls,
        restrictionType__extension__anonymous2: super::UNQUAL::assertions,
    }

    struct restrictionType {
        base: super::UNQUAL::annotated,
        extension: restrictionType__extension,
    }

    struct attributeGroup {
        base: super::UNQUAL::annotated,
        extension: super::UNQUAL::attrDecls,
    }

    struct localSimpleType(super::UNQUAL::simpleType);

    struct attribute__extension__simpleType(super::UNQUAL::localSimpleType);

    struct attribute__extension {
        simpleType: attribute__extension__simpleType,
    }

    struct attribute {
        base: super::UNQUAL::annotated,
        extension: attribute__extension,
    }

    struct topLevelAttribute(super::UNQUAL::attribute);

    struct simpleRestrictionType(super::UNQUAL::restrictionType);

    struct keybase__extension {
        selector: super::UNQUAL::selector,
        field: super::UNQUAL::field,
    }

    struct keybase {
        base: super::UNQUAL::annotated,
        extension: keybase__extension,
    }

    struct public(super::UNQUAL::token);

    struct anyType {
        anyType__anonymous0: Vec<u8>,
    }

    struct group {
        base: super::UNQUAL::annotated,
        extension: super::UNQUAL::particle,
    }

    struct namespaceList {
        member0: super::UNQUAL::specialNamespaceList,
        member1: super::UNQUAL::basicNamespaceList,
    }

    struct numFacet(super::UNQUAL::facet);

    struct basicNamespaceList__valuetype__item0(super::UNQUAL::token);

    struct basicNamespaceList__valuetype {
        member0: super::UNQUAL::anyURI,
        item0: basicNamespaceList__valuetype__item0,
    }

    struct basicNamespaceList(Vec<basicNamespaceList__valuetype>);

    struct topLevelComplexType(super::UNQUAL::complexType);

    struct complexRestrictionType(super::UNQUAL::restrictionType);

    struct qnameListA__valuetype__item0(super::UNQUAL::token);

    struct qnameListA__valuetype {
        member0: super::UNQUAL::QName,
        item0: qnameListA__valuetype__item0,
    }

    struct qnameListA(Vec<qnameListA__valuetype>);

    struct allNNI__item0(super::UNQUAL::NMTOKEN);

    struct allNNI {
        member0: super::UNQUAL::nonNegativeInteger,
        item0: allNNI__item0,
    }

    struct simpleExtensionType(super::UNQUAL::extensionType);

    struct simpleDerivationSet__item0(super::UNQUAL::token);

    struct simpleDerivationSet__item1__valuetype(super::UNQUAL::derivationControl);

    struct simpleDerivationSet__item1(Vec<simpleDerivationSet__item1__valuetype>);

    struct simpleDerivationSet {
        item0: simpleDerivationSet__item0,
        item1: simpleDerivationSet__item1,
    }

    struct derivationControl(super::UNQUAL::NMTOKEN);

    struct openAttrs(super::UNQUAL::anyType);

    struct typeDerivationControl(super::UNQUAL::derivationControl);

    struct blockSet__item0(super::UNQUAL::token);

    struct blockSet__item1__valuetype(super::UNQUAL::derivationControl);

    struct blockSet__item1(Vec<blockSet__item1__valuetype>);

    struct blockSet {
        item0: blockSet__item0,
        item1: blockSet__item1,
    }

    struct qnameList__valuetype__item0(super::UNQUAL::token);

    struct qnameList__valuetype {
        member0: super::UNQUAL::QName,
        item0: qnameList__valuetype__item0,
    }

    struct qnameList(Vec<qnameList__valuetype>);

    struct altType__extension__item0(super::UNQUAL::localSimpleType);

    struct altType__extension__item1(super::UNQUAL::localComplexType);

    enum altType__extension {
        item0(Box<altType__extension__item0>),
        item1(Box<altType__extension__item1>),
    }

    struct altType {
        base: super::UNQUAL::annotated,
        extension: altType__extension,
    }

    struct simpleExplicitGroup(super::UNQUAL::explicitGroup);

    struct formChoice(super::UNQUAL::NMTOKEN);

    struct simpleType {
        base: super::UNQUAL::annotated,
        extension: super::UNQUAL::simpleDerivation,
    }

    struct namedAttributeGroup(super::UNQUAL::attributeGroup);

    struct topLevelElement(super::UNQUAL::element);

    struct facet {
        base: super::UNQUAL::annotated,
    }

    struct annotated__extension {
        annotation: super::UNQUAL::annotation,
    }

    struct annotated {
        base: super::UNQUAL::openAttrs,
        extension: annotated__extension,
    }

    struct assertion {
        base: super::UNQUAL::annotated,
    }

    struct topLevelSimpleType(super::UNQUAL::simpleType);

    struct noFixedFacet(super::UNQUAL::facet);

    struct realGroup(super::UNQUAL::group);

    struct xpathDefaultNamespace__item0(super::UNQUAL::token);

    struct xpathDefaultNamespace {
        member0: super::UNQUAL::anyURI,
        item0: xpathDefaultNamespace__item0,
    }

    struct namedGroup(super::UNQUAL::realGroup);

    struct all(super::UNQUAL::explicitGroup);

    struct specialNamespaceList(super::UNQUAL::token);

    struct derivationSet__item0(super::UNQUAL::token);

    struct derivationSet__item1(Vec<super::UNQUAL::reducedDerivationControl>);

    struct derivationSet {
        item0: derivationSet__item0,
        item1: derivationSet__item1,
    }

    struct localElement(super::UNQUAL::element);

    struct wildcard {
        base: super::UNQUAL::annotated,
    }

    struct attributeGroupRef(super::UNQUAL::attributeGroup);

    struct intFacet(super::UNQUAL::facet);

    struct element__extension__element__extension__anonymous0__item0(super::UNQUAL::localSimpleType);

    struct element__extension__element__extension__anonymous0__item1(super::UNQUAL::localComplexType);

    enum element__extension__element__extension__anonymous0 {
        item0(Box<element__extension__element__extension__anonymous0__item0>),
        item1(Box<element__extension__element__extension__anonymous0__item1>),
    }

    struct element__extension__alternative(super::UNQUAL::altType);

    struct element__extension {
        element__extension__anonymous0: element__extension__element__extension__anonymous0,
        alternative: element__extension__alternative,
        element__extension__anonymous2: super::UNQUAL::identityConstraint,
    }

    struct element {
        base: super::UNQUAL::annotated,
        extension: element__extension,
    }

    struct groupRef(super::UNQUAL::realGroup);

    struct reducedDerivationControl(super::UNQUAL::derivationControl);

    struct fullDerivationSet__item0(super::UNQUAL::token);

    struct fullDerivationSet__item1(Vec<super::UNQUAL::typeDerivationControl>);

    struct fullDerivationSet {
        item0: fullDerivationSet__item0,
        item1: fullDerivationSet__item1,
    }

    struct explicitGroup(super::UNQUAL::group);

    struct localComplexType(super::UNQUAL::complexType);

    struct extensionType__extension {
        openContent: super::UNQUAL::openContent,
        extensionType__extension__anonymous1: super::UNQUAL::typeDefParticle,
        extensionType__extension__anonymous2: super::UNQUAL::attrDecls,
        extensionType__extension__anonymous3: super::UNQUAL::assertions,
    }

    struct extensionType {
        base: super::UNQUAL::annotated,
        extension: extensionType__extension,
    }

    struct complexType {
        base: super::UNQUAL::annotated,
        extension: super::UNQUAL::complexTypeModel,
    }

    struct simpleRestrictionModel__simpleType(super::UNQUAL::localSimpleType);

    enum simpleRestrictionModel__simpleRestrictionModel__anonymous1 {
        item0(Box<super::UNQUAL::facet>),
        item1(Box<Vec<u8>>),
    }

    struct simpleRestrictionModel {
        simpleType: simpleRestrictionModel__simpleType,
        simpleRestrictionModel__anonymous1: simpleRestrictionModel__simpleRestrictionModel__anonymous1,
    }

    struct typeDefParticle__item0(super::UNQUAL::groupRef);

    enum typeDefParticle {
        item0(Box<typeDefParticle__item0>),
        item1(Box<super::UNQUAL::all>),
        item2(Box<super::UNQUAL::choice>),
        item3(Box<super::UNQUAL::sequence>),
    }

    struct nestedParticle__item0(super::UNQUAL::localElement);

    struct nestedParticle__item1(super::UNQUAL::groupRef);

    enum nestedParticle {
        item0(Box<nestedParticle__item0>),
        item1(Box<nestedParticle__item1>),
        item2(Box<super::UNQUAL::choice>),
        item3(Box<super::UNQUAL::sequence>),
        item4(Box<super::UNQUAL::any>),
    }

    enum identityConstraint {
        item0(Box<super::UNQUAL::unique>),
        item1(Box<super::UNQUAL::key>),
        item2(Box<super::UNQUAL::keyref>),
    }

    enum redefinable {
        item0(Box<super::UNQUAL::simpleType>),
        item1(Box<super::UNQUAL::complexType>),
        item2(Box<super::UNQUAL::group>),
        item3(Box<super::UNQUAL::attributeGroup>),
    }

    enum composition {
        item0(Box<super::UNQUAL::include>),
        item1(Box<super::UNQUAL::import>),
        item2(Box<super::UNQUAL::redefine>),
        item3(Box<super::UNQUAL::override_>),
        item4(Box<super::UNQUAL::annotation>),
    }

    struct attrDecls__attrDecls__anonymous0__item0(super::UNQUAL::attribute);

    struct attrDecls__attrDecls__anonymous0__item1(super::UNQUAL::attributeGroupRef);

    enum attrDecls__attrDecls__anonymous0 {
        item0(Box<attrDecls__attrDecls__anonymous0__item0>),
        item1(Box<attrDecls__attrDecls__anonymous0__item1>),
    }

    struct attrDecls {
        attrDecls__anonymous0: attrDecls__attrDecls__anonymous0,
        anyAttribute: super::UNQUAL::anyAttribute,
    }

    struct anyAttrGroup;

    struct defRef;

    struct particle__item0(super::UNQUAL::localElement);

    struct particle__item1(super::UNQUAL::groupRef);

    enum particle {
        item0(Box<particle__item0>),
        item1(Box<particle__item1>),
        item2(Box<super::UNQUAL::all>),
        item3(Box<super::UNQUAL::choice>),
        item4(Box<super::UNQUAL::sequence>),
        item5(Box<super::UNQUAL::any>),
    }

    struct allModel__allModel__anonymous1__item0(super::UNQUAL::localElement);

    struct allModel__allModel__anonymous1__item2(super::UNQUAL::groupRef);

    enum allModel__allModel__anonymous1 {
        item0(Box<allModel__allModel__anonymous1__item0>),
        item1(Box<super::UNQUAL::any>),
        item2(Box<allModel__allModel__anonymous1__item2>),
    }

    struct allModel {
        annotation: super::UNQUAL::annotation,
        allModel__anonymous1: allModel__allModel__anonymous1,
    }

    enum schemaTop {
        item0(Box<super::UNQUAL::redefinable>),
        item1(Box<super::UNQUAL::element>),
        item2(Box<super::UNQUAL::attribute>),
        item3(Box<super::UNQUAL::notation>),
    }

    struct complexTypeModel__item2 {
        openContent: super::UNQUAL::openContent,
        complexTypeModel__item2__anonymous1: super::UNQUAL::typeDefParticle,
        complexTypeModel__item2__anonymous2: super::UNQUAL::attrDecls,
        complexTypeModel__item2__anonymous3: super::UNQUAL::assertions,
    }

    enum complexTypeModel {
        item0(Box<super::UNQUAL::simpleContent>),
        item1(Box<super::UNQUAL::complexContent>),
        item2(Box<complexTypeModel__item2>),
    }

    struct occurs;

    enum simpleDerivation {
        item0(Box<super::UNQUAL::restriction>),
        item1(Box<super::UNQUAL::list>),
        item2(Box<super::UNQUAL::union>),
    }

    struct assertions__assert(super::UNQUAL::assertion);

    struct assertions {
        assert: assertions__assert,
    }
}