<?xml version="1.0"?>
<!--  Readers of this schema are reminded that the default value for both
      minOccurs and maxOccurs is "1". -->
<xsd:schema xmlns="http://www.w3.org/2005/XQueryX"
            xmlns:xsd="http://www.w3.org/2001/XMLSchema"
            targetNamespace="http://www.w3.org/2005/XQueryX"
            elementFormDefault="qualified" attributeFormDefault="qualified">

  <!-- A few helper declarations -->
  <xsd:complexType name="emptyContent"/>

  <xsd:element name="NCName" type="xsd:NCName"/>

  <xsd:complexType name="QName">
    <xsd:simpleContent>
      <xsd:extension base="xsd:NCName">
        <xsd:attribute name="prefix" type="xsd:NCName" use="optional"/>
      </xsd:extension>
    </xsd:simpleContent>
  </xsd:complexType>

  <!-- The base class -->
  <xsd:complexType name="expr"/>

  <xsd:element name="expr" type="expr" abstract="true"/>

  <!-- A list of expressions -->
  <xsd:complexType name="exprList">
    <xsd:sequence>
      <xsd:element ref="expr" minOccurs="0" maxOccurs="unbounded"/>
    </xsd:sequence>
  </xsd:complexType>

  <xsd:complexType name="exprWrapperOptional">
    <xsd:sequence>
      <xsd:element ref="expr" minOccurs="0"/>
    </xsd:sequence>
  </xsd:complexType>

  <!-- Simple wrapper class -->
  <xsd:complexType name="exprWrapper">
    <xsd:sequence>
      <xsd:element ref="expr"/>
    </xsd:sequence>
  </xsd:complexType>

  <!-- constant expressions. We have 4 different subclasses for this -->
  <xsd:complexType name="constantExpr">
    <xsd:complexContent>
      <xsd:extension base="expr">
        <xsd:sequence>
          <xsd:element name="value" type="xsd:anyType"/>
        </xsd:sequence>
      </xsd:extension>
    </xsd:complexContent>
  </xsd:complexType>

  <xsd:element name="constantExpr" type="constantExpr" abstract="true" substitutionGroup="expr"/>

  <xsd:complexType name="integerConstantExpr">
    <xsd:complexContent>
      <xsd:restriction base="constantExpr">
        <xsd:sequence>
          <xsd:element name="value" type="xsd:integer"/>
        </xsd:sequence>
      </xsd:restriction>
    </xsd:complexContent>
  </xsd:complexType>

  <xsd:element name="integerConstantExpr" type="integerConstantExpr" substitutionGroup="constantExpr"/>

  <xsd:complexType name="decimalConstantExpr">
    <xsd:complexContent>
      <xsd:restriction base="constantExpr">
        <xsd:sequence>
          <xsd:element name="value" type="xsd:decimal"/>
        </xsd:sequence>
      </xsd:restriction>
    </xsd:complexContent>
  </xsd:complexType>

  <xsd:element name="decimalConstantExpr" type="decimalConstantExpr" substitutionGroup="constantExpr"/>

  <xsd:complexType name="doubleConstantExpr">
    <xsd:complexContent>
      <xsd:restriction base="constantExpr">
        <xsd:sequence>
          <xsd:element name="value" type="xsd:double"/>
        </xsd:sequence>
      </xsd:restriction>
    </xsd:complexContent>
  </xsd:complexType>

  <xsd:element name="doubleConstantExpr" type="doubleConstantExpr" substitutionGroup="constantExpr"/>

  <xsd:complexType name="stringConstantExpr">
    <xsd:complexContent>
      <xsd:restriction base="constantExpr">
        <xsd:sequence>
          <xsd:element name="value" type="xsd:string"/>
        </xsd:sequence>
      </xsd:restriction>
    </xsd:complexContent>
  </xsd:complexType>

  <xsd:element name="stringConstantExpr" type="stringConstantExpr" substitutionGroup="constantExpr"/>

  <!-- Variables -->
  <xsd:complexType name="varRef">
    <xsd:complexContent>
      <xsd:extension base="expr">
        <xsd:sequence>
          <xsd:element name="name" type="QName"/>
        </xsd:sequence>
      </xsd:extension>
    </xsd:complexContent>
  </xsd:complexType>

  <xsd:element name="varRef" type="varRef" substitutionGroup="expr"/>

  <!-- root and context-item expressions -->
  <!-- rootExpr deleted per Bugzilla Bug #2523 -->
  <xsd:complexType name="contextItemExpr">
    <xsd:complexContent>
      <xsd:extension base="expr"/>
    </xsd:complexContent>
  </xsd:complexType>

  <xsd:element name="contextItemExpr" type="contextItemExpr" substitutionGroup="expr"/>

  <!-- Pragmas and extension expressions -->
  <xsd:element name="pragma">
    <xsd:complexType>
      <xsd:sequence>
        <xsd:element name="pragmaName" type="QName"/>
        <xsd:element name="pragmaContents" type="xsd:string"/>
      </xsd:sequence>
    </xsd:complexType>
  </xsd:element>

  <xsd:complexType name="extensionExpr">
    <xsd:complexContent>
      <xsd:extension base="expr">
        <xsd:sequence>
          <xsd:element ref="pragma" maxOccurs="unbounded"/>
          <xsd:element name="argExpr" type="exprWrapper" minOccurs="0"/>
        </xsd:sequence>
      </xsd:extension>
    </xsd:complexContent>
  </xsd:complexType>

  <xsd:element name="extensionExpr" type="extensionExpr" substitutionGroup="expr"/>

  <xsd:complexType name="functionCallExpr">
    <xsd:complexContent>
      <xsd:extension base="expr">
        <xsd:sequence>
          <xsd:element name="functionName" type="QName"/>
          <xsd:element name="arguments" type="exprList" minOccurs="0"/>
        </xsd:sequence>
      </xsd:extension>
    </xsd:complexContent>
  </xsd:complexType>

  <xsd:element name="functionCallExpr" type="functionCallExpr" substitutionGroup="expr"/>

  <!-- Constructor functions -->
  <xsd:complexType name="constructorFunctionExpr">
    <xsd:complexContent>
      <xsd:extension base="expr">
        <xsd:sequence>
          <xsd:element name="typeName" type="QName"/>
          <xsd:element name="argExpr" type="exprWrapper"/>
        </xsd:sequence>
      </xsd:extension>
    </xsd:complexContent>
  </xsd:complexType>

  <xsd:element name="constructorFunctionExpr" type="constructorFunctionExpr" substitutionGroup="expr"/>

  <xsd:complexType name="sequenceExpr">
    <xsd:complexContent>
      <xsd:extension base="expr">
        <xsd:sequence>
          <xsd:element ref="expr" minOccurs="0" maxOccurs="unbounded"/>
        </xsd:sequence>
      </xsd:extension>
    </xsd:complexContent>
  </xsd:complexType>

  <xsd:element name="sequenceExpr" type="sequenceExpr" substitutionGroup="expr"/>

  <xsd:complexType name="rangeSequenceExpr">
    <xsd:complexContent>
      <xsd:extension base="expr">
        <xsd:sequence>
          <xsd:element name="startExpr" type="exprWrapper"/>
          <xsd:element name="endExpr" type="exprWrapper"/>
        </xsd:sequence>
      </xsd:extension>
    </xsd:complexContent>
  </xsd:complexType>

  <xsd:element name="rangeSequenceExpr" type="rangeSequenceExpr" substitutionGroup="expr"/>

  <!-- Builtin operator expressions -->
  <xsd:complexType name="operatorExpr">
    <xsd:complexContent>
      <xsd:extension base="expr"/>
    </xsd:complexContent>
  </xsd:complexType>

  <xsd:complexType name="unaryOperatorExpr">
    <xsd:complexContent>
      <xsd:extension base="operatorExpr">
        <xsd:sequence>
          <xsd:element name="operand" type="exprWrapper"/>
        </xsd:sequence>
      </xsd:extension>
    </xsd:complexContent>
  </xsd:complexType>

  <xsd:complexType name="binaryOperatorExpr">
    <xsd:complexContent>
      <xsd:extension base="operatorExpr">
        <xsd:sequence>
          <xsd:element name="firstOperand" type="exprWrapper"/>
          <xsd:element name="secondOperand" type="exprWrapper"/>
        </xsd:sequence>
      </xsd:extension>
    </xsd:complexContent>
  </xsd:complexType>

  <xsd:element name="operatorExpr" type="operatorExpr" abstract="true" substitutionGroup="expr"/>

  <xsd:element name="arithmeticOp" type="operatorExpr" abstract="true" substitutionGroup="operatorExpr"/>

  <xsd:element name="addOp" type="binaryOperatorExpr" substitutionGroup="arithmeticOp"/>

  <xsd:element name="subtractOp" type="binaryOperatorExpr" substitutionGroup="arithmeticOp"/>

  <xsd:element name="multiplyOp" type="binaryOperatorExpr" substitutionGroup="arithmeticOp"/>

  <xsd:element name="divOp" type="binaryOperatorExpr" substitutionGroup="arithmeticOp"/>

  <xsd:element name="idivOp" type="binaryOperatorExpr" substitutionGroup="arithmeticOp"/>

  <xsd:element name="modOp" type="binaryOperatorExpr" substitutionGroup="arithmeticOp"/>

  <xsd:element name="unaryMinusOp" type="unaryOperatorExpr" substitutionGroup="arithmeticOp"/>

  <xsd:element name="unaryPlusOp" type="unaryOperatorExpr" substitutionGroup="arithmeticOp"/>

  <xsd:element name="comparisonOp" type="binaryOperatorExpr" abstract="true"
               substitutionGroup="operatorExpr"/>

  <xsd:element name="valueComparisonOp" type="binaryOperatorExpr" abstract="true"
               substitutionGroup="operatorExpr"/>

  <xsd:element name="eqOp" type="binaryOperatorExpr" substitutionGroup="valueComparisonOp"/>

  <xsd:element name="neOp" type="binaryOperatorExpr" substitutionGroup="valueComparisonOp"/>

  <xsd:element name="gtOp" type="binaryOperatorExpr" substitutionGroup="valueComparisonOp"/>

  <xsd:element name="geOp" type="binaryOperatorExpr" substitutionGroup="valueComparisonOp"/>

  <xsd:element name="ltOp" type="binaryOperatorExpr" substitutionGroup="valueComparisonOp"/>

  <xsd:element name="leOp" type="binaryOperatorExpr" substitutionGroup="valueComparisonOp"/>

  <xsd:element name="generalComparisonOp" type="binaryOperatorExpr" abstract="true"
               substitutionGroup="operatorExpr"/>

  <xsd:element name="equalOp" type="binaryOperatorExpr" substitutionGroup="generalComparisonOp"/>

  <xsd:element name="notEqualOp" type="binaryOperatorExpr" substitutionGroup="generalComparisonOp"/>

  <xsd:element name="lessThanOp" type="binaryOperatorExpr" substitutionGroup="generalComparisonOp"/>

  <xsd:element name="lessThanOrEqualOp" type="binaryOperatorExpr"
               substitutionGroup="generalComparisonOp"/>

  <xsd:element name="greaterThanOp" type="binaryOperatorExpr" substitutionGroup="generalComparisonOp"/>

  <xsd:element name="greaterThanOrEqualOp" type="binaryOperatorExpr"
               substitutionGroup="generalComparisonOp"/>

  <xsd:element name="nodeComparisonOp" type="binaryOperatorExpr" abstract="true"
               substitutionGroup="operatorExpr"/>

  <xsd:element name="isOp" type="binaryOperatorExpr" substitutionGroup="nodeComparisonOp"/>

  <xsd:element name="orderComparisonOp" type="binaryOperatorExpr" abstract="true"
               substitutionGroup="operatorExpr"/>

  <xsd:element name="nodeBeforeOp" type="binaryOperatorExpr" substitutionGroup="orderComparisonOp"/>

  <xsd:element name="nodeAfterOp" type="binaryOperatorExpr" substitutionGroup="orderComparisonOp"/>

  <xsd:element name="logicalOp" type="binaryOperatorExpr" abstract="true"
               substitutionGroup="operatorExpr"/>

  <xsd:element name="andOp" type="binaryOperatorExpr" substitutionGroup="logicalOp"/>

  <xsd:element name="orOp" type="binaryOperatorExpr" substitutionGroup="logicalOp"/>

  <xsd:element name="setOp" type="binaryOperatorExpr" abstract="true" substitutionGroup="operatorExpr"/>

  <xsd:element name="unionOp" type="binaryOperatorExpr" substitutionGroup="setOp"/>

  <xsd:element name="intersectOp" type="binaryOperatorExpr" substitutionGroup="setOp"/>

  <xsd:element name="exceptOp" type="binaryOperatorExpr" substitutionGroup="setOp"/>

  <!-- Basic typenames -->
  <xsd:element name="atomicType" type="QName" substitutionGroup="itemType"/>

  <!-- Used in castable expression -->
  <xsd:element name="singleType">
    <xsd:complexType>
      <xsd:sequence>
        <xsd:element ref="atomicType"/>
        <xsd:element name="optional" type="emptyContent" minOccurs="0"/>
      </xsd:sequence>
    </xsd:complexType>
  </xsd:element>

  <xsd:element name="itemType" abstract="true"/>

  <xsd:complexType name="emptyItemTypeContent"/>

  <xsd:element name="anyItemType" type="emptyItemTypeContent" substitutionGroup="itemType"/>

  <xsd:simpleType name="occurrenceIndicator">
    <xsd:restriction base="xsd:string">
      <xsd:enumeration value="?"/>
      <xsd:enumeration value="*"/>
      <xsd:enumeration value="+"/>
    </xsd:restriction>
  </xsd:simpleType>

  <xsd:complexType name="sequenceType">
    <xsd:choice>
      <xsd:element name="voidSequenceType" type="emptyContent"/>
      <xsd:sequence>
        <xsd:element ref="itemType"/>
        <xsd:element name="occurrenceIndicator" type="occurrenceIndicator" minOccurs="0"/>
      </xsd:sequence>
    </xsd:choice>
  </xsd:complexType>

  <xsd:element name="sequenceType" type="sequenceType"/>

  <xsd:element name="typeDeclaration" type="sequenceType"/>

  <!-- Represents a "typed" variable (for clause, let clause etc) -->
  <xsd:element name="typedVariableBinding">
    <xsd:complexType>
      <xsd:sequence>
        <xsd:element name="varName" type="QName"/>
        <xsd:element ref="typeDeclaration" minOccurs="0"/>
      </xsd:sequence>
    </xsd:complexType>
  </xsd:element>

  <xsd:element name="positionalVariableBinding" type="QName"/>

  <xsd:element name="variableBinding" type="QName"/>

  <xsd:element name="forClauseItem">
    <xsd:complexType>
      <xsd:sequence>
        <xsd:element ref="typedVariableBinding"/>
        <xsd:element ref="positionalVariableBinding" minOccurs="0"/>
        <xsd:element name="forExpr" type="exprWrapper"/>
      </xsd:sequence>
    </xsd:complexType>
  </xsd:element>

  <xsd:element name="forClause">
    <xsd:complexType>
      <xsd:sequence>
        <xsd:element ref="forClauseItem" maxOccurs="unbounded"/>
      </xsd:sequence>
    </xsd:complexType>
  </xsd:element>

  <xsd:element name="letClauseItem">
    <xsd:complexType>
      <xsd:sequence>
        <xsd:element ref="typedVariableBinding"/>
        <xsd:element name="letExpr" type="exprWrapper"/>
      </xsd:sequence>
    </xsd:complexType>
  </xsd:element>

  <xsd:element name="letClause">
    <xsd:complexType>
      <xsd:sequence>
        <xsd:element ref="letClauseItem" maxOccurs="unbounded"/>
      </xsd:sequence>
    </xsd:complexType>
  </xsd:element>

  <xsd:element name="whereClause" type="exprWrapper"/>

  <xsd:element name="returnClause" type="exprWrapper"/>

  <xsd:simpleType name="emptyOrderingMode">
    <xsd:restriction base="xsd:string">
      <xsd:enumeration value="empty greatest"/>
      <xsd:enumeration value="empty least"/>
    </xsd:restriction>
  </xsd:simpleType>

  <xsd:simpleType name="orderingKind">
    <xsd:restriction base="xsd:string">
      <xsd:enumeration value="ascending"/>
      <xsd:enumeration value="descending"/>
    </xsd:restriction>
  </xsd:simpleType>

  <xsd:element name="orderModifier">
    <xsd:complexType>
      <xsd:sequence>
        <xsd:element name="orderingKind" type="orderingKind" minOccurs="0"/>
        <xsd:element name="emptyOrderingMode" type="emptyOrderingMode" minOccurs="0"/>
        <xsd:element name="collation" type="xsd:string" minOccurs="0"/>
      </xsd:sequence>
    </xsd:complexType>
  </xsd:element>

  <xsd:element name="orderBySpec">
    <xsd:complexType>
      <xsd:sequence>
        <xsd:element name="orderByExpr" type="exprWrapper"/>
        <xsd:element ref="orderModifier" minOccurs="0"/>
      </xsd:sequence>
    </xsd:complexType>
  </xsd:element>

  <xsd:element name="orderByClause">
    <xsd:complexType>
      <xsd:sequence>
        <xsd:element name="stable" type="emptyContent" minOccurs="0"/>
        <xsd:element ref="orderBySpec" maxOccurs="unbounded"/>
      </xsd:sequence>
    </xsd:complexType>
  </xsd:element>

  <!-- This is the flwor expression -->
  <xsd:complexType name="flworExpr">
    <xsd:complexContent>
      <xsd:extension base="expr">
        <xsd:sequence>
          <xsd:choice maxOccurs="unbounded">
            <xsd:element ref="forClause"/>
            <xsd:element ref="letClause"/>
          </xsd:choice>
          <xsd:element ref="whereClause" minOccurs="0"/>
          <xsd:element ref="orderByClause" minOccurs="0"/>
          <xsd:element ref="returnClause"/>
        </xsd:sequence>
      </xsd:extension>
    </xsd:complexContent>
  </xsd:complexType>

  <xsd:element name="flworExpr" type="flworExpr" substitutionGroup="expr"/>

  <!-- conditional expressions -->
  <xsd:complexType name="ifThenElseExpr">
    <xsd:complexContent>
      <xsd:extension base="expr">
        <xsd:sequence>
          <xsd:element name="ifClause" type="exprWrapper"/>
          <xsd:element name="thenClause" type="exprWrapper"/>
          <xsd:element name="elseClause" type="exprWrapper"/>
        </xsd:sequence>
      </xsd:extension>
    </xsd:complexContent>
  </xsd:complexType>

  <xsd:element name="ifThenElseExpr" type="ifThenElseExpr" substitutionGroup="expr"/>

  <!-- The following clauses describe quantified expressions -->
  <xsd:simpleType name="quantifier">
    <xsd:restriction base="xsd:NMTOKEN">
      <xsd:enumeration value="some"/>
      <xsd:enumeration value="every"/>
    </xsd:restriction>
  </xsd:simpleType>

  <xsd:element name="quantifiedExprInClause">
    <xsd:complexType>
      <xsd:sequence>
        <xsd:element ref="typedVariableBinding"/>
        <xsd:element name="sourceExpr" type="exprWrapper"/>
      </xsd:sequence>
    </xsd:complexType>
  </xsd:element>

  <xsd:complexType name="quantifiedExpr">
    <xsd:complexContent>
      <xsd:extension base="expr">
        <xsd:sequence>
          <xsd:element name="quantifier" type="quantifier"/>
          <xsd:element ref="quantifiedExprInClause" maxOccurs="unbounded"/>
          <xsd:element name="predicateExpr" type="exprWrapper"/>
        </xsd:sequence>
      </xsd:extension>
    </xsd:complexContent>
  </xsd:complexType>

  <xsd:element name="quantifiedExpr" type="quantifiedExpr" substitutionGroup="expr"/>

  <!-- handle the typeswitch construct -->
  <!-- Note: no substitutionGroup as we cannot use this anywhere -->
  <xsd:element name="typeswitchExprCaseClause">
    <xsd:complexType>
      <xsd:complexContent>
        <xsd:extension base="expr">
          <xsd:sequence>
            <xsd:element ref="variableBinding" minOccurs="0"/>
            <xsd:element ref="sequenceType"/>
            <xsd:element name="resultExpr" type="exprWrapper"/>
          </xsd:sequence>
        </xsd:extension>
      </xsd:complexContent>
    </xsd:complexType>
  </xsd:element>

  <!-- Note: no substitutionGroup as we cannot use this anywhere -->
  <xsd:element name="typeswitchExprDefaultClause">
    <xsd:complexType>
      <xsd:complexContent>
        <xsd:extension base="expr">
          <xsd:sequence>
            <xsd:element ref="variableBinding" minOccurs="0"/>
            <xsd:element name="resultExpr" type="exprWrapper"/>
          </xsd:sequence>
        </xsd:extension>
      </xsd:complexContent>
    </xsd:complexType>
  </xsd:element>

  <xsd:complexType name="typeswitchExpr">
    <xsd:complexContent>
      <xsd:extension base="expr">
        <xsd:sequence>
          <xsd:element name="argExpr" type="exprWrapper"/>
          <xsd:element ref="typeswitchExprCaseClause" maxOccurs="unbounded"/>
          <xsd:element ref="typeswitchExprDefaultClause"/>
        </xsd:sequence>
      </xsd:extension>
    </xsd:complexContent>
  </xsd:complexType>

  <xsd:element name="typeswitchExpr" type="typeswitchExpr" substitutionGroup="expr"/>

  <!-- instance-of expressions -->
  <xsd:complexType name="instanceOfExpr">
    <xsd:complexContent>
      <xsd:extension base="expr">
        <xsd:sequence>
          <xsd:element name="argExpr" type="exprWrapper"/>
          <xsd:element ref="sequenceType"/>
        </xsd:sequence>
      </xsd:extension>
    </xsd:complexContent>
  </xsd:complexType>

  <xsd:element name="instanceOfExpr" type="instanceOfExpr" substitutionGroup="expr"/>

  <!-- treat-as expressions -->
  <xsd:complexType name="treatExpr">
    <xsd:complexContent>
      <xsd:extension base="expr">
        <xsd:sequence>
          <xsd:element name="argExpr" type="exprWrapper"/>
          <xsd:element ref="sequenceType"/>
        </xsd:sequence>
      </xsd:extension>
    </xsd:complexContent>
  </xsd:complexType>

  <xsd:element name="treatExpr" type="treatExpr" substitutionGroup="expr"/>

  <!-- castable and cast expressions -->
  <xsd:complexType name="castableExpr">
    <xsd:complexContent>
      <xsd:extension base="expr">
        <xsd:sequence>
          <xsd:element name="argExpr" type="exprWrapper"/>
          <xsd:element ref="singleType"/>
        </xsd:sequence>
      </xsd:extension>
    </xsd:complexContent>
  </xsd:complexType>

  <xsd:element name="castableExpr" type="castableExpr" substitutionGroup="expr"/>

  <xsd:complexType name="castExpr">
    <xsd:complexContent>
      <xsd:extension base="expr">
        <xsd:sequence>
          <xsd:element name="argExpr" type="exprWrapper"/>
          <xsd:element ref="singleType"/>
        </xsd:sequence>
      </xsd:extension>
    </xsd:complexContent>
  </xsd:complexType>

  <xsd:element name="castExpr" type="castExpr" substitutionGroup="expr"/>

  <!-- Validate expressions -->
  <xsd:simpleType name="validationMode">
    <xsd:restriction base="xsd:NMTOKEN">
      <xsd:enumeration value="lax"/>
      <xsd:enumeration value="strict"/>
    </xsd:restriction>
  </xsd:simpleType>

  <xsd:complexType name="validateExpr">
    <xsd:complexContent>
      <xsd:extension base="expr">
        <xsd:sequence>
          <xsd:element name="validationMode" type="validationMode" minOccurs="0"/>
          <xsd:element name="argExpr" type="exprWrapper"/>
        </xsd:sequence>
      </xsd:extension>
    </xsd:complexContent>
  </xsd:complexType>

  <xsd:element name="validateExpr" type="validateExpr" substitutionGroup="expr"/>

  <!-- Direct constructors. Only elementConstructor for now -->
  <!-- Note the absence of constructors corresponding to
       the directCommentConstructor and the directPIConstructor
       productions in the XQuery grammar. This is because they are
       trivially identical to the computed variants
    -->

  <!-- attributeConstructor is no longer a subclass of expr -->
  <xsd:complexType name="attributeConstructor">
    <xsd:sequence>
      <xsd:element name="attributeName" type="QName"/>
      <xsd:choice>
        <xsd:element name="attributeValueExpr" type="exprList"/>
        <xsd:element name="attributeValue" type="xsd:string"/>
      </xsd:choice>
    </xsd:sequence>
  </xsd:complexType>

  <xsd:complexType name="namespaceDeclaration">
    <xsd:sequence>
      <xsd:element name="prefix" type="xsd:NCName" minOccurs="0"/>
      <xsd:element name="uri" type="xsd:string"/>
    </xsd:sequence>
  </xsd:complexType>

  <xsd:element name="attributeList">
    <xsd:complexType>
      <xsd:sequence>
        <xsd:choice maxOccurs="unbounded">
          <xsd:element name="attributeConstructor" type="attributeConstructor"/>
          <xsd:element name="namespaceDeclaration" type="namespaceDeclaration"/>
        </xsd:choice>
      </xsd:sequence>
    </xsd:complexType>
  </xsd:element>

  <xsd:element name="elementContent" type="exprList"/>

  <xsd:complexType name="elementConstructor">
    <xsd:complexContent>
      <xsd:extension base="expr">
        <xsd:sequence>
          <xsd:element name="tagName" type="QName"/>
          <xsd:element ref="attributeList" minOccurs="0"/>
          <xsd:element ref="elementContent" minOccurs="0"/>
        </xsd:sequence>
      </xsd:extension>
    </xsd:complexContent>
  </xsd:complexType>

  <xsd:element name="elementConstructor" type="elementConstructor" substitutionGroup="expr"/>

  <!-- computed constructors -->
  <xsd:complexType name="computedElementConstructor">
    <xsd:complexContent>
      <xsd:extension base="expr">
        <xsd:sequence>
          <xsd:choice>
            <xsd:element name="tagName" type="QName"/>
            <xsd:element name="tagNameExpr" type="exprWrapper"/>
          </xsd:choice>
          <xsd:element name="contentExpr" type="exprWrapper" minOccurs="0"/>
        </xsd:sequence>
      </xsd:extension>
    </xsd:complexContent>
  </xsd:complexType>

  <xsd:element name="computedElementConstructor" type="computedElementConstructor"
               substitutionGroup="expr"/>

  <xsd:complexType name="computedAttributeConstructor">
    <xsd:complexContent>
      <xsd:extension base="expr">
        <xsd:sequence>
          <xsd:choice>
            <xsd:element name="tagName" type="QName"/>
            <xsd:element name="tagNameExpr" type="exprWrapper"/>
          </xsd:choice>
          <xsd:element name="valueExpr" type="exprWrapper" minOccurs="0"/>
        </xsd:sequence>
      </xsd:extension>
    </xsd:complexContent>
  </xsd:complexType>

  <xsd:element name="computedAttributeConstructor" type="computedAttributeConstructor"
               substitutionGroup="expr"/>

  <xsd:complexType name="computedDocumentConstructor">
    <xsd:complexContent>
      <xsd:extension base="expr">
        <xsd:sequence>
          <xsd:element name="argExpr" type="exprWrapper"/>
        </xsd:sequence>
      </xsd:extension>
    </xsd:complexContent>
  </xsd:complexType>

  <xsd:element name="computedDocumentConstructor" type="computedDocumentConstructor"
               substitutionGroup="expr"/>

  <xsd:complexType name="computedTextConstructor">
    <xsd:complexContent>
      <xsd:extension base="expr">
        <xsd:sequence>
          <xsd:element name="argExpr" type="exprWrapper" minOccurs="0"/>
        </xsd:sequence>
      </xsd:extension>
    </xsd:complexContent>
  </xsd:complexType>

  <xsd:element name="computedTextConstructor" type="computedTextConstructor" substitutionGroup="expr"/>

  <xsd:complexType name="computedCommentConstructor">
    <xsd:complexContent>
      <xsd:extension base="expr">
        <xsd:sequence>
          <xsd:element name="argExpr" type="exprWrapper"/>
        </xsd:sequence>
      </xsd:extension>
    </xsd:complexContent>
  </xsd:complexType>

  <xsd:element name="computedCommentConstructor" type="computedCommentConstructor"
               substitutionGroup="expr"/>

  <xsd:complexType name="computedPIConstructor">
    <xsd:complexContent>
      <xsd:extension base="expr">
        <xsd:sequence>
          <xsd:choice>
            <xsd:element name="piTarget" type="xsd:NCName"/>
            <xsd:element name="piTargetExpr" type="exprWrapper"/>
          </xsd:choice>
          <xsd:element name="piValueExpr" type="exprWrapper" minOccurs="0"/>
        </xsd:sequence>
      </xsd:extension>
    </xsd:complexContent>
  </xsd:complexType>

  <xsd:element name="computedPIConstructor" type="computedPIConstructor" substitutionGroup="expr"/>

  <!-- ordered and unordered expressions -->
  <xsd:complexType name="unorderedExpr">
    <xsd:complexContent>
      <xsd:extension base="expr">
        <xsd:sequence>
          <xsd:element name="argExpr" type="exprWrapper"/>
        </xsd:sequence>
      </xsd:extension>
    </xsd:complexContent>
  </xsd:complexType>

  <xsd:element name="unorderedExpr" type="unorderedExpr" substitutionGroup="expr"/>

  <xsd:complexType name="orderedExpr">
    <xsd:complexContent>
      <xsd:extension base="expr">
        <xsd:sequence>
          <xsd:element name="argExpr" type="exprWrapper"/>
        </xsd:sequence>
      </xsd:extension>
    </xsd:complexContent>
  </xsd:complexType>

  <xsd:element name="orderedExpr" type="orderedExpr" substitutionGroup="expr"/>

  <xsd:complexType name="simpleWildcard">
    <xsd:choice>
      <xsd:element name="QName" type="QName"/>
      <xsd:element name="star" type="emptyContent"/>
    </xsd:choice>
  </xsd:complexType>

  <xsd:element name="Wildcard">
    <xsd:complexType>
      <xsd:all>
        <xsd:element name="star" type="emptyContent" minOccurs="0"/>
        <xsd:element ref="NCName" minOccurs="0"/>
      </xsd:all>
    </xsd:complexType>
  </xsd:element>

  <xsd:element name="schemaAttributeTest" type="QName" substitutionGroup="kindTest"/>

  <xsd:element name="attributeTest" substitutionGroup="kindTest">
    <xsd:complexType>
      <xsd:complexContent>
         <xsd:extension base="emptyItemTypeContent">
          <xsd:sequence minOccurs="0">
            <xsd:element name="attributeName" type="simpleWildcard"/>
            <xsd:element name="typeName" type="QName" minOccurs="0"/>
          </xsd:sequence>
         </xsd:extension>
      </xsd:complexContent>
    </xsd:complexType>
  </xsd:element>

  <xsd:element name="anyElementTest" abstract="true" substitutionGroup="kindTest"/>

  <xsd:element name="schemaElementTest" type="QName" substitutionGroup="anyElementTest"/>

  <xsd:element name="elementTest" substitutionGroup="anyElementTest">
    <xsd:complexType>
      <xsd:complexContent>
        <xsd:extension base="emptyItemTypeContent">
          <xsd:sequence minOccurs="0">
            <xsd:element name="elementName" type="simpleWildcard"/>
            <xsd:sequence minOccurs="0">
              <xsd:element name="typeName" type="QName"/>
              <xsd:element name="nillable" type="emptyContent" minOccurs="0"/>
            </xsd:sequence>
          </xsd:sequence>
        </xsd:extension>
      </xsd:complexContent>
    </xsd:complexType>
  </xsd:element>

  <xsd:element name="documentTest" substitutionGroup="kindTest">
    <xsd:complexType>
      <xsd:complexContent>
        <xsd:extension base="emptyItemTypeContent">
          <xsd:sequence>
             <xsd:element ref="anyElementTest" minOccurs="0"/>
          </xsd:sequence>
        </xsd:extension>
      </xsd:complexContent>
    </xsd:complexType>
  </xsd:element>

  <xsd:element name="piTest" substitutionGroup="kindTest">
    <xsd:complexType>
      <xsd:complexContent>
        <xsd:extension base="emptyItemTypeContent">
          <xsd:sequence>
            <xsd:element name="piTarget" type="xsd:NCName" minOccurs="0"/>
          </xsd:sequence>
        </xsd:extension>
      </xsd:complexContent>
    </xsd:complexType>
  </xsd:element>


  <xsd:element name="nameTest" type="QName"/>

  <xsd:element name="kindTest" substitutionGroup="itemType"/>

  <xsd:element name="textTest" type="emptyItemTypeContent" substitutionGroup="kindTest"/>

  <xsd:element name="commentTest" type="emptyItemTypeContent" substitutionGroup="kindTest"/>

  <xsd:element name="anyKindTest" type="emptyItemTypeContent" substitutionGroup="kindTest"/>


  <xsd:element name="xpathAxis">
    <xsd:simpleType>
      <xsd:restriction base="xsd:NMTOKEN">
        <xsd:enumeration value="child"/>
        <xsd:enumeration value="attribute"/>
        <xsd:enumeration value="self"/>
        <xsd:enumeration value="parent"/>
        <xsd:enumeration value="descendant-or-self"/>
        <xsd:enumeration value="descendant"/>
        <xsd:enumeration value="following"/>
        <xsd:enumeration value="following-sibling"/>
        <xsd:enumeration value="ancestor"/>
        <xsd:enumeration value="ancestor-or-self"/>
        <xsd:enumeration value="preceding"/>
        <xsd:enumeration value="preceding-sibling"/>
      </xsd:restriction>
    </xsd:simpleType>
  </xsd:element>

  <xsd:element name="parenthesizedExpr" type="exprWrapperOptional"/>


  <xsd:group name="filterExpr">
    <xsd:choice>
      <xsd:element ref="constantExpr"/>
      <xsd:element ref="varRef"/>
      <xsd:element ref="contextItemExpr"/>
      <xsd:element ref="functionCallExpr"/>
      <xsd:element ref="parenthesizedExpr"/>
      <xsd:element ref="elementConstructor"/>
      <xsd:element ref="computedElementConstructor"/>
      <xsd:element ref="computedAttributeConstructor"/>
      <xsd:element ref="computedDocumentConstructor"/>
      <xsd:element ref="computedTextConstructor"/>
      <xsd:element ref="computedCommentConstructor"/>
      <xsd:element ref="computedPIConstructor"/>
      <xsd:element ref="orderedExpr"/>
      <xsd:element ref="unorderedExpr"/>
    </xsd:choice>
  </xsd:group>

  <!-- removed nameTest and Wildcard outer choices per Bugzilla Bug #2523 -->
  <xsd:element name="stepExpr">
    <xsd:complexType>
      <xsd:sequence>
        <xsd:choice>
          <xsd:sequence>
            <xsd:element ref="xpathAxis"/>
            <xsd:choice>
              <xsd:element ref="kindTest"/>
              <xsd:element ref="nameTest"/>
              <xsd:element ref="Wildcard"/>
             </xsd:choice>
          </xsd:sequence>
          <xsd:element name="filterExpr">
            <xsd:complexType>
              <xsd:sequence>
                <xsd:group ref="filterExpr"/>
              </xsd:sequence>
            </xsd:complexType>
          </xsd:element>
        </xsd:choice>
        <xsd:element name="predicates" type="exprList" minOccurs="0"/>
      </xsd:sequence>
    </xsd:complexType>
  </xsd:element>

  <!-- rewrote pathExpr definition per Bugzilla Bug #2523 -->
  <xsd:complexType name="pathExpr">
    <xsd:complexContent>
      <xsd:extension base="expr">
        <xsd:choice>
          <xsd:sequence>
            <xsd:element name="rootExpr" type="emptyContent"/>
            <xsd:element ref="stepExpr" minOccurs="0" maxOccurs="unbounded"/>
          </xsd:sequence>
          <xsd:element ref="stepExpr" maxOccurs="unbounded"/>
        </xsd:choice>
      </xsd:extension>
    </xsd:complexContent>
  </xsd:complexType>

  <xsd:element name="pathExpr" type="pathExpr" substitutionGroup="expr"/>

  <!-- The following constructs deal with the query prolog -->
  <xsd:element name="module">
    <xsd:complexType>
      <xsd:sequence>
        <xsd:element ref="versionDecl" minOccurs="0"/>
        <xsd:choice>
          <xsd:element ref="mainModule"/>
          <xsd:element ref="libraryModule"/>
        </xsd:choice>
      </xsd:sequence>
    </xsd:complexType>
  </xsd:element>

  <xsd:element name="mainModule">
    <xsd:complexType>
      <xsd:sequence>
        <xsd:element ref="prolog" minOccurs="0"/>
        <xsd:element name="queryBody" type="exprWrapper"/>
      </xsd:sequence>
    </xsd:complexType>
  </xsd:element>

  <xsd:complexType name="namespaceDeclType">
    <xsd:sequence>
      <xsd:element name="prefix" type="xsd:NCName"/>
      <xsd:element name="uri" type="xsd:string"/>
    </xsd:sequence>
  </xsd:complexType>

  <xsd:element name="namespaceDecl" type="namespaceDeclType"/>

  <xsd:element name="moduleDecl" type="namespaceDeclType"/>

  <xsd:element name="libraryModule">
    <xsd:complexType>
      <xsd:sequence>
        <xsd:element ref="moduleDecl"/>
        <xsd:element ref="prolog" minOccurs="0"/>
      </xsd:sequence>
    </xsd:complexType>
  </xsd:element>

  <xsd:element name="versionDecl">
    <xsd:complexType>
      <xsd:sequence>
        <xsd:element name="version" type="xsd:string"/>
      </xsd:sequence>
    </xsd:complexType>
  </xsd:element>

  <xsd:element name="prolog">
    <xsd:complexType>
      <xsd:sequence>
        <xsd:choice minOccurs="0" maxOccurs="unbounded">
          <xsd:element ref="defaultCollationDecl"/>
          <xsd:element ref="baseUriDecl"/>
          <xsd:element ref="constructionDecl"/>
          <xsd:element ref="orderingModeDecl"/>
          <xsd:element ref="emptyOrderingDecl"/>
          <xsd:element ref="copyNamespacesDecl"/>
          <xsd:element ref="defaultNamespaceDecl"/>
          <xsd:element ref="namespaceDecl"/>
          <xsd:element ref="schemaImport"/>
          <xsd:element ref="moduleImport"/>
        </xsd:choice>
        <xsd:choice minOccurs="0" maxOccurs="unbounded">
          <xsd:element ref="varDecl"/>
          <xsd:element ref="functionDecl"/>
          <xsd:element ref="optionDecl"/>
        </xsd:choice>
      </xsd:sequence>
    </xsd:complexType>
  </xsd:element>

  <xsd:element name="defaultCollationDecl" type="xsd:string"/>

  <xsd:element name="baseUriDecl" type="xsd:string"/>

  <xsd:element name="orderingModeDecl">
    <xsd:simpleType>
      <xsd:restriction base="xsd:NMTOKEN">
        <xsd:enumeration value="ordered"/>
        <xsd:enumeration value="unordered"/>
      </xsd:restriction>
    </xsd:simpleType>
  </xsd:element>

  <xsd:element name="emptyOrderingDecl" type="emptyOrderingMode"/>

  <xsd:element name="constructionDecl">
    <xsd:simpleType>
      <xsd:restriction base="xsd:NMTOKEN">
        <xsd:enumeration value="strip"/>
        <xsd:enumeration value="preserve"/>
      </xsd:restriction>
    </xsd:simpleType>
  </xsd:element>

  <xsd:element name="copyNamespacesDecl">
    <xsd:complexType>
      <xsd:sequence>
        <xsd:element name="preserveMode">
          <xsd:simpleType>
            <xsd:restriction base="xsd:NMTOKEN">
              <xsd:enumeration value="preserve"/>
              <xsd:enumeration value="no-preserve"/>
            </xsd:restriction>
          </xsd:simpleType>
        </xsd:element>
        <xsd:element name="inheritMode">
          <xsd:simpleType>
            <xsd:restriction base="xsd:NMTOKEN">
              <xsd:enumeration value="inherit"/>
              <xsd:enumeration value="no-inherit"/>
            </xsd:restriction>
          </xsd:simpleType>
        </xsd:element>
      </xsd:sequence>
    </xsd:complexType>
  </xsd:element>

  <xsd:simpleType name="defaultNamespaceCategory">
    <xsd:restriction base="xsd:NMTOKEN">
      <xsd:enumeration value="function"/>
      <xsd:enumeration value="element"/>
    </xsd:restriction>
  </xsd:simpleType>

  <xsd:element name="defaultNamespaceDecl">
    <xsd:complexType>
      <xsd:sequence>
        <xsd:element name="defaultNamespaceCategory" type="defaultNamespaceCategory"/>
        <xsd:element name="uri" type="xsd:string"/>
      </xsd:sequence>
    </xsd:complexType>
  </xsd:element>

  <xsd:element name="varDecl">
    <xsd:complexType>
      <xsd:sequence>
        <xsd:element name="varName" type="QName"/>
        <xsd:element ref="typeDeclaration" minOccurs="0"/>
        <xsd:choice>
          <xsd:element name="varValue" type="exprWrapper"/>
          <xsd:element name="external" type="emptyContent"/>
        </xsd:choice>
      </xsd:sequence>
    </xsd:complexType>
  </xsd:element>

  <xsd:element name="optionDecl">
    <xsd:complexType>
      <xsd:sequence>
        <xsd:element name="optionName" type="QName"/>
        <xsd:element name="optionContents" type="xsd:string"/>
      </xsd:sequence>
    </xsd:complexType>
  </xsd:element>

  <xsd:element name="param">
    <xsd:complexType>
      <xsd:sequence>
        <xsd:element name="varName" type="QName"/>
        <xsd:element ref="typeDeclaration" minOccurs="0"/>
      </xsd:sequence>
    </xsd:complexType>
  </xsd:element>

  <xsd:element name="paramList">
    <xsd:complexType>
      <xsd:sequence>
        <xsd:element ref="param" minOccurs="0" maxOccurs="unbounded"/>
      </xsd:sequence>
    </xsd:complexType>
  </xsd:element>

  <xsd:element name="functionDecl">
    <xsd:complexType>
      <xsd:sequence>
        <xsd:element name="functionName" type="QName"/>
        <xsd:element ref="paramList"/>
        <xsd:element ref="typeDeclaration" minOccurs="0"/>
        <xsd:choice>
          <xsd:element name="functionBody" type="exprWrapper"/>
          <xsd:element name="externalDefinition" type="emptyContent"/>
        </xsd:choice>
      </xsd:sequence>
    </xsd:complexType>
  </xsd:element>

  <xsd:element name="moduleImport">
    <xsd:complexType>
      <xsd:sequence>
        <xsd:element name="namespacePrefix" type="xsd:NCName" minOccurs="0"/>
        <xsd:element name="targetNamespace" type="xsd:string"/>
        <xsd:element name="targetLocation" type="xsd:string" minOccurs="0" maxOccurs="unbounded"/>
      </xsd:sequence>
    </xsd:complexType>
  </xsd:element>

  <xsd:element name="schemaImport">
    <xsd:complexType>
      <xsd:sequence>
        <xsd:choice minOccurs="0">
          <xsd:element name="namespacePrefix" type="xsd:NCName"/>
          <xsd:element name="defaultElementNamespace" type="emptyContent"/>
        </xsd:choice>
        <xsd:element name="targetNamespace" type="xsd:string"/>
        <xsd:element name="targetLocation" type="xsd:string" minOccurs="0" maxOccurs="unbounded"/>
      </xsd:sequence>
    </xsd:complexType>
  </xsd:element>

  <!-- The element below handles the trivial XQuery embedding -->
  <xsd:element name="xquery" type="xsd:string"/>

</xsd:schema>