<?xml version="1.0" encoding="utf-8"?>
<?xml-stylesheet type="text/xsl" href="documentation/transform-xsd.xsl"?>
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema"
	xmlns="http://mint-kolleg.kit.edu/edML"
	xmlns:edml="http://mint-kolleg.kit.edu/edML"
	xmlns:edmldoc="http://mint-kolleg.kit.edu/edML-documentation"
	targetNamespace="http://mint-kolleg.kit.edu/edML"
	elementFormDefault="qualified">
  
  	<xs:import namespace="http://www.w3.org/XML/1998/namespace" schemaLocation="http://www.w3.org/2001/xml.xsd"/>
  	    
    <!-- ### Course structure level ### -->

    <xs:complexType name="Course">
        <xs:annotation>
            <xs:documentation>Root element of the course.</xs:documentation>
        </xs:annotation>
        <xs:sequence>
            <xs:element name="settings" minOccurs="1" maxOccurs="1" type="CourseSettings"/>
            <xs:sequence>
                <xs:element ref="variant" minOccurs="1" maxOccurs="unbounded"/>
            </xs:sequence>
        </xs:sequence>
        <xs:attributeGroup ref="RootAttributes"/>
        <xs:attribute name="edmlversion" type="xs:string" use="optional" fixed="0.2.2">
            <xs:annotation>
                <xs:documentation>Version of the education markup language that this course is written in. Must match the language version of this schema.</xs:documentation>
                </xs:annotation>
        </xs:attribute>

    </xs:complexType>
    
    <xs:complexType name="CourseSettings">
        <xs:annotation>
            <xs:documentation>Contains all global course settings.</xs:documentation>
        </xs:annotation>
        <xs:all>
          <xs:element name="defaultvariant" minOccurs="0" maxOccurs="1" type="xs:language">
              <xs:annotation>
                  <xs:documentation>Sets the default variant of the course by specifying its language.</xs:documentation>
              </xs:annotation>
          </xs:element>
          <xs:element name="inputmodels" minOccurs="0" maxOccurs="1" type="InputModels"/>
          <xs:element name="styles" minOccurs="0" maxOccurs="1" type="Styles"></xs:element>
        </xs:all>
    </xs:complexType>
    
    <xs:complexType name="Styles">
    	<xs:annotation>
    		<xs:documentation>Contains one or more style assignments to elements with specified roles.</xs:documentation>
    		<xs:appinfo>
    			<edmldoc:example>
    				<edmldoc:description></edmldoc:description>
    				<edmldoc:code><![CDATA[<style>
  <style role="base">
    color: blue;
  </style>
  <style role="acid">
    color: red;
  </style>
</styles>]]></edmldoc:code>
    			</edmldoc:example>
    		</xs:appinfo>
    	</xs:annotation>
    	<xs:sequence>
    		<xs:element name="style" type="Style" minOccurs="1" maxOccurs="unbounded"/>
    	</xs:sequence>
    </xs:complexType>
    
    <xs:complexType name="Style">
    	<xs:annotation>
    		<xs:documentation>Assigns a list of CSS style declarations to all elements with a specified role.</xs:documentation>
    		<xs:appinfo>
    			<edmldoc:example>
    				<edmldoc:description></edmldoc:description>
    				<edmldoc:code><![CDATA[<style role="term">
 font-weight: bold;
</style>]]></edmldoc:code>
    			</edmldoc:example>
    		</xs:appinfo>
    	</xs:annotation>
    	<xs:simpleContent>
    		<xs:extension base="CSSDeclarations">
    			<xs:attribute name="role" use="required" type="xs:Name">
    				<xs:annotation>
    					<xs:documentation>The role which an element must have in order for this style setting to apply.</xs:documentation>
    				</xs:annotation>
    			</xs:attribute>
    		</xs:extension>
    	</xs:simpleContent>
    </xs:complexType>
    
    <xs:simpleType name="CSSDeclarations">
    	<xs:annotation>
    		<xs:documentation>Zero or more CSS style declarations, each one terminated by a semicolon.</xs:documentation>
    	</xs:annotation>
    	<xs:restriction base="xs:string">
    		<xs:pattern value="([^:\s]+)*\s*:\s*([^;]+);"></xs:pattern>
    	</xs:restriction>
    </xs:simpleType>
    
    <xs:complexType name="InputModels">
        <xs:annotation>
            <xs:documentation>Defines the settings for input elements in this course.</xs:documentation>
        </xs:annotation>
        <xs:sequence>
            <xs:element name="inputmodel" minOccurs="0" maxOccurs="unbounded" type="InputModel" />
        </xs:sequence>
    </xs:complexType>
    
    <xs:complexType name="InputModel">
    		<xs:annotation>
            <xs:documentation>
            	A group of settings for input elements that can be enabled by using the <code>model</code> attribute on input elements.
            	If the <code>name</code> attribute is not set, this input model describes the default input model.
            </xs:documentation>
        </xs:annotation>
        <xs:all>
        		<xs:element name="string" minOccurs="0" maxOccurs="1" type="StringInputModel"/>
        		<xs:element name="order" minOccurs="0" maxOccurs="1" type="OrderInputModel"/>
        		<xs:element name="matching" minOccurs="0" maxOccurs="1" type="MatchingInputModel"/>
        		<xs:element name="boolean" minOccurs="0" maxOccurs="1" type="BooleanInputModel"/>
						<xs:element name="choice" minOccurs="0" maxOccurs="1" type="ChoiceInputModel"/>
						<xs:element name="number" minOccurs="0" maxOccurs="1" type="NumberInputModel"/>
						<xs:element name="exponential" minOccurs="0" maxOccurs="1" type="ExponentialInputModel"/>
						<xs:element name="expression" minOccurs="0" maxOccurs="1" type="ExpressionInputModel"/>
						<xs:element name="set" minOccurs="0" maxOccurs="1" type="SetInputModel"/>
						<xs:element name="vector" minOccurs="0" maxOccurs="1" type="VectorInputModel"/>
						<xs:element name="matrix" minOccurs="0" maxOccurs="1" type="MatrixInputModel"/>
						<xs:element name="interval" minOccurs="0" maxOccurs="1" type="IntervalInputModel"/>
						<xs:element name="unit" minOccurs="0" maxOccurs="1" type="UnitInputModel"/>
						<xs:element name="quantity" minOccurs="0" maxOccurs="1" type="QuantityInputModel"/>
						<xs:element name="molecular" minOccurs="0" maxOccurs="1" type="MolecularInputModel"/>
						<xs:element name="reaction" minOccurs="0" maxOccurs="1" type="ReactionInputModel"/>
        </xs:all>
        <xs:attribute name="name" type="xs:Name" use="optional">
        	<xs:annotation>
        			<xs:documentation>Name of this input model. If this is not set, this input model describes the default input model.</xs:documentation>
        	</xs:annotation>
        </xs:attribute>
    </xs:complexType>
	
    <xs:simpleType name="LabelFormat">
        <xs:annotation>
            <xs:documentation>A format for the automatic generation of labels.</xs:documentation>
        </xs:annotation>
        <xs:restriction base="xs:NMTOKEN">
            <xs:enumeration value="none"><xs:annotation><xs:documentation>No labels.</xs:documentation></xs:annotation></xs:enumeration>
            <xs:enumeration value="arabic"><xs:annotation><xs:documentation>1,2,3,4,5...</xs:documentation></xs:annotation></xs:enumeration>
            <xs:enumeration value="roman"><xs:annotation><xs:documentation>i,ii,iii,iv,v...</xs:documentation></xs:annotation></xs:enumeration>
            <xs:enumeration value="Roman"><xs:annotation><xs:documentation>I,II,III,IV,V...</xs:documentation></xs:annotation></xs:enumeration>
            <xs:enumeration value="letter"><xs:annotation><xs:documentation>a,b,c,d,e,...</xs:documentation></xs:annotation></xs:enumeration>
            <xs:enumeration value="Letter"><xs:annotation><xs:documentation>A,B,C,D,E,...</xs:documentation></xs:annotation></xs:enumeration>
            <xs:enumeration value="greek"><xs:annotation><xs:documentation>α,β,γ,δ,ε,...</xs:documentation></xs:annotation></xs:enumeration>
            <xs:enumeration value="bullet"><xs:annotation><xs:documentation>Use bullet points as labels.</xs:documentation></xs:annotation></xs:enumeration>
            <xs:enumeration value="dot"><xs:annotation><xs:documentation>Use dots as labels.</xs:documentation></xs:annotation></xs:enumeration>
            <xs:enumeration value="dash"><xs:annotation><xs:documentation>Use dashed as labels.</xs:documentation></xs:annotation></xs:enumeration>
        </xs:restriction>
    </xs:simpleType>

    <xs:complexType name="Variant">
        <xs:annotation>
            <xs:documentation>A variant of the course for a specified language.</xs:documentation>
        </xs:annotation>
        <xs:sequence>
          	<xs:element name="title" type="Title"/>
            <xs:element name="navigation" type="Navigation"/>
            <xs:element name="pages" type="Pages"/>
        </xs:sequence>
        <xs:attribute name="lang" use="required" type="xs:language">
            <xs:annotation>
                <xs:documentation>Language of this course variant according to RFC 5646, must be unique among all course variants in this course.</xs:documentation>
            </xs:annotation>
        </xs:attribute>
        <xs:attributeGroup ref="RootAttributes"/>
    </xs:complexType>
    
    <xs:complexType name="Title" mixed="true">
        <xs:annotation>
            <xs:documentation>Title of either a course variant, a page, a container or a panel.</xs:documentation>
        </xs:annotation>
        <xs:sequence>
            <xs:group ref="InlineGroup" minOccurs="0" maxOccurs="unbounded"/>
        </xs:sequence>
        <xs:attribute name="short" use="optional" type="xs:string">
            <xs:annotation>
                <xs:documentation>Alternative short version of the title that can be used in situations where the full title can not be displayed.</xs:documentation>
            </xs:annotation>
        </xs:attribute>
    </xs:complexType>    
    
    <xs:complexType name="Navigation">
        <xs:annotation>
            <xs:documentation>Contains all information about the navigation menu of a course variant.</xs:documentation>
        </xs:annotation>
        <xs:sequence>
            <xs:element name="navlist" type="NavigationList" minOccurs="1" maxOccurs="1"/>
        </xs:sequence>
        <xs:attributeGroup ref="IndentAttribute"/>
				<xs:attribute name="fullnumbering" type="xs:boolean" default="true">
					<xs:annotation>
						<xs:documentation>Whether or not the automatically generated labels of a navigation item should include the full numbering of all of its parent navigation items or only its number in the list of the children of its parent.</xs:documentation>
					</xs:annotation>
				</xs:attribute>
    </xs:complexType>
    
    <xs:complexType name="NavigationList">
        <xs:annotation>
            <xs:documentation>
                A list of one or more navigation items in the navigation menu.
            </xs:documentation>
        </xs:annotation>
        <xs:sequence>
            <xs:element minOccurs="1" maxOccurs="unbounded" name="navitem" type="NavigationItem"/>
        </xs:sequence>
        <xs:attribute name="format" type="LabelFormat" use="optional" default="arabic">
            <xs:annotation>
                <xs:documentation>
                    Format used for the automatically generated label of the navigation items in this list.
                </xs:documentation>
            </xs:annotation>
        </xs:attribute>
        <xs:attribute name="separator" type="xs:string" use="optional" default=".">
            <xs:annotation>
                <xs:documentation>
                    Separator used in the automatically generated label of the navigation items in this list.
                </xs:documentation>
            </xs:annotation>
        </xs:attribute>
        <xs:attribute name="lastsep" type="xs:boolean" use="optional" default="false">
            <xs:annotation>
                <xs:documentation>
                    Controls whether the last separator should be shown in the automatically generated label of the navigation items in this list.
                </xs:documentation>
            </xs:annotation>
        </xs:attribute>
    </xs:complexType>
    
    <xs:attributeGroup name="IndentAttribute">
    	<xs:attribute name="indent" type="xs:string" use="optional">
        	<xs:annotation>
        		<xs:documentation>The horizontal length (in CSS units) by which sub items should be indented. If this attribute is not set,
        			the application will indent by a default length, which is guaranteed to be strictly smaller than 0.</xs:documentation>
        	</xs:annotation>
        </xs:attribute>
    </xs:attributeGroup>
    
    <xs:complexType name="NavigationItem">
        <xs:annotation>
            <xs:documentation>
                One item in the navigation menu of the course variant.
            </xs:documentation>
        </xs:annotation>
        <xs:sequence>
            <xs:choice minOccurs="0" maxOccurs="1">
                <xs:element name="ref" type="Ref"/>
                <xs:element name="link" type="Link"/>
            </xs:choice>
            <xs:element name="navlist" type="NavigationList" minOccurs="0" maxOccurs="1"/>
        </xs:sequence>
        <xs:attribute name="name" type="xs:Name" use="optional">
            <xs:annotation>
                <xs:documentation>Name of this navigation item, must be unique among all names in this course variant.</xs:documentation>
            </xs:annotation>
        </xs:attribute>
        <xs:attribute name="tags" type="xs:NMTOKENS" use="optional">
            <xs:annotation>
                <xs:documentation>A space-separated list of tags for this navigation item.</xs:documentation>
            </xs:annotation>
        </xs:attribute>
        <xs:attribute name="roles" type="NavigationItemRoleList" use="optional">
            <xs:annotation>
                <xs:documentation>Gives this navigation items special roles. Must be a space-separated list of the roles "learnpath", "home", "impressum" and "privacy".</xs:documentation>
            </xs:annotation>
        </xs:attribute>
        <xs:attribute name="visible" type="xs:boolean" use="optional" default="true">
            <xs:annotation>
                <xs:documentation>Controls whether or not this navigation item should be visible for the user.</xs:documentation>
            </xs:annotation>
        </xs:attribute>
        <xs:attribute name="numbered" type="xs:boolean" use="optional" default="true">
            <xs:annotation>
                <xs:documentation>Controls whether or not this navigation item increases the counter for the automatically generated labels.</xs:documentation>
            </xs:annotation>
        </xs:attribute>
        <xs:attribute name="label" type="xs:string" use="optional">
            <xs:annotation>
                <xs:documentation>Custom label of this navigation item, overrides any automatically generated labels.</xs:documentation>
            </xs:annotation>
        </xs:attribute>
    	<xs:attributeGroup ref="DifficultyAttribute"/>
    </xs:complexType>
    
    <xs:simpleType name="NavigationItemRoleList">
        <xs:annotation>
            <xs:documentation>A space-separated list of navigation item roles.</xs:documentation>
        </xs:annotation>
        <xs:restriction>
          <xs:simpleType>
            <xs:list itemType="NavigationItemRole"/>
          </xs:simpleType>
          <xs:minLength value="1"/>
        </xs:restriction>
    </xs:simpleType>
    
    <xs:simpleType name="NavigationItemRole">
        <xs:annotation>
            <xs:documentation>A special role that a navigation item may have.</xs:documentation>
        </xs:annotation>
        <xs:restriction base="xs:NMTOKEN">
            <xs:enumeration value="learnpath"><xs:annotation><xs:documentation>Marks the navigation item as learn path.</xs:documentation></xs:annotation></xs:enumeration>
            <xs:enumeration value="home"><xs:annotation><xs:documentation>Marks the navigation item as starting page.</xs:documentation></xs:annotation></xs:enumeration>
            <xs:enumeration value="impressum"><xs:annotation><xs:documentation>Marks the navigation item as impressum.</xs:documentation></xs:annotation></xs:enumeration>
            <xs:enumeration value="privacy"><xs:annotation><xs:documentation>Marks the navigation item as privacy site.</xs:documentation></xs:annotation></xs:enumeration>
        </xs:restriction>                  
    </xs:simpleType>
    
    <xs:complexType name="Pages">
        <xs:annotation>
            <xs:documentation>
                Contains all pages of a course variant.
            </xs:documentation>
        </xs:annotation>
        <xs:sequence minOccurs="0" maxOccurs="unbounded">
            <xs:element ref="page"/>
        </xs:sequence>
    </xs:complexType>
    
    <xs:complexType name="Page">
        <xs:annotation>
            <xs:documentation>
                One page in the course, consists of an optional title and a sequence of containers.
            </xs:documentation>
        </xs:annotation>
        <xs:sequence>
            <xs:sequence>
                <xs:element name="title" type="Title" minOccurs="0" maxOccurs="1"/>
                <xs:group ref="ContainerGroup" minOccurs="0" maxOccurs="unbounded"/>
            </xs:sequence>   
        </xs:sequence>
        <xs:attribute name="name" type="xs:Name" use="required">
            <xs:annotation>
                <xs:documentation>Name of this page, must be unique among all names in this course variant.</xs:documentation>
            </xs:annotation>
        </xs:attribute>
        <xs:attribute name="tags" type="xs:NMTOKENS" use="optional">
            <xs:annotation>
                <xs:documentation>A space-separated list of tags for this page.</xs:documentation>
            </xs:annotation>
        </xs:attribute>
        <xs:attributeGroup ref="RootAttributes"/>
    </xs:complexType>
    
    <xs:attributeGroup name="RootAttributes">
    	<xs:attribute ref="xml:base"/>	
    </xs:attributeGroup>
    
    <!-- ### Root elements ### -->
    <xs:element name="course" type="Course">
        <xs:key name="Course_VariantLanguage">
            <xs:selector xpath="edml:variant"/>
            <xs:field xpath="@lang"/>
        </xs:key>
    </xs:element>
    
    <xs:element name="variant" type="Variant">
        <xs:unique name="Variant_Name">
            <xs:selector xpath=".//*"/>
            <xs:field xpath="@name"/>
        </xs:unique>
        
        <xs:keyref name="Variant_Ref" refer="Variant_Name">
            <xs:selector xpath=".//edml:ref"/>
            <xs:field xpath="@to"/>
        </xs:keyref>
    </xs:element>
    
    <xs:element name="page" type="Page">
				<xs:unique name="Page_Name">
            <xs:selector xpath=".//*"/>
            <xs:field xpath="@name"/>
        </xs:unique>
        
        <xs:unique name="Page_InputName">
            <xs:selector xpath=".//edml:input"/>
            <xs:field xpath="@name"/>
        </xs:unique>
        
        <xs:keyref name="Page_SolutionHint" refer="Page_InputName">
            <xs:selector xpath="edml:solutionhint"/>
            <xs:field xpath="@to"/>
        </xs:keyref>
    </xs:element>
    
    <!-- ### Container level ### -->
    
    <xs:complexType name="Parameter">
    	<xs:annotation>
    		<xs:documentation>
    			Defines a parameter whose value will be randomly chosen each time the page is reloaded.
    			The parameter can be used in all <code>calculate</code> elements and input elements inside the container in which it is defined.
    			Each time the page is reloaded, one of the value generators defined as child elements of this element is randomly chosen and called to generate a new parameter value.
    			Parameters can be defined at the start of each box and are only accessible inside the box in which they are defined.
    		</xs:documentation>
    		<xs:appinfo>
    			<edmldoc:example>
    				<edmldoc:description>The following parameter can take the values 1, 2, 3, 4, 5 and 20:</edmldoc:description>
    				<edmldoc:code><![CDATA[<parameter identifier="a">
  <range step="1">
    <value>1</value>
    <value>5</value>
  </range>
  <value>20</value>
</parameter>]]></edmldoc:code>
					</edmldoc:example>
    		</xs:appinfo>
    	</xs:annotation>
    	<xs:sequence>
    		<xs:sequence minOccurs="1" maxOccurs="unbounded">
    			<xs:group ref="ParameterValueGeneratorGroup"/>
  			</xs:sequence>
    	</xs:sequence>
    	<xs:attribute name="identifier" use="required" type="xs:Name">
    		<xs:annotation>
    			<xs:documentation>
    				Defines the identifier by which this parameter can be referred to in all <code>calculate</code> and input elements inside the surrounding box.
    				Must be unique among all parameters defined in the surrounding box.
    			</xs:documentation>
    		</xs:annotation>
    	</xs:attribute>
    </xs:complexType>
    
    <xs:group name="ParameterValueGeneratorGroup">
    	<xs:choice>
    		<xs:element name="value" type="ParameterValue"/>
    		<xs:element name="range" type="ParameterRange"/>
    	</xs:choice>
    </xs:group>
    
    <xs:attributeGroup name="ParameterWeightAttribute">
    	<xs:attribute name="weight" use="optional" type="PositiveDecimal" default="1">
    		<xs:annotation>
    			<xs:documentation>Defines the weight of this parameter value generator among all value generators specified for the parameter.</xs:documentation>
    		</xs:annotation>
    	</xs:attribute>
    </xs:attributeGroup>
    
    <xs:complexType name="ParameterValue">
    	<xs:annotation>
    		<xs:documentation>Generates a single value for a parameter that can be a string or a number.</xs:documentation>
    	</xs:annotation>
    	<xs:simpleContent>
    		<xs:extension base="xs:string">
    			<xs:attributeGroup ref="ParameterWeightAttribute"/>
    		</xs:extension>
    	</xs:simpleContent>
    </xs:complexType>
    
    <xs:complexType name="NumericParameterValue">
    	<xs:annotation>
    		<xs:documentation>Generates a single value for a parameter that must be a number.</xs:documentation>
    	</xs:annotation>
    	<xs:simpleContent>
    		<xs:extension base="xs:decimal">
    			<xs:attributeGroup ref="ParameterWeightAttribute"/>
    		</xs:extension>
    	</xs:simpleContent>
    </xs:complexType>
    
		<xs:complexType name="ParameterRange">
			<xs:annotation>
    		<xs:documentation>
    			Uniformly generates a random value from a specified range for a parameter.
    			The start and end values for the range must be defined in the child elements.
    			In contrast to the values appearing direct in the parameter element, these two values must be numbers.
    		</xs:documentation>
    	</xs:annotation>
    	<xs:sequence>
    		<xs:element name="value" minOccurs="1" maxOccurs="2" type="NumericParameterValue"/>
    	</xs:sequence>
    	<xs:attributeGroup ref="ParameterWeightAttribute"/>
    	<xs:attribute name="step" use="optional" type="PositiveDecimal">
    		<xs:annotation>
    			<xs:documentation>
    				If this optional attribute is set, the range consists only of the numbers that are inside the interval defined by the start
    				and end values and by the closure attribute and whose absolute difference from the start value is a multiple of the step value.
    				Otherwise, the range is continuous.
    			</xs:documentation>
    		</xs:annotation>
    	</xs:attribute>
    	<xs:attribute name="closure" default="closed" type="IntervalClosureType">
    		<xs:annotation>
    			<xs:documentation>
    				The type of the interval which this range should be based on.
    				This decides whether or not the start and end values should be part of the range or not.</xs:documentation>
    		</xs:annotation>
    	</xs:attribute>
    </xs:complexType>
    
    <xs:attributeGroup name="ParameterRangeInclusiveAttribute">
    	<xs:attribute name="inclusive" type="xs:boolean" default="true">
    		<xs:annotation>
    			<xs:documentation>Whether or not the specified number should be part of the parameter value range or not.</xs:documentation>
    		</xs:annotation>
    	</xs:attribute>
    </xs:attributeGroup>
    
    <xs:complexType name="ParameterRangeStart">
			<xs:annotation>
    		<xs:documentation>Defines the start of a parameter value range.</xs:documentation>
    	</xs:annotation>
    	<xs:simpleContent>
    		<xs:extension base="xs:decimal">
    			<xs:attributeGroup ref="ParameterRangeInclusiveAttribute"/>
    		</xs:extension>
    	</xs:simpleContent>
    </xs:complexType>
    
    <xs:complexType name="ParameterRangeEnd">
			<xs:annotation>
    		<xs:documentation>Defines the end of a parameter value range.</xs:documentation>
    	</xs:annotation>
			<xs:simpleContent>
    		<xs:extension base="xs:decimal">
    			<xs:attributeGroup ref="ParameterRangeInclusiveAttribute"/>
    		</xs:extension>
    	</xs:simpleContent>
    </xs:complexType>

    <xs:complexType name="Box">
        <xs:sequence>
            <xs:element name="title" type="Title" minOccurs="0" maxOccurs="1"/>
            <xs:element name="parameter" minOccurs="0" maxOccurs="unbounded" type="Parameter"/>
            <xs:group ref="BlockGroup" minOccurs="0" maxOccurs="unbounded"/>
        </xs:sequence>
        <xs:attributeGroup ref="CommonContainerAttributes"/>
        <xs:attributeGroup ref="CommonBoxAttributes"/>
    </xs:complexType>
    
    <xs:attributeGroup name="CommonBoxAttributes">
    	<xs:attribute name="subtype" type="xs:Name">
        	<xs:annotation>
        		<xs:documentation>An optional subtype that further describes the content type of this box. For example, a theorembox can have the subtype "lemma".</xs:documentation>
        	</xs:annotation>
        </xs:attribute>
    </xs:attributeGroup>
	
	<xs:attributeGroup name="DifficultyAttribute">
		<xs:attribute name="difficulty" type="xs:positiveInteger">
			<xs:annotation>
				<xs:documentation> Number that specifies the difficulty of this content.
					A lower value means a lower difficulty, a higher value means a higher
					difficulty. If this attribute is not set, the difficulty is considered to be 0.
				</xs:documentation>
			</xs:annotation>
		</xs:attribute>
	</xs:attributeGroup>
	
	<xs:attributeGroup name="ContentLoadingAttributes">
		<xs:attribute name="preview" type="xs:string">
			<xs:annotation>
				<xs:documentation>A path to a preview image that should be displayed as long as the content itself is not loaded.</xs:documentation>
			</xs:annotation>
		</xs:attribute>
		<xs:attribute name="autoload" type="xs:boolean">
			<xs:annotation>
				<xs:documentation>Whether or not the content should be loaded automatically without a user interaction. If this attribute is not set, the
				application will apply a suitable default behavior.</xs:documentation>
			</xs:annotation>
		</xs:attribute>
	</xs:attributeGroup>
	
	<xs:complexType name="ExerciseBox">
		<xs:sequence>
			<xs:element name="title" type="Title" minOccurs="0" maxOccurs="1"/>
			<xs:sequence minOccurs="0" maxOccurs="unbounded">
				<xs:choice>
					<xs:element name="parameter" minOccurs="0" maxOccurs="unbounded" type="Parameter"/>
					<xs:group ref="BlockGroup"/>
				</xs:choice>
			</xs:sequence>
		</xs:sequence>
		<xs:attributeGroup ref="CommonContainerAttributes"/>
    <xs:attributeGroup ref="CommonBoxAttributes"/>
		<xs:attributeGroup ref="DifficultyAttribute"/>
	</xs:complexType>
	
	<xs:complexType name="ExampleBox">
		<xs:sequence>
			<xs:element name="title" type="Title" minOccurs="0" maxOccurs="1"/>
			<xs:sequence minOccurs="0" maxOccurs="unbounded">
				<xs:choice>
					<xs:element name="parameter" minOccurs="0" maxOccurs="unbounded" type="Parameter"/>
					<xs:group ref="BlockGroup"/>
				</xs:choice>
			</xs:sequence>
		</xs:sequence>
		<xs:attributeGroup ref="CommonContainerAttributes"/>
		<xs:attributeGroup ref="CommonBoxAttributes"/>
		<xs:attributeGroup ref="DifficultyAttribute"/>
	</xs:complexType>
	
	<xs:complexType name="GroupView">
        <xs:annotation>
        	<xs:documentation>A view that wraps a sequence of containers and has an optional title.</xs:documentation>
        </xs:annotation>
        <xs:sequence>
            <xs:element name="title" type="Title" minOccurs="0" maxOccurs="1"/>
            <xs:sequence minOccurs="1" maxOccurs="unbounded">
                <xs:group ref="ContainerGroup"/>
            </xs:sequence>
        </xs:sequence>
        <xs:attributeGroup ref="CommonContainerAttributes"/>
        <xs:attributeGroup ref="DifficultyAttribute"></xs:attributeGroup>
    </xs:complexType>
    
   <xs:complexType name="TitledGroupView">
		<xs:annotation>
			<xs:documentation>A view that wraps a sequence of containers and has a mandatory title.</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="title" type="Title" minOccurs="1" maxOccurs="1"/>
			<xs:sequence minOccurs="1" maxOccurs="unbounded">
				<xs:group ref="ContainerGroup"/>
			</xs:sequence>
		</xs:sequence>
		<xs:attributeGroup ref="CommonContainerAttributes"/>
	</xs:complexType>
    
   <xs:complexType name="PoolView">
		<xs:annotation>
			<xs:documentation>A view that wraps a sequence of containers and shows only a selection of them that is randomly chosen each time the page is reloaded.
			</xs:documentation>
		</xs:annotation>
			<xs:sequence>
       	<xs:element name="title" type="Title" minOccurs="0" maxOccurs="1"/>
       	<xs:sequence minOccurs="1" maxOccurs="unbounded">
       		<xs:group ref="ContainerGroup"/>
       	</xs:sequence>
			</xs:sequence>
		<xs:attributeGroup ref="CommonContainerAttributes"/>
		<xs:attribute name="amount" type="xs:positiveInteger" default="1">
			<xs:annotation>
				<xs:documentation>Amount of group views that are shown.</xs:documentation>
			</xs:annotation>
		</xs:attribute>
	</xs:complexType>
        
    <xs:complexType name="OptionalView">
        <xs:annotation>
            <xs:documentation>A view that wraps a sequence of containers that are optional in the sense that the course can be followed without them.
            </xs:documentation>
        </xs:annotation>
        <xs:sequence>
        	<xs:element name="title" type="Title" minOccurs="0" maxOccurs="1"/>
        	<xs:sequence minOccurs="1" maxOccurs="unbounded">
        		<xs:group ref="ContainerGroup"/>
        	</xs:sequence>
        </xs:sequence>
        <xs:attributeGroup ref="CommonContainerAttributes"/>
    </xs:complexType>
    
    <xs:complexType name="AccordionView">
        <xs:annotation>
            <xs:documentation>A view that wraps a sequence of group views (with mandatory titles) and displays them in an accordion.</xs:documentation>
            <xs:appinfo>
            	<edmldoc:hint>This element should not be used to hold solutions. For this task, use the <code>solutionhint</code> element.</edmldoc:hint>
            </xs:appinfo>
        </xs:annotation>
        <xs:sequence>
        	<xs:element name="title" type="Title" minOccurs="0" maxOccurs="1"/>
        	<xs:element name="groupview" type="TitledGroupView" minOccurs="1" maxOccurs="unbounded"/>
        </xs:sequence>
        <xs:attributeGroup ref="CommonContainerAttributes"/>
    </xs:complexType>
    
    <xs:complexType name="TabView">
        <xs:annotation>
            <xs:documentation>A view that wraps a sequence of group views (with mandatory titles) and displays them as items in a tab set.</xs:documentation>
            <xs:appinfo>
            	<edmldoc:hint>This element should not be used to hold solutions. For this task, use the <code>solutionhint</code> element.</edmldoc:hint>
            </xs:appinfo>
        </xs:annotation>
        <xs:sequence>
        	<xs:element name="title" type="Title" minOccurs="0" maxOccurs="1"/>
        	<xs:element name="groupview" type="TitledGroupView" minOccurs="1" maxOccurs="unbounded"/>
        </xs:sequence>
        <xs:attributeGroup ref="CommonContainerAttributes"/>
    </xs:complexType>
    
    <xs:complexType name="CarouselView">
    	<xs:annotation>
    		<xs:documentation>A view that warps a sequence of group views (with optional titles) and displays them in a carousel. Only one of the group views
    		is visible at once and the user can go to the next or previous one on demand.</xs:documentation>
    	</xs:annotation>
      <xs:sequence>
      	<xs:element name="title" type="Title" minOccurs="0" maxOccurs="1"/>
      	<xs:element name="groupview" type="GroupView" minOccurs="1" maxOccurs="unbounded"/>
      </xs:sequence>
			<xs:attribute name="loop" type="xs:boolean" default="false">
				<xs:annotation>
					<xs:documentation>
						Whether or not the sequence of group views should be wrapped to a loop for the user,
						starting with the first one again after the last one.
					</xs:documentation>				
				</xs:annotation>
			</xs:attribute>
			<xs:attribute name="autostepafter" use="optional" type="PositiveDecimal">
				<xs:annotation>
					<xs:documentation>
						When this attribute is set, the carousel view will automatically go to the next group view after the given number of seconds.
					</xs:documentation>
				</xs:annotation>
			</xs:attribute>
			<xs:attribute name="fixedheight" use="optional" type="xs:boolean" default="true">
				<xs:annotation>
					<xs:documentation>
						Whether or not the height of the carousel should be fixed to the maximum of the height of its childrens.
						If this attribute is set to false, the height of the carousel changes dynamically depending on the active child.
					</xs:documentation>
				</xs:annotation>
			</xs:attribute>
	</xs:complexType>
         
    <xs:group name="ContainerGroup">
        <xs:choice>
            <xs:group ref="BoxGroup"/>
            <xs:group ref="ViewGroup"/>
        </xs:choice>
    </xs:group>

    <xs:group name="BoxGroup">
        <xs:choice>
            <xs:element name="textbox" type="Box">
              <xs:annotation><xs:documentation>A container with block content.</xs:documentation></xs:annotation>
            </xs:element>
            <xs:element name="infobox" type="Box">
              <xs:annotation><xs:documentation>A container with block content tagged as information.</xs:documentation></xs:annotation>
            </xs:element>
            <xs:element name="hintbox" type="Box">
              <xs:annotation><xs:documentation>A container with block content tagged as a hint.</xs:documentation></xs:annotation>
            </xs:element>
            <xs:element name="helpbox" type="Box">
              <xs:annotation><xs:documentation>A container with block content tagged as help.</xs:documentation></xs:annotation>
            </xs:element>
            <xs:element name="remarkbox" type="Box">
              <xs:annotation><xs:documentation>A container with block content tagged as remark.</xs:documentation></xs:annotation>
            </xs:element>
            <xs:element name="examplebox" type="ExampleBox">
              <xs:annotation><xs:documentation>A container with block content tagged as example.</xs:documentation></xs:annotation>
            </xs:element>
            <xs:element name="theorembox" type="Box">
              <xs:annotation><xs:documentation>A container with block content tagged as theorem.</xs:documentation></xs:annotation>
            </xs:element>
            <xs:element name="proofbox" type="Box">
              <xs:annotation><xs:documentation>A container with block content tagged as a proof.</xs:documentation></xs:annotation>
            </xs:element>
            <xs:element name="definitionbox" type="Box">
              <xs:annotation><xs:documentation>A container with block content tagged as a definition.</xs:documentation></xs:annotation>
            </xs:element>
            <xs:element name="experimentbox" type="Box">
              <xs:annotation><xs:documentation>A container with block content tagged as an experiment.</xs:documentation></xs:annotation>
            </xs:element>    
            <xs:element name="exercisebox" type="ExerciseBox">
              <xs:annotation><xs:documentation>A container with block content tagged as exercise.</xs:documentation></xs:annotation>
            </xs:element>
            <xs:element name="conventionbox" type="Box">
              <xs:annotation>
              	<xs:documentation>A box whose content is a convention. A convention is a determination that is valid for the whole course or a part of the course.
              	</xs:documentation>
             	</xs:annotation>
            </xs:element>
            <xs:element name="formulabox" type="Box">
            		<xs:annotation>
            			<xs:documentation>A box whose main purpose is to present a formula to the user.</xs:documentation>
            		</xs:annotation>
            </xs:element>
            <xs:element name="applicationbox" type="Box">
            		<xs:annotation>
            			<xs:documentation>A box for content that describes an application of other content.</xs:documentation>
            		</xs:annotation>
            </xs:element>
        </xs:choice>
    </xs:group>
    
    <xs:group name="ViewGroup">
        <xs:choice>
        		<xs:element name="groupview" type="GroupView"/>
            <xs:element name="optionalview" type="OptionalView"/>
            <xs:element name="poolview" type="PoolView"/>
            <xs:element name="accordionview" type="AccordionView"/>
            <xs:element name="tabview" type="TabView"/>
            <xs:element name="carouselview" type="CarouselView"/>
        </xs:choice>
    </xs:group>    
    
    <xs:attributeGroup name="CommonContainerAttributes">
        <xs:attribute name="name" type="xs:Name" use="optional">
            <xs:annotation>
                <xs:documentation>Name of this container, must be unique among all names in this course variant.</xs:documentation>
            </xs:annotation>
        </xs:attribute>
        <xs:attribute name="tags" type="xs:NMTOKENS" use="optional">
            <xs:annotation>
                <xs:documentation>A space-separated list of tags for this container.</xs:documentation>
            </xs:annotation>
        </xs:attribute>
        <xs:attribute name="label" type="xs:string" use="optional">
            <xs:annotation>
                <xs:documentation>Custom label for this container, overriding any automatically generated label.</xs:documentation>
            </xs:annotation>
        </xs:attribute>
    </xs:attributeGroup>
    
    <!-- ### Content level ### -->
    
    <xs:attributeGroup name="CommonContentElementAttributes">
        <xs:attribute name="name" type="xs:Name" use="optional">
            <xs:annotation>
                <xs:documentation>Name of this content element, must be unique among all names in this course variant.</xs:documentation>
            </xs:annotation>
        </xs:attribute>
        <xs:attribute name="tags" type="xs:NMTOKENS" use="optional">
            <xs:annotation>
                <xs:documentation>A space-separated list of tags for this content element.</xs:documentation>
            </xs:annotation>
        </xs:attribute>
    </xs:attributeGroup>
    
    <xs:group name="InlineGroup">
        <xs:choice>
            <xs:element name="strong" type="InlineContent">
              <xs:annotation><xs:documentation>Inline element which indicates that its content has strong importance.</xs:documentation></xs:annotation>
            </xs:element>
            <xs:element name="emph" type="InlineContent">
              <xs:annotation><xs:documentation>Inline element which indicates that its content has stress emphasis.</xs:documentation></xs:annotation>
            </xs:element>
            <xs:element name="underline" type="InlineContent">
              <xs:annotation><xs:documentation>Inline element which underlines its content.</xs:documentation></xs:annotation>
            </xs:element>
            <xs:element name="strikeout" type="InlineContent">
              <xs:annotation><xs:documentation>Inline element which places a horizontal line through its content.</xs:documentation></xs:annotation>
            </xs:element>
            <xs:element name="sup" type="InlineContent">
              <xs:annotation><xs:documentation>Inline element which places its content in superscript.</xs:documentation></xs:annotation>
            </xs:element>
            <xs:element name="sub" type="InlineContent">
              <xs:annotation><xs:documentation>Inline element which places its content in subscript.</xs:documentation></xs:annotation>
            </xs:element>
            <xs:element name="code" type="Code"/>
            <xs:element name="hint" type="InlineContent">
              <xs:annotation><xs:documentation>Inline element which indicates that its content is a hint.</xs:documentation></xs:annotation>
            </xs:element>
            <xs:element name="info" type="InlineContent">
              <xs:annotation><xs:documentation>Inline element which indicates that its content is an information.</xs:documentation></xs:annotation>
            </xs:element>
            <xs:element name="help" type="InlineContent">
              <xs:annotation><xs:documentation>Inline element which indicates that its content is a help for the reader.</xs:documentation></xs:annotation>
            </xs:element>
            <xs:element name="warning" type="InlineContent">
              <xs:annotation><xs:documentation>Inline element which indicates that its content is a warning for the reader.</xs:documentation></xs:annotation>
            </xs:element>
            <xs:element name="quote" type="InlineContent">
              <xs:annotation><xs:documentation>An inline quotation that will be surrounded by quotation marks according to the course variant language.</xs:documentation></xs:annotation>
            </xs:element>
            <xs:element name="m" type="Math"/>
            <xs:element name="ref" type="Ref"/>
            <xs:element name="mark" type="Mark"/>
            <xs:element name="link" type="Link"/>
            <xs:element name="picture" type="Picture"/>
            <xs:element name="br" type="LineBreak"/>
        	<xs:element name="input" type="InlineInput"/>
        	<xs:element name="calculate" type="Calculate"/>
        </xs:choice>
    </xs:group>    
        
    <xs:group name="BlockGroup">
        <xs:choice>
            <xs:element name="p" type="InlineContent"/>
            <xs:element name="video" type="Video"/>
            <xs:element name="flex" type="Flex"/>
            <xs:element name="list" type="List"/>
            <xs:element name="table" type="Table"/>
            <xs:element name="codelisting" type="CodeListing"/>
            <xs:element name="blockquote" type="BlockQuote"/>
            <xs:element name="figureblock" type="FigureBlock"/>
            <xs:element name="solutionhint" type="SolutionHint"/>
            <xs:element name="booleangroup" type="BooleanGroup"/>
            <xs:element name="accordion" type="Accordion"/>
            <xs:element name="tabset" type="TabSet"/>
        		<xs:element name="externmedia" type="ExternMedia"/>
        		<xs:element name="inputblock" type="BlockInput"/>
        </xs:choice>
    </xs:group>
    
    <xs:complexType name="TabSet">
        <xs:annotation>
            <xs:documentation>
            	Block element that shows one or more panels as tabs.
            	This element should not be used to hold solutions. For this task, use the <code>solutionhint</code> element.
            </xs:documentation>
        </xs:annotation>
        <xs:sequence>
            <xs:element name="panel" type="Panel" minOccurs="1" maxOccurs="unbounded"/>
        </xs:sequence>
        <xs:attributeGroup ref="CommonContentElementAttributes"/>
    </xs:complexType>
	
	<xs:complexType name="ExternMedia">
		<xs:annotation>
			<xs:documentation>An external media object embedded from a web page.</xs:documentation>
		</xs:annotation>
		<xs:attributeGroup ref="CommonContentElementAttributes"/>
		<xs:attribute name="source" type="HttpUrl" use="required">
			<xs:annotation>
				<xs:documentation>
					Path to the external web page.
				</xs:documentation>
			</xs:annotation>
		</xs:attribute>
		<xs:attributeGroup ref="CommonMediaAttributes"/>
		<xs:attributeGroup ref="ContentLoadingAttributes"/>
	</xs:complexType>
	
	<xs:simpleType name="HttpUrl">
		<xs:annotation>
			<xs:documentation>An URL that must start with "http://" or "https://".</xs:documentation>
		</xs:annotation>
		<xs:restriction base="xs:anyURI">
			<xs:pattern value="https?://.+"/>
		</xs:restriction>
	</xs:simpleType>
    
    <xs:complexType name="Accordion">
        <xs:annotation>
            <xs:documentation>
            	Block element for an accordion with one or more panels.
            	This element should not be used to hold solutions. For this task, use the <code>solutionhint</code> element.
            </xs:documentation>
        </xs:annotation>
        <xs:sequence>
            <xs:element name="panel" type="Panel" minOccurs="1" maxOccurs="unbounded"/>
        </xs:sequence>
        <xs:attributeGroup ref="CommonContentElementAttributes"/>
    </xs:complexType>
    
    <xs:complexType name="Panel">
        <xs:annotation>
            <xs:documentation>A constituent of either an accordion (block element) or a tabset (also a block element).</xs:documentation>
        </xs:annotation>
        <xs:sequence>
            <xs:element name="title" type="Title" minOccurs="1" maxOccurs="1"/>
            <xs:group ref="BlockGroup" minOccurs="0" maxOccurs="unbounded"/>
        </xs:sequence>
        <xs:attributeGroup ref="CommonContentElementAttributes"/>
    </xs:complexType>
    
    <xs:complexType name="FigureBlock">
        <xs:annotation>
            <xs:documentation>Shows a figure (for example an image, a video, or a table) with an optional caption.</xs:documentation>
        </xs:annotation>
        <xs:sequence>
            <xs:group ref="BlockGroup" minOccurs="0" maxOccurs="unbounded"/>
            <xs:element name="caption" type="Caption" minOccurs="0" maxOccurs="1"/>
        </xs:sequence>
        <xs:attributeGroup ref="CommonContentElementAttributes"/>
    </xs:complexType>
    
    <xs:complexType name="Caption" mixed="true">
        <xs:annotation>
            <xs:documentation>Caption of a figure block.</xs:documentation>
        </xs:annotation>
        <xs:sequence>
            <xs:group ref="InlineGroup" minOccurs="0" maxOccurs="unbounded"/>
        </xs:sequence>
    </xs:complexType>
    
    <xs:simpleType name="Alignment">
        <xs:annotation>
            <xs:documentation>
                Horizontal alignment of a block element.
            </xs:documentation>
        </xs:annotation>
        <xs:restriction base="xs:NMTOKEN">
            <xs:enumeration value="left"><xs:annotation><xs:documentation>Aligned to the left side of its parent.</xs:documentation></xs:annotation></xs:enumeration>
            <xs:enumeration value="right"><xs:annotation><xs:documentation>Aligned to the right side of its parent</xs:documentation></xs:annotation></xs:enumeration>
            <xs:enumeration value="center"><xs:annotation><xs:documentation>Aligned to the center of its parent</xs:documentation></xs:annotation></xs:enumeration>
        </xs:restriction>                  
    </xs:simpleType>
    
    <xs:complexType name="Code">
        <xs:annotation>
            <xs:documentation>Inline element for a code fragment with optional syntax highlighting.</xs:documentation>
			<xs:appinfo>
				<edmldoc:example>
					<edmldoc:code><![CDATA[<p>In Java, classes are defined using the <code lang="java">class</code> keyword.</p>]]></edmldoc:code>					
				</edmldoc:example>
			</xs:appinfo>
        </xs:annotation>
        <xs:simpleContent>
            <xs:extension base="xs:string">
                <xs:attributeGroup ref="CommonContentElementAttributes"/>
                <xs:attributeGroup ref="CodeAttributes"/>
            </xs:extension>
        </xs:simpleContent>
    </xs:complexType>
    
    <xs:complexType name="Math" mixed="true">
        <xs:annotation>
            <xs:documentation>Math formula with LaTeX content. Will be displayed with MathJax.</xs:documentation>
        </xs:annotation>
        <xs:sequence>
        	<xs:element minOccurs="0" maxOccurs="unbounded" name="calculate" type="Calculate"/>
        </xs:sequence>
        <xs:attributeGroup ref="CommonContentElementAttributes"/>
        <xs:attribute name="display" type="MathDisplayStyle" default="inline">
        	<xs:annotation>
        		<xs:documentation>Determines whether this formula should be displayed as an inline element or block element.</xs:documentation>
        	</xs:annotation>
        </xs:attribute>
        <xs:attribute name="align" type="Alignment" default="center">
          <xs:annotation>
            <xs:documentation>
            	Horizontal alignment of this formula when displayed as a block element.
            </xs:documentation>
          </xs:annotation>
        </xs:attribute>
    </xs:complexType>
    
    <xs:simpleType name="MathDisplayStyle">
    	<xs:annotation><xs:documentation>Describes the visual style of a math formula in the output.</xs:documentation></xs:annotation>
    	<xs:restriction base="xs:NMTOKEN">
    		<xs:enumeration value="inline"><xs:annotation><xs:documentation>Display the math formula as an inline element.</xs:documentation></xs:annotation></xs:enumeration>
    		<xs:enumeration value="block"><xs:annotation><xs:documentation>Display the math formula as a centered block element.</xs:documentation></xs:annotation></xs:enumeration>
    	</xs:restriction>
    </xs:simpleType>
    
    <xs:complexType name="InlineContent" mixed="true">
        <xs:sequence minOccurs="0" maxOccurs="unbounded">
            <xs:group ref="InlineGroup"/>
        </xs:sequence>
        <xs:attributeGroup ref="CommonContentElementAttributes"/>
    </xs:complexType>

    <xs:complexType name="BlockContent">
        <xs:sequence minOccurs="0" maxOccurs="unbounded">
            <xs:group ref="BlockGroup"/>
        </xs:sequence>
        <xs:attributeGroup ref="CommonContentElementAttributes"/>
    </xs:complexType>
    
    <xs:complexType name="BlockQuote">
        <xs:annotation>
            <xs:documentation>Block element displaying a quotation.</xs:documentation>
        </xs:annotation>
        <xs:complexContent>
            <xs:extension base="BlockContent">
            </xs:extension>
        </xs:complexContent>
    </xs:complexType>
     
    <xs:complexType name="CodeListing">
        <xs:annotation>
            <xs:documentation>Block element for a code listing with optional syntax hightlighting.</xs:documentation>
        </xs:annotation>
        <xs:simpleContent>
            <xs:extension base="xs:string">
                <xs:attributeGroup ref="CommonContentElementAttributes"/>
                <xs:attributeGroup ref="CodeAttributes"/>
            </xs:extension>
        </xs:simpleContent>
    </xs:complexType>

    <xs:complexType name="CodeEnvironment">
        <xs:annotation>
            <xs:documentation>Block element in which the user can write source code in a specified
            programming language and execute it.</xs:documentation>
        </xs:annotation>
        <xs:sequence>
        	<xs:element name="content" minOccurs="0" maxOccurs="1" type="CodeEnvironmentContent"/>
        </xs:sequence>
        <xs:attribute name="lang" use="required" type="xs:string">
            <xs:annotation>
                <xs:documentation>Short string identifying the programming language to be used, such as "java".</xs:documentation>
            </xs:annotation>
        </xs:attribute>
        <xs:attribute name="type" use="optional" default="file" type="CodeEnvironmentType">
        	<xs:annotation>
        		<xs:documentation>Whether the user should write multiple source code files, only one file or several functions or statements.</xs:documentation>
        	</xs:annotation>
        </xs:attribute>
    </xs:complexType>
    
    <xs:simpleType name="CodeEnvironmentType">
    	<xs:annotation>
    		<xs:documentation>The type of a code environment element.</xs:documentation>
    	</xs:annotation>
    	<xs:restriction base="xs:NMTOKEN">
    		<xs:enumeration value="project">
    			<xs:annotation>
    				<xs:documentation>One or multiple source code files.</xs:documentation>
    			</xs:annotation>
    		</xs:enumeration>
    		<xs:enumeration value="file">
    			<xs:annotation>
    				<xs:documentation>A single source code file.</xs:documentation>
    			</xs:annotation>
    		</xs:enumeration>
    		<xs:enumeration value="functions">
    			<xs:annotation>
    				<xs:documentation>One or multiple functions.</xs:documentation>
    			</xs:annotation>
    		</xs:enumeration>
    		<xs:enumeration value="statements">
    			<xs:annotation>
    				<xs:documentation>One or multiple statements.</xs:documentation>
    			</xs:annotation>
    		</xs:enumeration>
    	</xs:restriction>
    </xs:simpleType>
    
    <xs:complexType name="CodeEnvironmentContent">
    	<xs:annotation>
            <xs:documentation>Initial code content of a <code>codeenvironment</code> element.</xs:documentation>
        </xs:annotation>
        <xs:simpleContent>
        	<xs:extension base="xs:string"/>
        </xs:simpleContent>
    </xs:complexType>
    
    <xs:attributeGroup name="CodeAttributes">
        <xs:attribute name="lang" type="xs:string">
            <xs:annotation>
                <xs:documentation>Short string identifying the language of the code content, such as "java", "c++" or "xml".</xs:documentation>
                <xs:appinfo>
                	<edmldoc:experimental/>
                </xs:appinfo>
            </xs:annotation>
        </xs:attribute>
    </xs:attributeGroup>

    <xs:complexType name="LineBreak">
        <xs:annotation>
            <xs:documentation>A line break. Should not be used to distinguish paragraphs.</xs:documentation>
        </xs:annotation>
    </xs:complexType>

    <xs:complexType name="Metadata">
        <xs:annotation>
            <xs:documentation>Contains information about the metadata of a resource that is used in the course, such as a picture or a video. Note that every <code>metadata</code> element should contain at least one <code>license</code> child element, even through this is currently not validated by the schema.</xs:documentation>
        </xs:annotation>
        <xs:sequence minOccurs="0" maxOccurs="unbounded">
					<xs:choice>
            <xs:element name="creator" type="Creator"/>
            <xs:element name="date" type="Date"/>
            <xs:element name="description" type="Description"/>
            <xs:element name="source" type="Source"/>
            <xs:element name="license" type="License"/>
					</xs:choice>
        </xs:sequence>
    </xs:complexType>
		
		<xs:attributeGroup name="UrlAttribute">
			<xs:attribute name="url" type="xs:string" use="optional">
        <xs:annotation>
            <xs:documentation>An URL to a resource that contains further information about this metadata field.</xs:documentation>
        </xs:annotation>
			</xs:attribute>
		</xs:attributeGroup>
			
		<xs:complexType name="Creator">
			<xs:annotation><xs:documentation>An entity who is primarily responsible for making a resource.</xs:documentation></xs:annotation>
			<xs:simpleContent>
				<xs:extension base="xs:string">
					<xs:attributeGroup ref="UrlAttribute"/>
				</xs:extension>
			</xs:simpleContent>
		</xs:complexType>
		
		<xs:complexType name="Date">
			<xs:annotation><xs:documentation>A point of time associated with an event in the lifecycle of a resource.</xs:documentation></xs:annotation>
			<xs:simpleContent>
				<xs:extension base="xs:date">
				</xs:extension>
			</xs:simpleContent>
		</xs:complexType>
		
		<xs:complexType name="Description">
			<xs:annotation><xs:documentation>A description or an account of a resource.</xs:documentation></xs:annotation>
			<xs:simpleContent>
				<xs:extension base="xs:string">
					<xs:attributeGroup ref="UrlAttribute"/>
				</xs:extension>
			</xs:simpleContent>
		</xs:complexType>
		
		<xs:complexType name="Source">
			<xs:annotation><xs:documentation>A description of a related resource from which the described resource is derived.</xs:documentation></xs:annotation>
			<xs:simpleContent>
				<xs:extension base="xs:string">
					<xs:attributeGroup ref="UrlAttribute"/>
				</xs:extension>
			</xs:simpleContent>
		</xs:complexType>
		
		<xs:complexType name="License">
			<xs:annotation><xs:documentation>Describes the license of a resource.</xs:documentation></xs:annotation>
			<xs:simpleContent>
				<xs:extension base="xs:string">
					<xs:attributeGroup ref="UrlAttribute"/>
				</xs:extension>
			</xs:simpleContent>
		</xs:complexType>
	
	<xs:attributeGroup name="CommonMediaAttributes">
		<xs:attribute name="minwidth" type="xs:string" use="optional">
			<xs:annotation>
				<xs:documentation>Minimum width of this media object as CSS length. If this attribute is not set, the processing application will apply a suitable default value.</xs:documentation>
			</xs:annotation>
		</xs:attribute>
		<xs:attribute name="maxwidth" type="xs:string" use="optional">
			<xs:annotation>
				<xs:documentation>Maximal width of this media object as CSS length. If this attribute is not set, the processing application will apply a suitable default value.</xs:documentation>
			</xs:annotation>
		</xs:attribute>
		<xs:attribute name="minheight" type="xs:string" use="optional">
			<xs:annotation>
				<xs:documentation>Minimum height of this media object as CSS length. If this attribute is not set, the processing application will apply a suitable default value.</xs:documentation>
			</xs:annotation>
		</xs:attribute>
		<xs:attribute name="maxheight" type="xs:string" use="optional">
			<xs:annotation>
				<xs:documentation>Maximal height of this media object as CSS length. If this attribute is not set, the processing application will apply a suitable default value.</xs:documentation>
			</xs:annotation>
		</xs:attribute>
	</xs:attributeGroup>
	
    <xs:complexType name="Picture">
    	<xs:annotation>
    		<xs:documentation>Displays a picture loaded from a local image file.
    		The image file can contain either a raster graphic graphic (for example, a PNG file) or a vector graphic (for example, an SVG file).
    		</xs:documentation>
    	</xs:annotation>
        <xs:sequence>
            <xs:element name="metadata" type="Metadata" minOccurs="1" maxOccurs="1"/>
        </xs:sequence>
        <xs:attributeGroup ref="CommonContentElementAttributes"/>
        <xs:attribute name="filepath" type="xs:string" use="required">
            <xs:annotation>
                <xs:documentation>Path to the image file relative to the current document.</xs:documentation>
            </xs:annotation>
        </xs:attribute>
    	<xs:attributeGroup ref="CommonMediaAttributes"/>
    </xs:complexType>
    
    <xs:complexType name="Video">
    	<xs:annotation>
    		<xs:documentation>Plays a video loaded from a local video file (for example, an MP4 file).</xs:documentation>
    	</xs:annotation>
        <xs:sequence>
            <xs:element name="metadata" type="Metadata" minOccurs="1" maxOccurs="1"/>
        </xs:sequence>
        <xs:attributeGroup ref="CommonContentElementAttributes"/>
        <xs:attribute name="filepath" type="xs:string" use="required">
            <xs:annotation>
                <xs:documentation>Path to the video file relative to the current document.</xs:documentation>
            </xs:annotation>
        </xs:attribute>
    	<xs:attributeGroup ref="CommonMediaAttributes"/>
    	<xs:attributeGroup ref="ContentLoadingAttributes"/>
    </xs:complexType>
    
    <xs:complexType name="Ref">
        <xs:annotation>
            <xs:documentation>A reference to another part of the course.</xs:documentation>
        </xs:annotation>
        <xs:complexContent>
            <xs:extension base="InlineContent">
                <xs:attribute name="to" type="xs:Name" use="required">
                    <xs:annotation>
                        <xs:documentation>Name of the target element to which this reference points.</xs:documentation>
                    </xs:annotation>
                </xs:attribute>
            </xs:extension>
        </xs:complexContent>
    </xs:complexType>
    
    <xs:complexType name="Link">
        <xs:annotation>
            <xs:documentation>Link to an external resource, such as a website or an email address.</xs:documentation>
        </xs:annotation>
        <xs:complexContent>
            <xs:extension base="InlineContent">
                <xs:attribute name="to" type="xs:anyURI" use="required">
                    <xs:annotation>
                        <xs:documentation>URI of the external resource to which this link points.</xs:documentation>
                    </xs:annotation>
                </xs:attribute>
            </xs:extension>
        </xs:complexContent>
    </xs:complexType>
    
    <xs:complexType name="Mark" mixed="true">
        <xs:annotation>
            <xs:documentation>Inline element that can be used to give its content a name and/or to assign semantic roles to its content.</xs:documentation>
            <xs:appinfo>
            	<edmldoc:example>
            		<edmldoc:code><![CDATA[Ein <mark name="vektorraum" role="definition">Vektorraum</mark> ist eine Menge ...]]></edmldoc:code>
            	</edmldoc:example>
            </xs:appinfo>
        </xs:annotation>
        <xs:sequence>
        	<xs:group ref="InlineGroup" minOccurs="0" maxOccurs="unbounded"/>
        </xs:sequence>
        <xs:attributeGroup ref="CommonContentElementAttributes"/>
        <xs:attribute name="role" type="xs:NMTOKENS">
        	<xs:annotation>
        		<xs:documentation>A space-separated list of semantic roles that should be applied to the content of this element.</xs:documentation>
        	</xs:annotation>
        </xs:attribute>
    </xs:complexType>

    <xs:complexType name="Flex">
        <xs:annotation>
            <xs:documentation>Block element that will be displayed as a flexbox.</xs:documentation>
        </xs:annotation>
        <xs:sequence minOccurs="1" maxOccurs="unbounded">
            <xs:element name="flexitem" type="FlexItem"/>
        </xs:sequence>
        <xs:attributeGroup ref="CommonContentElementAttributes"/>
        <xs:attributeGroup ref="FlexContainerAttributes"/>
    </xs:complexType>
    
    <xs:complexType name="FlexItem">
        <xs:annotation>
            <xs:documentation>An item of a flexbox.</xs:documentation>
        </xs:annotation>
        <xs:sequence minOccurs="0" maxOccurs="unbounded">
            <xs:group ref="BlockGroup"/>
        </xs:sequence>
        <xs:attributeGroup ref="CommonContentElementAttributes"/>
        <xs:attributeGroup ref="FlexItemAttributes"/>
    </xs:complexType>
    
    <xs:attributeGroup name="FlexContainerAttributes">
        <xs:attribute name="flexdirection" type="FlexDirection" default="row">
            <xs:annotation>
                <xs:documentation>The direction flex items are placed in the flex container.</xs:documentation>
            </xs:annotation>
        </xs:attribute>
        <xs:attribute name="flexwrap" type="FlexWrap" default="nowrap">
            <xs:annotation>
                <xs:documentation>Defines whether the flex items are forced in a single line or can be flowed into multiple lines.</xs:documentation>
            </xs:annotation>
        </xs:attribute>
        <xs:attribute name="justifycontent" type="FlexJustifyContent" default="normal">
            <xs:annotation>
                <xs:documentation>The alignment of the flex items along the main axis.</xs:documentation>
            </xs:annotation>
        </xs:attribute>
        <xs:attribute name="alignitems" type="FlexAlignItems" default="normal">
            <xs:annotation>
                <xs:documentation>Defines the default behavior for how flex items are laid out along the cross axis on the current line.</xs:documentation>
            </xs:annotation>
        </xs:attribute>
        <xs:attribute name="aligncontent" type="FlexAlignContent" default="normal">
            <xs:annotation>
                <xs:documentation>Aligns a flex container’s lines within when there is extra space in the cross-axis.</xs:documentation>
            </xs:annotation>
        </xs:attribute>
        <xs:attribute name="rowgap" type="xs:string">
            <xs:annotation>
                <xs:documentation>The space between flex items in CSS em units. If this attribute is not present, then there will be no row gap.</xs:documentation>
            </xs:annotation>
        </xs:attribute>
        <xs:attribute name="columngap" type="xs:string">
            <xs:annotation>
                <xs:documentation>The space between flex items in CSS em units. If this attribute is not present, then there will be no column gap.</xs:documentation>
            </xs:annotation>
        </xs:attribute>        
    </xs:attributeGroup>
    
    <xs:simpleType name="FlexDirection">
    	<xs:annotation>
    		<xs:documentation>Direction in which flex items are placed in the flex container.</xs:documentation>
    	</xs:annotation>
    	<xs:restriction base="xs:NMTOKENS">
    		<xs:enumeration value="row"></xs:enumeration>
    		<xs:enumeration value="rowreverse"></xs:enumeration>
    		<xs:enumeration value="column"></xs:enumeration>
    		<xs:enumeration value="columnreverse"></xs:enumeration>
    	</xs:restriction>
    </xs:simpleType>
    
    <xs:simpleType name="FlexWrap">
    	<xs:annotation>
    		<xs:documentation>Values for the wrap attribute of flex containers.</xs:documentation>
    	</xs:annotation>
    	<xs:restriction base="xs:NMTOKENS">
    		<xs:enumeration value="nowrap"></xs:enumeration>
    		<xs:enumeration value="wrap"></xs:enumeration>
    		<xs:enumeration value="wrapreverse"></xs:enumeration>
    	</xs:restriction>
    </xs:simpleType>
    
    <xs:simpleType name="FlexJustifyContent">
    	<xs:annotation>
    		<xs:documentation>Values for the justifycontent attribute of flex containers.</xs:documentation>
    	</xs:annotation>
      <xs:restriction base="xs:NMTOKENS">
    		<xs:enumeration value="normal"></xs:enumeration>
    		<xs:enumeration value="spacebetween"></xs:enumeration>
    		<xs:enumeration value="spacearound"></xs:enumeration>
    		<xs:enumeration value="spaceevenly"></xs:enumeration>
    		<xs:enumeration value="stretch"></xs:enumeration>
    		<xs:enumeration value="center"></xs:enumeration>
    		<xs:enumeration value="start"></xs:enumeration>
    		<xs:enumeration value="end"></xs:enumeration>
    		<xs:enumeration value="flexstart"></xs:enumeration>
    		<xs:enumeration value="flexend"></xs:enumeration>
    	</xs:restriction>
    </xs:simpleType>
    
    <xs:simpleType name="FlexAlignItems">
    	<xs:annotation>
    		<xs:documentation>Values for the alignitems attribute of flex containers.</xs:documentation>
    	</xs:annotation>
      <xs:restriction base="xs:NMTOKENS">
    		<xs:enumeration value="normal"></xs:enumeration>
    		<xs:enumeration value="stretch"></xs:enumeration>
    		<xs:enumeration value="center"></xs:enumeration>
    		<xs:enumeration value="start"></xs:enumeration>
    		<xs:enumeration value="end"></xs:enumeration>
    		<xs:enumeration value="selfstart"></xs:enumeration>
    		<xs:enumeration value="selfend"></xs:enumeration>
    		<xs:enumeration value="flexstart"></xs:enumeration>
    		<xs:enumeration value="flexend"></xs:enumeration>
    	</xs:restriction>
    </xs:simpleType>
    
    <xs:simpleType name="FlexAlignContent">
    	<xs:annotation>
    		<xs:documentation>Values for the aligncontent attribute of flex containers.</xs:documentation>
    	</xs:annotation>
      <xs:restriction base="xs:NMTOKENS">
    		<xs:enumeration value="normal"></xs:enumeration>
    		<xs:enumeration value="baseline"></xs:enumeration>
    		<xs:enumeration value="spacebetween"></xs:enumeration>
    		<xs:enumeration value="spacearound"></xs:enumeration>
    		<xs:enumeration value="spaceevenly"></xs:enumeration>
    		<xs:enumeration value="stretch"></xs:enumeration>
    		<xs:enumeration value="center"></xs:enumeration>
    		<xs:enumeration value="start"></xs:enumeration>
    		<xs:enumeration value="end"></xs:enumeration>
    		<xs:enumeration value="flexstart"></xs:enumeration>
    		<xs:enumeration value="flexend"></xs:enumeration>
    	</xs:restriction>
    </xs:simpleType>
    
    <xs:attributeGroup name="FlexItemAttributes">
        <xs:attribute name="order" type="xs:integer" default="0">
            <xs:annotation>
                <xs:documentation>The order of this item in the flex container.</xs:documentation>
            </xs:annotation>
        </xs:attribute>
        <xs:attribute name="flexgrow" type="xs:decimal" default="0">
            <xs:annotation>
                <xs:documentation>Specifies how much of the remaining space in the flex container should be assigned to this item.</xs:documentation>
            </xs:annotation>
        </xs:attribute>
        <xs:attribute name="flexshrink" type="xs:decimal" default="1">
            <xs:annotation>
                <xs:documentation>Flex shrink factor of this flex item.</xs:documentation>
            </xs:annotation>
        </xs:attribute>
        <xs:attribute name="flexbasis" type="xs:nonNegativeInteger">
            <xs:annotation>
                <xs:documentation>Initial main size of this flex item in CSS em units. If this attribute is not present, the size is automatically calculated.</xs:documentation>
            </xs:annotation>
        </xs:attribute>
        <xs:attribute name="alignself" type="FlexAlignSelf" default="auto">
            <xs:annotation>
                <xs:documentation>Overrides this flex item's alignitems value.</xs:documentation>
            </xs:annotation>
        </xs:attribute>
    </xs:attributeGroup>
    
    <xs:simpleType name="FlexAlignSelf">
    	<xs:restriction base="xs:NMTOKENS">
    		<xs:enumeration value="auto"></xs:enumeration>
    		<xs:enumeration value="normal"></xs:enumeration>
    		<xs:enumeration value="stretch"></xs:enumeration>
    		<xs:enumeration value="baseline"></xs:enumeration>
    		<xs:enumeration value="center"></xs:enumeration>
    		<xs:enumeration value="start"></xs:enumeration>
    		<xs:enumeration value="end"></xs:enumeration>
    		<xs:enumeration value="selfstart"></xs:enumeration>
    		<xs:enumeration value="selfend"></xs:enumeration>
    		<xs:enumeration value="flexstart"></xs:enumeration>
    		<xs:enumeration value="flexend"></xs:enumeration>
    	</xs:restriction>
    </xs:simpleType>

    <xs:complexType name="List">
        <xs:annotation>
            <xs:documentation>
                A list, can be either numbered or unnumbered depending on the used format.
								Note that attributes such as "format" and "fullnumbering" will be inherited if a list occurs inside of another list.
            </xs:documentation>
        </xs:annotation>
        <xs:sequence minOccurs="1" maxOccurs="unbounded">
            <xs:element name="listitem" type="ListItem"/>
        </xs:sequence>
        <xs:attributeGroup ref="CommonContentElementAttributes"/>  
        <xs:attribute name="format" type="LabelFormat" use="optional" default="arabic">
            <xs:annotation>
                <xs:documentation>
                    Format used for the automatically generated label of the items in this list.
                </xs:documentation>
            </xs:annotation>
        </xs:attribute>
        <xs:attribute name="separator" type="xs:string" use="optional" default=".">
            <xs:annotation>
                <xs:documentation>
                    Separator used in the automatically generated label of the items in this list.
                </xs:documentation>
            </xs:annotation>
        </xs:attribute>
        <xs:attribute name="lastsep" type="xs:boolean" use="optional" default="true">
            <xs:annotation>
                <xs:documentation>
                    Controls whether the last separator should be shown in the automatically generated label of the items in this list.
                </xs:documentation>
            </xs:annotation>
        </xs:attribute>
        <xs:attributeGroup ref="IndentAttribute"/>
				<xs:attribute name="fullnumbering" type="xs:boolean" default="false">
					<xs:annotation>
						<xs:documentation>Whether or not the automatically generated labels of a list item of this list should include the full numbering of all of its parent navigation items or only its number in the list of the children of its parent.</xs:documentation>
					</xs:annotation>
				</xs:attribute>
    </xs:complexType>
    
    <xs:complexType name="ListItem">
        <xs:annotation>
            <xs:documentation>
                Item of a list.
            </xs:documentation>
        </xs:annotation>
        <xs:complexContent>
            <xs:extension base="BlockContent">
                <xs:attribute name="numbered" type="xs:boolean" use="optional" default="true">
                    <xs:annotation>
                        <xs:documentation>Controls whether or not this list item increases the counter for the automatically generated labels.</xs:documentation>
                    </xs:annotation>
                </xs:attribute>
                <xs:attribute name="label" type="xs:string" use="optional">
                    <xs:annotation>
                        <xs:documentation>Custom label of this list item, overrides any automatically generated labels.</xs:documentation>
                    </xs:annotation>
                </xs:attribute>
            </xs:extension>
        </xs:complexContent>
    </xs:complexType>
    
    <xs:complexType name="Row">
        <xs:annotation>
            <xs:documentation>One row of a table, consisting of one or multiple cells.</xs:documentation>
        </xs:annotation>
        <xs:sequence minOccurs="1" maxOccurs="unbounded">
            <xs:element name="cell" type="BlockContent">
              <xs:annotation><xs:documentation>A cell of a table row.</xs:documentation></xs:annotation>
            </xs:element>
        </xs:sequence>
        <xs:attributeGroup ref="CommonContentElementAttributes"/>
    </xs:complexType>
    
    <xs:complexType name="Table">
        <xs:annotation>
            <xs:documentation>A table consisting of rows and cells.</xs:documentation>
        </xs:annotation>
        <xs:sequence minOccurs="1" maxOccurs="unbounded">
            <xs:element name="row" type="Row"/>
        </xs:sequence>
        <xs:attributeGroup ref="CommonContentElementAttributes"/>
        <xs:attributeGroup ref="TableAttributes"/>
    </xs:complexType>
    
    <xs:attributeGroup name="TableAttributes">
        <xs:attribute name="border" type="xs:boolean" use="optional" default="true">
            <xs:annotation>
                <xs:documentation>Controls whether or not this table should have a border.</xs:documentation>
            </xs:annotation>
        </xs:attribute>
    </xs:attributeGroup>
    
    <xs:group name="InlineInputValueGroup">
    	<xs:choice>
	    	<!-- General input values -->
				<xs:element name="string" type="StringInputValue" minOccurs="1" maxOccurs="unbounded"/>
				<xs:element name="boolean" type="BooleanInputValue" minOccurs="1" maxOccurs="1"/>
				<xs:element name="choice" type="ChoiceInputValue" minOccurs="1" maxOccurs="1"/>
				
				<!-- Mathematical input values -->
				<xs:element name="number" type="NumberInputValue" minOccurs="1" maxOccurs="unbounded"/>
				<xs:element name="exponential" type="ExponentialInputValue" minOccurs="1" maxOccurs="unbounded"/>
				<xs:element name="expression" type="ExpressionInputValue" minOccurs="1" maxOccurs="unbounded"/>
				<xs:element name="set" type="SetInputValue" minOccurs="1" maxOccurs="unbounded"/>
				<xs:element name="vector" type="VectorInputValue" minOccurs="1" maxOccurs="unbounded"/>
				<xs:element name="matrix" type="MatrixInputValue" minOccurs="1" maxOccurs="unbounded"/>
				<xs:element name="interval" type="IntervalInputValue" minOccurs="1" maxOccurs="unbounded"/>
				
				<!-- Natural sciences related input values -->
				<xs:element name="unit" type="UnitInputValue" minOccurs="1" maxOccurs="unbounded"/>
				<xs:element name="quantity" type="QuantityInputValue" minOccurs="1" maxOccurs="unbounded"/>
				<xs:element name="molecular" type="MolecularInputValue" minOccurs="1" maxOccurs="unbounded"/>
			</xs:choice>
    </xs:group>
    
    <xs:group name="BlockInputValueGroup">
    	<xs:choice>
				<xs:element name="order" type="OrderInputValue" minOccurs="1" maxOccurs="1"/>
				<xs:element name="matching" type="MatchingInputValue" minOccurs="1" maxOccurs="1"/>
				<xs:element name="reaction" type="ReactionInputValue" minOccurs="1" maxOccurs="1"/>
				<xs:element name="codeenvironment" type="CodeEnvironment" minOccurs="1" maxOccurs="1"/>
			</xs:choice>
    </xs:group>
    
    <xs:attributeGroup name="CommonInputElementAttributes">
    	<xs:attribute name="penalty" use="optional" default="0" type="xs:nonNegativeInteger">
    		<xs:annotation>
    			<xs:documentation>Number of credit points the user gets deducted for an incorrect solution of this input element.</xs:documentation>
    		</xs:annotation>
    	</xs:attribute>
    	<xs:attribute name="model" type="xs:Name" use="optional">
			<xs:annotation>
				<xs:documentation>Name of the model to use for values in this input field. If this attribute is not set, the default input model is used.</xs:documentation>
			</xs:annotation>
			</xs:attribute>
    </xs:attributeGroup>
    
    <xs:complexType name="InlineInput">
    	<xs:annotation>
    		<xs:documentation>
    			Inline element for an input field in which the user can input a value that is checked against the specified solution.
    		</xs:documentation>
    	</xs:annotation>
    	<xs:sequence>
	    		<xs:group ref="InlineInputValueGroup"/>
    	</xs:sequence>
    	<xs:attributeGroup ref="CommonContentElementAttributes"/>
    	<xs:attributeGroup ref="CommonInputElementAttributes"/>
    	<xs:attribute name="width" type="xs:string" use="optional">
			<xs:annotation>
				<xs:documentation>Desired width of this input element as a CSS length dimension. If this attribute is not set, the application will decide about the width of the input element.</xs:documentation>
			</xs:annotation>
			</xs:attribute>
    </xs:complexType>
    
    <xs:complexType name="BlockInput">
    	<xs:annotation>
    		<xs:documentation>
    			Block element for user input in which the user has to solve specific problems.
    		</xs:documentation>
    	</xs:annotation>
    	<xs:sequence>
	    		<xs:group ref="BlockInputValueGroup"/>
    	</xs:sequence>
    	<xs:attributeGroup ref="CommonContentElementAttributes"/>
    	<xs:attributeGroup ref="CommonInputElementAttributes"/>
    </xs:complexType>
	
	<xs:attributeGroup name="CommonInputValueAttributes">
		<xs:attribute name="credits" use="optional" default="1" type="xs:nonNegativeInteger">
			<xs:annotation>
				<xs:documentation>Number of credit points the user gets awarded for this input value.</xs:documentation>
			</xs:annotation>
		</xs:attribute>
		<xs:attribute name="model" type="xs:Name" use="optional">
			<xs:annotation>
				<xs:documentation>Name of the model to use for this input value. If this attribute is not set, the input model associated to the input field containing this input value is used.</xs:documentation>
			</xs:annotation>
		</xs:attribute>
	</xs:attributeGroup>
	
	<xs:attributeGroup name="StringInputAttributes">
		<xs:attribute name="cloze" type="xs:boolean" use="optional" default="false">
  		<xs:annotation>
  			<xs:documentation>Controls whether or not the string field should be displayed like an item of a cloze test.</xs:documentation>
  		</xs:annotation>
  	</xs:attribute>
  	<xs:attribute name="characters" use="optional" type="xs:string">
  		<xs:annotation>
  			<xs:documentation>When set, limits the characters that the user may use to the characters occuring in the given string.</xs:documentation>
  		</xs:annotation>
  	</xs:attribute>
  	<xs:attribute name="minlength" default="0" type="xs:nonNegativeInteger">
  		<xs:annotation>
  			<xs:documentation>Minimum length of the string that the user may enter.</xs:documentation>
  		</xs:annotation>
  	</xs:attribute>
  	<xs:attribute name="maxlength" use="optional" type="xs:positiveInteger">
  		<xs:annotation>
  			<xs:documentation>Maximum length of the string that the user may enter. If this attribute is not set, it defines no restrictions.</xs:documentation>
  		</xs:annotation>
  	</xs:attribute>
  	<xs:attribute name="casesensitive" type="xs:boolean" default="true">
  		<xs:annotation>
  			<xs:documentation>Wether or not the solution should be checked in a case sensitive way or not.</xs:documentation>
  		</xs:annotation>
  	</xs:attribute>
		<xs:attribute name="charactershints" type="xs:boolean" default="false">
 			<xs:annotation>
 				<xs:documentation>Whether or not to give live hints about the allowed characters when the user has not yet submitted the input value.</xs:documentation>
 			</xs:annotation>
 		</xs:attribute>
 		<xs:attribute name="minlengthhints" type="xs:boolean" default="false">
 			<xs:annotation>
 				<xs:documentation>Whether or not to give live hints about the allowed minimal length when the user has not yet submitted the input value.</xs:documentation>
 			</xs:annotation>
 		</xs:attribute>
 		<xs:attribute name="maxlengthhints" type="xs:boolean" default="false">
 			<xs:annotation>
 				<xs:documentation>Whether or not to give live hints about the allowed maximal length when the user has not yet submitted the input value.</xs:documentation>
 			</xs:annotation>
 		</xs:attribute>
	</xs:attributeGroup>
	
	<xs:attributeGroup name="BooleanInputAttributes"/>
	
	<xs:attributeGroup name="ChoiceInputAttributes">
  	<xs:attribute name="shuffle" use="optional" type="xs:boolean" default="false">
  		<xs:annotation>
  			<xs:documentation>
  				Whether or not the available options should be shuffled randomly
  				each time the page is loaded.
  			</xs:documentation>
  		</xs:annotation>
  	</xs:attribute>
	</xs:attributeGroup>
	
	<xs:attributeGroup name="NumberInputAttributes">
		<xs:attribute name="base" default="10" type="NumberBase">
			<xs:annotation>
				<xs:documentation>Base of the standard positional number system in which the number is expected from the user and written in the solution.</xs:documentation>
			</xs:annotation>
		</xs:attribute>
		<xs:attribute name="minfracdigits" default="0" type="xs:nonNegativeInteger">
			<xs:annotation>
				<xs:documentation>
					The minimum number of fractional digits (digits after the radix point) that have to be present in the users input.
				</xs:documentation>
			</xs:annotation>
		</xs:attribute>
		<xs:attribute name="maxfracdigits" use="optional" type="xs:nonNegativeInteger">
			<xs:annotation>
				<xs:documentation>
					The maximum number of fractional digits (digits after the radix point) that have to be present in the users input.
					If this attribute is not present, it defines no restrictions.
				</xs:documentation>
			</xs:annotation>
		</xs:attribute>
		<xs:attribute name="minintdigits" default="0" type="xs:nonNegativeInteger">
			<xs:annotation>
				<xs:documentation>
					The minimum number of integer digits (digits before the radix point) that have to be present in the users input.
				</xs:documentation>
			</xs:annotation>
		</xs:attribute>
		<xs:attribute name="maxintdigits" use="optional" type="xs:nonNegativeInteger">
			<xs:annotation>
				<xs:documentation>
					The maximum number of integer digits (digits before the radix point) that have to be present in the users input.
					If this attribute is not present, it defines no restrictions.
				</xs:documentation>
			</xs:annotation>
		</xs:attribute>
		<xs:attribute name="significant" use="optional" default="15" type="xs:nonNegativeInteger">
			<xs:annotation>
				<xs:documentation>
					The number of digits of the users input after the radix point that the system takes into account
					for checking its value against the correct solution.
				</xs:documentation>
			</xs:annotation>
		</xs:attribute>
		<xs:attribute name="minfracdigitshints" type="xs:boolean" default="false">
 			<xs:annotation>
 				<xs:documentation>Whether or not to give live hints about the minimum number of allowed fractional digits (digits after the radix point)
 				when the user has not yet submitted the input value.</xs:documentation>
 			</xs:annotation>
 		</xs:attribute>
 		<xs:attribute name="maxfracdigitshints" type="xs:boolean" default="false">
 			<xs:annotation>
 				<xs:documentation>Whether or not to give live hints about the maximum number of allowed fractional digits (digits after the radix point)
 				when the user has not yet submitted the input value.</xs:documentation>
 			</xs:annotation>
 		</xs:attribute>
		<xs:attribute name="minintdigitshints" type="xs:boolean" default="false">
 			<xs:annotation>
 				<xs:documentation>Whether or not to give live hints about the minimum number of allowed integer digits (digits before the radix point)
 				when the user has not yet submitted the input value.</xs:documentation>
 			</xs:annotation>
 		</xs:attribute>
 		<xs:attribute name="maxintdigitshints" type="xs:boolean" default="false">
 			<xs:annotation>
 				<xs:documentation>Whether or not to give live hints about the maximum number of allowed integer digits (digits before the radix point)
 				when the user has not yet submitted the input value.</xs:documentation>
 			</xs:annotation>
 		</xs:attribute>
 		<xs:attribute name="lowertolerance" default="0" type="NonNegativeDecimal">
			<xs:annotation>
				<xs:documentation>
					If this value is LT and the solution is x, then any value between x-LT and x is considered a correct value.
				</xs:documentation>
			</xs:annotation>
		</xs:attribute>
		<xs:attribute name="uppertolerance" default="0" type="NonNegativeDecimal">
			<xs:annotation>
				<xs:documentation>
					If this value is UT and the solution is x, then any value between x and x+UT is considered a correct value.
				</xs:documentation>
			</xs:annotation>
		</xs:attribute>
		<xs:attribute name="lowerreltolerance" default="0" type="NonNegativeDecimal">
			<xs:annotation>
				<xs:documentation>
					If this value is LRT and the solution is x, then any value between x-LRT*|x| and x is considered a correct value.
				</xs:documentation>
			</xs:annotation>
		</xs:attribute>
		<xs:attribute name="upperreltolerance" default="0" type="NonNegativeDecimal">
			<xs:annotation>
				<xs:documentation>
					If this value is URT and the solution is x, then any value between x and x+URT*|x| is considered a correct value.
				</xs:documentation>
			</xs:annotation>
		</xs:attribute>
	</xs:attributeGroup>
	
	<xs:simpleType name="NumberBase">
		<xs:annotation>
			<xs:documentation>
				Describes a valid number that can be used as base for a standard positional number system with digits and Latin characters.
				Since there are 9 distinct digits and 26 distinct characters in the Latin alphabet, all integers between 1 and 35 are valid base numbers.
			</xs:documentation>
		</xs:annotation>
		<xs:restriction base="xs:positiveInteger">
			<xs:maxInclusive value="35"/>
		</xs:restriction>
	</xs:simpleType>
	
	<xs:attributeGroup name="ExponentialInputAttributes">
		<xs:attribute name="base" default="10" type="xs:positiveInteger">
			<xs:annotation>
				<xs:documentation>The base which is used to describe the number.</xs:documentation>
			</xs:annotation>
		</xs:attribute>
		<xs:attribute name="lowertolerance" default="0" type="NonNegativeDecimal">
			<xs:annotation>
				<xs:documentation>
					If this value is LT and the solution is x, then any value between x-LT and x is considered a correct value.
				</xs:documentation>
			</xs:annotation>
		</xs:attribute>
		<xs:attribute name="uppertolerance" default="0" type="NonNegativeDecimal">
			<xs:annotation>
				<xs:documentation>
					If this value is UT and the solution is x, then any value between x and x+UT is considered a correct value.
				</xs:documentation>
			</xs:annotation>
		</xs:attribute>
		<xs:attribute name="lowerreltolerance" default="0" type="NonNegativeDecimal">
			<xs:annotation>
				<xs:documentation>
					If this value is LRT and the solution is x, then any value between x-LRT*|x| and x is considered a correct value.
				</xs:documentation>
			</xs:annotation>
		</xs:attribute>
		<xs:attribute name="upperreltolerance" default="0" type="NonNegativeDecimal">
			<xs:annotation>
				<xs:documentation>
					If this value is URT and the solution is x, then any value between x and x+URT*|x| is considered a correct value.
				</xs:documentation>
			</xs:annotation>
		</xs:attribute>
	</xs:attributeGroup>
	
	<xs:attributeGroup name="ExpressionInputAttributes">
		<xs:attribute name="useonly" use="optional" type="ExpressionNodeTypeList">
			<xs:annotation>
				<xs:documentation>
					A space-separated list of expression node types that are allowed to appear in the expression.
					If this attribute is not present, it defines no restrictions.
				</xs:documentation>
			</xs:annotation>
		</xs:attribute>
		<xs:attribute name="usenot" default="" type="ExpressionNodeTypeList">
			<xs:annotation>
				<xs:documentation>
					A space-separated list of expression node types that must not occur anywhere in the expression.
				</xs:documentation>
			</xs:annotation>
		</xs:attribute>        
		<xs:attribute name="useonce" default="" type="ExpressionNodeTypeList">
			<xs:annotation>
				<xs:documentation>
					A space-separated list of expression node types that have to appear exactly once in the expression.
				</xs:documentation>
			</xs:annotation>
		</xs:attribute>
		<xs:attribute name="expect" use="optional" type="ExpressionNodeTypeList">
			<xs:annotation>
				<xs:documentation>
					A space-separated list of expression node types that are allowed for the root node of the expression.
					If this attribute is not present, it defines no restrictions.
				</xs:documentation>
			</xs:annotation>
		</xs:attribute>
		<xs:attribute name="simplified" default="false" type="xs:boolean">
			<xs:annotation>
				<xs:documentation>
					If this attribute is set to true, then the expression that the users writes into the field must be fully simplified.
					In particular, this means that all fractions must be reduced.
				</xs:documentation>
				<xs:appinfo>
        	<edmldoc:experimental/>
        </xs:appinfo>
			</xs:annotation>
		</xs:attribute>
	</xs:attributeGroup>
	
	<xs:attributeGroup name="SetInputAttributes">
		<xs:attribute name="minsize" default="0" type="xs:nonNegativeInteger">
			<xs:annotation>
  			<xs:documentation>Minimum number of elements that the user may put into the set.</xs:documentation>
  		</xs:annotation>
		</xs:attribute>
		
		<xs:attribute name="maxsize" use="optional" type="xs:nonNegativeInteger">
			<xs:annotation>
  			<xs:documentation>Maximum number of elements that the user may put into the set.</xs:documentation>
  		</xs:annotation>
		</xs:attribute>
		
		<xs:attribute name="of" use="optional" type="SetElementValueTypeList">
			<xs:annotation>
				<xs:documentation>
					Space-separated list of element types that the user may put into this set.
					If this attribute is not present, the system will automatically look for all element types that appear in the solution and offer only these types.
				</xs:documentation>
			</xs:annotation>
		</xs:attribute>
				
		<xs:attribute name="minsizehints" type="xs:boolean" default="false">
  		<xs:annotation>
  			<xs:documentation>Whether or not to give live hints about the allowed minimum size of the set
  			when the user has not yet submitted the input value.</xs:documentation>
  		</xs:annotation>
  	</xs:attribute>
  	
  	<xs:attribute name="maxsizehints" type="xs:boolean" default="false">
  		<xs:annotation>
  			<xs:documentation>Whether or not to give live hints about the allowed maximum size of the set
  			when the user has not yet submitted the input value.</xs:documentation>
  		</xs:annotation>
  	</xs:attribute>
  	
  	<xs:attribute name="ofhints" type="xs:boolean" default="false">
  		<xs:annotation>
  			<xs:documentation>Whether or not to give live hints about the allowed element types in the set
  			when the user has not yet submitted the input value.</xs:documentation>
  		</xs:annotation>
  	</xs:attribute>
	
	</xs:attributeGroup>
	
	<xs:attributeGroup name="VectorInputAttributes">
		<xs:attribute name="minsize" type="xs:positiveInteger" default="1">
			<xs:annotation>
  			<xs:documentation>Minimum number of components in this vector.</xs:documentation>
  		</xs:annotation>
		</xs:attribute>
		<xs:attribute name="maxsize" use="optional" type="xs:positiveInteger">
			<xs:annotation>
  			<xs:documentation>Maximum number of components in this vector.</xs:documentation>
  		</xs:annotation>
		</xs:attribute>
		<xs:attribute name="defaultsize" use="optional" type="xs:positiveInteger">
			<xs:annotation>
  			<xs:documentation>Initial number of components in this vector that are already there when the user loads the page.</xs:documentation>
  		</xs:annotation>
		</xs:attribute>
		<xs:attribute name="minsizehints" type="xs:boolean" default="false">
 			<xs:annotation>
 				<xs:documentation>Whether or not to give live hints about the allowed minimum size of the vector
  			when the user has not yet submitted the input value.</xs:documentation>
 			</xs:annotation>
 		</xs:attribute>
 		<xs:attribute name="maxsizehints" type="xs:boolean" default="false">
 			<xs:annotation>
 				<xs:documentation>Whether or not to give live hints about the allowed maximum size of the vector
  			when the user has not yet submitted the input value.</xs:documentation>
 			</xs:annotation>
 		</xs:attribute>
	</xs:attributeGroup>

	<xs:attributeGroup name="MatrixInputAttributes">
		<xs:attribute name="minrows" type="xs:positiveInteger" default="1">
			<xs:annotation>
  			<xs:documentation>Minimum number of rows in this matrix.</xs:documentation>
  		</xs:annotation>
		</xs:attribute>
		<xs:attribute name="maxrows" type="xs:positiveInteger">
			<xs:annotation>
  			<xs:documentation>Maximum number of rows in this matrix.</xs:documentation>
  		</xs:annotation>
		</xs:attribute>
		<xs:attribute name="defaultrows" type="xs:positiveInteger">
			<xs:annotation>
  			<xs:documentation>Initial number of rows in this matrix that are already there when the user loads the page.</xs:documentation>
  		</xs:annotation>
		</xs:attribute>
		
		<xs:attribute name="mincolumns" type="xs:positiveInteger" default="1">
			<xs:annotation>
  			<xs:documentation>Minimum number of columns in this matrix.</xs:documentation>
  		</xs:annotation>
		</xs:attribute>
		<xs:attribute name="maxcolumns" type="xs:positiveInteger">
			<xs:annotation>
  			<xs:documentation>Maximum number of columns in this matrix.</xs:documentation>
  		</xs:annotation>
		</xs:attribute>
		<xs:attribute name="defaultcolumns" type="xs:positiveInteger">
			<xs:annotation>
  			<xs:documentation>Initial number of columns in this matrix that are already there when the user loads the page.</xs:documentation>
  		</xs:annotation>
		</xs:attribute>
		<xs:attribute name="minrowshints" type="xs:boolean" default="false">
 			<xs:annotation>
 				<xs:documentation>Whether or not to give live hints about the allowed minimum number of rows in the matrix
  			when the user has not yet submitted the input value.</xs:documentation>
 			</xs:annotation>
 		</xs:attribute>
 		<xs:attribute name="maxrowshints" type="xs:boolean" default="false">
 			<xs:annotation>
 				<xs:documentation>Whether or not to give live hints about the allowed maximum number of rows in the matrix
  			when the user has not yet submitted the input value.</xs:documentation>
 			</xs:annotation>
 		</xs:attribute>
 		<xs:attribute name="mincolumnshints" type="xs:boolean" default="false">
 			<xs:annotation>
 				<xs:documentation>Whether or not to give live hints about the allowed minimum number of columns in the matrix
  			when the user has not yet submitted the input value.</xs:documentation>
 			</xs:annotation>
 		</xs:attribute>
 		<xs:attribute name="maxcolumnshints" type="xs:boolean" default="false">
 			<xs:annotation>
 				<xs:documentation>Whether or not to give live hints about the allowed maximum number of columns in the matrix
  			when the user has not yet submitted the input value.</xs:documentation>
 			</xs:annotation>
 		</xs:attribute>
	</xs:attributeGroup>
	
	<xs:attributeGroup name="IntervalInputAttributes">
		<xs:attribute name="fixclosure" type="xs:boolean" default="false">
			<xs:annotation>
				<xs:documentation>
					Specifies whether the interval type should be already filled in for the user with the type defined in the "closed" attribute.
					If this attribute is set to true, the user can not change the interval type.
					Otherwise, the user has to specify the interval type on his or her own.
				</xs:documentation>
			</xs:annotation>
		</xs:attribute>
	</xs:attributeGroup>
	
	<xs:attributeGroup name="QuantityInputAttributes"/>
	
	<xs:simpleType name="UnitPrefix">
		<xs:annotation>
			<xs:documentation>A unit prefix as defined in the SI unit system.</xs:documentation>
		</xs:annotation>
		<xs:restriction base="xs:NMTOKEN">
			<xs:enumeration value="Y">
				<xs:annotation>
					<xs:documentation>Yota</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="Z">
				<xs:annotation>
					<xs:documentation>Zetta</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="E">
				<xs:annotation>
					<xs:documentation>Exa</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="P">
				<xs:annotation>
					<xs:documentation>Peta</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="T">
				<xs:annotation>
					<xs:documentation>Tera</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="G">
				<xs:annotation>
					<xs:documentation>Giga</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="M">
				<xs:annotation>
					<xs:documentation>Mega</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="k">
				<xs:annotation>
					<xs:documentation>Kilo</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="h">
				<xs:annotation>
					<xs:documentation>Hekto</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="da">
				<xs:annotation>
					<xs:documentation>Deka</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="d">
				<xs:annotation>
					<xs:documentation>Dezi</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="c">
				<xs:annotation>
					<xs:documentation>Zenti</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="m">
				<xs:annotation>
					<xs:documentation>Milli</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="μ">
				<xs:annotation>
					<xs:documentation>Mikro</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="n">
				<xs:annotation>
					<xs:documentation>Nano</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="p">
				<xs:annotation>
					<xs:documentation>Piko</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="f">
				<xs:annotation>
					<xs:documentation>Femto</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="a">
				<xs:annotation>
					<xs:documentation>Atto</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="z">
				<xs:annotation>
					<xs:documentation>Zepto</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="y">
				<xs:annotation>
					<xs:documentation>Yokto</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
		</xs:restriction>
	</xs:simpleType>
	
	<xs:simpleType name="UnitPrefixList">
		<xs:annotation>
			<xs:documentation>A space-separated list of unit prefixes (such as "k m d").</xs:documentation>
		</xs:annotation>
		<xs:list itemType="UnitPrefix"/>
	</xs:simpleType>
	
	<xs:simpleType name="UnitSymbol">
		<xs:annotation>
			<xs:documentation>A symbol for a physical unit as described in the SI unit system.</xs:documentation>
		</xs:annotation>
		<xs:restriction base="xs:NMTOKEN">
			<xs:enumeration value="SIbase">
				<xs:annotation>
					<xs:documentation>Shorthand for all seven SI base units (s, m, kg A, K, mol and cd).</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="SIderived">
				<xs:annotation>
					<xs:documentation>Shorthand for all SI units that are not base units. This is the opposite of SIbase.</xs:documentation>
				</xs:annotation>
			</xs:enumeration>			
			<xs:enumeration value="s">
				<xs:annotation>
					<xs:documentation>Second</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="m">
				<xs:annotation>
					<xs:documentation>Meter</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="kg">
				<xs:annotation>
					<xs:documentation>Kilogram</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="A">
				<xs:annotation>
					<xs:documentation>Ampere</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="K">
				<xs:annotation>
					<xs:documentation>Kelvin</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="mol">
				<xs:annotation>
					<xs:documentation>Mole</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="cd">
				<xs:annotation>
					<xs:documentation>Candela</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="rad">
				<xs:annotation>
					<xs:documentation>Radian</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="sr">
				<xs:annotation>
					<xs:documentation>Steradian</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="Hz">
				<xs:annotation>
					<xs:documentation>Hertz</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="N">
				<xs:annotation>
					<xs:documentation>Newton</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="Pa">
				<xs:annotation>
					<xs:documentation>Pascal</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="J">
				<xs:annotation>
					<xs:documentation>Joule</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="W">
				<xs:annotation>
					<xs:documentation>Watt</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="C">
				<xs:annotation>
					<xs:documentation>Coulomb</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="V">
				<xs:annotation>
					<xs:documentation>Volt</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="F">
				<xs:annotation>
					<xs:documentation>Farad</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="ohm">
				<xs:annotation>
					<xs:documentation>Ohm</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="S">
				<xs:annotation>
					<xs:documentation>Siemens</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="Wb">
				<xs:annotation>
					<xs:documentation>Weber</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="T">
				<xs:annotation>
					<xs:documentation>Tesla</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="H">
				<xs:annotation>
					<xs:documentation>Henry</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="celsius">
				<xs:annotation>
					<xs:documentation>Celsius</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="lm">
				<xs:annotation>
					<xs:documentation>Lumen</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="lx">
				<xs:annotation>
					<xs:documentation>Lux</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="Bq">
				<xs:annotation>
					<xs:documentation>Becquerel</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="Gy">
				<xs:annotation>
					<xs:documentation>Gray</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="Sv">
				<xs:annotation>
					<xs:documentation>Sievert</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="kat">
				<xs:annotation>
					<xs:documentation>Katal</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
		</xs:restriction>
	</xs:simpleType>
	
	<xs:simpleType name="UnitSymbolList">
		<xs:annotation>
			<xs:documentation>A space-separated list of unit symbols.</xs:documentation>
		</xs:annotation>
	  <xs:list itemType="UnitSymbol"/>
	</xs:simpleType>
	
	<xs:attributeGroup name="UnitInputAttributes">
		<xs:attribute name="useonly" type="UnitSymbolList">
			<xs:annotation>
				<xs:documentation>
					A space-separated list of unit symbols that the user is allowed to use.
					If this attribute is not present, then it defines no restrictions.
				</xs:documentation>
			</xs:annotation>
		</xs:attribute>
		<xs:attribute name="usenot" type="UnitSymbolList">
			<xs:annotation>
				<xs:documentation>
					A space-separated list of unit symbols that the user is allowed to use.
					If this attribute is not present, then it defines no restrictions.
				</xs:documentation>
			</xs:annotation>
		</xs:attribute>
		<xs:attribute name="prefixes" type="UnitPrefixList">
			<xs:annotation>
				<xs:documentation>
					A space-separated list of unit prefixes that the user is allowed to use.
					If this attribute is not present, then it defines no restrictions.
				</xs:documentation>
			</xs:annotation>
		</xs:attribute>
		<xs:attribute name="useonlyhints" type="xs:boolean" default="false">
  		<xs:annotation>
  			<xs:documentation>Whether or not to give live hints about the list of allowed unit symbols
  			when the user has not yet submitted the input value.</xs:documentation>
  		</xs:annotation>
  	</xs:attribute>
  	<xs:attribute name="usenothints" type="xs:boolean" default="false">
  		<xs:annotation>
  			<xs:documentation>Whether or not to give live hints about the list of forbidden unit symbols
  			when the user has not yet submitted the input value.</xs:documentation>
  		</xs:annotation>
  	</xs:attribute>
  	<xs:attribute name="prefixeshints" type="xs:boolean" default="false">
  		<xs:annotation>
  			<xs:documentation>Whether or not to give live hints about the list of allowed unit prefixes
  			when the user has not yet submitted the input value.</xs:documentation>
  		</xs:annotation>
  	</xs:attribute>
	</xs:attributeGroup>
	
	<xs:attributeGroup name="MolecularInputAttributes"/>
	
	<xs:attributeGroup name="ReactionInputAttributes">
		<xs:attribute name="type" type="ReactionType" default="equilibrium">
			<xs:annotation>
				<xs:documentation>Describes the type of the chemical reaction. This decides what symbol is placed between the educts and the products.</xs:documentation>
			</xs:annotation>
		</xs:attribute>
		<xs:attribute name="integers" type="xs:boolean" default="false">
			<xs:annotation>
				<xs:documentation>Whether or not the user should only be allowed to use integer coefficients.</xs:documentation>
			</xs:annotation>
		</xs:attribute>
	</xs:attributeGroup>
	
	<xs:attributeGroup name="MatchingInputAttributes">
		<xs:attribute name="shuffle" use="optional" type="xs:boolean" default="false">
  		<xs:annotation>
  			<xs:documentation>
  				Whether or not the terms and definitions should be shuffled randomly
  				each time the page is loaded.
  			</xs:documentation>
  		</xs:annotation>
  	    </xs:attribute>
        <xs:attribute name="dragusage" default="1" type="xs:positiveInteger">
            <xs:annotation>
                <xs:documentation>Decides how often the user can use each drag item in the matching problem.</xs:documentation>
            </xs:annotation>
        </xs:attribute>
        <xs:attribute name="dropusage" default="1" type="xs:positiveInteger">
            <xs:annotation>
                <xs:documentation>Decides how often the user can use each drop item in the matching problem.</xs:documentation>
            </xs:annotation>
        </xs:attribute>

    </xs:attributeGroup>
	
	<xs:simpleType name="ReactionType">
		<xs:annotation>
			<xs:documentation>Type of a chemical reaction.</xs:documentation>
		</xs:annotation>	
		<xs:restriction base="xs:NMTOKEN">
			<xs:enumeration value="equilibrium">
				<xs:annotation><xs:documentation>A reaction that should be displayed as chemical equilibrium (&#x21CC;).</xs:documentation></xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="forward">
				<xs:annotation><xs:documentation>A reaction that should be displayed as a net foward reaction (&#x2192;).</xs:documentation></xs:annotation>
				</xs:enumeration>
			<xs:enumeration value="reverse">
				<xs:annotation><xs:documentation>A reaction that should be displayed as a reverse reaction (&#x2190;).</xs:documentation></xs:annotation>
				</xs:enumeration>
		</xs:restriction>
	</xs:simpleType>
	
	<xs:complexType name="StringInputModel">
		<xs:annotation>
			<xs:documentation>
				Settings element inside the <code>inputmodel</code> element which is used to specify the settings for string input fields.
			</xs:documentation>
		</xs:annotation>
		<xs:attributeGroup ref="StringInputAttributes"/>
	</xs:complexType>
	
	<xs:complexType name="OrderInputModel">
		<xs:annotation>
			<xs:documentation>
				Settings element inside the <code>inputmodel</code> element which is used to specify the settings for order input fields.
			</xs:documentation>
		</xs:annotation>
	</xs:complexType>
	
	<xs:complexType name="MatchingInputModel">
		<xs:annotation>
			<xs:documentation>
				Settings element inside the <code>inputmodel</code> element which is used to specify the settings for matching input fields.
			</xs:documentation>
			<xs:appinfo>
				<edmldoc:experimental/>
			</xs:appinfo>
		</xs:annotation>
		<xs:attributeGroup ref="MatchingInputAttributes"/>
	</xs:complexType>

	<xs:complexType name="BooleanInputModel">
		<xs:annotation>
			<xs:documentation>
				Settings element inside the <code>inputmodel</code> element which is used to specify the settings for boolean input fields.
			</xs:documentation>
		</xs:annotation>
		<xs:attributeGroup ref="BooleanInputAttributes"/>
	</xs:complexType>
	
	<xs:complexType name="ChoiceInputModel">
		<xs:annotation>
			<xs:documentation>
				Settings element inside the <code>inputmodel</code> element which is used to specify the settings for choice input fields.
			</xs:documentation>
		</xs:annotation>
		<xs:attributeGroup ref="ChoiceInputAttributes"/>
	</xs:complexType>
	
	<xs:complexType name="NumberInputModel">
		<xs:annotation>
			<xs:documentation>
				Settings element inside the <code>inputmodel</code> element which is used to specify the settings for number input fields.
			</xs:documentation>
		</xs:annotation>
		<xs:attributeGroup ref="NumberInputAttributes"/>
	</xs:complexType>
	
	<xs:complexType name="ExponentialInputModel">
		<xs:annotation>
			<xs:documentation>
				Settings element inside the <code>inputmodel</code> element which is used to specify the settings for exponential input fields.
			</xs:documentation>
		</xs:annotation>
		<xs:attributeGroup ref="ExponentialInputAttributes"/>
	</xs:complexType>
	
	<xs:complexType name="ExpressionInputModel">
		<xs:annotation>
			<xs:documentation>
				Settings element inside the <code>inputmodel</code> element which is used to specify the settings for expression input fields.
			</xs:documentation>
		</xs:annotation>
		<xs:attributeGroup ref="ExpressionInputAttributes"/>
	</xs:complexType>
	
	<xs:complexType name="SetInputModel">
		<xs:annotation>
			<xs:documentation>
				Settings element inside the <code>inputmodel</code> element which is used to specify the settings for set input fields.
			</xs:documentation>
		</xs:annotation>
		<xs:attributeGroup ref="SetInputAttributes"/>
	</xs:complexType>
	
	<xs:complexType name="VectorInputModel">
		<xs:annotation>
			<xs:documentation>
				Settings element inside the <code>inputmodel</code> element which is used to specify the settings for vector input fields.
			</xs:documentation>
		</xs:annotation>
		<xs:attributeGroup ref="VectorInputAttributes"/>
	</xs:complexType>
	
	<xs:complexType name="MatrixInputModel">
		<xs:annotation>
			<xs:documentation>
				Settings element inside the <code>inputmodel</code> element which is used to specify the settings for matrix input fields.
			</xs:documentation>
		</xs:annotation>
		<xs:attributeGroup ref="MatrixInputAttributes"/>
	</xs:complexType>
	
	<xs:complexType name="IntervalInputModel">
		<xs:annotation>
			<xs:documentation>
				Settings element inside the <code>inputmodel</code> element which is used to specify the settings for interval input fields.
			</xs:documentation>
		</xs:annotation>
		<xs:attributeGroup ref="IntervalInputAttributes"/>
	</xs:complexType>
	
	<xs:complexType name="UnitInputModel">
		<xs:annotation>
			<xs:documentation>
				Settings element inside the <code>inputmodel</code> element which is used to specify the settings for unit input fields.
			</xs:documentation>
		</xs:annotation>
		<xs:attributeGroup ref="UnitInputAttributes"/>
	</xs:complexType>
	
	<xs:complexType name="QuantityInputModel">
		<xs:annotation>
			<xs:documentation>
				Settings element inside the <code>inputmodel</code> element which is used to specify the settings for quantity input fields.
			</xs:documentation>
		</xs:annotation>
		<xs:attributeGroup ref="QuantityInputAttributes"/>
	</xs:complexType>
	
	<xs:complexType name="MolecularInputModel">
		<xs:annotation>
			<xs:documentation>
				Settings element inside the <code>inputmodel</code> element which is used to specify the settings for molecular input fields.
			</xs:documentation>
		</xs:annotation>
		<xs:attributeGroup ref="MolecularInputAttributes"/>
	</xs:complexType>
	
	<xs:complexType name="ReactionInputModel">
		<xs:annotation>
			<xs:documentation>
				Settings element inside the <code>inputmodel</code> element which is used to specify the settings for reaction input fields.
			</xs:documentation>
			<xs:appinfo>
				<edmldoc:experimental/>
			</xs:appinfo>
		</xs:annotation>
		<xs:attributeGroup ref="ReactionInputAttributes"/>
	</xs:complexType>
	
	
	<!-- Einstellungen
		Text:
			- minlength, maxlength (nur vorher),
			- cloze (nur vorher)
		Boolean:
			keine
		Choice:
			- shuffle (nur vorher)
		Number:
			- minfracdigits, maxfracdigits (beides),
			- minintdigits, maxintdigits (beides),
			- minvalue, maxvalue (beides)
		Expression:
			- useonly, usenot (beides),
			- useonce (beides),
			- expect (beides),
			- reduced (beides)
		Set:
			- minsize, maxsize (nur vorher)
		Interval:
			- closure (beides)
		Molecular:
			keine
	!-->
	
	<xs:complexType name="StringInputValue">
		<xs:annotation>
			<xs:documentation>
				Input value inside an <code>input</code> element representing a string, such as "Hello World!".
			</xs:documentation>
		</xs:annotation>
		<xs:simpleContent>
			<xs:extension base="xs:string">
				<xs:attributeGroup ref="CommonInputValueAttributes"/>
				<xs:attributeGroup ref="StringInputAttributes"/>
			</xs:extension>
		</xs:simpleContent>
	</xs:complexType>
	
	<xs:complexType name="BooleanInputValue">
		<xs:annotation>
			<xs:documentation>
				Input value representing a boolean value, either "true" or "false".
			</xs:documentation>
		</xs:annotation>
		<xs:simpleContent>
			<xs:extension base="xs:boolean">
				<xs:attributeGroup ref="CommonInputValueAttributes"/>
				<xs:attributeGroup ref="BooleanInputAttributes"/>
			</xs:extension>
		</xs:simpleContent>
	</xs:complexType>
	
	<xs:complexType name="ChoiceInputValue">
		<xs:annotation>
			<xs:documentation>
				Input value representing a choice out of several options.
			</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:element minOccurs="1" maxOccurs="unbounded" name="option" type="ChoiceOption"/>
		</xs:sequence>
		<xs:attributeGroup ref="CommonInputValueAttributes"/>
		<xs:attributeGroup ref="ChoiceInputAttributes"/>
	</xs:complexType>
	
	<xs:complexType name="ChoiceOption" mixed="true">
		<xs:annotation>
			<xs:documentation>
				An option of a choice input value.
			</xs:documentation>
		</xs:annotation>
		<xs:group ref="InlineGroup" minOccurs="0" maxOccurs="unbounded"/>
		<xs:attribute name="credits" type="xs:nonNegativeInteger" default="1">
			<xs:annotation>
				<xs:documentation>Number of credits the users gets awarded for enabling this option.</xs:documentation>
			</xs:annotation>
		</xs:attribute>		
		<xs:attribute name="correct" type="xs:boolean" default="false" use="optional">
			<xs:annotation>
				<xs:documentation>Whether or not this option is a correct solution of the input field.</xs:documentation>
			</xs:annotation>
		</xs:attribute>	
	</xs:complexType>
	
	<xs:complexType name="OrderInputValue">
		<xs:annotation>
			<xs:documentation>Input value element in which the user has to bring several items in a correct order.</xs:documentation>
			<xs:appinfo>
				<edmldoc:experimental/>
				<edmldoc:example>
					<edmldoc:description>In the order input element, A must appear before B, B must appear before C and A must appear before D:</edmldoc:description>
					<edmldoc:code><![CDATA[<input>
  <order>
    <items>
      <item>A</item>
      <item>B</item>
      <item>C</item>
      <item>D</item>
    </items>
    <chains>
      <chain credits="2">1 2 3</chain>
      <chain>1 4</chain>
    </chain>
  <order>
</input>]]></edmldoc:code>
				</edmldoc:example>
			</xs:appinfo>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="orderitems" type="OrderItems"/>
			<xs:element name="chains" type="OrderChains"/>
		</xs:sequence>
		<xs:attributeGroup ref="CommonInputValueAttributes"/>
	</xs:complexType>
		
	<xs:complexType name="OrderItems">
		<xs:annotation>
			<xs:documentation>Contains the items of an order input value.</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="item" minOccurs="1" maxOccurs="unbounded" type="InputItem"/>
		</xs:sequence>
	</xs:complexType>
	
	<xs:complexType name="InputItem" mixed="true">
		<xs:annotation>
			<xs:documentation>An item of an order or matching input value.</xs:documentation>
		</xs:annotation>
		<xs:sequence minOccurs="0" maxOccurs="unbounded">
        <xs:group ref="InlineGroup"/>
    </xs:sequence>
	</xs:complexType>
	
	<xs:complexType name="OrderChains">
		<xs:annotation>
			<xs:documentation>Contains the chains of an order input value.</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="chain" minOccurs="1" maxOccurs="unbounded" type="OrderChain"/>
		</xs:sequence>
	</xs:complexType>
	
	<xs:complexType name="OrderChain">
		<xs:annotation>
			<xs:documentation>
				A chain of an order input value.
				Every item whose index appears in a chain before another item must be put before that item by the user.
			</xs:documentation>
		</xs:annotation>
		<xs:simpleContent>
			<xs:extension base="InputItemIndexList">
				<xs:attribute name="credits" use="optional" default="1" type="xs:nonNegativeInteger">
					<xs:annotation>
						<xs:documentation>Number of credit points the user gets awarded for ordering the items in compliance with this chain.</xs:documentation>
					</xs:annotation>
				</xs:attribute>
			</xs:extension>
		</xs:simpleContent>
	</xs:complexType>
	
	<xs:simpleType name="InputItemIndexList">
		<xs:annotation>
			<xs:documentation>A space-separated list of one or more order or matching input value item indices.</xs:documentation>
		</xs:annotation>
		<xs:restriction base="PositiveIntegerList">
			<xs:minLength value="1"/>
		</xs:restriction>
	</xs:simpleType>
	
	<xs:simpleType name="PositiveIntegerList">
		<xs:annotation>
			<xs:documentation>A space-separated list of positive integers.</xs:documentation>
		</xs:annotation>
		<xs:list itemType="xs:nonNegativeInteger"/>
	</xs:simpleType>
	
	<xs:complexType name="MatchingInputValue">
		<xs:annotation>
			<xs:documentation>
				Input value element in which the user has to drag items to so-called drop items.
				For every correct match, the users gets a specified number of credits.
			</xs:documentation>
			<xs:appinfo>
				<edmldoc:experimental/>
				<edmldoc:example>
					<edmldoc:description>In the following exercise, the user has to drag color names to RGB triples:</edmldoc:description>
					<edmldoc:code><![CDATA[<matching>
  <dragitems>
    <item>Red</item>
    <item>Green</item>
    <item>Blue</item>
  </dragitems>
  <dropitems>
    <item>(255,0,0)</item>
    <item>(0,255,0)</item>
    <item>(0,0,255)</item>
    <item>(255,255,255)</item>
  </dropitems>
  <matches>
    <match credits="5">1 1</match>
    <match credits="3">2 2</match>
    <match>3 3</match>
  </matches>
</matching>]]></edmldoc:code>
				</edmldoc:example>
			</xs:appinfo>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="dragitems" type="DragItems"/>
			<xs:element name="dropitems" type="DropItems"/>
			<xs:element name="matches" type="Matches"/>
		</xs:sequence>
		<xs:attributeGroup ref="CommonInputValueAttributes"/>
		<xs:attributeGroup ref="MatchingInputAttributes"/>
	</xs:complexType>

    <xs:complexType name="DragItems">
		<xs:annotation>
            <xs:documentation>Contains the drag items of a matching input value.</xs:documentation>
		</xs:annotation>
		<xs:sequence>
            <xs:element name="item" minOccurs="1" maxOccurs="unbounded" type="InputItem"/>
		</xs:sequence>
	</xs:complexType>
	
	<xs:complexType name="DropItems">
		<xs:annotation>
			<xs:documentation>Contains the drop items of a matching input value.</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="item" minOccurs="1" maxOccurs="unbounded" type="InputItem"/>
		</xs:sequence>
	</xs:complexType>
	
	<xs:complexType name="Matches">
		<xs:annotation>
			<xs:documentation>Contains all the correct matches (pairs of drag and drop item numbers starting from 1) of a matching input value.</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="match" minOccurs="0" maxOccurs="unbounded" type="Match"/>
		</xs:sequence>
	</xs:complexType>

	<xs:complexType name="Match">
		<xs:annotation>
			<xs:documentation>Describes a correct match between a drag and a drop item of a matching input value.
				The content of this element must consist of two numbers separated by a space character.
                The first number is the drag item number and the second number is the drop item number (both starting from 1 from top to bottom), as defined in the parent <code>matching</code> element.
			</xs:documentation>
			<xs:appinfo>
				<edmldoc:example>
					<edmldoc:code><![CDATA[<match credits="5">1 2</match>]]></edmldoc:code>
				</edmldoc:example>
			</xs:appinfo>
		</xs:annotation>
		<xs:simpleContent>
			<xs:extension base="MatchingNumberPair">
				<xs:attribute name="credits" use="optional" default="1" type="xs:nonNegativeInteger">
					<xs:annotation>
						<xs:documentation>Number of credit points the user gets awarded for matching the two items.</xs:documentation>
					</xs:annotation>
				</xs:attribute>
			</xs:extension>
		</xs:simpleContent>
	</xs:complexType>
	
	<xs:simpleType name="MatchingNumberPair">
		<xs:annotation>
			<xs:documentation>A space-separated list of exactly two numbers: a drag item number followed by a drop item number.</xs:documentation>
		</xs:annotation>
		<xs:restriction base="PositiveIntegerList">
			<xs:length value="2"/>
		</xs:restriction>
	</xs:simpleType>
	
	<xs:complexType name="NumberInputValue">
		<xs:annotation>
			<xs:documentation>
				Input value representing a number. The correct number can be either given as a direct value such as "-20.123"
				or as an expression that can also involve parameters defined in this containers. The expression is interpreted by the Computer Algebra System
				and must evaluate to a number.
				
				It is possible to specify a different base than the standard base 10. All integers between 1 and 35 are valid bases. Note that both the input from the user and the value written in the solution are interpreted as numbers with respect to the base in use.
			</xs:documentation>
		</xs:annotation>
		<xs:simpleContent>
			<xs:extension base="xs:string">
				<xs:attributeGroup ref="CommonInputValueAttributes"/>
				<xs:attributeGroup ref="NumberInputAttributes"/>
			</xs:extension>
		</xs:simpleContent>
	</xs:complexType>
	
	<xs:complexType name="ExponentialInputValue">
		<xs:annotation>
			<xs:documentation>
				Input value representing a number in exponential notation, such as "-2.01 * 10^5".
			</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="number" minOccurs="1" maxOccurs="2" type="NumberInputValue"/>
		</xs:sequence>
		<xs:attributeGroup ref="CommonInputValueAttributes"/>
		<xs:attributeGroup ref="ExponentialInputAttributes"/>
	</xs:complexType>
	
	<xs:simpleType name="ExpressionNodeTypeList">
		<xs:annotation>
			<xs:documentation>
				A space-separated list of expression node types.
			</xs:documentation>
		</xs:annotation>
		<xs:list itemType="ExpressionNodeType"/>
	</xs:simpleType>
	
	<xs:simpleType name="ExpressionNodeType">
		<xs:annotation>
			<xs:documentation>
				Type of a node in a binary expression tree.
				For example, the expression <code>1+x</code> is parsed into a tree with a "sum" node as root that has two child nodes of type "number" and "variable".
			</xs:documentation>
		</xs:annotation>
		<xs:restriction base="xs:NMTOKEN">
			<xs:enumeration value="number"><xs:annotation><xs:documentation>A number writte in positional notation, possibly with a sign.</xs:documentation></xs:annotation></xs:enumeration>
			<xs:enumeration value="constant"><xs:annotation><xs:documentation>A constant like <code>pi</code>.</xs:documentation></xs:annotation></xs:enumeration>
			<xs:enumeration value="variable"><xs:annotation><xs:documentation>A variable like <code>x</code>.</xs:documentation></xs:annotation></xs:enumeration>
			<xs:enumeration value="faculty"><xs:annotation><xs:documentation>Operator of the form <code>a!</code>.</xs:documentation></xs:annotation></xs:enumeration>            
			<xs:enumeration value="negation"><xs:annotation><xs:documentation>Operator of the form <code>-a</code>.</xs:documentation></xs:annotation></xs:enumeration>
			<xs:enumeration value="abs"><xs:annotation><xs:documentation>Operator of the form <code>|a|</code>.</xs:documentation></xs:annotation></xs:enumeration>            
			<xs:enumeration value="sqrt"><xs:annotation><xs:documentation>Operator of the form <code>sqrt(a)</code>.</xs:documentation></xs:annotation></xs:enumeration>
			<xs:enumeration value="power"><xs:annotation><xs:documentation>Operator of the form <code>a^b</code>.</xs:documentation></xs:annotation></xs:enumeration>    
			<xs:enumeration value="product"><xs:annotation><xs:documentation>Operator of the form <code>a*b</code>.</xs:documentation></xs:annotation></xs:enumeration>
			<xs:enumeration value="fraction"><xs:annotation><xs:documentation>Operator of the form <code>a/b</code>.</xs:documentation></xs:annotation></xs:enumeration>
			<xs:enumeration value="sum"><xs:annotation><xs:documentation>Operator of the form <code>a+b</code>.</xs:documentation></xs:annotation></xs:enumeration>
			<xs:enumeration value="difference"><xs:annotation><xs:documentation>Operator of the form <code>a-b</code>.</xs:documentation></xs:annotation></xs:enumeration>
		</xs:restriction>
	</xs:simpleType>
	
	<xs:complexType name="ExpressionInputValue">
		<xs:annotation>
			<xs:documentation>
				<p>Input value representing a mathematical expression, such as <code>"2*x+1"</code>.
				The expression is parsed into a binary tree consisting of nodes that are either leafs or operators.
				There are three types of leaf nodes:
				</p>
				<ul>
					<li>number (such as <code>1.222</code> or <code>-5.55</code>)</li>
					<li>constant (such as <code>pi</code>, the full list of constants can be defined by the course or the input field)</li>
					<li>variable (such as <code>x</code>, each single letter that is not a constant)</li>
				</ul>
				<p>
				Additionally, there are the following types of operators, ordered by precedence from higher to lower.
				Operators on the same line have the same precedence and are processed from left to right:
				</p>
				<ul>
					<li>faculty (<code>a!</code>)</li>
					<li>negation (<code>-a</code>)</li>
					<li>absolute value (<code>|a|</code>), square root (<code>sqrt(a)</code>)</li>
					<li>power (<code>a^b</code>)</li>
					<li>product (<code>a*b</code>), fraction (<code>a/b</code>)</li>
					<li>sum (<code>a+b</code>), difference (<code>a-b</code>)</li>
				</ul>
				<p>
				Leaf nodes are considered to have the highest precedence.
				For example, the expression <code>-2.22</code> is parsed into a single number node,
				while the expression <code>-x</code> is parsed into a tree with a negation node as root node and one node for the variable <code>x</code> as child node.
				</p>
				<p>The user may use brackets to change the order of operators.
					For example, the expression <code>-(2.22)</code> is parsed into a tree whose root is a negation node.
				</p>
				<p>
				The multiplication sign may be left out in situations where the meaning is clear.
				For example, <code>2xy</code> is parsed the same as <code>2*x*y</code>.
					But <code>2pi</code> is parsed into a product of <code>2</code> with <code>pi</code>, because <code>pi</code> is a predefined constant.
				</p>
			</xs:documentation>
		</xs:annotation>
		<xs:simpleContent>
			<xs:extension base="xs:string">
				<xs:attributeGroup ref="CommonInputValueAttributes"/>
				<xs:attributeGroup ref="ExpressionInputAttributes"/>
			</xs:extension>
		</xs:simpleContent>
	</xs:complexType>
	
	<xs:complexType name="SetInputValue">
		<xs:annotation>
			<xs:documentation>
				Input value representing a set those elements are either text, number, expression, set, vector,
				matrix or interval values.
				For example, <code>{1,2,3}</code> is a set of numbers and <code>{{1},{}}</code> is a set of sets.
				The type of the element values in a set may not be mixed.
			</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:sequence minOccurs="0" maxOccurs="unbounded">
				<xs:element name="number" type="NumberInputValue"/>
				<xs:element name="exponential" type="ExponentialInputValue"/>
				<xs:element name="expression" type="ExpressionInputValue"/>
				<xs:element name="set" type="SetInputValue"/>
				<xs:element name="vector" type="VectorInputValue"/>
				<xs:element name="matrix" type="MatrixInputValue"/>
				<xs:element name="interval" type="IntervalInputValue"/>
				<xs:element name="string" type="StringInputValue"/>
			</xs:sequence>
		</xs:sequence>
		<xs:attributeGroup ref="CommonInputValueAttributes"/>
		<xs:attributeGroup ref="SetInputAttributes"/>
	</xs:complexType>
	
	<xs:simpleType name="SetElementValueTypeList">
		<xs:annotation>
			<xs:documentation>A list of input value types that can appear in a set.</xs:documentation>
		</xs:annotation>
		<xs:list itemType="SetElementInputValueType"/>
	</xs:simpleType>
	
	<xs:simpleType name="SetElementInputValueType">
		<xs:annotation>
			<xs:documentation>Describes a type of input elements that can appear in a set.</xs:documentation>
		</xs:annotation>
		<xs:restriction base="xs:NMTOKEN">
			<xs:enumeration value="number"><xs:annotation><xs:documentation>Number elements.</xs:documentation></xs:annotation></xs:enumeration>
			<xs:enumeration value="exponential"><xs:annotation><xs:documentation>Exponential elements.</xs:documentation></xs:annotation></xs:enumeration>
			<xs:enumeration value="expression"><xs:annotation><xs:documentation>Expression elements.</xs:documentation></xs:annotation></xs:enumeration>
			<xs:enumeration value="set"><xs:annotation><xs:documentation>Set elements with any content. Note that it is currently not possible to restrict this type further. </xs:documentation></xs:annotation></xs:enumeration>
			<xs:enumeration value="vector"><xs:annotation><xs:documentation>Vector elements with any content.</xs:documentation></xs:annotation></xs:enumeration>
			<xs:enumeration value="vectorofexpressions"><xs:annotation><xs:documentation>Vector elements with only expression elements as content.</xs:documentation></xs:annotation></xs:enumeration>
			<xs:enumeration value="vectorofnumbers"><xs:annotation><xs:documentation>Vector elements with only number elements as content.</xs:documentation></xs:annotation></xs:enumeration>
			<xs:enumeration value="vectorofstrings"><xs:annotation><xs:documentation>Vector elements with only number elements as content.</xs:documentation></xs:annotation></xs:enumeration>
			<xs:enumeration value="matrix"><xs:annotation><xs:documentation>Matrix elements with any content.</xs:documentation></xs:annotation></xs:enumeration>
			<xs:enumeration value="matrixofexpressions"><xs:annotation><xs:documentation>Matrix elements with only expression elements as content.</xs:documentation></xs:annotation></xs:enumeration>
			<xs:enumeration value="matrixofnumbers"><xs:annotation><xs:documentation>Matrix elements with only number elements as content.</xs:documentation></xs:annotation></xs:enumeration>
			<xs:enumeration value="matrixofstrings"><xs:annotation><xs:documentation>Matrix elements with only number elements as content.</xs:documentation></xs:annotation></xs:enumeration>
			<xs:enumeration value="interval"><xs:annotation><xs:documentation>Interval elements.</xs:documentation></xs:annotation></xs:enumeration>
			<xs:enumeration value="intervalofexpressions"><xs:annotation><xs:documentation>Interval element with only expression elements as bounds.</xs:documentation></xs:annotation></xs:enumeration>
			<xs:enumeration value="intervalofnumbers"><xs:annotation><xs:documentation>Interval elements with only number elements as bounds.</xs:documentation></xs:annotation></xs:enumeration>
			<xs:enumeration value="string"><xs:annotation><xs:documentation>String elements.</xs:documentation></xs:annotation></xs:enumeration>
		</xs:restriction>
	</xs:simpleType>
	
	<xs:complexType name="VectorInputValue">
		<xs:annotation>
			<xs:documentation>
				Input value representing a vector of a fixed amount of numbers or expressions.
				For example, <code>(1,2,3)</code> is a vector of numbers and <code>(2*x,3*x,x)</code> is a vector of expressions.
			</xs:documentation>
		</xs:annotation>
		<xs:choice>
			<xs:element name="number" type="NumberInputValue" minOccurs="1" maxOccurs="unbounded"/>
			<xs:element name="expression" type="ExpressionInputValue" minOccurs="1" maxOccurs="unbounded"/>
			<xs:element name="string" type="StringInputValue" minOccurs="1" maxOccurs="unbounded"/>
		</xs:choice>
		<xs:attributeGroup ref="CommonInputValueAttributes"/>
		<xs:attributeGroup ref="VectorInputAttributes"/>
	</xs:complexType>
	
	<xs:complexType name="MatrixInputValue">
		<xs:annotation>
			<xs:documentation>
				Input value representing a matrix of numbers, expressions or strings.
			</xs:documentation>
		</xs:annotation>
		<xs:choice>
			<xs:sequence minOccurs="1" maxOccurs="unbounded">
				<xs:element name="matrixrow" type="MatrixInputValueRow"/>
			</xs:sequence>
		</xs:choice>
		<xs:attributeGroup ref="CommonInputValueAttributes"/>
		<xs:attributeGroup ref="MatrixInputAttributes"/>
	</xs:complexType>
	
	<xs:complexType name="MatrixInputValueRow">
		<xs:annotation>
			<xs:documentation>
				A row of a matrix input value.
			</xs:documentation>
		</xs:annotation>
		<xs:choice>
			<xs:element name="number" type="NumberInputValue" minOccurs="1" maxOccurs="unbounded"/>
			<xs:element name="expression" type="ExpressionInputValue" minOccurs="1" maxOccurs="unbounded"/>
			<xs:element name="string" type="StringInputValue" minOccurs="1" maxOccurs="unbounded"/>
		</xs:choice>
	</xs:complexType>
	
	<xs:simpleType name="IntervalClosureType">
		<xs:annotation>
			<xs:documentation>Specifies the type of an interval.</xs:documentation>
		</xs:annotation>
		<xs:restriction base="xs:NMTOKEN">
			<xs:enumeration value="closed"><xs:annotation><xs:documentation>Interval of type [a;b].</xs:documentation></xs:annotation></xs:enumeration>
			<xs:enumeration value="closedopen"><xs:annotation><xs:documentation>Interval of type [a;b).</xs:documentation></xs:annotation></xs:enumeration>
			<xs:enumeration value="open"><xs:annotation><xs:documentation>Interval of type (a;b).</xs:documentation></xs:annotation></xs:enumeration>
			<xs:enumeration value="openclosed"><xs:annotation><xs:documentation>Interval of type (a;b].</xs:documentation></xs:annotation></xs:enumeration>
		</xs:restriction>
	</xs:simpleType>
	
	<xs:complexType name="IntervalInputValue">
		<xs:annotation>
			<xs:documentation>
				Input value representing an interval, such as "[2;10)", those endpoints are numbers or expressions.
			</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:choice>
				<xs:element name="number" type="NumberInputValue"/>
				<xs:element name="expression" type="ExpressionInputValue"/>
			</xs:choice>
			<xs:choice>
				<xs:element name="number" type="NumberInputValue"/>
				<xs:element name="expression" type="ExpressionInputValue"/>
			</xs:choice>
		</xs:sequence>	
		<xs:attributeGroup ref="CommonInputValueAttributes"/>
		<xs:attribute name="closure" type="IntervalClosureType" default="closed" use="optional">
			<xs:annotation>
				<xs:documentation>
					Specifies the correct type of the interval. This decides which of its endpoints should belong to it.
				</xs:documentation>
			</xs:annotation>
		</xs:attribute>
		<xs:attributeGroup ref="IntervalInputAttributes"/>
	</xs:complexType>
	
	<xs:complexType name="WordInputValue">
		<xs:annotation>
			<xs:documentation>
				Input value representing a word in the sense of theoretical computer science, such as "aab" or the empty word "epsilon".
			</xs:documentation>
		</xs:annotation>
	</xs:complexType>
	
	<xs:complexType name="UnitInputValue">
		<xs:annotation>
			<xs:documentation>
				Input value representing unit or a combination of units, such as "kg" or "m*s^-2".
			</xs:documentation>
		</xs:annotation>
		<xs:simpleContent>
			<xs:extension base="xs:string">
				<xs:attributeGroup ref="CommonInputValueAttributes"/>
				<xs:attributeGroup ref="UnitInputAttributes"/>
			</xs:extension>
		</xs:simpleContent>
	</xs:complexType>
	
	<xs:complexType name="QuantityInputValue">
		<xs:annotation>
			<xs:documentation>
				Input value representing a physical quantity: A combination of a number and a unit, such as "2*kg".
			</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:choice>
				<xs:element name="number" type="NumberInputValue"/>
				<xs:element name="exponential" type="ExponentialInputValue"/>
				<xs:element name="expression" type="ExpressionInputValue"/>
			</xs:choice>
			<xs:element name="unit" type="UnitInputValue"/>
		</xs:sequence>
		<xs:attributeGroup ref="CommonInputValueAttributes"/>
		<xs:attributeGroup ref="QuantityInputAttributes"/>
	</xs:complexType>
	
	<xs:complexType name="MolecularInputValue">
		<xs:annotation>
			<xs:documentation>
				An molecular formula input value, such as "H2O".
			</xs:documentation>
			<xs:appinfo>
				<edmldoc:example>
					<edmldoc:code><![CDATA[<molecular>H2O</molecular>]]></edmldoc:code>
				</edmldoc:example>
			</xs:appinfo>
		</xs:annotation>
		<xs:simpleContent>
			<xs:extension base="xs:string">
				<xs:attributeGroup ref="CommonInputValueAttributes"/>
				<xs:attributeGroup ref="MolecularInputAttributes"/>
			</xs:extension>
		</xs:simpleContent>
	</xs:complexType>
	
	<xs:complexType name="ReactionInputValue">
		<xs:annotation>
			<xs:documentation>
				Shows a chemical reaction to the user and prompts him to enter correct stoichiometric coefficients for the reagents that result in a balanced reaction. 
			</xs:documentation>
			<xs:appinfo>
				<edmldoc:experimental/>
				<edmldoc:example>
					<edmldoc:code><![CDATA[<reaction type="forward">
  <educts>
    <molecule>CH4</molecule>
    <molecule>O2</molecule>
  </educts>
  <product>
    <molecule>H2O</molecule>
    <molecule>CO2</molecule>
  </product>
</reaction>]]></edmldoc:code>
				</edmldoc:example>
			</xs:appinfo>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="educts" type="ReactionEducts"/>
			<xs:element name="products" type="ReactionProducts"/>
		</xs:sequence>
		<xs:attributeGroup ref="CommonInputValueAttributes"/>
		<xs:attributeGroup ref="ReactionInputAttributes"/>
	</xs:complexType>
	
	<xs:complexType name="ReactionEducts">
		<xs:annotation>
			<xs:documentation>Contains the list of all educts of a chemical reaction.</xs:documentation>
			<xs:appinfo>
				<edmldoc:experimental/>
			</xs:appinfo>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="molecule" type="ReactionMolecule" minOccurs="1" maxOccurs="unbounded"/>
		</xs:sequence>
	</xs:complexType>
	
	<xs:complexType name="ReactionProducts">
		<xs:annotation>
			<xs:documentation>Contains the list of all products of a chemical reaction.</xs:documentation>
			<xs:appinfo>
				<edmldoc:experimental/>
			</xs:appinfo>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="molecule" type="ReactionMolecule" minOccurs="1" maxOccurs="unbounded"/>
		</xs:sequence>
	</xs:complexType>
	
	<xs:complexType name="ReactionMolecule">
		<xs:annotation>
			<xs:documentation>A molecule that takes part in a chemical reaction given by a molecular formular.
			The format is the same as for the <code>molecular</code> element.</xs:documentation>
			<xs:appinfo>
				<edmldoc:experimental/>
				<edmldoc:example>
					<edmldoc:code><![CDATA[<molecule>H2O</molecule>]]></edmldoc:code>
				</edmldoc:example>
			</xs:appinfo>
		</xs:annotation>
		<xs:simpleContent>
			<xs:extension base="xs:string">
				<xs:attribute name="coefficient" type="PositiveDecimal">
					<xs:annotation>
						<xs:documentation>If this attribute is present, the specified value is shown to the user as coefficient (the number in front of the molecule in the chemical reaction)
						and cannot be changed by the user. Otherwise, the user must enter the coefficient.</xs:documentation>
					</xs:annotation>
				</xs:attribute>
				<xs:attribute name="fixed" type="xs:boolean" default="false">
					<xs:annotation>
						<xs:documentation>Specifies whether the molecular formular (not the coefficient) should be fixed and shown to the user.
						If this attribute is enabled, the molecular formular is shown to the user and cannot be changed by the user.
						Otherwise, the user must enter the molecular formular.</xs:documentation>
					</xs:annotation>
				</xs:attribute>
			</xs:extension>
		</xs:simpleContent>
	</xs:complexType>
	
	<xs:complexType name="Calculate">
		<xs:annotation>
			<xs:documentation>Calculates a decimal value from an expression that can involve parameters and replaces this element with the computed value.</xs:documentation>
			<xs:appinfo>
				<edmldoc:example>
					<edmldoc:description>When a parameter with identifier <code>a</code> is defined in a container, one could write the following somewhere in its content:</edmldoc:description>
					<edmldoc:code><![CDATA[<p>Please enter twice the value of <calculate>2*a</calculate>:</p>]]></edmldoc:code>
				</edmldoc:example>
			</xs:appinfo>
		</xs:annotation>
		<xs:simpleContent>
        <xs:extension base="xs:string"/>
    </xs:simpleContent>
	</xs:complexType>
	
    <xs:simpleType name="PositiveDecimal">
        <xs:annotation>
            <xs:documentation>Same as xs:decimal, expect that the value must be strictly greater than 0.</xs:documentation>
        </xs:annotation>
        <xs:restriction base="xs:decimal">
            <xs:minExclusive value="0"/>
        </xs:restriction>
    </xs:simpleType>
    
    <xs:simpleType name="NonNegativeDecimal">
        <xs:annotation>
            <xs:documentation>Same as xs:decimal, expect that the value must be greater than or equal to 0.</xs:documentation>
        </xs:annotation>
        <xs:restriction base="xs:decimal">
            <xs:minInclusive value="0"/>
        </xs:restriction>
    </xs:simpleType>
    
    <xs:complexType name="SolutionHint">
        <xs:annotation>
            <xs:documentation>
              A hint to a solution consisting of one or multiple steps.
              This element can be linked to a specific input element by setting <code>to</code> attribute.
              It then appears only as side note to this input element and not in the position of the text where it is placed itself.
              If the <code>to</code> attribute is not set, then this element appears as a collapsable box exactly where it is placed in the text.
              </xs:documentation>
        </xs:annotation>
        <xs:sequence>
            <xs:element minOccurs="0" maxOccurs="1" name="title" type="Title"/>
            <xs:element minOccurs="1" maxOccurs="unbounded" name="step" type="BlockContent">
                <xs:annotation>
                    <xs:documentation>A step of a solution hint.</xs:documentation>
                </xs:annotation>
            </xs:element>          
        </xs:sequence>
        <xs:attributeGroup ref="CommonContentElementAttributes"/>
        <xs:attribute name="to" type="xs:Name" use="optional">
            <xs:annotation>
                <xs:documentation>When set, links this solution hint to the input element with the given name.</xs:documentation>
            </xs:annotation>
        </xs:attribute>
    </xs:complexType>
    
    <xs:complexType name="BooleanGroup">
	    	<xs:annotation>
	    		<xs:documentation>A block element whose purpose is to group together boolean
	    		input fields into single or multiple choice questions. It affects all input elements with boolean values inside this element.</xs:documentation>
	    	</xs:annotation>
        <xs:complexContent>
            <xs:extension base="BlockContent">
                <xs:attribute name="minselection" use="optional" default="1" type="xs:nonNegativeInteger">
                    <xs:annotation>
                        <xs:documentation>Sets the minimum number of boolean inputs the user has to select in this boolean group.</xs:documentation>
                    </xs:annotation>
                </xs:attribute>
                <xs:attribute name="maxselection" use="optional" type="xs:nonNegativeInteger">
                    <xs:annotation>
                        <xs:documentation>Sets a maximum number of boolean inputs the user can select in this boolean group.</xs:documentation>
                    </xs:annotation>
                </xs:attribute>
                <xs:attribute name="maxcredits" use="optional" type="xs:nonNegativeInteger">
                    <xs:annotation>
                        <xs:documentation>Sets a total maximal number of credit points the user can earn in this boolean group.</xs:documentation>
                    </xs:annotation>
                </xs:attribute>
                <xs:attribute name="maxpenalty" use="optional" type="xs:nonNegativeInteger">
                    <xs:annotation>
                        <xs:documentation>Sets a total maximal number of credit points the user can get deducted in this boolean group.</xs:documentation>
                    </xs:annotation>
                </xs:attribute>
                <xs:attribute name="uncheck" use="optional" type="xs:boolean" default="false">
                    <xs:annotation>
                        <xs:documentation>Allows the user to uncheck fields after they have been checked.</xs:documentation>
                    </xs:annotation>
                </xs:attribute>
            </xs:extension>
        </xs:complexContent>
    </xs:complexType>
</xs:schema>
