<?xml version="1.0" encoding="UTF-8"?>

<!-- This file contains the XML Schema Document (XSD) for the XML Types
     Representation defined by the OMG specification "DDS Consolidated XML
     Syntax" (DDS-XML). -->

<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema"
           elementFormDefault="qualified"
           attributeFormDefault="unqualified">

    <!-- ================================================================== -->
    <!-- Identifiers -->
    <!-- ================================================================== -->

    <xs:simpleType name="identifierName">
        <xs:restriction base="xs:string">
            <xs:pattern value="([a-zA-Z_])([a-zA-Z_0-9])*"/>
        </xs:restriction>
    </xs:simpleType>

    <xs:simpleType name="quotedIdentifierName">
        <xs:restriction base="xs:string">
            <xs:pattern value="&quot;([a-zA-Z_])([a-zA-Z_0-9])*&quot;"/>
        </xs:restriction>
    </xs:simpleType>

    <xs:simpleType name="identifierNameRef">
        <xs:restriction base="xs:string">
            <xs:pattern value="(::)?[a-zA-Z_][a-zA-Z_0-9]*(::[a-zA-Z_][a-zA-Z_0-9]*)*"/>
        </xs:restriction>
    </xs:simpleType>

    <!-- <xs:pattern value="([a-zA-Z_]|::)([a-zA-Z_0-9]|::)*"/> -->

    <xs:simpleType name="emptyIdentifier">
        <xs:restriction base="xs:string">
            <xs:pattern value=""/>
        </xs:restriction>
    </xs:simpleType>

    <xs:simpleType name="integerOrIdentifierNameRef">
        <xs:union memberTypes="xs:int identifierNameRef"/>
    </xs:simpleType>

    <xs:simpleType name="floatOrIdentifierNameRef">
        <xs:union memberTypes="xs:float identifierNameRef"/>
    </xs:simpleType>

    <xs:simpleType name="integer1to32">
        <xs:restriction base="xs:unsignedShort">
            <xs:minInclusive value="1"/>
            <xs:maxInclusive value="32"/>
        </xs:restriction>
    </xs:simpleType>

    <xs:simpleType name="integer1to32_or_IdentifierNameRef">
        <xs:union memberTypes="integer1to32 identifierNameRef"/>
    </xs:simpleType>

    <xs:simpleType name="integer1to64">
        <xs:restriction base="xs:unsignedShort">
            <xs:minInclusive value="1"/>
            <xs:maxInclusive value="64"/>
        </xs:restriction>
    </xs:simpleType>

    <xs:simpleType name="integer1to64_or_IdentifierNameRef">
        <xs:union memberTypes="integer1to64 identifierNameRef"/>
    </xs:simpleType>

    <xs:simpleType name="integer0to63">
        <xs:restriction base="xs:unsignedShort">
            <xs:minInclusive value="0"/>
            <xs:maxInclusive value="63"/>
        </xs:restriction>
    </xs:simpleType>    

    <xs:simpleType name="integer0to63_or_IdentifierNameRef">
        <xs:union memberTypes="integer0to63 identifierNameRef"/>
    </xs:simpleType>

    <xs:simpleType name="integer0to0x0FFFFFFF">
        <xs:restriction base="xs:unsignedInt">
            <xs:minInclusive value="0"/>
            <xs:maxInclusive value="268435455"/> <!-- 0x0FFFFFFF -->
        </xs:restriction>
    </xs:simpleType>

    <xs:simpleType name="integer0to0x0FFFFFFF_or_IdentifierNameRef">
        <xs:union memberTypes="integer0to0x0FFFFFFF identifierNameRef"/>
    </xs:simpleType>
    
    <xs:simpleType name="commaSeparatedIntegerOrIdentifierRef">
        <xs:restriction base="xs:string">
            <xs:pattern value="(\s*(\d+|([a-zA-Z_]|::)([a-zA-Z_0-9]|::)*)\s*)(,\s*(\d+|([a-zA-Z_]|::)([a-zA-Z_0-9]|::)*)\s*)*"/>
        </xs:restriction>
    </xs:simpleType>  

    <xs:simpleType name="memberIdKind">
        <xs:restriction base="integer0to0x0FFFFFFF_or_IdentifierNameRef"/>
    </xs:simpleType>

    <xs:simpleType name="hashIdKind">
        <xs:union memberTypes="emptyIdentifier identifierName quotedIdentifierName identifierNameRef"/>
    </xs:simpleType>

    <xs:simpleType name="topicOrServiceName">
        <xs:restriction base="xs:string">
            <xs:pattern value="[a-zA-Z0-9/_\-\.]+( [A-Za-z0-9/_\.\-]+)*"/>
        </xs:restriction>
    </xs:simpleType>

    <xs:simpleType name="domainTagName">
        <xs:restriction base="xs:string">
            <xs:pattern value="[a-zA-Z0-9/\-_\.]+"/>
        </xs:restriction>
    </xs:simpleType>

    <!-- ================================================================== -->
    <!-- File Inclusion -->
    <!-- ================================================================== -->

    <xs:simpleType name="fileName">
        <xs:restriction base="xs:string">
        </xs:restriction>
    </xs:simpleType>

    <xs:complexType name="includeDecl">
        <xs:attribute name="file" type="fileName" use="required"/>
    </xs:complexType>

    <!-- ================================================================== -->
    <!-- Forward Declarations -->
    <!-- ================================================================== -->

    <xs:simpleType name="forwardDeclTypeKind">
        <xs:restriction base="xs:string">
            <xs:enumeration value="enum"/>
            <xs:enumeration value="bitmask"/>
            <xs:enumeration value="bitset"/>
            <xs:enumeration value="struct"/>
            <xs:enumeration value="union"/>
            <xs:enumeration value="exception"/>
            <xs:enumeration value="interface"/>
        </xs:restriction>
    </xs:simpleType>

    <xs:complexType name="forwardDecl">
        <xs:attribute name="name" type="identifierName" use="required"/>
        <xs:attribute name="kind" type="forwardDeclTypeKind" use="required"/>
    </xs:complexType>

    <!-- ================================================================== -->
    <!-- Basic Types -->
    <!-- ================================================================== -->

    <xs:simpleType name="autoTypeGroup">
        <xs:restriction base="xs:string">
            <xs:enumeration value="auto"/>
        </xs:restriction>
    </xs:simpleType>

    <xs:simpleType name="nonBasicTypeGroup">
        <xs:restriction base="xs:string">
            <xs:enumeration value="nonBasic"/>
        </xs:restriction>
    </xs:simpleType>

    <xs:simpleType name="booleanTypeGroup">
        <xs:restriction base="xs:string">
            <xs:enumeration value="boolean"/>
        </xs:restriction>
    </xs:simpleType>

    <xs:simpleType name="stringTypeGroup">
        <xs:restriction base="xs:string">
            <xs:enumeration value="string"/>
            <xs:enumeration value="wstring"/>
        </xs:restriction>
    </xs:simpleType>

    <xs:simpleType name="floatTypeGroup">
        <xs:restriction base="xs:string">
            <xs:enumeration value="float32"/>
            <xs:enumeration value="float64"/>
            <xs:enumeration value="float128"/>
        </xs:restriction>
    </xs:simpleType>

    <!-- Primitive Discrete Types -->
    <xs:simpleType name="discreteTypeGroup">
        <xs:restriction base="xs:string">
            <xs:enumeration value="byte"/>
            <xs:enumeration value="char8"/>
            <xs:enumeration value="char16"/>
            <xs:enumeration value="int8"/>
            <xs:enumeration value="uint8"/>
            <xs:enumeration value="int16"/>
            <xs:enumeration value="uint16"/>
            <xs:enumeration value="int32"/>
            <xs:enumeration value="uint32"/>
            <xs:enumeration value="int64"/>
            <xs:enumeration value="uint64"/>
        </xs:restriction>
    </xs:simpleType>

    <xs:simpleType name="bitfieldTypeKind">
        <xs:union memberTypes="autoTypeGroup booleanTypeGroup discreteTypeGroup"/>
    </xs:simpleType>

    <xs:simpleType name="discriminatorTypeKind">
        <xs:union memberTypes="booleanTypeGroup discreteTypeGroup nonBasicTypeGroup"/>
    </xs:simpleType>
    
    <xs:simpleType name="mapKeyTypeKind">
        <xs:union memberTypes="discreteTypeGroup stringTypeGroup nonBasicTypeGroup"/>
    </xs:simpleType>

    <xs:simpleType name="allTypeKind">
        <xs:union memberTypes="booleanTypeGroup discreteTypeGroup floatTypeGroup stringTypeGroup nonBasicTypeGroup"/>
    </xs:simpleType>

    <!-- Define a union type that can be either a known string or an arbitrary string -->
    <xs:simpleType name="ServiceKind">
        <xs:union>
            <xs:simpleType>
                <xs:restriction base="xs:string">
                    <xs:enumeration value="DDS"/>
                    <xs:enumeration value="CORBA"/>
                    <xs:enumeration value="*"/>
                </xs:restriction>
            </xs:simpleType>
            <xs:simpleType>
                <xs:restriction base="xs:string"/>
            </xs:simpleType>
        </xs:union>
    </xs:simpleType>

    <!-- ================================================================== -->
    <!-- Common Member Attributes -->
    <!-- ================================================================== -->

    <xs:attributeGroup name="typenameAttributeGroup">
        <xs:attribute name="type" type="allTypeKind" use="required"/>
        <xs:attribute name="nonBasicTypeName" type="identifierNameRef"/>
    </xs:attributeGroup>

    <xs:attributeGroup name="collectionSizeAttributeGroup">
        <xs:attribute name="stringMaxLength" type="integerOrIdentifierNameRef"/>
        <xs:attribute name="sequenceMaxLength" type="integerOrIdentifierNameRef"/>
        <xs:attribute name="arrayDimensions" type="commaSeparatedIntegerOrIdentifierRef"/>                            
        <xs:attribute name="mapKeyType" type="mapKeyTypeKind"/>
        <xs:attribute name="mapKeyNonBasicTypeName" type="identifierName"/>
        <xs:attribute name="mapKeyStringMaxLength" type="integerOrIdentifierNameRef"/>
        <xs:attribute name="mapMaxLength" type="integerOrIdentifierNameRef"/>
    </xs:attributeGroup>

    <xs:attributeGroup name="rangeAttributeGroup">
        <xs:attribute name="min"  type="floatOrIdentifierNameRef"/>
        <xs:attribute name="max"  type="floatOrIdentifierNameRef"/>
    </xs:attributeGroup>

    <xs:attributeGroup name="rangeAndUnitsAttributeGroup">
        <xs:attributeGroup ref="rangeAttributeGroup"></xs:attributeGroup>
        <xs:attribute name="unit" type="xs:string"/>
    </xs:attributeGroup>

    <xs:attributeGroup name="defaultAndExternalAttributeGroup">
        <xs:attribute name="default" type="xs:string"/>
        <xs:attribute name="external" type="xs:boolean"
            default="true"/>
    </xs:attributeGroup>

    <xs:attributeGroup name="annotationElementAttributes">
        <xs:attributeGroup ref="typenameAttributeGroup"/>
        <xs:attribute name="default" type="xs:string"/>
    </xs:attributeGroup>    

    <xs:attributeGroup name="constantElementAttributes">
        <xs:attributeGroup ref="typenameAttributeGroup"/>

        <xs:attribute name="unit" type="xs:string"/>
        <xs:attribute name="value" type="xs:string" use="required"/>
    </xs:attributeGroup>

    <xs:attributeGroup name="exceptionElementAttributes">
        <xs:attributeGroup ref="typenameAttributeGroup"/>
        <xs:attributeGroup ref="collectionSizeAttributeGroup"/>
    </xs:attributeGroup>

    <xs:attributeGroup name="typedefElementAttributes">
        <xs:attributeGroup ref="typenameAttributeGroup"/>
        <xs:attributeGroup ref="collectionSizeAttributeGroup"/>
        <xs:attributeGroup ref="rangeAndUnitsAttributeGroup"/>
        <xs:attributeGroup ref="defaultAndExternalAttributeGroup"/>
    </xs:attributeGroup>

    <xs:attributeGroup name="commonMemberElementAttributes">
        <xs:attributeGroup ref="typedefElementAttributes"/>

        <xs:attribute name="optional" type="xs:boolean"  
            default="true"/>
        <xs:attribute name="id" type="memberIdKind"/>
        <xs:attribute name="hashid" type="hashIdKind"
            default="" />
        <xs:attribute name="tryConstruct" type="tryConstructKind"  
            default="use_default"/>
        <xs:attribute name="nonSerialized" type="xs:boolean"
            default="true"/>
    </xs:attributeGroup>

    <xs:attributeGroup name="unionDiscriminatorAttributes">
        <xs:attributeGroup ref="rangeAttributeGroup"/>
        <xs:attribute name="key" type="xs:boolean"
            default="false"/>
        <xs:attribute name="default" type="xs:string"/>
        <xs:attribute name="tryConstruct" type="tryConstructKind"  
            default="use_default"/>
    </xs:attributeGroup>

    <xs:attributeGroup name="unionMemberAttributes">
        <xs:attributeGroup ref="commonMemberElementAttributes"/>
    </xs:attributeGroup>

    <xs:attributeGroup name="structMemberAttributes">
        <xs:attributeGroup ref="commonMemberElementAttributes"/>
        <xs:attribute name="key" type="xs:boolean"
            default="true"/>
        <xs:attribute name="mustUnderstand" type="xs:boolean"
            default="false"/>
    </xs:attributeGroup>

    <xs:attributeGroup name="operationArgumentAttributes">
        <xs:attributeGroup ref="typenameAttributeGroup"/>
        <xs:attributeGroup ref="collectionSizeAttributeGroup"/>
        <xs:attributeGroup ref="rangeAndUnitsAttributeGroup"/>
        <xs:attributeGroup ref="defaultAndExternalAttributeGroup"/>

        <xs:attribute name="direction" type="operationArgumentDirectionKind" 
            default="in"/>
    </xs:attributeGroup>

    <xs:simpleType name="dataRepresentationMask">
        <xs:restriction base="xs:string">
            <xs:whiteSpace value="collapse"/>
            <xs:pattern value="(xcdr|xcdr2|xml)(\s*\|\s*(xcdr|xcdr2|xml))*"/>
        </xs:restriction>
    </xs:simpleType>

    <xs:attributeGroup name="commonTypeAttributes">
        <xs:attribute name="nested" type="xs:boolean" 
            default="false"/>
        <xs:attribute name="extensibility" type="extensibilityKind"
            default="append"/>
        <xs:attribute name="autoid" type="autoIdKind" 
            default="hash"/>
        <xs:attribute name="data_representation" type="dataRepresentationMask"/>
        <xs:attribute name="topic" type="topicOrServiceName"/>
    </xs:attributeGroup>

    <xs:attributeGroup name="unionTypeAttributes">
        <xs:attributeGroup ref="commonTypeAttributes"/>
    </xs:attributeGroup>

    <xs:attributeGroup name="structTypeAttributes">
        <xs:attributeGroup ref="commonTypeAttributes"/>
        <xs:attribute name="baseType" type="identifierName"/>
    </xs:attributeGroup>

    <xs:attributeGroup name="interfaceTypeAttributes">
        <xs:attribute name="extensibility" type="extensibilityKind"
            default="append"/>
        <xs:attribute name="baseType" type="identifierName"/>
        <xs:attribute name="service" type="ServiceKind"/>                
    </xs:attributeGroup>

    <xs:attributeGroup name="enumTypeAttributes">
        <xs:attribute name="extensibility" type="extensibilityKind"
            default="append"/>
        <xs:attribute name="bitBound" type="enumBitBound"
            default="32"/>
        <xs:attribute name="ignoreLiteralNames" type="xs:boolean"
            default="true"/>
    </xs:attributeGroup>
    
    <xs:attributeGroup name="bitmaskTypeAttributes">
        <xs:attribute name="extensibility" type="extensibilityKind"
            default="append"/>                
        <xs:attribute name="bitBound" type="bitmaskBitBound"
            default="32"/>
    </xs:attributeGroup>

    <!-- ================================================================== -->
    <!-- Type Declarations -->
    <!-- ================================================================== -->

    <xs:complexType name="commonTypeDecl">
        <xs:sequence minOccurs="0" maxOccurs="1">
            <xs:element name="annotations" type="typeAnnotationList"/>
        </xs:sequence>
        <xs:attribute name="name" type="identifierName" use="required"/>
        <xs:attribute name="license" type="licenseUseIdentifierRef"/>
    </xs:complexType>

    <xs:complexType name="commonMemberDecl">
        <xs:sequence>
            <xs:element name="annotations" type="memberAnnotationList" minOccurs="0" maxOccurs="1"/>
        </xs:sequence>
        <xs:attribute name="name" type="identifierName" use="required"/>
    </xs:complexType>

    <!-- ================================================================== -->
    <!-- Constants -->
    <!-- ================================================================== -->

    <xs:complexType name="constDecl">
        <xs:complexContent>
            <xs:extension base="commonTypeDecl">
                <xs:attributeGroup ref="constantElementAttributes"/>
            </xs:extension>
        </xs:complexContent>
    </xs:complexType>

    <!-- ================================================================== -->
    <!-- Aggregated Types (General) -->
    <!-- ================================================================== -->

    <xs:complexType name="annotationMemberDecl">
        <!-- do not extend commonMemberDecl as we don't want to allow
            annotations within  annotation parameters -->
        <xs:sequence>
            <xs:element name="doc" type="docDecl" minOccurs="0" maxOccurs="unbounded"/>
        </xs:sequence>
    
        <xs:attribute name="name" type="identifierName" use="required"/>
        <xs:attributeGroup ref="annotationElementAttributes"/>
    </xs:complexType>
    
    <xs:complexType name="exceptionMemberDecl">
        <xs:complexContent>
            <xs:extension base="commonMemberDecl">
                <xs:attributeGroup ref="exceptionElementAttributes"/>
            </xs:extension>
        </xs:complexContent>
    </xs:complexType>

    <xs:simpleType name="tryConstructKind">
        <xs:restriction base="xs:string">
            <xs:enumeration value="discard"/>
            <xs:enumeration value="use_default"/>
            <xs:enumeration value="trim"/>
        </xs:restriction>
    </xs:simpleType>

    <xs:complexType name="verbatimDecl">
        <xs:simpleContent>
            <xs:extension base="xs:string">
                <xs:attribute name="language"  type="xs:string"
                              default="*"/>
                <xs:attribute name="placement" type="xs:string" 
                              default="before-declaration"/>           
            </xs:extension>
        </xs:simpleContent>
    </xs:complexType>

    <xs:simpleType name="extensibilityKind">
        <xs:restriction base="xs:string">
            <xs:enumeration value="final"/>
            <xs:enumeration value="append"/>
            <xs:enumeration value="mutable"/>
        </xs:restriction>
    </xs:simpleType>

    <xs:simpleType name="autoIdKind">
        <xs:restriction base="xs:string">
            <xs:enumeration value="hash"/>
            <xs:enumeration value="sequential"/>
        </xs:restriction>
    </xs:simpleType>

    <xs:simpleType name="unionAutoIdSelection">
        <xs:restriction base="xs:string">
            <xs:enumeration value="all_unions"/>
            <xs:enumeration value="mutable_unions"/>
        </xs:restriction>
    </xs:simpleType>

    <xs:simpleType name="docFormatKind">
        <xs:restriction base="xs:string">
            <xs:enumeration value="plain"/>
            <xs:enumeration value="markdown"/>
            <xs:enumeration value="html"/>
        </xs:restriction>
    </xs:simpleType>

    <xs:complexType name="docDecl">
        <xs:simpleContent>
            <xs:extension base="xs:string">
                <xs:attribute name="format" type="docFormatKind" default="plain"/>
            </xs:extension>
        </xs:simpleContent>
    </xs:complexType>

    <xs:simpleType name="licenseIdentifier">
        <xs:restriction base="xs:string">
            <xs:pattern value="[a-zA-Z][a-zA-Z0-9._-]*"/>
        </xs:restriction>
    </xs:simpleType>

    <xs:simpleType name="licenseIdentifierRef">
        <xs:restriction base="xs:string">
            <xs:pattern value="((::)?[a-zA-Z][a-zA-Z0-9._-]*)*"/>
        </xs:restriction>
    </xs:simpleType>

    <xs:simpleType name="licenseUseIdentifier">
        <xs:restriction base="licenseIdentifier"/>
    </xs:simpleType>

    <xs:simpleType name="licenseUseIdentifierRef">
        <xs:restriction base="licenseIdentifierRef"/>
    </xs:simpleType>

    <xs:complexType name="licenseDefinitionDecl">
        <xs:attribute name="name" type="licenseIdentifier"  use="required"/>
        <xs:attribute name="link" type="xs:anyURI" use="required"/>
    </xs:complexType>

    <xs:complexType name="licenseUseDecl">
        <xs:attribute name="name" type="licenseUseIdentifier" use="required"/>
        <xs:attribute name="license_type" type="licenseIdentifierRef" use="required"/>
        <xs:attribute name="link" type="xs:string" use="required"/>
    </xs:complexType>

    <xs:complexType name="typeAnnotationList">
        <xs:choice minOccurs="1" maxOccurs="unbounded">
            <xs:element name="doc" type="docDecl" />
            <xs:element name="verbatim" type="verbatimDecl" />
            <xs:element name="custom" type="appliedAnnotation" />
        </xs:choice>
    </xs:complexType>

    <xs:complexType name="memberAnnotationList">
        <xs:choice minOccurs="1" maxOccurs="unbounded">
            <xs:element name="doc" type="docDecl" />
            <xs:element name="verbatim" type="verbatimDecl" />
            <xs:element name="custom" type="appliedAnnotation" />
        </xs:choice>
    </xs:complexType>

    <!-- =================================================================== -->
    <!-- Annotations -->
    <!-- =================================================================== -->

    <xs:complexType name="annotationTypeDecl">
        <!-- do not extend commonTypeDecl as we don't want to allow
            annotations within  annotation definition -->
        <xs:sequence>
            <xs:element name="doc" type="docDecl" minOccurs="0" maxOccurs="unbounded"/>
            <xs:element name="parameter" type="annotationMemberDecl"
                        minOccurs="0" maxOccurs="unbounded"/>
        </xs:sequence>

        <xs:attribute name="name" type="identifierName" use="required"/>
        <xs:attribute name="baseType" type="identifierName"/>
    </xs:complexType>

    <xs:complexType name="annotationParameterValue">
        <xs:attribute name="name" type="identifierName" use="required"/>
        <xs:attribute name="value" type="xs:string" use="required"/>
    </xs:complexType>

    <xs:complexType name="appliedAnnotation">
        <xs:sequence>
            <xs:element name="parameter" type="annotationParameterValue"
                        minOccurs="0" maxOccurs="unbounded"/>
        </xs:sequence>

        <xs:attribute name="annotation_ref" type="identifierName" use="required"/>
    </xs:complexType>

    <!-- ================================================================== -->
    <!-- Structures -->
    <!-- ================================================================== -->

    <xs:complexType name="structMemberDecl">
        <xs:complexContent>
            <xs:extension base="commonMemberDecl">
                <xs:attributeGroup ref="structMemberAttributes"/>
            </xs:extension>
        </xs:complexContent>
    </xs:complexType>

    <xs:complexType name="structDecl">
        <xs:complexContent>
            <xs:extension base="commonTypeDecl">
                <xs:sequence>
                    <xs:element name="member" type="structMemberDecl" minOccurs="0" maxOccurs="unbounded"/>
                </xs:sequence>

                <xs:attributeGroup ref="structTypeAttributes"/>
            </xs:extension>
        </xs:complexContent>
    </xs:complexType>

    <!-- =================================================================== -->
    <!-- Unions -->
    <!-- =================================================================== -->

    <xs:complexType name="unionMemberDecl">
        <xs:complexContent>
            <xs:extension base="commonMemberDecl">
                <xs:attributeGroup ref="unionMemberAttributes"/>
            </xs:extension>
        </xs:complexContent>
    </xs:complexType>

    <xs:complexType name="discriminatorDecl">
        <xs:attribute name="type" type="discriminatorTypeKind" use="required"/>
        <xs:attribute name="nonBasicTypeName" type="identifierName"/>
        <xs:attributeGroup ref="unionDiscriminatorAttributes"/>
    </xs:complexType>

    <xs:complexType name="caseDiscriminatorDecl">
        <xs:attribute name="value" type="integerOrIdentifierNameRef" use="required"/>
    </xs:complexType>

    <xs:complexType name="caseDecl">
        <xs:sequence>
            <xs:element name="caseDiscriminator" type="caseDiscriminatorDecl"
                        minOccurs="1" maxOccurs="unbounded"/>
            <xs:element name="member" type="unionMemberDecl"
                        minOccurs="1" maxOccurs="1"/>
        </xs:sequence>
    </xs:complexType>

    <xs:complexType name="defaultCaseDecl">
        <xs:sequence>
            <xs:element name="member" type="unionMemberDecl"
                        minOccurs="1" maxOccurs="1"/>
        </xs:sequence>
    </xs:complexType>

    <xs:complexType name="baseUnionDecl">
        <xs:attribute name="type" type="identifierName" use="required"/>
    </xs:complexType>

    <xs:complexType name="unionDecl">
        <xs:complexContent>
            <xs:extension base="commonTypeDecl">
                <xs:sequence>
                    <xs:choice minOccurs="1" maxOccurs="1">
                        <xs:element name="discriminator" type="discriminatorDecl"/>
                        <xs:element name="baseUnion" type="baseUnionDecl"/>
                    </xs:choice>
                    <xs:element name="case" type="caseDecl"
                                minOccurs="1" maxOccurs="unbounded"/>
                    <xs:element name="defaultCase" type="defaultCaseDecl"
                                minOccurs="0" maxOccurs="1"/>                                
                </xs:sequence>

                <xs:attributeGroup ref="unionTypeAttributes"/>
            </xs:extension>
        </xs:complexContent>
    </xs:complexType>

    <!-- =================================================================== -->
    <!-- Aliases -->
    <!-- =================================================================== -->

    <xs:complexType name="typedefDecl">
        <xs:complexContent>
            <xs:extension base="commonTypeDecl">
                <xs:attributeGroup ref="typedefElementAttributes"/>
            </xs:extension>
        </xs:complexContent>

    </xs:complexType>

    <!-- =================================================================== -->
    <!-- Enumerations -->
    <!-- =================================================================== -->

    <xs:simpleType name="enumBitBound">
        <xs:restriction base="integer1to32_or_IdentifierNameRef" />
    </xs:simpleType>

    <xs:complexType name="enumeratorDecl">
        <xs:complexContent>
            <xs:extension base="commonMemberDecl">
                <xs:attribute name="value" type="integerOrIdentifierNameRef"/>
                <xs:attribute name="defaultLiteral" type="xs:boolean"
                            default="true"/>
            </xs:extension>
        </xs:complexContent>
    </xs:complexType>

    <xs:complexType name="enumDecl">
        <xs:complexContent>
            <xs:extension base="commonTypeDecl">
                <xs:sequence>
                    <xs:element name="enumerator" type="enumeratorDecl"
                                minOccurs="1" maxOccurs="unbounded"/>
                </xs:sequence>

                <xs:attributeGroup ref="enumTypeAttributes"/>
            </xs:extension>
        </xs:complexContent>
    </xs:complexType>

    <!-- =================================================================== -->
    <!-- Bit Masks -->
    <!-- =================================================================== -->

    <xs:simpleType name="bitmaskBitBound">
        <xs:restriction base="integer1to64_or_IdentifierNameRef"/>
    </xs:simpleType>

    <xs:simpleType name="flagIndex">
        <xs:restriction base="integer0to63_or_IdentifierNameRef"/>
    </xs:simpleType>

    <xs:complexType name="flagDecl">
        <xs:complexContent>
            <xs:extension base="commonMemberDecl">
                <xs:attribute name="position" type="flagIndex"/>
            </xs:extension>
        </xs:complexContent>
    </xs:complexType>

    <xs:complexType name="bitmaskDecl">
        <xs:complexContent>
            <xs:extension base="commonTypeDecl">
                <xs:sequence>
                    <xs:element name="flag" type="flagDecl" minOccurs="0"
                        maxOccurs="64"/>
                </xs:sequence>
                <xs:attributeGroup ref="bitmaskTypeAttributes"/>
            </xs:extension>
        </xs:complexContent>
    </xs:complexType>

    <!-- =================================================================== -->
    <!-- Bit Set -->
    <!-- =================================================================== -->
    
    <xs:complexType name="bitfieldDecl">
        <xs:complexContent>
            <xs:extension base="commonMemberDecl">
                <xs:attribute name="bitSize" type="integer1to64_or_IdentifierNameRef" use="required"/>
                <xs:attribute name="holdingType" type="bitfieldTypeKind"/>            </xs:extension>
        </xs:complexContent>
    </xs:complexType>
    
    <xs:complexType name="bitpaddingDecl">
        <xs:attribute name="bitSize" type="integer1to64_or_IdentifierNameRef" use="required"/>
    </xs:complexType>

    <xs:complexType name="bitsetDecl">
        <xs:complexContent>
            <xs:extension base="commonTypeDecl">
                <xs:choice minOccurs="1" maxOccurs="64">
                    <xs:element name="bitfield" type="bitfieldDecl"/>
                    <xs:element name="bitpadding" type="bitpaddingDecl"/>
                </xs:choice>
                <xs:attribute name="baseType" type="identifierName"/>
            </xs:extension>
        </xs:complexContent>
    </xs:complexType> 

    <!-- ================================================================== -->
    <!-- Interfaces -->
    <!-- ================================================================== -->

    <xs:complexType name="operationReturnAndExceptionMemberDecl">
        <xs:attributeGroup ref="typenameAttributeGroup"/>
        <xs:attributeGroup ref="collectionSizeAttributeGroup"/>
        <xs:attributeGroup ref="rangeAndUnitsAttributeGroup"/>
    </xs:complexType>

    <xs:complexType name="operationReturnDecl">
        <xs:complexContent>
            <xs:extension base="operationReturnAndExceptionMemberDecl">
            </xs:extension>
        </xs:complexContent>
    </xs:complexType>

    <xs:complexType name="exceptionTypeDecl">
        <xs:complexContent>
            <xs:extension base="commonTypeDecl">
                <xs:sequence>
                    <xs:element name="member" type="exceptionMemberDecl"
                            minOccurs="0" maxOccurs="unbounded"/>
                </xs:sequence>
                
                <xs:attribute name="baseType" type="identifierName"/>
            </xs:extension>
        </xs:complexContent>
    </xs:complexType>

    <xs:simpleType name="operationArgumentDirectionKind">
        <xs:restriction base="xs:string">
            <xs:enumeration value="in"/>
            <xs:enumeration value="out"/>
            <xs:enumeration value="inout"/>
        </xs:restriction>
    </xs:simpleType>

    <xs:complexType name="operationArgumentDecl">
        <xs:complexContent>
            <xs:extension base="commonMemberDecl">
                <xs:attributeGroup ref="operationArgumentAttributes"/>
            </xs:extension>
        </xs:complexContent>
    </xs:complexType>

    <xs:complexType name="raisedExceptionDecl">
        <xs:attribute name="exceptionType" type="identifierName" use="required"/>
    </xs:complexType>

    <xs:complexType name="raisesDecl">
        <xs:sequence>
            <xs:element name="exception_ref" type="raisedExceptionDecl" minOccurs="1" maxOccurs="unbounded"/>
        </xs:sequence>
    </xs:complexType>

    <xs:complexType name="operationArgumentList">
        <xs:sequence>
            <xs:element name="argument" type="operationArgumentDecl" minOccurs="0" maxOccurs="unbounded"/>
        </xs:sequence>
    </xs:complexType>

    <xs:complexType name="operationDecl">
        <xs:all>
            <xs:element name="annotations" type="memberAnnotationList" 
                minOccurs="0"/>            
            <xs:element name="return" type="operationReturnDecl" 
                minOccurs="0"/>
            <xs:element name="raises" type="raisesDecl" 
                minOccurs="0"/>                
            <xs:element name="arguments"  type="operationArgumentList"
                minOccurs="0"/>
        </xs:all>
        <xs:attribute name="name" type="identifierName" use="required"/>
        <xs:attribute name="extensibility" type="extensibilityKind" 
                      />
    </xs:complexType>

    <xs:complexType name="interfaceDecl">
        <xs:complexContent>
            <xs:extension base="commonTypeDecl">
                <xs:choice minOccurs="1" maxOccurs="unbounded">
                    <xs:element name="operation" type="operationDecl" 
                        minOccurs="0"  maxOccurs="unbounded"/>
                    <xs:element name="const" type="constDecl"
                                minOccurs="0"/>
                </xs:choice>

                <xs:attributeGroup ref="interfaceTypeAttributes"/>
            </xs:extension>
        </xs:complexContent>
    </xs:complexType>

    <!-- ================================================================== -->
    <!-- Modules -->
    <!-- ================================================================== -->

    <xs:group name="moduleElements">
        <xs:sequence>
            <xs:choice minOccurs="1" maxOccurs="unbounded">
                <xs:element name="include" type="includeDecl"/>
                <xs:element name="forward_dcl" type="forwardDecl"/>
                <xs:element name="const" type="constDecl" minOccurs="0"/>
                <xs:element name="module" type="moduleDecl"/>
                <xs:element name="struct" type="structDecl"/>
                <xs:element name="union" type="unionDecl" minOccurs="0"/>
                <xs:element name="annotation" type="annotationTypeDecl"/>
                <xs:element name="typedef" type="typedefDecl"/>
                <xs:element name="enum" type="enumDecl" minOccurs="0"/>
                <xs:element name="bitmask" type="bitmaskDecl"/>
                <xs:element name="bitset" type="bitsetDecl"/>                            
                <xs:element name="exception" type="exceptionTypeDecl"/>
                <xs:element name="interface" type="interfaceDecl" 
                            minOccurs="0"/>
                <xs:element name="license_type" type="licenseDefinitionDecl" 
                            minOccurs="0"/>
                <xs:element name="license_use" type="licenseUseDecl" 
                            minOccurs="0"/>             
            </xs:choice>
        </xs:sequence>
    </xs:group>

    <xs:complexType name="moduleDecl">
        <xs:sequence>
            <xs:element name="annotations" type="typeAnnotationList" minOccurs="0" maxOccurs="1"/>
            <xs:group ref="moduleElements" minOccurs="0" maxOccurs="unbounded"/>
        </xs:sequence>

        <xs:attribute name="name" type="identifierName" use="required"/>
        <xs:attribute name="extensibility" type="extensibilityKind"
            default="append"/>

        <xs:attribute name="autoid" type="autoIdKind"
                      default="hash"/>
        <xs:attribute name="union_autoid" type="autoIdKind" 
                      default="hash"/>
        <xs:attribute name="union_autoid_selection" type="unionAutoIdSelection" 
                      default="mutable_unions"/>

        <xs:attribute name="data_representation" type="dataRepresentationMask"/>
        <xs:attribute name="defaultNested" type="xs:boolean"
                      default="true"/>
    </xs:complexType>

    <xs:complexType name="typeLibrary">
        <xs:group ref="moduleElements"/>
    </xs:complexType>

</xs:schema>
