<?xml version="1.0" encoding="utf-8"?>
<?xml-stylesheet type="text/xsl" href="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">
  
    <!-- ### 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="Settings"/>
            <xs:sequence>
                <xs:element name="variant" minOccurs="1" maxOccurs="unbounded" type="Variant">
                  <xs:unique name="Name">
                      <xs:selector xpath=".//*"/>
                      <xs:field xpath="@name"/>
                  </xs:unique>
                  
                  <xs:keyref name="Ref" refer="Name">
                      <xs:selector xpath=".//edml:ref"/>
                      <xs:field xpath="@to"/>
                  </xs:keyref>
                  
                  <xs:unique name="InputElementName">
                      <xs:selector xpath=".//edml:input"/>
                      <xs:field xpath="@name"/>
                  </xs:unique>
                  
                  <xs:keyref name="SolutionHint" refer="InputElementName">
                      <xs:selector xpath="edml:solutionhint"/>
                      <xs:field xpath="@to"/>
                  </xs:keyref>
                </xs:element>
            </xs:sequence>
        </xs:sequence>
    </xs:complexType>
    
    <xs:complexType name="Settings">
        <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:all>
    </xs:complexType>
    
    <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="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: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>All labels are a dash.</xs:documentation></xs:annotation></xs:enumeration>
            <xs:enumeration value="dot"><xs:annotation><xs:documentation>All labels are a dot.</xs:documentation></xs:annotation></xs:enumeration>
            <xs:enumeration value="dash"><xs:annotation><xs:documentation>All labels are a dash.</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:complexType>
    
    <xs:complexType name="Title">
        <xs:annotation>
            <xs:documentation>Title of either a course variant, a page, a container or a panel.</xs:documentation>
        </xs:annotation>
        <xs:simpleContent>
            <xs:extension base="xs:string">
                <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:extension>
        </xs:simpleContent>
    </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: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 the automatically generated label of the navigation items in this list.
                </xs:documentation>
            </xs:annotation>
        </xs:attribute>
    </xs:complexType>
    
    <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 name="page" type="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:complexType>
    
    <xs:element name="course" type="Course">
        <xs:key name="VariantLanguage">
            <xs:selector xpath="edml:variant"/>
            <xs:field xpath="@lang"/>
        </xs:key>
    </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 generators defined in this element is called to generate a new parameter value.
    		</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[<exercisebox>
  <parameter>
    <identifier>a</identifier>
    <range step="1">
    	<start>1</start>
    	<end>5</end>
    </range>
    <value>20</value>
  </parameter>
  <p>Value of the parameter is: <m><calulcate>a</calulcate></m>.</p> 
</exercisebox>]]></edmldoc:code>
					</edmldoc:example>
    		</xs:appinfo>
    	</xs:annotation>
    	<xs:sequence>
    		<xs:element minOccurs="1" maxOccurs="1" name="identifier" type="ParameterIdentifier"/>
    		<xs:sequence minOccurs="1" maxOccurs="unbounded">
    			<xs:group ref="ParameterGeneratorGroup"/>
  			</xs:sequence>
    	</xs:sequence>
    </xs:complexType>
    
    <xs:complexType name="ParameterIdentifier">
    	<xs:annotation>
    		<xs:documentation>Defines the identifier by which a parameter can be referred to in <code>calculate</code> elements and input elements.</xs:documentation>
    	</xs:annotation>
    	<xs:simpleContent>
    		<xs:extension base="xs:NMTOKEN"/>
    	</xs:simpleContent>
    </xs:complexType>
    
    <xs:group name="ParameterGeneratorGroup">
    	<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 or range among all specified ranges and values 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.</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.</xs:documentation>
    	</xs:annotation>
    	<xs:sequence>
    		<xs:element name="start" type="ParameterRangeStart"/>
    		<xs:element name="end" type="ParameterRangeEnd"/>
    	</xs:sequence>
    	<xs:attributeGroup ref="ParameterWeightAttribute"/>
    	<xs:attribute name="step" use="optional" type="PositiveDecimal">
    		<xs:annotation>
    			<xs:documentation>
    				If this optional attribute is set, then the range consists only of the numbers that are inside the bounds defined by the start
    				and end attributes and whose absolute difference from the start value is a multiple of the step value.
    				If this attribute is not set, then the range consists of all rational numbers inside the bounds defined by the start
    				and end attributes.
    			</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:sequence minOccurs="0" maxOccurs="unbounded">
            		<xs:element name="parameter" minOccurs="0" maxOccurs="unbounded" type="Parameter"/>
                <xs:choice>
                    <xs:group ref="BlockGroup"/>
                </xs:choice>
            </xs:sequence>
        </xs:sequence>
        <xs:attributeGroup ref="CommonContainerAttributes"/>
    </xs:complexType>
	
	<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: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="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="DifficultyAttribute"/>
	</xs:complexType>
    
    <xs:complexType name="OptionalView">
        <xs:annotation>
            <xs:documentation>
              A view that wraps a sequence of boxes 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="BoxGroup"/>
        	</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 panel views and displays them in an accordion.
            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:sequence>
            	<xs:element name="title" type="Title" minOccurs="0" maxOccurs="1"/>
            	<xs:element name="panelview" type="TitledPanelView" minOccurs="1" maxOccurs="unbounded"/>
            </xs:sequence>
        </xs:sequence>
        <xs:attributeGroup ref="CommonContainerAttributes"/>
    </xs:complexType>
    
    <xs:complexType name="TabView">
        <xs:annotation>
            <xs:documentation>
            	A view that wraps a sequence of panel views and displays one of them in a tab pane.
            	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:sequence>
            	<xs:element name="title" type="Title" minOccurs="0" maxOccurs="1"/>
            	<xs:element name="panelview" type="TitledPanelView" minOccurs="1" maxOccurs="unbounded"/>
            </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 panel views and always only shows a specified amount of them at once.
				The user can see how many panel views there are and can go through them.
			</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:sequence>
				<xs:element name="title" type="Title" minOccurs="0" maxOccurs="1"/>
				<xs:element name="panelview" type="PanelView" minOccurs="1" maxOccurs="unbounded"/>
			</xs:sequence>
		</xs:sequence>
		<xs:attributeGroup ref="CommonContainerAttributes"/>
		<xs:attribute name="show" type="xs:positiveInteger" default="1">
			<xs:annotation>
				<xs:documentation>Amount of panel views that are shown simultaneously.</xs:documentation>				
			</xs:annotation>
		</xs:attribute>
		<xs:attribute name="shuffle" type="xs:boolean" default="true">
			<xs:annotation>
				<xs:documentation>Whether or not the panel views should be shuffled randomly each time the page is reloaded.</xs:documentation>				
			</xs:annotation>
		</xs:attribute>
		<xs:attribute name="direction" type="Direction" default="horizontal">
			<xs:annotation>
				<xs:documentation>Specifies the way in which the active panel views should be displayed.</xs:documentation>				
			</xs:annotation>
		</xs:attribute>
		<xs:attribute name="loop" type="xs:boolean" default="false">
			<xs:annotation>
				<xs:documentation>
					Wether or not the sequence of panel 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 attribut is set, the view always automatically goes to the next panel after the given number of seconds.
				</xs:documentation>				
			</xs:annotation>
		</xs:attribute>
	</xs:complexType>
	
	<xs:simpleType name="Direction">
		<xs:annotation>
			<xs:documentation>
				Direction of the flow of elements, either vertical or horizontal.
			</xs:documentation>
		</xs:annotation>
		<xs:restriction base="xs:NMTOKEN">
			<xs:enumeration value="horizontal"><xs:annotation><xs:documentation>Horizontal direction.</xs:documentation></xs:annotation></xs:enumeration>
			<xs:enumeration value="vertical"><xs:annotation><xs:documentation>Vertical direction.</xs:documentation></xs:annotation></xs:enumeration>
		</xs:restriction>
	</xs:simpleType>
    
    <xs:complexType name="PanelView">
        <xs:annotation>
        	<xs:documentation>A panel view with an optional title that wraps a sequence of boxes.</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="BoxGroup"/>
            </xs:sequence>
        </xs:sequence>
    </xs:complexType>
	
	<xs:complexType name="TitledPanelView">
		<xs:annotation>
			<xs:documentation>A panel view with an mandatory title that wraps a sequence of boxes.</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="BoxGroup"/>
			</xs:sequence>
		</xs:sequence>
	</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 convention is a determination that is valid for the whole course or a part of the course.
              	</xs:documentation>
             	</xs:annotation>
            </xs:element>
        </xs:choice>
    </xs:group>
    
    <xs:group name="ViewGroup">
        <xs:choice>
            <xs:element name="optionalview" type="OptionalView"/>
            <xs:element name="accordionview" type="AccordionView"/>
            <xs:element name="tabview" type="TabView"/>
        	<xs:element name="poolview" type="PoolView"/>
        </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="b" type="InlineContent">
              <xs:annotation><xs:documentation>Inline element for bold text.</xs:documentation></xs:annotation>
            </xs:element>
            <xs:element name="i" type="InlineContent">
              <xs:annotation><xs:documentation>Inline element for italic text.</xs:documentation></xs:annotation>
            </xs:element>
            <xs:element name="u" type="InlineContent">
              <xs:annotation><xs:documentation>Inline element for underlined text.</xs:documentation></xs:annotation>
            </xs:element>
            <xs:element name="sup" type="InlineContent">
              <xs:annotation><xs:documentation>Inline element for superscript text.</xs:documentation></xs:annotation>
            </xs:element>
            <xs:element name="sub" type="InlineContent">
              <xs:annotation><xs:documentation>Inline element for subscript text.</xs:documentation></xs:annotation>
            </xs:element>
            <xs:element name="code" type="Code"/>
            <xs:element name="hint" type="InlineContent">
              <xs:annotation><xs:documentation>Inline element for text tagged as a hint.</xs:documentation></xs:annotation>
            </xs:element>
            <xs:element name="info" type="InlineContent">
              <xs:annotation><xs:documentation>Inline element for text tagged as an information.</xs:documentation></xs:annotation>
            </xs:element>
            <xs:element name="help" type="InlineContent">
              <xs:annotation><xs:documentation>Inline element for text tagged as a help.</xs:documentation></xs:annotation>
            </xs:element>
            <xs:element name="warning" type="InlineContent">
              <xs:annotation><xs:documentation>Inline element for text tagged as a warning.</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="MediaContent">
              <xs:annotation>
                <xs:documentation>
                  A picture consisting of either a raster graphic (a PNG file) or a vector graphic (an SVG file).
                </xs:documentation>
              </xs:annotation>
            </xs:element>
            <xs:element name="br" type="LineBreak"/>
        	<xs:element name="input" type="Input"/>
        	<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="equation" type="Equation"/>
            <xs:element name="video" type="MediaContent">
              <xs:annotation><xs:documentation>A video stored in a MP4 file.</xs:documentation></xs:annotation>
            </xs:element>
            <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="codeenvironment" type="CodeEnvironment"/>
            <xs:element name="blockquote" type="BlockQuote"/>
            <xs:element name="figureblock" type="FigureBlock"/>
            <xs:element name="solutionhint" type="SolutionHint"/>
            <xs:element name="inputblock" type="InputBlock"/>
            <xs:element name="accordion" type="Accordion"/>
            <xs:element name="tabset" type="TabSet"/>
        		<xs:element name="externmedia" type="ExternMedia"/>
        </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: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:complexType name="Equation">
        <xs:annotation>
            <xs:documentation>Block element displaying LaTeX content with MathJax in display mode, that is, (by default centered) in its own line.</xs:documentation>
        </xs:annotation>
        <xs:simpleContent>
            <xs:extension base="xs:string">
                <xs:attributeGroup ref="CommonContentElementAttributes"/>
                <xs:attribute name="align" type="Alignment" default="center">
                  <xs:annotation>
                    <xs:documentation>Horizontal alignment of this equation.</xs:documentation>
                  </xs:annotation>
                </xs:attribute>
            </xs:extension>
        </xs:simpleContent>
    </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: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: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="Attribution">
        <xs:annotation>
            <xs:documentation>Stores attribution information about a media object.</xs:documentation>
        </xs:annotation>
        <xs:sequence>
            <xs:element name="author" minOccurs="0" maxOccurs="unbounded" type="xs:string">
              <xs:annotation><xs:documentation>An author of a creation.</xs:documentation></xs:annotation>
            </xs:element>
            <xs:element name="date" minOccurs="0" maxOccurs="1" type="xs:string">
              <xs:annotation><xs:documentation>Stores information about the creation date of a work.</xs:documentation></xs:annotation>
            </xs:element>
            <xs:element name="info" minOccurs="0" maxOccurs="1" type="xs:string">
              <xs:annotation><xs:documentation>Stores additional information about a work.</xs:documentation></xs:annotation>
            </xs:element>
            <xs:element name="source" minOccurs="0" maxOccurs="1" type="xs:string">
              <xs:annotation><xs:documentation>Stores information about the origin of a work.</xs:documentation></xs:annotation>
            </xs:element>
        </xs:sequence>
        <xs:attribute name="license" type="xs:string" use="required">
            <xs:annotation>
                <xs:documentation>A short string referencing the license of this attribution, such as "CC BY SA 4.0".</xs:documentation>
            </xs:annotation>
        </xs:attribute>
    </xs:complexType>
	
	<xs:attributeGroup name="CommonMediaAttributes">
		<xs:attribute name="minwidth" type="xs:nonNegativeInteger" use="optional">
			<xs:annotation>
				<xs:documentation>Minimum width of this media object in pixels.</xs:documentation>
			</xs:annotation>
		</xs:attribute>
		<xs:attribute name="maxwidth" type="xs:positiveInteger" use="optional">
			<xs:annotation>
				<xs:documentation>Maximal width of this media object in pixels.</xs:documentation>
			</xs:annotation>
		</xs:attribute>
		<xs:attribute name="minheight" type="xs:nonNegativeInteger" use="optional">
			<xs:annotation>
				<xs:documentation>Minimum height of this media object in pixels.</xs:documentation>
			</xs:annotation>
		</xs:attribute>
		<xs:attribute name="maxheight" type="xs:positiveInteger" use="optional">
			<xs:annotation>
				<xs:documentation>Maximal height of this media object in pixels.</xs:documentation>
			</xs:annotation>
		</xs:attribute>
	</xs:attributeGroup>
	
    <xs:complexType name="MediaContent">
        <xs:sequence>
            <xs:element name="attribution" type="Attribution" 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 file of this media object relative to the current document.</xs:documentation>
            </xs:annotation>
        </xs:attribute>
    	<xs:attributeGroup ref="CommonMediaAttributes"/>
    </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">
        <xs:annotation>
            <xs:documentation>Acts as an anchor that can be used to reference to this place.</xs:documentation>
        </xs:annotation>
        <xs:attributeGroup ref="CommonContentElementAttributes"/>
    </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="xs:string">
            <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="xs:string" 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="xs:string">
            <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="xs:string">
            <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="xs:string">
            <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>Controls the space between flex items.</xs:documentation>
            </xs:annotation>
        </xs:attribute>
        <xs:attribute name="columngap" type="xs:string">
            <xs:annotation>
                <xs:documentation>Controls the space between flex items.</xs:documentation>
            </xs:annotation>
        </xs:attribute>        
    </xs:attributeGroup>
    
    <xs:attributeGroup name="FlexItemAttributes">
        <xs:attribute name="order" type="xs:integer">
            <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:string" default="auto">
            <xs:annotation>
                <xs:documentation>Initial main size of this flex item.</xs:documentation>
            </xs:annotation>
        </xs:attribute>
        <xs:attribute name="alignself" type="xs:string">
            <xs:annotation>
                <xs:documentation>Overrides this flex item's align-items value.</xs:documentation>
            </xs:annotation>
        </xs:attribute>
    </xs:attributeGroup>

    <xs:complexType name="List">
        <xs:annotation>
            <xs:documentation>
                A list, can be either numbered or unnumbered depending on the used format.
            </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: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:complexType name="Input">
    	<xs:annotation>
    		<xs:documentation>
    			Input field in which the user can input a value that is checked against the specified solution.
    		</xs:documentation>
    	</xs:annotation>
    	<xs:sequence>
	    	<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:sequence>
    	<xs:attributeGroup ref="CommonContentElementAttributes"/>
    	<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:attribute name="width" type="xs:positiveInteger" use="optional">
				<xs:annotation>
					<xs:documentation>Desired width of the input field in CSS em units.</xs:documentation>
				</xs:annotation>
			</xs:attribute>
    </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="width" use="optional" type="xs:string">
  		<xs:annotation>
  			<xs:documentation>Controls the width of the input field, must be valid CSS length 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="ToleranceAttributes">
		<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="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.</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:attributeGroup ref="ToleranceAttributes"/>
		<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="checklive" type="xs:string" default="">
  		<xs:annotation>
  			<xs:documentation>Space-separated list of settings that are checked before the user presses the "check" button.</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:attributeGroup ref="ToleranceAttributes"/>
	</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:annotation>
		</xs:attribute>
		<xs:attribute name="checklive" type="xs:string" default="">
  		<xs:annotation>
  			<xs:documentation>Space-separated list of settings that are checked before the user presses the "check" button.</xs:documentation>
  		</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="checklive" type="xs:string" default="minsize maxsize">
  		<xs:annotation>
  			<xs:documentation>Space-separated list of settings that are checked before the user presses the "check" button.</xs:documentation>
  		</xs:annotation>
  	</xs:attribute>
	
	</xs:attributeGroup>
	
	<xs:attributeGroup name="VectorInputAttributes">
		<xs:attribute name="minsize" type="xs:nonNegativeInteger">
			<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:nonNegativeInteger">
			<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:nonNegativeInteger">
			<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:attributeGroup>

	<xs:attributeGroup name="MatrixInputAttributes">
		<xs:attribute name="minrows" type="xs:nonNegativeInteger">
			<xs:annotation>
  			<xs:documentation>Minimum number of rows in this matrix.</xs:documentation>
  		</xs:annotation>
		</xs:attribute>
		<xs:attribute name="maxrows" use="optional" type="xs:nonNegativeInteger">
			<xs:annotation>
  			<xs:documentation>Maximum number of rows in this matrix.</xs:documentation>
  		</xs:annotation>
		</xs:attribute>
		<xs:attribute name="defaultrows" use="optional" type="xs:nonNegativeInteger">
			<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:nonNegativeInteger">
			<xs:annotation>
  			<xs:documentation>Minimum number of columns in this matrix.</xs:documentation>
  		</xs:annotation>
		</xs:attribute>
		<xs:attribute name="maxcolumns" use="optional" type="xs:nonNegativeInteger">
			<xs:annotation>
  			<xs:documentation>Maximum number of columns in this matrix.</xs:documentation>
  		</xs:annotation>
		</xs:attribute>
		<xs:attribute name="defaultcolumns" use="optional" type="xs:nonNegativeInteger">
			<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:attributeGroup>
	
	<xs:attributeGroup name="IntervalInputAttributes">
		<xs:attribute name="fixclosure" type="IntervalEndOption" default="none">
			<xs:annotation>
				<xs:documentation>
					Specifies the ends of the interval where the endpoint type, that is, if this endpoint should be included in the interval or not, should be taken from the "closed" attribute.
					The user can not edit these endpoint types anymore.
				</xs:documentation>
			</xs:annotation>
		</xs:attribute>
		<xs:attribute name="flipped" type="xs:boolean" default="false">
  		<xs:annotation>
  			<xs:documentation>
  				If set to true, this flips the lower and upper bounds of the interval for the user during the process of entering an interval.
  			</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="checklive" type="xs:string" default="useonly usenot prefixes">
  		<xs:annotation>
  			<xs:documentation>Space-separated list of settings that are checked before the user presses the "check" button.</xs:documentation>
  		</xs:annotation>
  	</xs:attribute>
	</xs:attributeGroup>
	
	<xs:attributeGroup name="MolecularInputAttributes"/>
	
	<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="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>
	
	
	<!-- 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),
			- flipped (nur vorher)
		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">
		<xs:annotation>
			<xs:documentation>
				An option of a choice input value.
			</xs:documentation>
		</xs:annotation>
		<xs:simpleContent>
			<xs:extension base="xs:string">
				<xs:attributeGroup ref="CommonInputValueAttributes"/>
				<xs:attribute name="correct" type="xs:boolean" default="false" use="optional">
					<xs:annotation>
						<xs:documentation>Wether or not this option is a correct solution of the input field.</xs:documentation>
					</xs:annotation>
				</xs:attribute>
			</xs:extension>
		</xs:simpleContent>		
	</xs:complexType>
	
	<xs:complexType name="NumberInputValue">
		<xs:annotation>
			<xs:documentation>
				Input value representing a number. The correct number can be either given as a decimal 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.
			</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="1" type="NumberInputValue"/>
			<xs:element name="number" minOccurs="0" maxOccurs="1" 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="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="interval"><xs:annotation><xs:documentation>Interval elements.</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:sequence minOccurs="1" maxOccurs="unbounded">
				<xs:element name="number" type="NumberInputValue"/>
			</xs:sequence>
			<xs:sequence minOccurs="1" maxOccurs="unbounded">
				<xs:element name="expression" type="ExpressionInputValue"/>
			</xs:sequence>
		</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, such as "[[1,2],[3,4]]", of numbers or expressions.
			</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:choice>
	</xs:complexType>
	
	<xs:simpleType name="IntervalEndOption">
		<xs:annotation>
			<xs:documentation>Specifies a set of ends of an interval.</xs:documentation>
		</xs:annotation>
		<xs:restriction base="xs:NMTOKEN">
			<xs:enumeration value="left"><xs:annotation><xs:documentation>Left end of an interval.</xs:documentation></xs:annotation></xs:enumeration>
			<xs:enumeration value="right"><xs:annotation><xs:documentation>Right end of an interval.</xs:documentation></xs:annotation></xs:enumeration>
			<xs:enumeration value="both"><xs:annotation><xs:documentation>Both ends of an interval.</xs:documentation></xs:annotation></xs:enumeration>
			<xs:enumeration value="none"><xs:annotation><xs:documentation>No ends of an interval.</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="closed" type="IntervalEndOption" use="required">
			<xs:annotation>
				<xs:documentation>
					Specifies at which end points the interval should be closed for a correct solution, that is, which of its endpoints should be included in 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 "H_2O".
			</xs:documentation>
		</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="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="InputBlock">
        <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 input block.</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 input block.</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 input block.</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 input block.</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>
