<?xml version = "1.0" encoding = "UTF-8"?>
<xs:schema xmlns="http://www.imsglobal.org/xsd/imsqti_v2p1"
     targetNamespace="http://www.imsglobal.org/xsd/imsqti_v2p1"
     xmlns:xi="http://www.w3.org/2001/XInclude"
     xmlns:m="http://www.w3.org/1998/Math/MathML"
     xmlns:apip="http://www.imsglobal.org/xsd/apip/apipv1p0/imsapip_qtiv1p0"
     xmlns:xs="http://www.w3.org/2001/XMLSchema"
     xmlns:sch="http://purl.oclc.org/dsdl/schematron"
     version="IMS QTI 2.1.1"
     elementFormDefault="qualified"
     attributeFormDefault="unqualified">
    <xs:import namespace="http://www.w3.org/XML/1998/namespace" schemaLocation="xsd/xml.xsd" />
    <xs:import namespace="http://www.w3.org/2001/XInclude" schemaLocation="xsd/XInclude.xsd" />
    <xs:import namespace="http://www.w3.org/1998/Math/MathML" schemaLocation="mathml2/mathml2.xsd" />
    <xs:import namespace="http://www.imsglobal.org/xsd/apip/apipv1p0/imsapip_qtiv1p0" schemaLocation="xsd/apipv1p0_qtiextv2p1_v1p0.xsd" />

    <xs:annotation>
        <xs:documentation>
            XSD Data File Information
            =========================
            Author:         Colin Smythe (IMS Global)
            Date:           6th October, 2016
            Version:        2.1.2
            Status:         Final Release
            Description:    This is the Platform Specific Model of the IMS QTI v2.1 Specification Information Model.
                            It is this representation that is used to produce the XSD binding for IMS QTI v2.1.

            History:        Version 2.1.0: Supercedes the full IMS QTI v1.2 and QTIv2.0 specifications;
                            Version 2.1.1: The changes in this release are:-
                            (a) ChoiceInteraction, GraphicOrderInteraction, HotspotInteraction, PositionObjectInteraction, SelectPointInteraction, 
                            OrderInteraction, HotTextInteraction - minChoices and maxChoices attributes datatype made 'nonNegativeInteger'
                            (b) AssociableHotspot, GapText, GapImg, SimpleAssociableInteraction - matchMin and matchMax attributes datatype made 'nonNegativeInteger'
                            (c) GraphicAssociateInteraction, MatchInteraction, AssociateInteractions - 
                            minAssociations and maxAssociations attributes datatype made 'nonNegativeInteger'
                            (d) MediaInteraction - minPlays and maxPlays attributes datatype made 'nonNegativeInteger'
                            (e) SliderInteraction - lowerBound, upperBound and step attributes datatype made 'NonNegativeDouble'
                            (f) ExtendedTextInteraction - minStrings, maxStrings, expectedLength and expectedLines attributes datatype made 'nonNegativeInteger'
                            (g) TimeLimits - minTime and maxTime attributes datatype made 'NonNegativeDouble'
                            Version 2.1.2: The changes in this release are:-
                            (a) Remove String256 and replace with NormalizedString
                            (b) Correct the minChoices/MaxChoices schematron rule for ChoiceInteraction
                            (c) Replace 'id' for 'name' attribute in the 'pattern' element within the schematron rules
                            (d) Replace spaces in the values for the 'id' attribute with underscore.

            License:        IPR and Distribution Notices

                            This machine readable file is derived from IMS Global specification IMS Question and Test Interoperability (QTI) Version 2.1
                            found at http://www.imsglobal.org/qti and the original IMS Global schema binding or code base
                            http://www.imsglobal.org/qti.

                            Recipients of this document are requested to submit, with their comments, notification of any relevant 
                            patent claims or other intellectual property rights of which they may be aware that might be infringed by
                            any implementation of the specification set forth in this document, and to provide supporting documentation.

                            IMS takes no position regarding the validity or scope of any intellectual property or other rights that might
                            be claimed to pertain to the implementation or use of the technology described in this document or the extent 
                            to which any license under such rights might or might not be available; neither does it represent that it has 
                            made any effort to identify any such rights. Information on IMS procedures with respect to rights in IMS 
                            specifications can be found at the IMS Global Intellectual Property Rights web page: http://www.imsglobal.org/ipr/imsipr_policyFinal.pdf.

                            Copyright (c) IMS Global Learning Consortium 1999-2016. All Rights Reserved.

                            Use of this specification to develop products or services is governed by the license with IMS found on the IMS website: http://www.imsglobal.org/license.html.

                            Permission is granted to all parties to use excerpts from this document as needed in producing requests for proposals.

                            The limited permissions granted above are perpetual and will not be revoked by IMS or its successors or assigns.

                            THIS SPECIFICATION IS BEING OFFERED WITHOUT ANY WARRANTY WHATSOEVER, AND IN PARTICULAR, ANY WARRANTY OF NONINFRINGEMENT IS
                            EXPRESSLY DISCLAIMED. ANY USE OF THIS SPECIFICATION SHALL BE MADE ENTIRELY AT THE IMPLEMENTERS OWN RISK, AND NEITHER THE CONSORTIUM
                            NOR ANY OF ITS MEMBERS OR SUBMITTERS, SHALL HAVE ANY LIABILITY WHATSOEVER TO ANY IMPLEMENTER OR THIRD PARTY FOR ANY DAMAGES OF
                            ANY NATURE WHATSOEVER, DIRECTLY OR INDIRECTLY, ARISING FROM THE USE OF THIS SPECIFICATION.

            Source UML File Information
            ===========================
            The source file information must be supplied as an XMI file (without diagram layout information).
            The supported UML authoring tools are:
            (a) Poseidon - v6 (and later)
            (b) Papyrus - v1.1.3 (and later)

            Source XSLT File Information
            ============================
            XSL Generator:    Specificationv1p0_GenerationToolv1.xsl
            XSLT Processor:   Saxon-EE-9.6.0.7
            Release:          1.0
            Date:             31st January, 2016
            Autogen Engineer: Colin Smythe (IMS Global, UK)
            Autogen Date:     2016-10-14

            IMS Global Auto-generation Binding Tool-kit (I-BAT)
            ===================================================
            This file was auto-generated using the IMS Global Binding Auto-generation Tool-kit (I-BAT).  While every
            attempt has been made to ensure that this tool auto-generates the files correctly, users should be aware
            that this is an experimental tool.  Permission is given to make use of this tool.  IMS Global makes no
            claim on the materials created by third party users of this tool.  Details on how to use this tool
            are contained in the IMS Global "I-BAT" documentation available at the IMS Global web-site:
            http://www.imsglobal.org.

            Tool Copyright:  2012-2016  (c) IMS Global Learning Consortium Inc.  All Rights Reserved.
        </xs:documentation>
    </xs:annotation>

    <xs:annotation>
        <xs:documentation>
            Definition of Schematron Validation Rules
            =========================================
            Author:         Colin Smythe (IMS Global)
            Date:           31st July, 2013
            Version:        1.0
            Status:         Final Release

            Description:    This is the set of Schematron Rules to further enforce the QTIv2.1 Information Model. The rule sets that have been defined are:

                            [RULE_SET_GENERAL_1] Ensure that certain expressions are NOT used for Response Processing.
                            [RULE_SET_GENERAL_2] Ensure that the Item, Section, Test and TestPart identifiers are unique.
                            [RULE_SET_GENERAL_3] Ensure that AssessmentItem Response Declarations are correct.
                            [RULE_SET_INTERACTION_1] Enforce the correct use the TextEntryInteraction attributes.
                            [RULE_SET_INTERACTION_2] Enforce the correct use the ChoiceInteraction attributes.
                            [RULE_SET_INTERACTION_3] Enforce the correct use the ExtendedTextInteraction attributes.
                            [RULE_SET_INTERACTION_4] Enforce the correct use the HotspotInteraction attributes.
                            [RULE_SET_INTERACTION_5] Enforce the correct use the GraphicOrderInteraction attributes.
                            [RULE_SET_INTERACTION_6] Enforce the correct use the PositionObjectInteraction attributes.
                            [RULE_SET_INTERACTION_7] Enforce the correct use the SelectPointInteraction attributes.
                            [RULE_SET_INTERACTION_8] Enforce the correct use the OrderInteraction attributes.
                            [RULE_SET_INTERACTION_9] Enforce the correct use the HotTextInteraction attributes.

                            RULE_SET_GENERAL_1: Ensure that certain expressions are NOT used for Response Processing. The set of rules are:-
                            * RULE GENERAL 1a-Assertion 1 :- The expression numberCorrect must NOT be used in Response Processing.
                            * RULE GENERAL 1a-Assertion 2 :- The expression numberIncorrect must NOT be used in Response Processing.
                            * RULE GENERAL 1a-Assertion 3 :- The expression numberPresented must NOT be used in Response Processing.
                            * RULE GENERAL 1a-Assertion 4 :- The expression numberResponded must NOT be used in Response Processing.
                            * RULE GENERAL 1a-Assertion 5 :- The expression numberSelected must NOT be used in Response Processing.
                            * RULE GENERAL 1a-Assertion 6 :- The expression outcomeMinimum must NOT be used in Response Processing.
                            * RULE GENERAL 1a-Assertion 7 :- The expression outcomeMaximum must NOT be used in Response Processing.
                            * RULE GENERAL 1a-Assertion 8 :- The expression testVariables must NOT be used in Response Processing.

                            RULE_SET_GENERAL_2: Ensure that the Item, Section, Test and TestPart identifiers are unique. The set of rules are:-
                            * RULE GENERAL 2a-Assertion 1 :- The AssessmentTest and a TestPart must not have the same unique identifier.
                            * RULE GENERAL 2a-Assertion 2 :- The AssessmentTest and an AssessmentSection must not have the same unique identifier.
                            * RULE GENERAL 2a-Assertion 3 :- The AssessmentTest and a direct child AssessmentSectionRef must not have the same unique identifier.
                            * RULE GENERAL 2a-Assertion 4 :- The AssessmentTest and a descendant AssessmentSectionRef must not have the same unique identifier.
                            * RULE GENERAL 2a-Assertion 5 :- The AssessmentTest and a descendant AssessmentItemRef must not have the same unique identifier.
                            * RULE GENERAL 2b-Assertion 1 :- Two TestParts must not have the same unique identifier.
                            * RULE GENERAL 2b-Assertion 2 :- The TestPart and an AssessmentSection must not have the same unique identifier.
                            * RULE GENERAL 2b-Assertion 3 :- The TestPart and a direct child AssessmentSectionRef must not have the same unique identifier.
                            * RULE GENERAL 2b-Assertion 4 :- The TestPart and a descendant AssessmentSectionRef must not have the same unique identifier.
                            * RULE GENERAL 2b-Assertion 5 :- The TestPart and a descendant AssessmentItemRef must not have the same unique identifier.
                            * RULE GENERAL 2c-Assertion 1 :- Two AssessmentSection children of a TestPart must not have the same unique identifier.
                            * RULE GENERAL 2c-Assertion 2 :- The AssessmentSection and a descendant AssessmentSection must not have the same unique identifier.
                            * RULE GENERAL 2c-Assertion 3 :- The AssessmentSection and a descendant AssessmentSectionRef must not have the same unique identifier.
                            * RULE GENERAL 2c-Assertion 4 :- The AssessmentSection and a descendant AssessmentItemRef must not have the same unique identifier.

                            RULE_SET_GENERAL_3: Ensure that AssessmentItem Response Declarations are correct. The set of rules are:-
                            * RULE GENERAL 3a-Assertion 1 :- ***To be completed***..

                            RULE_SET_INTERACTION_1: Enforce the correct use the TextEntryInteraction attributes. The set of rules are:-
                            * RULE INTERACTION 1a-Assertion 1 :- The StringIdentifier and ResponseIdentifier attribute values must not be the same.
                            * RULE INTERACTION 1b-Assertion 1 :- The baseType must have a value of either string or float or integer.

                            RULE_SET_INTERACTION_2: Enforce the correct use the ChoiceInteraction attributes. The set of rules are:-
                            * RULE INTERACTION 2a-Assertion 1 :- The MaxChoices attribute value, provided it is not 0, must not be less than the MinChoices value.

                            RULE_SET_INTERACTION_3: Enforce the correct use the ExtendedTextInteraction attributes. The set of rules are:-
                            * RULE INTERACTION 3a-Assertion 1 :- The StringIdentifier and ResponseIdentifier attribute values must not be the same.

                            RULE_SET_INTERACTION_4: Enforce the correct use the HotspotInteraction attributes. The set of rules are:-
                            * RULE INTERACTION 4a-Assertion 1 :- The MaxChoices attribute value must not be less than the MinChoices value.

                            RULE_SET_INTERACTION_5: Enforce the correct use the GraphicOrderInteraction attributes. The set of rules are:-
                            * RULE INTERACTION 5a-Assertion 1 :- The MaxChoices attribute value must not be less than the MinChoices value.

                            RULE_SET_INTERACTION_6: Enforce the correct use the PositionObjectInteraction attributes. The set of rules are:-
                            * RULE INTERACTION 6a-Assertion 1 :- The MaxChoices attribute value must not be less than the MinChoices value.

                            RULE_SET_INTERACTION_7: Enforce the correct use the SelectPointInteraction attributes. The set of rules are:-
                            * RULE INTERACTION 7a-Assertion 1 :- The MaxChoices attribute value must not be less than the MinChoices value.

                            RULE_SET_INTERACTION_8: Enforce the correct use the OrderInteraction attributes. The set of rules are:-
                            * RULE INTERACTION 8a-Assertion 1 :- The MaxChoices attribute value must not be less than the MinChoices value.

                            RULE_SET_INTERACTION_9: Enforce the correct use the HotTextInteraction attributes. The set of rules are:-
                            * RULE INTERACTION 9a-Assertion 1 :- The MaxChoices attribute value must not be less than the MinChoices value.

            History:        Version 1.0: The first set of schematron rules for the IMS Global QTIv2.1 specification.

        </xs:documentation>

        <xs:appinfo>
            <sch:ns uri="http://www.imsglobal.org/xsd/imsqti_v2p1" prefix="qti" />
            <sch:title>Schematron Validation Rules for QTI Specification v2.1.</sch:title>

            <!-- RULESET ******************************************************************* -->
            <sch:pattern abstract="false" id="RULE_SET_GENERAL_1">
                <sch:title>Ensure that certain expressions are NOT used for Response Processing.</sch:title>

                <sch:rule abstract="false" context="//qti:assessmentItem/qti:responseProcessing">
                    <sch:assert test="count(descendant::qti:numberCorrect) = 0">
                        [RULE GENERAL 1a: Assertion 1] The expression numberCorrect must NOT be used in Response Processing.<sch:value-of select="concat('The Assessment Item identifier is:', ../@identifier)" />
                    </sch:assert>
                    <sch:assert test="count(descendant::qti:numberIncorrect) = 0">
                        [RULE GENERAL 1a: Assertion 2] The expression numberIncorrect must NOT be used in Response Processing.<sch:value-of select="concat('The Assessment Item identifier is:', ../@identifier)" />
                    </sch:assert>
                    <sch:assert test="count(descendant::qti:numberPresented) = 0">
                        [RULE GENERAL 1a: Assertion 3] The expression numberPresented must NOT be used in Response Processing.<sch:value-of select="concat('The Assessment Item identifier is:', ../@identifier)" />
                    </sch:assert>
                    <sch:assert test="count(descendant::qti:numberResponded) = 0">
                        [RULE GENERAL 1a: Assertion 4] The expression numberResponded must NOT be used in Response Processing.<sch:value-of select="concat('The Assessment Item identifier is:', ../@identifier)" />
                    </sch:assert>
                    <sch:assert test="count(descendant::qti:numberSelected) = 0">
                        [RULE GENERAL 1a: Assertion 5] The expression numberSelected must NOT be used in Response Processing.<sch:value-of select="concat('The Assessment Item identifier is:', ../@identifier)" />
                    </sch:assert>
                    <sch:assert test="count(descendant::qti:outcomeMinimum) = 0">
                        [RULE GENERAL 1a: Assertion 6] The expression outcomeMinimum must NOT be used in Response Processing.<sch:value-of select="concat('The Assessment Item identifier is:', ../@identifier)" />
                    </sch:assert>
                    <sch:assert test="count(descendant::qti:outcomeMaximum) = 0">
                        [RULE GENERAL 1a: Assertion 7] The expression outcomeMaximum must NOT be used in Response Processing.<sch:value-of select="concat('The Assessment Item identifier is:', ../@identifier)" />
                    </sch:assert>
                    <sch:assert test="count(descendant::qti:testVariables) = 0">
                        [RULE GENERAL 1a: Assertion 8] The expression testVariables must NOT be used in Response Processing.<sch:value-of select="concat('The Assessment Item identifier is:', ../@identifier)" />
                    </sch:assert>
                </sch:rule>

            </sch:pattern>
            <!-- *************************************************************************** -->

            <!-- RULESET ******************************************************************* -->
            <sch:pattern abstract="false" id="RULE_SET_GENERAL_2">
                <sch:title>Ensure that the Item, Section, Test and TestPart identifiers are unique.</sch:title>

                <sch:rule abstract="false" context="//qti:assessmentTest">
                    <sch:assert test="not(@identifier=qti:testPart/@identifier)">
                        [RULE GENERAL 2a: Assertion 1] The AssessmentTest and a TestPart must not have the same unique identifier.<sch:value-of select="concat('The AssessmentTest identifier is:', @identifier)" />
                    </sch:assert>
                    <sch:assert test="not(@identifier=qti:testPart/descendant::qti:assessmentSection/@identifier)">
                        [RULE GENERAL 2a: Assertion 2] The AssessmentTest and an AssessmentSection must not have the same unique identifier.<sch:value-of select="concat('The AssessmentTest identifier is:', @identifier)" />
                    </sch:assert>
                    <sch:assert test="not(@identifier=qti:testPart/qti:assessmentSectionRef/@identifier)">
                        [RULE GENERAL 2a: Assertion 3] The AssessmentTest and a direct child AssessmentSectionRef must not have the same unique identifier.<sch:value-of select="concat('The AssessmentTest identifier is:', @identifier)" />
                    </sch:assert>
                    <sch:assert test="not(@identifier=qti:testPart/descendant::qti:assessmentSection/qti:assessmentSectionRef/@identifier)">
                        [RULE GENERAL 2a: Assertion 4] The AssessmentTest and a descendant AssessmentSectionRef must not have the same unique identifier.<sch:value-of select="concat('The AssessmentTest identifier is:', @identifier)" />
                    </sch:assert>
                    <sch:assert test="not(@identifier=qti:testPart/descendant::qti:assessmentSection/qti:assessmentItemRef/@identifier)">
                        [RULE GENERAL 2a: Assertion 5] The AssessmentTest and a descendant AssessmentItemRef must not have the same unique identifier.<sch:value-of select="concat('The AssessmentTest identifier is:', @identifier)" />
                    </sch:assert>
                </sch:rule>

                <sch:rule abstract="false" context="//qti:assessmentTest/qti:testPart">
                    <sch:assert test="not(@identifier=preceding-sibling::qti:testPart/@identifier)">
                        [RULE GENERAL 2b: Assertion 1] Two TestParts must not have the same unique identifier.<sch:value-of select="concat('The TestPart identifier is:', @identifier)" />
                    </sch:assert>
                    <sch:assert test="not(@identifier=descendant::qti:assessmentSection/@identifier)">
                        [RULE GENERAL 2b: Assertion 2] The TestPart and an AssessmentSection must not have the same unique identifier.<sch:value-of select="concat('The TestPart identifier is:', @identifier)" />
                    </sch:assert>
                    <sch:assert test="not(@identifier=qti:assessmentSectionRef/@identifier)">
                        [RULE GENERAL 2b: Assertion 3] The TestPart and a direct child AssessmentSectionRef must not have the same unique identifier.<sch:value-of select="concat('The TestPart identifier is:', @identifier)" />
                    </sch:assert>
                    <sch:assert test="not(@identifier=descendant::qti:assessmentSection/qti:assessmentSectionRef/@identifier)">
                        [RULE GENERAL 2b: Assertion 4] The TestPart and a descendant AssessmentSectionRef must not have the same unique identifier.<sch:value-of select="concat('The TestPart identifier is:', @identifier)" />
                    </sch:assert>
                    <sch:assert test="not(@identifier=descendant::qti:assessmentSection/qti:assessmentItemRef/@identifier)">
                        [RULE GENERAL 2b: Assertion 5] The TestPart and a descendant AssessmentItemRef must not have the same unique identifier.<sch:value-of select="concat('The TestPart identifier is:', @identifier)" />
                    </sch:assert>
                </sch:rule>

                <sch:rule abstract="false" context="//qti:assessmentTest/qti:testPart/qti:assessmentSection">
                    <sch:assert test="not(@identifier=preceding-sibling::qti:assessmentSection/@identifier)">
                        [RULE GENERAL 2c: Assertion 1] Two AssessmentSection children of a TestPart must not have the same unique identifier.<sch:value-of select="concat('The AssessmentSection identifier is:', @identifier)" />
                    </sch:assert>
                    <sch:assert test="not(@identifier=descendant::qti:assessmentSection/@identifier)">
                        [RULE GENERAL 2c: Assertion 2] The AssessmentSection and a descendant AssessmentSection must not have the same unique identifier.<sch:value-of select="concat('The AssessmentSection identifier is:', @identifier)" />
                    </sch:assert>
                    <sch:assert test="not(@identifier=descendant::qti:assessmentSectionRef/@identifier)">
                        [RULE GENERAL 2c: Assertion 3] The AssessmentSection and a descendant AssessmentSectionRef must not have the same unique identifier.<sch:value-of select="concat('The TestPart identifier is:', @identifier)" />
                    </sch:assert>
                    <sch:assert test="not(@identifier=descendant::qti:assessmentItemRef/@identifier)">
                        [RULE GENERAL 2c: Assertion 4] The AssessmentSection and a descendant AssessmentItemRef must not have the same unique identifier.<sch:value-of select="concat('The TestPart identifier is:', @identifier)" />
                    </sch:assert>
                </sch:rule>

            </sch:pattern>
            <!-- *************************************************************************** -->

            <!-- RULESET ******************************************************************* -->
            <sch:pattern abstract="false" id="RULE_SET_GENERAL_3">
                <sch:title>Ensure that AssessmentItem Response Declarations are correct.</sch:title>

                <sch:rule abstract="false" context="//qti:assessmentItem/qti:responseProcessing">
                    <sch:assert test="1=1">
                        [RULE GENERAL 3a: Assertion 1] ***To be completed***..<sch:value-of select="'***To be completed***'" />
                    </sch:assert>
                </sch:rule>

            </sch:pattern>
            <!-- *************************************************************************** -->

            <!-- RULESET ******************************************************************* -->
            <sch:pattern abstract="false" id="RULE_SET_INTERACTION_1">
                <sch:title>Enforce the correct use the TextEntryInteraction attributes.</sch:title>

                <sch:rule abstract="false" context="//qti:textEntryInteraction">
                    <sch:assert test="not(@stringIdentifier=@responseIdentifier)">
                        [RULE INTERACTION 1a: Assertion 1] The StringIdentifier and ResponseIdentifier attribute values must not be the same.<sch:value-of select="concat('The StringIdentifier value is:', @stringIdentifier)" />
                    </sch:assert>
                </sch:rule>

                <sch:rule abstract="false" context="//qti:textEntryInteraction[@responseIdentifier=//qti:responseDeclaration/@identifier]">
                    <sch:assert test="//qti:responseDeclaration[@baseType='string'] or //qti:responseDeclaration[@baseType='float'] or //qti:responseDeclaration[@baseType='integer']">
                        [RULE INTERACTION 1b: Assertion 1] The baseType must have a value of either string or float or integer.<sch:value-of select="concat('The BaseType value is:', //qti:responseDeclaration/@baseType)" />
                    </sch:assert>
                </sch:rule>

            </sch:pattern>
            <!-- *************************************************************************** -->

            <!-- RULESET ******************************************************************* -->
            <sch:pattern abstract="false" id="RULE_SET_INTERACTION_2">
                <sch:title>Enforce the correct use the ChoiceInteraction attributes.</sch:title>

                <sch:rule abstract="false" context="//qti:choiceInteraction">
                    <sch:assert test="not(not(@maxChoices=0) and @maxChoices &lt; @minChoices)">
                        [RULE INTERACTION 2a: Assertion 1] The MaxChoices attribute value, provided it is not 0, must not be less than the MinChoices value.<sch:value-of select="concat('The MaxChoices value is:', @maxChoices)" />
                    </sch:assert>
                </sch:rule>

            </sch:pattern>
            <!-- *************************************************************************** -->

            <!-- RULESET ******************************************************************* -->
            <sch:pattern abstract="false" id="RULE_SET_INTERACTION_3">
                <sch:title>Enforce the correct use the ExtendedTextInteraction attributes.</sch:title>

                <sch:rule abstract="false" context="//qti:extendedTextInteraction">
                    <sch:assert test="not(@stringIdentifier=@responseIdentifier)">
                        [RULE INTERACTION 3a: Assertion 1] The StringIdentifier and ResponseIdentifier attribute values must not be the same.<sch:value-of select="concat('The StringIdentifier value is:', @stringIdentifier)" />
                    </sch:assert>
                </sch:rule>

            </sch:pattern>
            <!-- *************************************************************************** -->

            <!-- RULESET ******************************************************************* -->
            <sch:pattern abstract="false" id="RULE_SET_INTERACTION_4">
                <sch:title>Enforce the correct use the HotspotInteraction attributes.</sch:title>

                <sch:rule abstract="false" context="//qti:hotspotInteraction">
                    <sch:assert test="not(@maxChoices &lt; @minChoices)">
                        [RULE INTERACTION 4a: Assertion 1] The MaxChoices attribute value must not be less than the MinChoices value.<sch:value-of select="concat('The MaxChoices value is:', @maxChoices)" />
                    </sch:assert>
                </sch:rule>

            </sch:pattern>
            <!-- *************************************************************************** -->

            <!-- RULESET ******************************************************************* -->
            <sch:pattern abstract="false" id="RULE_SET_INTERACTION_5">
                <sch:title>Enforce the correct use the GraphicOrderInteraction attributes.</sch:title>

                <sch:rule abstract="false" context="//qti:graphicOrderInteraction">
                    <sch:assert test="not(@maxChoices &lt; @minChoices)">
                        [RULE INTERACTION 5a: Assertion 1] The MaxChoices attribute value must not be less than the MinChoices value.<sch:value-of select="concat('The MaxChoices value is:', @maxChoices)" />
                    </sch:assert>
                </sch:rule>

            </sch:pattern>
            <!-- *************************************************************************** -->

            <!-- RULESET ******************************************************************* -->
            <sch:pattern abstract="false" id="RULE_SET_INTERACTION_6">
                <sch:title>Enforce the correct use the PositionObjectInteraction attributes.</sch:title>

                <sch:rule abstract="false" context="//qti:positionObjectInteraction">
                    <sch:assert test="not(@maxChoices &lt; @minChoices)">
                        [RULE INTERACTION 6a: Assertion 1] The MaxChoices attribute value must not be less than the MinChoices value.<sch:value-of select="concat('The MaxChoices value is:', @maxChoices)" />
                    </sch:assert>
                </sch:rule>

            </sch:pattern>
            <!-- *************************************************************************** -->

            <!-- RULESET ******************************************************************* -->
            <sch:pattern abstract="false" id="RULE_SET_INTERACTION_7">
                <sch:title>Enforce the correct use the SelectPointInteraction attributes.</sch:title>

                <sch:rule abstract="false" context="//qti:selectPointInteraction">
                    <sch:assert test="not(@maxChoices &lt; @minChoices)">
                        [RULE INTERACTION 7a: Assertion 1] The MaxChoices attribute value must not be less than the MinChoices value.<sch:value-of select="concat('The MaxChoices value is:', @maxChoices)" />
                    </sch:assert>
                </sch:rule>

            </sch:pattern>
            <!-- *************************************************************************** -->

            <!-- RULESET ******************************************************************* -->
            <sch:pattern abstract="false" id="RULE_SET_INTERACTION_8">
                <sch:title>Enforce the correct use the OrderInteraction attributes.</sch:title>

                <sch:rule abstract="false" context="//qti:orderInteraction">
                    <sch:assert test="not(@maxChoices &lt; @minChoices)">
                        [RULE INTERACTION 8a: Assertion 1] The MaxChoices attribute value must not be less than the MinChoices value.<sch:value-of select="concat('The MaxChoices value is:', @maxChoices)" />
                    </sch:assert>
                </sch:rule>

            </sch:pattern>
            <!-- *************************************************************************** -->

            <!-- RULESET ******************************************************************* -->
            <sch:pattern abstract="false" id="RULE_SET_INTERACTION_9">
                <sch:title>Enforce the correct use the HotTextInteraction attributes.</sch:title>

                <sch:rule abstract="false" context="//qti:hottextInteraction">
                    <sch:assert test="not(@maxChoices &lt; @minChoices)">
                        [RULE INTERACTION 9a: Assertion 1] The MaxChoices attribute value must not be less than the MinChoices value.<sch:value-of select="concat('The MaxChoices value is:', @maxChoices)" />
                    </sch:assert>
                </sch:rule>

            </sch:pattern>
            <!-- *************************************************************************** -->

        </xs:appinfo>
    </xs:annotation>

    <!-- Generate Global Attributes (non-assigned) ******************************************************** -->

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

    <!-- Generate Global Attributes *********************************************************************** -->

    <xs:attributeGroup name="class.A.Attr">
        <xs:attribute name="class" use="optional">
            <xs:simpleType>
                <xs:list itemType="StringList.Type" />
            </xs:simpleType>
        </xs:attribute>
    </xs:attributeGroup>

    <xs:attributeGroup name="href.A.Attr">
        <xs:attribute name="href" use="required" type="xs:anyURI" />
    </xs:attributeGroup>

    <xs:attributeGroup name="id.A.Attr">
        <xs:attribute name="id" use="optional" type="UniqueIdentifier.Type" />
    </xs:attributeGroup>

    <xs:attributeGroup name="label.A.Attr">
        <xs:attribute name="label" use="optional" type="xs:string" />
    </xs:attributeGroup>

    <xs:attributeGroup name="type.A.Attr">
        <xs:attribute name="type" use="optional" type="MimeType.Type" />
    </xs:attributeGroup>

    <xs:attributeGroup name="xmlbase.A.Attr">
        <xs:attribute ref="xml:base" use="optional" />
    </xs:attributeGroup>

    <xs:attributeGroup name="xmllang.A.Attr">
        <xs:attribute ref="xml:lang" use="optional" />
    </xs:attributeGroup>

    <xs:attributeGroup name="max.AnyN.Attr">
        <xs:attribute name="max" use="required">
            <xs:simpleType>
                <xs:union>
                    <xs:simpleType>
                        <xs:restriction base="xs:integer" />
                    </xs:simpleType>
                    <xs:simpleType>
                        <xs:restriction base="VariableString.Type" />
                    </xs:simpleType>
                </xs:union>
            </xs:simpleType>
        </xs:attribute>
    </xs:attributeGroup>

    <xs:attributeGroup name="min.AnyN.Attr">
        <xs:attribute name="min" use="required">
            <xs:simpleType>
                <xs:union>
                    <xs:simpleType>
                        <xs:restriction base="xs:integer" />
                    </xs:simpleType>
                    <xs:simpleType>
                        <xs:restriction base="VariableString.Type" />
                    </xs:simpleType>
                </xs:union>
            </xs:simpleType>
        </xs:attribute>
    </xs:attributeGroup>

    <xs:attributeGroup name="coords.AreaMapEntry.Attr">
        <xs:attribute name="coords" use="required" type="xs:normalizedString" />
    </xs:attributeGroup>

    <xs:attributeGroup name="mappedValue.AreaMapEntry.Attr">
        <xs:attribute name="mappedValue" use="required" type="xs:double" />
    </xs:attributeGroup>

    <xs:attributeGroup name="shape.AreaMapEntry.Attr">
        <xs:attribute name="shape" use="required">
            <xs:simpleType>
                <xs:restriction base="xs:string">
                    <xs:enumeration value="circle" />
                    <xs:enumeration value="default" />
                    <xs:enumeration value="ellipse" />
                    <xs:enumeration value="poly" />
                    <xs:enumeration value="rect" />
                </xs:restriction>
            </xs:simpleType>
        </xs:attribute>
    </xs:attributeGroup>

    <xs:attributeGroup name="defaultValue.AreaMapping.Attr">
        <xs:attribute name="defaultValue" use="optional" default="0" type="xs:double" />
    </xs:attributeGroup>

    <xs:attributeGroup name="lowerBound.AreaMapping.Attr">
        <xs:attribute name="lowerBound" use="optional" type="xs:double" />
    </xs:attributeGroup>

    <xs:attributeGroup name="upperBound.AreaMapping.Attr">
        <xs:attribute name="upperBound" use="optional" type="xs:double" />
    </xs:attributeGroup>

    <xs:attributeGroup name="adaptive.AssessmentItem.Attr">
        <xs:attribute name="adaptive" use="optional" default="false" type="xs:boolean" />
    </xs:attributeGroup>

    <xs:attributeGroup name="identifier.AssessmentItem.Attr">
        <xs:attribute name="identifier" use="required" type="xs:normalizedString" />
    </xs:attributeGroup>

    <xs:attributeGroup name="label.AssessmentItem.Attr">
        <xs:attribute name="label" use="optional" type="xs:string" />
    </xs:attributeGroup>

    <xs:attributeGroup name="timeDependent.AssessmentItem.Attr">
        <xs:attribute name="timeDependent" use="required" type="xs:boolean" />
    </xs:attributeGroup>

    <xs:attributeGroup name="title.AssessmentItem.Attr">
        <xs:attribute name="title" use="required" type="xs:normalizedString" />
    </xs:attributeGroup>

    <xs:attributeGroup name="toolName.AssessmentItem.Attr">
        <xs:attribute name="toolName" use="optional" type="xs:normalizedString" />
    </xs:attributeGroup>

    <xs:attributeGroup name="toolVersion.AssessmentItem.Attr">
        <xs:attribute name="toolVersion" use="optional" type="xs:normalizedString" />
    </xs:attributeGroup>

    <xs:attributeGroup name="xmllang.AssessmentItem.Attr">
        <xs:attribute ref="xml:lang" use="optional" />
    </xs:attributeGroup>

    <xs:attributeGroup name="category.AssessmentItemRef.Attr">
        <xs:attribute name="category" use="optional">
            <xs:simpleType>
                <xs:list itemType="IdentifierList.Type" />
            </xs:simpleType>
        </xs:attribute>
    </xs:attributeGroup>

    <xs:attributeGroup name="fixed.AssessmentItemRef.Attr">
        <xs:attribute name="fixed" use="optional" default="false" type="xs:boolean" />
    </xs:attributeGroup>

    <xs:attributeGroup name="href.AssessmentItemRef.Attr">
        <xs:attribute name="href" use="required" type="xs:anyURI" />
    </xs:attributeGroup>

    <xs:attributeGroup name="identifier.AssessmentItemRef.Attr">
        <xs:attribute name="identifier" use="required" type="xs:normalizedString" />
    </xs:attributeGroup>

    <xs:attributeGroup name="required.AssessmentItemRef.Attr">
        <xs:attribute name="required" use="optional" default="false" type="xs:boolean" />
    </xs:attributeGroup>

    <xs:attributeGroup name="fixed.AssessmentSection.Attr">
        <xs:attribute name="fixed" use="optional" default="false" type="xs:boolean" />
    </xs:attributeGroup>

    <xs:attributeGroup name="identifier.AssessmentSection.Attr">
        <xs:attribute name="identifier" use="required" type="xs:normalizedString" />
    </xs:attributeGroup>

    <xs:attributeGroup name="keepTogether.AssessmentSection.Attr">
        <xs:attribute name="keepTogether" use="optional" default="true" type="xs:boolean" />
    </xs:attributeGroup>

    <xs:attributeGroup name="required.AssessmentSection.Attr">
        <xs:attribute name="required" use="optional" default="false" type="xs:boolean" />
    </xs:attributeGroup>

    <xs:attributeGroup name="title.AssessmentSection.Attr">
        <xs:attribute name="title" use="required" type="xs:normalizedString" />
    </xs:attributeGroup>

    <xs:attributeGroup name="visible.AssessmentSection.Attr">
        <xs:attribute name="visible" use="required" type="xs:boolean" />
    </xs:attributeGroup>

    <xs:attributeGroup name="href.AssessmentSectionRef.Attr">
        <xs:attribute name="href" use="required" type="xs:anyURI" />
    </xs:attributeGroup>

    <xs:attributeGroup name="identifier.AssessmentSectionRef.Attr">
        <xs:attribute name="identifier" use="required" type="xs:normalizedString" />
    </xs:attributeGroup>

    <xs:attributeGroup name="identifier.AssessmentTest.Attr">
        <xs:attribute name="identifier" use="required" type="xs:normalizedString" />
    </xs:attributeGroup>

    <xs:attributeGroup name="title.AssessmentTest.Attr">
        <xs:attribute name="title" use="required" type="xs:normalizedString" />
    </xs:attributeGroup>

    <xs:attributeGroup name="toolName.AssessmentTest.Attr">
        <xs:attribute name="toolName" use="optional" type="xs:string" />
    </xs:attributeGroup>

    <xs:attributeGroup name="toolVersion.AssessmentTest.Attr">
        <xs:attribute name="toolVersion" use="optional" type="xs:string" />
    </xs:attributeGroup>

    <xs:attributeGroup name="class.AssociableHotspot.Attr">
        <xs:attribute name="class" use="optional">
            <xs:simpleType>
                <xs:list itemType="StringList.Type" />
            </xs:simpleType>
        </xs:attribute>
    </xs:attributeGroup>

    <xs:attributeGroup name="coords.AssociableHotspot.Attr">
        <xs:attribute name="coords" use="required" type="xs:normalizedString" />
    </xs:attributeGroup>

    <xs:attributeGroup name="fixed.AssociableHotspot.Attr">
        <xs:attribute name="fixed" use="optional" default="false" type="xs:boolean" />
    </xs:attributeGroup>

    <xs:attributeGroup name="hotspotLabel.AssociableHotspot.Attr">
        <xs:attribute name="hotspotLabel" use="optional" type="xs:string" />
    </xs:attributeGroup>

    <xs:attributeGroup name="id.AssociableHotspot.Attr">
        <xs:attribute name="id" use="optional" type="UniqueIdentifier.Type" />
    </xs:attributeGroup>

    <xs:attributeGroup name="identifier.AssociableHotspot.Attr">
        <xs:attribute name="identifier" use="required" type="Identifier.Type" />
    </xs:attributeGroup>

    <xs:attributeGroup name="label.AssociableHotspot.Attr">
        <xs:attribute name="label" use="optional" type="xs:string" />
    </xs:attributeGroup>

    <xs:attributeGroup name="matchGroup.AssociableHotspot.Attr">
        <xs:attribute name="matchGroup" use="optional">
            <xs:simpleType>
                <xs:list itemType="IdentifierList.Type" />
            </xs:simpleType>
        </xs:attribute>
    </xs:attributeGroup>

    <xs:attributeGroup name="matchMax.AssociableHotspot.Attr">
        <xs:attribute name="matchMax" use="required" type="xs:nonNegativeInteger" />
    </xs:attributeGroup>

    <xs:attributeGroup name="matchMin.AssociableHotspot.Attr">
        <xs:attribute name="matchMin" use="optional" default="0" type="xs:nonNegativeInteger" />
    </xs:attributeGroup>

    <xs:attributeGroup name="shape.AssociableHotspot.Attr">
        <xs:attribute name="shape" use="required">
            <xs:simpleType>
                <xs:restriction base="xs:string">
                    <xs:enumeration value="circle" />
                    <xs:enumeration value="default" />
                    <xs:enumeration value="ellipse" />
                    <xs:enumeration value="poly" />
                    <xs:enumeration value="rect" />
                </xs:restriction>
            </xs:simpleType>
        </xs:attribute>
    </xs:attributeGroup>

    <xs:attributeGroup name="showHide.AssociableHotspot.Attr">
        <xs:attribute name="showHide" use="optional" default="show">
            <xs:simpleType>
                <xs:restriction base="xs:string">
                    <xs:enumeration value="show" />
                    <xs:enumeration value="hide" />
                </xs:restriction>
            </xs:simpleType>
        </xs:attribute>
    </xs:attributeGroup>

    <xs:attributeGroup name="templateIdentifier.AssociableHotspot.Attr">
        <xs:attribute name="templateIdentifier" use="optional" type="Identifier.Type" />
    </xs:attributeGroup>

    <xs:attributeGroup name="xmllang.AssociableHotspot.Attr">
        <xs:attribute ref="xml:lang" use="optional" />
    </xs:attributeGroup>

    <xs:attributeGroup name="class.AssociateInteraction.Attr">
        <xs:attribute name="class" use="optional">
            <xs:simpleType>
                <xs:list itemType="StringList.Type" />
            </xs:simpleType>
        </xs:attribute>
    </xs:attributeGroup>

    <xs:attributeGroup name="id.AssociateInteraction.Attr">
        <xs:attribute name="id" use="optional" type="UniqueIdentifier.Type" />
    </xs:attributeGroup>

    <xs:attributeGroup name="label.AssociateInteraction.Attr">
        <xs:attribute name="label" use="optional" type="xs:string" />
    </xs:attributeGroup>

    <xs:attributeGroup name="maxAssociations.AssociateInteraction.Attr">
        <xs:attribute name="maxAssociations" use="optional" default="1" type="xs:nonNegativeInteger" />
    </xs:attributeGroup>

    <xs:attributeGroup name="minAssociations.AssociateInteraction.Attr">
        <xs:attribute name="minAssociations" use="optional" default="0" type="xs:nonNegativeInteger" />
    </xs:attributeGroup>

    <xs:attributeGroup name="responseIdentifier.AssociateInteraction.Attr">
        <xs:attribute name="responseIdentifier" use="required" type="Identifier.Type" />
    </xs:attributeGroup>

    <xs:attributeGroup name="shuffle.AssociateInteraction.Attr">
        <xs:attribute name="shuffle" use="optional" default="false" type="xs:boolean" />
    </xs:attributeGroup>

    <xs:attributeGroup name="xmlbase.AssociateInteraction.Attr">
        <xs:attribute ref="xml:base" use="optional" />
    </xs:attributeGroup>

    <xs:attributeGroup name="xmllang.AssociateInteraction.Attr">
        <xs:attribute ref="xml:lang" use="optional" />
    </xs:attributeGroup>

    <xs:attributeGroup name="baseType.BaseValue.Attr">
        <xs:attribute name="baseType" use="required">
            <xs:simpleType>
                <xs:restriction base="xs:string">
                    <xs:enumeration value="boolean" />
                    <xs:enumeration value="directedPair" />
                    <xs:enumeration value="duration" />
                    <xs:enumeration value="file" />
                    <xs:enumeration value="float" />
                    <xs:enumeration value="identifier" />
                    <xs:enumeration value="integer" />
                    <xs:enumeration value="pair" />
                    <xs:enumeration value="point" />
                    <xs:enumeration value="string" />
                    <xs:enumeration value="uri" />
                </xs:restriction>
            </xs:simpleType>
        </xs:attribute>
    </xs:attributeGroup>

    <xs:attributeGroup name="cite.BlockQuote.Attr">
        <xs:attribute name="cite" use="optional" type="xs:anyURI" />
    </xs:attributeGroup>

    <xs:attributeGroup name="class.BlockQuote.Attr">
        <xs:attribute name="class" use="optional">
            <xs:simpleType>
                <xs:list itemType="StringList.Type" />
            </xs:simpleType>
        </xs:attribute>
    </xs:attributeGroup>

    <xs:attributeGroup name="id.BlockQuote.Attr">
        <xs:attribute name="id" use="optional" type="UniqueIdentifier.Type" />
    </xs:attributeGroup>

    <xs:attributeGroup name="label.BlockQuote.Attr">
        <xs:attribute name="label" use="optional" type="xs:string" />
    </xs:attributeGroup>

    <xs:attributeGroup name="xmlbase.BlockQuote.Attr">
        <xs:attribute ref="xml:base" use="optional" />
    </xs:attributeGroup>

    <xs:attributeGroup name="xmllang.BlockQuote.Attr">
        <xs:attribute ref="xml:lang" use="optional" />
    </xs:attributeGroup>

    <xs:attributeGroup name="class.BR.Attr">
        <xs:attribute name="class" use="optional">
            <xs:simpleType>
                <xs:list itemType="StringList.Type" />
            </xs:simpleType>
        </xs:attribute>
    </xs:attributeGroup>

    <xs:attributeGroup name="id.BR.Attr">
        <xs:attribute name="id" use="optional" type="UniqueIdentifier.Type" />
    </xs:attributeGroup>

    <xs:attributeGroup name="label.BR.Attr">
        <xs:attribute name="label" use="optional" type="xs:string" />
    </xs:attributeGroup>

    <xs:attributeGroup name="xmlbase.BR.Attr">
        <xs:attribute ref="xml:base" use="optional" />
    </xs:attributeGroup>

    <xs:attributeGroup name="xmllang.BR.Attr">
        <xs:attribute ref="xml:lang" use="optional" />
    </xs:attributeGroup>

    <xs:attributeGroup name="target.BranchRule.Attr">
        <xs:attribute name="target" use="required" type="Identifier.Type" />
    </xs:attributeGroup>

    <xs:attributeGroup name="class.Caption.Attr">
        <xs:attribute name="class" use="optional">
            <xs:simpleType>
                <xs:list itemType="StringList.Type" />
            </xs:simpleType>
        </xs:attribute>
    </xs:attributeGroup>

    <xs:attributeGroup name="id.Caption.Attr">
        <xs:attribute name="id" use="optional" type="UniqueIdentifier.Type" />
    </xs:attributeGroup>

    <xs:attributeGroup name="label.Caption.Attr">
        <xs:attribute name="label" use="optional" type="xs:string" />
    </xs:attributeGroup>

    <xs:attributeGroup name="xmllang.Caption.Attr">
        <xs:attribute ref="xml:lang" use="optional" />
    </xs:attributeGroup>

    <xs:attributeGroup name="class.ChoiceInteraction.Attr">
        <xs:attribute name="class" use="optional">
            <xs:simpleType>
                <xs:list itemType="StringList.Type" />
            </xs:simpleType>
        </xs:attribute>
    </xs:attributeGroup>

    <xs:attributeGroup name="id.ChoiceInteraction.Attr">
        <xs:attribute name="id" use="optional" type="UniqueIdentifier.Type" />
    </xs:attributeGroup>

    <xs:attributeGroup name="label.ChoiceInteraction.Attr">
        <xs:attribute name="label" use="optional" type="xs:string" />
    </xs:attributeGroup>

    <xs:attributeGroup name="maxChoices.ChoiceInteraction.Attr">
        <xs:attribute name="maxChoices" use="optional" default="0" type="xs:nonNegativeInteger" />
    </xs:attributeGroup>

    <xs:attributeGroup name="minChoices.ChoiceInteraction.Attr">
        <xs:attribute name="minChoices" use="optional" default="0" type="xs:nonNegativeInteger" />
    </xs:attributeGroup>

    <xs:attributeGroup name="orientation.ChoiceInteraction.Attr">
        <xs:attribute name="orientation" use="optional">
            <xs:simpleType>
                <xs:restriction base="xs:string">
                    <xs:enumeration value="horizontal" />
                    <xs:enumeration value="vertical" />
                </xs:restriction>
            </xs:simpleType>
        </xs:attribute>
    </xs:attributeGroup>

    <xs:attributeGroup name="responseIdentifier.ChoiceInteraction.Attr">
        <xs:attribute name="responseIdentifier" use="required" type="Identifier.Type" />
    </xs:attributeGroup>

    <xs:attributeGroup name="shuffle.ChoiceInteraction.Attr">
        <xs:attribute name="shuffle" use="optional" default="false" type="xs:boolean" />
    </xs:attributeGroup>

    <xs:attributeGroup name="xmlbase.ChoiceInteraction.Attr">
        <xs:attribute ref="xml:base" use="optional" />
    </xs:attributeGroup>

    <xs:attributeGroup name="xmllang.ChoiceInteraction.Attr">
        <xs:attribute ref="xml:lang" use="optional" />
    </xs:attributeGroup>

    <xs:attributeGroup name="class.Col.Attr">
        <xs:attribute name="class" use="optional">
            <xs:simpleType>
                <xs:list itemType="StringList.Type" />
            </xs:simpleType>
        </xs:attribute>
    </xs:attributeGroup>

    <xs:attributeGroup name="id.Col.Attr">
        <xs:attribute name="id" use="optional" type="UniqueIdentifier.Type" />
    </xs:attributeGroup>

    <xs:attributeGroup name="label.Col.Attr">
        <xs:attribute name="label" use="optional" type="xs:string" />
    </xs:attributeGroup>

    <xs:attributeGroup name="span.Col.Attr">
        <xs:attribute name="span" use="optional" type="xs:int" />
    </xs:attributeGroup>

    <xs:attributeGroup name="xmllang.Col.Attr">
        <xs:attribute ref="xml:lang" use="optional" />
    </xs:attributeGroup>

    <xs:attributeGroup name="class.ColGroup.Attr">
        <xs:attribute name="class" use="optional">
            <xs:simpleType>
                <xs:list itemType="StringList.Type" />
            </xs:simpleType>
        </xs:attribute>
    </xs:attributeGroup>

    <xs:attributeGroup name="id.ColGroup.Attr">
        <xs:attribute name="id" use="optional" type="UniqueIdentifier.Type" />
    </xs:attributeGroup>

    <xs:attributeGroup name="label.ColGroup.Attr">
        <xs:attribute name="label" use="optional" type="xs:string" />
    </xs:attributeGroup>

    <xs:attributeGroup name="span.ColGroup.Attr">
        <xs:attribute name="span" use="optional" type="xs:int" />
    </xs:attributeGroup>

    <xs:attributeGroup name="xmllang.ColGroup.Attr">
        <xs:attribute ref="xml:lang" use="optional" />
    </xs:attributeGroup>

    <xs:attributeGroup name="identifier.Correct.Attr">
        <xs:attribute name="identifier" use="required" type="Identifier.Type" />
    </xs:attributeGroup>

    <xs:attributeGroup name="interpretation.CorrectResponse.Attr">
        <xs:attribute name="interpretation" use="optional" type="xs:string" />
    </xs:attributeGroup>

    <xs:attributeGroup name="class.CustomInteraction.Attr">
        <xs:attribute name="class" use="optional">
            <xs:simpleType>
                <xs:list itemType="StringList.Type" />
            </xs:simpleType>
        </xs:attribute>
    </xs:attributeGroup>

    <xs:attributeGroup name="extension.CustomInteraction.Attr">
        <xs:anyAttribute namespace = "##other" processContents = "lax" />
    </xs:attributeGroup>

    <xs:attributeGroup name="id.CustomInteraction.Attr">
        <xs:attribute name="id" use="optional" type="UniqueIdentifier.Type" />
    </xs:attributeGroup>

    <xs:attributeGroup name="label.CustomInteraction.Attr">
        <xs:attribute name="label" use="optional" type="xs:string" />
    </xs:attributeGroup>

    <xs:attributeGroup name="responseIdentifier.CustomInteraction.Attr">
        <xs:attribute name="responseIdentifier" use="required" type="Identifier.Type" />
    </xs:attributeGroup>

    <xs:attributeGroup name="xmlbase.CustomInteraction.Attr">
        <xs:attribute ref="xml:base" use="optional" />
    </xs:attributeGroup>

    <xs:attributeGroup name="xmllang.CustomInteraction.Attr">
        <xs:attribute ref="xml:lang" use="optional" />
    </xs:attributeGroup>

    <xs:attributeGroup name="class.CustomOperator.Attr">
        <xs:attribute name="class" use="optional" type="Identifier.Type" />
    </xs:attributeGroup>

    <xs:attributeGroup name="definition.CustomOperator.Attr">
        <xs:attribute name="definition" use="optional" type="xs:anyURI" />
    </xs:attributeGroup>

    <xs:attributeGroup name="extension.CustomOperator.Attr">
        <xs:anyAttribute namespace = "##other" processContents = "lax" />
    </xs:attributeGroup>

    <xs:attributeGroup name="class.DD.Attr">
        <xs:attribute name="class" use="optional">
            <xs:simpleType>
                <xs:list itemType="StringList.Type" />
            </xs:simpleType>
        </xs:attribute>
    </xs:attributeGroup>

    <xs:attributeGroup name="id.DD.Attr">
        <xs:attribute name="id" use="optional" type="UniqueIdentifier.Type" />
    </xs:attributeGroup>

    <xs:attributeGroup name="label.DD.Attr">
        <xs:attribute name="label" use="optional" type="xs:string" />
    </xs:attributeGroup>

    <xs:attributeGroup name="xmlbase.DD.Attr">
        <xs:attribute ref="xml:base" use="optional" />
    </xs:attributeGroup>

    <xs:attributeGroup name="xmllang.DD.Attr">
        <xs:attribute ref="xml:lang" use="optional" />
    </xs:attributeGroup>

    <xs:attributeGroup name="identifier.Default.Attr">
        <xs:attribute name="identifier" use="required" type="Identifier.Type" />
    </xs:attributeGroup>

    <xs:attributeGroup name="interpretation.DefaultValue.Attr">
        <xs:attribute name="interpretation" use="optional" type="xs:normalizedString" />
    </xs:attributeGroup>

    <xs:attributeGroup name="class.Div.Attr">
        <xs:attribute name="class" use="optional">
            <xs:simpleType>
                <xs:list itemType="StringList.Type" />
            </xs:simpleType>
        </xs:attribute>
    </xs:attributeGroup>

    <xs:attributeGroup name="id.Div.Attr">
        <xs:attribute name="id" use="optional" type="UniqueIdentifier.Type" />
    </xs:attributeGroup>

    <xs:attributeGroup name="label.Div.Attr">
        <xs:attribute name="label" use="optional" type="xs:string" />
    </xs:attributeGroup>

    <xs:attributeGroup name="xmlbase.Div.Attr">
        <xs:attribute ref="xml:base" use="optional" />
    </xs:attributeGroup>

    <xs:attributeGroup name="xmllang.Div.Attr">
        <xs:attribute ref="xml:lang" use="optional" />
    </xs:attributeGroup>

    <xs:attributeGroup name="class.DL.Attr">
        <xs:attribute name="class" use="optional">
            <xs:simpleType>
                <xs:list itemType="StringList.Type" />
            </xs:simpleType>
        </xs:attribute>
    </xs:attributeGroup>

    <xs:attributeGroup name="id.DL.Attr">
        <xs:attribute name="id" use="optional" type="UniqueIdentifier.Type" />
    </xs:attributeGroup>

    <xs:attributeGroup name="label.DL.Attr">
        <xs:attribute name="label" use="optional" type="xs:string" />
    </xs:attributeGroup>

    <xs:attributeGroup name="xmlbase.DL.Attr">
        <xs:attribute ref="xml:base" use="optional" />
    </xs:attributeGroup>

    <xs:attributeGroup name="xmllang.DL.Attr">
        <xs:attribute ref="xml:lang" use="optional" />
    </xs:attributeGroup>

    <xs:attributeGroup name="class.DrawingInteraction.Attr">
        <xs:attribute name="class" use="optional">
            <xs:simpleType>
                <xs:list itemType="StringList.Type" />
            </xs:simpleType>
        </xs:attribute>
    </xs:attributeGroup>

    <xs:attributeGroup name="id.DrawingInteraction.Attr">
        <xs:attribute name="id" use="optional" type="Identifier.Type" />
    </xs:attributeGroup>

    <xs:attributeGroup name="label.DrawingInteraction.Attr">
        <xs:attribute name="label" use="optional" type="xs:string" />
    </xs:attributeGroup>

    <xs:attributeGroup name="responseIdentifier.DrawingInteraction.Attr">
        <xs:attribute name="responseIdentifier" use="required" type="Identifier.Type" />
    </xs:attributeGroup>

    <xs:attributeGroup name="xmlbase.DrawingInteraction.Attr">
        <xs:attribute ref="xml:base" use="optional" />
    </xs:attributeGroup>

    <xs:attributeGroup name="xmllang.DrawingInteraction.Attr">
        <xs:attribute ref="xml:lang" use="optional" />
    </xs:attributeGroup>

    <xs:attributeGroup name="class.DT.Attr">
        <xs:attribute name="class" use="optional">
            <xs:simpleType>
                <xs:list itemType="StringList.Type" />
            </xs:simpleType>
        </xs:attribute>
    </xs:attributeGroup>

    <xs:attributeGroup name="id.DT.Attr">
        <xs:attribute name="id" use="optional" type="UniqueIdentifier.Type" />
    </xs:attributeGroup>

    <xs:attributeGroup name="label.DT.Attr">
        <xs:attribute name="label" use="optional" type="xs:string" />
    </xs:attributeGroup>

    <xs:attributeGroup name="xmlbase.DT.Attr">
        <xs:attribute ref="xml:base" use="optional" />
    </xs:attributeGroup>

    <xs:attributeGroup name="xmllang.DT.Attr">
        <xs:attribute ref="xml:lang" use="optional" />
    </xs:attributeGroup>

    <xs:attributeGroup name="class.EndAttemptInteraction.Attr">
        <xs:attribute name="class" use="optional">
            <xs:simpleType>
                <xs:list itemType="StringList.Type" />
            </xs:simpleType>
        </xs:attribute>
    </xs:attributeGroup>

    <xs:attributeGroup name="countAttempt.EndAttemptInteraction.Attr">
        <xs:attribute name="countAttempt" use="optional" type="xs:boolean" />
    </xs:attributeGroup>

    <xs:attributeGroup name="id.EndAttemptInteraction.Attr">
        <xs:attribute name="id" use="optional" type="UniqueIdentifier.Type" />
    </xs:attributeGroup>

    <xs:attributeGroup name="label.EndAttemptInteraction.Attr">
        <xs:attribute name="label" use="optional" type="xs:string" />
    </xs:attributeGroup>

    <xs:attributeGroup name="responseIdentifier.EndAttemptInteraction.Attr">
        <xs:attribute name="responseIdentifier" use="required" type="Identifier.Type" />
    </xs:attributeGroup>

    <xs:attributeGroup name="title.EndAttemptInteraction.Attr">
        <xs:attribute name="title" use="required" type="xs:string" />
    </xs:attributeGroup>

    <xs:attributeGroup name="xmlbase.EndAttemptInteraction.Attr">
        <xs:attribute ref="xml:base" use="optional" />
    </xs:attributeGroup>

    <xs:attributeGroup name="xmllang.EndAttemptInteraction.Attr">
        <xs:attribute ref="xml:lang" use="optional" />
    </xs:attributeGroup>

    <xs:attributeGroup name="includeLowerBound.Equal.Attr">
        <xs:attribute name="includeLowerBound" use="optional" default="true" type="xs:boolean" />
    </xs:attributeGroup>

    <xs:attributeGroup name="includeUpperBound.Equal.Attr">
        <xs:attribute name="includeUpperBound" use="optional" default="true" type="xs:boolean" />
    </xs:attributeGroup>

    <xs:attributeGroup name="tolerance.Equal.Attr">
        <xs:attribute name="tolerance" use="optional">
            <xs:simpleType>
                <xs:list itemType="ToleranceList.Type" />
            </xs:simpleType>
        </xs:attribute>
    </xs:attributeGroup>

    <xs:attributeGroup name="toleranceMode.Equal.Attr">
        <xs:attribute name="toleranceMode" use="optional" default="exact">
            <xs:simpleType>
                <xs:restriction base="xs:string">
                    <xs:enumeration value="absolute" />
                    <xs:enumeration value="exact" />
                    <xs:enumeration value="relative" />
                </xs:restriction>
            </xs:simpleType>
        </xs:attribute>
    </xs:attributeGroup>

    <xs:attributeGroup name="figures.EqualRounded.Attr">
        <xs:attribute name="figures" use="required">
            <xs:simpleType>
                <xs:union>
                    <xs:simpleType>
                        <xs:restriction base="xs:integer" />
                    </xs:simpleType>
                    <xs:simpleType>
                        <xs:restriction base="VariableString.Type" />
                    </xs:simpleType>
                </xs:union>
            </xs:simpleType>
        </xs:attribute>
    </xs:attributeGroup>

    <xs:attributeGroup name="roundingMode.EqualRounded.Attr">
        <xs:attribute name="roundingMode" use="optional" default="significantFigures">
            <xs:simpleType>
                <xs:restriction base="xs:string">
                    <xs:enumeration value="decimalPlaces" />
                    <xs:enumeration value="significantFigures" />
                </xs:restriction>
            </xs:simpleType>
        </xs:attribute>
    </xs:attributeGroup>

    <xs:attributeGroup name="base.ExtendedTextInteraction.Attr">
        <xs:attribute name="base" use="optional" default="10" type="xs:int" />
    </xs:attributeGroup>

    <xs:attributeGroup name="class.ExtendedTextInteraction.Attr">
        <xs:attribute name="class" use="optional">
            <xs:simpleType>
                <xs:list itemType="StringList.Type" />
            </xs:simpleType>
        </xs:attribute>
    </xs:attributeGroup>

    <xs:attributeGroup name="expectedLength.ExtendedTextInteraction.Attr">
        <xs:attribute name="expectedLength" use="optional" type="xs:nonNegativeInteger" />
    </xs:attributeGroup>

    <xs:attributeGroup name="expectedLines.ExtendedTextInteraction.Attr">
        <xs:attribute name="expectedLines" use="optional" type="xs:nonNegativeInteger" />
    </xs:attributeGroup>

    <xs:attributeGroup name="format.ExtendedTextInteraction.Attr">
        <xs:attribute name="format" use="optional" default="plain">
            <xs:simpleType>
                <xs:restriction base="xs:string">
                    <xs:enumeration value="plain" />
                    <xs:enumeration value="preformatted" />
                    <xs:enumeration value="xhtml" />
                </xs:restriction>
            </xs:simpleType>
        </xs:attribute>
    </xs:attributeGroup>

    <xs:attributeGroup name="id.ExtendedTextInteraction.Attr">
        <xs:attribute name="id" use="optional" type="UniqueIdentifier.Type" />
    </xs:attributeGroup>

    <xs:attributeGroup name="label.ExtendedTextInteraction.Attr">
        <xs:attribute name="label" use="optional" type="xs:string" />
    </xs:attributeGroup>

    <xs:attributeGroup name="maxStrings.ExtendedTextInteraction.Attr">
        <xs:attribute name="maxStrings" use="optional" type="xs:nonNegativeInteger" />
    </xs:attributeGroup>

    <xs:attributeGroup name="minStrings.ExtendedTextInteraction.Attr">
        <xs:attribute name="minStrings" use="optional" default="0" type="xs:nonNegativeInteger" />
    </xs:attributeGroup>

    <xs:attributeGroup name="patternMask.ExtendedTextInteraction.Attr">
        <xs:attribute name="patternMask" use="optional" type="xs:string" />
    </xs:attributeGroup>

    <xs:attributeGroup name="placeholderText.ExtendedTextInteraction.Attr">
        <xs:attribute name="placeholderText" use="optional" type="xs:string" />
    </xs:attributeGroup>

    <xs:attributeGroup name="responseIdentifier.ExtendedTextInteraction.Attr">
        <xs:attribute name="responseIdentifier" use="required" type="Identifier.Type" />
    </xs:attributeGroup>

    <xs:attributeGroup name="stringIdentifier.ExtendedTextInteraction.Attr">
        <xs:attribute name="stringIdentifier" use="optional" type="Identifier.Type" />
    </xs:attributeGroup>

    <xs:attributeGroup name="xmlbase.ExtendedTextInteraction.Attr">
        <xs:attribute ref="xml:base" use="optional" />
    </xs:attributeGroup>

    <xs:attributeGroup name="xmllang.ExtendedTextInteraction.Attr">
        <xs:attribute ref="xml:lang" use="optional" />
    </xs:attributeGroup>

    <xs:attributeGroup name="class.FeedbackBlock.Attr">
        <xs:attribute name="class" use="optional">
            <xs:simpleType>
                <xs:list itemType="StringList.Type" />
            </xs:simpleType>
        </xs:attribute>
    </xs:attributeGroup>

    <xs:attributeGroup name="id.FeedbackBlock.Attr">
        <xs:attribute name="id" use="optional" type="Identifier.Type" />
    </xs:attributeGroup>

    <xs:attributeGroup name="identifier.FeedbackBlock.Attr">
        <xs:attribute name="identifier" use="required" type="Identifier.Type" />
    </xs:attributeGroup>

    <xs:attributeGroup name="label.FeedbackBlock.Attr">
        <xs:attribute name="label" use="optional" type="xs:string" />
    </xs:attributeGroup>

    <xs:attributeGroup name="outcomeIdentifier.FeedbackBlock.Attr">
        <xs:attribute name="outcomeIdentifier" use="required" type="Identifier.Type" />
    </xs:attributeGroup>

    <xs:attributeGroup name="showHide.FeedbackBlock.Attr">
        <xs:attribute name="showHide" use="optional" default="show">
            <xs:simpleType>
                <xs:restriction base="xs:string">
                    <xs:enumeration value="show" />
                    <xs:enumeration value="hide" />
                </xs:restriction>
            </xs:simpleType>
        </xs:attribute>
    </xs:attributeGroup>

    <xs:attributeGroup name="xmlbase.FeedbackBlock.Attr">
        <xs:attribute ref="xml:base" use="optional" />
    </xs:attributeGroup>

    <xs:attributeGroup name="xmllang.FeedbackBlock.Attr">
        <xs:attribute ref="xml:lang" use="optional" />
    </xs:attributeGroup>

    <xs:attributeGroup name="class.FeedbackInline.Attr">
        <xs:attribute name="class" use="optional">
            <xs:simpleType>
                <xs:list itemType="StringList.Type" />
            </xs:simpleType>
        </xs:attribute>
    </xs:attributeGroup>

    <xs:attributeGroup name="id.FeedbackInline.Attr">
        <xs:attribute name="id" use="optional" type="Identifier.Type" />
    </xs:attributeGroup>

    <xs:attributeGroup name="identifier.FeedbackInline.Attr">
        <xs:attribute name="identifier" use="required" type="Identifier.Type" />
    </xs:attributeGroup>

    <xs:attributeGroup name="label.FeedbackInline.Attr">
        <xs:attribute name="label" use="optional" type="xs:string" />
    </xs:attributeGroup>

    <xs:attributeGroup name="outcomeIdentifier.FeedbackInline.Attr">
        <xs:attribute name="outcomeIdentifier" use="required" type="Identifier.Type" />
    </xs:attributeGroup>

    <xs:attributeGroup name="showHide.FeedbackInline.Attr">
        <xs:attribute name="showHide" use="optional" default="show">
            <xs:simpleType>
                <xs:restriction base="xs:string">
                    <xs:enumeration value="show" />
                    <xs:enumeration value="hide" />
                </xs:restriction>
            </xs:simpleType>
        </xs:attribute>
    </xs:attributeGroup>

    <xs:attributeGroup name="xmlbase.FeedbackInline.Attr">
        <xs:attribute ref="xml:base" use="optional" />
    </xs:attributeGroup>

    <xs:attributeGroup name="xmllang.FeedbackInline.Attr">
        <xs:attribute ref="xml:lang" use="optional" />
    </xs:attributeGroup>

    <xs:attributeGroup name="fieldIdentifier.FieldValue.Attr">
        <xs:attribute name="fieldIdentifier" use="required" type="Identifier.Type" />
    </xs:attributeGroup>

    <xs:attributeGroup name="class.Gap.Attr">
        <xs:attribute name="class" use="optional">
            <xs:simpleType>
                <xs:list itemType="StringList.Type" />
            </xs:simpleType>
        </xs:attribute>
    </xs:attributeGroup>

    <xs:attributeGroup name="fixed.Gap.Attr">
        <xs:attribute name="fixed" use="optional" default="false" type="xs:boolean" />
    </xs:attributeGroup>

    <xs:attributeGroup name="id.Gap.Attr">
        <xs:attribute name="id" use="optional" type="UniqueIdentifier.Type" />
    </xs:attributeGroup>

    <xs:attributeGroup name="identifier.Gap.Attr">
        <xs:attribute name="identifier" use="required" type="Identifier.Type" />
    </xs:attributeGroup>

    <xs:attributeGroup name="label.Gap.Attr">
        <xs:attribute name="label" use="optional" type="xs:string" />
    </xs:attributeGroup>

    <xs:attributeGroup name="matchGroup.Gap.Attr">
        <xs:attribute name="matchGroup" use="optional">
            <xs:simpleType>
                <xs:list itemType="IdentifierList.Type" />
            </xs:simpleType>
        </xs:attribute>
    </xs:attributeGroup>

    <xs:attributeGroup name="required.Gap.Attr">
        <xs:attribute name="required" use="optional" default="false" type="xs:boolean" />
    </xs:attributeGroup>

    <xs:attributeGroup name="showHide.Gap.Attr">
        <xs:attribute name="showHide" use="optional" default="show">
            <xs:simpleType>
                <xs:restriction base="xs:string">
                    <xs:enumeration value="show" />
                    <xs:enumeration value="hide" />
                </xs:restriction>
            </xs:simpleType>
        </xs:attribute>
    </xs:attributeGroup>

    <xs:attributeGroup name="templateIdentifier.Gap.Attr">
        <xs:attribute name="templateIdentifier" use="optional" type="Identifier.Type" />
    </xs:attributeGroup>

    <xs:attributeGroup name="xmllang.Gap.Attr">
        <xs:attribute ref="xml:lang" use="optional" />
    </xs:attributeGroup>

    <xs:attributeGroup name="class.GapImg.Attr">
        <xs:attribute name="class" use="optional">
            <xs:simpleType>
                <xs:list itemType="StringList.Type" />
            </xs:simpleType>
        </xs:attribute>
    </xs:attributeGroup>

    <xs:attributeGroup name="fixed.GapImg.Attr">
        <xs:attribute name="fixed" use="optional" default="false" type="xs:boolean" />
    </xs:attributeGroup>

    <xs:attributeGroup name="id.GapImg.Attr">
        <xs:attribute name="id" use="optional" type="UniqueIdentifier.Type" />
    </xs:attributeGroup>

    <xs:attributeGroup name="identifier.GapImg.Attr">
        <xs:attribute name="identifier" use="required" type="Identifier.Type" />
    </xs:attributeGroup>

    <xs:attributeGroup name="label.GapImg.Attr">
        <xs:attribute name="label" use="optional" type="xs:string" />
    </xs:attributeGroup>

    <xs:attributeGroup name="matchGroup.GapImg.Attr">
        <xs:attribute name="matchGroup" use="optional">
            <xs:simpleType>
                <xs:list itemType="IdentifierList.Type" />
            </xs:simpleType>
        </xs:attribute>
    </xs:attributeGroup>

    <xs:attributeGroup name="matchMax.GapImg.Attr">
        <xs:attribute name="matchMax" use="required" type="xs:nonNegativeInteger" />
    </xs:attributeGroup>

    <xs:attributeGroup name="matchMin.GapImg.Attr">
        <xs:attribute name="matchMin" use="optional" default="0" type="xs:nonNegativeInteger" />
    </xs:attributeGroup>

    <xs:attributeGroup name="objectLabel.GapImg.Attr">
        <xs:attribute name="objectLabel" use="optional" type="xs:string" />
    </xs:attributeGroup>

    <xs:attributeGroup name="showHide.GapImg.Attr">
        <xs:attribute name="showHide" use="optional" default="show">
            <xs:simpleType>
                <xs:restriction base="xs:string">
                    <xs:enumeration value="show" />
                    <xs:enumeration value="hide" />
                </xs:restriction>
            </xs:simpleType>
        </xs:attribute>
    </xs:attributeGroup>

    <xs:attributeGroup name="templateIdentifier.GapImg.Attr">
        <xs:attribute name="templateIdentifier" use="optional" type="Identifier.Type" />
    </xs:attributeGroup>

    <xs:attributeGroup name="xmllang.GapImg.Attr">
        <xs:attribute ref="xml:lang" use="optional" />
    </xs:attributeGroup>

    <xs:attributeGroup name="class.GapMatchInteraction.Attr">
        <xs:attribute name="class" use="optional">
            <xs:simpleType>
                <xs:list itemType="StringList.Type" />
            </xs:simpleType>
        </xs:attribute>
    </xs:attributeGroup>

    <xs:attributeGroup name="id.GapMatchInteraction.Attr">
        <xs:attribute name="id" use="optional" type="UniqueIdentifier.Type" />
    </xs:attributeGroup>

    <xs:attributeGroup name="label.GapMatchInteraction.Attr">
        <xs:attribute name="label" use="optional" type="xs:string" />
    </xs:attributeGroup>

    <xs:attributeGroup name="responseIdentifier.GapMatchInteraction.Attr">
        <xs:attribute name="responseIdentifier" use="required" type="Identifier.Type" />
    </xs:attributeGroup>

    <xs:attributeGroup name="shuffle.GapMatchInteraction.Attr">
        <xs:attribute name="shuffle" use="optional" default="false" type="xs:boolean" />
    </xs:attributeGroup>

    <xs:attributeGroup name="xmlbase.GapMatchInteraction.Attr">
        <xs:attribute ref="xml:base" use="optional" />
    </xs:attributeGroup>

    <xs:attributeGroup name="xmllang.GapMatchInteraction.Attr">
        <xs:attribute ref="xml:lang" use="optional" />
    </xs:attributeGroup>

    <xs:attributeGroup name="class.GapText.Attr">
        <xs:attribute name="class" use="optional">
            <xs:simpleType>
                <xs:list itemType="StringList.Type" />
            </xs:simpleType>
        </xs:attribute>
    </xs:attributeGroup>

    <xs:attributeGroup name="fixed.GapText.Attr">
        <xs:attribute name="fixed" use="optional" default="false" type="xs:boolean" />
    </xs:attributeGroup>

    <xs:attributeGroup name="id.GapText.Attr">
        <xs:attribute name="id" use="optional" type="UniqueIdentifier.Type" />
    </xs:attributeGroup>

    <xs:attributeGroup name="identifier.GapText.Attr">
        <xs:attribute name="identifier" use="required" type="Identifier.Type" />
    </xs:attributeGroup>

    <xs:attributeGroup name="label.GapText.Attr">
        <xs:attribute name="label" use="optional" type="xs:string" />
    </xs:attributeGroup>

    <xs:attributeGroup name="matchGroup.GapText.Attr">
        <xs:attribute name="matchGroup" use="optional">
            <xs:simpleType>
                <xs:list itemType="IdentifierList.Type" />
            </xs:simpleType>
        </xs:attribute>
    </xs:attributeGroup>

    <xs:attributeGroup name="matchMax.GapText.Attr">
        <xs:attribute name="matchMax" use="required" type="xs:nonNegativeInteger" />
    </xs:attributeGroup>

    <xs:attributeGroup name="matchMin.GapText.Attr">
        <xs:attribute name="matchMin" use="optional" default="0" type="xs:nonNegativeInteger" />
    </xs:attributeGroup>

    <xs:attributeGroup name="showHide.GapText.Attr">
        <xs:attribute name="showHide" use="optional" default="show">
            <xs:simpleType>
                <xs:restriction base="xs:string">
                    <xs:enumeration value="show" />
                    <xs:enumeration value="hide" />
                </xs:restriction>
            </xs:simpleType>
        </xs:attribute>
    </xs:attributeGroup>

    <xs:attributeGroup name="templateIdentifier.GapText.Attr">
        <xs:attribute name="templateIdentifier" use="optional" type="Identifier.Type" />
    </xs:attributeGroup>

    <xs:attributeGroup name="xmllang.GapText.Attr">
        <xs:attribute ref="xml:lang" use="optional" />
    </xs:attributeGroup>

    <xs:attributeGroup name="class.GraphicAssociateInteraction.Attr">
        <xs:attribute name="class" use="optional">
            <xs:simpleType>
                <xs:list itemType="StringList.Type" />
            </xs:simpleType>
        </xs:attribute>
    </xs:attributeGroup>

    <xs:attributeGroup name="id.GraphicAssociateInteraction.Attr">
        <xs:attribute name="id" use="optional" type="Identifier.Type" />
    </xs:attributeGroup>

    <xs:attributeGroup name="label.GraphicAssociateInteraction.Attr">
        <xs:attribute name="label" use="optional" type="xs:string" />
    </xs:attributeGroup>

    <xs:attributeGroup name="maxAssociations.GraphicAssociateInteraction.Attr">
        <xs:attribute name="maxAssociations" use="optional" default="1" type="xs:nonNegativeInteger" />
    </xs:attributeGroup>

    <xs:attributeGroup name="minAssociations.GraphicAssociateInteraction.Attr">
        <xs:attribute name="minAssociations" use="optional" type="xs:nonNegativeInteger" />
    </xs:attributeGroup>

    <xs:attributeGroup name="responseIdentifier.GraphicAssociateInteraction.Attr">
        <xs:attribute name="responseIdentifier" use="required" type="Identifier.Type" />
    </xs:attributeGroup>

    <xs:attributeGroup name="xmlbase.GraphicAssociateInteraction.Attr">
        <xs:attribute ref="xml:base" use="optional" />
    </xs:attributeGroup>

    <xs:attributeGroup name="xmllang.GraphicAssociateInteraction.Attr">
        <xs:attribute ref="xml:lang" use="optional" />
    </xs:attributeGroup>

    <xs:attributeGroup name="class.GraphicGapMatchInteraction.Attr">
        <xs:attribute name="class" use="optional">
            <xs:simpleType>
                <xs:list itemType="StringList.Type" />
            </xs:simpleType>
        </xs:attribute>
    </xs:attributeGroup>

    <xs:attributeGroup name="id.GraphicGapMatchInteraction.Attr">
        <xs:attribute name="id" use="optional" type="UniqueIdentifier.Type" />
    </xs:attributeGroup>

    <xs:attributeGroup name="label.GraphicGapMatchInteraction.Attr">
        <xs:attribute name="label" use="optional" type="xs:string" />
    </xs:attributeGroup>

    <xs:attributeGroup name="responseIdentifier.GraphicGapMatchInteraction.Attr">
        <xs:attribute name="responseIdentifier" use="required" type="Identifier.Type" />
    </xs:attributeGroup>

    <xs:attributeGroup name="xmlbase.GraphicGapMatchInteraction.Attr">
        <xs:attribute ref="xml:base" use="optional" />
    </xs:attributeGroup>

    <xs:attributeGroup name="xmllang.GraphicGapMatchInteraction.Attr">
        <xs:attribute ref="xml:lang" use="optional" />
    </xs:attributeGroup>

    <xs:attributeGroup name="class.GraphicOrderInteraction.Attr">
        <xs:attribute name="class" use="optional">
            <xs:simpleType>
                <xs:list itemType="StringList.Type" />
            </xs:simpleType>
        </xs:attribute>
    </xs:attributeGroup>

    <xs:attributeGroup name="id.GraphicOrderInteraction.Attr">
        <xs:attribute name="id" use="optional" type="UniqueIdentifier.Type" />
    </xs:attributeGroup>

    <xs:attributeGroup name="label.GraphicOrderInteraction.Attr">
        <xs:attribute name="label" use="optional" type="xs:string" />
    </xs:attributeGroup>

    <xs:attributeGroup name="maxChoices.GraphicOrderInteraction.Attr">
        <xs:attribute name="maxChoices" use="optional" type="xs:nonNegativeInteger" />
    </xs:attributeGroup>

    <xs:attributeGroup name="minChoices.GraphicOrderInteraction.Attr">
        <xs:attribute name="minChoices" use="optional" type="xs:nonNegativeInteger" />
    </xs:attributeGroup>

    <xs:attributeGroup name="responseIdentifier.GraphicOrderInteraction.Attr">
        <xs:attribute name="responseIdentifier" use="required" type="Identifier.Type" />
    </xs:attributeGroup>

    <xs:attributeGroup name="xmlbase.GraphicOrderInteraction.Attr">
        <xs:attribute ref="xml:base" use="optional" />
    </xs:attributeGroup>

    <xs:attributeGroup name="xmllang.GraphicOrderInteraction.Attr">
        <xs:attribute ref="xml:lang" use="optional" />
    </xs:attributeGroup>

    <xs:attributeGroup name="class.HotspotChoice.Attr">
        <xs:attribute name="class" use="optional">
            <xs:simpleType>
                <xs:list itemType="StringList.Type" />
            </xs:simpleType>
        </xs:attribute>
    </xs:attributeGroup>

    <xs:attributeGroup name="coords.HotspotChoice.Attr">
        <xs:attribute name="coords" use="required" type="xs:string" />
    </xs:attributeGroup>

    <xs:attributeGroup name="fixed.HotspotChoice.Attr">
        <xs:attribute name="fixed" use="optional" default="false" type="xs:boolean" />
    </xs:attributeGroup>

    <xs:attributeGroup name="hotspotLabel.HotspotChoice.Attr">
        <xs:attribute name="hotspotLabel" use="optional" type="xs:string" />
    </xs:attributeGroup>

    <xs:attributeGroup name="id.HotspotChoice.Attr">
        <xs:attribute name="id" use="optional" type="UniqueIdentifier.Type" />
    </xs:attributeGroup>

    <xs:attributeGroup name="identifier.HotspotChoice.Attr">
        <xs:attribute name="identifier" use="required" type="Identifier.Type" />
    </xs:attributeGroup>

    <xs:attributeGroup name="label.HotspotChoice.Attr">
        <xs:attribute name="label" use="optional" type="xs:string" />
    </xs:attributeGroup>

    <xs:attributeGroup name="shape.HotspotChoice.Attr">
        <xs:attribute name="shape" use="required">
            <xs:simpleType>
                <xs:restriction base="xs:string">
                    <xs:enumeration value="circle" />
                    <xs:enumeration value="default" />
                    <xs:enumeration value="ellipse" />
                    <xs:enumeration value="poly" />
                    <xs:enumeration value="rect" />
                </xs:restriction>
            </xs:simpleType>
        </xs:attribute>
    </xs:attributeGroup>

    <xs:attributeGroup name="showHide.HotspotChoice.Attr">
        <xs:attribute name="showHide" use="optional" default="show">
            <xs:simpleType>
                <xs:restriction base="xs:string">
                    <xs:enumeration value="show" />
                    <xs:enumeration value="hide" />
                </xs:restriction>
            </xs:simpleType>
        </xs:attribute>
    </xs:attributeGroup>

    <xs:attributeGroup name="templateIdentifier.HotspotChoice.Attr">
        <xs:attribute name="templateIdentifier" use="optional" type="Identifier.Type" />
    </xs:attributeGroup>

    <xs:attributeGroup name="xmllang.HotspotChoice.Attr">
        <xs:attribute ref="xml:lang" use="optional" />
    </xs:attributeGroup>

    <xs:attributeGroup name="class.HotspotInteraction.Attr">
        <xs:attribute name="class" use="optional">
            <xs:simpleType>
                <xs:list itemType="StringList.Type" />
            </xs:simpleType>
        </xs:attribute>
    </xs:attributeGroup>

    <xs:attributeGroup name="id.HotspotInteraction.Attr">
        <xs:attribute name="id" use="optional" type="UniqueIdentifier.Type" />
    </xs:attributeGroup>

    <xs:attributeGroup name="label.HotspotInteraction.Attr">
        <xs:attribute name="label" use="optional" type="xs:string" />
    </xs:attributeGroup>

    <xs:attributeGroup name="maxChoices.HotspotInteraction.Attr">
        <xs:attribute name="maxChoices" use="optional" default="0" type="xs:nonNegativeInteger" />
    </xs:attributeGroup>

    <xs:attributeGroup name="minChoices.HotspotInteraction.Attr">
        <xs:attribute name="minChoices" use="optional" default="0" type="xs:nonNegativeInteger" />
    </xs:attributeGroup>

    <xs:attributeGroup name="responseIdentifier.HotspotInteraction.Attr">
        <xs:attribute name="responseIdentifier" use="required" type="Identifier.Type" />
    </xs:attributeGroup>

    <xs:attributeGroup name="xmlbase.HotspotInteraction.Attr">
        <xs:attribute ref="xml:base" use="optional" />
    </xs:attributeGroup>

    <xs:attributeGroup name="xmllang.HotspotInteraction.Attr">
        <xs:attribute ref="xml:lang" use="optional" />
    </xs:attributeGroup>

    <xs:attributeGroup name="class.HotText.Attr">
        <xs:attribute name="class" use="optional">
            <xs:simpleType>
                <xs:list itemType="StringList.Type" />
            </xs:simpleType>
        </xs:attribute>
    </xs:attributeGroup>

    <xs:attributeGroup name="fixed.HotText.Attr">
        <xs:attribute name="fixed" use="optional" default="false" type="xs:boolean" />
    </xs:attributeGroup>

    <xs:attributeGroup name="id.HotText.Attr">
        <xs:attribute name="id" use="optional" type="UniqueIdentifier.Type" />
    </xs:attributeGroup>

    <xs:attributeGroup name="identifier.HotText.Attr">
        <xs:attribute name="identifier" use="required" type="Identifier.Type" />
    </xs:attributeGroup>

    <xs:attributeGroup name="label.HotText.Attr">
        <xs:attribute name="label" use="optional" type="xs:string" />
    </xs:attributeGroup>

    <xs:attributeGroup name="showHide.HotText.Attr">
        <xs:attribute name="showHide" use="optional" default="show">
            <xs:simpleType>
                <xs:restriction base="xs:string">
                    <xs:enumeration value="show" />
                    <xs:enumeration value="hide" />
                </xs:restriction>
            </xs:simpleType>
        </xs:attribute>
    </xs:attributeGroup>

    <xs:attributeGroup name="templateIdentifier.HotText.Attr">
        <xs:attribute name="templateIdentifier" use="optional" type="Identifier.Type" />
    </xs:attributeGroup>

    <xs:attributeGroup name="xmlbase.HotText.Attr">
        <xs:attribute ref="xml:base" use="optional" />
    </xs:attributeGroup>

    <xs:attributeGroup name="xmllanguage.HotText.Attr">
        <xs:attribute ref="xml:lang" use="optional" />
    </xs:attributeGroup>

    <xs:attributeGroup name="class.HotTextInteraction.Attr">
        <xs:attribute name="class" use="optional">
            <xs:simpleType>
                <xs:list itemType="StringList.Type" />
            </xs:simpleType>
        </xs:attribute>
    </xs:attributeGroup>

    <xs:attributeGroup name="id.HotTextInteraction.Attr">
        <xs:attribute name="id" use="optional" type="UniqueIdentifier.Type" />
    </xs:attributeGroup>

    <xs:attributeGroup name="label.HotTextInteraction.Attr">
        <xs:attribute name="label" use="optional" type="xs:string" />
    </xs:attributeGroup>

    <xs:attributeGroup name="maxChoices.HotTextInteraction.Attr">
        <xs:attribute name="maxChoices" use="optional" default="0" type="xs:nonNegativeInteger" />
    </xs:attributeGroup>

    <xs:attributeGroup name="minChoices.HotTextInteraction.Attr">
        <xs:attribute name="minChoices" use="optional" default="0" type="xs:nonNegativeInteger" />
    </xs:attributeGroup>

    <xs:attributeGroup name="responseIdentifier.HotTextInteraction.Attr">
        <xs:attribute name="responseIdentifier" use="required" type="Identifier.Type" />
    </xs:attributeGroup>

    <xs:attributeGroup name="xmlbase.HotTextInteraction.Attr">
        <xs:attribute ref="xml:base" use="optional" />
    </xs:attributeGroup>

    <xs:attributeGroup name="xmllang.HotTextInteraction.Attr">
        <xs:attribute ref="xml:lang" use="optional" />
    </xs:attributeGroup>

    <xs:attributeGroup name="class.HR.Attr">
        <xs:attribute name="class" use="optional">
            <xs:simpleType>
                <xs:list itemType="StringList.Type" />
            </xs:simpleType>
        </xs:attribute>
    </xs:attributeGroup>

    <xs:attributeGroup name="id.HR.Attr">
        <xs:attribute name="id" use="optional" type="UniqueIdentifier.Type" />
    </xs:attributeGroup>

    <xs:attributeGroup name="label.HR.Attr">
        <xs:attribute name="label" use="optional" type="xs:string" />
    </xs:attributeGroup>

    <xs:attributeGroup name="xmlbase.HR.Attr">
        <xs:attribute ref="xml:base" use="optional" />
    </xs:attributeGroup>

    <xs:attributeGroup name="xmllang.HR.Attr">
        <xs:attribute ref="xml:lang" use="optional" />
    </xs:attributeGroup>

    <xs:attributeGroup name="class.HTMLText.Attr">
        <xs:attribute name="class" use="optional">
            <xs:simpleType>
                <xs:list itemType="StringList.Type" />
            </xs:simpleType>
        </xs:attribute>
    </xs:attributeGroup>

    <xs:attributeGroup name="id.HTMLText.Attr">
        <xs:attribute name="id" use="optional" type="UniqueIdentifier.Type" />
    </xs:attributeGroup>

    <xs:attributeGroup name="label.HTMLText.Attr">
        <xs:attribute name="label" use="optional" type="xs:string" />
    </xs:attributeGroup>

    <xs:attributeGroup name="xmlbase.HTMLText.Attr">
        <xs:attribute ref="xml:base" use="optional" />
    </xs:attributeGroup>

    <xs:attributeGroup name="xmllang.HTMLText.Attr">
        <xs:attribute ref="xml:lang" use="optional" />
    </xs:attributeGroup>

    <xs:attributeGroup name="alt.Img.Attr">
        <xs:attribute name="alt" use="required" type="xs:string" />
    </xs:attributeGroup>

    <xs:attributeGroup name="class.Img.Attr">
        <xs:attribute name="class" use="optional">
            <xs:simpleType>
                <xs:list itemType="StringList.Type" />
            </xs:simpleType>
        </xs:attribute>
    </xs:attributeGroup>

    <xs:attributeGroup name="height.Img.Attr">
        <xs:attribute name="height" use="optional" type="Length.Type" />
    </xs:attributeGroup>

    <xs:attributeGroup name="id.Img.Attr">
        <xs:attribute name="id" use="optional" type="UniqueIdentifier.Type" />
    </xs:attributeGroup>

    <xs:attributeGroup name="label.Img.Attr">
        <xs:attribute name="label" use="optional" type="xs:string" />
    </xs:attributeGroup>

    <xs:attributeGroup name="longdesc.Img.Attr">
        <xs:attribute name="longdesc" use="optional" type="xs:anyURI" />
    </xs:attributeGroup>

    <xs:attributeGroup name="src.Img.Attr">
        <xs:attribute name="src" use="required" type="xs:anyURI" />
    </xs:attributeGroup>

    <xs:attributeGroup name="width.Img.Attr">
        <xs:attribute name="width" use="optional" type="Length.Type" />
    </xs:attributeGroup>

    <xs:attributeGroup name="xmlbase.Img.Attr">
        <xs:attribute ref="xml:base" use="optional" />
    </xs:attributeGroup>

    <xs:attributeGroup name="xmllang.Img.Attr">
        <xs:attribute ref="xml:lang" use="optional" />
    </xs:attributeGroup>

    <xs:attributeGroup name="n.Index.Attr">
        <xs:attribute name="n" use="required">
            <xs:simpleType>
                <xs:union>
                    <xs:simpleType>
                        <xs:restriction base="xs:NCName" />
                    </xs:simpleType>
                    <xs:simpleType>
                        <xs:restriction base="xs:int" />
                    </xs:simpleType>
                </xs:union>
            </xs:simpleType>
        </xs:attribute>
    </xs:attributeGroup>

    <xs:attributeGroup name="class.InfoControl.Attr">
        <xs:attribute name="class" use="optional">
            <xs:simpleType>
                <xs:list itemType="StringList.Type" />
            </xs:simpleType>
        </xs:attribute>
    </xs:attributeGroup>

    <xs:attributeGroup name="id.InfoControl.Attr">
        <xs:attribute name="id" use="optional" type="Identifier.Type" />
    </xs:attributeGroup>

    <xs:attributeGroup name="label.InfoControl.Attr">
        <xs:attribute name="label" use="optional" type="xs:string" />
    </xs:attributeGroup>

    <xs:attributeGroup name="title.InfoControl.Attr">
        <xs:attribute name="title" use="required" type="xs:normalizedString" />
    </xs:attributeGroup>

    <xs:attributeGroup name="xmllang.InfoControl.Attr">
        <xs:attribute ref="xml:lang" use="optional" />
    </xs:attributeGroup>

    <xs:attributeGroup name="class.InlineChoice.Attr">
        <xs:attribute name="class" use="optional">
            <xs:simpleType>
                <xs:list itemType="StringList.Type" />
            </xs:simpleType>
        </xs:attribute>
    </xs:attributeGroup>

    <xs:attributeGroup name="fixed.InlineChoice.Attr">
        <xs:attribute name="fixed" use="optional" default="false" type="xs:boolean" />
    </xs:attributeGroup>

    <xs:attributeGroup name="id.InlineChoice.Attr">
        <xs:attribute name="id" use="optional" type="UniqueIdentifier.Type" />
    </xs:attributeGroup>

    <xs:attributeGroup name="identifier.InlineChoice.Attr">
        <xs:attribute name="identifier" use="required" type="Identifier.Type" />
    </xs:attributeGroup>

    <xs:attributeGroup name="label.InlineChoice.Attr">
        <xs:attribute name="label" use="optional" type="xs:string" />
    </xs:attributeGroup>

    <xs:attributeGroup name="showHide.InlineChoice.Attr">
        <xs:attribute name="showHide" use="optional" default="show">
            <xs:simpleType>
                <xs:restriction base="xs:string">
                    <xs:enumeration value="show" />
                    <xs:enumeration value="hide" />
                </xs:restriction>
            </xs:simpleType>
        </xs:attribute>
    </xs:attributeGroup>

    <xs:attributeGroup name="templateIdentifier.InlineChoice.Attr">
        <xs:attribute name="templateIdentifier" use="optional" type="Identifier.Type" />
    </xs:attributeGroup>

    <xs:attributeGroup name="xmllang.InlineChoice.Attr">
        <xs:attribute ref="xml:lang" use="optional" />
    </xs:attributeGroup>

    <xs:attributeGroup name="class.InlineChoiceInteraction.Attr">
        <xs:attribute name="class" use="optional">
            <xs:simpleType>
                <xs:list itemType="StringList.Type" />
            </xs:simpleType>
        </xs:attribute>
    </xs:attributeGroup>

    <xs:attributeGroup name="id.InlineChoiceInteraction.Attr">
        <xs:attribute name="id" use="optional" type="UniqueIdentifier.Type" />
    </xs:attributeGroup>

    <xs:attributeGroup name="label.InlineChoiceInteraction.Attr">
        <xs:attribute name="label" use="optional" type="xs:string" />
    </xs:attributeGroup>

    <xs:attributeGroup name="required.InlineChoiceInteraction.Attr">
        <xs:attribute name="required" use="optional" default="false" type="xs:boolean" />
    </xs:attributeGroup>

    <xs:attributeGroup name="responseIdentifier.InlineChoiceInteraction.Attr">
        <xs:attribute name="responseIdentifier" use="required" type="Identifier.Type" />
    </xs:attributeGroup>

    <xs:attributeGroup name="shuffle.InlineChoiceInteraction.Attr">
        <xs:attribute name="shuffle" use="optional" default="false" type="xs:boolean" />
    </xs:attributeGroup>

    <xs:attributeGroup name="xmlbase.InlineChoiceInteraction.Attr">
        <xs:attribute ref="xml:base" use="optional" />
    </xs:attributeGroup>

    <xs:attributeGroup name="xmllang.InlineChoiceInteraction.Attr">
        <xs:attribute ref="xml:lang" use="optional" />
    </xs:attributeGroup>

    <xs:attributeGroup name="coords.Inside.Attr">
        <xs:attribute name="coords" use="required" type="xs:normalizedString" />
    </xs:attributeGroup>

    <xs:attributeGroup name="shape.Inside.Attr">
        <xs:attribute name="shape" use="required">
            <xs:simpleType>
                <xs:restriction base="xs:string">
                    <xs:enumeration value="circle" />
                    <xs:enumeration value="default" />
                    <xs:enumeration value="ellipse" />
                    <xs:enumeration value="poly" />
                    <xs:enumeration value="rect" />
                </xs:restriction>
            </xs:simpleType>
        </xs:attribute>
    </xs:attributeGroup>

    <xs:attributeGroup name="defaultValue.InterpolationTable.Attr">
        <xs:attribute name="defaultValue" use="optional" type="xs:string" />
    </xs:attributeGroup>

    <xs:attributeGroup name="includeBoundary.InterpolationTableEntry.Attr">
        <xs:attribute name="includeBoundary" use="optional" default="true" type="xs:boolean" />
    </xs:attributeGroup>

    <xs:attributeGroup name="sourceValue.InterpolationTableEntry.Attr">
        <xs:attribute name="sourceValue" use="required" type="xs:double" />
    </xs:attributeGroup>

    <xs:attributeGroup name="targetValue.InterpolationTableEntry.Attr">
        <xs:attribute name="targetValue" use="required" type="xs:string" />
    </xs:attributeGroup>

    <xs:attributeGroup name="class.ItemBody.Attr">
        <xs:attribute name="class" use="optional">
            <xs:simpleType>
                <xs:list itemType="StringList.Type" />
            </xs:simpleType>
        </xs:attribute>
    </xs:attributeGroup>

    <xs:attributeGroup name="id.ItemBody.Attr">
        <xs:attribute name="id" use="optional" type="Identifier.Type" />
    </xs:attributeGroup>

    <xs:attributeGroup name="label.ItemBody.Attr">
        <xs:attribute name="label" use="optional" type="xs:normalizedString" />
    </xs:attributeGroup>

    <xs:attributeGroup name="xmllang.ItemBody.Attr">
        <xs:attribute ref="xml:lang" use="optional" />
    </xs:attributeGroup>

    <xs:attributeGroup name="allowComment.ItemSessionControl.Attr">
        <xs:attribute name="allowComment" use="optional" type="xs:boolean" />
    </xs:attributeGroup>

    <xs:attributeGroup name="allowReview.ItemSessionControl.Attr">
        <xs:attribute name="allowReview" use="optional" default="true" type="xs:boolean" />
    </xs:attributeGroup>

    <xs:attributeGroup name="allowSkipping.ItemSessionControl.Attr">
        <xs:attribute name="allowSkipping" use="optional" default="true" type="xs:boolean" />
    </xs:attributeGroup>

    <xs:attributeGroup name="maxAttempts.ItemSessionControl.Attr">
        <xs:attribute name="maxAttempts" use="optional" type="xs:int" />
    </xs:attributeGroup>

    <xs:attributeGroup name="showFeedback.ItemSessionControl.Attr">
        <xs:attribute name="showFeedback" use="optional" default="false" type="xs:boolean" />
    </xs:attributeGroup>

    <xs:attributeGroup name="showSolution.ItemSessionControl.Attr">
        <xs:attribute name="showSolution" use="optional" default="false" type="xs:boolean" />
    </xs:attributeGroup>

    <xs:attributeGroup name="validateResponses.ItemSessionControl.Attr">
        <xs:attribute name="validateResponses" use="optional" type="xs:boolean" />
    </xs:attributeGroup>

    <xs:attributeGroup name="class.LI.Attr">
        <xs:attribute name="class" use="optional">
            <xs:simpleType>
                <xs:list itemType="StringList.Type" />
            </xs:simpleType>
        </xs:attribute>
    </xs:attributeGroup>

    <xs:attributeGroup name="id.LI.Attr">
        <xs:attribute name="id" use="optional" type="UniqueIdentifier.Type" />
    </xs:attributeGroup>

    <xs:attributeGroup name="label.LI.Attr">
        <xs:attribute name="label" use="optional" type="xs:string" />
    </xs:attributeGroup>

    <xs:attributeGroup name="xmllang.LI.Attr">
        <xs:attribute ref="xml:lang" use="optional" />
    </xs:attributeGroup>

    <xs:attributeGroup name="identifier.LookupOutcomeValue.Attr">
        <xs:attribute name="identifier" use="required" type="Identifier.Type" />
    </xs:attributeGroup>

    <xs:attributeGroup name="caseSensitive.MapEntry.Attr">
        <xs:attribute name="caseSensitive" use="optional" type="xs:boolean" />
    </xs:attributeGroup>

    <xs:attributeGroup name="mapKey.MapEntry.Attr">
        <xs:attribute name="mapKey" use="required" type="xs:normalizedString" />
    </xs:attributeGroup>

    <xs:attributeGroup name="mappedValue.MapEntry.Attr">
        <xs:attribute name="mappedValue" use="required" type="xs:double" />
    </xs:attributeGroup>

    <xs:attributeGroup name="defaultValue.Mapping.Attr">
        <xs:attribute name="defaultValue" use="optional" default="0" type="xs:double" />
    </xs:attributeGroup>

    <xs:attributeGroup name="lowerBound.Mapping.Attr">
        <xs:attribute name="lowerBound" use="optional" type="xs:double" />
    </xs:attributeGroup>

    <xs:attributeGroup name="upperBound.Mapping.Attr">
        <xs:attribute name="upperBound" use="optional" type="xs:double" />
    </xs:attributeGroup>

    <xs:attributeGroup name="identifier.MapResponse.Attr">
        <xs:attribute name="identifier" use="required" type="Identifier.Type" />
    </xs:attributeGroup>

    <xs:attributeGroup name="class.MatchInteraction.Attr">
        <xs:attribute name="class" use="optional">
            <xs:simpleType>
                <xs:list itemType="StringList.Type" />
            </xs:simpleType>
        </xs:attribute>
    </xs:attributeGroup>

    <xs:attributeGroup name="id.MatchInteraction.Attr">
        <xs:attribute name="id" use="optional" type="UniqueIdentifier.Type" />
    </xs:attributeGroup>

    <xs:attributeGroup name="label.MatchInteraction.Attr">
        <xs:attribute name="label" use="optional" type="xs:string" />
    </xs:attributeGroup>

    <xs:attributeGroup name="maxAssociations.MatchInteraction.Attr">
        <xs:attribute name="maxAssociations" use="optional" default="1" type="xs:nonNegativeInteger" />
    </xs:attributeGroup>

    <xs:attributeGroup name="minAssociations.MatchInteraction.Attr">
        <xs:attribute name="minAssociations" use="optional" default="0" type="xs:nonNegativeInteger" />
    </xs:attributeGroup>

    <xs:attributeGroup name="responseIdentifier.MatchInteraction.Attr">
        <xs:attribute name="responseIdentifier" use="required" type="Identifier.Type" />
    </xs:attributeGroup>

    <xs:attributeGroup name="shuffle.MatchInteraction.Attr">
        <xs:attribute name="shuffle" use="optional" default="false" type="xs:boolean" />
    </xs:attributeGroup>

    <xs:attributeGroup name="xmlbase.MatchInteraction.Attr">
        <xs:attribute ref="xml:base" use="optional" />
    </xs:attributeGroup>

    <xs:attributeGroup name="xmllang.MatchInteraction.Attr">
        <xs:attribute ref="xml:lang" use="optional" />
    </xs:attributeGroup>

    <xs:attributeGroup name="defaultValue.MatchTable.Attr">
        <xs:attribute name="defaultValue" use="optional" type="xs:string" />
    </xs:attributeGroup>

    <xs:attributeGroup name="sourceValue.MatchTableEntry.Attr">
        <xs:attribute name="sourceValue" use="required" type="xs:int" />
    </xs:attributeGroup>

    <xs:attributeGroup name="targetValue.MatchTableEntry.Attr">
        <xs:attribute name="targetValue" use="required">
            <xs:simpleType>
                <xs:restriction base="xs:string">
                    <xs:enumeration value="boolean" />
                    <xs:enumeration value="directedPair" />
                    <xs:enumeration value="duration" />
                    <xs:enumeration value="file" />
                    <xs:enumeration value="float" />
                    <xs:enumeration value="identifier" />
                    <xs:enumeration value="integer" />
                    <xs:enumeration value="pair" />
                    <xs:enumeration value="point" />
                    <xs:enumeration value="string" />
                    <xs:enumeration value="uri" />
                </xs:restriction>
            </xs:simpleType>
        </xs:attribute>
    </xs:attributeGroup>

    <xs:attributeGroup name="name.MathConstant.Attr">
        <xs:attribute name="name" use="required">
            <xs:simpleType>
                <xs:restriction base="xs:string">
                    <xs:enumeration value="pi" />
                    <xs:enumeration value="e" />
                </xs:restriction>
            </xs:simpleType>
        </xs:attribute>
    </xs:attributeGroup>

    <xs:attributeGroup name="name.MathOperator.Attr">
        <xs:attribute name="name" use="required">
            <xs:simpleType>
                <xs:restriction base="xs:string">
                    <xs:enumeration value="sin" />
                    <xs:enumeration value="cos" />
                    <xs:enumeration value="tan" />
                    <xs:enumeration value="sec" />
                    <xs:enumeration value="csc" />
                    <xs:enumeration value="cot" />
                    <xs:enumeration value="asin" />
                    <xs:enumeration value="acos" />
                    <xs:enumeration value="atan" />
                    <xs:enumeration value="atan2" />
                    <xs:enumeration value="asec" />
                    <xs:enumeration value="acsc" />
                    <xs:enumeration value="acot" />
                    <xs:enumeration value="sinh" />
                    <xs:enumeration value="cosh" />
                    <xs:enumeration value="tanh" />
                    <xs:enumeration value="sech" />
                    <xs:enumeration value="csch" />
                    <xs:enumeration value="coth" />
                    <xs:enumeration value="log" />
                    <xs:enumeration value="ln" />
                    <xs:enumeration value="exp" />
                    <xs:enumeration value="abs" />
                    <xs:enumeration value="signum" />
                    <xs:enumeration value="floor" />
                    <xs:enumeration value="ceil" />
                    <xs:enumeration value="toDegrees" />
                    <xs:enumeration value="toRadians" />
                </xs:restriction>
            </xs:simpleType>
        </xs:attribute>
    </xs:attributeGroup>

    <xs:attributeGroup name="autostart.MediaInteraction.Attr">
        <xs:attribute name="autostart" use="required" type="xs:boolean" />
    </xs:attributeGroup>

    <xs:attributeGroup name="class.MediaInteraction.Attr">
        <xs:attribute name="class" use="optional">
            <xs:simpleType>
                <xs:list itemType="StringList.Type" />
            </xs:simpleType>
        </xs:attribute>
    </xs:attributeGroup>

    <xs:attributeGroup name="id.MediaInteraction.Attr">
        <xs:attribute name="id" use="optional" type="UniqueIdentifier.Type" />
    </xs:attributeGroup>

    <xs:attributeGroup name="label.MediaInteraction.Attr">
        <xs:attribute name="label" use="optional" type="xs:string" />
    </xs:attributeGroup>

    <xs:attributeGroup name="loop.MediaInteraction.Attr">
        <xs:attribute name="loop" use="optional" default="false" type="xs:boolean" />
    </xs:attributeGroup>

    <xs:attributeGroup name="maxPlays.MediaInteraction.Attr">
        <xs:attribute name="maxPlays" use="optional" default="0" type="xs:nonNegativeInteger" />
    </xs:attributeGroup>

    <xs:attributeGroup name="minPlays.MediaInteraction.Attr">
        <xs:attribute name="minPlays" use="optional" default="0" type="xs:nonNegativeInteger" />
    </xs:attributeGroup>

    <xs:attributeGroup name="responseIdentifier.MediaInteraction.Attr">
        <xs:attribute name="responseIdentifier" use="required" type="Identifier.Type" />
    </xs:attributeGroup>

    <xs:attributeGroup name="xmlbase.MediaInteraction.Attr">
        <xs:attribute ref="xml:base" use="optional" />
    </xs:attributeGroup>

    <xs:attributeGroup name="xmllang.MediaInteraction.Attr">
        <xs:attribute ref="xml:lang" use="optional" />
    </xs:attributeGroup>

    <xs:attributeGroup name="identifier.ModalFeedback.Attr">
        <xs:attribute name="identifier" use="required" type="Identifier.Type" />
    </xs:attributeGroup>

    <xs:attributeGroup name="outcomeIdentifier.ModalFeedback.Attr">
        <xs:attribute name="outcomeIdentifier" use="required" type="Identifier.Type" />
    </xs:attributeGroup>

    <xs:attributeGroup name="showHide.ModalFeedback.Attr">
        <xs:attribute name="showHide" use="required">
            <xs:simpleType>
                <xs:restriction base="xs:string">
                    <xs:enumeration value="show" />
                    <xs:enumeration value="hide" />
                </xs:restriction>
            </xs:simpleType>
        </xs:attribute>
    </xs:attributeGroup>

    <xs:attributeGroup name="title.ModalFeedback.Attr">
        <xs:attribute name="title" use="optional" type="xs:normalizedString" />
    </xs:attributeGroup>

    <xs:attributeGroup name="excludeCategory.Number.Attr">
        <xs:attribute name="excludeCategory" use="optional">
            <xs:simpleType>
                <xs:list itemType="IdentifierList.Type" />
            </xs:simpleType>
        </xs:attribute>
    </xs:attributeGroup>

    <xs:attributeGroup name="includeCategory.Number.Attr">
        <xs:attribute name="includeCategory" use="optional">
            <xs:simpleType>
                <xs:list itemType="IdentifierList.Type" />
            </xs:simpleType>
        </xs:attribute>
    </xs:attributeGroup>

    <xs:attributeGroup name="sectionIdentifier.Number.Attr">
        <xs:attribute name="sectionIdentifier" use="optional" type="Identifier.Type" />
    </xs:attributeGroup>

    <xs:attributeGroup name="class.Object.Attr">
        <xs:attribute name="class" use="optional">
            <xs:simpleType>
                <xs:list itemType="StringList.Type" />
            </xs:simpleType>
        </xs:attribute>
    </xs:attributeGroup>

    <xs:attributeGroup name="data.Object.Attr">
        <xs:attribute name="data" use="required" type="xs:string" />
    </xs:attributeGroup>

    <xs:attributeGroup name="height.Object.Attr">
        <xs:attribute name="height" use="optional" type="Length.Type" />
    </xs:attributeGroup>

    <xs:attributeGroup name="id.Object.Attr">
        <xs:attribute name="id" use="optional" type="UniqueIdentifier.Type" />
    </xs:attributeGroup>

    <xs:attributeGroup name="label.Object.Attr">
        <xs:attribute name="label" use="optional" type="xs:string" />
    </xs:attributeGroup>

    <xs:attributeGroup name="type.Object.Attr">
        <xs:attribute name="type" use="required" type="MimeType.Type" />
    </xs:attributeGroup>

    <xs:attributeGroup name="width.Object.Attr">
        <xs:attribute name="width" use="optional" type="Length.Type" />
    </xs:attributeGroup>

    <xs:attributeGroup name="xmlbase.Object.Attr">
        <xs:attribute ref="xml:base" use="optional" />
    </xs:attributeGroup>

    <xs:attributeGroup name="xmllang.Object.Attr">
        <xs:attribute ref="xml:lang" use="optional" />
    </xs:attributeGroup>

    <xs:attributeGroup name="extension.Ordering.Attr">
        <xs:anyAttribute namespace = "##other" processContents = "strict" />
    </xs:attributeGroup>

    <xs:attributeGroup name="shuffle.Ordering.Attr">
        <xs:attribute name="shuffle" use="optional" default="false" type="xs:boolean" />
    </xs:attributeGroup>

    <xs:attributeGroup name="class.OrderInteraction.Attr">
        <xs:attribute name="class" use="optional">
            <xs:simpleType>
                <xs:list itemType="StringList.Type" />
            </xs:simpleType>
        </xs:attribute>
    </xs:attributeGroup>

    <xs:attributeGroup name="id.OrderInteraction.Attr">
        <xs:attribute name="id" use="optional" type="UniqueIdentifier.Type" />
    </xs:attributeGroup>

    <xs:attributeGroup name="label.OrderInteraction.Attr">
        <xs:attribute name="label" use="optional" type="xs:string" />
    </xs:attributeGroup>

    <xs:attributeGroup name="maxChoices.OrderInteraction.Attr">
        <xs:attribute name="maxChoices" use="optional" type="xs:nonNegativeInteger" />
    </xs:attributeGroup>

    <xs:attributeGroup name="minChoices.OrderInteraction.Attr">
        <xs:attribute name="minChoices" use="optional" type="xs:nonNegativeInteger" />
    </xs:attributeGroup>

    <xs:attributeGroup name="orientation.OrderInteraction.Attr">
        <xs:attribute name="orientation" use="optional">
            <xs:simpleType>
                <xs:restriction base="xs:string">
                    <xs:enumeration value="horizontal" />
                    <xs:enumeration value="vertical" />
                </xs:restriction>
            </xs:simpleType>
        </xs:attribute>
    </xs:attributeGroup>

    <xs:attributeGroup name="responseIdentifier.OrderInteraction.Attr">
        <xs:attribute name="responseIdentifier" use="required" type="Identifier.Type" />
    </xs:attributeGroup>

    <xs:attributeGroup name="shuffle.OrderInteraction.Attr">
        <xs:attribute name="shuffle" use="optional" default="false" type="xs:boolean" />
    </xs:attributeGroup>

    <xs:attributeGroup name="xmlbase.OrderInteraction.Attr">
        <xs:attribute ref="xml:base" use="optional" />
    </xs:attributeGroup>

    <xs:attributeGroup name="xmllang.OrderInteraction.Attr">
        <xs:attribute ref="xml:lang" use="optional" />
    </xs:attributeGroup>

    <xs:attributeGroup name="class.OUL.Attr">
        <xs:attribute name="class" use="optional">
            <xs:simpleType>
                <xs:list itemType="StringList.Type" />
            </xs:simpleType>
        </xs:attribute>
    </xs:attributeGroup>

    <xs:attributeGroup name="id.OUL.Attr">
        <xs:attribute name="id" use="optional" type="UniqueIdentifier.Type" />
    </xs:attributeGroup>

    <xs:attributeGroup name="label.OUL.Attr">
        <xs:attribute name="label" use="optional" type="xs:string" />
    </xs:attributeGroup>

    <xs:attributeGroup name="xmlbase.OUL.Attr">
        <xs:attribute ref="xml:base" use="optional" />
    </xs:attributeGroup>

    <xs:attributeGroup name="xmllang.OUL.Attr">
        <xs:attribute ref="xml:lang" use="optional" />
    </xs:attributeGroup>

    <xs:attributeGroup name="baseType.OutcomeDeclaration.Attr">
        <xs:attribute name="baseType" use="optional">
            <xs:simpleType>
                <xs:restriction base="xs:string">
                    <xs:enumeration value="boolean" />
                    <xs:enumeration value="directedPair" />
                    <xs:enumeration value="duration" />
                    <xs:enumeration value="file" />
                    <xs:enumeration value="float" />
                    <xs:enumeration value="identifier" />
                    <xs:enumeration value="integer" />
                    <xs:enumeration value="pair" />
                    <xs:enumeration value="point" />
                    <xs:enumeration value="string" />
                    <xs:enumeration value="uri" />
                </xs:restriction>
            </xs:simpleType>
        </xs:attribute>
    </xs:attributeGroup>

    <xs:attributeGroup name="cardinality.OutcomeDeclaration.Attr">
        <xs:attribute name="cardinality" use="required">
            <xs:simpleType>
                <xs:restriction base="xs:string">
                    <xs:enumeration value="multiple" />
                    <xs:enumeration value="ordered" />
                    <xs:enumeration value="record" />
                    <xs:enumeration value="single" />
                </xs:restriction>
            </xs:simpleType>
        </xs:attribute>
    </xs:attributeGroup>

    <xs:attributeGroup name="identifier.OutcomeDeclaration.Attr">
        <xs:attribute name="identifier" use="required" type="Identifier.Type" />
    </xs:attributeGroup>

    <xs:attributeGroup name="interpretation.OutcomeDeclaration.Attr">
        <xs:attribute name="interpretation" use="optional" type="xs:string" />
    </xs:attributeGroup>

    <xs:attributeGroup name="longInterpretation.OutcomeDeclaration.Attr">
        <xs:attribute name="longInterpretation" use="optional" type="xs:anyURI" />
    </xs:attributeGroup>

    <xs:attributeGroup name="masteryValue.OutcomeDeclaration.Attr">
        <xs:attribute name="masteryValue" use="optional" type="xs:double" />
    </xs:attributeGroup>

    <xs:attributeGroup name="normalMaximum.OutcomeDeclaration.Attr">
        <xs:attribute name="normalMaximum" use="optional" type="xs:double" />
    </xs:attributeGroup>

    <xs:attributeGroup name="normalMinimum.OutcomeDeclaration.Attr">
        <xs:attribute name="normalMinimum" use="optional" type="xs:double" />
    </xs:attributeGroup>

    <xs:attributeGroup name="view.OutcomeDeclaration.Attr">
        <xs:attribute name="view" use="optional">
            <xs:simpleType>
                <xs:list itemType="View.Type" />
            </xs:simpleType>
        </xs:attribute>
    </xs:attributeGroup>

    <xs:attributeGroup name="excludeCategory.OutcomeMinMax.Attr">
        <xs:attribute name="excludeCategory" use="optional">
            <xs:simpleType>
                <xs:list itemType="IdentifierList.Type" />
            </xs:simpleType>
        </xs:attribute>
    </xs:attributeGroup>

    <xs:attributeGroup name="includeCategory.OutcomeMinMax.Attr">
        <xs:attribute name="includeCategory" use="optional">
            <xs:simpleType>
                <xs:list itemType="IdentifierList.Type" />
            </xs:simpleType>
        </xs:attribute>
    </xs:attributeGroup>

    <xs:attributeGroup name="outcomeIdentifier.OutcomeMinMax.Attr">
        <xs:attribute name="outcomeIdentifier" use="required" type="Identifier.Type" />
    </xs:attributeGroup>

    <xs:attributeGroup name="sectionIdentifier.OutcomeMinMax.Attr">
        <xs:attribute name="sectionIdentifier" use="optional" type="Identifier.Type" />
    </xs:attributeGroup>

    <xs:attributeGroup name="weightIdentifier.OutcomeMinMax.Attr">
        <xs:attribute name="weightIdentifier" use="optional" type="Identifier.Type" />
    </xs:attributeGroup>

    <xs:attributeGroup name="name.Param.Attr">
        <xs:attribute name="name" use="required" type="xs:string" />
    </xs:attributeGroup>

    <xs:attributeGroup name="type.Param.Attr">
        <xs:attribute name="type" use="optional" type="MimeType.Type" />
    </xs:attributeGroup>

    <xs:attributeGroup name="value.Param.Attr">
        <xs:attribute name="value" use="required" type="xs:string" />
    </xs:attributeGroup>

    <xs:attributeGroup name="valuetype.Param.Attr">
        <xs:attribute name="valuetype" use="required">
            <xs:simpleType>
                <xs:restriction base="xs:string">
                    <xs:enumeration value="DATA" />
                    <xs:enumeration value="REF" />
                </xs:restriction>
            </xs:simpleType>
        </xs:attribute>
    </xs:attributeGroup>

    <xs:attributeGroup name="pattern.PatternMatch.Attr">
        <xs:attribute name="pattern" use="required">
            <xs:simpleType>
                <xs:union>
                    <xs:simpleType>
                        <xs:restriction base="xs:string" />
                    </xs:simpleType>
                    <xs:simpleType>
                        <xs:restriction base="EncVariableString.Type" />
                    </xs:simpleType>
                </xs:union>
            </xs:simpleType>
        </xs:attribute>
    </xs:attributeGroup>

    <xs:attributeGroup name="centerPoint.PositionObjectInteraction.Attr">
        <xs:attribute name="centerPoint" use="optional">
            <xs:simpleType>
                <xs:list itemType="IntegerList.Type" />
            </xs:simpleType>
        </xs:attribute>
    </xs:attributeGroup>

    <xs:attributeGroup name="class.PositionObjectInteraction.Attr">
        <xs:attribute name="class" use="optional">
            <xs:simpleType>
                <xs:list itemType="StringList.Type" />
            </xs:simpleType>
        </xs:attribute>
    </xs:attributeGroup>

    <xs:attributeGroup name="id.PositionObjectInteraction.Attr">
        <xs:attribute name="id" use="optional" type="UniqueIdentifier.Type" />
    </xs:attributeGroup>

    <xs:attributeGroup name="label.PositionObjectInteraction.Attr">
        <xs:attribute name="label" use="optional" type="xs:string" />
    </xs:attributeGroup>

    <xs:attributeGroup name="maxChoices.PositionObjectInteraction.Attr">
        <xs:attribute name="maxChoices" use="optional" default="0" type="xs:nonNegativeInteger" />
    </xs:attributeGroup>

    <xs:attributeGroup name="minChoices.PositionObjectInteraction.Attr">
        <xs:attribute name="minChoices" use="optional" type="xs:nonNegativeInteger" />
    </xs:attributeGroup>

    <xs:attributeGroup name="responseIdentifier.PositionObjectInteraction.Attr">
        <xs:attribute name="responseIdentifier" use="required" type="Identifier.Type" />
    </xs:attributeGroup>

    <xs:attributeGroup name="xmllang.PositionObjectInteraction.Attr">
        <xs:attribute ref="xml:lang" use="optional" />
    </xs:attributeGroup>

    <xs:attributeGroup name="base.PrintedVariable.Attr">
        <xs:attribute name="base" use="optional" default="10">
            <xs:simpleType>
                <xs:union>
                    <xs:simpleType>
                        <xs:restriction base="xs:integer" />
                    </xs:simpleType>
                    <xs:simpleType>
                        <xs:restriction base="VariableString.Type" />
                    </xs:simpleType>
                </xs:union>
            </xs:simpleType>
        </xs:attribute>
    </xs:attributeGroup>

    <xs:attributeGroup name="class.PrintedVariable.Attr">
        <xs:attribute name="class" use="optional">
            <xs:simpleType>
                <xs:list itemType="StringList.Type" />
            </xs:simpleType>
        </xs:attribute>
    </xs:attributeGroup>

    <xs:attributeGroup name="delimiter.PrintedVariable.Attr">
        <xs:attribute name="delimiter" use="optional" default=";" type="xs:normalizedString" />
    </xs:attributeGroup>

    <xs:attributeGroup name="field.PrintedVariable.Attr">
        <xs:attribute name="field" use="optional" type="xs:normalizedString" />
    </xs:attributeGroup>

    <xs:attributeGroup name="format.PrintedVariable.Attr">
        <xs:attribute name="format" use="optional" type="xs:normalizedString" />
    </xs:attributeGroup>

    <xs:attributeGroup name="id.PrintedVariable.Attr">
        <xs:attribute name="id" use="optional" type="Identifier.Type" />
    </xs:attributeGroup>

    <xs:attributeGroup name="identifier.PrintedVariable.Attr">
        <xs:attribute name="identifier" use="required" type="Identifier.Type" />
    </xs:attributeGroup>

    <xs:attributeGroup name="index.PrintedVariable.Attr">
        <xs:attribute name="index" use="optional">
            <xs:simpleType>
                <xs:union>
                    <xs:simpleType>
                        <xs:restriction base="xs:integer" />
                    </xs:simpleType>
                    <xs:simpleType>
                        <xs:restriction base="VariableString.Type" />
                    </xs:simpleType>
                </xs:union>
            </xs:simpleType>
        </xs:attribute>
    </xs:attributeGroup>

    <xs:attributeGroup name="label.PrintedVariable.Attr">
        <xs:attribute name="label" use="optional" type="xs:string" />
    </xs:attributeGroup>

    <xs:attributeGroup name="mappingIndicator.PrintedVariable.Attr">
        <xs:attribute name="mappingIndicator" use="optional" default="=" type="xs:normalizedString" />
    </xs:attributeGroup>

    <xs:attributeGroup name="powerForm.PrintedVariable.Attr">
        <xs:attribute name="powerForm" use="optional" default="false" type="xs:boolean" />
    </xs:attributeGroup>

    <xs:attributeGroup name="xmlbase.PrintedVariable.Attr">
        <xs:attribute ref="xml:base" use="optional" />
    </xs:attributeGroup>

    <xs:attributeGroup name="xmllang.PrintedVariable.Attr">
        <xs:attribute ref="xml:lang" use="optional" />
    </xs:attributeGroup>

    <xs:attributeGroup name="class.Prompt.Attr">
        <xs:attribute name="class" use="optional">
            <xs:simpleType>
                <xs:list itemType="StringList.Type" />
            </xs:simpleType>
        </xs:attribute>
    </xs:attributeGroup>

    <xs:attributeGroup name="id.Prompt.Attr">
        <xs:attribute name="id" use="optional" type="UniqueIdentifier.Type" />
    </xs:attributeGroup>

    <xs:attributeGroup name="label.Prompt.Attr">
        <xs:attribute name="label" use="optional" type="xs:string" />
    </xs:attributeGroup>

    <xs:attributeGroup name="xmllang.Prompt.Attr">
        <xs:attribute ref="xml:lang" use="optional" />
    </xs:attributeGroup>

    <xs:attributeGroup name="cite.Q.Attr">
        <xs:attribute name="cite" use="optional" type="xs:anyURI" />
    </xs:attributeGroup>

    <xs:attributeGroup name="class.Q.Attr">
        <xs:attribute name="class" use="optional">
            <xs:simpleType>
                <xs:list itemType="StringList.Type" />
            </xs:simpleType>
        </xs:attribute>
    </xs:attributeGroup>

    <xs:attributeGroup name="id.Q.Attr">
        <xs:attribute name="id" use="optional" type="UniqueIdentifier.Type" />
    </xs:attributeGroup>

    <xs:attributeGroup name="label.Q.Attr">
        <xs:attribute name="label" use="optional" type="xs:string" />
    </xs:attributeGroup>

    <xs:attributeGroup name="xmlbase.Q.Attr">
        <xs:attribute ref="xml:base" use="optional" />
    </xs:attributeGroup>

    <xs:attributeGroup name="xmllang.Q.Attr">
        <xs:attribute ref="xml:lang" use="optional" />
    </xs:attributeGroup>

    <xs:attributeGroup name="max.RandomFloat.Attr">
        <xs:attribute name="max" use="required">
            <xs:simpleType>
                <xs:union>
                    <xs:simpleType>
                        <xs:restriction base="xs:double" />
                    </xs:simpleType>
                    <xs:simpleType>
                        <xs:restriction base="VariableString.Type" />
                    </xs:simpleType>
                </xs:union>
            </xs:simpleType>
        </xs:attribute>
    </xs:attributeGroup>

    <xs:attributeGroup name="min.RandomFloat.Attr">
        <xs:attribute name="min" use="optional" default="0">
            <xs:simpleType>
                <xs:union>
                    <xs:simpleType>
                        <xs:restriction base="xs:double" />
                    </xs:simpleType>
                    <xs:simpleType>
                        <xs:restriction base="VariableString.Type" />
                    </xs:simpleType>
                </xs:union>
            </xs:simpleType>
        </xs:attribute>
    </xs:attributeGroup>

    <xs:attributeGroup name="max.RandomInteger.Attr">
        <xs:attribute name="max" use="required">
            <xs:simpleType>
                <xs:union>
                    <xs:simpleType>
                        <xs:restriction base="xs:integer" />
                    </xs:simpleType>
                    <xs:simpleType>
                        <xs:restriction base="VariableString.Type" />
                    </xs:simpleType>
                </xs:union>
            </xs:simpleType>
        </xs:attribute>
    </xs:attributeGroup>

    <xs:attributeGroup name="min.RandomInteger.Attr">
        <xs:attribute name="min" use="optional" default="0">
            <xs:simpleType>
                <xs:union>
                    <xs:simpleType>
                        <xs:restriction base="xs:integer" />
                    </xs:simpleType>
                    <xs:simpleType>
                        <xs:restriction base="VariableString.Type" />
                    </xs:simpleType>
                </xs:union>
            </xs:simpleType>
        </xs:attribute>
    </xs:attributeGroup>

    <xs:attributeGroup name="step.RandomInteger.Attr">
        <xs:attribute name="step" use="optional" default="1">
            <xs:simpleType>
                <xs:union>
                    <xs:simpleType>
                        <xs:restriction base="xs:integer" />
                    </xs:simpleType>
                    <xs:simpleType>
                        <xs:restriction base="VariableString.Type" />
                    </xs:simpleType>
                </xs:union>
            </xs:simpleType>
        </xs:attribute>
    </xs:attributeGroup>

    <xs:attributeGroup name="baseType.ResponseDeclaration.Attr">
        <xs:attribute name="baseType" use="optional">
            <xs:simpleType>
                <xs:restriction base="xs:string">
                    <xs:enumeration value="boolean" />
                    <xs:enumeration value="directedPair" />
                    <xs:enumeration value="duration" />
                    <xs:enumeration value="file" />
                    <xs:enumeration value="float" />
                    <xs:enumeration value="identifier" />
                    <xs:enumeration value="integer" />
                    <xs:enumeration value="pair" />
                    <xs:enumeration value="point" />
                    <xs:enumeration value="string" />
                    <xs:enumeration value="uri" />
                </xs:restriction>
            </xs:simpleType>
        </xs:attribute>
    </xs:attributeGroup>

    <xs:attributeGroup name="cardinality.ResponseDeclaration.Attr">
        <xs:attribute name="cardinality" use="required">
            <xs:simpleType>
                <xs:restriction base="xs:string">
                    <xs:enumeration value="multiple" />
                    <xs:enumeration value="ordered" />
                    <xs:enumeration value="record" />
                    <xs:enumeration value="single" />
                </xs:restriction>
            </xs:simpleType>
        </xs:attribute>
    </xs:attributeGroup>

    <xs:attributeGroup name="identifier.ResponseDeclaration.Attr">
        <xs:attribute name="identifier" use="required" type="UniqueIdentifier.Type" />
    </xs:attributeGroup>

    <xs:attributeGroup name="template.ResponseProcessing.Attr">
        <xs:attribute name="template" use="optional" type="xs:anyURI" />
    </xs:attributeGroup>

    <xs:attributeGroup name="templateLocation.ResponseProcessing.Attr">
        <xs:attribute name="templateLocation" use="optional" type="xs:anyURI" />
    </xs:attributeGroup>

    <xs:attributeGroup name="figures.RoundTo.Attr">
        <xs:attribute name="figures" use="required">
            <xs:simpleType>
                <xs:union>
                    <xs:simpleType>
                        <xs:restriction base="xs:integer" />
                    </xs:simpleType>
                    <xs:simpleType>
                        <xs:restriction base="VariableString.Type" />
                    </xs:simpleType>
                </xs:union>
            </xs:simpleType>
        </xs:attribute>
    </xs:attributeGroup>

    <xs:attributeGroup name="roundingMode.RoundTo.Attr">
        <xs:attribute name="roundingMode" use="required">
            <xs:simpleType>
                <xs:restriction base="xs:string">
                    <xs:enumeration value="decimalPlaces" />
                    <xs:enumeration value="significantFigures" />
                </xs:restriction>
            </xs:simpleType>
        </xs:attribute>
    </xs:attributeGroup>

    <xs:attributeGroup name="class.RubricBlock.Attr">
        <xs:attribute name="class" use="optional">
            <xs:simpleType>
                <xs:list itemType="StringList.Type" />
            </xs:simpleType>
        </xs:attribute>
    </xs:attributeGroup>

    <xs:attributeGroup name="id.RubricBlock.Attr">
        <xs:attribute name="id" use="optional" type="Identifier.Type" />
    </xs:attributeGroup>

    <xs:attributeGroup name="label.RubricBlock.Attr">
        <xs:attribute name="label" use="optional" type="xs:string" />
    </xs:attributeGroup>

    <xs:attributeGroup name="use.RubricBlock.Attr">
        <xs:attribute name="use" use="optional" type="xs:normalizedString" />
    </xs:attributeGroup>

    <xs:attributeGroup name="view.RubricBlock.Attr">
        <xs:attribute name="view" use="required">
            <xs:simpleType>
                <xs:list itemType="View.Type" />
            </xs:simpleType>
        </xs:attribute>
    </xs:attributeGroup>

    <xs:attributeGroup name="xmlbase.RubricBlock.Attr">
        <xs:attribute ref="xml:base" use="optional" />
    </xs:attributeGroup>

    <xs:attributeGroup name="xmllang.RubricBlock.Attr">
        <xs:attribute ref="xml:lang" use="optional" />
    </xs:attributeGroup>

    <xs:attributeGroup name="class.RubricBlockTemplateBlock.Attr">
        <xs:attribute name="class" use="optional">
            <xs:simpleType>
                <xs:list itemType="StringList.Type" />
            </xs:simpleType>
        </xs:attribute>
    </xs:attributeGroup>

    <xs:attributeGroup name="id.RubricBlockTemplateBlock.Attr">
        <xs:attribute name="id" use="optional" type="Identifier.Type" />
    </xs:attributeGroup>

    <xs:attributeGroup name="identifier.RubricBlockTemplateBlock.Attr">
        <xs:attribute name="identifier" use="required" type="Identifier.Type" />
    </xs:attributeGroup>

    <xs:attributeGroup name="label.RubricBlockTemplateBlock.Attr">
        <xs:attribute name="label" use="optional" type="xs:string" />
    </xs:attributeGroup>

    <xs:attributeGroup name="showHide.RubricBlockTemplateBlock.Attr">
        <xs:attribute name="showHide" use="optional" default="show">
            <xs:simpleType>
                <xs:restriction base="xs:string">
                    <xs:enumeration value="show" />
                    <xs:enumeration value="hide" />
                </xs:restriction>
            </xs:simpleType>
        </xs:attribute>
    </xs:attributeGroup>

    <xs:attributeGroup name="templateIdentifier.RubricBlockTemplateBlock.Attr">
        <xs:attribute name="templateIdentifier" use="required" type="Identifier.Type" />
    </xs:attributeGroup>

    <xs:attributeGroup name="xmlbase.RubricBlockTemplateBlock.Attr">
        <xs:attribute ref="xml:base" use="optional" />
    </xs:attributeGroup>

    <xs:attributeGroup name="xmllang.RubricBlockTemplateBlock.Attr">
        <xs:attribute ref="xml:lang" use="optional" />
    </xs:attributeGroup>

    <xs:attributeGroup name="class.RubricBlockTemplateInline.Attr">
        <xs:attribute name="class" use="optional">
            <xs:simpleType>
                <xs:list itemType="StringList.Type" />
            </xs:simpleType>
        </xs:attribute>
    </xs:attributeGroup>

    <xs:attributeGroup name="id.RubricBlockTemplateInline.Attr">
        <xs:attribute name="id" use="optional" type="Identifier.Type" />
    </xs:attributeGroup>

    <xs:attributeGroup name="identifier.RubricBlockTemplateInline.Attr">
        <xs:attribute name="identifier" use="required" type="Identifier.Type" />
    </xs:attributeGroup>

    <xs:attributeGroup name="label.RubricBlockTemplateInline.Attr">
        <xs:attribute name="label" use="optional" type="xs:string" />
    </xs:attributeGroup>

    <xs:attributeGroup name="showHide.RubricBlockTemplateInline.Attr">
        <xs:attribute name="showHide" use="optional" default="show">
            <xs:simpleType>
                <xs:restriction base="xs:string">
                    <xs:enumeration value="show" />
                    <xs:enumeration value="hide" />
                </xs:restriction>
            </xs:simpleType>
        </xs:attribute>
    </xs:attributeGroup>

    <xs:attributeGroup name="templateIdentifier.RubricBlockTemplateInline.Attr">
        <xs:attribute name="templateIdentifier" use="required" type="Identifier.Type" />
    </xs:attributeGroup>

    <xs:attributeGroup name="xmlbase.RubricBlockTemplateInline.Attr">
        <xs:attribute ref="xml:base" use="optional" />
    </xs:attributeGroup>

    <xs:attributeGroup name="xmllang.RubricBlockTemplateInline.Attr">
        <xs:attribute ref="xml:lang" use="optional" />
    </xs:attributeGroup>

    <xs:attributeGroup name="extension.Selection.Attr">
        <xs:anyAttribute namespace = "##other" processContents = "strict" />
    </xs:attributeGroup>

    <xs:attributeGroup name="select.Selection.Attr">
        <xs:attribute name="select" use="required" type="xs:int" />
    </xs:attributeGroup>

    <xs:attributeGroup name="withReplacement.Selection.Attr">
        <xs:attribute name="withReplacement" use="optional" default="false" type="xs:boolean" />
    </xs:attributeGroup>

    <xs:attributeGroup name="class.SelectPointInteraction.Attr">
        <xs:attribute name="class" use="optional">
            <xs:simpleType>
                <xs:list itemType="StringList.Type" />
            </xs:simpleType>
        </xs:attribute>
    </xs:attributeGroup>

    <xs:attributeGroup name="id.SelectPointInteraction.Attr">
        <xs:attribute name="id" use="optional" type="UniqueIdentifier.Type" />
    </xs:attributeGroup>

    <xs:attributeGroup name="label.SelectPointInteraction.Attr">
        <xs:attribute name="label" use="optional" type="xs:string" />
    </xs:attributeGroup>

    <xs:attributeGroup name="maxChoices.SelectPointInteraction.Attr">
        <xs:attribute name="maxChoices" use="optional" default="0" type="xs:nonNegativeInteger" />
    </xs:attributeGroup>

    <xs:attributeGroup name="minChoices.SelectPointInteraction.Attr">
        <xs:attribute name="minChoices" use="optional" default="0" type="xs:nonNegativeInteger" />
    </xs:attributeGroup>

    <xs:attributeGroup name="responseIdentifier.SelectPointInteraction.Attr">
        <xs:attribute name="responseIdentifier" use="required" type="Identifier.Type" />
    </xs:attributeGroup>

    <xs:attributeGroup name="xmlbase.SelectPointInteraction.Attr">
        <xs:attribute ref="xml:base" use="optional" />
    </xs:attributeGroup>

    <xs:attributeGroup name="xmllang.SelectPointInteraction.Attr">
        <xs:attribute ref="xml:lang" use="optional" />
    </xs:attributeGroup>

    <xs:attributeGroup name="identifier.SetValue.Attr">
        <xs:attribute name="identifier" use="required" type="Identifier.Type" />
    </xs:attributeGroup>

    <xs:attributeGroup name="class.SimpleAssociableChoice.Attr">
        <xs:attribute name="class" use="optional">
            <xs:simpleType>
                <xs:list itemType="StringList.Type" />
            </xs:simpleType>
        </xs:attribute>
    </xs:attributeGroup>

    <xs:attributeGroup name="fixed.SimpleAssociableChoice.Attr">
        <xs:attribute name="fixed" use="optional" type="xs:boolean" />
    </xs:attributeGroup>

    <xs:attributeGroup name="id.SimpleAssociableChoice.Attr">
        <xs:attribute name="id" use="optional" type="UniqueIdentifier.Type" />
    </xs:attributeGroup>

    <xs:attributeGroup name="identifier.SimpleAssociableChoice.Attr">
        <xs:attribute name="identifier" use="required" type="Identifier.Type" />
    </xs:attributeGroup>

    <xs:attributeGroup name="label.SimpleAssociableChoice.Attr">
        <xs:attribute name="label" use="optional" type="xs:string" />
    </xs:attributeGroup>

    <xs:attributeGroup name="matchGroup.SimpleAssociableChoice.Attr">
        <xs:attribute name="matchGroup" use="optional">
            <xs:simpleType>
                <xs:list itemType="IdentifierList.Type" />
            </xs:simpleType>
        </xs:attribute>
    </xs:attributeGroup>

    <xs:attributeGroup name="matchMax.SimpleAssociableChoice.Attr">
        <xs:attribute name="matchMax" use="required" type="xs:nonNegativeInteger" />
    </xs:attributeGroup>

    <xs:attributeGroup name="matchMin.SimpleAssociableChoice.Attr">
        <xs:attribute name="matchMin" use="optional" default="0" type="xs:nonNegativeInteger" />
    </xs:attributeGroup>

    <xs:attributeGroup name="showHide.SimpleAssociableChoice.Attr">
        <xs:attribute name="showHide" use="optional">
            <xs:simpleType>
                <xs:restriction base="xs:string">
                    <xs:enumeration value="show" />
                    <xs:enumeration value="hide" />
                </xs:restriction>
            </xs:simpleType>
        </xs:attribute>
    </xs:attributeGroup>

    <xs:attributeGroup name="templateIdentifier.SimpleAssociableChoice.Attr">
        <xs:attribute name="templateIdentifier" use="optional" type="Identifier.Type" />
    </xs:attributeGroup>

    <xs:attributeGroup name="xmllang.SimpleAssociableChoice.Attr">
        <xs:attribute ref="xml:lang" use="optional" />
    </xs:attributeGroup>

    <xs:attributeGroup name="class.SimpleChoice.Attr">
        <xs:attribute name="class" use="optional">
            <xs:simpleType>
                <xs:list itemType="StringList.Type" />
            </xs:simpleType>
        </xs:attribute>
    </xs:attributeGroup>

    <xs:attributeGroup name="fixed.SimpleChoice.Attr">
        <xs:attribute name="fixed" use="optional" default="false" type="xs:boolean" />
    </xs:attributeGroup>

    <xs:attributeGroup name="id.SimpleChoice.Attr">
        <xs:attribute name="id" use="optional" type="UniqueIdentifier.Type" />
    </xs:attributeGroup>

    <xs:attributeGroup name="identifier.SimpleChoice.Attr">
        <xs:attribute name="identifier" use="required" type="Identifier.Type" />
    </xs:attributeGroup>

    <xs:attributeGroup name="label.SimpleChoice.Attr">
        <xs:attribute name="label" use="optional" type="xs:string" />
    </xs:attributeGroup>

    <xs:attributeGroup name="showHide.SimpleChoice.Attr">
        <xs:attribute name="showHide" use="optional" default="show">
            <xs:simpleType>
                <xs:restriction base="xs:string">
                    <xs:enumeration value="show" />
                    <xs:enumeration value="hide" />
                </xs:restriction>
            </xs:simpleType>
        </xs:attribute>
    </xs:attributeGroup>

    <xs:attributeGroup name="templateIdentifier.SimpleChoice.Attr">
        <xs:attribute name="templateIdentifier" use="optional" type="Identifier.Type" />
    </xs:attributeGroup>

    <xs:attributeGroup name="xmllang.SimpleChoice.Attr">
        <xs:attribute ref="xml:lang" use="optional" />
    </xs:attributeGroup>

    <xs:attributeGroup name="class.SliderInteraction.Attr">
        <xs:attribute name="class" use="optional">
            <xs:simpleType>
                <xs:list itemType="StringList.Type" />
            </xs:simpleType>
        </xs:attribute>
    </xs:attributeGroup>

    <xs:attributeGroup name="id.SliderInteraction.Attr">
        <xs:attribute name="id" use="optional" type="UniqueIdentifier.Type" />
    </xs:attributeGroup>

    <xs:attributeGroup name="label.SliderInteraction.Attr">
        <xs:attribute name="label" use="optional" type="xs:string" />
    </xs:attributeGroup>

    <xs:attributeGroup name="lowerBound.SliderInteraction.Attr">
        <xs:attribute name="lowerBound" use="required" type="NonNegativeDouble.Type" />
    </xs:attributeGroup>

    <xs:attributeGroup name="orientation.SliderInteraction.Attr">
        <xs:attribute name="orientation" use="optional">
            <xs:simpleType>
                <xs:restriction base="xs:string">
                    <xs:enumeration value="horizontal" />
                    <xs:enumeration value="vertical" />
                </xs:restriction>
            </xs:simpleType>
        </xs:attribute>
    </xs:attributeGroup>

    <xs:attributeGroup name="responseIdentifier.SliderInteraction.Attr">
        <xs:attribute name="responseIdentifier" use="required" type="Identifier.Type" />
    </xs:attributeGroup>

    <xs:attributeGroup name="reverse.SliderInteraction.Attr">
        <xs:attribute name="reverse" use="optional" type="xs:boolean" />
    </xs:attributeGroup>

    <xs:attributeGroup name="step.SliderInteraction.Attr">
        <xs:attribute name="step" use="optional" default="1.0" type="NonNegativeDouble.Type" />
    </xs:attributeGroup>

    <xs:attributeGroup name="stepLabel.SliderInteraction.Attr">
        <xs:attribute name="stepLabel" use="optional" default="false" type="xs:boolean" />
    </xs:attributeGroup>

    <xs:attributeGroup name="upperBound.SliderInteraction.Attr">
        <xs:attribute name="upperBound" use="required" type="NonNegativeDouble.Type" />
    </xs:attributeGroup>

    <xs:attributeGroup name="xmlbase.SliderInteraction.Attr">
        <xs:attribute ref="xml:base" use="optional" />
    </xs:attributeGroup>

    <xs:attributeGroup name="xmllang.SliderInteraction.Attr">
        <xs:attribute ref="xml:lang" use="optional" />
    </xs:attributeGroup>

    <xs:attributeGroup name="name.StatsOperator.Attr">
        <xs:attribute name="name" use="required">
            <xs:simpleType>
                <xs:restriction base="xs:string">
                    <xs:enumeration value="mean" />
                    <xs:enumeration value="sampleVariance" />
                    <xs:enumeration value="sampleSD" />
                    <xs:enumeration value="popVariance" />
                    <xs:enumeration value="popSD" />
                </xs:restriction>
            </xs:simpleType>
        </xs:attribute>
    </xs:attributeGroup>

    <xs:attributeGroup name="caseSensitive.StringMatch.Attr">
        <xs:attribute name="caseSensitive" use="required" type="xs:boolean" />
    </xs:attributeGroup>

    <xs:attributeGroup name="substring.StringMatch.Attr">
        <xs:attribute name="substring" use="optional" default="false" type="xs:boolean" />
    </xs:attributeGroup>

    <xs:attributeGroup name="href.StyleSheet.Attr">
        <xs:attribute name="href" use="required" type="xs:anyURI" />
    </xs:attributeGroup>

    <xs:attributeGroup name="media.StyleSheet.Attr">
        <xs:attribute name="media" use="optional" type="xs:normalizedString" />
    </xs:attributeGroup>

    <xs:attributeGroup name="title.StyleSheet.Attr">
        <xs:attribute name="title" use="optional" type="xs:normalizedString" />
    </xs:attributeGroup>

    <xs:attributeGroup name="type.StyleSheet.Attr">
        <xs:attribute name="type" use="required" type="MimeType.Type" />
    </xs:attributeGroup>

    <xs:attributeGroup name="caseSensitive.Substring.Attr">
        <xs:attribute name="caseSensitive" use="required" type="xs:boolean" />
    </xs:attributeGroup>

    <xs:attributeGroup name="class.Table.Attr">
        <xs:attribute name="class" use="optional">
            <xs:simpleType>
                <xs:list itemType="StringList.Type" />
            </xs:simpleType>
        </xs:attribute>
    </xs:attributeGroup>

    <xs:attributeGroup name="id.Table.Attr">
        <xs:attribute name="id" use="optional" type="UniqueIdentifier.Type" />
    </xs:attributeGroup>

    <xs:attributeGroup name="label.Table.Attr">
        <xs:attribute name="label" use="optional" type="xs:string" />
    </xs:attributeGroup>

    <xs:attributeGroup name="summary.Table.Attr">
        <xs:attribute name="summary" use="optional" type="xs:string" />
    </xs:attributeGroup>

    <xs:attributeGroup name="xmlbase.Table.Attr">
        <xs:attribute ref="xml:base" use="optional" />
    </xs:attributeGroup>

    <xs:attributeGroup name="xmllang.Table.Attr">
        <xs:attribute ref="xml:lang" use="optional" />
    </xs:attributeGroup>

    <xs:attributeGroup name="class.TablePart.Attr">
        <xs:attribute name="class" use="optional">
            <xs:simpleType>
                <xs:list itemType="StringList.Type" />
            </xs:simpleType>
        </xs:attribute>
    </xs:attributeGroup>

    <xs:attributeGroup name="id.TablePart.Attr">
        <xs:attribute name="id" use="optional" type="UniqueIdentifier.Type" />
    </xs:attributeGroup>

    <xs:attributeGroup name="label.TablePart.Attr">
        <xs:attribute name="label" use="optional" type="xs:string" />
    </xs:attributeGroup>

    <xs:attributeGroup name="xmllang.TablePart.Attr">
        <xs:attribute ref="xml:lang" use="optional" />
    </xs:attributeGroup>

    <xs:attributeGroup name="abbr.TDH.Attr">
        <xs:attribute name="abbr" use="optional" type="xs:string" />
    </xs:attributeGroup>

    <xs:attributeGroup name="align.TDH.Attr">
        <xs:attribute name="align" use="optional">
            <xs:simpleType>
                <xs:restriction base="xs:string">
                    <xs:enumeration value="left" />
                    <xs:enumeration value="center" />
                    <xs:enumeration value="right" />
                    <xs:enumeration value="justify" />
                    <xs:enumeration value="char" />
                </xs:restriction>
            </xs:simpleType>
        </xs:attribute>
    </xs:attributeGroup>

    <xs:attributeGroup name="axis.TDH.Attr">
        <xs:attribute name="axis" use="optional" type="xs:string" />
    </xs:attributeGroup>

    <xs:attributeGroup name="class.TDH.Attr">
        <xs:attribute name="class" use="optional">
            <xs:simpleType>
                <xs:list itemType="StringList.Type" />
            </xs:simpleType>
        </xs:attribute>
    </xs:attributeGroup>

    <xs:attributeGroup name="colspan.TDH.Attr">
        <xs:attribute name="colspan" use="optional" type="xs:int" />
    </xs:attributeGroup>

    <xs:attributeGroup name="headers.TDH.Attr">
        <xs:attribute name="headers" use="optional" type="Identifier.Type" />
    </xs:attributeGroup>

    <xs:attributeGroup name="id.TDH.Attr">
        <xs:attribute name="id" use="optional" type="UniqueIdentifier.Type" />
    </xs:attributeGroup>

    <xs:attributeGroup name="label.TDH.Attr">
        <xs:attribute name="label" use="optional" type="xs:string" />
    </xs:attributeGroup>

    <xs:attributeGroup name="rowspan.TDH.Attr">
        <xs:attribute name="rowspan" use="optional" type="xs:int" />
    </xs:attributeGroup>

    <xs:attributeGroup name="scope.TDH.Attr">
        <xs:attribute name="scope" use="optional">
            <xs:simpleType>
                <xs:restriction base="xs:string">
                    <xs:enumeration value="col" />
                    <xs:enumeration value="colgroup" />
                    <xs:enumeration value="row" />
                    <xs:enumeration value="rowgroup" />
                </xs:restriction>
            </xs:simpleType>
        </xs:attribute>
    </xs:attributeGroup>

    <xs:attributeGroup name="valign.TDH.Attr">
        <xs:attribute name="valign" use="optional">
            <xs:simpleType>
                <xs:restriction base="xs:string">
                    <xs:enumeration value="bottom" />
                    <xs:enumeration value="middle" />
                    <xs:enumeration value="top" />
                    <xs:enumeration value="baseline" />
                </xs:restriction>
            </xs:simpleType>
        </xs:attribute>
    </xs:attributeGroup>

    <xs:attributeGroup name="xmllang.TDH.Attr">
        <xs:attribute ref="xml:lang" use="optional" />
    </xs:attributeGroup>

    <xs:attributeGroup name="class.TemplateBlock.Attr">
        <xs:attribute name="class" use="optional">
            <xs:simpleType>
                <xs:list itemType="StringList.Type" />
            </xs:simpleType>
        </xs:attribute>
    </xs:attributeGroup>

    <xs:attributeGroup name="id.TemplateBlock.Attr">
        <xs:attribute name="id" use="optional" type="Identifier.Type" />
    </xs:attributeGroup>

    <xs:attributeGroup name="identifier.TemplateBlock.Attr">
        <xs:attribute name="identifier" use="required" type="Identifier.Type" />
    </xs:attributeGroup>

    <xs:attributeGroup name="label.TemplateBlock.Attr">
        <xs:attribute name="label" use="optional" type="xs:string" />
    </xs:attributeGroup>

    <xs:attributeGroup name="showHide.TemplateBlock.Attr">
        <xs:attribute name="showHide" use="optional" default="show">
            <xs:simpleType>
                <xs:restriction base="xs:string">
                    <xs:enumeration value="show" />
                    <xs:enumeration value="hide" />
                </xs:restriction>
            </xs:simpleType>
        </xs:attribute>
    </xs:attributeGroup>

    <xs:attributeGroup name="templateIdentifier.TemplateBlock.Attr">
        <xs:attribute name="templateIdentifier" use="required" type="Identifier.Type" />
    </xs:attributeGroup>

    <xs:attributeGroup name="xmlbase.TemplateBlock.Attr">
        <xs:attribute ref="xml:base" use="optional" />
    </xs:attributeGroup>

    <xs:attributeGroup name="xmllang.TemplateBlock.Attr">
        <xs:attribute ref="xml:lang" use="optional" />
    </xs:attributeGroup>

    <xs:attributeGroup name="class.TemplateBlockFeedbackBlock.Attr">
        <xs:attribute name="class" use="optional">
            <xs:simpleType>
                <xs:list itemType="StringList.Type" />
            </xs:simpleType>
        </xs:attribute>
    </xs:attributeGroup>

    <xs:attributeGroup name="id.TemplateBlockFeedbackBlock.Attr">
        <xs:attribute name="id" use="optional" type="Identifier.Type" />
    </xs:attributeGroup>

    <xs:attributeGroup name="identifier.TemplateBlockFeedbackBlock.Attr">
        <xs:attribute name="identifier" use="required" type="Identifier.Type" />
    </xs:attributeGroup>

    <xs:attributeGroup name="label.TemplateBlockFeedbackBlock.Attr">
        <xs:attribute name="label" use="optional" type="xs:string" />
    </xs:attributeGroup>

    <xs:attributeGroup name="outcomeIdentifier.TemplateBlockFeedbackBlock.Attr">
        <xs:attribute name="outcomeIdentifier" use="required" type="Identifier.Type" />
    </xs:attributeGroup>

    <xs:attributeGroup name="showHide.TemplateBlockFeedbackBlock.Attr">
        <xs:attribute name="showHide" use="optional" default="show">
            <xs:simpleType>
                <xs:restriction base="xs:string">
                    <xs:enumeration value="show" />
                    <xs:enumeration value="hide" />
                </xs:restriction>
            </xs:simpleType>
        </xs:attribute>
    </xs:attributeGroup>

    <xs:attributeGroup name="xmlbase.TemplateBlockFeedbackBlock.Attr">
        <xs:attribute ref="xml:base" use="optional" />
    </xs:attributeGroup>

    <xs:attributeGroup name="xmllang.TemplateBlockFeedbackBlock.Attr">
        <xs:attribute ref="xml:lang" use="optional" />
    </xs:attributeGroup>

    <xs:attributeGroup name="baseType.TemplateDeclaration.Attr">
        <xs:attribute name="baseType" use="optional">
            <xs:simpleType>
                <xs:restriction base="xs:string">
                    <xs:enumeration value="boolean" />
                    <xs:enumeration value="directedPair" />
                    <xs:enumeration value="duration" />
                    <xs:enumeration value="file" />
                    <xs:enumeration value="float" />
                    <xs:enumeration value="identifier" />
                    <xs:enumeration value="integer" />
                    <xs:enumeration value="pair" />
                    <xs:enumeration value="point" />
                    <xs:enumeration value="string" />
                    <xs:enumeration value="uri" />
                </xs:restriction>
            </xs:simpleType>
        </xs:attribute>
    </xs:attributeGroup>

    <xs:attributeGroup name="cardinality.TemplateDeclaration.Attr">
        <xs:attribute name="cardinality" use="required">
            <xs:simpleType>
                <xs:restriction base="xs:string">
                    <xs:enumeration value="multiple" />
                    <xs:enumeration value="ordered" />
                    <xs:enumeration value="record" />
                    <xs:enumeration value="single" />
                </xs:restriction>
            </xs:simpleType>
        </xs:attribute>
    </xs:attributeGroup>

    <xs:attributeGroup name="identifier.TemplateDeclaration.Attr">
        <xs:attribute name="identifier" use="required" type="Identifier.Type" />
    </xs:attributeGroup>

    <xs:attributeGroup name="mathVariable.TemplateDeclaration.Attr">
        <xs:attribute name="mathVariable" use="optional" default="false" type="xs:boolean" />
    </xs:attributeGroup>

    <xs:attributeGroup name="paramVariable.TemplateDeclaration.Attr">
        <xs:attribute name="paramVariable" use="optional" default="false" type="xs:boolean" />
    </xs:attributeGroup>

    <xs:attributeGroup name="templateIdentifier.TemplateDefault.Attr">
        <xs:attribute name="templateIdentifier" use="required" type="Identifier.Type" />
    </xs:attributeGroup>

    <xs:attributeGroup name="class.TemplateInline.Attr">
        <xs:attribute name="class" use="optional">
            <xs:simpleType>
                <xs:list itemType="StringList.Type" />
            </xs:simpleType>
        </xs:attribute>
    </xs:attributeGroup>

    <xs:attributeGroup name="id.TemplateInline.Attr">
        <xs:attribute name="id" use="optional" type="Identifier.Type" />
    </xs:attributeGroup>

    <xs:attributeGroup name="identifier.TemplateInline.Attr">
        <xs:attribute name="identifier" use="required" type="Identifier.Type" />
    </xs:attributeGroup>

    <xs:attributeGroup name="label.TemplateInline.Attr">
        <xs:attribute name="label" use="optional" type="xs:string" />
    </xs:attributeGroup>

    <xs:attributeGroup name="showHide.TemplateInline.Attr">
        <xs:attribute name="showHide" use="optional" default="show">
            <xs:simpleType>
                <xs:restriction base="xs:string">
                    <xs:enumeration value="show" />
                    <xs:enumeration value="hide" />
                </xs:restriction>
            </xs:simpleType>
        </xs:attribute>
    </xs:attributeGroup>

    <xs:attributeGroup name="templateIdentifier.TemplateInline.Attr">
        <xs:attribute name="templateIdentifier" use="required" type="Identifier.Type" />
    </xs:attributeGroup>

    <xs:attributeGroup name="xmlbase.TemplateInline.Attr">
        <xs:attribute ref="xml:base" use="optional" />
    </xs:attributeGroup>

    <xs:attributeGroup name="xmllang.TemplateInline.Attr">
        <xs:attribute ref="xml:lang" use="optional" />
    </xs:attributeGroup>

    <xs:attributeGroup name="access.TestFeedback.Attr">
        <xs:attribute name="access" use="required">
            <xs:simpleType>
                <xs:restriction base="xs:string">
                    <xs:enumeration value="atEnd" />
                    <xs:enumeration value="during" />
                </xs:restriction>
            </xs:simpleType>
        </xs:attribute>
    </xs:attributeGroup>

    <xs:attributeGroup name="identifier.TestFeedback.Attr">
        <xs:attribute name="identifier" use="required" type="Identifier.Type" />
    </xs:attributeGroup>

    <xs:attributeGroup name="outcomeIdentifier.TestFeedback.Attr">
        <xs:attribute name="outcomeIdentifier" use="required" type="Identifier.Type" />
    </xs:attributeGroup>

    <xs:attributeGroup name="showHide.TestFeedback.Attr">
        <xs:attribute name="showHide" use="required">
            <xs:simpleType>
                <xs:restriction base="xs:string">
                    <xs:enumeration value="show" />
                    <xs:enumeration value="hide" />
                </xs:restriction>
            </xs:simpleType>
        </xs:attribute>
    </xs:attributeGroup>

    <xs:attributeGroup name="title.TestFeedback.Attr">
        <xs:attribute name="title" use="optional" type="xs:normalizedString" />
    </xs:attributeGroup>

    <xs:attributeGroup name="identifier.TestPart.Attr">
        <xs:attribute name="identifier" use="required" type="xs:normalizedString" />
    </xs:attributeGroup>

    <xs:attributeGroup name="navigationMode.TestPart.Attr">
        <xs:attribute name="navigationMode" use="required">
            <xs:simpleType>
                <xs:restriction base="xs:string">
                    <xs:enumeration value="linear" />
                    <xs:enumeration value="nonlinear" />
                </xs:restriction>
            </xs:simpleType>
        </xs:attribute>
    </xs:attributeGroup>

    <xs:attributeGroup name="submissionMode.TestPart.Attr">
        <xs:attribute name="submissionMode" use="required">
            <xs:simpleType>
                <xs:restriction base="xs:string">
                    <xs:enumeration value="individual" />
                    <xs:enumeration value="simultaneous" />
                </xs:restriction>
            </xs:simpleType>
        </xs:attribute>
    </xs:attributeGroup>

    <xs:attributeGroup name="baseType.TestVariables.Attr">
        <xs:attribute name="baseType" use="optional">
            <xs:simpleType>
                <xs:restriction base="xs:string">
                    <xs:enumeration value="boolean" />
                    <xs:enumeration value="directedPair" />
                    <xs:enumeration value="duration" />
                    <xs:enumeration value="file" />
                    <xs:enumeration value="float" />
                    <xs:enumeration value="identifier" />
                    <xs:enumeration value="integer" />
                    <xs:enumeration value="pair" />
                    <xs:enumeration value="point" />
                    <xs:enumeration value="string" />
                    <xs:enumeration value="uri" />
                </xs:restriction>
            </xs:simpleType>
        </xs:attribute>
    </xs:attributeGroup>

    <xs:attributeGroup name="excludeCategory.TestVariables.Attr">
        <xs:attribute name="excludeCategory" use="optional">
            <xs:simpleType>
                <xs:list itemType="IdentifierList.Type" />
            </xs:simpleType>
        </xs:attribute>
    </xs:attributeGroup>

    <xs:attributeGroup name="includeCategory.TestVariables.Attr">
        <xs:attribute name="includeCategory" use="optional">
            <xs:simpleType>
                <xs:list itemType="IdentifierList.Type" />
            </xs:simpleType>
        </xs:attribute>
    </xs:attributeGroup>

    <xs:attributeGroup name="sectionIdentifier.TestVariables.Attr">
        <xs:attribute name="sectionIdentifier" use="optional" type="Identifier.Type" />
    </xs:attributeGroup>

    <xs:attributeGroup name="variableIdentifier.TestVariables.Attr">
        <xs:attribute name="variableIdentifier" use="required" type="Identifier.Type" />
    </xs:attributeGroup>

    <xs:attributeGroup name="weightIdentifier.TestVariables.Attr">
        <xs:attribute name="weightIdentifier" use="optional" type="Identifier.Type" />
    </xs:attributeGroup>

    <xs:attributeGroup name="base.TextEntryInteraction.Attr">
        <xs:attribute name="base" use="optional" default="10" type="xs:int" />
    </xs:attributeGroup>

    <xs:attributeGroup name="class.TextEntryInteraction.Attr">
        <xs:attribute name="class" use="optional">
            <xs:simpleType>
                <xs:list itemType="StringList.Type" />
            </xs:simpleType>
        </xs:attribute>
    </xs:attributeGroup>

    <xs:attributeGroup name="expectedLength.TextEntryInteraction.Attr">
        <xs:attribute name="expectedLength" use="optional" type="xs:int" />
    </xs:attributeGroup>

    <xs:attributeGroup name="id.TextEntryInteraction.Attr">
        <xs:attribute name="id" use="optional" type="UniqueIdentifier.Type" />
    </xs:attributeGroup>

    <xs:attributeGroup name="label.TextEntryInteraction.Attr">
        <xs:attribute name="label" use="optional" type="xs:string" />
    </xs:attributeGroup>

    <xs:attributeGroup name="patternMask.TextEntryInteraction.Attr">
        <xs:attribute name="patternMask" use="optional" type="xs:string" />
    </xs:attributeGroup>

    <xs:attributeGroup name="placeholderText.TextEntryInteraction.Attr">
        <xs:attribute name="placeholderText" use="optional" type="xs:string" />
    </xs:attributeGroup>

    <xs:attributeGroup name="responseIdentifier.TextEntryInteraction.Attr">
        <xs:attribute name="responseIdentifier" use="required" type="UniqueIdentifierRef.Type" />
    </xs:attributeGroup>

    <xs:attributeGroup name="stringIdentifier.TextEntryInteraction.Attr">
        <xs:attribute name="stringIdentifier" use="optional" type="UniqueIdentifierRef.Type" />
    </xs:attributeGroup>

    <xs:attributeGroup name="xmlbase.TextEntryInteraction.Attr">
        <xs:attribute ref="xml:base" use="optional" />
    </xs:attributeGroup>

    <xs:attributeGroup name="xmllang.TextEntryInteraction.Attr">
        <xs:attribute ref="xml:lang" use="optional" />
    </xs:attributeGroup>

    <xs:attributeGroup name="allowLateSubmission.TimeLimits.Attr">
        <xs:attribute name="allowLateSubmission" use="optional" default="false" type="xs:boolean" />
    </xs:attributeGroup>

    <xs:attributeGroup name="maxTime.TimeLimits.Attr">
        <xs:attribute name="maxTime" use="optional" type="NonNegativeDouble.Type" />
    </xs:attributeGroup>

    <xs:attributeGroup name="minTime.TimeLimits.Attr">
        <xs:attribute name="minTime" use="optional" type="NonNegativeDouble.Type" />
    </xs:attributeGroup>

    <xs:attributeGroup name="class.TR.Attr">
        <xs:attribute name="class" use="optional">
            <xs:simpleType>
                <xs:list itemType="StringList.Type" />
            </xs:simpleType>
        </xs:attribute>
    </xs:attributeGroup>

    <xs:attributeGroup name="id.TR.Attr">
        <xs:attribute name="id" use="optional" type="UniqueIdentifier.Type" />
    </xs:attributeGroup>

    <xs:attributeGroup name="label.TR.Attr">
        <xs:attribute name="label" use="optional" type="xs:string" />
    </xs:attributeGroup>

    <xs:attributeGroup name="xmllang.TR.Attr">
        <xs:attribute ref="xml:lang" use="optional" />
    </xs:attributeGroup>

    <xs:attributeGroup name="class.UploadInteraction.Attr">
        <xs:attribute name="class" use="optional">
            <xs:simpleType>
                <xs:list itemType="StringList.Type" />
            </xs:simpleType>
        </xs:attribute>
    </xs:attributeGroup>

    <xs:attributeGroup name="id.UploadInteraction.Attr">
        <xs:attribute name="id" use="optional" type="UniqueIdentifier.Type" />
    </xs:attributeGroup>

    <xs:attributeGroup name="label.UploadInteraction.Attr">
        <xs:attribute name="label" use="optional" type="xs:string" />
    </xs:attributeGroup>

    <xs:attributeGroup name="responseIdentifier.UploadInteraction.Attr">
        <xs:attribute name="responseIdentifier" use="required" type="Identifier.Type" />
    </xs:attributeGroup>

    <xs:attributeGroup name="type.UploadInteraction.Attr">
        <xs:attribute name="type" use="optional" type="MimeType.Type" />
    </xs:attributeGroup>

    <xs:attributeGroup name="xmlbase.UploadInteraction.Attr">
        <xs:attribute ref="xml:base" use="optional" />
    </xs:attributeGroup>

    <xs:attributeGroup name="xmllang.UploadInteraction.Attr">
        <xs:attribute ref="xml:lang" use="optional" />
    </xs:attributeGroup>

    <xs:attributeGroup name="baseType.Value.Attr">
        <xs:attribute name="baseType" use="optional">
            <xs:simpleType>
                <xs:restriction base="xs:string">
                    <xs:enumeration value="boolean" />
                    <xs:enumeration value="directedPair" />
                    <xs:enumeration value="duration" />
                    <xs:enumeration value="file" />
                    <xs:enumeration value="float" />
                    <xs:enumeration value="identifier" />
                    <xs:enumeration value="integer" />
                    <xs:enumeration value="pair" />
                    <xs:enumeration value="point" />
                    <xs:enumeration value="string" />
                    <xs:enumeration value="uri" />
                </xs:restriction>
            </xs:simpleType>
        </xs:attribute>
    </xs:attributeGroup>

    <xs:attributeGroup name="fieldIdentifier.Value.Attr">
        <xs:attribute name="fieldIdentifier" use="optional" type="Identifier.Type" />
    </xs:attributeGroup>

    <xs:attributeGroup name="identifier.Variable.Attr">
        <xs:attribute name="identifier" use="required" type="Identifier.Type" />
    </xs:attributeGroup>

    <xs:attributeGroup name="weightIdentifier.Variable.Attr">
        <xs:attribute name="weightIdentifier" use="optional" type="Identifier.Type" />
    </xs:attributeGroup>

    <xs:attributeGroup name="sourceIdentifier.VariableMapping.Attr">
        <xs:attribute name="sourceIdentifier" use="required" type="Identifier.Type" />
    </xs:attributeGroup>

    <xs:attributeGroup name="targetIdentifier.VariableMapping.Attr">
        <xs:attribute name="targetIdentifier" use="required" type="Identifier.Type" />
    </xs:attributeGroup>

    <xs:attributeGroup name="identifier.Weight.Attr">
        <xs:attribute name="identifier" use="required" type="Identifier.Type" />
    </xs:attributeGroup>

    <xs:attributeGroup name="value.Weight.Attr">
        <xs:attribute name="value" use="required" type="xs:double" />
    </xs:attributeGroup>

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

    <!-- Generate Global List Types *********************************************************************** -->

    <xs:simpleType name="IdentifierList.Type">
        <xs:restriction base="xs:NCName" />
    </xs:simpleType>

    <xs:simpleType name="IntegerList.Type">
        <xs:restriction base="xs:int" />
    </xs:simpleType>

    <xs:simpleType name="StringList.Type">
        <xs:restriction base="xs:string" />
    </xs:simpleType>

    <xs:simpleType name="ToleranceList.Type">
        <xs:union>
            <xs:simpleType>
                <xs:restriction base="xs:string" />
            </xs:simpleType>
            <xs:simpleType>
                <xs:restriction base="xs:double" />
            </xs:simpleType>
        </xs:union>
    </xs:simpleType>

    <xs:simpleType name="View.Type">
        <xs:restriction base="xs:string">
            <xs:enumeration value="author" />
            <xs:enumeration value="candidate" />
            <xs:enumeration value="proctor" />
            <xs:enumeration value="scorer" />
            <xs:enumeration value="testConstructor" />
            <xs:enumeration value="tutor" />
        </xs:restriction>
    </xs:simpleType>

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

    <!-- Generate Namespaced extension Group  ************************************************************* -->

    <xs:group name="grpLax.any">
        <xs:annotation>
            <xs:documentation>
                Any namespaced element from any namespace, other than the target namespace, may be included within an "any" element.
                The namespace for the imported element must be defined in the instance, and the schema must be imported.
                The extension has a definition of "lax" i.e. validation is not required if the XSD for the extension is not available.
            </xs:documentation>
        </xs:annotation>
        <xs:sequence>
            <xs:any namespace = "##other" processContents = "lax" minOccurs = "0" maxOccurs = "unbounded" />
        </xs:sequence>
    </xs:group>

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

    <!-- Generate Special DataTypes  ********************************************************************** -->

    <xs:complexType name="EmptyPrimitiveType.Type">
        <xs:complexContent>
            <xs:restriction base="xs:anyType" />
        </xs:complexContent>
    </xs:complexType>

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

    <!-- Generate the enumerated simpleType declarations ************************************************** -->

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

    <!-- Generate the simpleType elements based on IMS data-types (Parameter) ***************************** -->

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

    <!-- Generate the simpleType elements based on IMS data-types (Derived) ******************************* -->

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

    <!-- Generate the simpleType elements based on IMS data-types (Union) ********************************* -->

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

    <!-- Generate the simpleType elements based on IMS data-types (Complex) ******************************* -->

    <xs:element name="exitResponse" type="EmptyPrimitiveType.Type" />

    <xs:element name="exitTemplate" type="EmptyPrimitiveType.Type" />

    <xs:element name="exitTest" type="EmptyPrimitiveType.Type" />

    <xs:element name="null" type="EmptyPrimitiveType.Type" />

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

    <!-- Generate the derived data-type elements based upon simpleType ************************************ -->

    <xs:simpleType name="Date.Type">
        <xs:restriction base="xs:date">
            <xs:pattern value="[0-9]{4}-[0-9]{2}-[0-9]{2}" />
        </xs:restriction>
    </xs:simpleType>

    <xs:simpleType name="DateTime.Type">
        <xs:restriction base="xs:dateTime">
            <xs:pattern value="[0-9]{4}.*" />
        </xs:restriction>
    </xs:simpleType>

    <xs:simpleType name="EncVariableString.Type">
        <xs:restriction base="xs:string">
            <xs:pattern value="\{[\i-[:]][\c-[:]]*\}" />
        </xs:restriction>
    </xs:simpleType>

    <xs:simpleType name="Identifier.Type">
        <xs:restriction base="xs:NCName" />
    </xs:simpleType>

    <xs:simpleType name="Length.Type">
        <xs:restriction base="xs:string">
            <xs:pattern value="[0-9]+%?" />
        </xs:restriction>
    </xs:simpleType>

    <xs:simpleType name="MimeType.Type">
        <xs:restriction base="xs:normalizedString">
            <xs:pattern value="[\p{IsBasicLatin}-[()&lt;&gt;@,;:\\&quot;/\[\]?=]]+/[\p{IsBasicLatin}-[()&lt;&gt;@,;:\\&quot;/\[\]?=]]+" />
        </xs:restriction>
    </xs:simpleType>

    <xs:simpleType name="NonNegativeDouble.Type">
        <xs:restriction base="xs:double">
            <xs:minInclusive value="0.0" />
        </xs:restriction>
    </xs:simpleType>

    <xs:simpleType name="UniqueIdentifier.Type">
        <xs:restriction base="xs:ID" />
    </xs:simpleType>

    <xs:simpleType name="UniqueIdentifierRef.Type">
        <xs:restriction base="xs:IDREF" />
    </xs:simpleType>

    <xs:simpleType name="VariableString.Type">
        <xs:restriction base="xs:string">
            <xs:pattern value="[\i-[:]][\c-[:]]*" />
        </xs:restriction>
    </xs:simpleType>

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

    <!-- Generate the derived data-type elements based upon derived simpleType **************************** -->

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

    <!-- Generate the ComplexTypes ************************************************************************ -->

    <xs:complexType name="A.Type" abstract="false" mixed="true">
        <xs:annotation>
            <xs:documentation source="documentation">
                The 'A' complexType is the container for content that is equivalent to the HTML 'a' marku-
                p.                                                                                        
            </xs:documentation>
        </xs:annotation>
        <xs:sequence>
            <xs:choice minOccurs="0" maxOccurs="unbounded">
                <xs:element ref="textEntryInteraction" minOccurs="1" maxOccurs="1" />
                <xs:element ref="hottext" minOccurs="1" maxOccurs="1" />
                <xs:element ref="printedVariable" minOccurs="1" maxOccurs="1" />
                <xs:element ref="gap" minOccurs="1" maxOccurs="1" />
                <xs:element ref="feedbackInline" minOccurs="1" maxOccurs="1" />
                <xs:element ref="templateInline" minOccurs="1" maxOccurs="1" />
                <xs:element ref="inlineChoiceInteraction" minOccurs="1" maxOccurs="1" />
                <xs:element ref="endAttemptInteraction" minOccurs="1" maxOccurs="1" />
                <xs:element ref="customInteraction" minOccurs="1" maxOccurs="1" />
                <xs:element ref="m:math" minOccurs="1" maxOccurs="1" />
                <xs:element ref="xi:include" minOccurs="1" maxOccurs="1" />
                <xs:choice minOccurs="1" maxOccurs="1">
                    <xs:element ref="img" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="br" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="object" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="em" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="a" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="code" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="span" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="sub" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="acronym" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="big" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="tt" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="kbd" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="q" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="i" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="dfn" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="abbr" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="strong" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="sup" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="var" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="small" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="samp" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="b" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="cite" minOccurs="1" maxOccurs="1" />
                </xs:choice>
            </xs:choice>
        </xs:sequence>
        <xs:attributeGroup ref="id.A.Attr" />
        <xs:attributeGroup ref="class.A.Attr" />
        <xs:attributeGroup ref="xmllang.A.Attr" />
        <xs:attributeGroup ref="label.A.Attr" />
        <xs:attributeGroup ref="xmlbase.A.Attr" />
        <xs:attributeGroup ref="href.A.Attr" />
        <xs:attributeGroup ref="type.A.Attr" />
    </xs:complexType>

    <xs:complexType name="AnyN.Type" abstract="false" mixed="false">
        <xs:annotation>
            <xs:documentation source="documentation">
                The anyN operator takes one or more sub-expressions each with a base-type of boolean and  
                single cardinality. The result is a single boolean which is true if at least min of the s-
                ub-expressions are true and at most max of the sub-expressions are true. If more than n - 
                min sub-expressions are false (where n is the total number of sub-expressions) or more th-
                an max sub-expressions are true then the result is false. If one or more sub-expressions  
                are NULL then it is possible that neither of these conditions is satisfied, in which case 
                the operator results in NULL. For example, if min is 3 and max is 4 and the sub-expressio-
                ns have values {true,true,false,NULL} then the operator results in NULL whereas {true,fal-
                se,false,NULL} results in false and {true,true,true,NULL} results in true. The result NULL
                indicates that the correct value for the operator cannot be determined.                   
            </xs:documentation>
        </xs:annotation>
        <xs:sequence>
            <xs:choice minOccurs="1" maxOccurs="unbounded">
                <xs:element ref="and" minOccurs="1" maxOccurs="1" />
                <xs:element ref="gt" minOccurs="1" maxOccurs="1" />
                <xs:element ref="not" minOccurs="1" maxOccurs="1" />
                <xs:element ref="lt" minOccurs="1" maxOccurs="1" />
                <xs:element ref="gte" minOccurs="1" maxOccurs="1" />
                <xs:element ref="lte" minOccurs="1" maxOccurs="1" />
                <xs:element ref="or" minOccurs="1" maxOccurs="1" />
                <xs:element ref="sum" minOccurs="1" maxOccurs="1" />
                <xs:element ref="durationLT" minOccurs="1" maxOccurs="1" />
                <xs:element ref="durationGTE" minOccurs="1" maxOccurs="1" />
                <xs:element ref="subtract" minOccurs="1" maxOccurs="1" />
                <xs:element ref="divide" minOccurs="1" maxOccurs="1" />
                <xs:element ref="multiple" minOccurs="1" maxOccurs="1" />
                <xs:element ref="ordered" minOccurs="1" maxOccurs="1" />
                <xs:element ref="customOperator" minOccurs="1" maxOccurs="1" />
                <xs:element ref="random" minOccurs="1" maxOccurs="1" />
                <xs:element ref="numberIncorrect" minOccurs="1" maxOccurs="1" />
                <xs:element ref="numberCorrect" minOccurs="1" maxOccurs="1" />
                <xs:element ref="numberPresented" minOccurs="1" maxOccurs="1" />
                <xs:element ref="numberResponded" minOccurs="1" maxOccurs="1" />
                <xs:element ref="numberSelected" minOccurs="1" maxOccurs="1" />
                <xs:element ref="substring" minOccurs="1" maxOccurs="1" />
                <xs:element ref="equalRounded" minOccurs="1" maxOccurs="1" />
                <xs:element ref="null" minOccurs="1" maxOccurs="1" />
                <xs:element ref="delete" minOccurs="1" maxOccurs="1" />
                <xs:element ref="match" minOccurs="1" maxOccurs="1" />
                <xs:element ref="index" minOccurs="1" maxOccurs="1" />
                <xs:element ref="power" minOccurs="1" maxOccurs="1" />
                <xs:element ref="equal" minOccurs="1" maxOccurs="1" />
                <xs:element ref="contains" minOccurs="1" maxOccurs="1" />
                <xs:element ref="containerSize" minOccurs="1" maxOccurs="1" />
                <xs:element ref="correct" minOccurs="1" maxOccurs="1" />
                <xs:element ref="default" minOccurs="1" maxOccurs="1" />
                <xs:element ref="anyN" minOccurs="1" maxOccurs="1" />
                <xs:element ref="integerDivide" minOccurs="1" maxOccurs="1" />
                <xs:element ref="integerModulus" minOccurs="1" maxOccurs="1" />
                <xs:element ref="isNull" minOccurs="1" maxOccurs="1" />
                <xs:element ref="member" minOccurs="1" maxOccurs="1" />
                <xs:element ref="product" minOccurs="1" maxOccurs="1" />
                <xs:element ref="round" minOccurs="1" maxOccurs="1" />
                <xs:element ref="truncate" minOccurs="1" maxOccurs="1" />
                <xs:element ref="fieldValue" minOccurs="1" maxOccurs="1" />
                <xs:element ref="randomInteger" minOccurs="1" maxOccurs="1" />
                <xs:element ref="randomFloat" minOccurs="1" maxOccurs="1" />
                <xs:element ref="variable" minOccurs="1" maxOccurs="1" />
                <xs:element ref="outcomeMinimum" minOccurs="1" maxOccurs="1" />
                <xs:element ref="outcomeMaximum" minOccurs="1" maxOccurs="1" />
                <xs:element ref="testVariables" minOccurs="1" maxOccurs="1" />
                <xs:element ref="integerToFloat" minOccurs="1" maxOccurs="1" />
                <xs:element ref="inside" minOccurs="1" maxOccurs="1" />
                <xs:element ref="baseValue" minOccurs="1" maxOccurs="1" />
                <xs:element ref="patternMatch" minOccurs="1" maxOccurs="1" />
                <xs:element ref="mapResponsePoint" minOccurs="1" maxOccurs="1" />
                <xs:element ref="mapResponse" minOccurs="1" maxOccurs="1" />
                <xs:element ref="stringMatch" minOccurs="1" maxOccurs="1" />
                <xs:element ref="repeat" minOccurs="1" maxOccurs="1" />
                <xs:element ref="roundTo" minOccurs="1" maxOccurs="1" />
                <xs:element ref="lcm" minOccurs="1" maxOccurs="1" />
                <xs:element ref="gcd" minOccurs="1" maxOccurs="1" />
                <xs:element ref="min" minOccurs="1" maxOccurs="1" />
                <xs:element ref="max" minOccurs="1" maxOccurs="1" />
                <xs:element ref="mathConstant" minOccurs="1" maxOccurs="1" />
                <xs:element ref="statsOperator" minOccurs="1" maxOccurs="1" />
                <xs:element ref="mathOperator" minOccurs="1" maxOccurs="1" />
            </xs:choice>
        </xs:sequence>
        <xs:attributeGroup ref="min.AnyN.Attr" />
        <xs:attributeGroup ref="max.AnyN.Attr" />
    </xs:complexType>

    <xs:complexType name="AreaMapping.Type" abstract="false" mixed="false">
        <xs:annotation>
            <xs:documentation source="documentation">
                The AreaMapping complexType is the container for information about for mapping data points
                in areas. The areaMapping, which may only be present in declarations of variables with ba-
                seType point, provides an alternative form of mapping which tests against areas of the co-
                ordinate space instead of mapping single values (i.e., single points).                    
            </xs:documentation>
        </xs:annotation>
        <xs:sequence>
            <xs:element ref="areaMapEntry" minOccurs="1" maxOccurs="unbounded" />
        </xs:sequence>
        <xs:attributeGroup ref="lowerBound.AreaMapping.Attr" />
        <xs:attributeGroup ref="upperBound.AreaMapping.Attr" />
        <xs:attributeGroup ref="defaultValue.AreaMapping.Attr" />
    </xs:complexType>

    <xs:complexType name="AssessmentItem.Type" abstract="false" mixed="false">
        <xs:annotation>
            <xs:documentation source="documentation">
                An Assessment consists of one or more Items. An 'assessmentItem' is the binding form of an
                Item. An Item is the smallest exchangeable assessment object. An Item is more than a 'Que-
                stion' in that it contains the question and instructions to be presented, the response pr-
                ocessing to be applied to the candidates response(s) and then feedback that may be presen-
                ted (including hints and solutions).                                                      
            </xs:documentation>
        </xs:annotation>
        <xs:sequence>
            <xs:element ref="responseDeclaration" minOccurs="0" maxOccurs="unbounded" />
            <xs:element ref="outcomeDeclaration" minOccurs="0" maxOccurs="unbounded" />
            <xs:element ref="templateDeclaration" minOccurs="0" maxOccurs="unbounded" />
            <xs:element ref="templateProcessing" minOccurs="0" maxOccurs="1" />
            <xs:element ref="stylesheet" minOccurs="0" maxOccurs="unbounded" />
            <xs:element ref="itemBody" minOccurs="0" maxOccurs="1" />
            <xs:element ref="responseProcessing" minOccurs="0" maxOccurs="1" />
            <xs:element ref="modalFeedback" minOccurs="0" maxOccurs="unbounded" />
            <xs:element ref="apip:apipAccessibility" minOccurs="0" maxOccurs="1" />
        </xs:sequence>
        <xs:attributeGroup ref="identifier.AssessmentItem.Attr" />
        <xs:attributeGroup ref="title.AssessmentItem.Attr" />
        <xs:attributeGroup ref="label.AssessmentItem.Attr" />
        <xs:attributeGroup ref="xmllang.AssessmentItem.Attr" />
        <xs:attributeGroup ref="toolName.AssessmentItem.Attr" />
        <xs:attributeGroup ref="toolVersion.AssessmentItem.Attr" />
        <xs:attributeGroup ref="adaptive.AssessmentItem.Attr" />
        <xs:attributeGroup ref="timeDependent.AssessmentItem.Attr" />
    </xs:complexType>

    <xs:complexType name="AssessmentItemRef.Type" abstract="false" mixed="false">
        <xs:annotation>
            <xs:documentation source="documentation">
                This is the container for referential link to the externally stored AssessmentItem (each  
                such Item is stored in its own XML instance file). The identifier attribute should be used
                to identify the actual Item. The details for the Item provided at this point enable the a-
                ssociated Test/Section to determine if the Item fulfills any prerequisites.               
            </xs:documentation>
        </xs:annotation>
        <xs:sequence>
            <xs:element ref="preCondition" minOccurs="0" maxOccurs="unbounded" />
            <xs:element ref="branchRule" minOccurs="0" maxOccurs="unbounded" />
            <xs:element ref="itemSessionControl" minOccurs="0" maxOccurs="1" />
            <xs:element ref="timeLimits" minOccurs="0" maxOccurs="1" />
            <xs:element ref="variableMapping" minOccurs="0" maxOccurs="unbounded" />
            <xs:element ref="weight" minOccurs="0" maxOccurs="unbounded" />
            <xs:element ref="templateDefault" minOccurs="0" maxOccurs="unbounded" />
        </xs:sequence>
        <xs:attributeGroup ref="identifier.AssessmentItemRef.Attr" />
        <xs:attributeGroup ref="required.AssessmentItemRef.Attr" />
        <xs:attributeGroup ref="fixed.AssessmentItemRef.Attr" />
        <xs:attributeGroup ref="href.AssessmentItemRef.Attr" />
        <xs:attributeGroup ref="category.AssessmentItemRef.Attr" />
    </xs:complexType>

    <xs:complexType name="AssessmentSection.Type" abstract="false" mixed="false">
        <xs:annotation>
            <xs:documentation source="documentation">
                A Test consists of one or more Sections. An 'assessmentSection' is the binding form of a  
                Section. More significantly, a Section is an aggregation of assessmentItems i.e. a set of 
                Items that are used to achieve some co-ordnated assessment activity. An assessmentSection 
                contains the rules that should be used to select and order the set of associated Sections 
                and/or Items. Furthermore, the associated rubricBlock is used to present content that is  
                relevant to all of the contained Sections and/or Items.                                   
            </xs:documentation>
        </xs:annotation>
        <xs:sequence>
            <xs:element ref="preCondition" minOccurs="0" maxOccurs="unbounded" />
            <xs:element ref="branchRule" minOccurs="0" maxOccurs="unbounded" />
            <xs:element ref="itemSessionControl" minOccurs="0" maxOccurs="1" />
            <xs:element ref="timeLimits" minOccurs="0" maxOccurs="1" />
            <xs:element ref="selection" minOccurs="0" maxOccurs="1" />
            <xs:element ref="ordering" minOccurs="0" maxOccurs="1" />
            <xs:element ref="rubricBlock" minOccurs="0" maxOccurs="unbounded" />
            <xs:choice minOccurs="0" maxOccurs="unbounded">
                <xs:element ref="xi:include" minOccurs="1" maxOccurs="1" />
                <xs:element ref="assessmentItemRef" minOccurs="1" maxOccurs="1" />
                <xs:element ref="assessmentSection" minOccurs="1" maxOccurs="1" />
                <xs:element ref="assessmentSectionRef" minOccurs="1" maxOccurs="1" />
            </xs:choice>
        </xs:sequence>
        <xs:attributeGroup ref="identifier.AssessmentSection.Attr" />
        <xs:attributeGroup ref="required.AssessmentSection.Attr" />
        <xs:attributeGroup ref="fixed.AssessmentSection.Attr" />
        <xs:attributeGroup ref="title.AssessmentSection.Attr" />
        <xs:attributeGroup ref="visible.AssessmentSection.Attr" />
        <xs:attributeGroup ref="keepTogether.AssessmentSection.Attr" />
    </xs:complexType>

    <xs:complexType name="AssessmentTest.Type" abstract="false" mixed="false">
        <xs:annotation>
            <xs:documentation source="documentation">
                This is the container for the information about a Test. An 'assessmentTest' is the binding
                form of a Test. Each Test is composed of one or more TestParts (with each part consisting 
                of at least one Section). Outcomes processing and feedback at the test level may be avail-
                able.                                                                                     
            </xs:documentation>
        </xs:annotation>
        <xs:sequence>
            <xs:element ref="outcomeDeclaration" minOccurs="0" maxOccurs="unbounded" />
            <xs:element ref="timeLimits" minOccurs="0" maxOccurs="1" />
            <xs:element ref="stylesheet" minOccurs="0" maxOccurs="unbounded" />
            <xs:element ref="testPart" minOccurs="1" maxOccurs="unbounded" />
            <xs:element ref="outcomeProcessing" minOccurs="0" maxOccurs="1" />
            <xs:element ref="testFeedback" minOccurs="0" maxOccurs="unbounded" />
        </xs:sequence>
        <xs:attributeGroup ref="identifier.AssessmentTest.Attr" />
        <xs:attributeGroup ref="title.AssessmentTest.Attr" />
        <xs:attributeGroup ref="toolName.AssessmentTest.Attr" />
        <xs:attributeGroup ref="toolVersion.AssessmentTest.Attr" />
    </xs:complexType>

    <xs:complexType name="AssociateInteraction.Type" abstract="false" mixed="false">
        <xs:annotation>
            <xs:documentation source="documentation">
                The AssociateInteraction complexType is the container for information about associate int-
                eractions. An associate interaction is a blockInteraction that presents candidates with a 
                number of choices and allows them to create associations between them. The associateInter-
                action must be bound to a response variable with base-type pair and either single or mult-
                iple cardinality.                                                                         
            </xs:documentation>
        </xs:annotation>
        <xs:sequence>
            <xs:element ref="prompt" minOccurs="0" maxOccurs="1" />
            <xs:element ref="simpleAssociableChoice" minOccurs="1" maxOccurs="unbounded" />
        </xs:sequence>
        <xs:attributeGroup ref="xmlbase.AssociateInteraction.Attr" />
        <xs:attributeGroup ref="id.AssociateInteraction.Attr" />
        <xs:attributeGroup ref="class.AssociateInteraction.Attr" />
        <xs:attributeGroup ref="xmllang.AssociateInteraction.Attr" />
        <xs:attributeGroup ref="label.AssociateInteraction.Attr" />
        <xs:attributeGroup ref="responseIdentifier.AssociateInteraction.Attr" />
        <xs:attributeGroup ref="shuffle.AssociateInteraction.Attr" />
        <xs:attributeGroup ref="maxAssociations.AssociateInteraction.Attr" />
        <xs:attributeGroup ref="minAssociations.AssociateInteraction.Attr" />
    </xs:complexType>

    <xs:complexType name="BlockQuote.Type" abstract="false" mixed="false">
        <xs:annotation>
            <xs:documentation source="documentation">
                The 'BlockQuote' complexType is the container for content that is equivalent to the HTML  
                'blockquote' markup.                                                                      
            </xs:documentation>
        </xs:annotation>
        <xs:sequence>
            <xs:choice minOccurs="0" maxOccurs="unbounded">
                <xs:element ref="positionObjectStage" minOccurs="1" maxOccurs="1" />
                <xs:element ref="customInteraction" minOccurs="1" maxOccurs="1" />
                <xs:element ref="drawingInteraction" minOccurs="1" maxOccurs="1" />
                <xs:element ref="gapMatchInteraction" minOccurs="1" maxOccurs="1" />
                <xs:element ref="matchInteraction" minOccurs="1" maxOccurs="1" />
                <xs:element ref="graphicGapMatchInteraction" minOccurs="1" maxOccurs="1" />
                <xs:element ref="hotspotInteraction" minOccurs="1" maxOccurs="1" />
                <xs:element ref="graphicOrderInteraction" minOccurs="1" maxOccurs="1" />
                <xs:element ref="selectPointInteraction" minOccurs="1" maxOccurs="1" />
                <xs:element ref="graphicAssociateInteraction" minOccurs="1" maxOccurs="1" />
                <xs:element ref="sliderInteraction" minOccurs="1" maxOccurs="1" />
                <xs:element ref="choiceInteraction" minOccurs="1" maxOccurs="1" />
                <xs:element ref="mediaInteraction" minOccurs="1" maxOccurs="1" />
                <xs:element ref="hottextInteraction" minOccurs="1" maxOccurs="1" />
                <xs:element ref="orderInteraction" minOccurs="1" maxOccurs="1" />
                <xs:element ref="extendedTextInteraction" minOccurs="1" maxOccurs="1" />
                <xs:element ref="uploadInteraction" minOccurs="1" maxOccurs="1" />
                <xs:element ref="associateInteraction" minOccurs="1" maxOccurs="1" />
                <xs:element name="feedbackBlock" type="FeedbackBlock.Type" minOccurs="1" maxOccurs="1"/>
                <xs:element name="templateBlock" type="TemplateBlock.Type" minOccurs="1" maxOccurs="1"/>
                <xs:element ref="infoControl" minOccurs="1" maxOccurs="1" />
                <xs:element ref="m:math" minOccurs="1" maxOccurs="1" />
                <xs:element ref="xi:include" minOccurs="1" maxOccurs="1" />
                <xs:choice minOccurs="1" maxOccurs="1">
                    <xs:element ref="pre" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="h1" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="h2" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="h3" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="h4" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="h5" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="h6" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="p" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="address" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="dl" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="ol" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="hr" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="ul" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="blockquote" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="table" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="div" minOccurs="1" maxOccurs="1" />
                </xs:choice>
            </xs:choice>
        </xs:sequence>
        <xs:attributeGroup ref="id.BlockQuote.Attr" />
        <xs:attributeGroup ref="class.BlockQuote.Attr" />
        <xs:attributeGroup ref="xmllang.BlockQuote.Attr" />
        <xs:attributeGroup ref="label.BlockQuote.Attr" />
        <xs:attributeGroup ref="xmlbase.BlockQuote.Attr" />
        <xs:attributeGroup ref="cite.BlockQuote.Attr" />
    </xs:complexType>

    <xs:complexType name="BranchRule.Type" abstract="false" mixed="false">
        <xs:annotation>
            <xs:documentation source="documentation">
                A branch-rule is a simple expression attached to an assessmentItemRef, assessmentSection  
                or testPart that is evaluated after the item, section or part has been presented to the c-
                andidate. If the expression evaluates to true the test jumps forward to the item, section 
                or part referred to by the target identifier. In the case of an item or section, the targ-
                et must refer to an item or section in the same testPart that has not yet been presented. 
                For testParts, the target must refer to another testPart.                                 
            </xs:documentation>
        </xs:annotation>
        <xs:sequence>
            <xs:choice minOccurs="1" maxOccurs="1">
                <xs:element ref="and" minOccurs="1" maxOccurs="1" />
                <xs:element ref="gt" minOccurs="1" maxOccurs="1" />
                <xs:element ref="not" minOccurs="1" maxOccurs="1" />
                <xs:element ref="lt" minOccurs="1" maxOccurs="1" />
                <xs:element ref="gte" minOccurs="1" maxOccurs="1" />
                <xs:element ref="lte" minOccurs="1" maxOccurs="1" />
                <xs:element ref="or" minOccurs="1" maxOccurs="1" />
                <xs:element ref="sum" minOccurs="1" maxOccurs="1" />
                <xs:element ref="durationLT" minOccurs="1" maxOccurs="1" />
                <xs:element ref="durationGTE" minOccurs="1" maxOccurs="1" />
                <xs:element ref="subtract" minOccurs="1" maxOccurs="1" />
                <xs:element ref="divide" minOccurs="1" maxOccurs="1" />
                <xs:element ref="multiple" minOccurs="1" maxOccurs="1" />
                <xs:element ref="ordered" minOccurs="1" maxOccurs="1" />
                <xs:element ref="customOperator" minOccurs="1" maxOccurs="1" />
                <xs:element ref="random" minOccurs="1" maxOccurs="1" />
                <xs:element ref="numberIncorrect" minOccurs="1" maxOccurs="1" />
                <xs:element ref="numberCorrect" minOccurs="1" maxOccurs="1" />
                <xs:element ref="numberPresented" minOccurs="1" maxOccurs="1" />
                <xs:element ref="numberResponded" minOccurs="1" maxOccurs="1" />
                <xs:element ref="numberSelected" minOccurs="1" maxOccurs="1" />
                <xs:element ref="substring" minOccurs="1" maxOccurs="1" />
                <xs:element ref="equalRounded" minOccurs="1" maxOccurs="1" />
                <xs:element ref="null" minOccurs="1" maxOccurs="1" />
                <xs:element ref="delete" minOccurs="1" maxOccurs="1" />
                <xs:element ref="match" minOccurs="1" maxOccurs="1" />
                <xs:element ref="index" minOccurs="1" maxOccurs="1" />
                <xs:element ref="power" minOccurs="1" maxOccurs="1" />
                <xs:element ref="equal" minOccurs="1" maxOccurs="1" />
                <xs:element ref="contains" minOccurs="1" maxOccurs="1" />
                <xs:element ref="containerSize" minOccurs="1" maxOccurs="1" />
                <xs:element ref="correct" minOccurs="1" maxOccurs="1" />
                <xs:element ref="default" minOccurs="1" maxOccurs="1" />
                <xs:element ref="anyN" minOccurs="1" maxOccurs="1" />
                <xs:element ref="integerDivide" minOccurs="1" maxOccurs="1" />
                <xs:element ref="integerModulus" minOccurs="1" maxOccurs="1" />
                <xs:element ref="isNull" minOccurs="1" maxOccurs="1" />
                <xs:element ref="member" minOccurs="1" maxOccurs="1" />
                <xs:element ref="product" minOccurs="1" maxOccurs="1" />
                <xs:element ref="round" minOccurs="1" maxOccurs="1" />
                <xs:element ref="truncate" minOccurs="1" maxOccurs="1" />
                <xs:element ref="fieldValue" minOccurs="1" maxOccurs="1" />
                <xs:element ref="randomInteger" minOccurs="1" maxOccurs="1" />
                <xs:element ref="randomFloat" minOccurs="1" maxOccurs="1" />
                <xs:element ref="variable" minOccurs="1" maxOccurs="1" />
                <xs:element ref="outcomeMinimum" minOccurs="1" maxOccurs="1" />
                <xs:element ref="outcomeMaximum" minOccurs="1" maxOccurs="1" />
                <xs:element ref="testVariables" minOccurs="1" maxOccurs="1" />
                <xs:element ref="integerToFloat" minOccurs="1" maxOccurs="1" />
                <xs:element ref="inside" minOccurs="1" maxOccurs="1" />
                <xs:element ref="baseValue" minOccurs="1" maxOccurs="1" />
                <xs:element ref="patternMatch" minOccurs="1" maxOccurs="1" />
                <xs:element ref="mapResponsePoint" minOccurs="1" maxOccurs="1" />
                <xs:element ref="mapResponse" minOccurs="1" maxOccurs="1" />
                <xs:element ref="stringMatch" minOccurs="1" maxOccurs="1" />
                <xs:element ref="repeat" minOccurs="1" maxOccurs="1" />
                <xs:element ref="roundTo" minOccurs="1" maxOccurs="1" />
                <xs:element ref="lcm" minOccurs="1" maxOccurs="1" />
                <xs:element ref="gcd" minOccurs="1" maxOccurs="1" />
                <xs:element ref="min" minOccurs="1" maxOccurs="1" />
                <xs:element ref="max" minOccurs="1" maxOccurs="1" />
                <xs:element ref="mathConstant" minOccurs="1" maxOccurs="1" />
                <xs:element ref="statsOperator" minOccurs="1" maxOccurs="1" />
                <xs:element ref="mathOperator" minOccurs="1" maxOccurs="1" />
            </xs:choice>
        </xs:sequence>
        <xs:attributeGroup ref="target.BranchRule.Attr" />
    </xs:complexType>

    <xs:complexType name="Caption.Type" abstract="false" mixed="true">
        <xs:annotation>
            <xs:documentation source="documentation">
                The 'Caption' complexType is the container for content that is equivalent to the HTML 'ca-
                ption' markup.                                                                            
            </xs:documentation>
        </xs:annotation>
        <xs:sequence>
            <xs:choice minOccurs="0" maxOccurs="unbounded">
                <xs:element ref="textEntryInteraction" minOccurs="1" maxOccurs="1" />
                <xs:element ref="hottext" minOccurs="1" maxOccurs="1" />
                <xs:element ref="printedVariable" minOccurs="1" maxOccurs="1" />
                <xs:element ref="gap" minOccurs="1" maxOccurs="1" />
                <xs:element ref="feedbackInline" minOccurs="1" maxOccurs="1" />
                <xs:element ref="templateInline" minOccurs="1" maxOccurs="1" />
                <xs:element ref="inlineChoiceInteraction" minOccurs="1" maxOccurs="1" />
                <xs:element ref="endAttemptInteraction" minOccurs="1" maxOccurs="1" />
                <xs:element ref="customInteraction" minOccurs="1" maxOccurs="1" />
                <xs:element ref="m:math" minOccurs="1" maxOccurs="1" />
                <xs:element ref="xi:include" minOccurs="1" maxOccurs="1" />
                <xs:choice minOccurs="1" maxOccurs="1">
                    <xs:element ref="img" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="br" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="object" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="em" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="a" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="code" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="span" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="sub" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="acronym" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="big" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="tt" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="kbd" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="q" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="i" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="dfn" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="abbr" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="strong" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="sup" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="var" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="small" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="samp" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="b" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="cite" minOccurs="1" maxOccurs="1" />
                </xs:choice>
            </xs:choice>
        </xs:sequence>
        <xs:attributeGroup ref="id.Caption.Attr" />
        <xs:attributeGroup ref="class.Caption.Attr" />
        <xs:attributeGroup ref="xmllang.Caption.Attr" />
        <xs:attributeGroup ref="label.Caption.Attr" />
    </xs:complexType>

    <xs:complexType name="ChoiceInteraction.Type" abstract="false" mixed="false">
        <xs:annotation>
            <xs:documentation source="documentation">
                The ChoiceInteraction is the complexType for the information in a choice interaction. The 
                choice interaction presents a set of choices to the candidate. The candidate's task is to 
                select one or more of the choices, up to a maximum of maxChoices. There is no correspondi-
                ng minimum number of choices. The interaction is always initialized with no choices selec-
                ted.                                                                                      
            </xs:documentation>
        </xs:annotation>
        <xs:sequence>
            <xs:element ref="prompt" minOccurs="0" maxOccurs="1" />
            <xs:element ref="simpleChoice" minOccurs="1" maxOccurs="unbounded" />
        </xs:sequence>
        <xs:attributeGroup ref="xmlbase.ChoiceInteraction.Attr" />
        <xs:attributeGroup ref="id.ChoiceInteraction.Attr" />
        <xs:attributeGroup ref="class.ChoiceInteraction.Attr" />
        <xs:attributeGroup ref="xmllang.ChoiceInteraction.Attr" />
        <xs:attributeGroup ref="label.ChoiceInteraction.Attr" />
        <xs:attributeGroup ref="responseIdentifier.ChoiceInteraction.Attr" />
        <xs:attributeGroup ref="shuffle.ChoiceInteraction.Attr" />
        <xs:attributeGroup ref="maxChoices.ChoiceInteraction.Attr" />
        <xs:attributeGroup ref="minChoices.ChoiceInteraction.Attr" />
        <xs:attributeGroup ref="orientation.ChoiceInteraction.Attr" />
    </xs:complexType>

    <xs:complexType name="ColGroup.Type" abstract="false" mixed="false">
        <xs:annotation>
            <xs:documentation source="documentation">
                The 'ColGroup' complexType is the container for set of columns defined within a table. The
                content is the set of 'col' HTML markup.                                                  
            </xs:documentation>
        </xs:annotation>
        <xs:sequence>
            <xs:element ref="col" minOccurs="0" maxOccurs="unbounded" />
        </xs:sequence>
        <xs:attributeGroup ref="id.ColGroup.Attr" />
        <xs:attributeGroup ref="class.ColGroup.Attr" />
        <xs:attributeGroup ref="xmllang.ColGroup.Attr" />
        <xs:attributeGroup ref="label.ColGroup.Attr" />
        <xs:attributeGroup ref="span.ColGroup.Attr" />
    </xs:complexType>

    <xs:complexType name="CorrectResponse.Type" abstract="false" mixed="false">
        <xs:annotation>
            <xs:documentation source="documentation">
                The CorrectResponse complexType is the container for information about the correct respon-
                se for an interaction. A response declaration may assign an optional 'correctResponse'. T-
                his value may indicate the only possible value of the response variable to be considered  
                correct or merely just a correct value. For responses that are being measured against a m-
                ore complex scale than correct/incorrect this value should be set to the (or an) optimal  
                value. Finally, for responses for hwich no such optimal value is defined the 'correctResp-
                onse' must be omitted. If a delivery system supports the display of a solution then it sh-
                ould display the correct values of responses (where defined) to the candidate's own respo-
                nses (which may be hidden completely if necessary).                                       
            </xs:documentation>
        </xs:annotation>
        <xs:sequence>
            <xs:element ref="value" minOccurs="1" maxOccurs="unbounded" />
        </xs:sequence>
        <xs:attributeGroup ref="interpretation.CorrectResponse.Attr" />
    </xs:complexType>

    <xs:complexType name="CustomInteraction.Type" abstract="false" mixed="false">
        <xs:annotation>
            <xs:documentation source="documentation">
                The CustomInteraction complexType is the container for undefined QTI interactions i.e. on-
                es of a proprietary nature. These are supported using a lax namespacing approach but deve-
                lopers are encouraged to define and use an associated validation XSD.                     
            </xs:documentation>
        </xs:annotation>
        <xs:sequence>
            <xs:group ref="grpLax.any" />
        </xs:sequence>
        <xs:attributeGroup ref="xmlbase.CustomInteraction.Attr" />
        <xs:attributeGroup ref="id.CustomInteraction.Attr" />
        <xs:attributeGroup ref="class.CustomInteraction.Attr" />
        <xs:attributeGroup ref="xmllang.CustomInteraction.Attr" />
        <xs:attributeGroup ref="label.CustomInteraction.Attr" />
        <xs:attributeGroup ref="responseIdentifier.CustomInteraction.Attr" />
        <xs:attributeGroup ref="extension.CustomInteraction.Attr" />
    </xs:complexType>

    <xs:complexType name="CustomOperator.Type" abstract="false" mixed="false">
        <xs:annotation>
            <xs:documentation source="documentation">
                The custom operator provides a namespaced extension mechanism for defining operations not 
                currently supported by this specification.                                                
            </xs:documentation>
        </xs:annotation>
        <xs:sequence>
            <xs:choice minOccurs="0" maxOccurs="unbounded">
                <xs:element ref="and" minOccurs="1" maxOccurs="1" />
                <xs:element ref="gt" minOccurs="1" maxOccurs="1" />
                <xs:element ref="not" minOccurs="1" maxOccurs="1" />
                <xs:element ref="lt" minOccurs="1" maxOccurs="1" />
                <xs:element ref="gte" minOccurs="1" maxOccurs="1" />
                <xs:element ref="lte" minOccurs="1" maxOccurs="1" />
                <xs:element ref="or" minOccurs="1" maxOccurs="1" />
                <xs:element ref="sum" minOccurs="1" maxOccurs="1" />
                <xs:element ref="durationLT" minOccurs="1" maxOccurs="1" />
                <xs:element ref="durationGTE" minOccurs="1" maxOccurs="1" />
                <xs:element ref="subtract" minOccurs="1" maxOccurs="1" />
                <xs:element ref="divide" minOccurs="1" maxOccurs="1" />
                <xs:element ref="multiple" minOccurs="1" maxOccurs="1" />
                <xs:element ref="ordered" minOccurs="1" maxOccurs="1" />
                <xs:element ref="customOperator" minOccurs="1" maxOccurs="1" />
                <xs:element ref="random" minOccurs="1" maxOccurs="1" />
                <xs:element ref="numberIncorrect" minOccurs="1" maxOccurs="1" />
                <xs:element ref="numberCorrect" minOccurs="1" maxOccurs="1" />
                <xs:element ref="numberPresented" minOccurs="1" maxOccurs="1" />
                <xs:element ref="numberResponded" minOccurs="1" maxOccurs="1" />
                <xs:element ref="numberSelected" minOccurs="1" maxOccurs="1" />
                <xs:element ref="substring" minOccurs="1" maxOccurs="1" />
                <xs:element ref="equalRounded" minOccurs="1" maxOccurs="1" />
                <xs:element ref="null" minOccurs="1" maxOccurs="1" />
                <xs:element ref="delete" minOccurs="1" maxOccurs="1" />
                <xs:element ref="match" minOccurs="1" maxOccurs="1" />
                <xs:element ref="index" minOccurs="1" maxOccurs="1" />
                <xs:element ref="power" minOccurs="1" maxOccurs="1" />
                <xs:element ref="equal" minOccurs="1" maxOccurs="1" />
                <xs:element ref="contains" minOccurs="1" maxOccurs="1" />
                <xs:element ref="containerSize" minOccurs="1" maxOccurs="1" />
                <xs:element ref="correct" minOccurs="1" maxOccurs="1" />
                <xs:element ref="default" minOccurs="1" maxOccurs="1" />
                <xs:element ref="anyN" minOccurs="1" maxOccurs="1" />
                <xs:element ref="integerDivide" minOccurs="1" maxOccurs="1" />
                <xs:element ref="integerModulus" minOccurs="1" maxOccurs="1" />
                <xs:element ref="isNull" minOccurs="1" maxOccurs="1" />
                <xs:element ref="member" minOccurs="1" maxOccurs="1" />
                <xs:element ref="product" minOccurs="1" maxOccurs="1" />
                <xs:element ref="round" minOccurs="1" maxOccurs="1" />
                <xs:element ref="truncate" minOccurs="1" maxOccurs="1" />
                <xs:element ref="fieldValue" minOccurs="1" maxOccurs="1" />
                <xs:element ref="randomInteger" minOccurs="1" maxOccurs="1" />
                <xs:element ref="randomFloat" minOccurs="1" maxOccurs="1" />
                <xs:element ref="variable" minOccurs="1" maxOccurs="1" />
                <xs:element ref="outcomeMinimum" minOccurs="1" maxOccurs="1" />
                <xs:element ref="outcomeMaximum" minOccurs="1" maxOccurs="1" />
                <xs:element ref="testVariables" minOccurs="1" maxOccurs="1" />
                <xs:element ref="integerToFloat" minOccurs="1" maxOccurs="1" />
                <xs:element ref="inside" minOccurs="1" maxOccurs="1" />
                <xs:element ref="baseValue" minOccurs="1" maxOccurs="1" />
                <xs:element ref="patternMatch" minOccurs="1" maxOccurs="1" />
                <xs:element ref="mapResponsePoint" minOccurs="1" maxOccurs="1" />
                <xs:element ref="mapResponse" minOccurs="1" maxOccurs="1" />
                <xs:element ref="stringMatch" minOccurs="1" maxOccurs="1" />
                <xs:element ref="repeat" minOccurs="1" maxOccurs="1" />
                <xs:element ref="roundTo" minOccurs="1" maxOccurs="1" />
                <xs:element ref="lcm" minOccurs="1" maxOccurs="1" />
                <xs:element ref="gcd" minOccurs="1" maxOccurs="1" />
                <xs:element ref="min" minOccurs="1" maxOccurs="1" />
                <xs:element ref="max" minOccurs="1" maxOccurs="1" />
                <xs:element ref="mathConstant" minOccurs="1" maxOccurs="1" />
                <xs:element ref="statsOperator" minOccurs="1" maxOccurs="1" />
                <xs:element ref="mathOperator" minOccurs="1" maxOccurs="1" />
            </xs:choice>
            <xs:group ref="grpLax.any" />
        </xs:sequence>
        <xs:attributeGroup ref="class.CustomOperator.Attr" />
        <xs:attributeGroup ref="definition.CustomOperator.Attr" />
        <xs:attributeGroup ref="extension.CustomOperator.Attr" />
    </xs:complexType>

    <xs:complexType name="DD.Type" abstract="false" mixed="true">
        <xs:annotation>
            <xs:documentation source="documentation">
                The 'DD' complexType is the container for term definitions as per the HTML 'dd' markup.   
            </xs:documentation>
        </xs:annotation>
        <xs:sequence>
            <xs:choice minOccurs="0" maxOccurs="unbounded">
                <xs:element ref="printedVariable" minOccurs="1" maxOccurs="1" />
                <xs:element ref="feedbackBlock" minOccurs="1" maxOccurs="1" />
                <xs:element ref="hottext" minOccurs="1" maxOccurs="1" />
                <xs:element ref="feedbackInline" minOccurs="1" maxOccurs="1" />
                <xs:element ref="templateInline" minOccurs="1" maxOccurs="1" />
                <xs:element ref="templateBlock" minOccurs="1" maxOccurs="1" />
                <xs:element ref="m:math" minOccurs="1" maxOccurs="1" />
                <xs:element ref="xi:include" minOccurs="1" maxOccurs="1" />
                <xs:element ref="textEntryInteraction" minOccurs="1" maxOccurs="1" />
                <xs:element ref="inlineChoiceInteraction" minOccurs="1" maxOccurs="1" />
                <xs:element ref="endAttemptInteraction" minOccurs="1" maxOccurs="1" />
                <xs:element ref="customInteraction" minOccurs="1" maxOccurs="1" />
                <xs:element ref="drawingInteraction" minOccurs="1" maxOccurs="1" />
                <xs:element ref="gapMatchInteraction" minOccurs="1" maxOccurs="1" />
                <xs:element ref="matchInteraction" minOccurs="1" maxOccurs="1" />
                <xs:element ref="graphicGapMatchInteraction" minOccurs="1" maxOccurs="1" />
                <xs:element ref="hotspotInteraction" minOccurs="1" maxOccurs="1" />
                <xs:element ref="graphicOrderInteraction" minOccurs="1" maxOccurs="1" />
                <xs:element ref="selectPointInteraction" minOccurs="1" maxOccurs="1" />
                <xs:element ref="graphicAssociateInteraction" minOccurs="1" maxOccurs="1" />
                <xs:element ref="sliderInteraction" minOccurs="1" maxOccurs="1" />
                <xs:element ref="choiceInteraction" minOccurs="1" maxOccurs="1" />
                <xs:element ref="mediaInteraction" minOccurs="1" maxOccurs="1" />
                <xs:element ref="hottextInteraction" minOccurs="1" maxOccurs="1" />
                <xs:element ref="orderInteraction" minOccurs="1" maxOccurs="1" />
                <xs:element ref="extendedTextInteraction" minOccurs="1" maxOccurs="1" />
                <xs:element ref="uploadInteraction" minOccurs="1" maxOccurs="1" />
                <xs:element ref="associateInteraction" minOccurs="1" maxOccurs="1" />
                <xs:choice minOccurs="1" maxOccurs="1">
                    <xs:element ref="pre" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="h1" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="h2" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="h3" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="h4" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="h5" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="h6" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="p" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="address" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="dl" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="ol" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="ul" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="br" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="hr" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="img" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="object" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="blockquote" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="em" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="a" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="code" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="span" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="sub" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="acronym" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="big" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="tt" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="kbd" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="q" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="i" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="dfn" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="abbr" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="strong" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="sup" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="var" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="small" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="samp" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="b" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="cite" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="table" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="div" minOccurs="1" maxOccurs="1" />
                </xs:choice>
            </xs:choice>
        </xs:sequence>
        <xs:attributeGroup ref="id.DD.Attr" />
        <xs:attributeGroup ref="class.DD.Attr" />
        <xs:attributeGroup ref="xmllang.DD.Attr" />
        <xs:attributeGroup ref="label.DD.Attr" />
        <xs:attributeGroup ref="xmlbase.DD.Attr" />
    </xs:complexType>

    <xs:complexType name="DefaultValue.Type" abstract="false" mixed="false">
        <xs:annotation>
            <xs:documentation source="documentation">
                This is the container for the permitted set of default values. A human readable interpret-
                ation of the default value is also supplied using the 'interpretation' attribute.         
            </xs:documentation>
        </xs:annotation>
        <xs:sequence>
            <xs:element ref="value" minOccurs="1" maxOccurs="unbounded" />
        </xs:sequence>
        <xs:attributeGroup ref="interpretation.DefaultValue.Attr" />
    </xs:complexType>

    <xs:complexType name="Div.Type" abstract="false" mixed="true">
        <xs:annotation>
            <xs:documentation source="documentation">
                The 'Div' complexType is the container for content that is equivalent to the HTML 'div' m-
                arkup.                                                                                    
            </xs:documentation>
        </xs:annotation>
        <xs:sequence>
            <xs:choice minOccurs="0" maxOccurs="unbounded">
                <xs:element ref="positionObjectStage" minOccurs="1" maxOccurs="1" />
                <xs:choice minOccurs="1" maxOccurs="1">
                    <xs:element ref="printedVariable" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="feedbackBlock" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="hottext" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="feedbackInline" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="templateInline" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="templateBlock" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="m:math" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="xi:include" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="textEntryInteraction" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="inlineChoiceInteraction" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="endAttemptInteraction" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="customInteraction" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="drawingInteraction" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="gapMatchInteraction" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="matchInteraction" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="graphicGapMatchInteraction" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="hotspotInteraction" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="graphicOrderInteraction" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="selectPointInteraction" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="graphicAssociateInteraction" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="sliderInteraction" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="choiceInteraction" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="mediaInteraction" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="hottextInteraction" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="orderInteraction" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="extendedTextInteraction" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="uploadInteraction" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="associateInteraction" minOccurs="1" maxOccurs="1" />
                    <xs:choice minOccurs="1" maxOccurs="1">
                        <xs:element ref="pre" minOccurs="1" maxOccurs="1" />
                        <xs:element ref="h1" minOccurs="1" maxOccurs="1" />
                        <xs:element ref="h2" minOccurs="1" maxOccurs="1" />
                        <xs:element ref="h3" minOccurs="1" maxOccurs="1" />
                        <xs:element ref="h4" minOccurs="1" maxOccurs="1" />
                        <xs:element ref="h5" minOccurs="1" maxOccurs="1" />
                        <xs:element ref="h6" minOccurs="1" maxOccurs="1" />
                        <xs:element ref="p" minOccurs="1" maxOccurs="1" />
                        <xs:element ref="address" minOccurs="1" maxOccurs="1" />
                        <xs:element ref="dl" minOccurs="1" maxOccurs="1" />
                        <xs:element ref="ol" minOccurs="1" maxOccurs="1" />
                        <xs:element ref="ul" minOccurs="1" maxOccurs="1" />
                        <xs:element ref="br" minOccurs="1" maxOccurs="1" />
                        <xs:element ref="hr" minOccurs="1" maxOccurs="1" />
                        <xs:element ref="img" minOccurs="1" maxOccurs="1" />
                        <xs:element ref="object" minOccurs="1" maxOccurs="1" />
                        <xs:element ref="blockquote" minOccurs="1" maxOccurs="1" />
                        <xs:element ref="em" minOccurs="1" maxOccurs="1" />
                        <xs:element ref="a" minOccurs="1" maxOccurs="1" />
                        <xs:element ref="code" minOccurs="1" maxOccurs="1" />
                        <xs:element ref="span" minOccurs="1" maxOccurs="1" />
                        <xs:element ref="sub" minOccurs="1" maxOccurs="1" />
                        <xs:element ref="acronym" minOccurs="1" maxOccurs="1" />
                        <xs:element ref="big" minOccurs="1" maxOccurs="1" />
                        <xs:element ref="tt" minOccurs="1" maxOccurs="1" />
                        <xs:element ref="kbd" minOccurs="1" maxOccurs="1" />
                        <xs:element ref="q" minOccurs="1" maxOccurs="1" />
                        <xs:element ref="i" minOccurs="1" maxOccurs="1" />
                        <xs:element ref="dfn" minOccurs="1" maxOccurs="1" />
                        <xs:element ref="abbr" minOccurs="1" maxOccurs="1" />
                        <xs:element ref="strong" minOccurs="1" maxOccurs="1" />
                        <xs:element ref="sup" minOccurs="1" maxOccurs="1" />
                        <xs:element ref="var" minOccurs="1" maxOccurs="1" />
                        <xs:element ref="small" minOccurs="1" maxOccurs="1" />
                        <xs:element ref="samp" minOccurs="1" maxOccurs="1" />
                        <xs:element ref="b" minOccurs="1" maxOccurs="1" />
                        <xs:element ref="cite" minOccurs="1" maxOccurs="1" />
                        <xs:element ref="table" minOccurs="1" maxOccurs="1" />
                        <xs:element ref="div" minOccurs="1" maxOccurs="1" />
                    </xs:choice>
                </xs:choice>
            </xs:choice>
        </xs:sequence>
        <xs:attributeGroup ref="id.Div.Attr" />
        <xs:attributeGroup ref="class.Div.Attr" />
        <xs:attributeGroup ref="xmllang.Div.Attr" />
        <xs:attributeGroup ref="label.Div.Attr" />
        <xs:attributeGroup ref="xmlbase.Div.Attr" />
    </xs:complexType>

    <xs:complexType name="DL.Type" abstract="false" mixed="false">
        <xs:annotation>
            <xs:documentation source="documentation">
                The 'DL' complexType is the container for list definitions as per the HTML 'dl' markup. T-
                his can contain any combination of 'dd' and 'dt' HTML elements.                           
            </xs:documentation>
        </xs:annotation>
        <xs:sequence>
            <xs:choice minOccurs="0" maxOccurs="unbounded">
                <xs:element ref="dd" minOccurs="1" maxOccurs="1" />
                <xs:element ref="dt" minOccurs="1" maxOccurs="1" />
            </xs:choice>
        </xs:sequence>
        <xs:attributeGroup ref="id.DL.Attr" />
        <xs:attributeGroup ref="class.DL.Attr" />
        <xs:attributeGroup ref="xmllang.DL.Attr" />
        <xs:attributeGroup ref="label.DL.Attr" />
        <xs:attributeGroup ref="xmlbase.DL.Attr" />
    </xs:complexType>

    <xs:complexType name="DrawingInteraction.Type" abstract="false" mixed="false">
        <xs:annotation>
            <xs:documentation source="documentation">
                DrawingInteraction is the complexType for graphic gap match QTI interactions. The drawing 
                interaction allows the candidate to use a common set of drawing tools to modify a given g-
                raphical image (the canvas). It must be bound to a response variable with base-type file  
                and single cardinality. The result is a file in the same format as the original image.    
            </xs:documentation>
        </xs:annotation>
        <xs:sequence>
            <xs:element ref="prompt" minOccurs="0" maxOccurs="1" />
            <xs:element ref="object" minOccurs="1" maxOccurs="1" />
        </xs:sequence>
        <xs:attributeGroup ref="xmlbase.DrawingInteraction.Attr" />
        <xs:attributeGroup ref="id.DrawingInteraction.Attr" />
        <xs:attributeGroup ref="class.DrawingInteraction.Attr" />
        <xs:attributeGroup ref="xmllang.DrawingInteraction.Attr" />
        <xs:attributeGroup ref="label.DrawingInteraction.Attr" />
        <xs:attributeGroup ref="responseIdentifier.DrawingInteraction.Attr" />
    </xs:complexType>

    <xs:complexType name="DT.Type" abstract="false" mixed="true">
        <xs:annotation>
            <xs:documentation source="documentation">
                The 'DT' complexType is the container for term definitions as per the HTML 'dt' markup.   
            </xs:documentation>
        </xs:annotation>
        <xs:sequence>
            <xs:choice minOccurs="0" maxOccurs="unbounded">
                <xs:element ref="textEntryInteraction" minOccurs="1" maxOccurs="1" />
                <xs:element ref="hottext" minOccurs="1" maxOccurs="1" />
                <xs:element ref="printedVariable" minOccurs="1" maxOccurs="1" />
                <xs:element ref="gap" minOccurs="1" maxOccurs="1" />
                <xs:element ref="feedbackInline" minOccurs="1" maxOccurs="1" />
                <xs:element ref="templateInline" minOccurs="1" maxOccurs="1" />
                <xs:element ref="inlineChoiceInteraction" minOccurs="1" maxOccurs="1" />
                <xs:element ref="endAttemptInteraction" minOccurs="1" maxOccurs="1" />
                <xs:element ref="customInteraction" minOccurs="1" maxOccurs="1" />
                <xs:element ref="m:math" minOccurs="1" maxOccurs="1" />
                <xs:element ref="xi:include" minOccurs="1" maxOccurs="1" />
                <xs:choice minOccurs="1" maxOccurs="1">
                    <xs:element ref="img" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="br" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="object" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="em" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="a" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="code" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="span" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="sub" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="acronym" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="big" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="tt" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="kbd" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="q" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="i" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="dfn" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="abbr" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="strong" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="sup" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="var" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="small" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="samp" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="b" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="cite" minOccurs="1" maxOccurs="1" />
                </xs:choice>
            </xs:choice>
        </xs:sequence>
        <xs:attributeGroup ref="id.DT.Attr" />
        <xs:attributeGroup ref="class.DT.Attr" />
        <xs:attributeGroup ref="xmllang.DT.Attr" />
        <xs:attributeGroup ref="label.DT.Attr" />
        <xs:attributeGroup ref="xmlbase.DT.Attr" />
    </xs:complexType>

    <xs:complexType name="Equal.Type" abstract="false" mixed="false">
        <xs:annotation>
            <xs:documentation source="documentation">
                The equal operator takes two sub-expressions which must both have single cardinality and  
                have a numerical base-type. The result is a single boolean with a value of true if the two
                expressions are numerically equal and false if they are not. If either sub-expression is  
                NULL then the operator results in NULL.                                                   
            </xs:documentation>
        </xs:annotation>
        <xs:sequence>
            <xs:choice minOccurs="2" maxOccurs="2">
                <xs:element ref="and" minOccurs="1" maxOccurs="1" />
                <xs:element ref="gt" minOccurs="1" maxOccurs="1" />
                <xs:element ref="not" minOccurs="1" maxOccurs="1" />
                <xs:element ref="lt" minOccurs="1" maxOccurs="1" />
                <xs:element ref="gte" minOccurs="1" maxOccurs="1" />
                <xs:element ref="lte" minOccurs="1" maxOccurs="1" />
                <xs:element ref="or" minOccurs="1" maxOccurs="1" />
                <xs:element ref="sum" minOccurs="1" maxOccurs="1" />
                <xs:element ref="durationLT" minOccurs="1" maxOccurs="1" />
                <xs:element ref="durationGTE" minOccurs="1" maxOccurs="1" />
                <xs:element ref="subtract" minOccurs="1" maxOccurs="1" />
                <xs:element ref="divide" minOccurs="1" maxOccurs="1" />
                <xs:element ref="multiple" minOccurs="1" maxOccurs="1" />
                <xs:element ref="ordered" minOccurs="1" maxOccurs="1" />
                <xs:element ref="customOperator" minOccurs="1" maxOccurs="1" />
                <xs:element ref="random" minOccurs="1" maxOccurs="1" />
                <xs:element ref="numberIncorrect" minOccurs="1" maxOccurs="1" />
                <xs:element ref="numberCorrect" minOccurs="1" maxOccurs="1" />
                <xs:element ref="numberPresented" minOccurs="1" maxOccurs="1" />
                <xs:element ref="numberResponded" minOccurs="1" maxOccurs="1" />
                <xs:element ref="numberSelected" minOccurs="1" maxOccurs="1" />
                <xs:element ref="substring" minOccurs="1" maxOccurs="1" />
                <xs:element ref="equalRounded" minOccurs="1" maxOccurs="1" />
                <xs:element ref="null" minOccurs="1" maxOccurs="1" />
                <xs:element ref="delete" minOccurs="1" maxOccurs="1" />
                <xs:element ref="match" minOccurs="1" maxOccurs="1" />
                <xs:element ref="index" minOccurs="1" maxOccurs="1" />
                <xs:element ref="power" minOccurs="1" maxOccurs="1" />
                <xs:element ref="equal" minOccurs="1" maxOccurs="1" />
                <xs:element ref="contains" minOccurs="1" maxOccurs="1" />
                <xs:element ref="containerSize" minOccurs="1" maxOccurs="1" />
                <xs:element ref="correct" minOccurs="1" maxOccurs="1" />
                <xs:element ref="default" minOccurs="1" maxOccurs="1" />
                <xs:element ref="anyN" minOccurs="1" maxOccurs="1" />
                <xs:element ref="integerDivide" minOccurs="1" maxOccurs="1" />
                <xs:element ref="integerModulus" minOccurs="1" maxOccurs="1" />
                <xs:element ref="isNull" minOccurs="1" maxOccurs="1" />
                <xs:element ref="member" minOccurs="1" maxOccurs="1" />
                <xs:element ref="product" minOccurs="1" maxOccurs="1" />
                <xs:element ref="round" minOccurs="1" maxOccurs="1" />
                <xs:element ref="truncate" minOccurs="1" maxOccurs="1" />
                <xs:element ref="fieldValue" minOccurs="1" maxOccurs="1" />
                <xs:element ref="randomInteger" minOccurs="1" maxOccurs="1" />
                <xs:element ref="randomFloat" minOccurs="1" maxOccurs="1" />
                <xs:element ref="variable" minOccurs="1" maxOccurs="1" />
                <xs:element ref="outcomeMinimum" minOccurs="1" maxOccurs="1" />
                <xs:element ref="outcomeMaximum" minOccurs="1" maxOccurs="1" />
                <xs:element ref="testVariables" minOccurs="1" maxOccurs="1" />
                <xs:element ref="integerToFloat" minOccurs="1" maxOccurs="1" />
                <xs:element ref="inside" minOccurs="1" maxOccurs="1" />
                <xs:element ref="baseValue" minOccurs="1" maxOccurs="1" />
                <xs:element ref="patternMatch" minOccurs="1" maxOccurs="1" />
                <xs:element ref="mapResponsePoint" minOccurs="1" maxOccurs="1" />
                <xs:element ref="mapResponse" minOccurs="1" maxOccurs="1" />
                <xs:element ref="stringMatch" minOccurs="1" maxOccurs="1" />
                <xs:element ref="repeat" minOccurs="1" maxOccurs="1" />
                <xs:element ref="roundTo" minOccurs="1" maxOccurs="1" />
                <xs:element ref="lcm" minOccurs="1" maxOccurs="1" />
                <xs:element ref="gcd" minOccurs="1" maxOccurs="1" />
                <xs:element ref="min" minOccurs="1" maxOccurs="1" />
                <xs:element ref="max" minOccurs="1" maxOccurs="1" />
                <xs:element ref="mathConstant" minOccurs="1" maxOccurs="1" />
                <xs:element ref="statsOperator" minOccurs="1" maxOccurs="1" />
                <xs:element ref="mathOperator" minOccurs="1" maxOccurs="1" />
            </xs:choice>
        </xs:sequence>
        <xs:attributeGroup ref="toleranceMode.Equal.Attr" />
        <xs:attributeGroup ref="tolerance.Equal.Attr" />
        <xs:attributeGroup ref="includeLowerBound.Equal.Attr" />
        <xs:attributeGroup ref="includeUpperBound.Equal.Attr" />
    </xs:complexType>

    <xs:complexType name="EqualRounded.Type" abstract="false" mixed="false">
        <xs:annotation>
            <xs:documentation source="documentation">
                The equalRounded operator takes two sub-expressions which must both have single cardinali-
                ty and have a numerical base-type. The result is a single boolean with a value of true if 
                the two expressions are numerically equal after rounding and false if they are not. If ei-
                ther sub-expression is NULL then the operator results in NULL.                            
            </xs:documentation>
        </xs:annotation>
        <xs:sequence>
            <xs:choice minOccurs="2" maxOccurs="2">
                <xs:element ref="and" minOccurs="1" maxOccurs="1" />
                <xs:element ref="gt" minOccurs="1" maxOccurs="1" />
                <xs:element ref="not" minOccurs="1" maxOccurs="1" />
                <xs:element ref="lt" minOccurs="1" maxOccurs="1" />
                <xs:element ref="gte" minOccurs="1" maxOccurs="1" />
                <xs:element ref="lte" minOccurs="1" maxOccurs="1" />
                <xs:element ref="or" minOccurs="1" maxOccurs="1" />
                <xs:element ref="sum" minOccurs="1" maxOccurs="1" />
                <xs:element ref="durationLT" minOccurs="1" maxOccurs="1" />
                <xs:element ref="durationGTE" minOccurs="1" maxOccurs="1" />
                <xs:element ref="subtract" minOccurs="1" maxOccurs="1" />
                <xs:element ref="divide" minOccurs="1" maxOccurs="1" />
                <xs:element ref="multiple" minOccurs="1" maxOccurs="1" />
                <xs:element ref="ordered" minOccurs="1" maxOccurs="1" />
                <xs:element ref="customOperator" minOccurs="1" maxOccurs="1" />
                <xs:element ref="random" minOccurs="1" maxOccurs="1" />
                <xs:element ref="numberIncorrect" minOccurs="1" maxOccurs="1" />
                <xs:element ref="numberCorrect" minOccurs="1" maxOccurs="1" />
                <xs:element ref="numberPresented" minOccurs="1" maxOccurs="1" />
                <xs:element ref="numberResponded" minOccurs="1" maxOccurs="1" />
                <xs:element ref="numberSelected" minOccurs="1" maxOccurs="1" />
                <xs:element ref="substring" minOccurs="1" maxOccurs="1" />
                <xs:element ref="equalRounded" minOccurs="1" maxOccurs="1" />
                <xs:element ref="null" minOccurs="1" maxOccurs="1" />
                <xs:element ref="delete" minOccurs="1" maxOccurs="1" />
                <xs:element ref="match" minOccurs="1" maxOccurs="1" />
                <xs:element ref="index" minOccurs="1" maxOccurs="1" />
                <xs:element ref="power" minOccurs="1" maxOccurs="1" />
                <xs:element ref="equal" minOccurs="1" maxOccurs="1" />
                <xs:element ref="contains" minOccurs="1" maxOccurs="1" />
                <xs:element ref="containerSize" minOccurs="1" maxOccurs="1" />
                <xs:element ref="correct" minOccurs="1" maxOccurs="1" />
                <xs:element ref="default" minOccurs="1" maxOccurs="1" />
                <xs:element ref="anyN" minOccurs="1" maxOccurs="1" />
                <xs:element ref="integerDivide" minOccurs="1" maxOccurs="1" />
                <xs:element ref="integerModulus" minOccurs="1" maxOccurs="1" />
                <xs:element ref="isNull" minOccurs="1" maxOccurs="1" />
                <xs:element ref="member" minOccurs="1" maxOccurs="1" />
                <xs:element ref="product" minOccurs="1" maxOccurs="1" />
                <xs:element ref="round" minOccurs="1" maxOccurs="1" />
                <xs:element ref="truncate" minOccurs="1" maxOccurs="1" />
                <xs:element ref="fieldValue" minOccurs="1" maxOccurs="1" />
                <xs:element ref="randomInteger" minOccurs="1" maxOccurs="1" />
                <xs:element ref="randomFloat" minOccurs="1" maxOccurs="1" />
                <xs:element ref="variable" minOccurs="1" maxOccurs="1" />
                <xs:element ref="outcomeMinimum" minOccurs="1" maxOccurs="1" />
                <xs:element ref="outcomeMaximum" minOccurs="1" maxOccurs="1" />
                <xs:element ref="testVariables" minOccurs="1" maxOccurs="1" />
                <xs:element ref="integerToFloat" minOccurs="1" maxOccurs="1" />
                <xs:element ref="inside" minOccurs="1" maxOccurs="1" />
                <xs:element ref="baseValue" minOccurs="1" maxOccurs="1" />
                <xs:element ref="patternMatch" minOccurs="1" maxOccurs="1" />
                <xs:element ref="mapResponsePoint" minOccurs="1" maxOccurs="1" />
                <xs:element ref="mapResponse" minOccurs="1" maxOccurs="1" />
                <xs:element ref="stringMatch" minOccurs="1" maxOccurs="1" />
                <xs:element ref="repeat" minOccurs="1" maxOccurs="1" />
                <xs:element ref="roundTo" minOccurs="1" maxOccurs="1" />
                <xs:element ref="lcm" minOccurs="1" maxOccurs="1" />
                <xs:element ref="gcd" minOccurs="1" maxOccurs="1" />
                <xs:element ref="min" minOccurs="1" maxOccurs="1" />
                <xs:element ref="max" minOccurs="1" maxOccurs="1" />
                <xs:element ref="mathConstant" minOccurs="1" maxOccurs="1" />
                <xs:element ref="statsOperator" minOccurs="1" maxOccurs="1" />
                <xs:element ref="mathOperator" minOccurs="1" maxOccurs="1" />
            </xs:choice>
        </xs:sequence>
        <xs:attributeGroup ref="roundingMode.EqualRounded.Attr" />
        <xs:attributeGroup ref="figures.EqualRounded.Attr" />
    </xs:complexType>

    <xs:complexType name="ExtendedTextInteraction.Type" abstract="false" mixed="false">
        <xs:annotation>
            <xs:documentation source="documentation">
                The ExtendedTextInteraction complexType is the container for information about an extende-
                dText interaction. An extended text interaction is a blockInteraction that allows the can-
                didate to enter an extended amount of text. The extendedTextInteraction must be bound to a
                response variable with baseType of string, integer or float. When bound to response varia-
                ble with single cardinality a single string of text is required from the candidate. When  
                bound to a response variable with multiple or ordered cardinality several separate text s-
                trings may be required, see maxStrings below.                                             
            </xs:documentation>
        </xs:annotation>
        <xs:sequence>
            <xs:element ref="prompt" minOccurs="0" maxOccurs="1" />
        </xs:sequence>
        <xs:attributeGroup ref="xmlbase.ExtendedTextInteraction.Attr" />
        <xs:attributeGroup ref="id.ExtendedTextInteraction.Attr" />
        <xs:attributeGroup ref="class.ExtendedTextInteraction.Attr" />
        <xs:attributeGroup ref="xmllang.ExtendedTextInteraction.Attr" />
        <xs:attributeGroup ref="label.ExtendedTextInteraction.Attr" />
        <xs:attributeGroup ref="responseIdentifier.ExtendedTextInteraction.Attr" />
        <xs:attributeGroup ref="base.ExtendedTextInteraction.Attr" />
        <xs:attributeGroup ref="stringIdentifier.ExtendedTextInteraction.Attr" />
        <xs:attributeGroup ref="expectedLength.ExtendedTextInteraction.Attr" />
        <xs:attributeGroup ref="patternMask.ExtendedTextInteraction.Attr" />
        <xs:attributeGroup ref="placeholderText.ExtendedTextInteraction.Attr" />
        <xs:attributeGroup ref="maxStrings.ExtendedTextInteraction.Attr" />
        <xs:attributeGroup ref="minStrings.ExtendedTextInteraction.Attr" />
        <xs:attributeGroup ref="expectedLines.ExtendedTextInteraction.Attr" />
        <xs:attributeGroup ref="format.ExtendedTextInteraction.Attr" />
    </xs:complexType>

    <xs:complexType name="FeedbackBlock.Type" abstract="false" mixed="true">
        <xs:annotation>
            <xs:documentation source="documentation">
                The TemplateBlockFeedbackBlock complexType is the container for block-based feedback used 
                within a templateBlock.                                                                   
            </xs:documentation>
        </xs:annotation>
        <xs:sequence>
            <xs:choice minOccurs="0" maxOccurs="unbounded">
                <xs:choice minOccurs="1" maxOccurs="1">
                    <xs:element ref="positionObjectStage" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="customInteraction" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="drawingInteraction" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="gapMatchInteraction" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="matchInteraction" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="graphicGapMatchInteraction" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="hotspotInteraction" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="graphicOrderInteraction" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="selectPointInteraction" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="graphicAssociateInteraction" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="sliderInteraction" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="choiceInteraction" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="mediaInteraction" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="hottextInteraction" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="orderInteraction" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="extendedTextInteraction" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="uploadInteraction" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="associateInteraction" minOccurs="1" maxOccurs="1" />
                    <xs:element name="feedbackBlock" type="FeedbackBlock.Type" minOccurs="1" maxOccurs="1"/>
                    <xs:element name="templateBlock" type="TemplateBlock.Type" minOccurs="1" maxOccurs="1"/>
                    <xs:element ref="infoControl" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="m:math" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="xi:include" minOccurs="1" maxOccurs="1" />
                    <xs:choice minOccurs="1" maxOccurs="1">
                        <xs:element ref="pre" minOccurs="1" maxOccurs="1" />
                        <xs:element ref="h1" minOccurs="1" maxOccurs="1" />
                        <xs:element ref="h2" minOccurs="1" maxOccurs="1" />
                        <xs:element ref="h3" minOccurs="1" maxOccurs="1" />
                        <xs:element ref="h4" minOccurs="1" maxOccurs="1" />
                        <xs:element ref="h5" minOccurs="1" maxOccurs="1" />
                        <xs:element ref="h6" minOccurs="1" maxOccurs="1" />
                        <xs:element ref="p" minOccurs="1" maxOccurs="1" />
                        <xs:element ref="address" minOccurs="1" maxOccurs="1" />
                        <xs:element ref="dl" minOccurs="1" maxOccurs="1" />
                        <xs:element ref="ol" minOccurs="1" maxOccurs="1" />
                        <xs:element ref="hr" minOccurs="1" maxOccurs="1" />
                        <xs:element ref="ul" minOccurs="1" maxOccurs="1" />
                        <xs:element ref="blockquote" minOccurs="1" maxOccurs="1" />
                        <xs:element ref="table" minOccurs="1" maxOccurs="1" />
                        <xs:element ref="div" minOccurs="1" maxOccurs="1" />
                    </xs:choice>
                </xs:choice>
                <xs:choice minOccurs="1" maxOccurs="1">
                    <xs:element ref="img" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="br" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="object" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="em" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="a" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="code" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="span" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="sub" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="acronym" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="big" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="tt" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="kbd" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="q" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="i" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="dfn" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="abbr" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="strong" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="sup" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="var" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="small" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="samp" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="b" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="cite" minOccurs="1" maxOccurs="1" />
                </xs:choice>
                <xs:element name="templateInline" type="TemplateInline.Type" minOccurs="1" maxOccurs="1"/>
                <xs:element name="feedbackInline" type="FeedbackInline.Type" minOccurs="1" maxOccurs="1"/>
                <xs:element ref="printedVariable" minOccurs="1" maxOccurs="1" />
            </xs:choice>
            <xs:element ref="stylesheet" minOccurs="0" maxOccurs="unbounded" />
            <xs:element ref="apip:apipAccessibility" minOccurs="0" maxOccurs="1" />
        </xs:sequence>
        <xs:attributeGroup ref="outcomeIdentifier.FeedbackBlock.Attr" />
        <xs:attributeGroup ref="showHide.FeedbackBlock.Attr" />
        <xs:attributeGroup ref="identifier.FeedbackBlock.Attr" />
        <xs:attributeGroup ref="id.FeedbackBlock.Attr" />
        <xs:attributeGroup ref="class.FeedbackBlock.Attr" />
        <xs:attributeGroup ref="xmllang.FeedbackBlock.Attr" />
        <xs:attributeGroup ref="label.FeedbackBlock.Attr" />
        <xs:attributeGroup ref="xmlbase.FeedbackBlock.Attr" />
    </xs:complexType>

    <xs:complexType name="FeedbackInline.Type" abstract="false" mixed="true">
        <xs:annotation>
            <xs:documentation source="documentation">
                The FeedbackInline complexType is the container for the feedback to be presented to the c-
                andidate inline to other content.                                                         
            </xs:documentation>
        </xs:annotation>
        <xs:sequence>
            <xs:choice minOccurs="0" maxOccurs="unbounded">
                <xs:choice minOccurs="1" maxOccurs="1">
                    <xs:element ref="img" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="br" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="object" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="em" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="a" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="code" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="span" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="sub" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="acronym" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="big" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="tt" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="kbd" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="q" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="i" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="dfn" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="abbr" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="strong" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="sup" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="var" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="small" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="samp" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="b" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="cite" minOccurs="1" maxOccurs="1" />
                </xs:choice>
                <xs:element ref="m:math" minOccurs="1" maxOccurs="1" />
                <xs:element ref="xi:include" minOccurs="1" maxOccurs="1" />
                <xs:element name="templateInline" type="TemplateInline.Type" minOccurs="1" maxOccurs="1"/>
                <xs:element ref="printedVariable" minOccurs="1" maxOccurs="1" />
            </xs:choice>
        </xs:sequence>
        <xs:attributeGroup ref="outcomeIdentifier.FeedbackInline.Attr" />
        <xs:attributeGroup ref="showHide.FeedbackInline.Attr" />
        <xs:attributeGroup ref="identifier.FeedbackInline.Attr" />
        <xs:attributeGroup ref="id.FeedbackInline.Attr" />
        <xs:attributeGroup ref="class.FeedbackInline.Attr" />
        <xs:attributeGroup ref="xmllang.FeedbackInline.Attr" />
        <xs:attributeGroup ref="label.FeedbackInline.Attr" />
        <xs:attributeGroup ref="xmlbase.FeedbackInline.Attr" />
    </xs:complexType>

    <xs:complexType name="FieldValue.Type" abstract="false" mixed="false">
        <xs:annotation>
            <xs:documentation source="documentation">
                The field-value operator takes a sub-expression with a record container value. The result 
                is the value of the field with the specified fieldIdentifier. If there is no field with t-
                hat identifier then the result of the operator is NULL.                                   
            </xs:documentation>
        </xs:annotation>
        <xs:sequence>
            <xs:choice minOccurs="1" maxOccurs="1">
                <xs:element ref="and" minOccurs="1" maxOccurs="1" />
                <xs:element ref="gt" minOccurs="1" maxOccurs="1" />
                <xs:element ref="not" minOccurs="1" maxOccurs="1" />
                <xs:element ref="lt" minOccurs="1" maxOccurs="1" />
                <xs:element ref="gte" minOccurs="1" maxOccurs="1" />
                <xs:element ref="lte" minOccurs="1" maxOccurs="1" />
                <xs:element ref="or" minOccurs="1" maxOccurs="1" />
                <xs:element ref="sum" minOccurs="1" maxOccurs="1" />
                <xs:element ref="durationLT" minOccurs="1" maxOccurs="1" />
                <xs:element ref="durationGTE" minOccurs="1" maxOccurs="1" />
                <xs:element ref="subtract" minOccurs="1" maxOccurs="1" />
                <xs:element ref="divide" minOccurs="1" maxOccurs="1" />
                <xs:element ref="multiple" minOccurs="1" maxOccurs="1" />
                <xs:element ref="ordered" minOccurs="1" maxOccurs="1" />
                <xs:element ref="customOperator" minOccurs="1" maxOccurs="1" />
                <xs:element ref="random" minOccurs="1" maxOccurs="1" />
                <xs:element ref="numberIncorrect" minOccurs="1" maxOccurs="1" />
                <xs:element ref="numberCorrect" minOccurs="1" maxOccurs="1" />
                <xs:element ref="numberPresented" minOccurs="1" maxOccurs="1" />
                <xs:element ref="numberResponded" minOccurs="1" maxOccurs="1" />
                <xs:element ref="numberSelected" minOccurs="1" maxOccurs="1" />
                <xs:element ref="substring" minOccurs="1" maxOccurs="1" />
                <xs:element ref="equalRounded" minOccurs="1" maxOccurs="1" />
                <xs:element ref="null" minOccurs="1" maxOccurs="1" />
                <xs:element ref="delete" minOccurs="1" maxOccurs="1" />
                <xs:element ref="match" minOccurs="1" maxOccurs="1" />
                <xs:element ref="index" minOccurs="1" maxOccurs="1" />
                <xs:element ref="power" minOccurs="1" maxOccurs="1" />
                <xs:element ref="equal" minOccurs="1" maxOccurs="1" />
                <xs:element ref="contains" minOccurs="1" maxOccurs="1" />
                <xs:element ref="containerSize" minOccurs="1" maxOccurs="1" />
                <xs:element ref="correct" minOccurs="1" maxOccurs="1" />
                <xs:element ref="default" minOccurs="1" maxOccurs="1" />
                <xs:element ref="anyN" minOccurs="1" maxOccurs="1" />
                <xs:element ref="integerDivide" minOccurs="1" maxOccurs="1" />
                <xs:element ref="integerModulus" minOccurs="1" maxOccurs="1" />
                <xs:element ref="isNull" minOccurs="1" maxOccurs="1" />
                <xs:element ref="member" minOccurs="1" maxOccurs="1" />
                <xs:element ref="product" minOccurs="1" maxOccurs="1" />
                <xs:element ref="round" minOccurs="1" maxOccurs="1" />
                <xs:element ref="truncate" minOccurs="1" maxOccurs="1" />
                <xs:element ref="fieldValue" minOccurs="1" maxOccurs="1" />
                <xs:element ref="randomInteger" minOccurs="1" maxOccurs="1" />
                <xs:element ref="randomFloat" minOccurs="1" maxOccurs="1" />
                <xs:element ref="variable" minOccurs="1" maxOccurs="1" />
                <xs:element ref="outcomeMinimum" minOccurs="1" maxOccurs="1" />
                <xs:element ref="outcomeMaximum" minOccurs="1" maxOccurs="1" />
                <xs:element ref="testVariables" minOccurs="1" maxOccurs="1" />
                <xs:element ref="integerToFloat" minOccurs="1" maxOccurs="1" />
                <xs:element ref="inside" minOccurs="1" maxOccurs="1" />
                <xs:element ref="baseValue" minOccurs="1" maxOccurs="1" />
                <xs:element ref="patternMatch" minOccurs="1" maxOccurs="1" />
                <xs:element ref="mapResponsePoint" minOccurs="1" maxOccurs="1" />
                <xs:element ref="mapResponse" minOccurs="1" maxOccurs="1" />
                <xs:element ref="stringMatch" minOccurs="1" maxOccurs="1" />
                <xs:element ref="repeat" minOccurs="1" maxOccurs="1" />
                <xs:element ref="roundTo" minOccurs="1" maxOccurs="1" />
                <xs:element ref="lcm" minOccurs="1" maxOccurs="1" />
                <xs:element ref="gcd" minOccurs="1" maxOccurs="1" />
                <xs:element ref="min" minOccurs="1" maxOccurs="1" />
                <xs:element ref="max" minOccurs="1" maxOccurs="1" />
                <xs:element ref="mathConstant" minOccurs="1" maxOccurs="1" />
                <xs:element ref="statsOperator" minOccurs="1" maxOccurs="1" />
                <xs:element ref="mathOperator" minOccurs="1" maxOccurs="1" />
            </xs:choice>
        </xs:sequence>
        <xs:attributeGroup ref="fieldIdentifier.FieldValue.Attr" />
    </xs:complexType>

    <xs:complexType name="GapImg.Type" abstract="false" mixed="false">
        <xs:annotation>
            <xs:documentation source="documentation">
                The GapImg complexType is the container for an image assigned to a gap-based interaction. 
                A gap image contains a single image object to be inserted into a gap by the candidate.    
            </xs:documentation>
        </xs:annotation>
        <xs:sequence>
            <xs:element ref="object" minOccurs="1" maxOccurs="1" />
        </xs:sequence>
        <xs:attributeGroup ref="id.GapImg.Attr" />
        <xs:attributeGroup ref="class.GapImg.Attr" />
        <xs:attributeGroup ref="xmllang.GapImg.Attr" />
        <xs:attributeGroup ref="label.GapImg.Attr" />
        <xs:attributeGroup ref="identifier.GapImg.Attr" />
        <xs:attributeGroup ref="fixed.GapImg.Attr" />
        <xs:attributeGroup ref="templateIdentifier.GapImg.Attr" />
        <xs:attributeGroup ref="showHide.GapImg.Attr" />
        <xs:attributeGroup ref="matchGroup.GapImg.Attr" />
        <xs:attributeGroup ref="matchMax.GapImg.Attr" />
        <xs:attributeGroup ref="matchMin.GapImg.Attr" />
        <xs:attributeGroup ref="objectLabel.GapImg.Attr" />
    </xs:complexType>

    <xs:complexType name="GapMatchInteraction.Type" abstract="false" mixed="false">
        <xs:annotation>
            <xs:documentation source="documentation">
                The GapMatchInteraction complexType is the container for the information about a gap match
                interaction. A gap match interaction is a block interaction that contains a number gaps t-
                hat the candidate can fill from an associated set of choices. The candidate must be able  
                to review the content with the gaps filled in context, as indicated by their choices. The 
                gapMatchInteraction must be bound to a response variable with base-type directedPair and  
                either single or multiple cardinality, depending on the number of gaps. The choices repre-
                sent the source of the pairing and gaps the targets. Each gap can have at most one choice 
                associated with it. The maximum occurrence of the choices is controlled by the matchMax a-
                ttribute of gapChoice.                                                                    
            </xs:documentation>
        </xs:annotation>
        <xs:sequence>
            <xs:element ref="prompt" minOccurs="0" maxOccurs="1" />
            <xs:choice minOccurs="1" maxOccurs="unbounded">
                <xs:element ref="gapText" minOccurs="1" maxOccurs="1" />
                <xs:element ref="gapImg" minOccurs="1" maxOccurs="1" />
            </xs:choice>
            <xs:choice minOccurs="1" maxOccurs="unbounded">
                <xs:element ref="feedbackBlock" minOccurs="1" maxOccurs="1" />
                <xs:element ref="templateBlock" minOccurs="1" maxOccurs="1" />
                <xs:element ref="m:math" minOccurs="1" maxOccurs="1" />
                <xs:element ref="xi:include" minOccurs="1" maxOccurs="1" />
                <xs:choice minOccurs="1" maxOccurs="1">
                    <xs:element ref="pre" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="h1" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="h2" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="h3" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="h4" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="h5" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="h6" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="p" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="address" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="dl" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="ol" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="hr" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="ul" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="blockquote" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="table" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="div" minOccurs="1" maxOccurs="1" />
                </xs:choice>
            </xs:choice>
        </xs:sequence>
        <xs:attributeGroup ref="xmlbase.GapMatchInteraction.Attr" />
        <xs:attributeGroup ref="id.GapMatchInteraction.Attr" />
        <xs:attributeGroup ref="class.GapMatchInteraction.Attr" />
        <xs:attributeGroup ref="xmllang.GapMatchInteraction.Attr" />
        <xs:attributeGroup ref="label.GapMatchInteraction.Attr" />
        <xs:attributeGroup ref="responseIdentifier.GapMatchInteraction.Attr" />
        <xs:attributeGroup ref="shuffle.GapMatchInteraction.Attr" />
    </xs:complexType>

    <xs:complexType name="GapText.Type" abstract="false" mixed="true">
        <xs:annotation>
            <xs:documentation source="documentation">
                The GapText complexType is the container for text assigned to a gap-based interaction. A  
                simple run of text to be inserted into a gap by the user, may be subject to variable value
                substitution with printedVariable.                                                        
            </xs:documentation>
        </xs:annotation>
        <xs:sequence>
            <xs:element ref="printedVariable" minOccurs="0" maxOccurs="unbounded" />
        </xs:sequence>
        <xs:attributeGroup ref="id.GapText.Attr" />
        <xs:attributeGroup ref="class.GapText.Attr" />
        <xs:attributeGroup ref="xmllang.GapText.Attr" />
        <xs:attributeGroup ref="label.GapText.Attr" />
        <xs:attributeGroup ref="identifier.GapText.Attr" />
        <xs:attributeGroup ref="fixed.GapText.Attr" />
        <xs:attributeGroup ref="templateIdentifier.GapText.Attr" />
        <xs:attributeGroup ref="showHide.GapText.Attr" />
        <xs:attributeGroup ref="matchGroup.GapText.Attr" />
        <xs:attributeGroup ref="matchMax.GapText.Attr" />
        <xs:attributeGroup ref="matchMin.GapText.Attr" />
    </xs:complexType>

    <xs:complexType name="GraphicAssociateInteraction.Type" abstract="false" mixed="false">
        <xs:annotation>
            <xs:documentation source="documentation">
                GraphicAssociateInteraction is the complexType for graphic associate QTI interactions. A  
                graphic associate interaction is a graphic interaction with a corresponding set of choices
                that are defined as areas of the graphic image. The candidate's task is to associate the  
                areas (hotspots) with each other. The graphic associate interaction should only be used w-
                hen the graphical relationship of the choices with respect to each other (as represented  
                by the graphic image) is important to the needs of the item.                              
            </xs:documentation>
        </xs:annotation>
        <xs:sequence>
            <xs:element ref="prompt" minOccurs="0" maxOccurs="1" />
            <xs:element ref="object" minOccurs="1" maxOccurs="1" />
            <xs:element ref="associableHotspot" minOccurs="1" maxOccurs="unbounded" />
        </xs:sequence>
        <xs:attributeGroup ref="xmlbase.GraphicAssociateInteraction.Attr" />
        <xs:attributeGroup ref="id.GraphicAssociateInteraction.Attr" />
        <xs:attributeGroup ref="class.GraphicAssociateInteraction.Attr" />
        <xs:attributeGroup ref="xmllang.GraphicAssociateInteraction.Attr" />
        <xs:attributeGroup ref="label.GraphicAssociateInteraction.Attr" />
        <xs:attributeGroup ref="responseIdentifier.GraphicAssociateInteraction.Attr" />
        <xs:attributeGroup ref="maxAssociations.GraphicAssociateInteraction.Attr" />
        <xs:attributeGroup ref="minAssociations.GraphicAssociateInteraction.Attr" />
    </xs:complexType>

    <xs:complexType name="GraphicGapMatchInteraction.Type" abstract="false" mixed="false">
        <xs:annotation>
            <xs:documentation source="documentation">
                GraphicGapMatchInteraction is the complexType for graphic gap match QTI interactions. A g-
                raphic gap-match interaction is a graphical interaction with a set of gaps that are defin-
                ed as areas (hotspots) of the graphic image and an additional set of gap choices that are 
                defined outside the image. The candidate must associate the gap choices with the gaps in  
                the image and be able to review the image with the gaps filled in context, as indicated by
                their choices.                                                                            
            </xs:documentation>
        </xs:annotation>
        <xs:sequence>
            <xs:element ref="prompt" minOccurs="0" maxOccurs="1" />
            <xs:element ref="object" minOccurs="1" maxOccurs="1" />
            <xs:element ref="gapImg" minOccurs="1" maxOccurs="unbounded" />
            <xs:element ref="associableHotspot" minOccurs="1" maxOccurs="unbounded" />
        </xs:sequence>
        <xs:attributeGroup ref="xmlbase.GraphicGapMatchInteraction.Attr" />
        <xs:attributeGroup ref="id.GraphicGapMatchInteraction.Attr" />
        <xs:attributeGroup ref="class.GraphicGapMatchInteraction.Attr" />
        <xs:attributeGroup ref="xmllang.GraphicGapMatchInteraction.Attr" />
        <xs:attributeGroup ref="label.GraphicGapMatchInteraction.Attr" />
        <xs:attributeGroup ref="responseIdentifier.GraphicGapMatchInteraction.Attr" />
    </xs:complexType>

    <xs:complexType name="GraphicOrderInteraction.Type" abstract="false" mixed="false">
        <xs:annotation>
            <xs:documentation source="documentation">
                GraphicOrderInteraction is the complexType for graphic order QTI interactions. A graphic  
                order interaction is a graphic interaction with a corresponding set of choices that are d-
                efined as areas of the graphic image. The candidate's task is to impose an ordering on the
                areas (hotspots). The order hotspot interaction should only be used when the spacial rela-
                tionship of the choices with respect to each other (as represented by the graphic image)  
                is important to the needs of the item.                                                    
            </xs:documentation>
        </xs:annotation>
        <xs:sequence>
            <xs:element ref="prompt" minOccurs="0" maxOccurs="1" />
            <xs:element ref="object" minOccurs="1" maxOccurs="1" />
            <xs:element ref="hotspotChoice" minOccurs="1" maxOccurs="unbounded" />
        </xs:sequence>
        <xs:attributeGroup ref="xmlbase.GraphicOrderInteraction.Attr" />
        <xs:attributeGroup ref="id.GraphicOrderInteraction.Attr" />
        <xs:attributeGroup ref="class.GraphicOrderInteraction.Attr" />
        <xs:attributeGroup ref="xmllang.GraphicOrderInteraction.Attr" />
        <xs:attributeGroup ref="label.GraphicOrderInteraction.Attr" />
        <xs:attributeGroup ref="responseIdentifier.GraphicOrderInteraction.Attr" />
        <xs:attributeGroup ref="minChoices.GraphicOrderInteraction.Attr" />
        <xs:attributeGroup ref="maxChoices.GraphicOrderInteraction.Attr" />
    </xs:complexType>

    <xs:complexType name="HotspotInteraction.Type" abstract="false" mixed="false">
        <xs:annotation>
            <xs:documentation source="documentation">
                The HotspotInteraction complexType is the container for infromation on hotspot interactio-
                ns. A hotspot interaction is a graphical interaction with a corresponding set of choices  
                that are defined as areas of the graphic image. The candidate's task is to select one or  
                more of the areas (hotspots). The hotspot interaction should only be used when the spacial
                relationship of the choices with respect to each other (as represented by the graphic ima-
                ge) is important to the needs of the item. Otherwise, choiceInteraction should be used in-
                stead with separate material for each option.The delivery engine must clearly indicate the
                selected area(s) of the image and may also indicate the unselected areas as well. Interac-
                tions with hidden hotspots are achieved with the selectPointInteraction.                  
            </xs:documentation>
        </xs:annotation>
        <xs:sequence>
            <xs:element ref="prompt" minOccurs="0" maxOccurs="1" />
            <xs:element ref="object" minOccurs="1" maxOccurs="1" />
            <xs:element ref="hotspotChoice" minOccurs="1" maxOccurs="unbounded" />
        </xs:sequence>
        <xs:attributeGroup ref="xmlbase.HotspotInteraction.Attr" />
        <xs:attributeGroup ref="id.HotspotInteraction.Attr" />
        <xs:attributeGroup ref="class.HotspotInteraction.Attr" />
        <xs:attributeGroup ref="xmllang.HotspotInteraction.Attr" />
        <xs:attributeGroup ref="label.HotspotInteraction.Attr" />
        <xs:attributeGroup ref="responseIdentifier.HotspotInteraction.Attr" />
        <xs:attributeGroup ref="minChoices.HotspotInteraction.Attr" />
        <xs:attributeGroup ref="maxChoices.HotspotInteraction.Attr" />
    </xs:complexType>

    <xs:complexType name="HotText.Type" abstract="false" mixed="true">
        <xs:annotation>
            <xs:documentation source="documentation">
                The HotText complexType is the container for HotText information. A hottext area is used  
                within the content of an hottextInteraction to provide the individual choices. It must not
                contain any nested interactions or other hottext areas. When a hottext choice is hidden (-
                by the value of an associated template variable) the content of the choice must still be  
                presented to the candidate as if it were simply part of the surrounding material. In the  
                case of hottext, the effect of hiding the choice is simply to make the run of text unsele-
                ctable by the candidate.                                                                  
            </xs:documentation>
        </xs:annotation>
        <xs:sequence>
            <xs:choice minOccurs="0" maxOccurs="unbounded">
                <xs:element ref="hottext" minOccurs="1" maxOccurs="1" />
                <xs:element ref="printedVariable" minOccurs="1" maxOccurs="1" />
                <xs:element ref="gap" minOccurs="1" maxOccurs="1" />
                <xs:element ref="feedbackInline" minOccurs="1" maxOccurs="1" />
                <xs:element ref="templateInline" minOccurs="1" maxOccurs="1" />
                <xs:element ref="m:math" minOccurs="1" maxOccurs="1" />
                <xs:element ref="xi:include" minOccurs="1" maxOccurs="1" />
                <xs:choice minOccurs="1" maxOccurs="1">
                    <xs:element ref="img" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="br" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="object" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="em" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="a" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="code" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="span" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="sub" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="acronym" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="big" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="tt" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="kbd" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="q" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="i" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="dfn" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="abbr" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="strong" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="sup" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="var" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="small" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="samp" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="b" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="cite" minOccurs="1" maxOccurs="1" />
                </xs:choice>
            </xs:choice>
        </xs:sequence>
        <xs:attributeGroup ref="id.HotText.Attr" />
        <xs:attributeGroup ref="class.HotText.Attr" />
        <xs:attributeGroup ref="xmllanguage.HotText.Attr" />
        <xs:attributeGroup ref="label.HotText.Attr" />
        <xs:attributeGroup ref="identifier.HotText.Attr" />
        <xs:attributeGroup ref="fixed.HotText.Attr" />
        <xs:attributeGroup ref="templateIdentifier.HotText.Attr" />
        <xs:attributeGroup ref="showHide.HotText.Attr" />
        <xs:attributeGroup ref="xmlbase.HotText.Attr" />
    </xs:complexType>

    <xs:complexType name="HotTextInteraction.Type" abstract="false" mixed="false">
        <xs:annotation>
            <xs:documentation source="documentation">
                The HotTextInteraction complexType is the container for information about a hotText inter-
                action. The hottext interaction presents a set of choices to the candidate represented as 
                selectable runs of text embedded within a surrounding context, such as a simple passage of
                text. Like choiceInteraction, the candidate's task is to select one or more of the choice-
                s, up to a maximum of maxChoices. The interaction is initialized from the defaultValue of 
                the associated response variable, a NULL value indicating that no choices are selected (t-
                he usual case). The hottextInteraction must be bound to a response variable with a baseTy-
                pe of identifier and single or multiple cardinality.                                      
            </xs:documentation>
        </xs:annotation>
        <xs:sequence>
            <xs:element ref="prompt" minOccurs="0" maxOccurs="1" />
            <xs:choice minOccurs="1" maxOccurs="unbounded">
                <xs:element ref="feedbackBlock" minOccurs="1" maxOccurs="1" />
                <xs:element ref="templateBlock" minOccurs="1" maxOccurs="1" />
                <xs:element ref="m:math" minOccurs="1" maxOccurs="1" />
                <xs:element ref="xi:include" minOccurs="1" maxOccurs="1" />
                <xs:choice minOccurs="1" maxOccurs="1">
                    <xs:element ref="pre" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="h1" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="h2" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="h3" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="h4" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="h5" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="h6" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="p" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="address" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="dl" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="ol" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="hr" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="ul" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="blockquote" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="table" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="div" minOccurs="1" maxOccurs="1" />
                </xs:choice>
            </xs:choice>
        </xs:sequence>
        <xs:attributeGroup ref="xmlbase.HotTextInteraction.Attr" />
        <xs:attributeGroup ref="id.HotTextInteraction.Attr" />
        <xs:attributeGroup ref="class.HotTextInteraction.Attr" />
        <xs:attributeGroup ref="xmllang.HotTextInteraction.Attr" />
        <xs:attributeGroup ref="label.HotTextInteraction.Attr" />
        <xs:attributeGroup ref="responseIdentifier.HotTextInteraction.Attr" />
        <xs:attributeGroup ref="maxChoices.HotTextInteraction.Attr" />
        <xs:attributeGroup ref="minChoices.HotTextInteraction.Attr" />
    </xs:complexType>

    <xs:complexType name="HTMLText.Type" abstract="false" mixed="true">
        <xs:annotation>
            <xs:documentation source="documentation">
                The complexType for the set of HTML text elements i.e. h1, h2, h3, h4, h5, h6, p, pre and 
                address.                                                                                  
            </xs:documentation>
        </xs:annotation>
        <xs:sequence>
            <xs:choice minOccurs="0" maxOccurs="unbounded">
                <xs:element ref="textEntryInteraction" minOccurs="1" maxOccurs="1" />
                <xs:element ref="hottext" minOccurs="1" maxOccurs="1" />
                <xs:element ref="printedVariable" minOccurs="1" maxOccurs="1" />
                <xs:element ref="gap" minOccurs="1" maxOccurs="1" />
                <xs:element ref="feedbackInline" minOccurs="1" maxOccurs="1" />
                <xs:element ref="templateInline" minOccurs="1" maxOccurs="1" />
                <xs:element ref="inlineChoiceInteraction" minOccurs="1" maxOccurs="1" />
                <xs:element ref="endAttemptInteraction" minOccurs="1" maxOccurs="1" />
                <xs:element ref="customInteraction" minOccurs="1" maxOccurs="1" />
                <xs:element ref="m:math" minOccurs="1" maxOccurs="1" />
                <xs:element ref="xi:include" minOccurs="1" maxOccurs="1" />
                <xs:choice minOccurs="1" maxOccurs="1">
                    <xs:element ref="img" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="br" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="object" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="em" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="a" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="code" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="span" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="sub" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="acronym" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="big" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="tt" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="kbd" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="q" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="i" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="dfn" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="abbr" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="strong" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="sup" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="var" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="small" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="samp" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="b" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="cite" minOccurs="1" maxOccurs="1" />
                </xs:choice>
            </xs:choice>
        </xs:sequence>
        <xs:attributeGroup ref="id.HTMLText.Attr" />
        <xs:attributeGroup ref="class.HTMLText.Attr" />
        <xs:attributeGroup ref="xmllang.HTMLText.Attr" />
        <xs:attributeGroup ref="label.HTMLText.Attr" />
        <xs:attributeGroup ref="xmlbase.HTMLText.Attr" />
    </xs:complexType>

    <xs:complexType name="Index.Type" abstract="false" mixed="false">
        <xs:annotation>
            <xs:documentation source="documentation">
                The index operator takes a sub-expression with an ordered container value and any base-ty-
                pe. The result is the nth value of the container. The result has the same base-type as the
                sub-expression but single cardinality. The first value of a container has index 1, the se-
                cond 2 and so on. n must be a positive integer. If n exceeds the number of values in the  
                container (or the sub-expression is NULL) then the result of the index operator is NULL.  
                If n is an identifier, it is the value of n at runtime that is used.                      
            </xs:documentation>
        </xs:annotation>
        <xs:sequence>
            <xs:choice minOccurs="1" maxOccurs="1">
                <xs:element ref="and" minOccurs="1" maxOccurs="1" />
                <xs:element ref="gt" minOccurs="1" maxOccurs="1" />
                <xs:element ref="not" minOccurs="1" maxOccurs="1" />
                <xs:element ref="lt" minOccurs="1" maxOccurs="1" />
                <xs:element ref="gte" minOccurs="1" maxOccurs="1" />
                <xs:element ref="lte" minOccurs="1" maxOccurs="1" />
                <xs:element ref="or" minOccurs="1" maxOccurs="1" />
                <xs:element ref="sum" minOccurs="1" maxOccurs="1" />
                <xs:element ref="durationLT" minOccurs="1" maxOccurs="1" />
                <xs:element ref="durationGTE" minOccurs="1" maxOccurs="1" />
                <xs:element ref="subtract" minOccurs="1" maxOccurs="1" />
                <xs:element ref="divide" minOccurs="1" maxOccurs="1" />
                <xs:element ref="multiple" minOccurs="1" maxOccurs="1" />
                <xs:element ref="ordered" minOccurs="1" maxOccurs="1" />
                <xs:element ref="customOperator" minOccurs="1" maxOccurs="1" />
                <xs:element ref="random" minOccurs="1" maxOccurs="1" />
                <xs:element ref="numberIncorrect" minOccurs="1" maxOccurs="1" />
                <xs:element ref="numberCorrect" minOccurs="1" maxOccurs="1" />
                <xs:element ref="numberPresented" minOccurs="1" maxOccurs="1" />
                <xs:element ref="numberResponded" minOccurs="1" maxOccurs="1" />
                <xs:element ref="numberSelected" minOccurs="1" maxOccurs="1" />
                <xs:element ref="substring" minOccurs="1" maxOccurs="1" />
                <xs:element ref="equalRounded" minOccurs="1" maxOccurs="1" />
                <xs:element ref="null" minOccurs="1" maxOccurs="1" />
                <xs:element ref="delete" minOccurs="1" maxOccurs="1" />
                <xs:element ref="match" minOccurs="1" maxOccurs="1" />
                <xs:element ref="index" minOccurs="1" maxOccurs="1" />
                <xs:element ref="power" minOccurs="1" maxOccurs="1" />
                <xs:element ref="equal" minOccurs="1" maxOccurs="1" />
                <xs:element ref="contains" minOccurs="1" maxOccurs="1" />
                <xs:element ref="containerSize" minOccurs="1" maxOccurs="1" />
                <xs:element ref="correct" minOccurs="1" maxOccurs="1" />
                <xs:element ref="default" minOccurs="1" maxOccurs="1" />
                <xs:element ref="anyN" minOccurs="1" maxOccurs="1" />
                <xs:element ref="integerDivide" minOccurs="1" maxOccurs="1" />
                <xs:element ref="integerModulus" minOccurs="1" maxOccurs="1" />
                <xs:element ref="isNull" minOccurs="1" maxOccurs="1" />
                <xs:element ref="member" minOccurs="1" maxOccurs="1" />
                <xs:element ref="product" minOccurs="1" maxOccurs="1" />
                <xs:element ref="round" minOccurs="1" maxOccurs="1" />
                <xs:element ref="truncate" minOccurs="1" maxOccurs="1" />
                <xs:element ref="fieldValue" minOccurs="1" maxOccurs="1" />
                <xs:element ref="randomInteger" minOccurs="1" maxOccurs="1" />
                <xs:element ref="randomFloat" minOccurs="1" maxOccurs="1" />
                <xs:element ref="variable" minOccurs="1" maxOccurs="1" />
                <xs:element ref="outcomeMinimum" minOccurs="1" maxOccurs="1" />
                <xs:element ref="outcomeMaximum" minOccurs="1" maxOccurs="1" />
                <xs:element ref="testVariables" minOccurs="1" maxOccurs="1" />
                <xs:element ref="integerToFloat" minOccurs="1" maxOccurs="1" />
                <xs:element ref="inside" minOccurs="1" maxOccurs="1" />
                <xs:element ref="baseValue" minOccurs="1" maxOccurs="1" />
                <xs:element ref="patternMatch" minOccurs="1" maxOccurs="1" />
                <xs:element ref="mapResponsePoint" minOccurs="1" maxOccurs="1" />
                <xs:element ref="mapResponse" minOccurs="1" maxOccurs="1" />
                <xs:element ref="stringMatch" minOccurs="1" maxOccurs="1" />
                <xs:element ref="repeat" minOccurs="1" maxOccurs="1" />
                <xs:element ref="roundTo" minOccurs="1" maxOccurs="1" />
                <xs:element ref="lcm" minOccurs="1" maxOccurs="1" />
                <xs:element ref="gcd" minOccurs="1" maxOccurs="1" />
                <xs:element ref="min" minOccurs="1" maxOccurs="1" />
                <xs:element ref="max" minOccurs="1" maxOccurs="1" />
                <xs:element ref="mathConstant" minOccurs="1" maxOccurs="1" />
                <xs:element ref="statsOperator" minOccurs="1" maxOccurs="1" />
                <xs:element ref="mathOperator" minOccurs="1" maxOccurs="1" />
            </xs:choice>
        </xs:sequence>
        <xs:attributeGroup ref="n.Index.Attr" />
    </xs:complexType>

    <xs:complexType name="InfoControl.Type" abstract="false" mixed="true">
        <xs:annotation>
            <xs:documentation source="documentation">
                The 'InfoControl' complexType is the container to provide the candidate with extra inform-
                ation about the item when s/he chooses to trigger the control. The extra information can  
                be a hint, but could also be additional tools such as a ruler or a (javaScript) calculato-
                r.                                                                                        
            </xs:documentation>
        </xs:annotation>
        <xs:sequence>
            <xs:choice minOccurs="0" maxOccurs="unbounded">
                <xs:element ref="printedVariable" minOccurs="1" maxOccurs="1" />
                <xs:element ref="feedbackBlock" minOccurs="1" maxOccurs="1" />
                <xs:element ref="feedbackInline" minOccurs="1" maxOccurs="1" />
                <xs:element ref="templateInline" minOccurs="1" maxOccurs="1" />
                <xs:element ref="templateBlock" minOccurs="1" maxOccurs="1" />
                <xs:element ref="m:math" minOccurs="1" maxOccurs="1" />
                <xs:element ref="xi:include" minOccurs="1" maxOccurs="1" />
                <xs:choice minOccurs="1" maxOccurs="1">
                    <xs:element ref="pre" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="h1" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="h2" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="h3" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="h4" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="h5" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="h6" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="p" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="address" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="dl" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="ol" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="ul" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="br" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="hr" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="img" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="object" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="blockquote" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="em" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="a" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="code" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="span" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="sub" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="acronym" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="big" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="tt" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="kbd" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="q" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="i" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="dfn" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="abbr" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="strong" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="sup" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="var" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="small" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="samp" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="b" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="cite" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="table" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="div" minOccurs="1" maxOccurs="1" />
                </xs:choice>
            </xs:choice>
        </xs:sequence>
        <xs:attributeGroup ref="id.InfoControl.Attr" />
        <xs:attributeGroup ref="title.InfoControl.Attr" />
        <xs:attributeGroup ref="class.InfoControl.Attr" />
        <xs:attributeGroup ref="label.InfoControl.Attr" />
        <xs:attributeGroup ref="xmllang.InfoControl.Attr" />
    </xs:complexType>

    <xs:complexType name="InlineChoice.Type" abstract="false" mixed="true">
        <xs:annotation>
            <xs:documentation source="documentation">
                An InlineChoice complexType is the container for a simple run of text to be displayed to  
                the user, and which may be subject to variable value substitution with printedVariable(s).
            </xs:documentation>
        </xs:annotation>
        <xs:sequence>
            <xs:element ref="printedVariable" minOccurs="0" maxOccurs="unbounded" />
        </xs:sequence>
        <xs:attributeGroup ref="id.InlineChoice.Attr" />
        <xs:attributeGroup ref="class.InlineChoice.Attr" />
        <xs:attributeGroup ref="xmllang.InlineChoice.Attr" />
        <xs:attributeGroup ref="label.InlineChoice.Attr" />
        <xs:attributeGroup ref="identifier.InlineChoice.Attr" />
        <xs:attributeGroup ref="fixed.InlineChoice.Attr" />
        <xs:attributeGroup ref="templateIdentifier.InlineChoice.Attr" />
        <xs:attributeGroup ref="showHide.InlineChoice.Attr" />
    </xs:complexType>

    <xs:complexType name="InlineChoiceInteraction.Type" abstract="false" mixed="false">
        <xs:annotation>
            <xs:documentation source="documentation">
                The InlineChoiceInteraction complexType is the container for information about an inline  
                choice interaction. An inline choice is an inlineInteraction that presents the user with a
                set of choices, each of which is a simple piece of text. The candidate's task is to select
                one of the choices. Unlike the choiceInteraction, the delivery engine must allow the cand-
                idate to review their choice within the context of the surrounding text.                  
            </xs:documentation>
        </xs:annotation>
        <xs:sequence>
            <xs:element ref="inlineChoice" minOccurs="1" maxOccurs="unbounded" />
        </xs:sequence>
        <xs:attributeGroup ref="xmlbase.InlineChoiceInteraction.Attr" />
        <xs:attributeGroup ref="id.InlineChoiceInteraction.Attr" />
        <xs:attributeGroup ref="class.InlineChoiceInteraction.Attr" />
        <xs:attributeGroup ref="xmllang.InlineChoiceInteraction.Attr" />
        <xs:attributeGroup ref="label.InlineChoiceInteraction.Attr" />
        <xs:attributeGroup ref="responseIdentifier.InlineChoiceInteraction.Attr" />
        <xs:attributeGroup ref="shuffle.InlineChoiceInteraction.Attr" />
        <xs:attributeGroup ref="required.InlineChoiceInteraction.Attr" />
    </xs:complexType>

    <xs:complexType name="Inside.Type" abstract="false" mixed="false">
        <xs:annotation>
            <xs:documentation source="documentation">
                The inside operator takes a single sub-expression which must have a baseType of point. The
                result is a single boolean with a value of true if the given point is inside the area def-
                ined by shape and coords. If the sub-expression is a container the result is true if any  
                of the points are inside the area. If either sub-expression is NULL then the operator res-
                ults in NULL.                                                                             
            </xs:documentation>
        </xs:annotation>
        <xs:sequence>
            <xs:choice minOccurs="1" maxOccurs="1">
                <xs:element ref="and" minOccurs="1" maxOccurs="1" />
                <xs:element ref="gt" minOccurs="1" maxOccurs="1" />
                <xs:element ref="not" minOccurs="1" maxOccurs="1" />
                <xs:element ref="lt" minOccurs="1" maxOccurs="1" />
                <xs:element ref="gte" minOccurs="1" maxOccurs="1" />
                <xs:element ref="lte" minOccurs="1" maxOccurs="1" />
                <xs:element ref="or" minOccurs="1" maxOccurs="1" />
                <xs:element ref="sum" minOccurs="1" maxOccurs="1" />
                <xs:element ref="durationLT" minOccurs="1" maxOccurs="1" />
                <xs:element ref="durationGTE" minOccurs="1" maxOccurs="1" />
                <xs:element ref="subtract" minOccurs="1" maxOccurs="1" />
                <xs:element ref="divide" minOccurs="1" maxOccurs="1" />
                <xs:element ref="multiple" minOccurs="1" maxOccurs="1" />
                <xs:element ref="ordered" minOccurs="1" maxOccurs="1" />
                <xs:element ref="customOperator" minOccurs="1" maxOccurs="1" />
                <xs:element ref="random" minOccurs="1" maxOccurs="1" />
                <xs:element ref="numberIncorrect" minOccurs="1" maxOccurs="1" />
                <xs:element ref="numberCorrect" minOccurs="1" maxOccurs="1" />
                <xs:element ref="numberPresented" minOccurs="1" maxOccurs="1" />
                <xs:element ref="numberResponded" minOccurs="1" maxOccurs="1" />
                <xs:element ref="numberSelected" minOccurs="1" maxOccurs="1" />
                <xs:element ref="substring" minOccurs="1" maxOccurs="1" />
                <xs:element ref="equalRounded" minOccurs="1" maxOccurs="1" />
                <xs:element ref="null" minOccurs="1" maxOccurs="1" />
                <xs:element ref="delete" minOccurs="1" maxOccurs="1" />
                <xs:element ref="match" minOccurs="1" maxOccurs="1" />
                <xs:element ref="index" minOccurs="1" maxOccurs="1" />
                <xs:element ref="power" minOccurs="1" maxOccurs="1" />
                <xs:element ref="equal" minOccurs="1" maxOccurs="1" />
                <xs:element ref="contains" minOccurs="1" maxOccurs="1" />
                <xs:element ref="containerSize" minOccurs="1" maxOccurs="1" />
                <xs:element ref="correct" minOccurs="1" maxOccurs="1" />
                <xs:element ref="default" minOccurs="1" maxOccurs="1" />
                <xs:element ref="anyN" minOccurs="1" maxOccurs="1" />
                <xs:element ref="integerDivide" minOccurs="1" maxOccurs="1" />
                <xs:element ref="integerModulus" minOccurs="1" maxOccurs="1" />
                <xs:element ref="isNull" minOccurs="1" maxOccurs="1" />
                <xs:element ref="member" minOccurs="1" maxOccurs="1" />
                <xs:element ref="product" minOccurs="1" maxOccurs="1" />
                <xs:element ref="round" minOccurs="1" maxOccurs="1" />
                <xs:element ref="truncate" minOccurs="1" maxOccurs="1" />
                <xs:element ref="fieldValue" minOccurs="1" maxOccurs="1" />
                <xs:element ref="randomInteger" minOccurs="1" maxOccurs="1" />
                <xs:element ref="randomFloat" minOccurs="1" maxOccurs="1" />
                <xs:element ref="variable" minOccurs="1" maxOccurs="1" />
                <xs:element ref="outcomeMinimum" minOccurs="1" maxOccurs="1" />
                <xs:element ref="outcomeMaximum" minOccurs="1" maxOccurs="1" />
                <xs:element ref="testVariables" minOccurs="1" maxOccurs="1" />
                <xs:element ref="integerToFloat" minOccurs="1" maxOccurs="1" />
                <xs:element ref="inside" minOccurs="1" maxOccurs="1" />
                <xs:element ref="baseValue" minOccurs="1" maxOccurs="1" />
                <xs:element ref="patternMatch" minOccurs="1" maxOccurs="1" />
                <xs:element ref="mapResponsePoint" minOccurs="1" maxOccurs="1" />
                <xs:element ref="mapResponse" minOccurs="1" maxOccurs="1" />
                <xs:element ref="stringMatch" minOccurs="1" maxOccurs="1" />
                <xs:element ref="repeat" minOccurs="1" maxOccurs="1" />
                <xs:element ref="roundTo" minOccurs="1" maxOccurs="1" />
                <xs:element ref="lcm" minOccurs="1" maxOccurs="1" />
                <xs:element ref="gcd" minOccurs="1" maxOccurs="1" />
                <xs:element ref="min" minOccurs="1" maxOccurs="1" />
                <xs:element ref="max" minOccurs="1" maxOccurs="1" />
                <xs:element ref="mathConstant" minOccurs="1" maxOccurs="1" />
                <xs:element ref="statsOperator" minOccurs="1" maxOccurs="1" />
                <xs:element ref="mathOperator" minOccurs="1" maxOccurs="1" />
            </xs:choice>
        </xs:sequence>
        <xs:attributeGroup ref="shape.Inside.Attr" />
        <xs:attributeGroup ref="coords.Inside.Attr" />
    </xs:complexType>

    <xs:complexType name="InterpolationTable.Type" abstract="false" mixed="false">
        <xs:annotation>
            <xs:documentation source="documentation">
                The InterpolationTable complexType is the container for interpolation information. An int-
                erpolationTable transforms a source float (or integer) by finding the first interpolation-
                TableEntry with a sourceValue that is less than or equal to (subject to includeBoundary)  
                the source value. For example, an interpolation table can be used to map a raw numeric sc-
                ore onto an identifier representing a grade. It may also be used to implement numeric tra-
                nsformations such as those from a simple raw score to a value on a calibrated scale.      
            </xs:documentation>
        </xs:annotation>
        <xs:sequence>
            <xs:element ref="interpolationTableEntry" minOccurs="1" maxOccurs="unbounded" />
        </xs:sequence>
        <xs:attributeGroup ref="defaultValue.InterpolationTable.Attr" />
    </xs:complexType>

    <xs:complexType name="ItemBody.Type" abstract="false" mixed="false">
        <xs:annotation>
            <xs:documentation source="documentation">
                This is the container for the set of materials that are to be rendered as the question it-
                self. The content model is XHTML-based and combines with it the range of QTI interactions 
                (an interaction defines the nature of the question e.g. multple choice, hotspot, etc.). T-
                he rubric material can be interleaved with the block content.                             
            </xs:documentation>
        </xs:annotation>
        <xs:sequence>
            <xs:choice minOccurs="1" maxOccurs="unbounded">
                <xs:element ref="rubricBlock" minOccurs="1" maxOccurs="1" />
                <xs:choice minOccurs="1" maxOccurs="1">
                    <xs:element ref="positionObjectStage" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="customInteraction" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="drawingInteraction" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="gapMatchInteraction" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="matchInteraction" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="graphicGapMatchInteraction" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="hotspotInteraction" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="graphicOrderInteraction" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="selectPointInteraction" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="graphicAssociateInteraction" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="sliderInteraction" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="choiceInteraction" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="mediaInteraction" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="hottextInteraction" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="orderInteraction" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="extendedTextInteraction" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="uploadInteraction" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="associateInteraction" minOccurs="1" maxOccurs="1" />
                    <xs:element name="feedbackBlock" type="FeedbackBlock.Type" minOccurs="1" maxOccurs="1"/>
                    <xs:element name="templateBlock" type="TemplateBlock.Type" minOccurs="1" maxOccurs="1"/>
                    <xs:element ref="infoControl" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="m:math" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="xi:include" minOccurs="1" maxOccurs="1" />
                    <xs:choice minOccurs="1" maxOccurs="1">
                        <xs:element ref="pre" minOccurs="1" maxOccurs="1" />
                        <xs:element ref="h1" minOccurs="1" maxOccurs="1" />
                        <xs:element ref="h2" minOccurs="1" maxOccurs="1" />
                        <xs:element ref="h3" minOccurs="1" maxOccurs="1" />
                        <xs:element ref="h4" minOccurs="1" maxOccurs="1" />
                        <xs:element ref="h5" minOccurs="1" maxOccurs="1" />
                        <xs:element ref="h6" minOccurs="1" maxOccurs="1" />
                        <xs:element ref="p" minOccurs="1" maxOccurs="1" />
                        <xs:element ref="address" minOccurs="1" maxOccurs="1" />
                        <xs:element ref="dl" minOccurs="1" maxOccurs="1" />
                        <xs:element ref="ol" minOccurs="1" maxOccurs="1" />
                        <xs:element ref="hr" minOccurs="1" maxOccurs="1" />
                        <xs:element ref="ul" minOccurs="1" maxOccurs="1" />
                        <xs:element ref="blockquote" minOccurs="1" maxOccurs="1" />
                        <xs:element ref="table" minOccurs="1" maxOccurs="1" />
                        <xs:element ref="div" minOccurs="1" maxOccurs="1" />
                    </xs:choice>
                </xs:choice>
            </xs:choice>
        </xs:sequence>
        <xs:attributeGroup ref="id.ItemBody.Attr" />
        <xs:attributeGroup ref="class.ItemBody.Attr" />
        <xs:attributeGroup ref="xmllang.ItemBody.Attr" />
        <xs:attributeGroup ref="label.ItemBody.Attr" />
    </xs:complexType>

    <xs:complexType name="LI.Type" abstract="false" mixed="true">
        <xs:annotation>
            <xs:documentation source="documentation">
                The 'LI' complexType is the container for the definition of lists as per the HTML 'li' ma-
                rkup.                                                                                     
            </xs:documentation>
        </xs:annotation>
        <xs:sequence>
            <xs:choice minOccurs="0" maxOccurs="unbounded">
                <xs:element ref="printedVariable" minOccurs="1" maxOccurs="1" />
                <xs:element ref="feedbackBlock" minOccurs="1" maxOccurs="1" />
                <xs:element ref="hottext" minOccurs="1" maxOccurs="1" />
                <xs:element ref="feedbackInline" minOccurs="1" maxOccurs="1" />
                <xs:element ref="templateInline" minOccurs="1" maxOccurs="1" />
                <xs:element ref="templateBlock" minOccurs="1" maxOccurs="1" />
                <xs:element ref="m:math" minOccurs="1" maxOccurs="1" />
                <xs:element ref="xi:include" minOccurs="1" maxOccurs="1" />
                <xs:element ref="textEntryInteraction" minOccurs="1" maxOccurs="1" />
                <xs:element ref="inlineChoiceInteraction" minOccurs="1" maxOccurs="1" />
                <xs:element ref="endAttemptInteraction" minOccurs="1" maxOccurs="1" />
                <xs:element ref="customInteraction" minOccurs="1" maxOccurs="1" />
                <xs:element ref="drawingInteraction" minOccurs="1" maxOccurs="1" />
                <xs:element ref="gapMatchInteraction" minOccurs="1" maxOccurs="1" />
                <xs:element ref="matchInteraction" minOccurs="1" maxOccurs="1" />
                <xs:element ref="graphicGapMatchInteraction" minOccurs="1" maxOccurs="1" />
                <xs:element ref="hotspotInteraction" minOccurs="1" maxOccurs="1" />
                <xs:element ref="graphicOrderInteraction" minOccurs="1" maxOccurs="1" />
                <xs:element ref="selectPointInteraction" minOccurs="1" maxOccurs="1" />
                <xs:element ref="graphicAssociateInteraction" minOccurs="1" maxOccurs="1" />
                <xs:element ref="sliderInteraction" minOccurs="1" maxOccurs="1" />
                <xs:element ref="choiceInteraction" minOccurs="1" maxOccurs="1" />
                <xs:element ref="mediaInteraction" minOccurs="1" maxOccurs="1" />
                <xs:element ref="hottextInteraction" minOccurs="1" maxOccurs="1" />
                <xs:element ref="orderInteraction" minOccurs="1" maxOccurs="1" />
                <xs:element ref="extendedTextInteraction" minOccurs="1" maxOccurs="1" />
                <xs:element ref="uploadInteraction" minOccurs="1" maxOccurs="1" />
                <xs:element ref="associateInteraction" minOccurs="1" maxOccurs="1" />
                <xs:choice minOccurs="1" maxOccurs="1">
                    <xs:element ref="pre" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="h1" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="h2" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="h3" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="h4" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="h5" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="h6" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="p" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="address" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="dl" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="ol" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="ul" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="br" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="hr" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="img" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="object" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="blockquote" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="em" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="a" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="code" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="span" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="sub" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="acronym" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="big" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="tt" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="kbd" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="q" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="i" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="dfn" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="abbr" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="strong" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="sup" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="var" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="small" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="samp" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="b" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="cite" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="table" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="div" minOccurs="1" maxOccurs="1" />
                </xs:choice>
            </xs:choice>
        </xs:sequence>
        <xs:attributeGroup ref="id.LI.Attr" />
        <xs:attributeGroup ref="class.LI.Attr" />
        <xs:attributeGroup ref="xmllang.LI.Attr" />
        <xs:attributeGroup ref="label.LI.Attr" />
    </xs:complexType>

    <xs:complexType name="Logic0toMany.Type" abstract="false" mixed="false">
        <xs:annotation>
            <xs:documentation source="documentation">
                Provides the ability to use a multi variable operator e.g. an 'and' of the set of variabl-
                es.                                                                                       
            </xs:documentation>
        </xs:annotation>
        <xs:sequence>
            <xs:choice minOccurs="0" maxOccurs="unbounded">
                <xs:element ref="and" minOccurs="1" maxOccurs="1" />
                <xs:element ref="gt" minOccurs="1" maxOccurs="1" />
                <xs:element ref="not" minOccurs="1" maxOccurs="1" />
                <xs:element ref="lt" minOccurs="1" maxOccurs="1" />
                <xs:element ref="gte" minOccurs="1" maxOccurs="1" />
                <xs:element ref="lte" minOccurs="1" maxOccurs="1" />
                <xs:element ref="or" minOccurs="1" maxOccurs="1" />
                <xs:element ref="sum" minOccurs="1" maxOccurs="1" />
                <xs:element ref="durationLT" minOccurs="1" maxOccurs="1" />
                <xs:element ref="durationGTE" minOccurs="1" maxOccurs="1" />
                <xs:element ref="subtract" minOccurs="1" maxOccurs="1" />
                <xs:element ref="divide" minOccurs="1" maxOccurs="1" />
                <xs:element ref="multiple" minOccurs="1" maxOccurs="1" />
                <xs:element ref="ordered" minOccurs="1" maxOccurs="1" />
                <xs:element ref="customOperator" minOccurs="1" maxOccurs="1" />
                <xs:element ref="random" minOccurs="1" maxOccurs="1" />
                <xs:element ref="numberIncorrect" minOccurs="1" maxOccurs="1" />
                <xs:element ref="numberCorrect" minOccurs="1" maxOccurs="1" />
                <xs:element ref="numberPresented" minOccurs="1" maxOccurs="1" />
                <xs:element ref="numberResponded" minOccurs="1" maxOccurs="1" />
                <xs:element ref="numberSelected" minOccurs="1" maxOccurs="1" />
                <xs:element ref="substring" minOccurs="1" maxOccurs="1" />
                <xs:element ref="equalRounded" minOccurs="1" maxOccurs="1" />
                <xs:element ref="null" minOccurs="1" maxOccurs="1" />
                <xs:element ref="delete" minOccurs="1" maxOccurs="1" />
                <xs:element ref="match" minOccurs="1" maxOccurs="1" />
                <xs:element ref="index" minOccurs="1" maxOccurs="1" />
                <xs:element ref="power" minOccurs="1" maxOccurs="1" />
                <xs:element ref="equal" minOccurs="1" maxOccurs="1" />
                <xs:element ref="contains" minOccurs="1" maxOccurs="1" />
                <xs:element ref="containerSize" minOccurs="1" maxOccurs="1" />
                <xs:element ref="correct" minOccurs="1" maxOccurs="1" />
                <xs:element ref="default" minOccurs="1" maxOccurs="1" />
                <xs:element ref="anyN" minOccurs="1" maxOccurs="1" />
                <xs:element ref="integerDivide" minOccurs="1" maxOccurs="1" />
                <xs:element ref="integerModulus" minOccurs="1" maxOccurs="1" />
                <xs:element ref="isNull" minOccurs="1" maxOccurs="1" />
                <xs:element ref="member" minOccurs="1" maxOccurs="1" />
                <xs:element ref="product" minOccurs="1" maxOccurs="1" />
                <xs:element ref="round" minOccurs="1" maxOccurs="1" />
                <xs:element ref="truncate" minOccurs="1" maxOccurs="1" />
                <xs:element ref="fieldValue" minOccurs="1" maxOccurs="1" />
                <xs:element ref="randomInteger" minOccurs="1" maxOccurs="1" />
                <xs:element ref="randomFloat" minOccurs="1" maxOccurs="1" />
                <xs:element ref="variable" minOccurs="1" maxOccurs="1" />
                <xs:element ref="outcomeMinimum" minOccurs="1" maxOccurs="1" />
                <xs:element ref="outcomeMaximum" minOccurs="1" maxOccurs="1" />
                <xs:element ref="testVariables" minOccurs="1" maxOccurs="1" />
                <xs:element ref="integerToFloat" minOccurs="1" maxOccurs="1" />
                <xs:element ref="inside" minOccurs="1" maxOccurs="1" />
                <xs:element ref="baseValue" minOccurs="1" maxOccurs="1" />
                <xs:element ref="patternMatch" minOccurs="1" maxOccurs="1" />
                <xs:element ref="mapResponsePoint" minOccurs="1" maxOccurs="1" />
                <xs:element ref="mapResponse" minOccurs="1" maxOccurs="1" />
                <xs:element ref="stringMatch" minOccurs="1" maxOccurs="1" />
                <xs:element ref="repeat" minOccurs="1" maxOccurs="1" />
                <xs:element ref="roundTo" minOccurs="1" maxOccurs="1" />
                <xs:element ref="lcm" minOccurs="1" maxOccurs="1" />
                <xs:element ref="gcd" minOccurs="1" maxOccurs="1" />
                <xs:element ref="min" minOccurs="1" maxOccurs="1" />
                <xs:element ref="max" minOccurs="1" maxOccurs="1" />
                <xs:element ref="mathConstant" minOccurs="1" maxOccurs="1" />
                <xs:element ref="statsOperator" minOccurs="1" maxOccurs="1" />
                <xs:element ref="mathOperator" minOccurs="1" maxOccurs="1" />
            </xs:choice>
        </xs:sequence>
    </xs:complexType>

    <xs:complexType name="Logic1toMany.Type" abstract="false" mixed="false">
        <xs:annotation>
            <xs:documentation source="documentation">
                Provides the ability to use a multi variable operator e.g. an 'and' of the set of variabl-
                es.                                                                                       
            </xs:documentation>
        </xs:annotation>
        <xs:sequence>
            <xs:choice minOccurs="1" maxOccurs="unbounded">
                <xs:element ref="and" minOccurs="1" maxOccurs="1" />
                <xs:element ref="gt" minOccurs="1" maxOccurs="1" />
                <xs:element ref="not" minOccurs="1" maxOccurs="1" />
                <xs:element ref="lt" minOccurs="1" maxOccurs="1" />
                <xs:element ref="gte" minOccurs="1" maxOccurs="1" />
                <xs:element ref="lte" minOccurs="1" maxOccurs="1" />
                <xs:element ref="or" minOccurs="1" maxOccurs="1" />
                <xs:element ref="sum" minOccurs="1" maxOccurs="1" />
                <xs:element ref="durationLT" minOccurs="1" maxOccurs="1" />
                <xs:element ref="durationGTE" minOccurs="1" maxOccurs="1" />
                <xs:element ref="subtract" minOccurs="1" maxOccurs="1" />
                <xs:element ref="divide" minOccurs="1" maxOccurs="1" />
                <xs:element ref="multiple" minOccurs="1" maxOccurs="1" />
                <xs:element ref="ordered" minOccurs="1" maxOccurs="1" />
                <xs:element ref="customOperator" minOccurs="1" maxOccurs="1" />
                <xs:element ref="random" minOccurs="1" maxOccurs="1" />
                <xs:element ref="numberIncorrect" minOccurs="1" maxOccurs="1" />
                <xs:element ref="numberCorrect" minOccurs="1" maxOccurs="1" />
                <xs:element ref="numberPresented" minOccurs="1" maxOccurs="1" />
                <xs:element ref="numberResponded" minOccurs="1" maxOccurs="1" />
                <xs:element ref="numberSelected" minOccurs="1" maxOccurs="1" />
                <xs:element ref="substring" minOccurs="1" maxOccurs="1" />
                <xs:element ref="equalRounded" minOccurs="1" maxOccurs="1" />
                <xs:element ref="null" minOccurs="1" maxOccurs="1" />
                <xs:element ref="delete" minOccurs="1" maxOccurs="1" />
                <xs:element ref="match" minOccurs="1" maxOccurs="1" />
                <xs:element ref="index" minOccurs="1" maxOccurs="1" />
                <xs:element ref="power" minOccurs="1" maxOccurs="1" />
                <xs:element ref="equal" minOccurs="1" maxOccurs="1" />
                <xs:element ref="contains" minOccurs="1" maxOccurs="1" />
                <xs:element ref="containerSize" minOccurs="1" maxOccurs="1" />
                <xs:element ref="correct" minOccurs="1" maxOccurs="1" />
                <xs:element ref="default" minOccurs="1" maxOccurs="1" />
                <xs:element ref="anyN" minOccurs="1" maxOccurs="1" />
                <xs:element ref="integerDivide" minOccurs="1" maxOccurs="1" />
                <xs:element ref="integerModulus" minOccurs="1" maxOccurs="1" />
                <xs:element ref="isNull" minOccurs="1" maxOccurs="1" />
                <xs:element ref="member" minOccurs="1" maxOccurs="1" />
                <xs:element ref="product" minOccurs="1" maxOccurs="1" />
                <xs:element ref="round" minOccurs="1" maxOccurs="1" />
                <xs:element ref="truncate" minOccurs="1" maxOccurs="1" />
                <xs:element ref="fieldValue" minOccurs="1" maxOccurs="1" />
                <xs:element ref="randomInteger" minOccurs="1" maxOccurs="1" />
                <xs:element ref="randomFloat" minOccurs="1" maxOccurs="1" />
                <xs:element ref="variable" minOccurs="1" maxOccurs="1" />
                <xs:element ref="outcomeMinimum" minOccurs="1" maxOccurs="1" />
                <xs:element ref="outcomeMaximum" minOccurs="1" maxOccurs="1" />
                <xs:element ref="testVariables" minOccurs="1" maxOccurs="1" />
                <xs:element ref="integerToFloat" minOccurs="1" maxOccurs="1" />
                <xs:element ref="inside" minOccurs="1" maxOccurs="1" />
                <xs:element ref="baseValue" minOccurs="1" maxOccurs="1" />
                <xs:element ref="patternMatch" minOccurs="1" maxOccurs="1" />
                <xs:element ref="mapResponsePoint" minOccurs="1" maxOccurs="1" />
                <xs:element ref="mapResponse" minOccurs="1" maxOccurs="1" />
                <xs:element ref="stringMatch" minOccurs="1" maxOccurs="1" />
                <xs:element ref="repeat" minOccurs="1" maxOccurs="1" />
                <xs:element ref="roundTo" minOccurs="1" maxOccurs="1" />
                <xs:element ref="lcm" minOccurs="1" maxOccurs="1" />
                <xs:element ref="gcd" minOccurs="1" maxOccurs="1" />
                <xs:element ref="min" minOccurs="1" maxOccurs="1" />
                <xs:element ref="max" minOccurs="1" maxOccurs="1" />
                <xs:element ref="mathConstant" minOccurs="1" maxOccurs="1" />
                <xs:element ref="statsOperator" minOccurs="1" maxOccurs="1" />
                <xs:element ref="mathOperator" minOccurs="1" maxOccurs="1" />
            </xs:choice>
        </xs:sequence>
    </xs:complexType>

    <xs:complexType name="LogicPair.Type" abstract="false" mixed="false">
        <xs:annotation>
            <xs:documentation source="documentation">
                Provides the ability to use a two variable operator e.g. greater than.                    
            </xs:documentation>
        </xs:annotation>
        <xs:sequence>
            <xs:choice minOccurs="2" maxOccurs="2">
                <xs:element ref="and" minOccurs="1" maxOccurs="1" />
                <xs:element ref="gt" minOccurs="1" maxOccurs="1" />
                <xs:element ref="not" minOccurs="1" maxOccurs="1" />
                <xs:element ref="lt" minOccurs="1" maxOccurs="1" />
                <xs:element ref="gte" minOccurs="1" maxOccurs="1" />
                <xs:element ref="lte" minOccurs="1" maxOccurs="1" />
                <xs:element ref="or" minOccurs="1" maxOccurs="1" />
                <xs:element ref="sum" minOccurs="1" maxOccurs="1" />
                <xs:element ref="durationLT" minOccurs="1" maxOccurs="1" />
                <xs:element ref="durationGTE" minOccurs="1" maxOccurs="1" />
                <xs:element ref="subtract" minOccurs="1" maxOccurs="1" />
                <xs:element ref="divide" minOccurs="1" maxOccurs="1" />
                <xs:element ref="multiple" minOccurs="1" maxOccurs="1" />
                <xs:element ref="ordered" minOccurs="1" maxOccurs="1" />
                <xs:element ref="customOperator" minOccurs="1" maxOccurs="1" />
                <xs:element ref="random" minOccurs="1" maxOccurs="1" />
                <xs:element ref="numberIncorrect" minOccurs="1" maxOccurs="1" />
                <xs:element ref="numberCorrect" minOccurs="1" maxOccurs="1" />
                <xs:element ref="numberPresented" minOccurs="1" maxOccurs="1" />
                <xs:element ref="numberResponded" minOccurs="1" maxOccurs="1" />
                <xs:element ref="numberSelected" minOccurs="1" maxOccurs="1" />
                <xs:element ref="substring" minOccurs="1" maxOccurs="1" />
                <xs:element ref="equalRounded" minOccurs="1" maxOccurs="1" />
                <xs:element ref="null" minOccurs="1" maxOccurs="1" />
                <xs:element ref="delete" minOccurs="1" maxOccurs="1" />
                <xs:element ref="match" minOccurs="1" maxOccurs="1" />
                <xs:element ref="index" minOccurs="1" maxOccurs="1" />
                <xs:element ref="power" minOccurs="1" maxOccurs="1" />
                <xs:element ref="equal" minOccurs="1" maxOccurs="1" />
                <xs:element ref="contains" minOccurs="1" maxOccurs="1" />
                <xs:element ref="containerSize" minOccurs="1" maxOccurs="1" />
                <xs:element ref="correct" minOccurs="1" maxOccurs="1" />
                <xs:element ref="default" minOccurs="1" maxOccurs="1" />
                <xs:element ref="anyN" minOccurs="1" maxOccurs="1" />
                <xs:element ref="integerDivide" minOccurs="1" maxOccurs="1" />
                <xs:element ref="integerModulus" minOccurs="1" maxOccurs="1" />
                <xs:element ref="isNull" minOccurs="1" maxOccurs="1" />
                <xs:element ref="member" minOccurs="1" maxOccurs="1" />
                <xs:element ref="product" minOccurs="1" maxOccurs="1" />
                <xs:element ref="round" minOccurs="1" maxOccurs="1" />
                <xs:element ref="truncate" minOccurs="1" maxOccurs="1" />
                <xs:element ref="fieldValue" minOccurs="1" maxOccurs="1" />
                <xs:element ref="randomInteger" minOccurs="1" maxOccurs="1" />
                <xs:element ref="randomFloat" minOccurs="1" maxOccurs="1" />
                <xs:element ref="variable" minOccurs="1" maxOccurs="1" />
                <xs:element ref="outcomeMinimum" minOccurs="1" maxOccurs="1" />
                <xs:element ref="outcomeMaximum" minOccurs="1" maxOccurs="1" />
                <xs:element ref="testVariables" minOccurs="1" maxOccurs="1" />
                <xs:element ref="integerToFloat" minOccurs="1" maxOccurs="1" />
                <xs:element ref="inside" minOccurs="1" maxOccurs="1" />
                <xs:element ref="baseValue" minOccurs="1" maxOccurs="1" />
                <xs:element ref="patternMatch" minOccurs="1" maxOccurs="1" />
                <xs:element ref="mapResponsePoint" minOccurs="1" maxOccurs="1" />
                <xs:element ref="mapResponse" minOccurs="1" maxOccurs="1" />
                <xs:element ref="stringMatch" minOccurs="1" maxOccurs="1" />
                <xs:element ref="repeat" minOccurs="1" maxOccurs="1" />
                <xs:element ref="roundTo" minOccurs="1" maxOccurs="1" />
                <xs:element ref="lcm" minOccurs="1" maxOccurs="1" />
                <xs:element ref="gcd" minOccurs="1" maxOccurs="1" />
                <xs:element ref="min" minOccurs="1" maxOccurs="1" />
                <xs:element ref="max" minOccurs="1" maxOccurs="1" />
                <xs:element ref="mathConstant" minOccurs="1" maxOccurs="1" />
                <xs:element ref="statsOperator" minOccurs="1" maxOccurs="1" />
                <xs:element ref="mathOperator" minOccurs="1" maxOccurs="1" />
            </xs:choice>
        </xs:sequence>
    </xs:complexType>

    <xs:complexType name="LogicSingle.Type" abstract="false" mixed="false">
        <xs:annotation>
            <xs:documentation source="documentation">
                Provides the ability to use a single variable operator e.g. a 'not'.                      
            </xs:documentation>
        </xs:annotation>
        <xs:sequence>
            <xs:choice minOccurs="1" maxOccurs="1">
                <xs:element ref="and" minOccurs="1" maxOccurs="1" />
                <xs:element ref="gt" minOccurs="1" maxOccurs="1" />
                <xs:element ref="not" minOccurs="1" maxOccurs="1" />
                <xs:element ref="lt" minOccurs="1" maxOccurs="1" />
                <xs:element ref="gte" minOccurs="1" maxOccurs="1" />
                <xs:element ref="lte" minOccurs="1" maxOccurs="1" />
                <xs:element ref="or" minOccurs="1" maxOccurs="1" />
                <xs:element ref="sum" minOccurs="1" maxOccurs="1" />
                <xs:element ref="durationLT" minOccurs="1" maxOccurs="1" />
                <xs:element ref="durationGTE" minOccurs="1" maxOccurs="1" />
                <xs:element ref="subtract" minOccurs="1" maxOccurs="1" />
                <xs:element ref="divide" minOccurs="1" maxOccurs="1" />
                <xs:element ref="multiple" minOccurs="1" maxOccurs="1" />
                <xs:element ref="ordered" minOccurs="1" maxOccurs="1" />
                <xs:element ref="customOperator" minOccurs="1" maxOccurs="1" />
                <xs:element ref="random" minOccurs="1" maxOccurs="1" />
                <xs:element ref="numberIncorrect" minOccurs="1" maxOccurs="1" />
                <xs:element ref="numberCorrect" minOccurs="1" maxOccurs="1" />
                <xs:element ref="numberPresented" minOccurs="1" maxOccurs="1" />
                <xs:element ref="numberResponded" minOccurs="1" maxOccurs="1" />
                <xs:element ref="numberSelected" minOccurs="1" maxOccurs="1" />
                <xs:element ref="substring" minOccurs="1" maxOccurs="1" />
                <xs:element ref="equalRounded" minOccurs="1" maxOccurs="1" />
                <xs:element ref="null" minOccurs="1" maxOccurs="1" />
                <xs:element ref="delete" minOccurs="1" maxOccurs="1" />
                <xs:element ref="match" minOccurs="1" maxOccurs="1" />
                <xs:element ref="index" minOccurs="1" maxOccurs="1" />
                <xs:element ref="power" minOccurs="1" maxOccurs="1" />
                <xs:element ref="equal" minOccurs="1" maxOccurs="1" />
                <xs:element ref="contains" minOccurs="1" maxOccurs="1" />
                <xs:element ref="containerSize" minOccurs="1" maxOccurs="1" />
                <xs:element ref="correct" minOccurs="1" maxOccurs="1" />
                <xs:element ref="default" minOccurs="1" maxOccurs="1" />
                <xs:element ref="anyN" minOccurs="1" maxOccurs="1" />
                <xs:element ref="integerDivide" minOccurs="1" maxOccurs="1" />
                <xs:element ref="integerModulus" minOccurs="1" maxOccurs="1" />
                <xs:element ref="isNull" minOccurs="1" maxOccurs="1" />
                <xs:element ref="member" minOccurs="1" maxOccurs="1" />
                <xs:element ref="product" minOccurs="1" maxOccurs="1" />
                <xs:element ref="round" minOccurs="1" maxOccurs="1" />
                <xs:element ref="truncate" minOccurs="1" maxOccurs="1" />
                <xs:element ref="fieldValue" minOccurs="1" maxOccurs="1" />
                <xs:element ref="randomInteger" minOccurs="1" maxOccurs="1" />
                <xs:element ref="randomFloat" minOccurs="1" maxOccurs="1" />
                <xs:element ref="variable" minOccurs="1" maxOccurs="1" />
                <xs:element ref="outcomeMinimum" minOccurs="1" maxOccurs="1" />
                <xs:element ref="outcomeMaximum" minOccurs="1" maxOccurs="1" />
                <xs:element ref="testVariables" minOccurs="1" maxOccurs="1" />
                <xs:element ref="integerToFloat" minOccurs="1" maxOccurs="1" />
                <xs:element ref="inside" minOccurs="1" maxOccurs="1" />
                <xs:element ref="baseValue" minOccurs="1" maxOccurs="1" />
                <xs:element ref="patternMatch" minOccurs="1" maxOccurs="1" />
                <xs:element ref="mapResponsePoint" minOccurs="1" maxOccurs="1" />
                <xs:element ref="mapResponse" minOccurs="1" maxOccurs="1" />
                <xs:element ref="stringMatch" minOccurs="1" maxOccurs="1" />
                <xs:element ref="repeat" minOccurs="1" maxOccurs="1" />
                <xs:element ref="roundTo" minOccurs="1" maxOccurs="1" />
                <xs:element ref="lcm" minOccurs="1" maxOccurs="1" />
                <xs:element ref="gcd" minOccurs="1" maxOccurs="1" />
                <xs:element ref="min" minOccurs="1" maxOccurs="1" />
                <xs:element ref="max" minOccurs="1" maxOccurs="1" />
                <xs:element ref="mathConstant" minOccurs="1" maxOccurs="1" />
                <xs:element ref="statsOperator" minOccurs="1" maxOccurs="1" />
                <xs:element ref="mathOperator" minOccurs="1" maxOccurs="1" />
            </xs:choice>
        </xs:sequence>
    </xs:complexType>

    <xs:complexType name="LookupOutcomeValue.Type" abstract="false" mixed="false">
        <xs:annotation>
            <xs:documentation source="documentation">
                The LookupOutcomeValue complexType is the container for look-up mapping values to outcome 
                variables. The lookupOutcomeValue rule sets the value of an outcome variable to the value 
                obtained by looking up the value of the associated expression in the lookupTable associat-
                ed with the outcome's declaration.                                                        
            </xs:documentation>
        </xs:annotation>
        <xs:sequence>
            <xs:choice minOccurs="1" maxOccurs="1">
                <xs:element ref="and" minOccurs="1" maxOccurs="1" />
                <xs:element ref="gt" minOccurs="1" maxOccurs="1" />
                <xs:element ref="not" minOccurs="1" maxOccurs="1" />
                <xs:element ref="lt" minOccurs="1" maxOccurs="1" />
                <xs:element ref="gte" minOccurs="1" maxOccurs="1" />
                <xs:element ref="lte" minOccurs="1" maxOccurs="1" />
                <xs:element ref="or" minOccurs="1" maxOccurs="1" />
                <xs:element ref="sum" minOccurs="1" maxOccurs="1" />
                <xs:element ref="durationLT" minOccurs="1" maxOccurs="1" />
                <xs:element ref="durationGTE" minOccurs="1" maxOccurs="1" />
                <xs:element ref="subtract" minOccurs="1" maxOccurs="1" />
                <xs:element ref="divide" minOccurs="1" maxOccurs="1" />
                <xs:element ref="multiple" minOccurs="1" maxOccurs="1" />
                <xs:element ref="ordered" minOccurs="1" maxOccurs="1" />
                <xs:element ref="customOperator" minOccurs="1" maxOccurs="1" />
                <xs:element ref="random" minOccurs="1" maxOccurs="1" />
                <xs:element ref="numberIncorrect" minOccurs="1" maxOccurs="1" />
                <xs:element ref="numberCorrect" minOccurs="1" maxOccurs="1" />
                <xs:element ref="numberPresented" minOccurs="1" maxOccurs="1" />
                <xs:element ref="numberResponded" minOccurs="1" maxOccurs="1" />
                <xs:element ref="numberSelected" minOccurs="1" maxOccurs="1" />
                <xs:element ref="substring" minOccurs="1" maxOccurs="1" />
                <xs:element ref="equalRounded" minOccurs="1" maxOccurs="1" />
                <xs:element ref="null" minOccurs="1" maxOccurs="1" />
                <xs:element ref="delete" minOccurs="1" maxOccurs="1" />
                <xs:element ref="match" minOccurs="1" maxOccurs="1" />
                <xs:element ref="index" minOccurs="1" maxOccurs="1" />
                <xs:element ref="power" minOccurs="1" maxOccurs="1" />
                <xs:element ref="equal" minOccurs="1" maxOccurs="1" />
                <xs:element ref="contains" minOccurs="1" maxOccurs="1" />
                <xs:element ref="containerSize" minOccurs="1" maxOccurs="1" />
                <xs:element ref="correct" minOccurs="1" maxOccurs="1" />
                <xs:element ref="default" minOccurs="1" maxOccurs="1" />
                <xs:element ref="anyN" minOccurs="1" maxOccurs="1" />
                <xs:element ref="integerDivide" minOccurs="1" maxOccurs="1" />
                <xs:element ref="integerModulus" minOccurs="1" maxOccurs="1" />
                <xs:element ref="isNull" minOccurs="1" maxOccurs="1" />
                <xs:element ref="member" minOccurs="1" maxOccurs="1" />
                <xs:element ref="product" minOccurs="1" maxOccurs="1" />
                <xs:element ref="round" minOccurs="1" maxOccurs="1" />
                <xs:element ref="truncate" minOccurs="1" maxOccurs="1" />
                <xs:element ref="fieldValue" minOccurs="1" maxOccurs="1" />
                <xs:element ref="randomInteger" minOccurs="1" maxOccurs="1" />
                <xs:element ref="randomFloat" minOccurs="1" maxOccurs="1" />
                <xs:element ref="variable" minOccurs="1" maxOccurs="1" />
                <xs:element ref="outcomeMinimum" minOccurs="1" maxOccurs="1" />
                <xs:element ref="outcomeMaximum" minOccurs="1" maxOccurs="1" />
                <xs:element ref="testVariables" minOccurs="1" maxOccurs="1" />
                <xs:element ref="integerToFloat" minOccurs="1" maxOccurs="1" />
                <xs:element ref="inside" minOccurs="1" maxOccurs="1" />
                <xs:element ref="baseValue" minOccurs="1" maxOccurs="1" />
                <xs:element ref="patternMatch" minOccurs="1" maxOccurs="1" />
                <xs:element ref="mapResponsePoint" minOccurs="1" maxOccurs="1" />
                <xs:element ref="mapResponse" minOccurs="1" maxOccurs="1" />
                <xs:element ref="stringMatch" minOccurs="1" maxOccurs="1" />
                <xs:element ref="repeat" minOccurs="1" maxOccurs="1" />
                <xs:element ref="roundTo" minOccurs="1" maxOccurs="1" />
                <xs:element ref="lcm" minOccurs="1" maxOccurs="1" />
                <xs:element ref="gcd" minOccurs="1" maxOccurs="1" />
                <xs:element ref="min" minOccurs="1" maxOccurs="1" />
                <xs:element ref="max" minOccurs="1" maxOccurs="1" />
                <xs:element ref="mathConstant" minOccurs="1" maxOccurs="1" />
                <xs:element ref="statsOperator" minOccurs="1" maxOccurs="1" />
                <xs:element ref="mathOperator" minOccurs="1" maxOccurs="1" />
            </xs:choice>
        </xs:sequence>
        <xs:attributeGroup ref="identifier.LookupOutcomeValue.Attr" />
    </xs:complexType>

    <xs:complexType name="Mapping.Type" abstract="false" mixed="false">
        <xs:annotation>
            <xs:documentation source="documentation">
                A special class used to create a mapping from a source set of any baseType (except file a-
                nd duration) to a single float. Note that mappings from values of base type float should  
                be avoided due to the difficulty of matching floating point values, see the match operator
                for more details. When mapping containers the result is the sum of the mapped values from 
                the target set. See mapResponse for details.                                              
            </xs:documentation>
        </xs:annotation>
        <xs:sequence>
            <xs:element ref="mapEntry" minOccurs="1" maxOccurs="unbounded" />
        </xs:sequence>
        <xs:attributeGroup ref="lowerBound.Mapping.Attr" />
        <xs:attributeGroup ref="upperBound.Mapping.Attr" />
        <xs:attributeGroup ref="defaultValue.Mapping.Attr" />
    </xs:complexType>

    <xs:complexType name="MatchInteraction.Type" abstract="false" mixed="false">
        <xs:annotation>
            <xs:documentation source="documentation">
                The MatchInteraction complexType is the container for information about a match interacti-
                on. A match interaction is a blockInteraction that presents candidates with two sets of c-
                hoices and allows them to create associates between pairs of choices in the two sets, but 
                not between pairs of choices in the same set. Further restrictions can still be placed on 
                the allowable associations using the matchMax and matchGroup attributes of the choices. T-
                he matchInteraction must be bound to a response variable with base-type directedPair and  
                either single or multiple cardinality.                                                    
            </xs:documentation>
        </xs:annotation>
        <xs:sequence>
            <xs:element ref="prompt" minOccurs="0" maxOccurs="1" />
            <xs:element ref="simpleMatchSet" minOccurs="2" maxOccurs="2" />
        </xs:sequence>
        <xs:attributeGroup ref="xmlbase.MatchInteraction.Attr" />
        <xs:attributeGroup ref="id.MatchInteraction.Attr" />
        <xs:attributeGroup ref="class.MatchInteraction.Attr" />
        <xs:attributeGroup ref="xmllang.MatchInteraction.Attr" />
        <xs:attributeGroup ref="label.MatchInteraction.Attr" />
        <xs:attributeGroup ref="responseIdentifier.MatchInteraction.Attr" />
        <xs:attributeGroup ref="shuffle.MatchInteraction.Attr" />
        <xs:attributeGroup ref="maxAssociations.MatchInteraction.Attr" />
        <xs:attributeGroup ref="minAssociations.MatchInteraction.Attr" />
    </xs:complexType>

    <xs:complexType name="MatchTable.Type" abstract="false" mixed="false">
        <xs:annotation>
            <xs:documentation source="documentation">
                The MatchTable complexType is the container source mapping. A matchTable transforms a sou-
                rce integer by finding the first matchTableEntry with an exact match to the source.       
            </xs:documentation>
        </xs:annotation>
        <xs:sequence>
            <xs:element ref="matchTableEntry" minOccurs="1" maxOccurs="unbounded" />
        </xs:sequence>
        <xs:attributeGroup ref="defaultValue.MatchTable.Attr" />
    </xs:complexType>

    <xs:complexType name="MathOperator.Type" abstract="false" mixed="false">
        <xs:annotation>
            <xs:documentation source="documentation">
                The mathOperator operator takes 1 or more sub-expressions which all have single cardinali-
                ty and have numerical base-types. The trigonometric functions, sin, cos and tan, take one 
                argument in radians, which evaluates to a single float. Other functions take one numerical
                argument. Further functions might take more than one numerical argument, e.g. atan2 (two  
                argument arc tan). The result is a single float, except for the functions signum, floor a-
                nd ceil, which return a single integer. If any of the sub-expressions is NULL, the result 
                is NULL. If any of the sub-expressions falls outside the natural domain of the function c-
                alled by mathOperator, e.g. log(0) or asin(2), then the result is NULL.                   
            </xs:documentation>
        </xs:annotation>
        <xs:sequence>
            <xs:choice minOccurs="1" maxOccurs="unbounded">
                <xs:element ref="and" minOccurs="1" maxOccurs="1" />
                <xs:element ref="gt" minOccurs="1" maxOccurs="1" />
                <xs:element ref="not" minOccurs="1" maxOccurs="1" />
                <xs:element ref="lt" minOccurs="1" maxOccurs="1" />
                <xs:element ref="gte" minOccurs="1" maxOccurs="1" />
                <xs:element ref="lte" minOccurs="1" maxOccurs="1" />
                <xs:element ref="or" minOccurs="1" maxOccurs="1" />
                <xs:element ref="sum" minOccurs="1" maxOccurs="1" />
                <xs:element ref="durationLT" minOccurs="1" maxOccurs="1" />
                <xs:element ref="durationGTE" minOccurs="1" maxOccurs="1" />
                <xs:element ref="subtract" minOccurs="1" maxOccurs="1" />
                <xs:element ref="divide" minOccurs="1" maxOccurs="1" />
                <xs:element ref="multiple" minOccurs="1" maxOccurs="1" />
                <xs:element ref="ordered" minOccurs="1" maxOccurs="1" />
                <xs:element ref="customOperator" minOccurs="1" maxOccurs="1" />
                <xs:element ref="random" minOccurs="1" maxOccurs="1" />
                <xs:element ref="numberIncorrect" minOccurs="1" maxOccurs="1" />
                <xs:element ref="numberCorrect" minOccurs="1" maxOccurs="1" />
                <xs:element ref="numberPresented" minOccurs="1" maxOccurs="1" />
                <xs:element ref="numberResponded" minOccurs="1" maxOccurs="1" />
                <xs:element ref="numberSelected" minOccurs="1" maxOccurs="1" />
                <xs:element ref="substring" minOccurs="1" maxOccurs="1" />
                <xs:element ref="equalRounded" minOccurs="1" maxOccurs="1" />
                <xs:element ref="null" minOccurs="1" maxOccurs="1" />
                <xs:element ref="delete" minOccurs="1" maxOccurs="1" />
                <xs:element ref="match" minOccurs="1" maxOccurs="1" />
                <xs:element ref="index" minOccurs="1" maxOccurs="1" />
                <xs:element ref="power" minOccurs="1" maxOccurs="1" />
                <xs:element ref="equal" minOccurs="1" maxOccurs="1" />
                <xs:element ref="contains" minOccurs="1" maxOccurs="1" />
                <xs:element ref="containerSize" minOccurs="1" maxOccurs="1" />
                <xs:element ref="correct" minOccurs="1" maxOccurs="1" />
                <xs:element ref="default" minOccurs="1" maxOccurs="1" />
                <xs:element ref="anyN" minOccurs="1" maxOccurs="1" />
                <xs:element ref="integerDivide" minOccurs="1" maxOccurs="1" />
                <xs:element ref="integerModulus" minOccurs="1" maxOccurs="1" />
                <xs:element ref="isNull" minOccurs="1" maxOccurs="1" />
                <xs:element ref="member" minOccurs="1" maxOccurs="1" />
                <xs:element ref="product" minOccurs="1" maxOccurs="1" />
                <xs:element ref="round" minOccurs="1" maxOccurs="1" />
                <xs:element ref="truncate" minOccurs="1" maxOccurs="1" />
                <xs:element ref="fieldValue" minOccurs="1" maxOccurs="1" />
                <xs:element ref="randomInteger" minOccurs="1" maxOccurs="1" />
                <xs:element ref="randomFloat" minOccurs="1" maxOccurs="1" />
                <xs:element ref="variable" minOccurs="1" maxOccurs="1" />
                <xs:element ref="outcomeMinimum" minOccurs="1" maxOccurs="1" />
                <xs:element ref="outcomeMaximum" minOccurs="1" maxOccurs="1" />
                <xs:element ref="testVariables" minOccurs="1" maxOccurs="1" />
                <xs:element ref="integerToFloat" minOccurs="1" maxOccurs="1" />
                <xs:element ref="inside" minOccurs="1" maxOccurs="1" />
                <xs:element ref="baseValue" minOccurs="1" maxOccurs="1" />
                <xs:element ref="patternMatch" minOccurs="1" maxOccurs="1" />
                <xs:element ref="mapResponsePoint" minOccurs="1" maxOccurs="1" />
                <xs:element ref="mapResponse" minOccurs="1" maxOccurs="1" />
                <xs:element ref="stringMatch" minOccurs="1" maxOccurs="1" />
                <xs:element ref="repeat" minOccurs="1" maxOccurs="1" />
                <xs:element ref="roundTo" minOccurs="1" maxOccurs="1" />
                <xs:element ref="lcm" minOccurs="1" maxOccurs="1" />
                <xs:element ref="gcd" minOccurs="1" maxOccurs="1" />
                <xs:element ref="min" minOccurs="1" maxOccurs="1" />
                <xs:element ref="max" minOccurs="1" maxOccurs="1" />
                <xs:element ref="mathConstant" minOccurs="1" maxOccurs="1" />
                <xs:element ref="statsOperator" minOccurs="1" maxOccurs="1" />
                <xs:element ref="mathOperator" minOccurs="1" maxOccurs="1" />
            </xs:choice>
        </xs:sequence>
        <xs:attributeGroup ref="name.MathOperator.Attr" />
    </xs:complexType>

    <xs:complexType name="MediaInteraction.Type" abstract="false" mixed="false">
        <xs:annotation>
            <xs:documentation source="documentation">
                The MediaInteraction complexType is the container for the media interaction information.  
                The media interaction allows more control over the way the candidate interacts with a tim-
                e-based media object and allows the number of times the media object was experienced to be
                reported in the value of the associated response variable, which must be of base-type int-
                eger and single cardinality.                                                              
            </xs:documentation>
        </xs:annotation>
        <xs:sequence>
            <xs:element ref="prompt" minOccurs="0" maxOccurs="1" />
            <xs:element ref="object" minOccurs="1" maxOccurs="1" />
        </xs:sequence>
        <xs:attributeGroup ref="xmlbase.MediaInteraction.Attr" />
        <xs:attributeGroup ref="id.MediaInteraction.Attr" />
        <xs:attributeGroup ref="class.MediaInteraction.Attr" />
        <xs:attributeGroup ref="xmllang.MediaInteraction.Attr" />
        <xs:attributeGroup ref="label.MediaInteraction.Attr" />
        <xs:attributeGroup ref="responseIdentifier.MediaInteraction.Attr" />
        <xs:attributeGroup ref="autostart.MediaInteraction.Attr" />
        <xs:attributeGroup ref="minPlays.MediaInteraction.Attr" />
        <xs:attributeGroup ref="maxPlays.MediaInteraction.Attr" />
        <xs:attributeGroup ref="loop.MediaInteraction.Attr" />
    </xs:complexType>

    <xs:complexType name="ModalFeedback.Type" abstract="false" mixed="true">
        <xs:annotation>
            <xs:documentation source="documentation">
                The ModalFeedback complexType is the container for the item feedback to be presented to t-
                he candidate. Modal feedback is shown to the candidate directly following response proces-
                sing. The value of an outcome variable is used in conjunction with the showHide and ident-
                ifier attributes to determine whether or not the feedback is shown.                       
            </xs:documentation>
        </xs:annotation>
        <xs:sequence>
            <xs:choice minOccurs="0" maxOccurs="unbounded">
                <xs:element ref="printedVariable" minOccurs="1" maxOccurs="1" />
                <xs:element ref="hottext" minOccurs="1" maxOccurs="1" />
                <xs:element name="templateInline" type="TemplateInline.Type" minOccurs="1" maxOccurs="1"/>
                <xs:element name="templateBlock" type="TemplateBlock.Type" minOccurs="1" maxOccurs="1"/>
                <xs:element ref="m:math" minOccurs="1" maxOccurs="1" />
                <xs:element ref="xi:include" minOccurs="1" maxOccurs="1" />
                <xs:choice minOccurs="1" maxOccurs="1">
                    <xs:element ref="pre" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="h1" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="h2" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="h3" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="h4" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="h5" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="h6" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="p" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="address" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="dl" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="ol" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="ul" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="br" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="hr" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="img" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="object" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="blockquote" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="em" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="a" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="code" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="span" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="sub" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="acronym" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="big" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="tt" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="kbd" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="q" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="i" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="dfn" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="abbr" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="strong" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="sup" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="var" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="small" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="samp" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="b" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="cite" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="table" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="div" minOccurs="1" maxOccurs="1" />
                </xs:choice>
            </xs:choice>
            <xs:element ref="stylesheet" minOccurs="0" maxOccurs="unbounded" />
            <xs:element ref="apip:apipAccessibility" minOccurs="0" maxOccurs="1" />
        </xs:sequence>
        <xs:attributeGroup ref="outcomeIdentifier.ModalFeedback.Attr" />
        <xs:attributeGroup ref="showHide.ModalFeedback.Attr" />
        <xs:attributeGroup ref="identifier.ModalFeedback.Attr" />
        <xs:attributeGroup ref="title.ModalFeedback.Attr" />
    </xs:complexType>

    <xs:complexType name="NumericLogic1toMany.Type" abstract="false" mixed="false">
        <xs:annotation>
            <xs:documentation source="documentation">
                Provides the ability to use a multi variable numeric-based operator e.g. a 'sum' of the s-
                et of variables.                                                                          
            </xs:documentation>
        </xs:annotation>
        <xs:sequence>
            <xs:choice minOccurs="1" maxOccurs="unbounded">
                <xs:element ref="sum" minOccurs="1" maxOccurs="1" />
                <xs:element ref="subtract" minOccurs="1" maxOccurs="1" />
                <xs:element ref="divide" minOccurs="1" maxOccurs="1" />
                <xs:element ref="multiple" minOccurs="1" maxOccurs="1" />
                <xs:element ref="ordered" minOccurs="1" maxOccurs="1" />
                <xs:element ref="customOperator" minOccurs="1" maxOccurs="1" />
                <xs:element ref="random" minOccurs="1" maxOccurs="1" />
                <xs:element ref="numberIncorrect" minOccurs="1" maxOccurs="1" />
                <xs:element ref="numberCorrect" minOccurs="1" maxOccurs="1" />
                <xs:element ref="numberPresented" minOccurs="1" maxOccurs="1" />
                <xs:element ref="numberResponded" minOccurs="1" maxOccurs="1" />
                <xs:element ref="numberSelected" minOccurs="1" maxOccurs="1" />
                <xs:element ref="null" minOccurs="1" maxOccurs="1" />
                <xs:element ref="delete" minOccurs="1" maxOccurs="1" />
                <xs:element ref="index" minOccurs="1" maxOccurs="1" />
                <xs:element ref="power" minOccurs="1" maxOccurs="1" />
                <xs:element ref="containerSize" minOccurs="1" maxOccurs="1" />
                <xs:element ref="correct" minOccurs="1" maxOccurs="1" />
                <xs:element ref="default" minOccurs="1" maxOccurs="1" />
                <xs:element ref="integerDivide" minOccurs="1" maxOccurs="1" />
                <xs:element ref="integerModulus" minOccurs="1" maxOccurs="1" />
                <xs:element ref="product" minOccurs="1" maxOccurs="1" />
                <xs:element ref="round" minOccurs="1" maxOccurs="1" />
                <xs:element ref="truncate" minOccurs="1" maxOccurs="1" />
                <xs:element ref="fieldValue" minOccurs="1" maxOccurs="1" />
                <xs:element ref="randomInteger" minOccurs="1" maxOccurs="1" />
                <xs:element ref="randomFloat" minOccurs="1" maxOccurs="1" />
                <xs:element ref="variable" minOccurs="1" maxOccurs="1" />
                <xs:element ref="outcomeMinimum" minOccurs="1" maxOccurs="1" />
                <xs:element ref="outcomeMaximum" minOccurs="1" maxOccurs="1" />
                <xs:element ref="testVariables" minOccurs="1" maxOccurs="1" />
                <xs:element ref="integerToFloat" minOccurs="1" maxOccurs="1" />
                <xs:element ref="baseValue" minOccurs="1" maxOccurs="1" />
                <xs:element ref="mapResponsePoint" minOccurs="1" maxOccurs="1" />
                <xs:element ref="mapResponse" minOccurs="1" maxOccurs="1" />
                <xs:element ref="repeat" minOccurs="1" maxOccurs="1" />
                <xs:element ref="roundTo" minOccurs="1" maxOccurs="1" />
                <xs:element ref="lcm" minOccurs="1" maxOccurs="1" />
                <xs:element ref="gcd" minOccurs="1" maxOccurs="1" />
                <xs:element ref="min" minOccurs="1" maxOccurs="1" />
                <xs:element ref="max" minOccurs="1" maxOccurs="1" />
                <xs:element ref="mathConstant" minOccurs="1" maxOccurs="1" />
                <xs:element ref="statsOperator" minOccurs="1" maxOccurs="1" />
                <xs:element ref="mathOperator" minOccurs="1" maxOccurs="1" />
            </xs:choice>
        </xs:sequence>
    </xs:complexType>

    <xs:complexType name="Object.Type" abstract="false" mixed="true">
        <xs:annotation>
            <xs:documentation source="documentation">
                The Object complexType is the container for the objects used with the associated content  
                i.e. positionObjectStage, graphicInteraction, positionObjectInteraction, mediaInteraction,
                drawingInteraction and gapImg.                                                            
            </xs:documentation>
        </xs:annotation>
        <xs:sequence>
            <xs:choice minOccurs="0" maxOccurs="unbounded">
                <xs:element ref="m:math" minOccurs="1" maxOccurs="1" />
                <xs:element ref="xi:include" minOccurs="1" maxOccurs="1" />
                <xs:element ref="param" minOccurs="1" maxOccurs="1" />
                <xs:choice minOccurs="1" maxOccurs="1">
                    <xs:element ref="pre" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="h1" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="h2" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="h3" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="h4" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="h5" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="h6" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="p" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="address" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="dl" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="ol" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="ul" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="br" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="hr" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="img" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="object" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="blockquote" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="em" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="a" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="code" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="span" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="sub" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="acronym" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="big" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="tt" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="kbd" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="q" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="i" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="dfn" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="abbr" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="strong" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="sup" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="var" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="small" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="samp" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="b" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="cite" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="table" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="div" minOccurs="1" maxOccurs="1" />
                </xs:choice>
            </xs:choice>
        </xs:sequence>
        <xs:attributeGroup ref="id.Object.Attr" />
        <xs:attributeGroup ref="class.Object.Attr" />
        <xs:attributeGroup ref="xmllang.Object.Attr" />
        <xs:attributeGroup ref="label.Object.Attr" />
        <xs:attributeGroup ref="xmlbase.Object.Attr" />
        <xs:attributeGroup ref="data.Object.Attr" />
        <xs:attributeGroup ref="type.Object.Attr" />
        <xs:attributeGroup ref="width.Object.Attr" />
        <xs:attributeGroup ref="height.Object.Attr" />
    </xs:complexType>

    <xs:complexType name="Ordering.Type" abstract="false" mixed="false">
        <xs:annotation>
            <xs:documentation source="documentation">
                This is the container for the ordering rules to be applied when determining the order in  
                which the selected AssessmentSections and AssessmentItems are to be presented. At present 
                this is an open, namespaced, extension point. Feedback on what proprietary features are u-
                sed is welcomed.                                                                          
            </xs:documentation>
        </xs:annotation>
        <xs:sequence>
            <xs:group ref="grpLax.any" />
        </xs:sequence>
        <xs:attributeGroup ref="shuffle.Ordering.Attr" />
        <xs:attributeGroup ref="extension.Ordering.Attr" />
    </xs:complexType>

    <xs:complexType name="OrderInteraction.Type" abstract="false" mixed="false">
        <xs:annotation>
            <xs:documentation source="documentation">
                The OrderInteraction complexType is the container for the information about an order inte-
                raction.In an order interaction the candidate's task is to reorder the choices, the order 
                in which the choices are displayed initially is significant. By default the candidate's t-
                ask is to order all of the choices but a subset of the choices can be requested using the 
                maxChoices and minChoices attributes. When specified, the candidate must select a subset  
                of the choices and impose an ordering on them.                                            
            </xs:documentation>
        </xs:annotation>
        <xs:sequence>
            <xs:element ref="prompt" minOccurs="0" maxOccurs="1" />
            <xs:element ref="simpleChoice" minOccurs="1" maxOccurs="unbounded" />
        </xs:sequence>
        <xs:attributeGroup ref="xmlbase.OrderInteraction.Attr" />
        <xs:attributeGroup ref="id.OrderInteraction.Attr" />
        <xs:attributeGroup ref="class.OrderInteraction.Attr" />
        <xs:attributeGroup ref="xmllang.OrderInteraction.Attr" />
        <xs:attributeGroup ref="label.OrderInteraction.Attr" />
        <xs:attributeGroup ref="responseIdentifier.OrderInteraction.Attr" />
        <xs:attributeGroup ref="shuffle.OrderInteraction.Attr" />
        <xs:attributeGroup ref="minChoices.OrderInteraction.Attr" />
        <xs:attributeGroup ref="maxChoices.OrderInteraction.Attr" />
        <xs:attributeGroup ref="orientation.OrderInteraction.Attr" />
    </xs:complexType>

    <xs:complexType name="OUL.Type" abstract="false" mixed="false">
        <xs:annotation>
            <xs:documentation source="documentation">
                The 'OUL' complexType is the container for ordered and unordered lists as per the HTML 'u-
                l' and 'ol' markup.                                                                       
            </xs:documentation>
        </xs:annotation>
        <xs:sequence>
            <xs:element name="li" type="LI.Type" minOccurs="0" maxOccurs="unbounded" />
        </xs:sequence>
        <xs:attributeGroup ref="id.OUL.Attr" />
        <xs:attributeGroup ref="class.OUL.Attr" />
        <xs:attributeGroup ref="xmllang.OUL.Attr" />
        <xs:attributeGroup ref="label.OUL.Attr" />
        <xs:attributeGroup ref="xmlbase.OUL.Attr" />
    </xs:complexType>

    <xs:complexType name="OutcomeCondition.Type" abstract="false" mixed="false">
        <xs:annotation>
            <xs:documentation source="documentation">
                The OutcomeCondition complexType is the container for the sequence of outcome conditions  
                to be applied. The condition is structured as an 'If..ElseIf..ElseIf..Else' sequence. Each
                clause as its own outcome rule construct.                                                 
            </xs:documentation>
        </xs:annotation>
        <xs:sequence>
            <xs:element ref="outcomeIf" minOccurs="1" maxOccurs="1" />
            <xs:element ref="outcomeElseIf" minOccurs="0" maxOccurs="unbounded" />
            <xs:element ref="outcomeElse" minOccurs="0" maxOccurs="1" />
        </xs:sequence>
    </xs:complexType>

    <xs:complexType name="OutcomeDeclaration.Type" abstract="false" mixed="false">
        <xs:annotation>
            <xs:documentation source="documentation">
                The OutcomeDeclaration complexType is the container for the declaration of outcome variab-
                les. Outcome variables are declared by outcome declarations. Their value is set either fr-
                om a default given in the declaration itself or by a 'responseRule' during 'responseProce-
                ssing'.                                                                                   
            </xs:documentation>
        </xs:annotation>
        <xs:sequence>
            <xs:element ref="defaultValue" minOccurs="0" maxOccurs="1" />
            <xs:choice minOccurs="0" maxOccurs="1">
                <xs:element ref="matchTable" minOccurs="1" maxOccurs="1" />
                <xs:element ref="interpolationTable" minOccurs="1" maxOccurs="1" />
            </xs:choice>
        </xs:sequence>
        <xs:attributeGroup ref="identifier.OutcomeDeclaration.Attr" />
        <xs:attributeGroup ref="cardinality.OutcomeDeclaration.Attr" />
        <xs:attributeGroup ref="baseType.OutcomeDeclaration.Attr" />
        <xs:attributeGroup ref="view.OutcomeDeclaration.Attr" />
        <xs:attributeGroup ref="interpretation.OutcomeDeclaration.Attr" />
        <xs:attributeGroup ref="longInterpretation.OutcomeDeclaration.Attr" />
        <xs:attributeGroup ref="normalMaximum.OutcomeDeclaration.Attr" />
        <xs:attributeGroup ref="normalMinimum.OutcomeDeclaration.Attr" />
        <xs:attributeGroup ref="masteryValue.OutcomeDeclaration.Attr" />
    </xs:complexType>

    <xs:complexType name="OutcomeElse.Type" abstract="false" mixed="false">
        <xs:annotation>
            <xs:documentation source="documentation">
                The OutcomeElse complexType is the container for 'Else' processing. An outcomeElse part c-
                onsists of an expression which must have an effective baseType of boolean and single card-
                inality. For more information about the runtime data model employed see Expressions. It a-
                lso contains a set of sub-rules. If the expression is true then the sub-rules are process-
                ed.                                                                                       
            </xs:documentation>
        </xs:annotation>
        <xs:sequence>
            <xs:choice minOccurs="0" maxOccurs="unbounded">
                <xs:element ref="lookupOutcomeValue" minOccurs="1" maxOccurs="1" />
                <xs:element ref="outcomeProcessingFragment" minOccurs="1" maxOccurs="1" />
                <xs:element ref="setOutcomeValue" minOccurs="1" maxOccurs="1" />
                <xs:element ref="xi:include" minOccurs="1" maxOccurs="1" />
                <xs:element ref="exitTest" minOccurs="1" maxOccurs="1" />
                <xs:element ref="outcomeCondition" minOccurs="1" maxOccurs="1" />
            </xs:choice>
        </xs:sequence>
    </xs:complexType>

    <xs:complexType name="OutcomeIf.Type" abstract="false" mixed="false">
        <xs:annotation>
            <xs:documentation source="documentation">
                The OutcomeIf complexType is the container for 'If' processing. An outcomeIf part consists
                of an expression which must have an effective baseType of boolean and single cardinality. 
                For more information about the runtime data model employed see Expressions. It also conta-
                ins a set of sub-rules. If the expression is true then the sub-rules are processed, other-
                wise they are skipped (including if the expression is NULL) and the following outcomeElse-
                If or outcomeElse parts (if any) are considered instead.                                  
            </xs:documentation>
        </xs:annotation>
        <xs:sequence>
            <xs:choice minOccurs="1" maxOccurs="1">
                <xs:element ref="and" minOccurs="1" maxOccurs="1" />
                <xs:element ref="gt" minOccurs="1" maxOccurs="1" />
                <xs:element ref="not" minOccurs="1" maxOccurs="1" />
                <xs:element ref="lt" minOccurs="1" maxOccurs="1" />
                <xs:element ref="gte" minOccurs="1" maxOccurs="1" />
                <xs:element ref="lte" minOccurs="1" maxOccurs="1" />
                <xs:element ref="or" minOccurs="1" maxOccurs="1" />
                <xs:element ref="sum" minOccurs="1" maxOccurs="1" />
                <xs:element ref="durationLT" minOccurs="1" maxOccurs="1" />
                <xs:element ref="durationGTE" minOccurs="1" maxOccurs="1" />
                <xs:element ref="subtract" minOccurs="1" maxOccurs="1" />
                <xs:element ref="divide" minOccurs="1" maxOccurs="1" />
                <xs:element ref="multiple" minOccurs="1" maxOccurs="1" />
                <xs:element ref="ordered" minOccurs="1" maxOccurs="1" />
                <xs:element ref="customOperator" minOccurs="1" maxOccurs="1" />
                <xs:element ref="random" minOccurs="1" maxOccurs="1" />
                <xs:element ref="numberIncorrect" minOccurs="1" maxOccurs="1" />
                <xs:element ref="numberCorrect" minOccurs="1" maxOccurs="1" />
                <xs:element ref="numberPresented" minOccurs="1" maxOccurs="1" />
                <xs:element ref="numberResponded" minOccurs="1" maxOccurs="1" />
                <xs:element ref="numberSelected" minOccurs="1" maxOccurs="1" />
                <xs:element ref="substring" minOccurs="1" maxOccurs="1" />
                <xs:element ref="equalRounded" minOccurs="1" maxOccurs="1" />
                <xs:element ref="null" minOccurs="1" maxOccurs="1" />
                <xs:element ref="delete" minOccurs="1" maxOccurs="1" />
                <xs:element ref="match" minOccurs="1" maxOccurs="1" />
                <xs:element ref="index" minOccurs="1" maxOccurs="1" />
                <xs:element ref="power" minOccurs="1" maxOccurs="1" />
                <xs:element ref="equal" minOccurs="1" maxOccurs="1" />
                <xs:element ref="contains" minOccurs="1" maxOccurs="1" />
                <xs:element ref="containerSize" minOccurs="1" maxOccurs="1" />
                <xs:element ref="correct" minOccurs="1" maxOccurs="1" />
                <xs:element ref="default" minOccurs="1" maxOccurs="1" />
                <xs:element ref="anyN" minOccurs="1" maxOccurs="1" />
                <xs:element ref="integerDivide" minOccurs="1" maxOccurs="1" />
                <xs:element ref="integerModulus" minOccurs="1" maxOccurs="1" />
                <xs:element ref="isNull" minOccurs="1" maxOccurs="1" />
                <xs:element ref="member" minOccurs="1" maxOccurs="1" />
                <xs:element ref="product" minOccurs="1" maxOccurs="1" />
                <xs:element ref="round" minOccurs="1" maxOccurs="1" />
                <xs:element ref="truncate" minOccurs="1" maxOccurs="1" />
                <xs:element ref="fieldValue" minOccurs="1" maxOccurs="1" />
                <xs:element ref="randomInteger" minOccurs="1" maxOccurs="1" />
                <xs:element ref="randomFloat" minOccurs="1" maxOccurs="1" />
                <xs:element ref="variable" minOccurs="1" maxOccurs="1" />
                <xs:element ref="outcomeMinimum" minOccurs="1" maxOccurs="1" />
                <xs:element ref="outcomeMaximum" minOccurs="1" maxOccurs="1" />
                <xs:element ref="testVariables" minOccurs="1" maxOccurs="1" />
                <xs:element ref="integerToFloat" minOccurs="1" maxOccurs="1" />
                <xs:element ref="inside" minOccurs="1" maxOccurs="1" />
                <xs:element ref="baseValue" minOccurs="1" maxOccurs="1" />
                <xs:element ref="patternMatch" minOccurs="1" maxOccurs="1" />
                <xs:element ref="mapResponsePoint" minOccurs="1" maxOccurs="1" />
                <xs:element ref="mapResponse" minOccurs="1" maxOccurs="1" />
                <xs:element ref="stringMatch" minOccurs="1" maxOccurs="1" />
                <xs:element ref="repeat" minOccurs="1" maxOccurs="1" />
                <xs:element ref="roundTo" minOccurs="1" maxOccurs="1" />
                <xs:element ref="lcm" minOccurs="1" maxOccurs="1" />
                <xs:element ref="gcd" minOccurs="1" maxOccurs="1" />
                <xs:element ref="min" minOccurs="1" maxOccurs="1" />
                <xs:element ref="max" minOccurs="1" maxOccurs="1" />
                <xs:element ref="mathConstant" minOccurs="1" maxOccurs="1" />
                <xs:element ref="statsOperator" minOccurs="1" maxOccurs="1" />
                <xs:element ref="mathOperator" minOccurs="1" maxOccurs="1" />
            </xs:choice>
            <xs:choice minOccurs="0" maxOccurs="unbounded">
                <xs:element ref="lookupOutcomeValue" minOccurs="1" maxOccurs="1" />
                <xs:element ref="outcomeProcessingFragment" minOccurs="1" maxOccurs="1" />
                <xs:element ref="setOutcomeValue" minOccurs="1" maxOccurs="1" />
                <xs:element ref="xi:include" minOccurs="1" maxOccurs="1" />
                <xs:element ref="exitTest" minOccurs="1" maxOccurs="1" />
                <xs:element ref="outcomeCondition" minOccurs="1" maxOccurs="1" />
            </xs:choice>
        </xs:sequence>
    </xs:complexType>

    <xs:complexType name="OutcomeProcessing.Type" abstract="false" mixed="false">
        <xs:annotation>
            <xs:documentation source="documentation">
                The OutcomeProcessing complexType is the container for the outcome processing instruction-
                s. Outcome processing takes place each time the candidate submits the responses for an it-
                em (when in individual submission mode) or a group of items (when in simultaneous submiss-
                ion mode). It happens after any (item level) response processing triggered by the submiss-
                ion. The values of the test's outcome variables are always reset to their defaults prior  
                to carrying out the instructions described by the outcomeRules. Because outcome processing
                happend each time the candidate submits responses the resulting values of the test-level  
                outcomes may be used to activate test-level feedback during the test or to control the be-
                haviour of subsequent parts through the use of preConditions and branchRules.             
            </xs:documentation>
        </xs:annotation>
        <xs:sequence>
            <xs:choice minOccurs="0" maxOccurs="unbounded">
                <xs:element ref="lookupOutcomeValue" minOccurs="1" maxOccurs="1" />
                <xs:element ref="outcomeProcessingFragment" minOccurs="1" maxOccurs="1" />
                <xs:element ref="setOutcomeValue" minOccurs="1" maxOccurs="1" />
                <xs:element ref="xi:include" minOccurs="1" maxOccurs="1" />
                <xs:element ref="exitTest" minOccurs="1" maxOccurs="1" />
                <xs:element ref="outcomeCondition" minOccurs="1" maxOccurs="1" />
            </xs:choice>
        </xs:sequence>
    </xs:complexType>

    <xs:complexType name="OutcomeProcessingFragment.Type" abstract="false" mixed="false">
        <xs:annotation>
            <xs:documentation source="documentation">
                The OutcomeProcessingFragment is the complexType for a group of outcome rules. An outcome-
                ProcessingFragment is a simple group of outcomeRules which are grouped together in order  
                to allow them to be managed as a separate resource. It should not be used for any other p-
                urpose.                                                                                   
            </xs:documentation>
        </xs:annotation>
        <xs:sequence>
            <xs:choice minOccurs="0" maxOccurs="unbounded">
                <xs:element ref="lookupOutcomeValue" minOccurs="1" maxOccurs="1" />
                <xs:element ref="outcomeProcessingFragment" minOccurs="1" maxOccurs="1" />
                <xs:element ref="setOutcomeValue" minOccurs="1" maxOccurs="1" />
                <xs:element ref="xi:include" minOccurs="1" maxOccurs="1" />
                <xs:element ref="exitTest" minOccurs="1" maxOccurs="1" />
                <xs:element ref="outcomeCondition" minOccurs="1" maxOccurs="1" />
            </xs:choice>
        </xs:sequence>
    </xs:complexType>

    <xs:complexType name="PatternMatch.Type" abstract="false" mixed="false">
        <xs:annotation>
            <xs:documentation source="documentation">
                The patternMatch operator takes a sub-expression which must have single cardinality and a 
                base-type of string. The result is a single boolean with a value of true if the sub-expre-
                ssion matches the regular expression given by pattern and false if it doesn't. If the sub-
                -expression is NULL then the operator results in NULL.                                    
            </xs:documentation>
        </xs:annotation>
        <xs:sequence>
            <xs:choice minOccurs="1" maxOccurs="1">
                <xs:element ref="and" minOccurs="1" maxOccurs="1" />
                <xs:element ref="gt" minOccurs="1" maxOccurs="1" />
                <xs:element ref="not" minOccurs="1" maxOccurs="1" />
                <xs:element ref="lt" minOccurs="1" maxOccurs="1" />
                <xs:element ref="gte" minOccurs="1" maxOccurs="1" />
                <xs:element ref="lte" minOccurs="1" maxOccurs="1" />
                <xs:element ref="or" minOccurs="1" maxOccurs="1" />
                <xs:element ref="sum" minOccurs="1" maxOccurs="1" />
                <xs:element ref="durationLT" minOccurs="1" maxOccurs="1" />
                <xs:element ref="durationGTE" minOccurs="1" maxOccurs="1" />
                <xs:element ref="subtract" minOccurs="1" maxOccurs="1" />
                <xs:element ref="divide" minOccurs="1" maxOccurs="1" />
                <xs:element ref="multiple" minOccurs="1" maxOccurs="1" />
                <xs:element ref="ordered" minOccurs="1" maxOccurs="1" />
                <xs:element ref="customOperator" minOccurs="1" maxOccurs="1" />
                <xs:element ref="random" minOccurs="1" maxOccurs="1" />
                <xs:element ref="numberIncorrect" minOccurs="1" maxOccurs="1" />
                <xs:element ref="numberCorrect" minOccurs="1" maxOccurs="1" />
                <xs:element ref="numberPresented" minOccurs="1" maxOccurs="1" />
                <xs:element ref="numberResponded" minOccurs="1" maxOccurs="1" />
                <xs:element ref="numberSelected" minOccurs="1" maxOccurs="1" />
                <xs:element ref="substring" minOccurs="1" maxOccurs="1" />
                <xs:element ref="equalRounded" minOccurs="1" maxOccurs="1" />
                <xs:element ref="null" minOccurs="1" maxOccurs="1" />
                <xs:element ref="delete" minOccurs="1" maxOccurs="1" />
                <xs:element ref="match" minOccurs="1" maxOccurs="1" />
                <xs:element ref="index" minOccurs="1" maxOccurs="1" />
                <xs:element ref="power" minOccurs="1" maxOccurs="1" />
                <xs:element ref="equal" minOccurs="1" maxOccurs="1" />
                <xs:element ref="contains" minOccurs="1" maxOccurs="1" />
                <xs:element ref="containerSize" minOccurs="1" maxOccurs="1" />
                <xs:element ref="correct" minOccurs="1" maxOccurs="1" />
                <xs:element ref="default" minOccurs="1" maxOccurs="1" />
                <xs:element ref="anyN" minOccurs="1" maxOccurs="1" />
                <xs:element ref="integerDivide" minOccurs="1" maxOccurs="1" />
                <xs:element ref="integerModulus" minOccurs="1" maxOccurs="1" />
                <xs:element ref="isNull" minOccurs="1" maxOccurs="1" />
                <xs:element ref="member" minOccurs="1" maxOccurs="1" />
                <xs:element ref="product" minOccurs="1" maxOccurs="1" />
                <xs:element ref="round" minOccurs="1" maxOccurs="1" />
                <xs:element ref="truncate" minOccurs="1" maxOccurs="1" />
                <xs:element ref="fieldValue" minOccurs="1" maxOccurs="1" />
                <xs:element ref="randomInteger" minOccurs="1" maxOccurs="1" />
                <xs:element ref="randomFloat" minOccurs="1" maxOccurs="1" />
                <xs:element ref="variable" minOccurs="1" maxOccurs="1" />
                <xs:element ref="outcomeMinimum" minOccurs="1" maxOccurs="1" />
                <xs:element ref="outcomeMaximum" minOccurs="1" maxOccurs="1" />
                <xs:element ref="testVariables" minOccurs="1" maxOccurs="1" />
                <xs:element ref="integerToFloat" minOccurs="1" maxOccurs="1" />
                <xs:element ref="inside" minOccurs="1" maxOccurs="1" />
                <xs:element ref="baseValue" minOccurs="1" maxOccurs="1" />
                <xs:element ref="patternMatch" minOccurs="1" maxOccurs="1" />
                <xs:element ref="mapResponsePoint" minOccurs="1" maxOccurs="1" />
                <xs:element ref="mapResponse" minOccurs="1" maxOccurs="1" />
                <xs:element ref="stringMatch" minOccurs="1" maxOccurs="1" />
                <xs:element ref="repeat" minOccurs="1" maxOccurs="1" />
                <xs:element ref="roundTo" minOccurs="1" maxOccurs="1" />
                <xs:element ref="lcm" minOccurs="1" maxOccurs="1" />
                <xs:element ref="gcd" minOccurs="1" maxOccurs="1" />
                <xs:element ref="min" minOccurs="1" maxOccurs="1" />
                <xs:element ref="max" minOccurs="1" maxOccurs="1" />
                <xs:element ref="mathConstant" minOccurs="1" maxOccurs="1" />
                <xs:element ref="statsOperator" minOccurs="1" maxOccurs="1" />
                <xs:element ref="mathOperator" minOccurs="1" maxOccurs="1" />
            </xs:choice>
        </xs:sequence>
        <xs:attributeGroup ref="pattern.PatternMatch.Attr" />
    </xs:complexType>

    <xs:complexType name="PositionObjectInteraction.Type" abstract="false" mixed="false">
        <xs:annotation>
            <xs:documentation source="documentation">
                The PositionObjectInteraction is the complexType for position object interactions. The po-
                sition object interaction consists of a single image which must be positioned on another  
                graphic image (the stage) by the candidate. Like selectPointInteraction, the associated r-
                esponse may have an areaMapping that scores the response on the basis of comparing it aga-
                inst predefined areas but the delivery engine must not indicate these areas of the stage. 
                Only the actual position(s) selected by the candidate shall be indicated.                 
            </xs:documentation>
        </xs:annotation>
        <xs:sequence>
            <xs:element ref="object" minOccurs="1" maxOccurs="1" />
        </xs:sequence>
        <xs:attributeGroup ref="id.PositionObjectInteraction.Attr" />
        <xs:attributeGroup ref="class.PositionObjectInteraction.Attr" />
        <xs:attributeGroup ref="xmllang.PositionObjectInteraction.Attr" />
        <xs:attributeGroup ref="label.PositionObjectInteraction.Attr" />
        <xs:attributeGroup ref="responseIdentifier.PositionObjectInteraction.Attr" />
        <xs:attributeGroup ref="centerPoint.PositionObjectInteraction.Attr" />
        <xs:attributeGroup ref="minChoices.PositionObjectInteraction.Attr" />
        <xs:attributeGroup ref="maxChoices.PositionObjectInteraction.Attr" />
    </xs:complexType>

    <xs:complexType name="PositionObjectStage.Type" abstract="false" mixed="false">
        <xs:annotation>
            <xs:documentation source="documentation">
                The PositionObjectStage is the complexType container for the image to be used as a stage  
                onto which individual 'positionObjectInteractions' allow the candidate to place their obj-
                ects.                                                                                     
            </xs:documentation>
        </xs:annotation>
        <xs:sequence>
            <xs:element ref="object" minOccurs="1" maxOccurs="1" />
            <xs:element ref="positionObjectInteraction" minOccurs="1" maxOccurs="unbounded" />
        </xs:sequence>
    </xs:complexType>

    <xs:complexType name="Prompt.Type" abstract="false" mixed="true">
        <xs:annotation>
            <xs:documentation source="documentation">
                A Prompt complexType is the container for the material that is to be presented to a candi-
                date as the prompt for the question e.g. the actual question after which the set of possi-
                ble answers for a multiple choice are presented. CHANGED: To contain FlowStaticGroup inst-
                ead of InlineStaticGroup.                                                                 
            </xs:documentation>
        </xs:annotation>
        <xs:sequence>
            <xs:choice minOccurs="0" maxOccurs="unbounded">
                <xs:element ref="m:math" minOccurs="1" maxOccurs="1" />
                <xs:element ref="xi:include" minOccurs="1" maxOccurs="1" />
                <xs:choice minOccurs="1" maxOccurs="1">
                    <xs:element ref="pre" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="h1" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="h2" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="h3" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="h4" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="h5" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="h6" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="p" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="address" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="dl" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="ol" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="ul" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="br" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="hr" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="img" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="object" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="blockquote" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="em" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="a" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="code" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="span" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="sub" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="acronym" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="big" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="tt" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="kbd" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="q" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="i" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="dfn" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="abbr" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="strong" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="sup" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="var" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="small" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="samp" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="b" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="cite" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="table" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="div" minOccurs="1" maxOccurs="1" />
                </xs:choice>
            </xs:choice>
        </xs:sequence>
        <xs:attributeGroup ref="id.Prompt.Attr" />
        <xs:attributeGroup ref="class.Prompt.Attr" />
        <xs:attributeGroup ref="xmllang.Prompt.Attr" />
        <xs:attributeGroup ref="label.Prompt.Attr" />
    </xs:complexType>

    <xs:complexType name="Q.Type" abstract="false" mixed="true">
        <xs:annotation>
            <xs:documentation source="documentation">
                The 'Q' complexType is the container for content that is equivalent to the HTML 'q' marku-
                p.                                                                                        
            </xs:documentation>
        </xs:annotation>
        <xs:sequence>
            <xs:choice minOccurs="0" maxOccurs="unbounded">
                <xs:element ref="textEntryInteraction" minOccurs="1" maxOccurs="1" />
                <xs:element ref="hottext" minOccurs="1" maxOccurs="1" />
                <xs:element ref="printedVariable" minOccurs="1" maxOccurs="1" />
                <xs:element ref="gap" minOccurs="1" maxOccurs="1" />
                <xs:element ref="feedbackInline" minOccurs="1" maxOccurs="1" />
                <xs:element ref="templateInline" minOccurs="1" maxOccurs="1" />
                <xs:element ref="inlineChoiceInteraction" minOccurs="1" maxOccurs="1" />
                <xs:element ref="endAttemptInteraction" minOccurs="1" maxOccurs="1" />
                <xs:element ref="customInteraction" minOccurs="1" maxOccurs="1" />
                <xs:element ref="m:math" minOccurs="1" maxOccurs="1" />
                <xs:element ref="xi:include" minOccurs="1" maxOccurs="1" />
                <xs:choice minOccurs="1" maxOccurs="1">
                    <xs:element ref="img" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="br" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="object" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="em" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="a" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="code" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="span" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="sub" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="acronym" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="big" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="tt" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="kbd" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="q" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="i" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="dfn" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="abbr" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="strong" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="sup" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="var" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="small" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="samp" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="b" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="cite" minOccurs="1" maxOccurs="1" />
                </xs:choice>
            </xs:choice>
        </xs:sequence>
        <xs:attributeGroup ref="id.Q.Attr" />
        <xs:attributeGroup ref="class.Q.Attr" />
        <xs:attributeGroup ref="xmllang.Q.Attr" />
        <xs:attributeGroup ref="label.Q.Attr" />
        <xs:attributeGroup ref="xmlbase.Q.Attr" />
        <xs:attributeGroup ref="cite.Q.Attr" />
    </xs:complexType>

    <xs:complexType name="Repeat.Type" abstract="false" mixed="false">
        <xs:annotation>
            <xs:documentation source="documentation">
                The repeat operator allows the filling of an ordered container. The result of a repeat op-
                erator is an ordered set of values calculated from the expressions. Values will be set in 
                the associated container by a setTemplateValue expression. Each expression is calculated  
                as many times as it is queried by numberRepeats.                                          
            </xs:documentation>
        </xs:annotation>
        <xs:sequence>
            <xs:choice minOccurs="1" maxOccurs="unbounded">
                <xs:element ref="and" minOccurs="1" maxOccurs="1" />
                <xs:element ref="gt" minOccurs="1" maxOccurs="1" />
                <xs:element ref="not" minOccurs="1" maxOccurs="1" />
                <xs:element ref="lt" minOccurs="1" maxOccurs="1" />
                <xs:element ref="gte" minOccurs="1" maxOccurs="1" />
                <xs:element ref="lte" minOccurs="1" maxOccurs="1" />
                <xs:element ref="or" minOccurs="1" maxOccurs="1" />
                <xs:element ref="sum" minOccurs="1" maxOccurs="1" />
                <xs:element ref="durationLT" minOccurs="1" maxOccurs="1" />
                <xs:element ref="durationGTE" minOccurs="1" maxOccurs="1" />
                <xs:element ref="subtract" minOccurs="1" maxOccurs="1" />
                <xs:element ref="divide" minOccurs="1" maxOccurs="1" />
                <xs:element ref="multiple" minOccurs="1" maxOccurs="1" />
                <xs:element ref="ordered" minOccurs="1" maxOccurs="1" />
                <xs:element ref="customOperator" minOccurs="1" maxOccurs="1" />
                <xs:element ref="random" minOccurs="1" maxOccurs="1" />
                <xs:element ref="numberIncorrect" minOccurs="1" maxOccurs="1" />
                <xs:element ref="numberCorrect" minOccurs="1" maxOccurs="1" />
                <xs:element ref="numberPresented" minOccurs="1" maxOccurs="1" />
                <xs:element ref="numberResponded" minOccurs="1" maxOccurs="1" />
                <xs:element ref="numberSelected" minOccurs="1" maxOccurs="1" />
                <xs:element ref="substring" minOccurs="1" maxOccurs="1" />
                <xs:element ref="equalRounded" minOccurs="1" maxOccurs="1" />
                <xs:element ref="null" minOccurs="1" maxOccurs="1" />
                <xs:element ref="delete" minOccurs="1" maxOccurs="1" />
                <xs:element ref="match" minOccurs="1" maxOccurs="1" />
                <xs:element ref="index" minOccurs="1" maxOccurs="1" />
                <xs:element ref="power" minOccurs="1" maxOccurs="1" />
                <xs:element ref="equal" minOccurs="1" maxOccurs="1" />
                <xs:element ref="contains" minOccurs="1" maxOccurs="1" />
                <xs:element ref="containerSize" minOccurs="1" maxOccurs="1" />
                <xs:element ref="correct" minOccurs="1" maxOccurs="1" />
                <xs:element ref="default" minOccurs="1" maxOccurs="1" />
                <xs:element ref="anyN" minOccurs="1" maxOccurs="1" />
                <xs:element ref="integerDivide" minOccurs="1" maxOccurs="1" />
                <xs:element ref="integerModulus" minOccurs="1" maxOccurs="1" />
                <xs:element ref="isNull" minOccurs="1" maxOccurs="1" />
                <xs:element ref="member" minOccurs="1" maxOccurs="1" />
                <xs:element ref="product" minOccurs="1" maxOccurs="1" />
                <xs:element ref="round" minOccurs="1" maxOccurs="1" />
                <xs:element ref="truncate" minOccurs="1" maxOccurs="1" />
                <xs:element ref="fieldValue" minOccurs="1" maxOccurs="1" />
                <xs:element ref="randomInteger" minOccurs="1" maxOccurs="1" />
                <xs:element ref="randomFloat" minOccurs="1" maxOccurs="1" />
                <xs:element ref="variable" minOccurs="1" maxOccurs="1" />
                <xs:element ref="outcomeMinimum" minOccurs="1" maxOccurs="1" />
                <xs:element ref="outcomeMaximum" minOccurs="1" maxOccurs="1" />
                <xs:element ref="testVariables" minOccurs="1" maxOccurs="1" />
                <xs:element ref="integerToFloat" minOccurs="1" maxOccurs="1" />
                <xs:element ref="inside" minOccurs="1" maxOccurs="1" />
                <xs:element ref="baseValue" minOccurs="1" maxOccurs="1" />
                <xs:element ref="patternMatch" minOccurs="1" maxOccurs="1" />
                <xs:element ref="mapResponsePoint" minOccurs="1" maxOccurs="1" />
                <xs:element ref="mapResponse" minOccurs="1" maxOccurs="1" />
                <xs:element ref="stringMatch" minOccurs="1" maxOccurs="1" />
                <xs:element ref="repeat" minOccurs="1" maxOccurs="1" />
                <xs:element ref="roundTo" minOccurs="1" maxOccurs="1" />
                <xs:element ref="lcm" minOccurs="1" maxOccurs="1" />
                <xs:element ref="gcd" minOccurs="1" maxOccurs="1" />
                <xs:element ref="min" minOccurs="1" maxOccurs="1" />
                <xs:element ref="max" minOccurs="1" maxOccurs="1" />
                <xs:element ref="mathConstant" minOccurs="1" maxOccurs="1" />
                <xs:element ref="statsOperator" minOccurs="1" maxOccurs="1" />
                <xs:element ref="mathOperator" minOccurs="1" maxOccurs="1" />
            </xs:choice>
        </xs:sequence>
        <xs:attribute name="numberRepeats" use="required">
            <xs:simpleType>
                <xs:union>
                    <xs:simpleType>
                        <xs:restriction base="xs:NCName" />
                    </xs:simpleType>
                    <xs:simpleType>
                        <xs:restriction base="xs:int" />
                    </xs:simpleType>
                </xs:union>
            </xs:simpleType>
        </xs:attribute>
    </xs:complexType>

    <xs:complexType name="ResponseCondition.Type" abstract="false" mixed="false">
        <xs:annotation>
            <xs:documentation source="documentation">
                The ResponseCondition complexType is the container for the sequence of outcome conditions 
                to be applied. The condition is structured as an 'If..ElseIf..ElseIf..Else' sequence. Each
                clause as its own response rule construct.                                                
            </xs:documentation>
        </xs:annotation>
        <xs:sequence>
            <xs:element name="responseIf" type="ResponseIf.Type" minOccurs="1" maxOccurs="1" />
            <xs:element name="responseElseIf" type="ResponseIf.Type" minOccurs="0" maxOccurs="unbounded" />
            <xs:element name="responseElse" type="ResponseElse.Type" minOccurs="0" maxOccurs="1" />
        </xs:sequence>
    </xs:complexType>

    <xs:complexType name="ResponseDeclaration.Type" abstract="false" mixed="false">
        <xs:annotation>
            <xs:documentation source="documentation">
                The ResponseDeclaration complexType is used to contain the definition of the Response Var-
                iable that are to be bound to the interactions in the Item.                               
            </xs:documentation>
        </xs:annotation>
        <xs:sequence>
            <xs:element ref="defaultValue" minOccurs="0" maxOccurs="1" />
            <xs:element ref="correctResponse" minOccurs="0" maxOccurs="1" />
            <xs:element ref="mapping" minOccurs="0" maxOccurs="1" />
            <xs:element ref="areaMapping" minOccurs="0" maxOccurs="1" />
        </xs:sequence>
        <xs:attributeGroup ref="identifier.ResponseDeclaration.Attr" />
        <xs:attributeGroup ref="cardinality.ResponseDeclaration.Attr" />
        <xs:attributeGroup ref="baseType.ResponseDeclaration.Attr" />
    </xs:complexType>

    <xs:complexType name="ResponseElse.Type" abstract="false" mixed="false">
        <xs:annotation>
            <xs:documentation source="documentation">
                The ResponseElse complexType is the container for the 'Else' clause. If the expression gi-
                ven in a responseIf or responseElseIf evaluates to true then the sub-rules contained with-
                in it are followed and any following responseElseIf or responseElse parts are ignored for 
                this response condition. If the expression given in a responseIf or responseElseIf does n-
                ot evaluate to true then consideration passes to the next responseElseIf or, if there are 
                no more responseElseIf parts then the sub-rules of the responseElse are followed (if spec-
                ified).                                                                                   
            </xs:documentation>
        </xs:annotation>
        <xs:sequence>
            <xs:choice minOccurs="0" maxOccurs="unbounded">
                <xs:element ref="xi:include" minOccurs="1" maxOccurs="1" />
                <xs:element ref="responseCondition" minOccurs="1" maxOccurs="1" />
                <xs:element ref="responseProcessingFragment" minOccurs="1" maxOccurs="1" />
                <xs:element ref="setOutcomeValue" minOccurs="1" maxOccurs="1" />
                <xs:element ref="exitResponse" minOccurs="1" maxOccurs="1" />
                <xs:element ref="lookupOutcomeValue" minOccurs="1" maxOccurs="1" />
            </xs:choice>
        </xs:sequence>
    </xs:complexType>

    <xs:complexType name="ResponseIf.Type" abstract="false" mixed="false">
        <xs:annotation>
            <xs:documentation source="documentation">
                The ResponseIf complexType is the container for the 'If' clause. If the expression given  
                in a responseIf or responseElseIf evaluates to true then the sub-rules contained within it
                are followed and any following responseElseIf or responseElse parts are ignored for this  
                response condition. If the expression given in a responseIf or responseElseIf does not ev-
                aluate to true then consideration passes to the next responseElseIf or, if there are no m-
                ore responseElseIf parts then the sub-rules of the responseElse are followed (if specifie-
                d).                                                                                       
            </xs:documentation>
        </xs:annotation>
        <xs:sequence>
            <xs:choice minOccurs="1" maxOccurs="1">
                <xs:element ref="and" minOccurs="1" maxOccurs="1" />
                <xs:element ref="gt" minOccurs="1" maxOccurs="1" />
                <xs:element ref="not" minOccurs="1" maxOccurs="1" />
                <xs:element ref="lt" minOccurs="1" maxOccurs="1" />
                <xs:element ref="gte" minOccurs="1" maxOccurs="1" />
                <xs:element ref="lte" minOccurs="1" maxOccurs="1" />
                <xs:element ref="or" minOccurs="1" maxOccurs="1" />
                <xs:element ref="sum" minOccurs="1" maxOccurs="1" />
                <xs:element ref="durationLT" minOccurs="1" maxOccurs="1" />
                <xs:element ref="durationGTE" minOccurs="1" maxOccurs="1" />
                <xs:element ref="subtract" minOccurs="1" maxOccurs="1" />
                <xs:element ref="divide" minOccurs="1" maxOccurs="1" />
                <xs:element ref="multiple" minOccurs="1" maxOccurs="1" />
                <xs:element ref="ordered" minOccurs="1" maxOccurs="1" />
                <xs:element ref="customOperator" minOccurs="1" maxOccurs="1" />
                <xs:element ref="random" minOccurs="1" maxOccurs="1" />
                <xs:element ref="numberIncorrect" minOccurs="1" maxOccurs="1" />
                <xs:element ref="numberCorrect" minOccurs="1" maxOccurs="1" />
                <xs:element ref="numberPresented" minOccurs="1" maxOccurs="1" />
                <xs:element ref="numberResponded" minOccurs="1" maxOccurs="1" />
                <xs:element ref="numberSelected" minOccurs="1" maxOccurs="1" />
                <xs:element ref="substring" minOccurs="1" maxOccurs="1" />
                <xs:element ref="equalRounded" minOccurs="1" maxOccurs="1" />
                <xs:element ref="null" minOccurs="1" maxOccurs="1" />
                <xs:element ref="delete" minOccurs="1" maxOccurs="1" />
                <xs:element ref="match" minOccurs="1" maxOccurs="1" />
                <xs:element ref="index" minOccurs="1" maxOccurs="1" />
                <xs:element ref="power" minOccurs="1" maxOccurs="1" />
                <xs:element ref="equal" minOccurs="1" maxOccurs="1" />
                <xs:element ref="contains" minOccurs="1" maxOccurs="1" />
                <xs:element ref="containerSize" minOccurs="1" maxOccurs="1" />
                <xs:element ref="correct" minOccurs="1" maxOccurs="1" />
                <xs:element ref="default" minOccurs="1" maxOccurs="1" />
                <xs:element ref="anyN" minOccurs="1" maxOccurs="1" />
                <xs:element ref="integerDivide" minOccurs="1" maxOccurs="1" />
                <xs:element ref="integerModulus" minOccurs="1" maxOccurs="1" />
                <xs:element ref="isNull" minOccurs="1" maxOccurs="1" />
                <xs:element ref="member" minOccurs="1" maxOccurs="1" />
                <xs:element ref="product" minOccurs="1" maxOccurs="1" />
                <xs:element ref="round" minOccurs="1" maxOccurs="1" />
                <xs:element ref="truncate" minOccurs="1" maxOccurs="1" />
                <xs:element ref="fieldValue" minOccurs="1" maxOccurs="1" />
                <xs:element ref="randomInteger" minOccurs="1" maxOccurs="1" />
                <xs:element ref="randomFloat" minOccurs="1" maxOccurs="1" />
                <xs:element ref="variable" minOccurs="1" maxOccurs="1" />
                <xs:element ref="outcomeMinimum" minOccurs="1" maxOccurs="1" />
                <xs:element ref="outcomeMaximum" minOccurs="1" maxOccurs="1" />
                <xs:element ref="testVariables" minOccurs="1" maxOccurs="1" />
                <xs:element ref="integerToFloat" minOccurs="1" maxOccurs="1" />
                <xs:element ref="inside" minOccurs="1" maxOccurs="1" />
                <xs:element ref="baseValue" minOccurs="1" maxOccurs="1" />
                <xs:element ref="patternMatch" minOccurs="1" maxOccurs="1" />
                <xs:element ref="mapResponsePoint" minOccurs="1" maxOccurs="1" />
                <xs:element ref="mapResponse" minOccurs="1" maxOccurs="1" />
                <xs:element ref="stringMatch" minOccurs="1" maxOccurs="1" />
                <xs:element ref="repeat" minOccurs="1" maxOccurs="1" />
                <xs:element ref="roundTo" minOccurs="1" maxOccurs="1" />
                <xs:element ref="lcm" minOccurs="1" maxOccurs="1" />
                <xs:element ref="gcd" minOccurs="1" maxOccurs="1" />
                <xs:element ref="min" minOccurs="1" maxOccurs="1" />
                <xs:element ref="max" minOccurs="1" maxOccurs="1" />
                <xs:element ref="mathConstant" minOccurs="1" maxOccurs="1" />
                <xs:element ref="statsOperator" minOccurs="1" maxOccurs="1" />
                <xs:element ref="mathOperator" minOccurs="1" maxOccurs="1" />
            </xs:choice>
            <xs:choice minOccurs="0" maxOccurs="unbounded">
                <xs:element ref="xi:include" minOccurs="1" maxOccurs="1" />
                <xs:element ref="responseCondition" minOccurs="1" maxOccurs="1" />
                <xs:element ref="responseProcessingFragment" minOccurs="1" maxOccurs="1" />
                <xs:element ref="setOutcomeValue" minOccurs="1" maxOccurs="1" />
                <xs:element ref="exitResponse" minOccurs="1" maxOccurs="1" />
                <xs:element ref="lookupOutcomeValue" minOccurs="1" maxOccurs="1" />
            </xs:choice>
        </xs:sequence>
    </xs:complexType>

    <xs:complexType name="ResponseProcessing.Type" abstract="false" mixed="false">
        <xs:annotation>
            <xs:documentation source="documentation">
                The ResponseProcessing complexType is the container for response processing instructions. 
                Response processing involves the application of a set of responseRules, including the tes-
                ting of responseConditions and the evaluation of expressions involving the item variables.
                For delivery engines that are only designed to support very simple use cases the implemen-
                tation of a system for carrying out this evaluation, conditional testing and processing m-
                ay pose a barrier to the adoption of the specification.                                   
            </xs:documentation>
        </xs:annotation>
        <xs:sequence>
            <xs:choice minOccurs="0" maxOccurs="unbounded">
                <xs:element ref="xi:include" minOccurs="1" maxOccurs="1" />
                <xs:element ref="responseCondition" minOccurs="1" maxOccurs="1" />
                <xs:element ref="responseProcessingFragment" minOccurs="1" maxOccurs="1" />
                <xs:element ref="setOutcomeValue" minOccurs="1" maxOccurs="1" />
                <xs:element ref="exitResponse" minOccurs="1" maxOccurs="1" />
                <xs:element ref="lookupOutcomeValue" minOccurs="1" maxOccurs="1" />
            </xs:choice>
        </xs:sequence>
        <xs:attributeGroup ref="template.ResponseProcessing.Attr" />
        <xs:attributeGroup ref="templateLocation.ResponseProcessing.Attr" />
    </xs:complexType>

    <xs:complexType name="ResponseProcessingFragment.Type" abstract="false" mixed="false">
        <xs:annotation>
            <xs:documentation source="documentation">
                The ResponseProcessingFragment complexType is the container for a group of response rules.
                A responseProcessingFragment is a simple group of responseRules which are grouped together
                in order to allow them to be managed as a separate resource. It should not be used for any
                other purpose.                                                                            
            </xs:documentation>
        </xs:annotation>
        <xs:sequence>
            <xs:choice minOccurs="0" maxOccurs="unbounded">
                <xs:element ref="xi:include" minOccurs="1" maxOccurs="1" />
                <xs:element ref="responseCondition" minOccurs="1" maxOccurs="1" />
                <xs:element ref="responseProcessingFragment" minOccurs="1" maxOccurs="1" />
                <xs:element ref="setOutcomeValue" minOccurs="1" maxOccurs="1" />
                <xs:element ref="exitResponse" minOccurs="1" maxOccurs="1" />
                <xs:element ref="lookupOutcomeValue" minOccurs="1" maxOccurs="1" />
            </xs:choice>
        </xs:sequence>
    </xs:complexType>

    <xs:complexType name="RoundTo.Type" abstract="false" mixed="false">
        <xs:annotation>
            <xs:documentation source="documentation">
                The roundTo operator takes one sub-expression which must have single cardinality and a nu-
                merical base-type. The result is a single float with the value nearest to that of the exp-
                ression's value such that when converted to a decimal string it represents the expression 
                rounded by the specified rounding method to the specified precision. If the sub-expression
                is NULL, then the result is NULL. If the sub-expression is INF, then the result is INF. If
                the sub-expression is -INF, then the result is -INF. If the argument is NaN, then the res-
                ult is NULL. When rounding to n significant figures, the deciding digit is the (n+1)th di-
                git counting from the first non-zero digit from the left in the number. If the deciding d-
                igit is 5 or greater, the nth digit is increased by 1 and all digits to its right are dis-
                carded; if the deciding digit is less than 5, all digits to the right of the nth digit are
                discarded. When rounding to n decimal places, the deciding digit is the (n+1)th digit cou-
                nting to the right from the decimal point. If the deciding digit is 5 or greater, the nth 
                digit is increased by 1 and all digits to its right are discarded; if the deciding digit  
                is less than 5, all digits to the right of the nth digit are discarded.                   
            </xs:documentation>
        </xs:annotation>
        <xs:sequence>
            <xs:choice minOccurs="1" maxOccurs="1">
                <xs:element ref="and" minOccurs="1" maxOccurs="1" />
                <xs:element ref="gt" minOccurs="1" maxOccurs="1" />
                <xs:element ref="not" minOccurs="1" maxOccurs="1" />
                <xs:element ref="lt" minOccurs="1" maxOccurs="1" />
                <xs:element ref="gte" minOccurs="1" maxOccurs="1" />
                <xs:element ref="lte" minOccurs="1" maxOccurs="1" />
                <xs:element ref="or" minOccurs="1" maxOccurs="1" />
                <xs:element ref="sum" minOccurs="1" maxOccurs="1" />
                <xs:element ref="durationLT" minOccurs="1" maxOccurs="1" />
                <xs:element ref="durationGTE" minOccurs="1" maxOccurs="1" />
                <xs:element ref="subtract" minOccurs="1" maxOccurs="1" />
                <xs:element ref="divide" minOccurs="1" maxOccurs="1" />
                <xs:element ref="multiple" minOccurs="1" maxOccurs="1" />
                <xs:element ref="ordered" minOccurs="1" maxOccurs="1" />
                <xs:element ref="customOperator" minOccurs="1" maxOccurs="1" />
                <xs:element ref="random" minOccurs="1" maxOccurs="1" />
                <xs:element ref="numberIncorrect" minOccurs="1" maxOccurs="1" />
                <xs:element ref="numberCorrect" minOccurs="1" maxOccurs="1" />
                <xs:element ref="numberPresented" minOccurs="1" maxOccurs="1" />
                <xs:element ref="numberResponded" minOccurs="1" maxOccurs="1" />
                <xs:element ref="numberSelected" minOccurs="1" maxOccurs="1" />
                <xs:element ref="substring" minOccurs="1" maxOccurs="1" />
                <xs:element ref="equalRounded" minOccurs="1" maxOccurs="1" />
                <xs:element ref="null" minOccurs="1" maxOccurs="1" />
                <xs:element ref="delete" minOccurs="1" maxOccurs="1" />
                <xs:element ref="match" minOccurs="1" maxOccurs="1" />
                <xs:element ref="index" minOccurs="1" maxOccurs="1" />
                <xs:element ref="power" minOccurs="1" maxOccurs="1" />
                <xs:element ref="equal" minOccurs="1" maxOccurs="1" />
                <xs:element ref="contains" minOccurs="1" maxOccurs="1" />
                <xs:element ref="containerSize" minOccurs="1" maxOccurs="1" />
                <xs:element ref="correct" minOccurs="1" maxOccurs="1" />
                <xs:element ref="default" minOccurs="1" maxOccurs="1" />
                <xs:element ref="anyN" minOccurs="1" maxOccurs="1" />
                <xs:element ref="integerDivide" minOccurs="1" maxOccurs="1" />
                <xs:element ref="integerModulus" minOccurs="1" maxOccurs="1" />
                <xs:element ref="isNull" minOccurs="1" maxOccurs="1" />
                <xs:element ref="member" minOccurs="1" maxOccurs="1" />
                <xs:element ref="product" minOccurs="1" maxOccurs="1" />
                <xs:element ref="round" minOccurs="1" maxOccurs="1" />
                <xs:element ref="truncate" minOccurs="1" maxOccurs="1" />
                <xs:element ref="fieldValue" minOccurs="1" maxOccurs="1" />
                <xs:element ref="randomInteger" minOccurs="1" maxOccurs="1" />
                <xs:element ref="randomFloat" minOccurs="1" maxOccurs="1" />
                <xs:element ref="variable" minOccurs="1" maxOccurs="1" />
                <xs:element ref="outcomeMinimum" minOccurs="1" maxOccurs="1" />
                <xs:element ref="outcomeMaximum" minOccurs="1" maxOccurs="1" />
                <xs:element ref="testVariables" minOccurs="1" maxOccurs="1" />
                <xs:element ref="integerToFloat" minOccurs="1" maxOccurs="1" />
                <xs:element ref="inside" minOccurs="1" maxOccurs="1" />
                <xs:element ref="baseValue" minOccurs="1" maxOccurs="1" />
                <xs:element ref="patternMatch" minOccurs="1" maxOccurs="1" />
                <xs:element ref="mapResponsePoint" minOccurs="1" maxOccurs="1" />
                <xs:element ref="mapResponse" minOccurs="1" maxOccurs="1" />
                <xs:element ref="stringMatch" minOccurs="1" maxOccurs="1" />
                <xs:element ref="repeat" minOccurs="1" maxOccurs="1" />
                <xs:element ref="roundTo" minOccurs="1" maxOccurs="1" />
                <xs:element ref="lcm" minOccurs="1" maxOccurs="1" />
                <xs:element ref="gcd" minOccurs="1" maxOccurs="1" />
                <xs:element ref="min" minOccurs="1" maxOccurs="1" />
                <xs:element ref="max" minOccurs="1" maxOccurs="1" />
                <xs:element ref="mathConstant" minOccurs="1" maxOccurs="1" />
                <xs:element ref="statsOperator" minOccurs="1" maxOccurs="1" />
                <xs:element ref="mathOperator" minOccurs="1" maxOccurs="1" />
            </xs:choice>
        </xs:sequence>
        <xs:attributeGroup ref="roundingMode.RoundTo.Attr" />
        <xs:attributeGroup ref="figures.RoundTo.Attr" />
    </xs:complexType>

    <xs:complexType name="RubricBlock.Type" abstract="false" mixed="true">
        <xs:annotation>
            <xs:documentation source="documentation">
                A rubric block identifies instructions to one or more of the actors that view the item or 
                set of items (as per a section). Although rubric blocks are defined as simpleBlocks they  
                must not contain interactions. The visibility of nested bodyElements or rubricBlocks is d-
                etermined by the outermost element. In other words, if an element is determined to be hid-
                den then all of its content is hidden including conditionally visible elements for which  
                the conditions are satisfied and that therefore would otherwise be visible.               
            </xs:documentation>
        </xs:annotation>
        <xs:sequence>
            <xs:choice minOccurs="0" maxOccurs="unbounded">
                <xs:choice minOccurs="1" maxOccurs="1">
                    <xs:element ref="pre" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="h1" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="h2" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="h3" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="h4" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="h5" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="h6" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="p" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="address" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="dl" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="ol" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="ul" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="br" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="hr" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="img" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="object" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="blockquote" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="em" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="a" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="code" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="span" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="sub" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="acronym" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="big" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="tt" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="kbd" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="q" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="i" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="dfn" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="abbr" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="strong" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="sup" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="var" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="small" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="samp" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="b" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="cite" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="table" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="div" minOccurs="1" maxOccurs="1" />
                </xs:choice>
                <xs:element ref="m:math" minOccurs="1" maxOccurs="1" />
                <xs:element ref="xi:include" minOccurs="1" maxOccurs="1" />
                <xs:element name="templateBlock" type="RubricBlockTemplateBlock.Type" minOccurs="1" maxOccurs="1"/>
                <xs:element name="templateInline" type="RubricBlockTemplateInline.Type" minOccurs="1" maxOccurs="1"/>
                <xs:element ref="printedVariable" minOccurs="1" maxOccurs="1" />
            </xs:choice>
            <xs:element ref="stylesheet" minOccurs="0" maxOccurs="unbounded" />
            <xs:element ref="apip:apipAccessibility" minOccurs="0" maxOccurs="1" />
        </xs:sequence>
        <xs:attributeGroup ref="id.RubricBlock.Attr" />
        <xs:attributeGroup ref="class.RubricBlock.Attr" />
        <xs:attributeGroup ref="use.RubricBlock.Attr" />
        <xs:attributeGroup ref="xmllang.RubricBlock.Attr" />
        <xs:attributeGroup ref="label.RubricBlock.Attr" />
        <xs:attributeGroup ref="xmlbase.RubricBlock.Attr" />
        <xs:attributeGroup ref="view.RubricBlock.Attr" />
    </xs:complexType>

    <xs:complexType name="RubricBlockTemplateBlock.Type" abstract="false" mixed="true">
        <xs:annotation>
            <xs:documentation source="documentation">
                A rubricBlock template block identifies content to be used in a template within a rubricB-
                lock. The visibility of nested bodyElements or templateBlocks is determined by the outerm-
                ost element. In other words, if an element is determined to be hidden then all of its con-
                tent is hidden including conditionally visible elements for which the conditions are sati-
                sfied and that therefore would otherwise be visible.                                      
            </xs:documentation>
        </xs:annotation>
        <xs:sequence>
            <xs:choice minOccurs="0" maxOccurs="unbounded">
                <xs:choice minOccurs="1" maxOccurs="1">
                    <xs:element ref="pre" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="h1" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="h2" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="h3" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="h4" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="h5" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="h6" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="p" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="address" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="dl" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="ol" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="ul" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="br" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="hr" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="img" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="object" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="blockquote" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="em" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="a" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="code" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="span" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="sub" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="acronym" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="big" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="tt" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="kbd" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="q" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="i" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="dfn" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="abbr" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="strong" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="sup" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="var" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="small" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="samp" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="b" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="cite" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="table" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="div" minOccurs="1" maxOccurs="1" />
                </xs:choice>
                <xs:element ref="m:math" minOccurs="1" maxOccurs="1" />
                <xs:element ref="xi:include" minOccurs="1" maxOccurs="1" />
                <xs:element name="templateBlock" type="RubricBlockTemplateBlock.Type" minOccurs="1" maxOccurs="1"/>
                <xs:element ref="printedVariable" minOccurs="1" maxOccurs="1" />
            </xs:choice>
            <xs:element ref="stylesheet" minOccurs="0" maxOccurs="unbounded" />
            <xs:element ref="apip:apipAccessibility" minOccurs="0" maxOccurs="1" />
        </xs:sequence>
        <xs:attributeGroup ref="xmlbase.RubricBlockTemplateBlock.Attr" />
        <xs:attributeGroup ref="id.RubricBlockTemplateBlock.Attr" />
        <xs:attributeGroup ref="class.RubricBlockTemplateBlock.Attr" />
        <xs:attributeGroup ref="xmllang.RubricBlockTemplateBlock.Attr" />
        <xs:attributeGroup ref="label.RubricBlockTemplateBlock.Attr" />
        <xs:attributeGroup ref="templateIdentifier.RubricBlockTemplateBlock.Attr" />
        <xs:attributeGroup ref="showHide.RubricBlockTemplateBlock.Attr" />
        <xs:attributeGroup ref="identifier.RubricBlockTemplateBlock.Attr" />
    </xs:complexType>

    <xs:complexType name="RubricBlockTemplateInline.Type" abstract="false" mixed="true">
        <xs:annotation>
            <xs:documentation source="documentation">
                The RubricBlockTemplateInline complexType is the container for inline objects (excluding  
                interactions) that are used to create a template layout within a rubricBlock.             
            </xs:documentation>
        </xs:annotation>
        <xs:sequence>
            <xs:choice minOccurs="0" maxOccurs="unbounded">
                <xs:choice minOccurs="1" maxOccurs="1">
                    <xs:element ref="img" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="br" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="object" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="em" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="a" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="code" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="span" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="sub" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="acronym" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="big" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="tt" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="kbd" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="q" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="i" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="dfn" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="abbr" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="strong" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="sup" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="var" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="small" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="samp" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="b" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="cite" minOccurs="1" maxOccurs="1" />
                </xs:choice>
                <xs:element ref="m:math" minOccurs="1" maxOccurs="1" />
                <xs:element ref="xi:include" minOccurs="1" maxOccurs="1" />
                <xs:element name="templateInline" type="RubricBlockTemplateInline.Type" minOccurs="1" maxOccurs="1"/>
                <xs:element ref="printedVariable" minOccurs="1" maxOccurs="1" />
            </xs:choice>
        </xs:sequence>
        <xs:attributeGroup ref="xmlbase.RubricBlockTemplateInline.Attr" />
        <xs:attributeGroup ref="id.RubricBlockTemplateInline.Attr" />
        <xs:attributeGroup ref="class.RubricBlockTemplateInline.Attr" />
        <xs:attributeGroup ref="xmllang.RubricBlockTemplateInline.Attr" />
        <xs:attributeGroup ref="label.RubricBlockTemplateInline.Attr" />
        <xs:attributeGroup ref="templateIdentifier.RubricBlockTemplateInline.Attr" />
        <xs:attributeGroup ref="showHide.RubricBlockTemplateInline.Attr" />
        <xs:attributeGroup ref="identifier.RubricBlockTemplateInline.Attr" />
    </xs:complexType>

    <xs:complexType name="Selection.Type" abstract="false" mixed="false">
        <xs:annotation>
            <xs:documentation source="documentation">
                This is the container for the selection rules to be applied when selecting the enclosed A-
                ssessmentSections and AssessmentItems. At present this is an open, namespaced, extension  
                point. Feedback on what proprietary features are used is welcomed.                        
            </xs:documentation>
        </xs:annotation>
        <xs:sequence>
            <xs:group ref="grpLax.any" />
        </xs:sequence>
        <xs:attributeGroup ref="select.Selection.Attr" />
        <xs:attributeGroup ref="withReplacement.Selection.Attr" />
        <xs:attributeGroup ref="extension.Selection.Attr" />
    </xs:complexType>

    <xs:complexType name="SelectPointInteraction.Type" abstract="false" mixed="false">
        <xs:annotation>
            <xs:documentation source="documentation">
                SelectPointInteraction is the complexType for select point QTI interactions. Like hotspot-
                Interaction, a select point interaction is a graphic interaction. The candidate's task is 
                to select one or more points. The associated response may have an areaMapping that scores 
                the response on the basis of comparing it against predefined areas but the delivery engine
                must not indicate these areas of the image. Only the actual point(s) selected by the cand-
                idate shall be indicated.                                                                 
            </xs:documentation>
        </xs:annotation>
        <xs:sequence>
            <xs:element ref="prompt" minOccurs="0" maxOccurs="1" />
            <xs:element ref="object" minOccurs="1" maxOccurs="1" />
        </xs:sequence>
        <xs:attributeGroup ref="xmlbase.SelectPointInteraction.Attr" />
        <xs:attributeGroup ref="id.SelectPointInteraction.Attr" />
        <xs:attributeGroup ref="class.SelectPointInteraction.Attr" />
        <xs:attributeGroup ref="xmllang.SelectPointInteraction.Attr" />
        <xs:attributeGroup ref="label.SelectPointInteraction.Attr" />
        <xs:attributeGroup ref="responseIdentifier.SelectPointInteraction.Attr" />
        <xs:attributeGroup ref="minChoices.SelectPointInteraction.Attr" />
        <xs:attributeGroup ref="maxChoices.SelectPointInteraction.Attr" />
    </xs:complexType>

    <xs:complexType name="SetValue.Type" abstract="false" mixed="false">
        <xs:annotation>
            <xs:documentation source="documentation">
                The SetValue complexType is the container for the value set for the associated element (t-
                he element is identified using the 'identifier' attribute).                               
            </xs:documentation>
        </xs:annotation>
        <xs:sequence>
            <xs:choice minOccurs="1" maxOccurs="1">
                <xs:element ref="and" minOccurs="1" maxOccurs="1" />
                <xs:element ref="gt" minOccurs="1" maxOccurs="1" />
                <xs:element ref="not" minOccurs="1" maxOccurs="1" />
                <xs:element ref="lt" minOccurs="1" maxOccurs="1" />
                <xs:element ref="gte" minOccurs="1" maxOccurs="1" />
                <xs:element ref="lte" minOccurs="1" maxOccurs="1" />
                <xs:element ref="or" minOccurs="1" maxOccurs="1" />
                <xs:element ref="sum" minOccurs="1" maxOccurs="1" />
                <xs:element ref="durationLT" minOccurs="1" maxOccurs="1" />
                <xs:element ref="durationGTE" minOccurs="1" maxOccurs="1" />
                <xs:element ref="subtract" minOccurs="1" maxOccurs="1" />
                <xs:element ref="divide" minOccurs="1" maxOccurs="1" />
                <xs:element ref="multiple" minOccurs="1" maxOccurs="1" />
                <xs:element ref="ordered" minOccurs="1" maxOccurs="1" />
                <xs:element ref="customOperator" minOccurs="1" maxOccurs="1" />
                <xs:element ref="random" minOccurs="1" maxOccurs="1" />
                <xs:element ref="numberIncorrect" minOccurs="1" maxOccurs="1" />
                <xs:element ref="numberCorrect" minOccurs="1" maxOccurs="1" />
                <xs:element ref="numberPresented" minOccurs="1" maxOccurs="1" />
                <xs:element ref="numberResponded" minOccurs="1" maxOccurs="1" />
                <xs:element ref="numberSelected" minOccurs="1" maxOccurs="1" />
                <xs:element ref="substring" minOccurs="1" maxOccurs="1" />
                <xs:element ref="equalRounded" minOccurs="1" maxOccurs="1" />
                <xs:element ref="null" minOccurs="1" maxOccurs="1" />
                <xs:element ref="delete" minOccurs="1" maxOccurs="1" />
                <xs:element ref="match" minOccurs="1" maxOccurs="1" />
                <xs:element ref="index" minOccurs="1" maxOccurs="1" />
                <xs:element ref="power" minOccurs="1" maxOccurs="1" />
                <xs:element ref="equal" minOccurs="1" maxOccurs="1" />
                <xs:element ref="contains" minOccurs="1" maxOccurs="1" />
                <xs:element ref="containerSize" minOccurs="1" maxOccurs="1" />
                <xs:element ref="correct" minOccurs="1" maxOccurs="1" />
                <xs:element ref="default" minOccurs="1" maxOccurs="1" />
                <xs:element ref="anyN" minOccurs="1" maxOccurs="1" />
                <xs:element ref="integerDivide" minOccurs="1" maxOccurs="1" />
                <xs:element ref="integerModulus" minOccurs="1" maxOccurs="1" />
                <xs:element ref="isNull" minOccurs="1" maxOccurs="1" />
                <xs:element ref="member" minOccurs="1" maxOccurs="1" />
                <xs:element ref="product" minOccurs="1" maxOccurs="1" />
                <xs:element ref="round" minOccurs="1" maxOccurs="1" />
                <xs:element ref="truncate" minOccurs="1" maxOccurs="1" />
                <xs:element ref="fieldValue" minOccurs="1" maxOccurs="1" />
                <xs:element ref="randomInteger" minOccurs="1" maxOccurs="1" />
                <xs:element ref="randomFloat" minOccurs="1" maxOccurs="1" />
                <xs:element ref="variable" minOccurs="1" maxOccurs="1" />
                <xs:element ref="outcomeMinimum" minOccurs="1" maxOccurs="1" />
                <xs:element ref="outcomeMaximum" minOccurs="1" maxOccurs="1" />
                <xs:element ref="testVariables" minOccurs="1" maxOccurs="1" />
                <xs:element ref="integerToFloat" minOccurs="1" maxOccurs="1" />
                <xs:element ref="inside" minOccurs="1" maxOccurs="1" />
                <xs:element ref="baseValue" minOccurs="1" maxOccurs="1" />
                <xs:element ref="patternMatch" minOccurs="1" maxOccurs="1" />
                <xs:element ref="mapResponsePoint" minOccurs="1" maxOccurs="1" />
                <xs:element ref="mapResponse" minOccurs="1" maxOccurs="1" />
                <xs:element ref="stringMatch" minOccurs="1" maxOccurs="1" />
                <xs:element ref="repeat" minOccurs="1" maxOccurs="1" />
                <xs:element ref="roundTo" minOccurs="1" maxOccurs="1" />
                <xs:element ref="lcm" minOccurs="1" maxOccurs="1" />
                <xs:element ref="gcd" minOccurs="1" maxOccurs="1" />
                <xs:element ref="min" minOccurs="1" maxOccurs="1" />
                <xs:element ref="max" minOccurs="1" maxOccurs="1" />
                <xs:element ref="mathConstant" minOccurs="1" maxOccurs="1" />
                <xs:element ref="statsOperator" minOccurs="1" maxOccurs="1" />
                <xs:element ref="mathOperator" minOccurs="1" maxOccurs="1" />
            </xs:choice>
        </xs:sequence>
        <xs:attributeGroup ref="identifier.SetValue.Attr" />
    </xs:complexType>

    <xs:complexType name="SimpleAssociableChoice.Type" abstract="false" mixed="true">
        <xs:annotation>
            <xs:documentation source="documentation">
                The SimpleAssociableChoice complexType is the container for the ordered set of choices for
                the match set.                                                                            
            </xs:documentation>
        </xs:annotation>
        <xs:sequence>
            <xs:choice minOccurs="0" maxOccurs="unbounded">
                <xs:element ref="printedVariable" minOccurs="1" maxOccurs="1" />
                <xs:element ref="feedbackBlock" minOccurs="1" maxOccurs="1" />
                <xs:element ref="feedbackInline" minOccurs="1" maxOccurs="1" />
                <xs:element ref="templateInline" minOccurs="1" maxOccurs="1" />
                <xs:element ref="templateBlock" minOccurs="1" maxOccurs="1" />
                <xs:element ref="m:math" minOccurs="1" maxOccurs="1" />
                <xs:element ref="xi:include" minOccurs="1" maxOccurs="1" />
                <xs:choice minOccurs="1" maxOccurs="1">
                    <xs:element ref="pre" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="h1" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="h2" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="h3" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="h4" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="h5" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="h6" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="p" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="address" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="dl" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="ol" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="ul" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="br" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="hr" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="img" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="object" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="blockquote" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="em" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="a" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="code" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="span" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="sub" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="acronym" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="big" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="tt" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="kbd" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="q" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="i" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="dfn" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="abbr" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="strong" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="sup" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="var" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="small" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="samp" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="b" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="cite" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="table" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="div" minOccurs="1" maxOccurs="1" />
                </xs:choice>
            </xs:choice>
        </xs:sequence>
        <xs:attributeGroup ref="id.SimpleAssociableChoice.Attr" />
        <xs:attributeGroup ref="class.SimpleAssociableChoice.Attr" />
        <xs:attributeGroup ref="xmllang.SimpleAssociableChoice.Attr" />
        <xs:attributeGroup ref="label.SimpleAssociableChoice.Attr" />
        <xs:attributeGroup ref="identifier.SimpleAssociableChoice.Attr" />
        <xs:attributeGroup ref="fixed.SimpleAssociableChoice.Attr" />
        <xs:attributeGroup ref="templateIdentifier.SimpleAssociableChoice.Attr" />
        <xs:attributeGroup ref="showHide.SimpleAssociableChoice.Attr" />
        <xs:attributeGroup ref="matchGroup.SimpleAssociableChoice.Attr" />
        <xs:attributeGroup ref="matchMax.SimpleAssociableChoice.Attr" />
        <xs:attributeGroup ref="matchMin.SimpleAssociableChoice.Attr" />
    </xs:complexType>

    <xs:complexType name="SimpleChoice.Type" abstract="false" mixed="true">
        <xs:annotation>
            <xs:documentation source="documentation">
                The SimpleChoice complexType is the container for the information that is to be presented 
                to a candidate as a possible answer to be selected i.e. in a multiple choice, true/false  
                types of questions.                                                                       
            </xs:documentation>
        </xs:annotation>
        <xs:sequence>
            <xs:choice minOccurs="0" maxOccurs="unbounded">
                <xs:element ref="printedVariable" minOccurs="1" maxOccurs="1" />
                <xs:element ref="feedbackBlock" minOccurs="1" maxOccurs="1" />
                <xs:element ref="feedbackInline" minOccurs="1" maxOccurs="1" />
                <xs:element ref="templateInline" minOccurs="1" maxOccurs="1" />
                <xs:element ref="templateBlock" minOccurs="1" maxOccurs="1" />
                <xs:element ref="m:math" minOccurs="1" maxOccurs="1" />
                <xs:element ref="xi:include" minOccurs="1" maxOccurs="1" />
                <xs:choice minOccurs="1" maxOccurs="1">
                    <xs:element ref="pre" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="h1" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="h2" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="h3" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="h4" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="h5" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="h6" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="p" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="address" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="dl" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="ol" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="ul" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="br" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="hr" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="img" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="object" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="blockquote" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="em" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="a" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="code" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="span" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="sub" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="acronym" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="big" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="tt" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="kbd" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="q" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="i" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="dfn" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="abbr" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="strong" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="sup" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="var" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="small" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="samp" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="b" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="cite" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="table" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="div" minOccurs="1" maxOccurs="1" />
                </xs:choice>
            </xs:choice>
        </xs:sequence>
        <xs:attributeGroup ref="id.SimpleChoice.Attr" />
        <xs:attributeGroup ref="class.SimpleChoice.Attr" />
        <xs:attributeGroup ref="xmllang.SimpleChoice.Attr" />
        <xs:attributeGroup ref="label.SimpleChoice.Attr" />
        <xs:attributeGroup ref="identifier.SimpleChoice.Attr" />
        <xs:attributeGroup ref="fixed.SimpleChoice.Attr" />
        <xs:attributeGroup ref="templateIdentifier.SimpleChoice.Attr" />
        <xs:attributeGroup ref="showHide.SimpleChoice.Attr" />
    </xs:complexType>

    <xs:complexType name="SimpleMatchSet.Type" abstract="false" mixed="false">
        <xs:annotation>
            <xs:documentation source="documentation">
                The SimpleMatchSet complexType is the container for the match set chocies. There are two  
                sets of choices: the first set defines the source choices and the second set the targets. 
            </xs:documentation>
        </xs:annotation>
        <xs:sequence>
            <xs:element ref="simpleAssociableChoice" minOccurs="0" maxOccurs="unbounded" />
        </xs:sequence>
    </xs:complexType>

    <xs:complexType name="SliderInteraction.Type" abstract="false" mixed="false">
        <xs:annotation>
            <xs:documentation source="documentation">
                The SliderInteraction complexType is the container for the information abourt a slider nt-
                eraction. The slider interaction presents the candidate with a control for selecting a nu-
                merical value between a lower and upper bound. It must be bound to a response variable wi-
                th single cardinality with a base-type of either integer or float.                        
            </xs:documentation>
        </xs:annotation>
        <xs:sequence>
            <xs:element ref="prompt" minOccurs="0" maxOccurs="1" />
        </xs:sequence>
        <xs:attributeGroup ref="xmlbase.SliderInteraction.Attr" />
        <xs:attributeGroup ref="id.SliderInteraction.Attr" />
        <xs:attributeGroup ref="class.SliderInteraction.Attr" />
        <xs:attributeGroup ref="xmllang.SliderInteraction.Attr" />
        <xs:attributeGroup ref="label.SliderInteraction.Attr" />
        <xs:attributeGroup ref="responseIdentifier.SliderInteraction.Attr" />
        <xs:attributeGroup ref="lowerBound.SliderInteraction.Attr" />
        <xs:attributeGroup ref="upperBound.SliderInteraction.Attr" />
        <xs:attributeGroup ref="step.SliderInteraction.Attr" />
        <xs:attributeGroup ref="stepLabel.SliderInteraction.Attr" />
        <xs:attributeGroup ref="orientation.SliderInteraction.Attr" />
        <xs:attributeGroup ref="reverse.SliderInteraction.Attr" />
    </xs:complexType>

    <xs:complexType name="StatsOperator.Type" abstract="false" mixed="false">
        <xs:annotation>
            <xs:documentation source="documentation">
                The statsOperator operator takes 1 sub-expression which is a container of multiple or ord-
                ered cardinality and has a numerical base-type. The result is a single float. If the sub--
                expression or any value contained therein is NULL, the result is NULL. If any value conta-
                ined in the sub-expression is not a numerical value, then the result is NULL.             
            </xs:documentation>
        </xs:annotation>
        <xs:sequence>
            <xs:choice minOccurs="1" maxOccurs="1">
                <xs:element ref="and" minOccurs="1" maxOccurs="1" />
                <xs:element ref="gt" minOccurs="1" maxOccurs="1" />
                <xs:element ref="not" minOccurs="1" maxOccurs="1" />
                <xs:element ref="lt" minOccurs="1" maxOccurs="1" />
                <xs:element ref="gte" minOccurs="1" maxOccurs="1" />
                <xs:element ref="lte" minOccurs="1" maxOccurs="1" />
                <xs:element ref="or" minOccurs="1" maxOccurs="1" />
                <xs:element ref="sum" minOccurs="1" maxOccurs="1" />
                <xs:element ref="durationLT" minOccurs="1" maxOccurs="1" />
                <xs:element ref="durationGTE" minOccurs="1" maxOccurs="1" />
                <xs:element ref="subtract" minOccurs="1" maxOccurs="1" />
                <xs:element ref="divide" minOccurs="1" maxOccurs="1" />
                <xs:element ref="multiple" minOccurs="1" maxOccurs="1" />
                <xs:element ref="ordered" minOccurs="1" maxOccurs="1" />
                <xs:element ref="customOperator" minOccurs="1" maxOccurs="1" />
                <xs:element ref="random" minOccurs="1" maxOccurs="1" />
                <xs:element ref="numberIncorrect" minOccurs="1" maxOccurs="1" />
                <xs:element ref="numberCorrect" minOccurs="1" maxOccurs="1" />
                <xs:element ref="numberPresented" minOccurs="1" maxOccurs="1" />
                <xs:element ref="numberResponded" minOccurs="1" maxOccurs="1" />
                <xs:element ref="numberSelected" minOccurs="1" maxOccurs="1" />
                <xs:element ref="substring" minOccurs="1" maxOccurs="1" />
                <xs:element ref="equalRounded" minOccurs="1" maxOccurs="1" />
                <xs:element ref="null" minOccurs="1" maxOccurs="1" />
                <xs:element ref="delete" minOccurs="1" maxOccurs="1" />
                <xs:element ref="match" minOccurs="1" maxOccurs="1" />
                <xs:element ref="index" minOccurs="1" maxOccurs="1" />
                <xs:element ref="power" minOccurs="1" maxOccurs="1" />
                <xs:element ref="equal" minOccurs="1" maxOccurs="1" />
                <xs:element ref="contains" minOccurs="1" maxOccurs="1" />
                <xs:element ref="containerSize" minOccurs="1" maxOccurs="1" />
                <xs:element ref="correct" minOccurs="1" maxOccurs="1" />
                <xs:element ref="default" minOccurs="1" maxOccurs="1" />
                <xs:element ref="anyN" minOccurs="1" maxOccurs="1" />
                <xs:element ref="integerDivide" minOccurs="1" maxOccurs="1" />
                <xs:element ref="integerModulus" minOccurs="1" maxOccurs="1" />
                <xs:element ref="isNull" minOccurs="1" maxOccurs="1" />
                <xs:element ref="member" minOccurs="1" maxOccurs="1" />
                <xs:element ref="product" minOccurs="1" maxOccurs="1" />
                <xs:element ref="round" minOccurs="1" maxOccurs="1" />
                <xs:element ref="truncate" minOccurs="1" maxOccurs="1" />
                <xs:element ref="fieldValue" minOccurs="1" maxOccurs="1" />
                <xs:element ref="randomInteger" minOccurs="1" maxOccurs="1" />
                <xs:element ref="randomFloat" minOccurs="1" maxOccurs="1" />
                <xs:element ref="variable" minOccurs="1" maxOccurs="1" />
                <xs:element ref="outcomeMinimum" minOccurs="1" maxOccurs="1" />
                <xs:element ref="outcomeMaximum" minOccurs="1" maxOccurs="1" />
                <xs:element ref="testVariables" minOccurs="1" maxOccurs="1" />
                <xs:element ref="integerToFloat" minOccurs="1" maxOccurs="1" />
                <xs:element ref="inside" minOccurs="1" maxOccurs="1" />
                <xs:element ref="baseValue" minOccurs="1" maxOccurs="1" />
                <xs:element ref="patternMatch" minOccurs="1" maxOccurs="1" />
                <xs:element ref="mapResponsePoint" minOccurs="1" maxOccurs="1" />
                <xs:element ref="mapResponse" minOccurs="1" maxOccurs="1" />
                <xs:element ref="stringMatch" minOccurs="1" maxOccurs="1" />
                <xs:element ref="repeat" minOccurs="1" maxOccurs="1" />
                <xs:element ref="roundTo" minOccurs="1" maxOccurs="1" />
                <xs:element ref="lcm" minOccurs="1" maxOccurs="1" />
                <xs:element ref="gcd" minOccurs="1" maxOccurs="1" />
                <xs:element ref="min" minOccurs="1" maxOccurs="1" />
                <xs:element ref="max" minOccurs="1" maxOccurs="1" />
                <xs:element ref="mathConstant" minOccurs="1" maxOccurs="1" />
                <xs:element ref="statsOperator" minOccurs="1" maxOccurs="1" />
                <xs:element ref="mathOperator" minOccurs="1" maxOccurs="1" />
            </xs:choice>
        </xs:sequence>
        <xs:attributeGroup ref="name.StatsOperator.Attr" />
    </xs:complexType>

    <xs:complexType name="StringMatch.Type" abstract="false" mixed="false">
        <xs:annotation>
            <xs:documentation source="documentation">
                The stringMatch operator takes two sub-expressions which must have single and a base-type 
                of string. The result is a single boolean with a value of true if the two strings match a-
                ccording to the comparison rules defined by the attributes below and false if they don't. 
                If either sub-expression is NULL then the operator results in NULL.                       
            </xs:documentation>
        </xs:annotation>
        <xs:sequence>
            <xs:choice minOccurs="2" maxOccurs="2">
                <xs:element ref="and" minOccurs="1" maxOccurs="1" />
                <xs:element ref="gt" minOccurs="1" maxOccurs="1" />
                <xs:element ref="not" minOccurs="1" maxOccurs="1" />
                <xs:element ref="lt" minOccurs="1" maxOccurs="1" />
                <xs:element ref="gte" minOccurs="1" maxOccurs="1" />
                <xs:element ref="lte" minOccurs="1" maxOccurs="1" />
                <xs:element ref="or" minOccurs="1" maxOccurs="1" />
                <xs:element ref="sum" minOccurs="1" maxOccurs="1" />
                <xs:element ref="durationLT" minOccurs="1" maxOccurs="1" />
                <xs:element ref="durationGTE" minOccurs="1" maxOccurs="1" />
                <xs:element ref="subtract" minOccurs="1" maxOccurs="1" />
                <xs:element ref="divide" minOccurs="1" maxOccurs="1" />
                <xs:element ref="multiple" minOccurs="1" maxOccurs="1" />
                <xs:element ref="ordered" minOccurs="1" maxOccurs="1" />
                <xs:element ref="customOperator" minOccurs="1" maxOccurs="1" />
                <xs:element ref="random" minOccurs="1" maxOccurs="1" />
                <xs:element ref="numberIncorrect" minOccurs="1" maxOccurs="1" />
                <xs:element ref="numberCorrect" minOccurs="1" maxOccurs="1" />
                <xs:element ref="numberPresented" minOccurs="1" maxOccurs="1" />
                <xs:element ref="numberResponded" minOccurs="1" maxOccurs="1" />
                <xs:element ref="numberSelected" minOccurs="1" maxOccurs="1" />
                <xs:element ref="substring" minOccurs="1" maxOccurs="1" />
                <xs:element ref="equalRounded" minOccurs="1" maxOccurs="1" />
                <xs:element ref="null" minOccurs="1" maxOccurs="1" />
                <xs:element ref="delete" minOccurs="1" maxOccurs="1" />
                <xs:element ref="match" minOccurs="1" maxOccurs="1" />
                <xs:element ref="index" minOccurs="1" maxOccurs="1" />
                <xs:element ref="power" minOccurs="1" maxOccurs="1" />
                <xs:element ref="equal" minOccurs="1" maxOccurs="1" />
                <xs:element ref="contains" minOccurs="1" maxOccurs="1" />
                <xs:element ref="containerSize" minOccurs="1" maxOccurs="1" />
                <xs:element ref="correct" minOccurs="1" maxOccurs="1" />
                <xs:element ref="default" minOccurs="1" maxOccurs="1" />
                <xs:element ref="anyN" minOccurs="1" maxOccurs="1" />
                <xs:element ref="integerDivide" minOccurs="1" maxOccurs="1" />
                <xs:element ref="integerModulus" minOccurs="1" maxOccurs="1" />
                <xs:element ref="isNull" minOccurs="1" maxOccurs="1" />
                <xs:element ref="member" minOccurs="1" maxOccurs="1" />
                <xs:element ref="product" minOccurs="1" maxOccurs="1" />
                <xs:element ref="round" minOccurs="1" maxOccurs="1" />
                <xs:element ref="truncate" minOccurs="1" maxOccurs="1" />
                <xs:element ref="fieldValue" minOccurs="1" maxOccurs="1" />
                <xs:element ref="randomInteger" minOccurs="1" maxOccurs="1" />
                <xs:element ref="randomFloat" minOccurs="1" maxOccurs="1" />
                <xs:element ref="variable" minOccurs="1" maxOccurs="1" />
                <xs:element ref="outcomeMinimum" minOccurs="1" maxOccurs="1" />
                <xs:element ref="outcomeMaximum" minOccurs="1" maxOccurs="1" />
                <xs:element ref="testVariables" minOccurs="1" maxOccurs="1" />
                <xs:element ref="integerToFloat" minOccurs="1" maxOccurs="1" />
                <xs:element ref="inside" minOccurs="1" maxOccurs="1" />
                <xs:element ref="baseValue" minOccurs="1" maxOccurs="1" />
                <xs:element ref="patternMatch" minOccurs="1" maxOccurs="1" />
                <xs:element ref="mapResponsePoint" minOccurs="1" maxOccurs="1" />
                <xs:element ref="mapResponse" minOccurs="1" maxOccurs="1" />
                <xs:element ref="stringMatch" minOccurs="1" maxOccurs="1" />
                <xs:element ref="repeat" minOccurs="1" maxOccurs="1" />
                <xs:element ref="roundTo" minOccurs="1" maxOccurs="1" />
                <xs:element ref="lcm" minOccurs="1" maxOccurs="1" />
                <xs:element ref="gcd" minOccurs="1" maxOccurs="1" />
                <xs:element ref="min" minOccurs="1" maxOccurs="1" />
                <xs:element ref="max" minOccurs="1" maxOccurs="1" />
                <xs:element ref="mathConstant" minOccurs="1" maxOccurs="1" />
                <xs:element ref="statsOperator" minOccurs="1" maxOccurs="1" />
                <xs:element ref="mathOperator" minOccurs="1" maxOccurs="1" />
            </xs:choice>
        </xs:sequence>
        <xs:attributeGroup ref="caseSensitive.StringMatch.Attr" />
        <xs:attributeGroup ref="substring.StringMatch.Attr" />
    </xs:complexType>

    <xs:complexType name="Substring.Type" abstract="false" mixed="false">
        <xs:annotation>
            <xs:documentation source="documentation">
                The substring operator takes two sub-expressions which must both have an effective base-t-
                ype of string and single cardinality. The result is a single boolean with a value of true 
                if the first expression is a substring of the second expression and false if it isn't. If 
                either sub-expression is NULL then the result of the operator is NULL.                    
            </xs:documentation>
        </xs:annotation>
        <xs:sequence>
            <xs:choice minOccurs="2" maxOccurs="2">
                <xs:element ref="and" minOccurs="1" maxOccurs="1" />
                <xs:element ref="gt" minOccurs="1" maxOccurs="1" />
                <xs:element ref="not" minOccurs="1" maxOccurs="1" />
                <xs:element ref="lt" minOccurs="1" maxOccurs="1" />
                <xs:element ref="gte" minOccurs="1" maxOccurs="1" />
                <xs:element ref="lte" minOccurs="1" maxOccurs="1" />
                <xs:element ref="or" minOccurs="1" maxOccurs="1" />
                <xs:element ref="sum" minOccurs="1" maxOccurs="1" />
                <xs:element ref="durationLT" minOccurs="1" maxOccurs="1" />
                <xs:element ref="durationGTE" minOccurs="1" maxOccurs="1" />
                <xs:element ref="subtract" minOccurs="1" maxOccurs="1" />
                <xs:element ref="divide" minOccurs="1" maxOccurs="1" />
                <xs:element ref="multiple" minOccurs="1" maxOccurs="1" />
                <xs:element ref="ordered" minOccurs="1" maxOccurs="1" />
                <xs:element ref="customOperator" minOccurs="1" maxOccurs="1" />
                <xs:element ref="random" minOccurs="1" maxOccurs="1" />
                <xs:element ref="numberIncorrect" minOccurs="1" maxOccurs="1" />
                <xs:element ref="numberCorrect" minOccurs="1" maxOccurs="1" />
                <xs:element ref="numberPresented" minOccurs="1" maxOccurs="1" />
                <xs:element ref="numberResponded" minOccurs="1" maxOccurs="1" />
                <xs:element ref="numberSelected" minOccurs="1" maxOccurs="1" />
                <xs:element ref="substring" minOccurs="1" maxOccurs="1" />
                <xs:element ref="equalRounded" minOccurs="1" maxOccurs="1" />
                <xs:element ref="null" minOccurs="1" maxOccurs="1" />
                <xs:element ref="delete" minOccurs="1" maxOccurs="1" />
                <xs:element ref="match" minOccurs="1" maxOccurs="1" />
                <xs:element ref="index" minOccurs="1" maxOccurs="1" />
                <xs:element ref="power" minOccurs="1" maxOccurs="1" />
                <xs:element ref="equal" minOccurs="1" maxOccurs="1" />
                <xs:element ref="contains" minOccurs="1" maxOccurs="1" />
                <xs:element ref="containerSize" minOccurs="1" maxOccurs="1" />
                <xs:element ref="correct" minOccurs="1" maxOccurs="1" />
                <xs:element ref="default" minOccurs="1" maxOccurs="1" />
                <xs:element ref="anyN" minOccurs="1" maxOccurs="1" />
                <xs:element ref="integerDivide" minOccurs="1" maxOccurs="1" />
                <xs:element ref="integerModulus" minOccurs="1" maxOccurs="1" />
                <xs:element ref="isNull" minOccurs="1" maxOccurs="1" />
                <xs:element ref="member" minOccurs="1" maxOccurs="1" />
                <xs:element ref="product" minOccurs="1" maxOccurs="1" />
                <xs:element ref="round" minOccurs="1" maxOccurs="1" />
                <xs:element ref="truncate" minOccurs="1" maxOccurs="1" />
                <xs:element ref="fieldValue" minOccurs="1" maxOccurs="1" />
                <xs:element ref="randomInteger" minOccurs="1" maxOccurs="1" />
                <xs:element ref="randomFloat" minOccurs="1" maxOccurs="1" />
                <xs:element ref="variable" minOccurs="1" maxOccurs="1" />
                <xs:element ref="outcomeMinimum" minOccurs="1" maxOccurs="1" />
                <xs:element ref="outcomeMaximum" minOccurs="1" maxOccurs="1" />
                <xs:element ref="testVariables" minOccurs="1" maxOccurs="1" />
                <xs:element ref="integerToFloat" minOccurs="1" maxOccurs="1" />
                <xs:element ref="inside" minOccurs="1" maxOccurs="1" />
                <xs:element ref="baseValue" minOccurs="1" maxOccurs="1" />
                <xs:element ref="patternMatch" minOccurs="1" maxOccurs="1" />
                <xs:element ref="mapResponsePoint" minOccurs="1" maxOccurs="1" />
                <xs:element ref="mapResponse" minOccurs="1" maxOccurs="1" />
                <xs:element ref="stringMatch" minOccurs="1" maxOccurs="1" />
                <xs:element ref="repeat" minOccurs="1" maxOccurs="1" />
                <xs:element ref="roundTo" minOccurs="1" maxOccurs="1" />
                <xs:element ref="lcm" minOccurs="1" maxOccurs="1" />
                <xs:element ref="gcd" minOccurs="1" maxOccurs="1" />
                <xs:element ref="min" minOccurs="1" maxOccurs="1" />
                <xs:element ref="max" minOccurs="1" maxOccurs="1" />
                <xs:element ref="mathConstant" minOccurs="1" maxOccurs="1" />
                <xs:element ref="statsOperator" minOccurs="1" maxOccurs="1" />
                <xs:element ref="mathOperator" minOccurs="1" maxOccurs="1" />
            </xs:choice>
        </xs:sequence>
        <xs:attributeGroup ref="caseSensitive.Substring.Attr" />
    </xs:complexType>

    <xs:complexType name="Table.Type" abstract="false" mixed="false">
        <xs:annotation>
            <xs:documentation source="documentation">
                The 'Table' complexType is the container for content that is equivalent to the HTML 'tabl-
                e' markup.                                                                                
            </xs:documentation>
        </xs:annotation>
        <xs:sequence>
            <xs:element ref="caption" minOccurs="0" maxOccurs="1" />
            <xs:element ref="col" minOccurs="0" maxOccurs="unbounded" />
            <xs:element ref="colgroup" minOccurs="0" maxOccurs="unbounded" />
            <xs:element ref="thead" minOccurs="0" maxOccurs="1" />
            <xs:element ref="tfoot" minOccurs="0" maxOccurs="1" />
            <xs:element ref="tbody" minOccurs="1" maxOccurs="unbounded" />
        </xs:sequence>
        <xs:attributeGroup ref="id.Table.Attr" />
        <xs:attributeGroup ref="class.Table.Attr" />
        <xs:attributeGroup ref="xmllang.Table.Attr" />
        <xs:attributeGroup ref="label.Table.Attr" />
        <xs:attributeGroup ref="xmlbase.Table.Attr" />
        <xs:attributeGroup ref="summary.Table.Attr" />
    </xs:complexType>

    <xs:complexType name="TablePart.Type" abstract="false" mixed="false">
        <xs:annotation>
            <xs:documentation source="documentation">
                The TablePart complexType is the container for set of table row content that is used to t-
                he support content within a table.                                                        
            </xs:documentation>
        </xs:annotation>
        <xs:sequence>
            <xs:element ref="tr" minOccurs="1" maxOccurs="unbounded" />
        </xs:sequence>
        <xs:attributeGroup ref="id.TablePart.Attr" />
        <xs:attributeGroup ref="class.TablePart.Attr" />
        <xs:attributeGroup ref="xmllang.TablePart.Attr" />
        <xs:attributeGroup ref="label.TablePart.Attr" />
    </xs:complexType>

    <xs:complexType name="TDH.Type" abstract="false" mixed="true">
        <xs:annotation>
            <xs:documentation source="documentation">
                The 'TDH' complexType is the container for content that is equivalent to the HTML 'td' and
                'th' markup within a table.                                                               
            </xs:documentation>
        </xs:annotation>
        <xs:sequence>
            <xs:choice minOccurs="0" maxOccurs="unbounded">
                <xs:element ref="printedVariable" minOccurs="1" maxOccurs="1" />
                <xs:element ref="feedbackBlock" minOccurs="1" maxOccurs="1" />
                <xs:element ref="hottext" minOccurs="1" maxOccurs="1" />
                <xs:element ref="feedbackInline" minOccurs="1" maxOccurs="1" />
                <xs:element ref="templateInline" minOccurs="1" maxOccurs="1" />
                <xs:element ref="templateBlock" minOccurs="1" maxOccurs="1" />
                <xs:element ref="m:math" minOccurs="1" maxOccurs="1" />
                <xs:element ref="xi:include" minOccurs="1" maxOccurs="1" />
                <xs:element ref="textEntryInteraction" minOccurs="1" maxOccurs="1" />
                <xs:element ref="inlineChoiceInteraction" minOccurs="1" maxOccurs="1" />
                <xs:element ref="endAttemptInteraction" minOccurs="1" maxOccurs="1" />
                <xs:element ref="customInteraction" minOccurs="1" maxOccurs="1" />
                <xs:element ref="drawingInteraction" minOccurs="1" maxOccurs="1" />
                <xs:element ref="gapMatchInteraction" minOccurs="1" maxOccurs="1" />
                <xs:element ref="matchInteraction" minOccurs="1" maxOccurs="1" />
                <xs:element ref="graphicGapMatchInteraction" minOccurs="1" maxOccurs="1" />
                <xs:element ref="hotspotInteraction" minOccurs="1" maxOccurs="1" />
                <xs:element ref="graphicOrderInteraction" minOccurs="1" maxOccurs="1" />
                <xs:element ref="selectPointInteraction" minOccurs="1" maxOccurs="1" />
                <xs:element ref="graphicAssociateInteraction" minOccurs="1" maxOccurs="1" />
                <xs:element ref="sliderInteraction" minOccurs="1" maxOccurs="1" />
                <xs:element ref="choiceInteraction" minOccurs="1" maxOccurs="1" />
                <xs:element ref="mediaInteraction" minOccurs="1" maxOccurs="1" />
                <xs:element ref="hottextInteraction" minOccurs="1" maxOccurs="1" />
                <xs:element ref="orderInteraction" minOccurs="1" maxOccurs="1" />
                <xs:element ref="extendedTextInteraction" minOccurs="1" maxOccurs="1" />
                <xs:element ref="uploadInteraction" minOccurs="1" maxOccurs="1" />
                <xs:element ref="associateInteraction" minOccurs="1" maxOccurs="1" />
                <xs:choice minOccurs="1" maxOccurs="1">
                    <xs:element ref="pre" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="h1" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="h2" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="h3" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="h4" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="h5" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="h6" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="p" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="address" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="dl" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="ol" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="ul" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="br" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="hr" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="img" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="object" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="blockquote" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="em" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="a" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="code" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="span" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="sub" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="acronym" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="big" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="tt" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="kbd" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="q" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="i" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="dfn" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="abbr" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="strong" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="sup" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="var" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="small" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="samp" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="b" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="cite" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="table" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="div" minOccurs="1" maxOccurs="1" />
                </xs:choice>
            </xs:choice>
        </xs:sequence>
        <xs:attributeGroup ref="id.TDH.Attr" />
        <xs:attributeGroup ref="class.TDH.Attr" />
        <xs:attributeGroup ref="xmllang.TDH.Attr" />
        <xs:attributeGroup ref="label.TDH.Attr" />
        <xs:attributeGroup ref="headers.TDH.Attr" />
        <xs:attributeGroup ref="scope.TDH.Attr" />
        <xs:attributeGroup ref="abbr.TDH.Attr" />
        <xs:attributeGroup ref="axis.TDH.Attr" />
        <xs:attributeGroup ref="rowspan.TDH.Attr" />
        <xs:attributeGroup ref="colspan.TDH.Attr" />
        <xs:attributeGroup ref="align.TDH.Attr" />
        <xs:attributeGroup ref="valign.TDH.Attr" />
    </xs:complexType>

    <xs:complexType name="TemplateBlock.Type" abstract="false" mixed="true">
        <xs:annotation>
            <xs:documentation source="documentation">
                A template block identifies content to be used in a template. The visibility of nested bo-
                dyElements or templateBlocks is determined by the outermost element. In other words, if an
                element is determined to be hidden then all of its content is hidden including conditiona-
                lly visible elements for which the conditions are satisfied and that therefore would othe-
                rwise be visible.                                                                         
            </xs:documentation>
        </xs:annotation>
        <xs:sequence>
            <xs:choice minOccurs="0" maxOccurs="unbounded">
                <xs:choice minOccurs="1" maxOccurs="1">
                    <xs:element ref="pre" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="h1" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="h2" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="h3" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="h4" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="h5" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="h6" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="p" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="address" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="dl" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="ol" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="ul" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="br" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="hr" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="img" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="object" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="blockquote" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="em" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="a" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="code" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="span" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="sub" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="acronym" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="big" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="tt" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="kbd" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="q" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="i" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="dfn" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="abbr" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="strong" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="sup" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="var" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="small" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="samp" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="b" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="cite" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="table" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="div" minOccurs="1" maxOccurs="1" />
                </xs:choice>
                <xs:element ref="m:math" minOccurs="1" maxOccurs="1" />
                <xs:element ref="xi:include" minOccurs="1" maxOccurs="1" />
                <xs:element name="templateBlock" type="TemplateBlock.Type" minOccurs="1" maxOccurs="1"/>
                <xs:element name="templateInline" type="TemplateInline.Type" minOccurs="1" maxOccurs="1"/>
                <xs:element name="feedbackBlock" type="TemplateBlockFeedbackBlock.Type" minOccurs="1" maxOccurs="1"/>
                <xs:element name="feedbackInline" type="FeedbackInline.Type" minOccurs="1" maxOccurs="1"/>
                <xs:element ref="printedVariable" minOccurs="1" maxOccurs="1" />
            </xs:choice>
            <xs:element ref="stylesheet" minOccurs="0" maxOccurs="unbounded" />
            <xs:element ref="apip:apipAccessibility" minOccurs="0" maxOccurs="1" />
        </xs:sequence>
        <xs:attributeGroup ref="xmlbase.TemplateBlock.Attr" />
        <xs:attributeGroup ref="id.TemplateBlock.Attr" />
        <xs:attributeGroup ref="class.TemplateBlock.Attr" />
        <xs:attributeGroup ref="xmllang.TemplateBlock.Attr" />
        <xs:attributeGroup ref="label.TemplateBlock.Attr" />
        <xs:attributeGroup ref="templateIdentifier.TemplateBlock.Attr" />
        <xs:attributeGroup ref="showHide.TemplateBlock.Attr" />
        <xs:attributeGroup ref="identifier.TemplateBlock.Attr" />
    </xs:complexType>

    <xs:complexType name="TemplateBlockFeedbackBlock.Type" abstract="false" mixed="true">
        <xs:annotation>
            <xs:documentation source="documentation">
                The TemplateBlockFeedbackBlock complexType is the container for block-based feedback used 
                within a templateBlock.                                                                   
            </xs:documentation>
        </xs:annotation>
        <xs:sequence>
            <xs:choice minOccurs="0" maxOccurs="unbounded">
                <xs:choice minOccurs="1" maxOccurs="1">
                    <xs:element ref="pre" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="h1" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="h2" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="h3" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="h4" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="h5" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="h6" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="p" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="address" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="dl" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="ol" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="ul" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="br" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="hr" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="img" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="object" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="blockquote" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="em" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="a" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="code" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="span" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="sub" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="acronym" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="big" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="tt" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="kbd" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="q" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="i" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="dfn" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="abbr" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="strong" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="sup" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="var" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="small" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="samp" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="b" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="cite" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="table" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="div" minOccurs="1" maxOccurs="1" />
                </xs:choice>
                <xs:element ref="m:math" minOccurs="1" maxOccurs="1" />
                <xs:element ref="xi:include" minOccurs="1" maxOccurs="1" />
                <xs:element name="templateBlock" type="TemplateBlock.Type" minOccurs="1" maxOccurs="1"/>
                <xs:element name="templateInline" type="TemplateInline.Type" minOccurs="1" maxOccurs="1"/>
                <xs:element name="feedbackBlock" type="TemplateBlockFeedbackBlock.Type" minOccurs="1" maxOccurs="1"/>
                <xs:element name="feedbackInline" type="FeedbackInline.Type" minOccurs="1" maxOccurs="1"/>
                <xs:element ref="printedVariable" minOccurs="1" maxOccurs="1" />
            </xs:choice>
            <xs:element ref="stylesheet" minOccurs="0" maxOccurs="unbounded" />
            <xs:element ref="apip:apipAccessibility" minOccurs="0" maxOccurs="1" />
        </xs:sequence>
        <xs:attributeGroup ref="outcomeIdentifier.TemplateBlockFeedbackBlock.Attr" />
        <xs:attributeGroup ref="showHide.TemplateBlockFeedbackBlock.Attr" />
        <xs:attributeGroup ref="identifier.TemplateBlockFeedbackBlock.Attr" />
        <xs:attributeGroup ref="id.TemplateBlockFeedbackBlock.Attr" />
        <xs:attributeGroup ref="class.TemplateBlockFeedbackBlock.Attr" />
        <xs:attributeGroup ref="xmllang.TemplateBlockFeedbackBlock.Attr" />
        <xs:attributeGroup ref="label.TemplateBlockFeedbackBlock.Attr" />
        <xs:attributeGroup ref="xmlbase.TemplateBlockFeedbackBlock.Attr" />
    </xs:complexType>

    <xs:complexType name="TemplateCondition.Type" abstract="false" mixed="false">
        <xs:annotation>
            <xs:documentation source="documentation">
                The TemplateCondition complexType is the container for the definition of the 'If..Then..E-
                lse/ElseIf' rule construction. If the expression given in the templateIf or templateElseIf
                evaluates to true then the sub-rules contained within it are followed and any following t-
                emplateElseIf or templateElse parts are ignored for this template condition. If the expre-
                ssion given in the templateIf or templateElseIf does not evaluate to true then considerat-
                ion passes to the next templateElseIf or, if there are no more templateElseIf parts then  
                the sub-rules of the templateElse are followed (if specified).                            
            </xs:documentation>
        </xs:annotation>
        <xs:sequence>
            <xs:element ref="templateIf" minOccurs="1" maxOccurs="1" />
            <xs:element ref="templateElseIf" minOccurs="0" maxOccurs="unbounded" />
            <xs:element ref="templateElse" minOccurs="0" maxOccurs="1" />
        </xs:sequence>
    </xs:complexType>

    <xs:complexType name="TemplateConstraint.Type" abstract="false" mixed="false">
        <xs:annotation>
            <xs:documentation source="documentation">
                The TemplateConstraint complexType is the container for the constraints to be applied to a
                templateRule. A templateConstraint determines constraints on the binding of variables in  
                the contained expression. The expression must have an effective baseType of boolean and s-
                ingle cardinality. At the runtime the template variables must be instantiated according to
                these constraints. Implementors need to be aware that some configurations of templateCons-
                traint can cause an infinite loop. For that reason, the minimum supported maximum number  
                of templateConstraint iterations is 100.                                                  
            </xs:documentation>
        </xs:annotation>
        <xs:sequence>
            <xs:choice minOccurs="1" maxOccurs="1">
                <xs:element ref="and" minOccurs="1" maxOccurs="1" />
                <xs:element ref="gt" minOccurs="1" maxOccurs="1" />
                <xs:element ref="not" minOccurs="1" maxOccurs="1" />
                <xs:element ref="lt" minOccurs="1" maxOccurs="1" />
                <xs:element ref="gte" minOccurs="1" maxOccurs="1" />
                <xs:element ref="lte" minOccurs="1" maxOccurs="1" />
                <xs:element ref="or" minOccurs="1" maxOccurs="1" />
                <xs:element ref="sum" minOccurs="1" maxOccurs="1" />
                <xs:element ref="durationLT" minOccurs="1" maxOccurs="1" />
                <xs:element ref="durationGTE" minOccurs="1" maxOccurs="1" />
                <xs:element ref="subtract" minOccurs="1" maxOccurs="1" />
                <xs:element ref="divide" minOccurs="1" maxOccurs="1" />
                <xs:element ref="multiple" minOccurs="1" maxOccurs="1" />
                <xs:element ref="ordered" minOccurs="1" maxOccurs="1" />
                <xs:element ref="customOperator" minOccurs="1" maxOccurs="1" />
                <xs:element ref="random" minOccurs="1" maxOccurs="1" />
                <xs:element ref="numberIncorrect" minOccurs="1" maxOccurs="1" />
                <xs:element ref="numberCorrect" minOccurs="1" maxOccurs="1" />
                <xs:element ref="numberPresented" minOccurs="1" maxOccurs="1" />
                <xs:element ref="numberResponded" minOccurs="1" maxOccurs="1" />
                <xs:element ref="numberSelected" minOccurs="1" maxOccurs="1" />
                <xs:element ref="substring" minOccurs="1" maxOccurs="1" />
                <xs:element ref="equalRounded" minOccurs="1" maxOccurs="1" />
                <xs:element ref="null" minOccurs="1" maxOccurs="1" />
                <xs:element ref="delete" minOccurs="1" maxOccurs="1" />
                <xs:element ref="match" minOccurs="1" maxOccurs="1" />
                <xs:element ref="index" minOccurs="1" maxOccurs="1" />
                <xs:element ref="power" minOccurs="1" maxOccurs="1" />
                <xs:element ref="equal" minOccurs="1" maxOccurs="1" />
                <xs:element ref="contains" minOccurs="1" maxOccurs="1" />
                <xs:element ref="containerSize" minOccurs="1" maxOccurs="1" />
                <xs:element ref="correct" minOccurs="1" maxOccurs="1" />
                <xs:element ref="default" minOccurs="1" maxOccurs="1" />
                <xs:element ref="anyN" minOccurs="1" maxOccurs="1" />
                <xs:element ref="integerDivide" minOccurs="1" maxOccurs="1" />
                <xs:element ref="integerModulus" minOccurs="1" maxOccurs="1" />
                <xs:element ref="isNull" minOccurs="1" maxOccurs="1" />
                <xs:element ref="member" minOccurs="1" maxOccurs="1" />
                <xs:element ref="product" minOccurs="1" maxOccurs="1" />
                <xs:element ref="round" minOccurs="1" maxOccurs="1" />
                <xs:element ref="truncate" minOccurs="1" maxOccurs="1" />
                <xs:element ref="fieldValue" minOccurs="1" maxOccurs="1" />
                <xs:element ref="randomInteger" minOccurs="1" maxOccurs="1" />
                <xs:element ref="randomFloat" minOccurs="1" maxOccurs="1" />
                <xs:element ref="variable" minOccurs="1" maxOccurs="1" />
                <xs:element ref="outcomeMinimum" minOccurs="1" maxOccurs="1" />
                <xs:element ref="outcomeMaximum" minOccurs="1" maxOccurs="1" />
                <xs:element ref="testVariables" minOccurs="1" maxOccurs="1" />
                <xs:element ref="integerToFloat" minOccurs="1" maxOccurs="1" />
                <xs:element ref="inside" minOccurs="1" maxOccurs="1" />
                <xs:element ref="baseValue" minOccurs="1" maxOccurs="1" />
                <xs:element ref="patternMatch" minOccurs="1" maxOccurs="1" />
                <xs:element ref="mapResponsePoint" minOccurs="1" maxOccurs="1" />
                <xs:element ref="mapResponse" minOccurs="1" maxOccurs="1" />
                <xs:element ref="stringMatch" minOccurs="1" maxOccurs="1" />
                <xs:element ref="repeat" minOccurs="1" maxOccurs="1" />
                <xs:element ref="roundTo" minOccurs="1" maxOccurs="1" />
                <xs:element ref="lcm" minOccurs="1" maxOccurs="1" />
                <xs:element ref="gcd" minOccurs="1" maxOccurs="1" />
                <xs:element ref="min" minOccurs="1" maxOccurs="1" />
                <xs:element ref="max" minOccurs="1" maxOccurs="1" />
                <xs:element ref="mathConstant" minOccurs="1" maxOccurs="1" />
                <xs:element ref="statsOperator" minOccurs="1" maxOccurs="1" />
                <xs:element ref="mathOperator" minOccurs="1" maxOccurs="1" />
            </xs:choice>
        </xs:sequence>
    </xs:complexType>

    <xs:complexType name="TemplateDeclaration.Type" abstract="false" mixed="false">
        <xs:annotation>
            <xs:documentation source="documentation">
                The templateDeclaration complexType is the container for template declarations. Template  
                declarations declare item variables that are to be used specifically for the purposes of  
                cloning items. They can have their value set only during templateProcessing. They are ref-
                erred to within the itemBody in order to individualize the clone and possibily also within
                the responseProcessing rules if the cloning process affects the way the item is scored.   
            </xs:documentation>
        </xs:annotation>
        <xs:sequence>
            <xs:element ref="defaultValue" minOccurs="0" maxOccurs="1" />
        </xs:sequence>
        <xs:attributeGroup ref="identifier.TemplateDeclaration.Attr" />
        <xs:attributeGroup ref="cardinality.TemplateDeclaration.Attr" />
        <xs:attributeGroup ref="baseType.TemplateDeclaration.Attr" />
        <xs:attributeGroup ref="paramVariable.TemplateDeclaration.Attr" />
        <xs:attributeGroup ref="mathVariable.TemplateDeclaration.Attr" />
    </xs:complexType>

    <xs:complexType name="TemplateDefault.Type" abstract="false" mixed="false">
        <xs:annotation>
            <xs:documentation source="documentation">
                The information in a TemplateDefault complexType is used to alter the default value of a  
                template variable declared by the item based on an expression evaluated at test-level. The
                default value of a template variable in an item can be overridden based on the test conte-
                xt in which the template is instantiated. The value is obtained by evaluating an expressi-
                on defined within the reference to the item at test level and which may therefore depend  
                on the values of variables taken from other items in the test or from outcomes defined at 
                test level itself.                                                                        
            </xs:documentation>
        </xs:annotation>
        <xs:sequence>
            <xs:choice minOccurs="1" maxOccurs="1">
                <xs:element ref="and" minOccurs="1" maxOccurs="1" />
                <xs:element ref="gt" minOccurs="1" maxOccurs="1" />
                <xs:element ref="not" minOccurs="1" maxOccurs="1" />
                <xs:element ref="lt" minOccurs="1" maxOccurs="1" />
                <xs:element ref="gte" minOccurs="1" maxOccurs="1" />
                <xs:element ref="lte" minOccurs="1" maxOccurs="1" />
                <xs:element ref="or" minOccurs="1" maxOccurs="1" />
                <xs:element ref="sum" minOccurs="1" maxOccurs="1" />
                <xs:element ref="durationLT" minOccurs="1" maxOccurs="1" />
                <xs:element ref="durationGTE" minOccurs="1" maxOccurs="1" />
                <xs:element ref="subtract" minOccurs="1" maxOccurs="1" />
                <xs:element ref="divide" minOccurs="1" maxOccurs="1" />
                <xs:element ref="multiple" minOccurs="1" maxOccurs="1" />
                <xs:element ref="ordered" minOccurs="1" maxOccurs="1" />
                <xs:element ref="customOperator" minOccurs="1" maxOccurs="1" />
                <xs:element ref="random" minOccurs="1" maxOccurs="1" />
                <xs:element ref="numberIncorrect" minOccurs="1" maxOccurs="1" />
                <xs:element ref="numberCorrect" minOccurs="1" maxOccurs="1" />
                <xs:element ref="numberPresented" minOccurs="1" maxOccurs="1" />
                <xs:element ref="numberResponded" minOccurs="1" maxOccurs="1" />
                <xs:element ref="numberSelected" minOccurs="1" maxOccurs="1" />
                <xs:element ref="substring" minOccurs="1" maxOccurs="1" />
                <xs:element ref="equalRounded" minOccurs="1" maxOccurs="1" />
                <xs:element ref="null" minOccurs="1" maxOccurs="1" />
                <xs:element ref="delete" minOccurs="1" maxOccurs="1" />
                <xs:element ref="match" minOccurs="1" maxOccurs="1" />
                <xs:element ref="index" minOccurs="1" maxOccurs="1" />
                <xs:element ref="power" minOccurs="1" maxOccurs="1" />
                <xs:element ref="equal" minOccurs="1" maxOccurs="1" />
                <xs:element ref="contains" minOccurs="1" maxOccurs="1" />
                <xs:element ref="containerSize" minOccurs="1" maxOccurs="1" />
                <xs:element ref="correct" minOccurs="1" maxOccurs="1" />
                <xs:element ref="default" minOccurs="1" maxOccurs="1" />
                <xs:element ref="anyN" minOccurs="1" maxOccurs="1" />
                <xs:element ref="integerDivide" minOccurs="1" maxOccurs="1" />
                <xs:element ref="integerModulus" minOccurs="1" maxOccurs="1" />
                <xs:element ref="isNull" minOccurs="1" maxOccurs="1" />
                <xs:element ref="member" minOccurs="1" maxOccurs="1" />
                <xs:element ref="product" minOccurs="1" maxOccurs="1" />
                <xs:element ref="round" minOccurs="1" maxOccurs="1" />
                <xs:element ref="truncate" minOccurs="1" maxOccurs="1" />
                <xs:element ref="fieldValue" minOccurs="1" maxOccurs="1" />
                <xs:element ref="randomInteger" minOccurs="1" maxOccurs="1" />
                <xs:element ref="randomFloat" minOccurs="1" maxOccurs="1" />
                <xs:element ref="variable" minOccurs="1" maxOccurs="1" />
                <xs:element ref="outcomeMinimum" minOccurs="1" maxOccurs="1" />
                <xs:element ref="outcomeMaximum" minOccurs="1" maxOccurs="1" />
                <xs:element ref="testVariables" minOccurs="1" maxOccurs="1" />
                <xs:element ref="integerToFloat" minOccurs="1" maxOccurs="1" />
                <xs:element ref="inside" minOccurs="1" maxOccurs="1" />
                <xs:element ref="baseValue" minOccurs="1" maxOccurs="1" />
                <xs:element ref="patternMatch" minOccurs="1" maxOccurs="1" />
                <xs:element ref="mapResponsePoint" minOccurs="1" maxOccurs="1" />
                <xs:element ref="mapResponse" minOccurs="1" maxOccurs="1" />
                <xs:element ref="stringMatch" minOccurs="1" maxOccurs="1" />
                <xs:element ref="repeat" minOccurs="1" maxOccurs="1" />
                <xs:element ref="roundTo" minOccurs="1" maxOccurs="1" />
                <xs:element ref="lcm" minOccurs="1" maxOccurs="1" />
                <xs:element ref="gcd" minOccurs="1" maxOccurs="1" />
                <xs:element ref="min" minOccurs="1" maxOccurs="1" />
                <xs:element ref="max" minOccurs="1" maxOccurs="1" />
                <xs:element ref="mathConstant" minOccurs="1" maxOccurs="1" />
                <xs:element ref="statsOperator" minOccurs="1" maxOccurs="1" />
                <xs:element ref="mathOperator" minOccurs="1" maxOccurs="1" />
            </xs:choice>
        </xs:sequence>
        <xs:attributeGroup ref="templateIdentifier.TemplateDefault.Attr" />
    </xs:complexType>

    <xs:complexType name="TemplateElse.Type" abstract="false" mixed="false">
        <xs:annotation>
            <xs:documentation source="documentation">
                The TemplateElse complexType is the container for the alternative rules that are to be ap-
                plied if the templateIf rules are NULL/FALSE.                                             
            </xs:documentation>
        </xs:annotation>
        <xs:sequence>
            <xs:choice minOccurs="0" maxOccurs="unbounded">
                <xs:element ref="setTemplateValue" minOccurs="1" maxOccurs="1" />
                <xs:element ref="exitTemplate" minOccurs="1" maxOccurs="1" />
                <xs:element ref="templateCondition" minOccurs="1" maxOccurs="1" />
                <xs:element ref="setDefaultValue" minOccurs="1" maxOccurs="1" />
                <xs:element ref="setCorrectResponse" minOccurs="1" maxOccurs="1" />
                <xs:element ref="templateConstraint" minOccurs="1" maxOccurs="1" />
            </xs:choice>
        </xs:sequence>
    </xs:complexType>

    <xs:complexType name="TemplateIf.Type" abstract="false" mixed="false">
        <xs:annotation>
            <xs:documentation source="documentation">
                The TemplateIf complexType is the container of an expression which must have an effective 
                baseType of boolean and single cardinality. For more information about the runtime data m-
                odel employed see 'Expressions'. It also contains a set of sub-rules. If the expression is
                true then the sub-rules are processed, otherwise they are skipped (including if the expre-
                ssion is NULL) and the following templateElseIf or templateElse parts (if any) are consid-
                ered instead.                                                                             
            </xs:documentation>
        </xs:annotation>
        <xs:sequence>
            <xs:choice minOccurs="1" maxOccurs="1">
                <xs:element ref="and" minOccurs="1" maxOccurs="1" />
                <xs:element ref="gt" minOccurs="1" maxOccurs="1" />
                <xs:element ref="not" minOccurs="1" maxOccurs="1" />
                <xs:element ref="lt" minOccurs="1" maxOccurs="1" />
                <xs:element ref="gte" minOccurs="1" maxOccurs="1" />
                <xs:element ref="lte" minOccurs="1" maxOccurs="1" />
                <xs:element ref="or" minOccurs="1" maxOccurs="1" />
                <xs:element ref="sum" minOccurs="1" maxOccurs="1" />
                <xs:element ref="durationLT" minOccurs="1" maxOccurs="1" />
                <xs:element ref="durationGTE" minOccurs="1" maxOccurs="1" />
                <xs:element ref="subtract" minOccurs="1" maxOccurs="1" />
                <xs:element ref="divide" minOccurs="1" maxOccurs="1" />
                <xs:element ref="multiple" minOccurs="1" maxOccurs="1" />
                <xs:element ref="ordered" minOccurs="1" maxOccurs="1" />
                <xs:element ref="customOperator" minOccurs="1" maxOccurs="1" />
                <xs:element ref="random" minOccurs="1" maxOccurs="1" />
                <xs:element ref="numberIncorrect" minOccurs="1" maxOccurs="1" />
                <xs:element ref="numberCorrect" minOccurs="1" maxOccurs="1" />
                <xs:element ref="numberPresented" minOccurs="1" maxOccurs="1" />
                <xs:element ref="numberResponded" minOccurs="1" maxOccurs="1" />
                <xs:element ref="numberSelected" minOccurs="1" maxOccurs="1" />
                <xs:element ref="substring" minOccurs="1" maxOccurs="1" />
                <xs:element ref="equalRounded" minOccurs="1" maxOccurs="1" />
                <xs:element ref="null" minOccurs="1" maxOccurs="1" />
                <xs:element ref="delete" minOccurs="1" maxOccurs="1" />
                <xs:element ref="match" minOccurs="1" maxOccurs="1" />
                <xs:element ref="index" minOccurs="1" maxOccurs="1" />
                <xs:element ref="power" minOccurs="1" maxOccurs="1" />
                <xs:element ref="equal" minOccurs="1" maxOccurs="1" />
                <xs:element ref="contains" minOccurs="1" maxOccurs="1" />
                <xs:element ref="containerSize" minOccurs="1" maxOccurs="1" />
                <xs:element ref="correct" minOccurs="1" maxOccurs="1" />
                <xs:element ref="default" minOccurs="1" maxOccurs="1" />
                <xs:element ref="anyN" minOccurs="1" maxOccurs="1" />
                <xs:element ref="integerDivide" minOccurs="1" maxOccurs="1" />
                <xs:element ref="integerModulus" minOccurs="1" maxOccurs="1" />
                <xs:element ref="isNull" minOccurs="1" maxOccurs="1" />
                <xs:element ref="member" minOccurs="1" maxOccurs="1" />
                <xs:element ref="product" minOccurs="1" maxOccurs="1" />
                <xs:element ref="round" minOccurs="1" maxOccurs="1" />
                <xs:element ref="truncate" minOccurs="1" maxOccurs="1" />
                <xs:element ref="fieldValue" minOccurs="1" maxOccurs="1" />
                <xs:element ref="randomInteger" minOccurs="1" maxOccurs="1" />
                <xs:element ref="randomFloat" minOccurs="1" maxOccurs="1" />
                <xs:element ref="variable" minOccurs="1" maxOccurs="1" />
                <xs:element ref="outcomeMinimum" minOccurs="1" maxOccurs="1" />
                <xs:element ref="outcomeMaximum" minOccurs="1" maxOccurs="1" />
                <xs:element ref="testVariables" minOccurs="1" maxOccurs="1" />
                <xs:element ref="integerToFloat" minOccurs="1" maxOccurs="1" />
                <xs:element ref="inside" minOccurs="1" maxOccurs="1" />
                <xs:element ref="baseValue" minOccurs="1" maxOccurs="1" />
                <xs:element ref="patternMatch" minOccurs="1" maxOccurs="1" />
                <xs:element ref="mapResponsePoint" minOccurs="1" maxOccurs="1" />
                <xs:element ref="mapResponse" minOccurs="1" maxOccurs="1" />
                <xs:element ref="stringMatch" minOccurs="1" maxOccurs="1" />
                <xs:element ref="repeat" minOccurs="1" maxOccurs="1" />
                <xs:element ref="roundTo" minOccurs="1" maxOccurs="1" />
                <xs:element ref="lcm" minOccurs="1" maxOccurs="1" />
                <xs:element ref="gcd" minOccurs="1" maxOccurs="1" />
                <xs:element ref="min" minOccurs="1" maxOccurs="1" />
                <xs:element ref="max" minOccurs="1" maxOccurs="1" />
                <xs:element ref="mathConstant" minOccurs="1" maxOccurs="1" />
                <xs:element ref="statsOperator" minOccurs="1" maxOccurs="1" />
                <xs:element ref="mathOperator" minOccurs="1" maxOccurs="1" />
            </xs:choice>
            <xs:choice minOccurs="0" maxOccurs="unbounded">
                <xs:element ref="setTemplateValue" minOccurs="1" maxOccurs="1" />
                <xs:element ref="exitTemplate" minOccurs="1" maxOccurs="1" />
                <xs:element ref="templateCondition" minOccurs="1" maxOccurs="1" />
                <xs:element ref="setDefaultValue" minOccurs="1" maxOccurs="1" />
                <xs:element ref="setCorrectResponse" minOccurs="1" maxOccurs="1" />
                <xs:element ref="templateConstraint" minOccurs="1" maxOccurs="1" />
            </xs:choice>
        </xs:sequence>
    </xs:complexType>

    <xs:complexType name="TemplateInline.Type" abstract="false" mixed="true">
        <xs:annotation>
            <xs:documentation source="documentation">
                The TemplateInline complexType is the container for inline objects (excluding interaction-
                s) that are used to create a template layout.                                             
            </xs:documentation>
        </xs:annotation>
        <xs:sequence>
            <xs:choice minOccurs="0" maxOccurs="unbounded">
                <xs:element ref="hottext" minOccurs="1" maxOccurs="1" />
                <xs:element ref="printedVariable" minOccurs="1" maxOccurs="1" />
                <xs:element ref="gap" minOccurs="1" maxOccurs="1" />
                <xs:element ref="feedbackInline" minOccurs="1" maxOccurs="1" />
                <xs:element ref="templateInline" minOccurs="1" maxOccurs="1" />
                <xs:element ref="m:math" minOccurs="1" maxOccurs="1" />
                <xs:element ref="xi:include" minOccurs="1" maxOccurs="1" />
                <xs:choice minOccurs="1" maxOccurs="1">
                    <xs:element ref="img" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="br" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="object" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="em" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="a" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="code" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="span" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="sub" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="acronym" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="big" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="tt" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="kbd" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="q" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="i" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="dfn" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="abbr" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="strong" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="sup" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="var" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="small" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="samp" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="b" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="cite" minOccurs="1" maxOccurs="1" />
                </xs:choice>
            </xs:choice>
        </xs:sequence>
        <xs:attributeGroup ref="xmlbase.TemplateInline.Attr" />
        <xs:attributeGroup ref="id.TemplateInline.Attr" />
        <xs:attributeGroup ref="class.TemplateInline.Attr" />
        <xs:attributeGroup ref="xmllang.TemplateInline.Attr" />
        <xs:attributeGroup ref="label.TemplateInline.Attr" />
        <xs:attributeGroup ref="templateIdentifier.TemplateInline.Attr" />
        <xs:attributeGroup ref="showHide.TemplateInline.Attr" />
        <xs:attributeGroup ref="identifier.TemplateInline.Attr" />
    </xs:complexType>

    <xs:complexType name="TemplateProcessing.Type" abstract="false" mixed="false">
        <xs:annotation>
            <xs:documentation source="documentation">
                The TemplateProcessing complexType is the container for the template processing rules. Te-
                mplate processing consists of one or more templateRules that are followed by the cloning  
                engine or delivery system in order to assign values to the template variables. Template p-
                rocessing is identical in form to responseProcessing except that the purpose is to assign 
                values to template variables, not outcome variables.                                      
            </xs:documentation>
        </xs:annotation>
        <xs:sequence>
            <xs:choice minOccurs="1" maxOccurs="unbounded">
                <xs:element ref="setTemplateValue" minOccurs="1" maxOccurs="1" />
                <xs:element ref="exitTemplate" minOccurs="1" maxOccurs="1" />
                <xs:element ref="templateCondition" minOccurs="1" maxOccurs="1" />
                <xs:element ref="setDefaultValue" minOccurs="1" maxOccurs="1" />
                <xs:element ref="setCorrectResponse" minOccurs="1" maxOccurs="1" />
                <xs:element ref="templateConstraint" minOccurs="1" maxOccurs="1" />
            </xs:choice>
        </xs:sequence>
    </xs:complexType>

    <xs:complexType name="TestFeedback.Type" abstract="false" mixed="true">
        <xs:annotation>
            <xs:documentation source="documentation">
                The TestFeedback complexType is the container for the test feedback to be presented to the
                candidate. Test feedback is shown to the candidate either directly following outcome proc-
                essing (during the test) or at the end of the testPart or assessmentTest as appropriate (-
                referred to as atEnd). The value of an outcome variable is used in conjunction with the s-
                howHide and identifier attributes to determine whether or not the feedback is actually sh-
                own.                                                                                      
            </xs:documentation>
        </xs:annotation>
        <xs:sequence>
            <xs:choice minOccurs="0" maxOccurs="unbounded">
                <xs:element ref="printedVariable" minOccurs="1" maxOccurs="1" />
                <xs:element ref="hottext" minOccurs="1" maxOccurs="1" />
                <xs:element name="templateInline" type="TemplateInline.Type" minOccurs="1" maxOccurs="1"/>
                <xs:element name="templateBlock" type="TemplateBlock.Type" minOccurs="1" maxOccurs="1"/>
                <xs:element ref="m:math" minOccurs="1" maxOccurs="1" />
                <xs:element ref="xi:include" minOccurs="1" maxOccurs="1" />
                <xs:choice minOccurs="1" maxOccurs="1">
                    <xs:element ref="pre" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="h1" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="h2" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="h3" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="h4" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="h5" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="h6" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="p" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="address" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="dl" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="ol" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="ul" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="br" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="hr" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="img" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="object" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="blockquote" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="em" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="a" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="code" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="span" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="sub" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="acronym" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="big" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="tt" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="kbd" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="q" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="i" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="dfn" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="abbr" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="strong" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="sup" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="var" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="small" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="samp" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="b" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="cite" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="table" minOccurs="1" maxOccurs="1" />
                    <xs:element ref="div" minOccurs="1" maxOccurs="1" />
                </xs:choice>
            </xs:choice>
            <xs:element ref="stylesheet" minOccurs="0" maxOccurs="unbounded" />
            <xs:element ref="apip:apipAccessibility" minOccurs="0" maxOccurs="1" />
        </xs:sequence>
        <xs:attributeGroup ref="access.TestFeedback.Attr" />
        <xs:attributeGroup ref="outcomeIdentifier.TestFeedback.Attr" />
        <xs:attributeGroup ref="showHide.TestFeedback.Attr" />
        <xs:attributeGroup ref="identifier.TestFeedback.Attr" />
        <xs:attributeGroup ref="title.TestFeedback.Attr" />
    </xs:complexType>

    <xs:complexType name="TestPart.Type" abstract="false" mixed="false">
        <xs:annotation>
            <xs:documentation source="documentation">
                A Test is composed of one or more Test Parts. Each Test Part is used to control the prese-
                ntation of a part of the Test - this allows a Test to be undertaken in several related but
                separated stages. A TestPart conatins one or more assessmentSections (either included or  
                through external reference).                                                              
            </xs:documentation>
        </xs:annotation>
        <xs:sequence>
            <xs:element ref="preCondition" minOccurs="0" maxOccurs="unbounded" />
            <xs:element ref="branchRule" minOccurs="0" maxOccurs="unbounded" />
            <xs:element ref="itemSessionControl" minOccurs="0" maxOccurs="1" />
            <xs:element ref="timeLimits" minOccurs="0" maxOccurs="1" />
            <xs:choice minOccurs="1" maxOccurs="unbounded">
                <xs:element ref="assessmentSection" minOccurs="1" maxOccurs="1" />
                <xs:element ref="assessmentSectionRef" minOccurs="1" maxOccurs="1" />
            </xs:choice>
            <xs:element ref="testFeedback" minOccurs="0" maxOccurs="unbounded" />
        </xs:sequence>
        <xs:attributeGroup ref="identifier.TestPart.Attr" />
        <xs:attributeGroup ref="navigationMode.TestPart.Attr" />
        <xs:attributeGroup ref="submissionMode.TestPart.Attr" />
    </xs:complexType>

    <xs:complexType name="TR.Type" abstract="false" mixed="false">
        <xs:annotation>
            <xs:documentation source="documentation">
                The 'TR' complexType is the container for content that is equivalent to the HTML 'tr' mar-
                kup.                                                                                      
            </xs:documentation>
        </xs:annotation>
        <xs:sequence>
            <xs:choice minOccurs="1" maxOccurs="unbounded">
                <xs:element ref="td" minOccurs="1" maxOccurs="1" />
                <xs:element ref="th" minOccurs="1" maxOccurs="1" />
            </xs:choice>
        </xs:sequence>
        <xs:attributeGroup ref="id.TR.Attr" />
        <xs:attributeGroup ref="class.TR.Attr" />
        <xs:attributeGroup ref="xmllang.TR.Attr" />
        <xs:attributeGroup ref="label.TR.Attr" />
    </xs:complexType>

    <xs:complexType name="UploadInteraction.Type" abstract="false" mixed="false">
        <xs:annotation>
            <xs:documentation source="documentation">
                The UploadInteraction complexType is the container for QTI interactions that involve subm-
                ission of information in an external file. The upload interaction allows the candidate to 
                upload a pre-prepared file representing their response.                                   
            </xs:documentation>
        </xs:annotation>
        <xs:sequence>
            <xs:element ref="prompt" minOccurs="0" maxOccurs="1" />
        </xs:sequence>
        <xs:attributeGroup ref="xmlbase.UploadInteraction.Attr" />
        <xs:attributeGroup ref="id.UploadInteraction.Attr" />
        <xs:attributeGroup ref="class.UploadInteraction.Attr" />
        <xs:attributeGroup ref="xmllang.UploadInteraction.Attr" />
        <xs:attributeGroup ref="label.UploadInteraction.Attr" />
        <xs:attributeGroup ref="responseIdentifier.UploadInteraction.Attr" />
        <xs:attributeGroup ref="type.UploadInteraction.Attr" />
    </xs:complexType>

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

    <!-- Generate the SOAP Binding ComplexTypes *********************************************************** -->

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

    <!-- Generate the derived ComplexTypes **************************************************************** -->

    <xs:complexType name="AreaMapEntry.Type" abstract="false" mixed="false">
        <xs:annotation>
            <xs:documentation source="documentation">
                The AreaMapEntry complexType is the container for area map entries. A map is defined by a 
                set of areaMapEntries, each of which maps an area of the coordinate space onto a single f-
                loat. When mapping points each area is tested in turn, with those listed first taking pri-
                ority in the case where areas overlap and a point falls in the intersection.              
            </xs:documentation>
        </xs:annotation>
        <xs:complexContent>
            <xs:extension base="EmptyPrimitiveType.Type">
                <xs:attributeGroup ref="shape.AreaMapEntry.Attr" />
                <xs:attributeGroup ref="coords.AreaMapEntry.Attr" />
                <xs:attributeGroup ref="mappedValue.AreaMapEntry.Attr" />
            </xs:extension>
        </xs:complexContent>
    </xs:complexType>

    <xs:complexType name="AssessmentSectionRef.Type" abstract="false" mixed="false">
        <xs:annotation>
            <xs:documentation source="documentation">
                This is the container for referential link to an externally stored AssessmentSection (each
                such Section is stored in its own XML instance file). The identifier attribute should be  
                used to identify the actual Section.                                                      
            </xs:documentation>
        </xs:annotation>
        <xs:complexContent>
            <xs:extension base="EmptyPrimitiveType.Type">
                <xs:attributeGroup ref="identifier.AssessmentSectionRef.Attr" />
                <xs:attributeGroup ref="href.AssessmentSectionRef.Attr" />
            </xs:extension>
        </xs:complexContent>
    </xs:complexType>

    <xs:complexType name="AssociableHotspot.Type" abstract="false" mixed="false">
        <xs:annotation>
            <xs:documentation source="documentation">
                The AssociableHotspot complexType is the container for association of associableChoice, a-
                nd hotspot interactions. This ComplexType is intentionally empty.                         
            </xs:documentation>
        </xs:annotation>
        <xs:complexContent>
            <xs:extension base="EmptyPrimitiveType.Type">
                <xs:attributeGroup ref="id.AssociableHotspot.Attr" />
                <xs:attributeGroup ref="class.AssociableHotspot.Attr" />
                <xs:attributeGroup ref="xmllang.AssociableHotspot.Attr" />
                <xs:attributeGroup ref="label.AssociableHotspot.Attr" />
                <xs:attributeGroup ref="identifier.AssociableHotspot.Attr" />
                <xs:attributeGroup ref="fixed.AssociableHotspot.Attr" />
                <xs:attributeGroup ref="templateIdentifier.AssociableHotspot.Attr" />
                <xs:attributeGroup ref="showHide.AssociableHotspot.Attr" />
                <xs:attributeGroup ref="matchGroup.AssociableHotspot.Attr" />
                <xs:attributeGroup ref="shape.AssociableHotspot.Attr" />
                <xs:attributeGroup ref="coords.AssociableHotspot.Attr" />
                <xs:attributeGroup ref="hotspotLabel.AssociableHotspot.Attr" />
                <xs:attributeGroup ref="matchMax.AssociableHotspot.Attr" />
                <xs:attributeGroup ref="matchMin.AssociableHotspot.Attr" />
            </xs:extension>
        </xs:complexContent>
    </xs:complexType>

    <xs:complexType name="BaseValue.Type" abstract="false" mixed="false">
        <xs:annotation>
            <xs:documentation source="documentation">
                The simplest expression returns a single value from the set defined by the given baseType.
            </xs:documentation>
        </xs:annotation>
        <xs:simpleContent>
            <xs:extension base="xs:string">
                <xs:attributeGroup ref="baseType.BaseValue.Attr" />
            </xs:extension>
        </xs:simpleContent>
    </xs:complexType>

    <xs:complexType name="BR.Type" abstract="false" mixed="false">
        <xs:annotation>
            <xs:documentation source="documentation">
                The 'BR' complexType is the container for content that is equivalent to the HTML 'br' mar-
                kup.This ComplexType is intentionally empty.                                              
            </xs:documentation>
        </xs:annotation>
        <xs:complexContent>
            <xs:extension base="EmptyPrimitiveType.Type">
                <xs:attributeGroup ref="id.BR.Attr" />
                <xs:attributeGroup ref="class.BR.Attr" />
                <xs:attributeGroup ref="xmllang.BR.Attr" />
                <xs:attributeGroup ref="label.BR.Attr" />
                <xs:attributeGroup ref="xmlbase.BR.Attr" />
            </xs:extension>
        </xs:complexContent>
    </xs:complexType>

    <xs:complexType name="Col.Type" abstract="false" mixed="false">
        <xs:annotation>
            <xs:documentation source="documentation">
                The 'Col' complexType is the container for content that is equivalent to the HTML 'col' m-
                arkup.This ComplexType is intentionally empty.                                            
            </xs:documentation>
        </xs:annotation>
        <xs:complexContent>
            <xs:extension base="EmptyPrimitiveType.Type">
                <xs:attributeGroup ref="id.Col.Attr" />
                <xs:attributeGroup ref="class.Col.Attr" />
                <xs:attributeGroup ref="xmllang.Col.Attr" />
                <xs:attributeGroup ref="label.Col.Attr" />
                <xs:attributeGroup ref="span.Col.Attr" />
            </xs:extension>
        </xs:complexContent>
    </xs:complexType>

    <xs:complexType name="Correct.Type" abstract="false" mixed="false">
        <xs:annotation>
            <xs:documentation source="documentation">
                This expression looks up the declaration of a response variable and returns the associated
                correctResponse or NULL if no correct value was declared. When used in outcomes processing
                item identifier prefixing (see variable) may be used to obtain the correct response from  
                an individual item. This is intentionally empty.                                          
            </xs:documentation>
        </xs:annotation>
        <xs:complexContent>
            <xs:extension base="EmptyPrimitiveType.Type">
                <xs:attributeGroup ref="identifier.Correct.Attr" />
            </xs:extension>
        </xs:complexContent>
    </xs:complexType>

    <xs:complexType name="Default.Type" abstract="false" mixed="false">
        <xs:annotation>
            <xs:documentation source="documentation">
                This expression looks up the declaration of an itemVariable and returns the associated de-
                faultValue or NULL if no default value was declared. When used in outcomes processing item
                identifier prefixing (see variable) may be used to obtain the default value from an indiv-
                idual item. This is intentionally empty.                                                  
            </xs:documentation>
        </xs:annotation>
        <xs:complexContent>
            <xs:extension base="EmptyPrimitiveType.Type">
                <xs:attributeGroup ref="identifier.Default.Attr" />
            </xs:extension>
        </xs:complexContent>
    </xs:complexType>

    <xs:complexType name="EndAttemptInteraction.Type" abstract="false" mixed="false">
        <xs:annotation>
            <xs:documentation source="documentation">
                The EndAttemptInteraction complexType is the container for the end attempt interaction in-
                formation. The end attempt interaction is a special type of interaction which allows item 
                authors to provide the candidate with control over the way in which the candidate termina-
                tes an attempt. The candidate can use the interaction to terminate the attempt (triggering
                response processing) immediately, typically to request a hint. It must be bound to a resp-
                onse variable with base-type boolean and single cardinality.                              
            </xs:documentation>
        </xs:annotation>
        <xs:complexContent>
            <xs:extension base="EmptyPrimitiveType.Type">
                <xs:attributeGroup ref="xmlbase.EndAttemptInteraction.Attr" />
                <xs:attributeGroup ref="id.EndAttemptInteraction.Attr" />
                <xs:attributeGroup ref="class.EndAttemptInteraction.Attr" />
                <xs:attributeGroup ref="xmllang.EndAttemptInteraction.Attr" />
                <xs:attributeGroup ref="label.EndAttemptInteraction.Attr" />
                <xs:attributeGroup ref="responseIdentifier.EndAttemptInteraction.Attr" />
                <xs:attributeGroup ref="title.EndAttemptInteraction.Attr" />
                <xs:attributeGroup ref="countAttempt.EndAttemptInteraction.Attr" />
            </xs:extension>
        </xs:complexContent>
    </xs:complexType>

    <xs:complexType name="Gap.Type" abstract="false" mixed="false">
        <xs:annotation>
            <xs:documentation source="documentation">
                The Gap complexType is the container for the inline content as part of a gap-based intera-
                ction. The gap is an inline static element that must only appear within a gapMatchInterac-
                tion.                                                                                     
            </xs:documentation>
        </xs:annotation>
        <xs:complexContent>
            <xs:extension base="EmptyPrimitiveType.Type">
                <xs:attributeGroup ref="id.Gap.Attr" />
                <xs:attributeGroup ref="class.Gap.Attr" />
                <xs:attributeGroup ref="xmllang.Gap.Attr" />
                <xs:attributeGroup ref="label.Gap.Attr" />
                <xs:attributeGroup ref="identifier.Gap.Attr" />
                <xs:attributeGroup ref="fixed.Gap.Attr" />
                <xs:attributeGroup ref="templateIdentifier.Gap.Attr" />
                <xs:attributeGroup ref="showHide.Gap.Attr" />
                <xs:attributeGroup ref="matchGroup.Gap.Attr" />
                <xs:attributeGroup ref="required.Gap.Attr" />
            </xs:extension>
        </xs:complexContent>
    </xs:complexType>

    <xs:complexType name="HotspotChoice.Type" abstract="false" mixed="false">
        <xs:annotation>
            <xs:documentation source="documentation">
                The HotspotChoice complexType is the container for data about hotspot choices (this Compl-
                exType is intentionally empty). The hotspots that define the choices that can be selected 
                by the candidate. If the delivery system does not support pointer-based selection then the
                order in which the choices are given must be the order in which they are offered to the c-
                andidate for selection. For example, the 'tab order' in simple keyboard navigation. If ho-
                tspots overlap then those listed first hide overlapping hotspots that appear later. The d-
                efault hotspot, if defined, must appear last.                                             
            </xs:documentation>
        </xs:annotation>
        <xs:complexContent>
            <xs:extension base="EmptyPrimitiveType.Type">
                <xs:attributeGroup ref="id.HotspotChoice.Attr" />
                <xs:attributeGroup ref="class.HotspotChoice.Attr" />
                <xs:attributeGroup ref="xmllang.HotspotChoice.Attr" />
                <xs:attributeGroup ref="label.HotspotChoice.Attr" />
                <xs:attributeGroup ref="identifier.HotspotChoice.Attr" />
                <xs:attributeGroup ref="fixed.HotspotChoice.Attr" />
                <xs:attributeGroup ref="templateIdentifier.HotspotChoice.Attr" />
                <xs:attributeGroup ref="showHide.HotspotChoice.Attr" />
                <xs:attributeGroup ref="shape.HotspotChoice.Attr" />
                <xs:attributeGroup ref="coords.HotspotChoice.Attr" />
                <xs:attributeGroup ref="hotspotLabel.HotspotChoice.Attr" />
            </xs:extension>
        </xs:complexContent>
    </xs:complexType>

    <xs:complexType name="HR.Type" abstract="false" mixed="false">
        <xs:annotation>
            <xs:documentation source="documentation">
                The 'HR' complexType is the container for content that is equivalent to the HTML 'hr' mar-
                kup.This complexType is intentionally empty.                                              
            </xs:documentation>
        </xs:annotation>
        <xs:complexContent>
            <xs:extension base="EmptyPrimitiveType.Type">
                <xs:attributeGroup ref="id.HR.Attr" />
                <xs:attributeGroup ref="class.HR.Attr" />
                <xs:attributeGroup ref="xmllang.HR.Attr" />
                <xs:attributeGroup ref="label.HR.Attr" />
                <xs:attributeGroup ref="xmlbase.HR.Attr" />
            </xs:extension>
        </xs:complexContent>
    </xs:complexType>

    <xs:complexType name="Img.Type" abstract="false" mixed="false">
        <xs:annotation>
            <xs:documentation source="documentation">
                The 'Img' complexType is the container for content that is equivalent to the HTML 'img' m-
                arkup.This ComplexType is intentionally empty.                                            
            </xs:documentation>
        </xs:annotation>
        <xs:complexContent>
            <xs:extension base="EmptyPrimitiveType.Type">
                <xs:attributeGroup ref="id.Img.Attr" />
                <xs:attributeGroup ref="class.Img.Attr" />
                <xs:attributeGroup ref="xmllang.Img.Attr" />
                <xs:attributeGroup ref="label.Img.Attr" />
                <xs:attributeGroup ref="xmlbase.Img.Attr" />
                <xs:attributeGroup ref="src.Img.Attr" />
                <xs:attributeGroup ref="alt.Img.Attr" />
                <xs:attributeGroup ref="longdesc.Img.Attr" />
                <xs:attributeGroup ref="height.Img.Attr" />
                <xs:attributeGroup ref="width.Img.Attr" />
            </xs:extension>
        </xs:complexContent>
    </xs:complexType>

    <xs:complexType name="InterpolationTableEntry.Type" abstract="false" mixed="false">
        <xs:annotation>
            <xs:documentation source="documentation">
                The InterpolationTableEntry complexType is the container for an entry in the corresponding
                interpolationTable. This complexType is intentionally empty.                              
            </xs:documentation>
        </xs:annotation>
        <xs:complexContent>
            <xs:extension base="EmptyPrimitiveType.Type">
                <xs:attributeGroup ref="sourceValue.InterpolationTableEntry.Attr" />
                <xs:attributeGroup ref="includeBoundary.InterpolationTableEntry.Attr" />
                <xs:attributeGroup ref="targetValue.InterpolationTableEntry.Attr" />
            </xs:extension>
        </xs:complexContent>
    </xs:complexType>

    <xs:complexType name="ItemSessionControl.Type" abstract="false" mixed="false">
        <xs:annotation>
            <xs:documentation source="documentation">
                When items are referenced as part of a test, the test may impose constraints on how many  
                attempts, and which states are allowed. These constraints can be specified for individual 
                items, for whole sections or for an entire testPart. By default, a setting at testPart le-
                vel affects all items in that part unless the setting is overridden at the assessmentSect-
                ion level or ultimately at the individual assessmentItemRef. The defaults given below are 
                used only in the absence of any applicable constraint. This complexType is intentionally  
                empty.                                                                                    
            </xs:documentation>
        </xs:annotation>
        <xs:complexContent>
            <xs:extension base="EmptyPrimitiveType.Type">
                <xs:attributeGroup ref="maxAttempts.ItemSessionControl.Attr" />
                <xs:attributeGroup ref="showFeedback.ItemSessionControl.Attr" />
                <xs:attributeGroup ref="allowReview.ItemSessionControl.Attr" />
                <xs:attributeGroup ref="showSolution.ItemSessionControl.Attr" />
                <xs:attributeGroup ref="allowComment.ItemSessionControl.Attr" />
                <xs:attributeGroup ref="allowSkipping.ItemSessionControl.Attr" />
                <xs:attributeGroup ref="validateResponses.ItemSessionControl.Attr" />
            </xs:extension>
        </xs:complexContent>
    </xs:complexType>

    <xs:complexType name="MapEntry.Type" abstract="false" mixed="false">
        <xs:annotation>
            <xs:documentation source="documentation">
                The map is defined by a set of mapEntries, each of which maps a single value from the sou-
                rce set onto a single float.                                                              
            </xs:documentation>
        </xs:annotation>
        <xs:complexContent>
            <xs:extension base="EmptyPrimitiveType.Type">
                <xs:attributeGroup ref="mapKey.MapEntry.Attr" />
                <xs:attributeGroup ref="mappedValue.MapEntry.Attr" />
                <xs:attributeGroup ref="caseSensitive.MapEntry.Attr" />
            </xs:extension>
        </xs:complexContent>
    </xs:complexType>

    <xs:complexType name="MapResponse.Type" abstract="false" mixed="false">
        <xs:annotation>
            <xs:documentation source="documentation">
                This expression looks up the value of a response variable and then transforms it using the
                associated mapping, which must have been declared. The result is a single float. If the r-
                esponse variable has single cardinality then the value returned is simply the mapped targ-
                et value from the map. If the response variable has multiple or ordered cardinality then  
                the value returned is the sum of the mapped target values. This expression cannot be appl-
                ied to variables of record cardinality. This is intentionally empty.                      
            </xs:documentation>
        </xs:annotation>
        <xs:complexContent>
            <xs:extension base="EmptyPrimitiveType.Type">
                <xs:attributeGroup ref="identifier.MapResponse.Attr" />
            </xs:extension>
        </xs:complexContent>
    </xs:complexType>

    <xs:complexType name="MatchTableEntry.Type" abstract="false" mixed="false">
        <xs:annotation>
            <xs:documentation source="documentation">
                The MatchTableEnry complexType is the container for an entry n a match table. Intentional-
                ly empty comlexType.                                                                      
            </xs:documentation>
        </xs:annotation>
        <xs:complexContent>
            <xs:extension base="EmptyPrimitiveType.Type">
                <xs:attributeGroup ref="sourceValue.MatchTableEntry.Attr" />
                <xs:attributeGroup ref="targetValue.MatchTableEntry.Attr" />
            </xs:extension>
        </xs:complexContent>
    </xs:complexType>

    <xs:complexType name="MathConstant.Type" abstract="false" mixed="false">
        <xs:annotation>
            <xs:documentation source="documentation">
                The result is a mathematical constant returned as a single float, e.g. pi and e.          
            </xs:documentation>
        </xs:annotation>
        <xs:complexContent>
            <xs:extension base="EmptyPrimitiveType.Type">
                <xs:attributeGroup ref="name.MathConstant.Attr" />
            </xs:extension>
        </xs:complexContent>
    </xs:complexType>

    <xs:complexType name="Number.Type" abstract="false" mixed="false">
        <xs:annotation>
            <xs:documentation source="documentation">
                Provides an operator that returns the number of values that confrm to the associated cons-
                traints e.g. 'numberCorrect'.                                                             
            </xs:documentation>
        </xs:annotation>
        <xs:complexContent>
            <xs:extension base="EmptyPrimitiveType.Type">
                <xs:attributeGroup ref="sectionIdentifier.Number.Attr" />
                <xs:attributeGroup ref="includeCategory.Number.Attr" />
                <xs:attributeGroup ref="excludeCategory.Number.Attr" />
            </xs:extension>
        </xs:complexContent>
    </xs:complexType>

    <xs:complexType name="OutcomeMinMax.Type" abstract="false" mixed="false">
        <xs:annotation>
            <xs:documentation source="documentation">
                This expression, which can only be used in outcomes processing, simultaneously looks up t-
                he normal Maximum/Minimum value of an outcome variable in a sub-set of the items referred 
                to in a test. Only variables with single cardinality are considered. If any of the items  
                within the given subset have no declared maximum the result is NULL, otherwise the result 
                has cardinality multiple and base-type float. This is intentionally empty.                
            </xs:documentation>
        </xs:annotation>
        <xs:complexContent>
            <xs:extension base="EmptyPrimitiveType.Type">
                <xs:attributeGroup ref="sectionIdentifier.OutcomeMinMax.Attr" />
                <xs:attributeGroup ref="includeCategory.OutcomeMinMax.Attr" />
                <xs:attributeGroup ref="excludeCategory.OutcomeMinMax.Attr" />
                <xs:attributeGroup ref="outcomeIdentifier.OutcomeMinMax.Attr" />
                <xs:attributeGroup ref="weightIdentifier.OutcomeMinMax.Attr" />
            </xs:extension>
        </xs:complexContent>
    </xs:complexType>

    <xs:complexType name="Param.Type" abstract="false" mixed="false">
        <xs:annotation>
            <xs:documentation source="documentation">
                The Param complexType is the container for the parameter information to be used for the a-
                ssociated object. AN Object can have zero or more parameters.                             
            </xs:documentation>
        </xs:annotation>
        <xs:complexContent>
            <xs:extension base="EmptyPrimitiveType.Type">
                <xs:attributeGroup ref="name.Param.Attr" />
                <xs:attributeGroup ref="value.Param.Attr" />
                <xs:attributeGroup ref="valuetype.Param.Attr" />
                <xs:attributeGroup ref="type.Param.Attr" />
            </xs:extension>
        </xs:complexContent>
    </xs:complexType>

    <xs:complexType name="PrintedVariable.Type" abstract="false" mixed="false">
        <xs:annotation>
            <xs:documentation source="documentation">
                The PrintedVariable complexType is the container for variables that are to be printed. The
                outcome variable or template variable must have been defined and have single cardinality. 
                The values of response variables cannot be printed directly as their values are implicitly
                known to the candidate through the interactions they are bound to; if necessary, their va-
                lues can be assigned to outcomes during responseProcessing and displayed to the candidate 
                as part of a bodyElement visible only in the appropriate feedback states.                 
            </xs:documentation>
        </xs:annotation>
        <xs:complexContent>
            <xs:extension base="EmptyPrimitiveType.Type">
                <xs:attributeGroup ref="id.PrintedVariable.Attr" />
                <xs:attributeGroup ref="class.PrintedVariable.Attr" />
                <xs:attributeGroup ref="xmllang.PrintedVariable.Attr" />
                <xs:attributeGroup ref="label.PrintedVariable.Attr" />
                <xs:attributeGroup ref="xmlbase.PrintedVariable.Attr" />
                <xs:attributeGroup ref="identifier.PrintedVariable.Attr" />
                <xs:attributeGroup ref="format.PrintedVariable.Attr" />
                <xs:attributeGroup ref="base.PrintedVariable.Attr" />
                <xs:attributeGroup ref="index.PrintedVariable.Attr" />
                <xs:attributeGroup ref="powerForm.PrintedVariable.Attr" />
                <xs:attributeGroup ref="field.PrintedVariable.Attr" />
                <xs:attributeGroup ref="delimiter.PrintedVariable.Attr" />
                <xs:attributeGroup ref="mappingIndicator.PrintedVariable.Attr" />
            </xs:extension>
        </xs:complexContent>
    </xs:complexType>

    <xs:complexType name="RandomFloat.Type" abstract="false" mixed="false">
        <xs:annotation>
            <xs:documentation source="documentation">
                Selects a random float from the specified range [min,max]. This is intentionally empty.   
            </xs:documentation>
        </xs:annotation>
        <xs:complexContent>
            <xs:extension base="EmptyPrimitiveType.Type">
                <xs:attributeGroup ref="min.RandomFloat.Attr" />
                <xs:attributeGroup ref="max.RandomFloat.Attr" />
            </xs:extension>
        </xs:complexContent>
    </xs:complexType>

    <xs:complexType name="RandomInteger.Type" abstract="false" mixed="false">
        <xs:annotation>
            <xs:documentation source="documentation">
                Selects a random integer from the specified range [min,max] satisfying min + step * n for 
                some integer n. For example, with min=2, max=11 and step=3 the values {2,5,8,11} are poss-
                ible.                                                                                     
            </xs:documentation>
        </xs:annotation>
        <xs:complexContent>
            <xs:extension base="EmptyPrimitiveType.Type">
                <xs:attributeGroup ref="min.RandomInteger.Attr" />
                <xs:attributeGroup ref="max.RandomInteger.Attr" />
                <xs:attributeGroup ref="step.RandomInteger.Attr" />
            </xs:extension>
        </xs:complexContent>
    </xs:complexType>

    <xs:complexType name="StyleSheet.Type" abstract="false" mixed="false">
        <xs:annotation>
            <xs:documentation source="documentation">
                This is used to associate an external stylesheet (it is assumed that this takes the form  
                of a CSS file but other formats are permitted).                                           
            </xs:documentation>
        </xs:annotation>
        <xs:complexContent>
            <xs:extension base="EmptyPrimitiveType.Type">
                <xs:attributeGroup ref="href.StyleSheet.Attr" />
                <xs:attributeGroup ref="type.StyleSheet.Attr" />
                <xs:attributeGroup ref="media.StyleSheet.Attr" />
                <xs:attributeGroup ref="title.StyleSheet.Attr" />
            </xs:extension>
        </xs:complexContent>
    </xs:complexType>

    <xs:complexType name="TestVariables.Type" abstract="false" mixed="false">
        <xs:annotation>
            <xs:documentation source="documentation">
                This expression, which can only be used in outcomes processing, simultaneously looks up t-
                he value of an itemVariable in a sub-set of the items referred to in a test. Only variabl-
                es with single cardinality are considered, all NULL values are ignored. The result has ca-
                rdinality multiple and base-type as specified below. This is intentionally empty.         
            </xs:documentation>
        </xs:annotation>
        <xs:complexContent>
            <xs:extension base="EmptyPrimitiveType.Type">
                <xs:attributeGroup ref="sectionIdentifier.TestVariables.Attr" />
                <xs:attributeGroup ref="includeCategory.TestVariables.Attr" />
                <xs:attributeGroup ref="excludeCategory.TestVariables.Attr" />
                <xs:attributeGroup ref="variableIdentifier.TestVariables.Attr" />
                <xs:attributeGroup ref="weightIdentifier.TestVariables.Attr" />
                <xs:attributeGroup ref="baseType.TestVariables.Attr" />
            </xs:extension>
        </xs:complexContent>
    </xs:complexType>

    <xs:complexType name="TextEntryInteraction.Type" abstract="false" mixed="false">
        <xs:annotation>
            <xs:documentation source="documentation">
                The TestEntryInteraction complexType is the container for information about a textEntry i-
                nteraction. A textEntry interaction is an inlineInteraction that obtains a simple piece of
                text from the candidate. Like inlineChoiceInteraction, the delivery engine must allow the 
                candidate to review their choice within the context of the surrounding text. The textEntr-
                yInteraction must be bound to a response variable with single cardinality only. The baseT-
                ype must be one of string, integer or float. This complexType is intentionally empty.     
            </xs:documentation>
        </xs:annotation>
        <xs:complexContent>
            <xs:extension base="EmptyPrimitiveType.Type">
                <xs:attributeGroup ref="xmlbase.TextEntryInteraction.Attr" />
                <xs:attributeGroup ref="id.TextEntryInteraction.Attr" />
                <xs:attributeGroup ref="class.TextEntryInteraction.Attr" />
                <xs:attributeGroup ref="xmllang.TextEntryInteraction.Attr" />
                <xs:attributeGroup ref="label.TextEntryInteraction.Attr" />
                <xs:attributeGroup ref="responseIdentifier.TextEntryInteraction.Attr" />
                <xs:attributeGroup ref="base.TextEntryInteraction.Attr" />
                <xs:attributeGroup ref="stringIdentifier.TextEntryInteraction.Attr" />
                <xs:attributeGroup ref="expectedLength.TextEntryInteraction.Attr" />
                <xs:attributeGroup ref="patternMask.TextEntryInteraction.Attr" />
                <xs:attributeGroup ref="placeholderText.TextEntryInteraction.Attr" />
            </xs:extension>
        </xs:complexContent>
    </xs:complexType>

    <xs:complexType name="TimeLimits.Type" abstract="false" mixed="false">
        <xs:annotation>
            <xs:documentation source="documentation">
                In the context of a specific assessmentTest an item, or group of items, may be subject to 
                a time constraint. The QTI specification supports both minimum and maximum time constrain-
                ts. The controlled time for a single item is simply the duration of the item session as d-
                efined by the builtin response variable duration. For assessmentSections, testParts and w-
                hole assessmentTests the time limits relate to the durations of all the item sessions plus
                any other time spent navigating that part of the test. In other words, the time includes  
                time spent in states where no item is being interacted with, such as dedicated navigation 
                screens. This complexType is intentionally empty.                                         
            </xs:documentation>
        </xs:annotation>
        <xs:complexContent>
            <xs:extension base="EmptyPrimitiveType.Type">
                <xs:attributeGroup ref="minTime.TimeLimits.Attr" />
                <xs:attributeGroup ref="maxTime.TimeLimits.Attr" />
                <xs:attributeGroup ref="allowLateSubmission.TimeLimits.Attr" />
            </xs:extension>
        </xs:complexContent>
    </xs:complexType>

    <xs:complexType name="Value.Type" abstract="false" mixed="false">
        <xs:annotation>
            <xs:documentation source="documentation">
                A class that can represent a single value of any baseType in variable declarations and re-
                sult reports. The base-type is defined by the baseType attribute of the declaration except
                in the case of variables with record cardinality.                                         
            </xs:documentation>
        </xs:annotation>
        <xs:simpleContent>
            <xs:extension base="xs:normalizedString">
                <xs:attributeGroup ref="fieldIdentifier.Value.Attr" />
                <xs:attributeGroup ref="baseType.Value.Attr" />
            </xs:extension>
        </xs:simpleContent>
    </xs:complexType>

    <xs:complexType name="Variable.Type" abstract="false" mixed="false">
        <xs:annotation>
            <xs:documentation source="documentation">
                This expression looks up the value of an itemVariable that has been declared in a corresp-
                onding variableDeclaration or is one of the built-in variables. The result has the base-t-
                ype and cardinality declared for the variable subject to the type promotion of weighted o-
                utcomes. This is intentionally empty.                                                     
            </xs:documentation>
        </xs:annotation>
        <xs:complexContent>
            <xs:extension base="EmptyPrimitiveType.Type">
                <xs:attributeGroup ref="identifier.Variable.Attr" />
                <xs:attributeGroup ref="weightIdentifier.Variable.Attr" />
            </xs:extension>
        </xs:complexContent>
    </xs:complexType>

    <xs:complexType name="VariableMapping.Type" abstract="false" mixed="false">
        <xs:annotation>
            <xs:documentation source="documentation">
                The VariableMapping complexType is the contains the variable mappings that allow outcome  
                variables declared with the name sourceIdentifier in the corresponding item to be treated 
                as if they were declared with the name targetIdentifier during outcomeProcessing. Use of  
                variable mappings allows more control over the way outcomes are aggregated when using tes-
                tVariables.                                                                               
            </xs:documentation>
        </xs:annotation>
        <xs:complexContent>
            <xs:extension base="EmptyPrimitiveType.Type">
                <xs:attributeGroup ref="sourceIdentifier.VariableMapping.Attr" />
                <xs:attributeGroup ref="targetIdentifier.VariableMapping.Attr" />
            </xs:extension>
        </xs:complexContent>
    </xs:complexType>

    <xs:complexType name="Weight.Type" abstract="false" mixed="false">
        <xs:annotation>
            <xs:documentation source="documentation">
                The Weight complexType stores the weighting information. The contribution of an individual
                item score to an overall test score typically varies from test to test. The score of the  
                item is said to be weighted. Weights are defined as part of each reference to an item (as-
                sessmentItemRef) within a test.                                                           
            </xs:documentation>
        </xs:annotation>
        <xs:complexContent>
            <xs:extension base="EmptyPrimitiveType.Type">
                <xs:attributeGroup ref="identifier.Weight.Attr" />
                <xs:attributeGroup ref="value.Weight.Attr" />
            </xs:extension>
        </xs:complexContent>
    </xs:complexType>

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

    <!-- Declaration of the elements (Complex) ************************************************************ -->

    <xs:element name="a" type="A.Type" />

    <xs:element name="abbr" type="HTMLText.Type" />

    <xs:element name="acronym" type="HTMLText.Type" />

    <xs:element name="address" type="HTMLText.Type" />

    <xs:element name="and" type="Logic1toMany.Type" />

    <xs:element name="anyN" type="AnyN.Type" />

    <xs:element name="areaMapping" type="AreaMapping.Type" />

    <xs:element name="assessmentItemRef" type="AssessmentItemRef.Type" />

    <xs:element name="associateInteraction" type="AssociateInteraction.Type" />

    <xs:element name="b" type="HTMLText.Type" />

    <xs:element name="big" type="HTMLText.Type" />

    <xs:element name="blockquote" type="BlockQuote.Type" />

    <xs:element name="branchRule" type="BranchRule.Type" />

    <xs:element name="caption" type="Caption.Type" />

    <xs:element name="choiceInteraction" type="ChoiceInteraction.Type" />

    <xs:element name="cite" type="HTMLText.Type" />

    <xs:element name="code" type="HTMLText.Type" />

    <xs:element name="colgroup" type="ColGroup.Type" />

    <xs:element name="containerSize" type="LogicSingle.Type" />

    <xs:element name="contains" type="LogicPair.Type" />

    <xs:element name="correctResponse" type="CorrectResponse.Type" />

    <xs:element name="customInteraction" type="CustomInteraction.Type" />

    <xs:element name="customOperator" type="CustomOperator.Type" />

    <xs:element name="dd" type="DD.Type" />

    <xs:element name="defaultValue" type="DefaultValue.Type" />

    <xs:element name="delete" type="LogicPair.Type" />

    <xs:element name="dfn" type="HTMLText.Type" />

    <xs:element name="div" type="Div.Type" />

    <xs:element name="divide" type="LogicPair.Type" />

    <xs:element name="dl" type="DL.Type" />

    <xs:element name="drawingInteraction" type="DrawingInteraction.Type" />

    <xs:element name="dt" type="DT.Type" />

    <xs:element name="durationGTE" type="LogicPair.Type" />

    <xs:element name="durationLT" type="LogicPair.Type" />

    <xs:element name="em" type="HTMLText.Type" />

    <xs:element name="equal" type="Equal.Type" />

    <xs:element name="equalRounded" type="EqualRounded.Type" />

    <xs:element name="extendedTextInteraction" type="ExtendedTextInteraction.Type" />

    <xs:element name="feedbackBlock" type="FeedbackBlock.Type" />

    <xs:element name="feedbackInline" type="FeedbackInline.Type" />

    <xs:element name="fieldValue" type="FieldValue.Type" />

    <xs:element name="gapImg" type="GapImg.Type" />

    <xs:element name="gapMatchInteraction" type="GapMatchInteraction.Type" />

    <xs:element name="gapText" type="GapText.Type" />

    <xs:element name="gcd" type="Logic1toMany.Type" />

    <xs:element name="graphicAssociateInteraction" type="GraphicAssociateInteraction.Type" />

    <xs:element name="graphicGapMatchInteraction" type="GraphicGapMatchInteraction.Type" />

    <xs:element name="graphicOrderInteraction" type="GraphicOrderInteraction.Type" />

    <xs:element name="gt" type="LogicPair.Type" />

    <xs:element name="gte" type="LogicPair.Type" />

    <xs:element name="h1" type="HTMLText.Type" />

    <xs:element name="h2" type="HTMLText.Type" />

    <xs:element name="h3" type="HTMLText.Type" />

    <xs:element name="h4" type="HTMLText.Type" />

    <xs:element name="h5" type="HTMLText.Type" />

    <xs:element name="h6" type="HTMLText.Type" />

    <xs:element name="hotspotInteraction" type="HotspotInteraction.Type" />

    <xs:element name="hottext" type="HotText.Type" />

    <xs:element name="hottextInteraction" type="HotTextInteraction.Type" />

    <xs:element name="i" type="HTMLText.Type" />

    <xs:element name="index" type="Index.Type" />

    <xs:element name="infoControl" type="InfoControl.Type" />

    <xs:element name="inlineChoice" type="InlineChoice.Type" />

    <xs:element name="inlineChoiceInteraction" type="InlineChoiceInteraction.Type" />

    <xs:element name="inside" type="Inside.Type" />

    <xs:element name="integerDivide" type="LogicPair.Type" />

    <xs:element name="integerModulus" type="LogicPair.Type" />

    <xs:element name="integerToFloat" type="LogicSingle.Type" />

    <xs:element name="interpolationTable" type="InterpolationTable.Type" />

    <xs:element name="isNull" type="LogicSingle.Type" />

    <xs:element name="itemBody" type="ItemBody.Type" />

    <xs:element name="kbd" type="HTMLText.Type" />

    <xs:element name="lcm" type="Logic1toMany.Type" />

    <xs:element name="lookupOutcomeValue" type="LookupOutcomeValue.Type" />

    <xs:element name="lt" type="LogicPair.Type" />

    <xs:element name="lte" type="LogicPair.Type" />

    <xs:element name="mapping" type="Mapping.Type" />

    <xs:element name="match" type="LogicPair.Type" />

    <xs:element name="matchInteraction" type="MatchInteraction.Type" />

    <xs:element name="matchTable" type="MatchTable.Type" />

    <xs:element name="mathOperator" type="MathOperator.Type" />

    <xs:element name="max" type="Logic1toMany.Type" />

    <xs:element name="mediaInteraction" type="MediaInteraction.Type" />

    <xs:element name="member" type="LogicPair.Type" />

    <xs:element name="min" type="Logic1toMany.Type" />

    <xs:element name="modalFeedback" type="ModalFeedback.Type" />

    <xs:element name="multiple" type="Logic0toMany.Type" />

    <xs:element name="not" type="LogicSingle.Type" />

    <xs:element name="object" type="Object.Type" />

    <xs:element name="ol" type="OUL.Type" />

    <xs:element name="or" type="Logic1toMany.Type" />

    <xs:element name="ordered" type="Logic0toMany.Type" />

    <xs:element name="ordering" type="Ordering.Type" />

    <xs:element name="orderInteraction" type="OrderInteraction.Type" />

    <xs:element name="outcomeCondition" type="OutcomeCondition.Type" />

    <xs:element name="outcomeElse" type="OutcomeElse.Type" />

    <xs:element name="outcomeElseIf" type="OutcomeIf.Type" />

    <xs:element name="outcomeIf" type="OutcomeIf.Type" />

    <xs:element name="outcomeProcessing" type="OutcomeProcessing.Type" />

    <xs:element name="outcomeProcessingFragment" type="OutcomeProcessingFragment.Type" />

    <xs:element name="p" type="HTMLText.Type" />

    <xs:element name="patternMatch" type="PatternMatch.Type" />

    <xs:element name="positionObjectInteraction" type="PositionObjectInteraction.Type" />

    <xs:element name="positionObjectStage" type="PositionObjectStage.Type" />

    <xs:element name="power" type="LogicPair.Type" />

    <xs:element name="pre" type="HTMLText.Type" />

    <xs:element name="preCondition" type="LogicSingle.Type" />

    <xs:element name="product" type="Logic1toMany.Type" />

    <xs:element name="prompt" type="Prompt.Type" />

    <xs:element name="q" type="Q.Type" />

    <xs:element name="random" type="LogicSingle.Type" />

    <xs:element name="repeat" type="Repeat.Type" />

    <xs:element name="responseCondition" type="ResponseCondition.Type" />

    <xs:element name="responseDeclaration" type="ResponseDeclaration.Type" />

    <xs:element name="responseProcessingFragment" type="ResponseProcessingFragment.Type" />

    <xs:element name="round" type="LogicSingle.Type" />

    <xs:element name="roundTo" type="RoundTo.Type" />

    <xs:element name="rubricBlock" type="RubricBlock.Type" />

    <xs:element name="samp" type="HTMLText.Type" />

    <xs:element name="selection" type="Selection.Type" />

    <xs:element name="selectPointInteraction" type="SelectPointInteraction.Type" />

    <xs:element name="setCorrectResponse" type="SetValue.Type" />

    <xs:element name="setDefaultValue" type="SetValue.Type" />

    <xs:element name="setOutcomeValue" type="SetValue.Type" />

    <xs:element name="setTemplateValue" type="SetValue.Type" />

    <xs:element name="simpleAssociableChoice" type="SimpleAssociableChoice.Type" />

    <xs:element name="simpleChoice" type="SimpleChoice.Type" />

    <xs:element name="simpleMatchSet" type="SimpleMatchSet.Type" />

    <xs:element name="sliderInteraction" type="SliderInteraction.Type" />

    <xs:element name="small" type="HTMLText.Type" />

    <xs:element name="span" type="HTMLText.Type" />

    <xs:element name="statsOperator" type="StatsOperator.Type" />

    <xs:element name="stringMatch" type="StringMatch.Type" />

    <xs:element name="strong" type="HTMLText.Type" />

    <xs:element name="sub" type="HTMLText.Type" />

    <xs:element name="substring" type="Substring.Type" />

    <xs:element name="subtract" type="LogicPair.Type" />

    <xs:element name="sum" type="NumericLogic1toMany.Type" />

    <xs:element name="sup" type="HTMLText.Type" />

    <xs:element name="table" type="Table.Type" />

    <xs:element name="tbody" type="TablePart.Type" />

    <xs:element name="td" type="TDH.Type" />

    <xs:element name="templateBlock" type="TemplateBlock.Type" />

    <xs:element name="templateCondition" type="TemplateCondition.Type" />

    <xs:element name="templateConstraint" type="TemplateConstraint.Type" />

    <xs:element name="templateDeclaration" type="TemplateDeclaration.Type" />

    <xs:element name="templateDefault" type="TemplateDefault.Type" />

    <xs:element name="templateElse" type="TemplateElse.Type" />

    <xs:element name="templateElseIf" type="TemplateIf.Type" />

    <xs:element name="templateIf" type="TemplateIf.Type" />

    <xs:element name="templateInline" type="TemplateInline.Type" />

    <xs:element name="templateProcessing" type="TemplateProcessing.Type" />

    <xs:element name="testFeedback" type="TestFeedback.Type" />

    <xs:element name="testPart" type="TestPart.Type" />

    <xs:element name="tfoot" type="TablePart.Type" />

    <xs:element name="th" type="TDH.Type" />

    <xs:element name="thead" type="TablePart.Type" />

    <xs:element name="tr" type="TR.Type" />

    <xs:element name="truncate" type="LogicSingle.Type" />

    <xs:element name="tt" type="HTMLText.Type" />

    <xs:element name="ul" type="OUL.Type" />

    <xs:element name="uploadInteraction" type="UploadInteraction.Type" />

    <xs:element name="var" type="HTMLText.Type" />

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

    <!-- Declaration of the elements (Derived) ************************************************************ -->

    <xs:element name="areaMapEntry" type="AreaMapEntry.Type" />

    <xs:element name="assessmentSectionRef" type="AssessmentSectionRef.Type" />

    <xs:element name="associableHotspot" type="AssociableHotspot.Type" />

    <xs:element name="baseValue" type="BaseValue.Type" />

    <xs:element name="br" type="BR.Type" />

    <xs:element name="col" type="Col.Type" />

    <xs:element name="correct" type="Correct.Type" />

    <xs:element name="default" type="Default.Type" />

    <xs:element name="endAttemptInteraction" type="EndAttemptInteraction.Type" />

    <xs:element name="gap" type="Gap.Type" />

    <xs:element name="hotspotChoice" type="HotspotChoice.Type" />

    <xs:element name="hr" type="HR.Type" />

    <xs:element name="img" type="Img.Type" />

    <xs:element name="interpolationTableEntry" type="InterpolationTableEntry.Type" />

    <xs:element name="itemSessionControl" type="ItemSessionControl.Type" />

    <xs:element name="mapEntry" type="MapEntry.Type" />

    <xs:element name="mapResponse" type="MapResponse.Type" />

    <xs:element name="mapResponsePoint" type="MapResponse.Type" />

    <xs:element name="matchTableEntry" type="MatchTableEntry.Type" />

    <xs:element name="mathConstant" type="MathConstant.Type" />

    <xs:element name="numberCorrect" type="Number.Type" />

    <xs:element name="numberIncorrect" type="Number.Type" />

    <xs:element name="numberPresented" type="Number.Type" />

    <xs:element name="numberResponded" type="Number.Type" />

    <xs:element name="numberSelected" type="Number.Type" />

    <xs:element name="outcomeMaximum" type="OutcomeMinMax.Type" />

    <xs:element name="outcomeMinimum" type="OutcomeMinMax.Type" />

    <xs:element name="param" type="Param.Type" />

    <xs:element name="printedVariable" type="PrintedVariable.Type" />

    <xs:element name="randomFloat" type="RandomFloat.Type" />

    <xs:element name="randomInteger" type="RandomInteger.Type" />

    <xs:element name="stylesheet" type="StyleSheet.Type" />

    <xs:element name="testVariables" type="TestVariables.Type" />

    <xs:element name="textEntryInteraction" type="TextEntryInteraction.Type" />

    <xs:element name="timeLimits" type="TimeLimits.Type" />

    <xs:element name="value" type="Value.Type" />

    <xs:element name="variable" type="Variable.Type" />

    <xs:element name="variableMapping" type="VariableMapping.Type" />

    <xs:element name="weight" type="Weight.Type" />

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

    <!-- Declaration of the root element(s) *************************************************************** -->

    <xs:element name="assessmentItem" type="AssessmentItem.Type" />
    <xs:element name="assessmentSection" type="AssessmentSection.Type" />
    <xs:element name="assessmentTest" type="AssessmentTest.Type" />
    <xs:element name="outcomeDeclaration" type="OutcomeDeclaration.Type" />
    <xs:element name="responseProcessing" type="ResponseProcessing.Type" />

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

</xs:schema>
