<?xml version="1.0" encoding="utf-8"?>
<?xml-stylesheet type="text/xsl" href="documentation/transform-xsd.xsl"?>
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema"
	xmlns="https://edml.mint-kolleg.kit.edu"
	xmlns:edml="https://edml.mint-kolleg.kit.edu"
	xmlns:edmldoc="https://edml.mint-kolleg.kit.edu/documentation"
	xmlns:sch="http://purl.oclc.org/dsdl/schematron"
	targetNamespace="https://edml.mint-kolleg.kit.edu"
	elementFormDefault="qualified">
	<xs:import namespace="http://www.w3.org/XML/1998/namespace" schemaLocation="http://www.w3.org/2001/xml.xsd"/>

	<xs:annotation>
		<xs:appinfo>
			<sch:ns prefix="edml" uri="https://edml.mint-kolleg.kit.edu"/>
		</xs:appinfo>
	</xs:annotation>

	<!-- ### 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="0" type="CourseSettings"/>
			<xs:sequence>
				<xs:element ref="variant" minOccurs="1" maxOccurs="unbounded"/>
			</xs:sequence>
		</xs:sequence>
		<xs:attributeGroup ref="XmlAttributes"/>
		<xs:attribute name="edmlversion" type="xs:NMTOKEN" use="required" fixed="0.5.0">
			<xs:annotation>
				<xs:documentation xml:lang="en">
					Version of the education markup language that this course is written in. Must match the language
					version of the used schema.
				</xs:documentation>
				<xs:documentation xml:lang="de">
					Version der edML Sprache in welcher der Kurs geschrieben ist. Muss genau der Version des verwendeten
					Schemas entsprechen.
				</xs:documentation>
			</xs:annotation>
		</xs:attribute>
	</xs:complexType>

	<xs:complexType name="CourseSettings">
		<xs:annotation>
			<xs:documentation>Contains the course settings. Some of these settings can be overwritten for a specific
				course variant by using the settings child element of the corresponding variant element.
			</xs:documentation>
		</xs:annotation>
		<xs:all>
			<xs:element name="inputmodels" minOccurs="0" maxOccurs="1" type="InputModels"/>
			<xs:element name="containers" minOccurs="0" type="ContainerSettings"/>
			<xs:element name="styles" minOccurs="0" maxOccurs="1" type="Styles"/>
			<xs:element name="navsettings" minOccurs="0" type="NavigationSettings"/>
		</xs:all>
		<xs:attribute name="defaultvariant" type="xs:language">
			<xs:annotation>
				<xs:documentation xml:lang="en">
					Sets the default variant of the course by specifying its language.
				</xs:documentation>
				<xs:documentation xml:lang="de">
					Gibt die Sprache der Variante an, welche die Standardvariante sein soll.
				</xs:documentation>
			</xs:annotation>
		</xs:attribute>
	</xs:complexType>

	<xs:complexType name="NavigationSettings">
		<xs:annotation>
			<xs:documentation>Contains settings related to the navigation of the course including the navigation items
				and navigation lists.
			</xs:documentation>
		</xs:annotation>
		<xs:attribute name="numbered" type="xs:boolean" default="true">
			<xs:annotation>
				<xs:documentation xml:lang="en">
					Whether navigation items should be numbered by default. This affects all navigation
					items on which no numbered attribute is set.
				</xs:documentation>
				<xs:documentation xml:lang="de">
					Gibt an, ob Navigationseinträge standardmäßig nummeriert werden sollen. Das betrifft alle
					Navigationseinträge, bei welchen kein numbered Attribute gesetzt ist.
				</xs:documentation>
			</xs:annotation>
		</xs:attribute>
		<xs:attribute name="format" type="LabelFormat" default="arabic">
			<xs:annotation>
				<xs:documentation>Default format used in the generation of labels of navigation items. This affects all
					navigation lists on which no format attribute is set.</xs:documentation>
			</xs:annotation>
		</xs:attribute>
		<xs:attribute name="separator" type="xs:string" default=".">
			<xs:annotation>
				<xs:documentation>Default separator used in the automatically generated label of navigation items.
					This affects all navigation lists on which no separator attribute is set.</xs:documentation>
			</xs:annotation>
		</xs:attribute>
		<xs:attribute name="lastsep" type="xs:boolean" default="false">
			<xs:annotation>
				<xs:documentation>Whether the last separator should be shown by default in the automatically generated
					label of navigation items. This affects all navigation lists on which no lastsep attribute is set.
				</xs:documentation>
			</xs:annotation>
		</xs:attribute>
	</xs:complexType>

	<xs:group name="BoxSettingsGroup">
		<xs:choice>
			<xs:element name="applicationbox" type="BoxSettings"/>
			<xs:element name="conventionbox" type="BoxSettings"/>
			<xs:element name="definitionbox" type="BoxSettings"/>
			<xs:element name="examplebox" type="BoxSettings"/>
			<xs:element name="exercisebox" type="BoxSettings"/>
			<xs:element name="experimentbox" type="BoxSettings"/>
			<xs:element name="formulabox" type="BoxSettings"/>
			<xs:element name="helpbox" type="BoxSettings"/>
			<xs:element name="hintbox" type="BoxSettings"/>
			<xs:element name="infobox" type="BoxSettings"/>
			<xs:element name="proofbox" type="BoxSettings"/>
			<xs:element name="remarkbox" type="BoxSettings"/>
			<xs:element name="textbox" type="BoxSettings"/>
			<xs:element name="theorembox" type="BoxSettings"/>
		</xs:choice>
	</xs:group>

	<xs:complexType name="ContainerSettings">
		<xs:annotation>
			<xs:documentation>Contains the settings for containers of the course.</xs:documentation>
		</xs:annotation>
		<xs:sequence minOccurs="0" maxOccurs="unbounded">
			<xs:group ref="BoxSettingsGroup"/>
		</xs:sequence>
	</xs:complexType>

	<xs:complexType name="BoxSettings">
		<xs:annotation>
			<xs:documentation>
				This settings element can be used to define default settings for all boxes in the course or course
				variant with the same tag name as this element. Most of these settings can be overwritten in individual
				boxes.
			</xs:documentation>
		</xs:annotation>
		<xs:attribute name="withsubtype" type="xs:Name">
			<xs:annotation>
				<xs:documentation>
					When this attribute is set, only the matching boxes with the specified subtype are affected by the
					settings defined in this element.
				</xs:documentation>
			</xs:annotation>
		</xs:attribute>
		<xs:attribute name="descriptor" type="xs:string">
			<xs:annotation>
				<xs:documentation>
					Changes the default descriptor of the affected boxes.
				</xs:documentation>
			</xs:annotation>
		</xs:attribute>
		<xs:attribute name="numbered" type="xs:boolean">
			<xs:annotation>
				<xs:documentation>
					Changes whether the affected boxes are numbered by default.
				</xs:documentation>
			</xs:annotation>
		</xs:attribute>
		<xs:anyAttribute processContents="lax">
			<xs:annotation>
				<xs:documentation>
					Other attributes are allowed here for reasons of extensibility. The processing application can
					decide what to do with them.
				</xs:documentation>
			</xs:annotation>
		</xs:anyAttribute>
	</xs:complexType>

	<xs:complexType name="Styles">
		<xs:annotation>
			<xs:documentation>Contains one or more style assignments to elements with specified roles. Note that style
			settings are only possible when the Content-Security-Policy (CSP) settings of the web server allows this.
			</xs:documentation>
			<xs:appinfo>
				<edmldoc:example><![CDATA[<styles>
	<style role="base">
		color: blue;
	</style>
	<style role="acid">
		color: red;
	</style>
</styles>]]></edmldoc:example>
			</xs:appinfo>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="style" type="Style" minOccurs="1" maxOccurs="unbounded"/>
		</xs:sequence>
	</xs:complexType>

	<xs:complexType name="Style">
		<xs:annotation>
			<xs:documentation>Assigns a list of style declarations to all elements with a specified role. Note that
				style settings are only possible when the Content-Security-Policy (CSP) settings of the web server
				allows this.</xs:documentation>
			<xs:appinfo>
				<edmldoc:example><![CDATA[<style role="term">
	font-weight: bold;
</style>]]></edmldoc:example>
			</xs:appinfo>
		</xs:annotation>
		<xs:simpleContent>
			<xs:extension base="StyleDeclarations">
				<xs:attribute name="role" use="required" type="xs:Name">
					<xs:annotation>
						<xs:documentation>The role which an element must have in order for the style setting specified in this element to apply.</xs:documentation>
					</xs:annotation>
				</xs:attribute>
			</xs:extension>
		</xs:simpleContent>
	</xs:complexType>

	<xs:simpleType name="StyleDeclarations">
		<xs:annotation>
			<xs:documentation>A string representing zero or more style declarations, each one terminated by a semicolon.
				A style declaration consists of a named property followed by colon followed by the property value.
				For example, "color: blue;" or "color: red; font-weight: bold;" are valid style declarations.
			</xs:documentation>
		</xs:annotation>
		<xs:restriction base="xs:string">
			<xs:pattern value="(\s*[a-z]([a-z]|(-[a-z]))*\s*:\s*[^;]+;\s*)*"/>
		</xs:restriction>
	</xs:simpleType>

	<xs:complexType name="InputModels">
		<xs:annotation>
			<xs:documentation>Defines the settings for input elements in this course.</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="inputmodel" minOccurs="0" maxOccurs="unbounded" type="InputModel"/>
		</xs:sequence>
	</xs:complexType>

	<xs:complexType name="InputModel">
		<xs:annotation>
			<xs:documentation>A group of settings for input elements that can be enabled by using the <code>model</code> attribute on input elements.
				If the <code>name</code> attribute is not set, this input model describes the default input model.</xs:documentation>
		</xs:annotation>
		<xs:all>
			<xs:element name="string" minOccurs="0" maxOccurs="1" type="StringInputModel"/>
			<xs:element name="order" minOccurs="0" maxOccurs="1" type="OrderInputModel"/>
			<xs:element name="matching" minOccurs="0" maxOccurs="1" type="MatchingInputModel"/>
			<xs:element name="boolean" minOccurs="0" maxOccurs="1" type="BooleanInputModel"/>
			<xs:element name="choice" minOccurs="0" maxOccurs="1" type="ChoiceInputModel"/>
			<xs:element name="number" minOccurs="0" maxOccurs="1" type="NumberInputModel"/>
			<xs:element name="exponential" minOccurs="0" maxOccurs="1" type="ExponentialInputModel"/>
			<xs:element name="expression" minOccurs="0" maxOccurs="1" type="ExpressionInputModel"/>
			<xs:element name="set" minOccurs="0" maxOccurs="1" type="SetInputModel"/>
			<xs:element name="vector" minOccurs="0" maxOccurs="1" type="VectorInputModel"/>
			<xs:element name="matrix" minOccurs="0" maxOccurs="1" type="MatrixInputModel"/>
			<xs:element name="interval" minOccurs="0" maxOccurs="1" type="IntervalInputModel"/>
			<xs:element name="linearspan" minOccurs="0" maxOccurs="1" type="LinearSpanInputModel"/>
			<xs:element name="affinespace" minOccurs="0" maxOccurs="1" type="AffineSpaceInputModel"/>
			<xs:element name="unit" minOccurs="0" maxOccurs="1" type="UnitInputModel"/>
			<xs:element name="quantity" minOccurs="0" maxOccurs="1" type="QuantityInputModel"/>
			<xs:element name="molecular" minOccurs="0" maxOccurs="1" type="MolecularInputModel"/>
			<xs:element name="reaction" minOccurs="0" maxOccurs="1" type="ReactionInputModel"/>
			<xs:element name="sourcecode" minOccurs="0" maxOccurs="1" type="SourceCodeInputModel"/>
		</xs:all>
		<xs:attribute name="name" type="xs:Name" use="optional">
			<xs:annotation>
				<xs:documentation>Name of this input model. If this is not set, this input model describes the default input model.</xs:documentation>
			</xs:annotation>
		</xs:attribute>
	</xs:complexType>

	<xs:simpleType name="LabelFormat">
		<xs:annotation>
			<xs:documentation>A format for the automatic generation of labels.</xs:documentation>
		</xs:annotation>
		<xs:restriction base="xs:NMTOKEN">
			<xs:enumeration value="none">
				<xs:annotation>
					<xs:documentation>No labels.</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="arabic">
				<xs:annotation>
					<xs:documentation>1,2,3,4,5...</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="roman">
				<xs:annotation>
					<xs:documentation>i,ii,iii,iv,v...</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="Roman">
				<xs:annotation>
					<xs:documentation>I,II,III,IV,V...</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="letter">
				<xs:annotation>
					<xs:documentation>a,b,c,d,e,...</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="Letter">
				<xs:annotation>
					<xs:documentation>A,B,C,D,E,...</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="greek">
				<xs:annotation>
					<xs:documentation>α,β,γ,δ,ε,...</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="bullet">
				<xs:annotation>
					<xs:documentation>Use bullet points as labels.</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="dot">
				<xs:annotation>
					<xs:documentation>Use dots as labels.</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="dash">
				<xs:annotation>
					<xs:documentation>Use dashed as labels.</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
		</xs:restriction>
	</xs:simpleType>

	<xs:complexType name="Variant">
		<xs:annotation>
			<xs:documentation>A variant of the course for a specified language.</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="title" type="Title"/>
			<xs:element name="settings" minOccurs="0" type="VariantSettings"/>
			<xs:element name="navigation" type="Navigation"/>
			<xs:element name="tests" minOccurs="0" type="Tests"/>
			<xs:element name="pages" type="Pages"/>
		</xs:sequence>
		<xs:attribute name="lang" use="required" type="xs:language">
			<xs:annotation>
				<xs:documentation xml:lang="en">
					Language of this course variant according to RFC 5646, must be unique among all course variants in
					this course.
				</xs:documentation>
				<xs:documentation xml:lang="de">
					Sprache dieser Kursvariante. Muss im Format nach RFC 5646 angegeben werden. Muss eindeutig unter
					allen Kursvarianten im Kurs sein.
				</xs:documentation>
			</xs:annotation>
		</xs:attribute>
		<xs:attribute name="radixpoint" default="auto">
			<xs:annotation>
				<xs:documentation>The radix point is the symbol used to separate the integer part from the fractional part of a number in a number input field. When this is set to the special
				value auto, the application will automatically select a radix point based on the language of this course variant.</xs:documentation>
			</xs:annotation>
			<xs:simpleType>
				<xs:union memberTypes="RadixPointSymbol Auto"/>
			</xs:simpleType>
		</xs:attribute>
		<xs:attributeGroup ref="XmlAttributes"/>
	</xs:complexType>

	<xs:complexType name="VariantSettings">
		<xs:annotation>
			<xs:documentation>Contains the settings specific to a course variant. These settings will overwrite the
				settings defined in the course element.</xs:documentation>
		</xs:annotation>
		<xs:all>
			<xs:element name="containers" minOccurs="0" type="ContainerSettings"/>
			<xs:element name="styles" minOccurs="0" type="Styles"/>
		</xs:all>
	</xs:complexType>

	<xs:simpleType name="RadixPointSymbol">
		<xs:annotation>
			<xs:documentation>Symbol used to separate the integer part from the fractional part of a number written in a standard positional number system.</xs:documentation>
		</xs:annotation>
		<xs:restriction base="xs:NMTOKENS">
			<xs:enumeration value="dot"><xs:annotation><xs:documentation>Dot (.)</xs:documentation></xs:annotation></xs:enumeration>
			<xs:enumeration value="comma"><xs:annotation><xs:documentation>Comma (,)</xs:documentation></xs:annotation></xs:enumeration>
		</xs:restriction>
	</xs:simpleType>

	<xs:complexType name="Title" mixed="true">
		<xs:annotation>
			<xs:documentation>
				Title of a course variant, a page, a container or another element of the course.
			</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:group ref="InlineGroup" minOccurs="0" maxOccurs="unbounded"/>
		</xs:sequence>
		<xs:attribute name="short" use="optional" type="xs:string">
			<xs:annotation>
				<xs:documentation xml:lang="en">
					Alternative short version of the title that can be used in situations where the full title can not
					be displayed.
				</xs:documentation>
				<xs:documentation xml:lang="de">
					Alternative Kurzversion des Titels. Dieser kann an Stellen angezeigt werden, an welchen der volle
					Titel aus Platzgründen nicht angezeigt werden kann.
				</xs:documentation>
			</xs:annotation>
		</xs:attribute>
	</xs:complexType>

	<xs:complexType name="Navigation">
		<xs:annotation>
			<xs:documentation>Contains all information about the navigation menu of a course variant.</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="navlist" type="NavigationList" minOccurs="1" maxOccurs="1"/>
		</xs:sequence>
		<xs:attributeGroup ref="IndentAttribute"/>
		<xs:attribute name="fullnumbering" type="xs:boolean" default="true">
			<xs:annotation>
				<xs:documentation>Whether or not the automatically generated labels of a navigation item should include the full numbering of all of its parent navigation
					items or only its number in the list of the children of its parent.</xs:documentation>
			</xs:annotation>
		</xs:attribute>
	</xs:complexType>

	<xs:complexType name="NavigationList">
		<xs:annotation>
			<xs:documentation>A list of one or more navigation items in the navigation menu.</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:choice maxOccurs="unbounded">
				<xs:element name="navitem" type="NavigationItem"/>
			</xs:choice>
		</xs:sequence>
		<xs:attribute name="format" type="LabelFormat">
			<xs:annotation>
				<xs:documentation>Format used for the automatically generated label of the navigation items in this
					list. If this attribute is not set, the format will be the default format specified in the
					<a href="#navsettings">navsettings element</a> of the course settings.</xs:documentation>
			</xs:annotation>
		</xs:attribute>
		<xs:attribute name="separator" type="xs:string">
			<xs:annotation>
				<xs:documentation>Separator used in the automatically generated label of the navigation items in this
					navigation list. If this attribute is not set, the separator will be the default separator specified
					in the <a href="#navsettings">navsettings element</a> of the course settings.</xs:documentation>
			</xs:annotation>
		</xs:attribute>
		<xs:attribute name="lastsep" type="xs:boolean">
			<xs:annotation>
				<xs:documentation>Whether the last separator should be shown in the automatically generated
					label of the navigation items in this navigation list. If this attribute is not set, the behavior
					will be the default behavior specified in the <a href="#navsettings">navsettings element</a> of the
					course settings.</xs:documentation>
			</xs:annotation>
		</xs:attribute>
		<xs:attributeGroup ref="XmlAttributes"/>
	</xs:complexType>

	<xs:complexType name="Tests">
		<xs:annotation>
			<xs:documentation>Contains all tests of a course variant.</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="test" type="Test" minOccurs="0" maxOccurs="unbounded"/>
		</xs:sequence>
	</xs:complexType>

	<xs:complexType name="Test">
		<xs:annotation>
			<xs:documentation>A Test is a part of the course with its own navigation structure that is modelled by the
				test items of the test. Each test item links to a page that must be worked through by the user in order
				to complete the test. The title of a test is displayed on top of the starting page of the test. On this
				page, the user gets displayed some information about the test and can click a button to start the test.
				The feedback element contains content that is shown to the user at the end of the test.
				During a test, no solutionhints are displayed.
			</xs:documentation>
			<xs:appinfo>
				<edmldoc:property name="credits" datatypes="int" examplevalue="3" nullable="false">
					<xs:annotation>
						<xs:documentation>
							Total number of credits the user has achieved in this test.
						</xs:documentation>
					</xs:annotation>
				</edmldoc:property>
				<edmldoc:property name="maxcredits" datatypes="int" examplevalue="10" nullable="false">
					<xs:annotation>
						<xs:documentation>
							Total maximum number of credits the user can achieve in this test.
						</xs:documentation>
					</xs:annotation>
				</edmldoc:property>
			</xs:appinfo>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="title" type="Title"/>
			<xs:element name="testlist" minOccurs="0" type="TestList"/>
			<xs:element name="feedback" minOccurs="0" type="Feedback"/>
		</xs:sequence>
		<xs:attribute name="name" type="xs:Name" use="required">
			<xs:annotation>
				<xs:documentation>Name of the tests. Must be unique among all names in this course variant.
				</xs:documentation>
			</xs:annotation>
		</xs:attribute>
		<xs:attribute name="tags" type="TokenList" use="optional" default="">
			<xs:annotation>
				<xs:documentation>Whitespace-separated list of tags that this test should have.</xs:documentation>
			</xs:annotation>
		</xs:attribute>
		<xs:attribute name="maxduration" type="TimeDuration">
			<xs:annotation>
				<xs:documentation>Maximal time duration (in the format hh:mm:ss) that the user may take to complete the
					test. If this attribute is not set, the user has unlimited time to complete the test.
				</xs:documentation>
			</xs:annotation>
		</xs:attribute>
		<xs:attribute name="fullscreen" type="xs:boolean" default="false">
			<xs:annotation>
				<xs:documentation>Whether or not the test should be presented in fullscreen mode to the user. If this
					is set to true, the browser will switch to fullscreen mode as long as the test is running.
				</xs:documentation>
			</xs:annotation>
		</xs:attribute>
		<xs:attribute name="maxattempts" type="xs:positiveInteger">
			<xs:annotation>
				<xs:documentation>Number of allowed attempts at this test. If this attribute
				is not present, the user can try the test as often as wanted.</xs:documentation>
			</xs:annotation>
		</xs:attribute>
		<xs:attribute name="navigation" type="TestNavigationOption" default="full">
			<xs:annotation>
				<xs:documentation>Navigation options for the user during the test.</xs:documentation>
			</xs:annotation>
		</xs:attribute>
		<xs:attribute name="feedback" use="optional" type="TestFeedbackMode" default="detailed">
			<xs:annotation>
				<xs:documentation>Controls the amount of feedback the user gets shown after completing the test.
				</xs:documentation>
			</xs:annotation>
		</xs:attribute>
	</xs:complexType>

	<xs:simpleType name="TestFeedbackMode">
		<xs:annotation>
			<xs:documentation>Feedback mode for a test in the course.</xs:documentation>
		</xs:annotation>
		<xs:restriction base="xs:NMTOKEN">
			<xs:enumeration value="detailed">
				<xs:annotation>
					<xs:documentation>User gets shown his or her input values, their correctness (yes or no) and the
						corresponding solution hints linked to the input fields (if they exit) as well as the number
						of achieved and achievable credit points for all input fields.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="results">
				<xs:annotation>
					<xs:documentation>User gets shown his or her input values, their correctness (yes or no) and the
						number of achieved and achievable credit points for all input fields, but not the solution
						hints linked to the corresponding input fields.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="credits">
				<xs:annotation>
					<xs:documentation>User gets show his or her input values and the number of achieved and achievable
						credit points for all input fields, but not the solution hints and not the correctness of the
						user input values.</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="totalcredits">
				<xs:annotation>
					<xs:documentation>User gets show only the total number of achieved credit points and the total
						number of achievable credit points in the test.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
		</xs:restriction>
	</xs:simpleType>

	<xs:simpleType name="TimeDuration">
		<xs:annotation>
			<xs:documentation>A time duration in the format hh:mm:ss. We do not allow milliseconds or time zones here.
			</xs:documentation>
		</xs:annotation>
		<xs:restriction base="xs:time">
			<xs:pattern value="[0-9][0-9]:[0-9][0-9]:[0-9][0-9]"/>
		</xs:restriction>
	</xs:simpleType>
	
	<xs:simpleType name="TestNavigationOption">
		<xs:annotation>
			<xs:documentation>Navigation options for the user in a test.</xs:documentation>
		</xs:annotation>
		<xs:restriction base="xs:NMTOKEN">
			<xs:enumeration value="full">
				<xs:annotation>
					<xs:documentation>Allow the user full navigation through the test items.</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="forward">
				<xs:annotation>
					<xs:documentation>Allow the user only navigation forward in the hierarchy of test items.</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="none">
				<xs:annotation>
					<xs:documentation>Allow no navigation by the user.</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
		</xs:restriction>
	</xs:simpleType>

	<xs:complexType name="TestList">
		<xs:annotation>
			<xs:documentation>A list of one or more test items.</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:choice maxOccurs="unbounded">
				<xs:element name="testitem" type="TestItem"/>
			</xs:choice>
		</xs:sequence>
	</xs:complexType>

	<xs:complexType name="TestItem">
		<xs:annotation>
			<xs:documentation>An item of a test that links to a specific page or another testitem, which the user must
				work through as part of the test. The ref element of a test item must point to a page or a testitem.
			</xs:documentation>
		</xs:annotation>
		<xs:choice>
			<xs:sequence>
				<xs:element name="ref" type="Ref"/>
				<xs:element name="testlist" type="TestList" minOccurs="0"/>
			</xs:sequence>
			<xs:sequence>
				<xs:element name="title" type="Title"/>
				<xs:element name="testlist" type="TestList"/>
			</xs:sequence>
		</xs:choice>
		<xs:attribute name="name" type="xs:Name" use="optional">
			<xs:annotation>
				<xs:documentation xml:lang="en">
					Name of this test item, must be unique among all names in this course variant.
				</xs:documentation>
				<xs:documentation xml:lang="de">
					Name des Testeintrages. Muss eindeutig unter allen Namen innerhalb der Kursvariante sein.
				</xs:documentation>
			</xs:annotation>
		</xs:attribute>
		<xs:attribute name="tags" type="TokenList" use="optional" default="">
			<xs:annotation>
				<xs:documentation>Whitespace-separated list of tags that this test item should have.</xs:documentation>
			</xs:annotation>
		</xs:attribute>
		<xs:attribute name="maxduration" type="TimeDuration">
			<xs:annotation>
				<xs:documentation>Maximal time duration (in the format hh:mm:ss) that the user may take to complete the
					test item. If this attribute is not set, the user has unlimited time to complete the test item.
				</xs:documentation>
			</xs:annotation>
		</xs:attribute>
	</xs:complexType>

	<xs:complexType name="Feedback">
		<xs:annotation>
			<xs:documentation>
				A feedback element describes content that is shown to the user at the end of a test.
			</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:group ref="BlockGroup" minOccurs="0" maxOccurs="unbounded"/>
		</xs:sequence>
	</xs:complexType>

	<xs:attributeGroup name="IndentAttribute">
		<xs:attribute name="indent" use="optional" default="auto">
			<xs:annotation>
				<xs:documentation>The horizontal length by which subitems should be indented as <a href="#Length">length value</a> or "auto",
				which means that the application will indent by a default length, which is guaranteed to be strictly greater than 0.</xs:documentation>
			</xs:annotation>
			<xs:simpleType>
				<xs:union memberTypes="Length Auto"/>
			</xs:simpleType>
		</xs:attribute>
	</xs:attributeGroup>

	<xs:complexType name="NavigationItem">
		<xs:annotation>
			<xs:documentation>
				An item in the navigation menu of the course variant. Navigation items with a ref or link child element
				provide a link to a page or another navigation item. Navigation items with a title as child element
				always link to the next subitem of the navigation item where a ref or link is specified.
			</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:choice>
				<xs:sequence>
					<xs:choice>
						<xs:element name="ref" type="Ref"/>
						<xs:element name="link" type="Link"/>
					</xs:choice>
					<xs:element name="navlist" type="NavigationList" minOccurs="0"/>
				</xs:sequence>
				<xs:sequence>
					<xs:element name="title" type="Title"/>
					<xs:element name="navlist" type="NavigationList"/>
				</xs:sequence>
			</xs:choice>
		</xs:sequence>
		<xs:attribute name="name" type="xs:Name" use="optional">
			<xs:annotation>
				<xs:documentation xml:lang="en">
					Name of this navigation item, must be unique among all names in this course variant.
				</xs:documentation>
				<xs:documentation xml:lang="de">
					Name des Navigationseintrages. Muss eindeutig unter allen Namen innerhalb der Kursvariante sein.
				</xs:documentation>
			</xs:annotation>
		</xs:attribute>
		<xs:attribute name="tags" type="TokenList" use="optional" default="">
			<xs:annotation>
				<xs:documentation>Whitespace-separated list of tags that this navigation item should have.</xs:documentation>
			</xs:annotation>
		</xs:attribute>
		<xs:attribute name="roles" type="NavigationItemRoleList" use="optional" default="">
			<xs:annotation>
				<xs:documentation>Whitespace-separated list of special roles that this navigation item should have. Allowed roles are "learnpath", "home", "impressum"
					and/or "privacy".</xs:documentation>
			</xs:annotation>
		</xs:attribute>
		<xs:attribute name="visible" type="xs:boolean" use="optional" default="true">
			<xs:annotation>
				<xs:documentation>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">
			<xs:annotation>
				<xs:documentation>Whether or not this navigation item should be numbered. If this attribute is not set,
					the value will be as specified in navsettings element in the course settings.</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:attribute name="showlearnpathinfo" type="xs:boolean" default="true">
			<xs:annotation>
				<xs:documentation>Whether to show an information text when this navigation item is a learnpath. This
				attribute only has an effect on navigation items with the "learnpath" role.</xs:documentation>
			</xs:annotation>
		</xs:attribute>
	</xs:complexType>

	<xs:simpleType name="NavigationItemRoleList">
		<xs:annotation>
			<xs:documentation>A whitespace-separated list of navigation item roles.</xs:documentation>
		</xs:annotation>
		<xs:restriction>
			<xs:simpleType>
				<xs:list itemType="NavigationItemRole"/>
			</xs:simpleType>
		</xs:restriction>
	</xs:simpleType>

	<xs:simpleType name="NavigationItemRole">
		<xs:annotation>
			<xs:documentation>A special role that a navigation item may have.</xs:documentation>
		</xs:annotation>
		<xs:restriction base="xs:NMTOKEN">
			<xs:enumeration value="learnpath">
				<xs:annotation>
					<xs:documentation>Marks the navigation item as learn path.</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="home">
				<xs:annotation>
					<xs:documentation>Marks the navigation item as starting page.</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="impressum">
				<xs:annotation>
					<xs:documentation>Marks the navigation item as impressum.</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="privacy">
				<xs:annotation>
					<xs:documentation>Marks the navigation item as privacy site.</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
		</xs:restriction>
	</xs:simpleType>

	<xs:complexType name="Pages">
		<xs:annotation>
			<xs:documentation>Contains all pages of a course variant.</xs:documentation>
		</xs:annotation>
		<xs:sequence minOccurs="0" maxOccurs="unbounded">
			<xs:element ref="page"/>
		</xs:sequence>
	</xs:complexType>

	<xs:complexType name="Page">
		<xs:annotation>
			<xs:documentation>
				One page in the course, consists of an optional title and a sequence of containers.
			</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:sequence>
				<xs:element name="title" type="Title" minOccurs="0" maxOccurs="1"/>
				<xs:group ref="ContainerGroup" minOccurs="0" maxOccurs="unbounded"/>
			</xs:sequence>
		</xs:sequence>
		<xs:attribute name="name" type="xs:Name" use="required">
			<xs:annotation>
				<xs:documentation xml:lang="en">
					Name of this page, must be unique among all names in this course variant.
				</xs:documentation>
				<xs:documentation xml:lang="de">
					Name der Seite. Muss eindeutig unter allen Namen innerhalb der Kursvariante sein.
				</xs:documentation>
			</xs:annotation>
		</xs:attribute>
		<xs:attribute name="tags" type="TokenList" use="optional" default="">
			<xs:annotation>
				<xs:documentation>Whitespace-separated list of tags for this page.</xs:documentation>
			</xs:annotation>
		</xs:attribute>
		<xs:attributeGroup ref="XmlAttributes"/>
	</xs:complexType>

	<xs:attributeGroup name="XmlAttributes">
		<xs:attribute ref="xml:base">
			<xs:annotation>
				<xs:documentation>This attribute provides a general way to specify in an XML document the base address
					used by relative links in an element. The edML language does not make use of this attribute, but we
					allow the attribute for convenience. More details can be found in the corresponding
					<a href="https://www.w3.org/TR/xmlbase/">official W3C specification on xml:base</a>.
				</xs:documentation>
				<xs:appinfo>
					<edmldoc:externattribute type="xs:anyURI"/>
				</xs:appinfo>
			</xs:annotation>
		</xs:attribute>
		<xs:attribute ref="xml:id">
			<xs:annotation>
				<xs:documentation>This attribute provides a general way to give an element in an XML document a unique
					identifier by which it can be referenced. The edML language does not make use of this mechanism,
					but we allow the attribute for convenience. More details can be found in the corresponding
					<a href="https://www.w3.org/TR/xml-id/">official W3C specification on xml:id</a>.
				</xs:documentation>
				<xs:appinfo>
					<edmldoc:externattribute type="xs:ID"/>
				</xs:appinfo>
			</xs:annotation>
		</xs:attribute>
	</xs:attributeGroup>

	<!-- ### Root elements ### -->

	<xs:element name="course" type="Course">
		<xs:key name="Course_VariantLanguage">
			<xs:selector xpath="edml:variant"/>
			<xs:field xpath="@lang"/>
		</xs:key>
	</xs:element>

	<xs:element name="variant" type="Variant">
		<xs:unique name="Variant_Element_Name">
			<xs:selector xpath=".//*"/>
			<xs:field xpath="@name"/>
		</xs:unique>
		<xs:keyref name="Variant_Ref_To" refer="Variant_Element_Name">
			<xs:selector xpath=".//edml:ref"/>
			<xs:field xpath="@to"/>
		</xs:keyref>
		<xs:keyref name="Variant_Button_To" refer="Variant_Element_Name">
			<xs:selector xpath=".//edml:button"/>
			<xs:field xpath="@to"/>
		</xs:keyref>
		<xs:unique name="Variant_TheoremBox_Name">
			<xs:selector xpath=".//edml:theorembox"/>
			<xs:field xpath="@name"/>
		</xs:unique>
		<xs:keyref name="Variant_ProofBox_Of" refer="Variant_TheoremBox_Name">
			<xs:selector xpath=".//edml:proofbox"/>
			<xs:field xpath="@of"/>
		</xs:keyref>
		<xs:unique name="Variant_Page_Name">
			<xs:selector xpath="./edml:pages/edml:page"/>
			<xs:field xpath="@name"/>
		</xs:unique>
		<xs:unique name="Variant_TestItem_Target_Name">
			<xs:selector xpath="./edml:pages/edml:page|.//edml:testitem"/>
			<xs:field xpath="@name"/>
		</xs:unique>
		<xs:keyref name="Variant_TestItem_Ref_To" refer="Variant_TestItem_Target_Name">
			<xs:selector xpath=".//edml:testitem/edml:ref"/>
			<xs:field xpath="@to"/>
		</xs:keyref>
		<xs:unique name="Variant_TextBox_Name">
			<xs:selector xpath=".//edml:textbox"/>
			<xs:field xpath="@name"/>
		</xs:unique>
		<xs:keyref name="Variant_FlipCardView_CloneContainer_From" refer="Variant_TextBox_Name">
			<xs:selector xpath=".//edml:flipcardview/edml:clonecontainer"/>
			<xs:field xpath="@from"/>
		</xs:keyref>
		<xs:unique name="Variant_GroupView_Name">
			<xs:selector xpath=".//edml:groupview"/>
			<xs:field xpath="@name"/>
		</xs:unique>
		<xs:keyref name="Variant_AccordionView_CloneContainer_From" refer="Variant_GroupView_Name">
			<xs:selector xpath=".//edml:accordionview/edml:clonecontainer"/>
			<xs:field xpath="@from"/>
		</xs:keyref>
		<xs:keyref name="Variant_CarouselView_CloneContainer_From" refer="Variant_GroupView_Name">
			<xs:selector xpath=".//edml:carouselview/edml:clonecontainer"/>
			<xs:field xpath="@from"/>
		</xs:keyref>
		<xs:keyref name="Variant_TabView_CloneContainer_From" refer="Variant_GroupView_Name">
			<xs:selector xpath=".//edml:tabview/edml:clonecontainer"/>
			<xs:field xpath="@from"/>
		</xs:keyref>
	</xs:element>

	<xs:element name="page" type="Page">
		<xs:unique name="Page_Input_Name">
			<xs:selector xpath=".//edml:input|.//edml:inputblock|.//edml:booleangroup"/>
			<xs:field xpath="@name"/>
		</xs:unique>
		<xs:keyref name="Page_SolutionHint_To" refer="Page_Input_Name">
			<xs:selector xpath=".//edml:solutionhint"/>
			<xs:field xpath="@to"/>
		</xs:keyref>
		<xs:keyref name="Page_Label_For" refer="Page_Input_Name">
			<xs:selector xpath=".//edml:label"/>
			<xs:field xpath="@for"/>
		</xs:keyref>
	</xs:element>

	<xs:element name="navlist" type="NavigationList">
		<xs:unique name="Navlist_Name">
			<xs:selector xpath=".//*"/>
			<xs:field xpath="@name"/>
		</xs:unique>
	</xs:element>

	<!-- ### Container level ### -->

	<xs:complexType name="Parameter">
		<xs:annotation>
			<xs:documentation>Defines a parameter whose value will be randomly chosen each time the course is loaded.
				The parameter can be used in all <code>calc</code> elements and input elements inside the container in which it is defined.
				Each time the page is reloaded, one of the value generators defined as child elements of this element is randomly chosen and called to generate a new parameter
				value. Parameters can be defined at the start of each box and are only accessible inside the box in which they are defined. </xs:documentation>
			<xs:appinfo>
				<edmldoc:example><![CDATA[<!-- Possible values are 1, 2, 3, 4, 5, 20 -->
<parameter identifier="a">
	<range step="1">
		<value>1</value>
		<value>5</value>
	</range>
	<value>20</value>
</parameter>]]></edmldoc:example>
			</xs:appinfo>
		</xs:annotation>
		<xs:sequence>
			<xs:sequence minOccurs="1" maxOccurs="unbounded">
				<xs:group ref="ParameterValueGeneratorGroup"/>
			</xs:sequence>
		</xs:sequence>
		<xs:attribute name="identifier" use="required" type="xs:Name">
			<xs:annotation>
				<xs:documentation>Defines the identifier by which this parameter can be referred to in all <code>calc</code> and input elements inside the
				surrounding box. Must be unique among all parameters defined in the surrounding box.</xs:documentation>
			</xs:annotation>
		</xs:attribute>
	</xs:complexType>

	<xs:group name="ParameterValueGeneratorGroup">
		<xs:choice>
			<xs:element name="value" type="ParameterValue"/>
			<xs:element name="range" type="ParameterRange"/>
		</xs:choice>
	</xs:group>

	<xs:attributeGroup name="ParameterWeightAttribute">
		<xs:attribute name="weight" use="optional" type="PositiveDecimal" default="1">
			<xs:annotation>
				<xs:documentation>Defines the weight of this parameter value generator among all value generators specified for the parameter.</xs:documentation>
			</xs:annotation>
		</xs:attribute>
	</xs:attributeGroup>

	<xs:complexType name="ParameterValue">
		<xs:annotation>
			<xs:documentation>Generates a single value for a parameter that can be a string or a number.</xs:documentation>
		</xs:annotation>
		<xs:simpleContent>
			<xs:extension base="xs:string">
				<xs:attributeGroup ref="ParameterWeightAttribute"/>
			</xs:extension>
		</xs:simpleContent>
	</xs:complexType>

	<xs:complexType name="NumericParameterValue">
		<xs:annotation>
			<xs:documentation>Generates a single value for a parameter that must be a number.</xs:documentation>
		</xs:annotation>
		<xs:simpleContent>
			<xs:extension base="xs:decimal">
				<xs:attributeGroup ref="ParameterWeightAttribute"/>
			</xs:extension>
		</xs:simpleContent>
	</xs:complexType>

	<xs:complexType name="ParameterRange">
		<xs:annotation>
			<xs:documentation>Uniformly generates a random value from a specified range for a parameter.
				The start and end values for the range must be defined in the child elements.
				In contrast to the values appearing direct in the parameter element, these two values must be numbers.
			</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="value" minOccurs="2" maxOccurs="2" type="NumericParameterValue"/>
		</xs:sequence>
		<xs:attributeGroup ref="ParameterWeightAttribute"/>
		<xs:attribute name="step" default="none">
			<xs:annotation>
				<xs:documentation>If the step value is a number, the range consists only of the numbers that are inside the interval defined by the start
					and end values and by the closure attribute and whose absolute difference from the start value is a multiple of the step value.
					The special value "none" turns the range into a continuous interval.
				</xs:documentation>
			</xs:annotation>
			<xs:simpleType>
				<xs:union memberTypes="PositiveDecimal None"/>
			</xs:simpleType>
		</xs:attribute>
		<xs:attribute name="closure" default="closed" type="IntervalClosureType">
			<xs:annotation>
				<xs:documentation>The type of the interval which this range should be based on. This decides whether or not the start and end values should be part of the
					range or not.
				</xs:documentation>
			</xs:annotation>
		</xs:attribute>
	</xs:complexType>

	<xs:attributeGroup name="ParameterRangeInclusiveAttribute">
		<xs:attribute name="inclusive" type="xs:boolean" default="true">
			<xs:annotation>
				<xs:documentation>Whether or not the specified number should be part of the parameter value range or not.</xs:documentation>
			</xs:annotation>
		</xs:attribute>
	</xs:attributeGroup>

	<xs:complexType name="ParameterRangeStart">
		<xs:annotation>
			<xs:documentation>Defines the start of a parameter value range.</xs:documentation>
		</xs:annotation>
		<xs:simpleContent>
			<xs:extension base="xs:decimal">
				<xs:attributeGroup ref="ParameterRangeInclusiveAttribute"/>
			</xs:extension>
		</xs:simpleContent>
	</xs:complexType>

	<xs:complexType name="ParameterRangeEnd">
		<xs:annotation>
			<xs:documentation>Defines the end of a parameter value range.</xs:documentation>
		</xs:annotation>
		<xs:simpleContent>
			<xs:extension base="xs:decimal">
				<xs:attributeGroup ref="ParameterRangeInclusiveAttribute"/>
			</xs:extension>
		</xs:simpleContent>
	</xs:complexType>

	<xs:complexType name="ParameterGroup">
		<xs:annotation>
			<xs:documentation>A parameter group can be used to define constraints between the parameters defined inside
				this element that should be enforced by the random generator when possible. The values of the parameters
				in the group are chosen in the order in which they appear in the "parametergroup" element. For each such
				parameter, the random generator tries to satisfy the group constraints. This means that the order of the
				parameters can make a difference when constraints are present. As a user, it is therefore generally a
				good idea to order the parameters inside a parameter group in ascending order by the size of their
				domain.
			</xs:documentation>
			<xs:appinfo>
				<edmldoc:example><![CDATA[<!-- Two parameters whose values should not coincide: !-->
<parametergroup pairwisedistinct="true">
	<parameter identifier="a">
		<value>1</value>
		<value>2</value>
	</parameter>
	<parameter identifier="b">
		<value>1</value>
		<value>2</value>
	</parameter>
</parametergroup>]]></edmldoc:example>
			</xs:appinfo>
		</xs:annotation>
		<xs:sequence>
			<xs:element minOccurs="1" maxOccurs="unbounded" name="parameter" type="Parameter"/>
		</xs:sequence>
		<xs:attribute name="pairwisedistinct" type="xs:boolean" default="false">
			<xs:annotation>
				<xs:documentation>Whether or not the values of the parameters in the group should be forced to be
					pairwise distinct.</xs:documentation>
			</xs:annotation>
		</xs:attribute>
		<xs:attribute name="pairwisecoprime" type="xs:boolean" default="false">
			<xs:annotation>
				<xs:documentation>Whether or not all the parameters with integer values in the group should be forced to
					have pairwise coprime values. This has no effect on parameters with non-integer values.</xs:documentation>
			</xs:annotation>
		</xs:attribute>
	</xs:complexType>

	<xs:complexType name="Box">
		<xs:sequence>
			<xs:element name="title" type="Title" minOccurs="0" maxOccurs="1"/>
			<xs:group ref="BoxParameterGroup" minOccurs="0" maxOccurs="unbounded"/>
			<xs:group ref="BlockGroup" minOccurs="0" maxOccurs="unbounded"/>
		</xs:sequence>
		<xs:attributeGroup ref="CommonContainerAttributes"/>
		<xs:attributeGroup ref="CommonBoxAttributes"/>
		<xs:attributeGroup ref="GeneralSubtypeAttribute"/>
	</xs:complexType>

	<xs:complexType name="ProofBox">
		<xs:annotation>
			<xs:documentation>A container with block content tagged as a proof.</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="title" type="Title" minOccurs="0" maxOccurs="1"/>
			<xs:group ref="BoxParameterGroup" minOccurs="0" maxOccurs="unbounded"/>
			<xs:group ref="BlockGroup" minOccurs="0" maxOccurs="unbounded"/>
		</xs:sequence>
		<xs:attributeGroup ref="CommonContainerAttributes"/>
		<xs:attributeGroup ref="CommonBoxAttributes"/>
		<xs:attributeGroup ref="GeneralSubtypeAttribute"/>
		<xs:attribute name="of" type="xs:Name">
			<xs:annotation>
				<xs:documentation>
					Name of the theorembox whose statement is proven in this proofbox.
				</xs:documentation>
			</xs:annotation>
		</xs:attribute>
	</xs:complexType>

	<xs:attributeGroup name="CommonBoxAttributes">
		<xs:attribute name="descriptor" type="xs:string">
			<xs:annotation>
				<xs:documentation>
					Sets the descriptor of this box. If this attribute is not present, the descriptor is the one defined
					in the course or variant settings or the global defaults.
				</xs:documentation>
			</xs:annotation>
		</xs:attribute>
		<xs:attribute name="numbered" type="xs:boolean">
			<xs:annotation>
				<xs:documentation>
					Changes whether this box is numbered. When this attribute is not present, the value is as defined
					in the course or variant settings or the global defaults.
				</xs:documentation>
			</xs:annotation>
		</xs:attribute>
	</xs:attributeGroup>

	<xs:attributeGroup name="GeneralSubtypeAttribute">
		<xs:attribute name="subtype" type="xs:Name">
			<xs:annotation>
				<xs:documentation>
					An optional subtype that further describes the content type of this box.
				</xs:documentation>
			</xs:annotation>
		</xs:attribute>
	</xs:attributeGroup>

	<xs:attributeGroup name="DifficultyAttribute">
		<xs:attribute name="difficulty" type="xs:nonNegativeInteger" default="0">
			<xs:annotation>
				<xs:documentation>Difficulty of this content. Higher values signal an increased difficulty.
				</xs:documentation>
			</xs:annotation>
		</xs:attribute>
	</xs:attributeGroup>

	<xs:attributeGroup name="ContentLoadingAttributes">
		<xs:attribute name="preview" type="xs:string">
			<xs:annotation>
				<xs:documentation>A path to a preview image that should be displayed as long as the content itself is not loaded.</xs:documentation>
			</xs:annotation>
		</xs:attribute>
		<xs:attribute name="autoload" type="xs:boolean">
			<xs:annotation>
				<xs:documentation>Whether or not the content should be loaded automatically without a user interaction. If this attribute is not set, the
					application will apply a suitable default behavior.</xs:documentation>
			</xs:annotation>
		</xs:attribute>
	</xs:attributeGroup>

	<xs:complexType name="ExerciseBox">
		<xs:annotation>
			<xs:documentation>A container with block content tagged as exercise. An exercise box can also store metadata
				about the exercise which it describes.</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="metadata" type="Metadata" minOccurs="0" maxOccurs="1"/>
			<xs:element name="title" type="Title" minOccurs="0" maxOccurs="1"/>
			<xs:group ref="BoxParameterGroup" minOccurs="0" maxOccurs="unbounded"/>
			<xs:sequence minOccurs="0" maxOccurs="unbounded">
				<xs:group ref="BlockGroup"/>
			</xs:sequence>
		</xs:sequence>
		<xs:attributeGroup ref="CommonContainerAttributes"/>
		<xs:attributeGroup ref="CommonBoxAttributes"/>
		<xs:attributeGroup ref="GeneralSubtypeAttribute"/>
		<xs:attributeGroup ref="DifficultyAttribute"/>
	</xs:complexType>

	<xs:complexType name="ExampleBox">
		<xs:annotation>
			<xs:documentation>A container with block content tagged as example.</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="title" type="Title" minOccurs="0" maxOccurs="1"/>
			<xs:sequence minOccurs="0" maxOccurs="unbounded">
				<xs:sequence>
					<xs:group ref="BoxParameterGroup" minOccurs="0" maxOccurs="unbounded"/>
					<xs:group ref="BlockGroup"/>
				</xs:sequence>
			</xs:sequence>
		</xs:sequence>
		<xs:attributeGroup ref="CommonContainerAttributes"/>
		<xs:attributeGroup ref="CommonBoxAttributes"/>
		<xs:attributeGroup ref="GeneralSubtypeAttribute"/>
		<xs:attributeGroup ref="DifficultyAttribute"/>
	</xs:complexType>

	<xs:complexType name="TheoremBox">
		<xs:annotation>
			<xs:documentation>A container with block content tagged as theorem.</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="title" type="Title" minOccurs="0" maxOccurs="1"/>
			<xs:sequence minOccurs="0" maxOccurs="unbounded">
				<xs:sequence>
					<xs:group ref="BoxParameterGroup" minOccurs="0" maxOccurs="unbounded"/>
					<xs:group ref="BlockGroup"/>
				</xs:sequence>
			</xs:sequence>
		</xs:sequence>
		<xs:attributeGroup ref="CommonContainerAttributes"/>
		<xs:attributeGroup ref="CommonBoxAttributes"/>
		<xs:attribute name="subtype">
			<xs:annotation>
				<xs:documentation>An optional subtype that further describes the content type of this box.</xs:documentation>
			</xs:annotation>
			<xs:simpleType>
				<xs:union memberTypes="TheoremBoxSubtype xs:Name"/>
			</xs:simpleType>
		</xs:attribute>
	</xs:complexType>

	<xs:simpleType name="TheoremBoxSubtype">
		<xs:restriction base="xs:Name">
			<xs:enumeration value="lemma">
				<xs:annotation>
					<xs:documentation>A minor proposition which is used as a stepping stone to a larger result.</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="proposition">
				<xs:annotation>
					<xs:documentation>A minor theorem which is overall of lesser importance.</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="corollary">
				<xs:annotation>
					<xs:documentation>A minor theorem which can be readily deduced from another result.</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="conjecture">
				<xs:annotation>
					<xs:documentation>A statement that is thought to be true but not yet proven.</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
		</xs:restriction>
	</xs:simpleType>

	<xs:complexType name="InfoBox">
		<xs:sequence>
			<xs:element name="title" type="Title" minOccurs="0" maxOccurs="1"/>
			<xs:group ref="BoxParameterGroup" minOccurs="0" maxOccurs="unbounded"/>
			<xs:group ref="BlockGroup" minOccurs="0" maxOccurs="unbounded"/>
		</xs:sequence>
		<xs:attributeGroup ref="CommonContainerAttributes"/>
		<xs:attributeGroup ref="CommonBoxAttributes"/>
		<xs:attribute name="subtype">
			<xs:annotation>
				<xs:documentation>An optional subtype that further describes the content type of this box.</xs:documentation>
			</xs:annotation>
			<xs:simpleType>
				<xs:union memberTypes="InfoBoxSubtype xs:Name"/>
			</xs:simpleType>
		</xs:attribute>
	</xs:complexType>

	<xs:simpleType name="InfoBoxSubtype">
		<xs:restriction base="xs:Name">
			<xs:enumeration value="learningobjective">
				<xs:annotation>
					<xs:documentation>A learning objective defines the learning outcome and focus of the whole course
						or a part of the course.</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
		</xs:restriction>
	</xs:simpleType>

	<xs:complexType name="GroupView">
		<xs:annotation>
			<xs:documentation>A view that wraps a sequence of containers and has an optional title.</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="title" type="Title" minOccurs="0" maxOccurs="1"/>
			<xs:sequence minOccurs="1" maxOccurs="unbounded">
				<xs:group ref="ContainerGroup"/>
			</xs:sequence>
		</xs:sequence>
		<xs:attributeGroup ref="CommonContainerAttributes"/>
		<xs:attributeGroup ref="DifficultyAttribute"/>
	</xs:complexType>

	<xs:complexType name="TitledGroupView">
		<xs:annotation>
			<xs:documentation>A view that wraps a sequence of containers and has a mandatory title.</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="title" type="Title" minOccurs="1" maxOccurs="1"/>
			<xs:sequence minOccurs="1" maxOccurs="unbounded">
				<xs:group ref="ContainerGroup"/>
			</xs:sequence>
		</xs:sequence>
		<xs:attributeGroup ref="CommonContainerAttributes"/>
		<xs:attributeGroup ref="DifficultyAttribute"/>
	</xs:complexType>

	<xs:complexType name="PoolView">
		<xs:annotation>
			<xs:documentation>A view that wraps a sequence of containers and shows only a selection of them that is randomly chosen each time the page is reloaded.
			</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="title" type="Title" minOccurs="0" maxOccurs="1"/>
			<xs:sequence minOccurs="1" maxOccurs="unbounded">
				<xs:group ref="ContainerGroup"/>
			</xs:sequence>
		</xs:sequence>
		<xs:attributeGroup ref="CommonContainerAttributes"/>
		<xs:attribute name="amount" type="xs:positiveInteger" default="1">
			<xs:annotation>
				<xs:documentation>The number of containers (chosen from the children of this element) that are shown at once in the pool view.</xs:documentation>
			</xs:annotation>
		</xs:attribute>
		<xs:attribute name="shuffle" type="xs:boolean" default="true">
			<xs:annotation>
				<xs:documentation>Whether or not the order of the sequence of pool elements that will be drawn when the poolview is loaded or
				refreshed should be randomly shuffled or not.</xs:documentation>
			</xs:annotation>
		</xs:attribute>
		<xs:attribute name="allowrefresh" type="xs:boolean" default="false">
			<xs:annotation>
				<xs:documentation>When set to true, a button will be shown on the pool view which, when being clicked by the user, chooses a new content of this pool view
					just like on a page reload. When possible, the application will make sure that a new selection of containers is chosen each time the button is pressed.
				</xs:documentation>
			</xs:annotation>
		</xs:attribute>
	</xs:complexType>

	<xs:complexType name="OptionalView">
		<xs:annotation>
			<xs:documentation>A view that wraps a sequence of containers that are optional in the sense that the course can be followed without them.
			</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="title" type="Title" minOccurs="0" maxOccurs="1"/>
			<xs:sequence minOccurs="1" maxOccurs="unbounded">
				<xs:group ref="ContainerGroup"/>
			</xs:sequence>
		</xs:sequence>
		<xs:attributeGroup ref="CommonContainerAttributes"/>
	</xs:complexType>

	<xs:complexType name="AccordionView">
		<xs:annotation>
			<xs:documentation>A view that wraps a sequence of group views (with mandatory titles) and displays them in an accordion.
				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="title" type="Title" minOccurs="0" maxOccurs="1"/>
			<xs:sequence maxOccurs="unbounded">
				<xs:choice>
					<xs:element name="groupview" type="TitledGroupView" />
					<xs:element name="clonecontainer" type="CloneContainer"/>
				</xs:choice>
			</xs:sequence>
		</xs:sequence>
		<xs:attributeGroup ref="CommonContainerAttributes"/>
		<xs:attributeGroup ref="CommonAccordionAttributes"/>
	</xs:complexType>

	<xs:attributeGroup name="CommonAccordionAttributes">
		<xs:attribute name="open" default="none">
			<xs:annotation>
				<xs:documentation>Either the number of the item or panel of this accordion, starting at 1 from top to bottom, that should be open when the page is loaded
					or the special value "none" which means that the accordion should be initially collapsed.
				</xs:documentation>
			</xs:annotation>
			<xs:simpleType>
				<xs:union memberTypes="xs:positiveInteger None"/>
			</xs:simpleType>
		</xs:attribute>
	</xs:attributeGroup>

	<xs:complexType name="TabView">
		<xs:annotation>
			<xs:documentation>A view that wraps a sequence of group views (with mandatory titles) and displays them as items in a tab set.
				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="title" type="Title" minOccurs="0" maxOccurs="1"/>
			<xs:sequence maxOccurs="unbounded">
				<xs:choice>
					<xs:element name="groupview" type="TitledGroupView" />
					<xs:element name="clonecontainer" type="CloneContainer"/>
				</xs:choice>
			</xs:sequence>
		</xs:sequence>
		<xs:attributeGroup ref="CommonContainerAttributes"/>
	</xs:complexType>

	<xs:complexType name="CarouselView">
		<xs:annotation>
			<xs:documentation>A view that warps a sequence of group views (with optional titles) and displays them in a carousel. Only one of the group views
				is visible at once and the user can go to the next or previous one on demand.
			</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="title" type="Title" minOccurs="0" maxOccurs="1"/>
			<xs:sequence maxOccurs="unbounded">
				<xs:choice>
					<xs:element name="groupview" type="TitledGroupView" />
					<xs:element name="clonecontainer" type="CloneContainer"/>
				</xs:choice>
			</xs:sequence>
		</xs:sequence>
		<xs:attributeGroup ref="CommonContainerAttributes"/>
		<xs:attribute name="loop" type="xs:boolean" default="false">
			<xs:annotation>
				<xs:documentation>Whether or not the sequence of group views should be wrapped to a loop for the user,
					starting with the first one again after the last one.
				</xs:documentation>
			</xs:annotation>
		</xs:attribute>
		<xs:attribute name="autostep" use="optional" default="none">
			<xs:annotation>
				<xs:documentation>Either the number of seconds after which the carousel view will automatically go to the next group view or the special value "none",
				which means that the carousel will not change the active group view automatically.
				</xs:documentation>
			</xs:annotation>
			<xs:simpleType>
				<xs:union memberTypes="PositiveDecimal None"/>
			</xs:simpleType>
		</xs:attribute>
		<xs:attribute name="fixedheight" use="optional" type="xs:boolean" default="true">
			<xs:annotation>
				<xs:documentation>Whether or not the height of the carousel should be fixed to the maximum of the height of its children.
					If this attribute is set to false, the height of the carousel changes dynamically depending on the active child.
				</xs:documentation>
			</xs:annotation>
		</xs:attribute>
		<xs:attribute name="indicator" type="CarouselIndicatorType" default="dots">
			<xs:annotation>
				<xs:documentation>The type of indicator of this carousel view. The indicator of a carousel view is positioned below or above the active container and shows
					the user how many items are available in the carousel and which one is active.
				</xs:documentation>
			</xs:annotation>
		</xs:attribute>
	</xs:complexType>

	<xs:simpleType name="CarouselIndicatorType">
		<xs:annotation>
			<xs:documentation>A type of indicator of a carousel view.</xs:documentation>
		</xs:annotation>
		<xs:restriction base="xs:NMTOKEN">
			<xs:enumeration value="dots">
				<xs:annotation>
					<xs:documentation>Dots that show the presence of the active and non-active containers.</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="slider">
				<xs:annotation>
					<xs:documentation>A progress slider, each container corresponds to one step value of the progress slider. The user can change the active container by
						moving the slider.</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
		</xs:restriction>
	</xs:simpleType>

	<xs:complexType name="FlipCardView">
		<xs:annotation>
			<xs:documentation>A view that allows the user to flip between two text boxes. The first text box is visible
				when the page is loaded. The user can click a button (shown on the bottom of this view) to show the
				other textbox instead and then flip again.
			</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:choice>
				<xs:element name="textbox" type="Box"/>
				<xs:element name="clonecontainer" type="CloneContainer"/>
			</xs:choice>
			<xs:sequence>
				<xs:choice>
					<xs:element name="textbox" type="Box"/>
					<xs:element name="clonecontainer" type="CloneContainer"/>
				</xs:choice>
			</xs:sequence>
		</xs:sequence>
		<xs:attributeGroup ref="CommonContainerAttributes"/>
		<xs:attribute name="cardwidth" type="LengthPercentage">
			<xs:annotation>
				<xs:documentation xml:lang="en">
					Width of a card relative to the page, or, if this flipcardview is nested in some container, the
					parent container. When this attribute is not set, the application automatically chooses the width.
				</xs:documentation>
				<xs:documentation xml:lang="de">
					Breite einer Karte relativ zur Seite oder, falls das Element in einem Elterncontainer vorkommt,
					relativ zu diesem Container. Falls das Attribut nicht angegeben wird, bestimmt die Anwendung die
					Breite automatisch.
				</xs:documentation>
			</xs:annotation>
		</xs:attribute>
		<xs:attribute name="cardheight" type="LengthPercentage">
			<xs:annotation>
				<xs:documentation xml:lang="en">
					Height of a card relative to the page, or, if this flipcardview is nested in some container, the
					parent container. When this attribute is not set, the application automatically chooses the height.
				</xs:documentation>
				<xs:documentation xml:lang="de">
					Höhe einer Karte relativ zur Seite oder, falls das Element in einem Elterncontainer vorkommt,
					relativ zu diesem Container. Falls das Attribut nicht angegeben wird, bestimmt die Anwendung die
					Höhe automatisch.
				</xs:documentation>
			</xs:annotation>
		</xs:attribute>
	</xs:complexType>

	<xs:group name="ContainerGroup">
		<xs:choice>
			<xs:group ref="BoxGroup"/>
			<xs:group ref="ViewGroup"/>
			<xs:element name="clonecontainer" type="CloneContainer"/>
		</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="InfoBox">
				<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:element name="theorembox" type="TheoremBox"/>
			<xs:element name="proofbox" type="ProofBox"/>
			<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:element name="conventionbox" type="Box">
				<xs:annotation>
					<xs:documentation>A box whose content is a convention. A convention is a determination that is valid for the whole course or a part of the course.
					</xs:documentation>
				</xs:annotation>
			</xs:element>
			<xs:element name="formulabox" type="Box">
				<xs:annotation>
					<xs:documentation>A box whose main purpose is to present a formula to the user.</xs:documentation>
				</xs:annotation>
			</xs:element>
			<xs:element name="applicationbox" type="Box">
				<xs:annotation>
					<xs:documentation>A box for content that describes an application of other content.</xs:documentation>
				</xs:annotation>
			</xs:element>
		</xs:choice>
	</xs:group>

	<xs:group name="ViewGroup">
		<xs:choice>
			<xs:element name="groupview" type="GroupView"/>
			<xs:element name="optionalview" type="OptionalView"/>
			<xs:element name="poolview" type="PoolView"/>
			<xs:element name="accordionview" type="AccordionView"/>
			<xs:element name="tabview" type="TabView"/>
			<xs:element name="carouselview" type="CarouselView"/>
			<xs:element name="flipcardview" type="FlipCardView"/>
		</xs:choice>
	</xs:group>

	<xs:complexType name="CloneContainer">
		<xs:annotation>
			<xs:documentation>
				This element clones a container (a view or a box) and puts the cloned container into the place where
				this element appears.
			</xs:documentation>
		</xs:annotation>
		<xs:attribute name="from" use="required" type="xs:Name">
			<xs:annotation>
				<xs:documentation>
					Name of the container whose content is being cloned.
				</xs:documentation>
			</xs:annotation>
		</xs:attribute>
		<xs:attribute name="deep" type="xs:boolean" default="false">
			<xs:annotation>
				<xs:documentation>
					Whether or not a deep copy of the container should be performed. A deep copy means that all elements
					inside the container will also be copied. This means for example that input field values in the new
					container will exist independently of the original one. If no deep copy is performed (the default),
					then the input field values will be shared across the original container and its copy.
				</xs:documentation>
			</xs:annotation>
		</xs:attribute>
	</xs:complexType>

	<xs:group name="BoxParameterGroup">
		<xs:choice>
			<xs:element name="parameter" type="Parameter"/>
			<xs:element name="parametergroup" type="ParameterGroup"/>
		</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="TokenList" use="optional" default="">
			<xs:annotation>
				<xs:documentation>Whitespace-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">
			<xs:annotation>
				<xs:documentation xml:lang="en">
					Name of this element. Must be unique among all element names in this course variant.
				</xs:documentation>
				<xs:documentation xml:lang="de">
					Name des Elements. Dieser muss eindeutig unter allen Elementen in der Kursvariante sein.
				</xs:documentation>
			</xs:annotation>
		</xs:attribute>
		<xs:attribute name="tags" type="TokenList" default="">
			<xs:annotation>
				<xs:documentation xml:lang="en">
					Whitespace-separated list of tags of this element.
				</xs:documentation>
				<xs:documentation xml:lang="de">
					Durch Leerzeichen getrennte Liste von Etiketten, welches dieses Element haben soll.
				</xs:documentation>
			</xs:annotation>
		</xs:attribute>
	</xs:attributeGroup>

	<xs:group name="InlineGroup">
		<xs:choice>
			<xs:element name="strong" type="Strong"/>
			<xs:element name="emph" type="Emph"/>
			<xs:element name="underline" type="Underline"/>
			<xs:element name="strikeout" type="Strikeout"/>
			<xs:element name="sup" type="Sup"/>
			<xs:element name="sub" type="Sub"/>
			<xs:element name="code" type="Code"/>
			<xs:element name="hint" type="Hint"/>
			<xs:element name="info" type="Info"/>
			<xs:element name="warning" type="Warning"/>
			<xs:element name="quote" type="Quote"/>
			<xs:element name="m" type="Math"/>
			<xs:element name="ref" type="Ref"/>
			<xs:element name="autoref" type="AutoRef"/>
			<xs:element name="mark" type="Mark"/>
			<xs:element name="link" type="Link"/>
			<xs:element name="picture" type="Picture"/>
			<xs:element name="br" type="LineBreak"/>
			<xs:element name="input" type="InlineInput"/>
			<xs:element name="calc" type="Calculate"/>
			<xs:element name="note" type="Note"/>
			<xs:element name="audio" type="Audio"/>
			<xs:element name="label" type="Label"/>
			<xs:element name="button" type="Button"/>
		</xs:choice>
	</xs:group>

	<xs:complexType name="Strong" mixed="true">
		<xs:annotation>
			<xs:documentation>Inline element which indicates that its content has strong importance.</xs:documentation>
			<xs:appinfo>
				<sch:pattern>
					<sch:rule context="edml:strong">
						<sch:assert test="not(.//edml:strong)">Strongs elements may not be nested in each other.</sch:assert>
					</sch:rule>
				</sch:pattern>
			</xs:appinfo>
		</xs:annotation>
		<xs:sequence minOccurs="0" maxOccurs="unbounded">
			<xs:group ref="InlineGroup"/>
		</xs:sequence>
		<xs:attributeGroup ref="CommonContentElementAttributes"/>
	</xs:complexType>

	<xs:complexType name="Emph" mixed="true">
		<xs:annotation>
			<xs:documentation>Inline element which indicates that its content has stress emphasis.</xs:documentation>
			<xs:appinfo>
				<sch:pattern>
					<sch:rule context="edml:emph">
						<sch:assert test="not(.//edml:emph)">Emph elements may not be nested in each other.</sch:assert>
					</sch:rule>
				</sch:pattern>
			</xs:appinfo>
		</xs:annotation>
		<xs:sequence minOccurs="0" maxOccurs="unbounded">
			<xs:group ref="InlineGroup"/>
		</xs:sequence>
		<xs:attributeGroup ref="CommonContentElementAttributes"/>
	</xs:complexType>

	<xs:complexType name="Underline" mixed="true">
		<xs:annotation>
			<xs:documentation>Inline element which underlines its content.</xs:documentation>
			<xs:appinfo>
				<sch:pattern>
					<sch:rule context="edml:underline">
						<sch:assert test="not(.//edml:underline)">Underline elements may not be nested in each other.</sch:assert>
					</sch:rule>
				</sch:pattern>
			</xs:appinfo>
		</xs:annotation>
		<xs:sequence minOccurs="0" maxOccurs="unbounded">
			<xs:group ref="InlineGroup"/>
		</xs:sequence>
		<xs:attributeGroup ref="CommonContentElementAttributes"/>
	</xs:complexType>

	<xs:complexType name="Strikeout" mixed="true">
		<xs:annotation>
			<xs:documentation>Inline element which places a horizontal line through its content.</xs:documentation>
			<xs:appinfo>
				<sch:pattern>
					<sch:rule context="edml:strikeout">
						<sch:assert test="not(.//edml:strikeout)">Strikeout elements may not be nested in each other.</sch:assert>
					</sch:rule>
				</sch:pattern>
			</xs:appinfo>
		</xs:annotation>
		<xs:sequence minOccurs="0" maxOccurs="unbounded">
			<xs:group ref="InlineGroup"/>
		</xs:sequence>
		<xs:attributeGroup ref="CommonContentElementAttributes"/>
	</xs:complexType>

	<xs:complexType name="Sup" mixed="true">
		<xs:annotation>
			<xs:documentation>Inline element which places its content in superscript.</xs:documentation>
		</xs:annotation>
		<xs:sequence minOccurs="0" maxOccurs="unbounded">
			<xs:group ref="InlineGroup"/>
		</xs:sequence>
		<xs:attributeGroup ref="CommonContentElementAttributes"/>
	</xs:complexType>

	<xs:complexType name="Sub" mixed="true">
		<xs:annotation>
			<xs:documentation>Inline element which places its content in subscript.</xs:documentation>
		</xs:annotation>
		<xs:sequence minOccurs="0" maxOccurs="unbounded">
			<xs:group ref="InlineGroup"/>
		</xs:sequence>
		<xs:attributeGroup ref="CommonContentElementAttributes"/>
	</xs:complexType>

	<xs:complexType name="Hint" mixed="true">
		<xs:annotation>
			<xs:documentation>Inline element which indicates that its content is a hint.</xs:documentation>
		</xs:annotation>
		<xs:sequence minOccurs="0" maxOccurs="unbounded">
			<xs:group ref="InlineGroup"/>
		</xs:sequence>
		<xs:attributeGroup ref="CommonContentElementAttributes"/>
	</xs:complexType>

	<xs:complexType name="Info" mixed="true">
		<xs:annotation>
			<xs:documentation>Inline element which indicates that its content is an information.</xs:documentation>
		</xs:annotation>
		<xs:sequence minOccurs="0" maxOccurs="unbounded">
			<xs:group ref="InlineGroup"/>
		</xs:sequence>
		<xs:attributeGroup ref="CommonContentElementAttributes"/>
	</xs:complexType>

	<xs:complexType name="Warning" mixed="true">
		<xs:annotation>
			<xs:documentation>Inline element which indicates that its content is a warning for the reader.</xs:documentation>
		</xs:annotation>
		<xs:sequence minOccurs="0" maxOccurs="unbounded">
			<xs:group ref="InlineGroup"/>
		</xs:sequence>
		<xs:attributeGroup ref="CommonContentElementAttributes"/>
	</xs:complexType>

	<xs:complexType name="Quote" mixed="true">
		<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:sequence minOccurs="0" maxOccurs="unbounded">
			<xs:group ref="InlineGroup"/>
		</xs:sequence>
		<xs:attributeGroup ref="CommonContentElementAttributes"/>
	</xs:complexType>

	<xs:group name="BlockGroup">
		<xs:choice>
			<xs:element name="p" type="Paragraph"/>
			<xs:element name="video" type="Video"/>
			<xs:element name="flex" type="Flex"/>
			<xs:element name="list" type="List"/>
			<xs:element name="table" type="Table"/>
			<xs:element name="codelisting" type="CodeListing"/>
			<xs:element name="blockquote" type="BlockQuote"/>
			<xs:element name="figureblock" type="FigureBlock"/>
			<xs:element name="solutionhint" type="SolutionHint"/>
			<xs:element name="help" type="Help"/>
			<xs:element name="booleangroup" type="BooleanGroup"/>
			<xs:element name="stringgroup" type="StringGroup"/>
			<xs:element name="accordion" type="Accordion"/>
			<xs:element name="tabset" type="TabSet"/>
			<xs:element name="externmedia" type="ExternMedia"/>
			<xs:element name="inputblock" type="BlockInput"/>
			<xs:element name="objectblock" type="ObjectBlock"/>
			<xs:element name="decision" type="Decision"/>
		</xs:choice>
	</xs:group>

	<xs:complexType name="ObjectBlock">
		<xs:annotation>
			<xs:documentation>This element defines an extension point for the user to put a custom block element in the
			course. The content of this element must be either a JSON-encoded object value or the empty string (which is
			treated the same as the empty JSON-object {}). This JSON-object will be parsed and passed to the plugin
			whose identifier matches the one given in the plugin attribute of this element. The referenced plugin must
			be loaded by the application processing the course and is responsible for displaying the object block. If
			no matching plugin is found, the element is ignored and not displayed at all.
			</xs:documentation>
			<xs:appinfo>
				<edmldoc:example><![CDATA[<objectblock plugin="3dmol">
	{
		"data": "molecule.sdf",
		"datatype": "sdf",
		"style": {
			"stick": {
				"hidden": false,
				"radius": 0.1
			},
			"sphere": {
				"radius": 0.25
			}
		}
	}
</objectblock>]]></edmldoc:example>
			</xs:appinfo>
		</xs:annotation>
		<xs:simpleContent>
			<xs:extension base="ObjectBlockContent">
				<xs:attributeGroup ref="CommonContentElementAttributes"/>
				<xs:attribute name="plugin" use="required">
					<xs:annotation>
						<xs:documentation>Identifier of the plugin which is responsible for displaying this object block.
						Can either be one of the plugin identifiers predefined by the edML language or a custom plugin
						identifier of a plugin installed in the application processing the course.
						</xs:documentation>
					</xs:annotation>
					<xs:simpleType>
						<xs:union memberTypes="PluginIdentifier xs:NMTOKEN"/>
					</xs:simpleType>
				</xs:attribute>
			</xs:extension>
		</xs:simpleContent>
	</xs:complexType>

	<xs:simpleType name="ObjectBlockContent">
		<xs:union memberTypes="JSONObjectEncoding EmptyString"/>
	</xs:simpleType>

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

	<xs:simpleType name="JSONObjectEncoding">
		<xs:annotation>
			<xs:documentation>A JSON-encoded object value. This type enforces that its content starts with { and ends
			with }. Whitespace and newline characters are allowed as well.</xs:documentation>
		</xs:annotation>
		<xs:restriction base="xs:string">
			<xs:pattern value="\s*\{(.|\s)*\}\s*"/>
		</xs:restriction>
	</xs:simpleType>

	<xs:simpleType name="PluginIdentifier">
		<xs:annotation>
			<xs:documentation>Plugin identifiers predefined by the edML language.</xs:documentation>
		</xs:annotation>
		<xs:restriction base="xs:NMTOKEN">
			<xs:enumeration value="3dmol">
				<xs:annotation>
					<xs:documentation>Plugin for displaying molecular data with the 3dmol javascript library.</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="geogebra">
				<xs:annotation>
					<xs:documentation>Plugin for displaying GeoGebra applets.</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="showsubnavigation">
				<xs:annotation>
					<xs:documentation>Plugin for a block element which displays all subitems of the current navigation
						item as a list of clickable links in the page content.</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
		</xs:restriction>
	</xs:simpleType>

	<xs:complexType name="Decision">
		<xs:annotation>
			<xs:documentation>
				A block element with multiple cases. When the parent container of this element is loaded or reloaded,
				the cases are processed from top to bottom and the content of at most one case gets displayed. When the
				condition of none of the cases is satisfied and there is a default element, then the content of the
				default element gets displayed.
			</xs:documentation>
			<xs:appinfo>
				<edmldoc:example><![CDATA[<decision>
	<case>
		<condition left="a" operator="equal" right="1"/>
		<p>
			Parameter a has value <m>1</m>.
		</p>
	</case>
	<case>
		<condition left="a" operator="equal" right="2"/>
		<p>
			Parameter a has value <m>2</m>.
		</p>
	</case>
	<default>
		<p>
			Parameter a has another value.
		</p>
	</default>
</decision>]]></edmldoc:example>
			</xs:appinfo>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="case" type="Case" maxOccurs="unbounded"/>
			<xs:element name="default" type="DefaultCase" minOccurs="0"/>
		</xs:sequence>
	</xs:complexType>

	<xs:complexType name="Case">
		<xs:annotation>
			<xs:documentation>
				A case of a decision element consisting of a condition and a sequence of block elements. If the
				condition is satisfied, the block elements get displayed and the decision is finished.
			</xs:documentation>
			<xs:appinfo>
				<edmldoc:example><![CDATA[<case>
	<condition first="a" operator="equal" second="1"/>
	<p>
		Parameter has value <m>1</m>.
	</p>
</case>]]></edmldoc:example>
			</xs:appinfo>
		</xs:annotation>
		<xs:sequence>
			<xs:group ref="ConditionalGroup"/>
			<xs:group ref="BlockGroup" minOccurs="0" maxOccurs="unbounded"/>
		</xs:sequence>
	</xs:complexType>

	<xs:complexType name="DefaultCase">
		<xs:annotation>
			<xs:documentation>
				The default case of a decision. If none of the cases in the decision is satisfied, then the content of
				this element is displayed.
			</xs:documentation>
			<xs:appinfo>
				<edmldoc:example><![CDATA[<default>
	<p>
		This text is shown when none of the previously defined conditions is satisfied.
	</p>
</default>]]></edmldoc:example>
			</xs:appinfo>
		</xs:annotation>
		<xs:sequence>
			<xs:group ref="BlockGroup" maxOccurs="unbounded"/>
		</xs:sequence>
	</xs:complexType>

	<xs:group name="ConditionalGroup">
		<xs:choice>
			<xs:element name="condition" type="Condition"/>
			<xs:element name="oneof" type="OneOf"/>
			<xs:element name="allof" type="AllOf"/>
		</xs:choice>
	</xs:group>

	<xs:complexType name="Condition">
		<xs:annotation>
			<xs:documentation>
				A condition consisting of a left hand side expression, a right hand side expression and a comparison
				operator. The condition is satisfied if and only if the comparison yields true. The expressions are
				evaluated using the Computer Algebra System. Parameters defined in the parent container can be used in
				the expressions and are refeered to using their identifier. Moreover, when input field values are
				available during the processing of this condition (for example in the feedback element of tests), these
				input field values can also be used in the expressions and are refeered to using the syntax
				${name-of-input-field}.
			</xs:documentation>

			<xs:appinfo>
				<edmldoc:example><![CDATA[<condition left="x^2+y^2" operator="less" right="1"/>]]></edmldoc:example>
			</xs:appinfo>
		</xs:annotation>
		<xs:attribute name="left" type="xs:string" use="required">
			<xs:annotation>
				<xs:documentation>
					The expression on the left hand side of the equality or inequality. The expression is evaluated
					using the Computer Algebra System. The documentation of the condition element contains more
					information on the computed values that can be used here.
				</xs:documentation>
			</xs:annotation>
		</xs:attribute>
		<xs:attribute name="operator" type="ComparisonOperator" use="required">
			<xs:annotation>
				<xs:documentation>
					The comparison operator. Must be one of the operators defined by the language.
				</xs:documentation>
			</xs:annotation>
		</xs:attribute>
		<xs:attribute name="right" type="xs:string" use="required">
			<xs:annotation>
				<xs:documentation>
					The expression on the right hand side of the equality or inequality. The expression is evaluated
					using the Computer Algebra System. The documentation of the condition element contains more
					information on the computed values that can be used here.
				</xs:documentation>
			</xs:annotation>
		</xs:attribute>
	</xs:complexType>

	<xs:complexType name="AllOf">
		<xs:annotation>
			<xs:documentation>
				A combinator condition which is satisfied if and only if all of its child conditions are satisfied.
			</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:sequence maxOccurs="unbounded">
				<xs:choice>
					<xs:element name="condition" type="Condition"/>
					<xs:element name="oneof" type="OneOf"/>
				</xs:choice>
			</xs:sequence>
		</xs:sequence>
	</xs:complexType>

	<xs:complexType name="OneOf">
		<xs:annotation>
			<xs:documentation>
				A combinator condition which is satisfied if and only if at least one of its child conditions is
				satisfied.
			</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:sequence maxOccurs="unbounded">
				<xs:choice>
					<xs:element name="condition" type="Condition"/>
					<xs:element name="allof" type="AllOf"/>
				</xs:choice>
			</xs:sequence>
		</xs:sequence>
	</xs:complexType>

	<xs:simpleType name="ComparisonOperator">
		<xs:annotation>
			<xs:documentation>A comparison operator used in an equality or inequality.</xs:documentation>
		</xs:annotation>
		<xs:restriction base="xs:NMTOKEN">
			<xs:enumeration value="equal">
				<xs:annotation>
					<xs:documentation>(Equal) Tests that two values are equal.</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="notequal">
				<xs:annotation>
					<xs:documentation>(Not equal) Tests that two values are different.</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="less">
				<xs:annotation>
					<xs:documentation>(Less than) Tests that one values is less than another value.</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="lessequal">
				<xs:annotation>
					<xs:documentation>(Less than or equal) Tests that one values is less than or equal to another value.</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="greater">
				<xs:annotation>
					<xs:documentation>(Greater than) Tests that one values is greater than another value.</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="greaterequal">
				<xs:annotation>
					<xs:documentation>(Greater than or equal) Tests that one values is greater than or equal to another value.</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
		</xs:restriction>
	</xs:simpleType>

	<xs:complexType name="Paragraph" mixed="true">
		<xs:annotation>
			<xs:documentation>A paragraph which holds text or inline elements.</xs:documentation>
		</xs:annotation>
		<xs:sequence minOccurs="0" maxOccurs="unbounded">
			<xs:group ref="InlineGroup"/>
		</xs:sequence>
		<xs:attributeGroup ref="CommonContentElementAttributes"/>
	</xs:complexType>

	<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 media object embedded from an external web page.</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:sequence minOccurs="0">
				<xs:element name="metadata" type="Metadata"/>
			</xs:sequence>
		</xs:sequence>
		<xs:attributeGroup ref="CommonContentElementAttributes"/>
		<xs:attribute name="source" type="HypertextUrl" use="required">
			<xs:annotation>
				<xs:documentation>URL of the external web page.</xs:documentation>
			</xs:annotation>
		</xs:attribute>
		<xs:attributeGroup ref="CommonMediaAttributes"/>
		<xs:attributeGroup ref="ContentLoadingAttributes"/>
	</xs:complexType>

	<xs:simpleType name="HypertextUrl">
		<xs:annotation>
			<xs:documentation>An URL that starts 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:attributeGroup ref="CommonAccordionAttributes"/>
	</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:attribute name="numbered" type="xs:boolean" default="true">
			<xs:annotation>
				<xs:documentation xml:lang="en">
					Whether or not the figure should be numbered.
				</xs:documentation>
				<xs:documentation xml:lang="de">
					Entscheidet, ob die Abbildung nummeriert sein soll oder nicht.
				</xs:documentation>
			</xs:annotation>
		</xs:attribute>
	</xs:complexType>

	<xs:complexType name="Caption" mixed="true">
		<xs:annotation>
			<xs:documentation>Caption of a figure block.</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:group ref="InlineGroup" minOccurs="0" maxOccurs="unbounded"/>
		</xs:sequence>
	</xs:complexType>

	<xs:simpleType name="HorizontalAlignment">
		<xs:annotation>
			<xs:documentation>Horizontal alignment of an element in the course.</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:simpleType name="VerticalAlignment">
		<xs:annotation>
			<xs:documentation>
				Vertical alignment of an element in the course.
			</xs:documentation>
		</xs:annotation>
		<xs:restriction base="xs:NMTOKEN">
			<xs:enumeration value="baseline">
				<xs:annotation>
					<xs:documentation>Aligns the baseline of a table cell with the baseline of all other cells in the
						row that are also baseline aligned.</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="top">
				<xs:annotation>
					<xs:documentation>Aligned on the top side of its parent.</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="middle">
				<xs:annotation>
					<xs:documentation>Aligned in the middle of its parent</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="bottom">
				<xs:annotation>
					<xs:documentation>Aligned to the bottom side 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 short code fragment with optional syntax highlighting.
				Whitespace inside the code is preserved but newline characters are ignored.
			</xs:documentation>
			<xs:appinfo>
				<edmldoc:example><![CDATA[<p>In Java, classes are defined using the <code lang="java">class</code> keyword.</p>]]></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.
				The following macros are predefined and can be used as shorthands in this element:
				Differential operator \md: \mathrm{d}
			</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:element minOccurs="0" maxOccurs="unbounded" name="calc" type="Calculate"/>
		</xs:sequence>
		<xs:attributeGroup ref="CommonContentElementAttributes"/>
		<xs:attribute name="display" type="MathDisplayStyle" default="inline">
			<xs:annotation>
				<xs:documentation>Determines whether this formula should be displayed as an inline element or block element.</xs:documentation>
			</xs:annotation>
		</xs:attribute>
		<xs:attribute name="align" type="HorizontalAlignment" default="center">
			<xs:annotation>
				<xs:documentation>Horizontal alignment of this formula when displayed as a block element.</xs:documentation>
			</xs:annotation>
		</xs:attribute>
		<xs:attribute name="numbered" type="xs:boolean" default="false">
			<xs:annotation>
				<xs:documentation>Whether or not this math element should be numbered. If this is enabled, the value of
					the math element counter is displayed to the right of the math element in round brackets and this
					counter is increased by one.</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="BlockQuote">
		<xs:annotation>
			<xs:documentation>Block element displaying a quotation.</xs:documentation>
		</xs:annotation>
		<xs:sequence minOccurs="0" maxOccurs="unbounded">
			<xs:group ref="BlockGroup"/>
		</xs:sequence>
		<xs:attributeGroup ref="CommonContentElementAttributes"/>
	</xs:complexType>

	<xs:complexType name="CodeListing" mixed="true">
		<xs:annotation>
			<xs:documentation>Block element for a code listing with optional syntax highlighting.
				All whitespace and newline characters in the code listing are preserved in the output.
			</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="spotlight" minOccurs="0" maxOccurs="unbounded" type="Spotlight"/>
		</xs:sequence>
		<xs:attributeGroup ref="CommonContentElementAttributes"/>
		<xs:attributeGroup ref="CodeAttributes"/>
		<xs:attribute name="highlight" type="LineNumberRangeList" default="">
			<xs:annotation>
				<xs:documentation>A space-separated list of individual line numbers or line number ranges of the code to highlight. These lines are displayed differently
					than the other lines so that they can be distinguished by the user.
				</xs:documentation>
			</xs:annotation>
		</xs:attribute>
	</xs:complexType>

	<xs:complexType name="Spotlight">
		<xs:annotation>
			<xs:documentation>This element can be used inside the <code>codelisting</code>element to stress the attention of the user to a specific part of the code.
			</xs:documentation>
		</xs:annotation>
		<xs:simpleContent>
			<xs:extension base="xs:string"/>
		</xs:simpleContent>
	</xs:complexType>

	<xs:simpleType name="LineNumberRangeList">
		<xs:annotation>
			<xs:documentation>A space-separated list of line number ranges, such as "1", "1 5", "10-12" or "1 5 20-26 7 100-141 9".</xs:documentation>
		</xs:annotation>
		<xs:list itemType="LineNumberRange"/>
	</xs:simpleType>

	<xs:simpleType name="LineNumberRange">
		<xs:annotation>
			<xs:documentation>A line number range consists either of a single line number, such as "1" or "5", or a range such as "10-16".
				Every line number must be a positive integer without leading zeros.
			</xs:documentation>
		</xs:annotation>
		<xs:restriction base="xs:NMTOKEN">
			<xs:pattern value="[1-9]+\d*|([1-9]+\d*\-[1-9]+\d*)"/>
		</xs:restriction>
	</xs:simpleType>

	<xs:complexType name="SourceCodeInputValue">
		<xs:annotation>
			<xs:documentation>Input element in which the user can write source code in a specified
				programming language and execute it.
			</xs:documentation>
			<xs:appinfo>
				<edmldoc:property name="value" datatypes="string" examplevalue="public class A {}" nullable="true">
					<xs:annotation>
						<xs:documentation>
							Source code entered by the user. Can contain newline characters.
						</xs:documentation>
					</xs:annotation>
				</edmldoc:property>
			</xs:appinfo>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="initialcontent" minOccurs="0" maxOccurs="1" type="SourceCodeInitialContent"/>
		</xs:sequence>
		<xs:attributeGroup ref="CommonInputValueAttributes"/>
		<xs:attribute name="lang" use="required" type="ProgrammingLanguage">
			<xs:annotation>
				<xs:documentation>Programming language that the source code should be written in, such as "java".</xs:documentation>
			</xs:annotation>
		</xs:attribute>
		<xs:attribute name="type" type="SourceCodeInputType">
			<xs:annotation>
				<xs:documentation>Controls what kind of source code input is expected: Multiple source code files (project), only one source code file (file), several
					functions (functions) or statements (statements).</xs:documentation>
				<xs:appinfo>
					<edmldoc:modelattribute/>
				</xs:appinfo>
			</xs:annotation>
		</xs:attribute>
	</xs:complexType>

	<xs:simpleType name="SourceCodeInputType">
		<xs:annotation>
			<xs:documentation>Controls what kind of source code input is expected in a source code input 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="SourceCodeInitialContent">
		<xs:annotation>
			<xs:documentation>Initial code content of a <code>sourcecode</code> element. All whitespace and newline characters inside this element are preserved.
			</xs:documentation>
		</xs:annotation>
		<xs:simpleContent>
			<xs:extension base="xs:string"/>
		</xs:simpleContent>
	</xs:complexType>

	<xs:attributeGroup name="CodeAttributes">
		<xs:attribute name="lang" type="CodeLanguage" default="plaintext">
			<xs:annotation>
				<xs:documentation>Short string identifying the language of the code content, such as "plaintext" (no language), "xml", "java" or "cpp".</xs:documentation>
			</xs:annotation>
		</xs:attribute>
	</xs:attributeGroup>

	<xs:simpleType name="CodeLanguage">
		<xs:annotation>
			<xs:documentation>A language of a code fragment.</xs:documentation>
		</xs:annotation>
		<xs:restriction base="xs:NMTOKEN">
			<xs:enumeration value="plaintext">
				<xs:annotation>
					<xs:documentation>Plaintext</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="xml">
				<xs:annotation>
					<xs:documentation>XML</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="java">
				<xs:annotation>
					<xs:documentation>Java</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="cpp">
				<xs:annotation>
					<xs:documentation>C++</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
		</xs:restriction>
	</xs:simpleType>

	<xs:simpleType name="ProgrammingLanguage">
		<xs:annotation>
			<xs:documentation>A programming language.</xs:documentation>
		</xs:annotation>
		<xs:restriction base="xs:NMTOKEN">
			<xs:enumeration value="java">
				<xs:annotation>
					<xs:documentation>Java</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
		</xs:restriction>
	</xs:simpleType>

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

	<xs:complexType name="Metadata">
		<xs:annotation>
			<xs:documentation>
				Contains information about the metadata of a resource that is used in the course, such as a picture or a video. Every <code>metadata</code>
				element should contain at least one <code>license</code> child element.</xs:documentation>
			<xs:appinfo>
				<sch:pattern>
					<sch:rule context="edml:metadata">
						<sch:assert test="edml:license">Every metadata element must have at least one license child element.</sch:assert>
					</sch:rule>
				</sch:pattern>
			</xs:appinfo>
		</xs:annotation>
		<xs:sequence minOccurs="0" maxOccurs="unbounded">
			<xs:choice>
				<xs:element name="creator" type="Creator"/>
				<xs:element name="date" type="Date"/>
				<xs:element name="description" type="Description"/>
				<xs:element name="source" type="Source"/>
				<xs:element name="license" type="License"/>
			</xs:choice>
		</xs:sequence>
	</xs:complexType>

	<xs:attributeGroup name="MetadataUrlAttribute">
		<xs:attribute name="url" type="xs:anyURI" use="optional">
			<xs:annotation>
				<xs:documentation>An URL to a resource that contains further information about this metadata field.</xs:documentation>
			</xs:annotation>
		</xs:attribute>
	</xs:attributeGroup>

	<xs:complexType name="Creator">
		<xs:annotation>
			<xs:documentation>An entity who is primarily responsible for making a resource.</xs:documentation>
		</xs:annotation>
		<xs:simpleContent>
			<xs:extension base="xs:string">
				<xs:attributeGroup ref="MetadataUrlAttribute"/>
			</xs:extension>
		</xs:simpleContent>
	</xs:complexType>

	<xs:complexType name="Date">
		<xs:annotation>
			<xs:documentation>A point of time associated with an event in the lifecycle of a resource.</xs:documentation>
		</xs:annotation>
		<xs:simpleContent>
			<xs:extension base="xs:date">
			</xs:extension>
		</xs:simpleContent>
	</xs:complexType>

	<xs:complexType name="Description">
		<xs:annotation>
			<xs:documentation>A description or an account of a resource.</xs:documentation>
		</xs:annotation>
		<xs:simpleContent>
			<xs:extension base="xs:string">
				<xs:attributeGroup ref="MetadataUrlAttribute"/>
			</xs:extension>
		</xs:simpleContent>
	</xs:complexType>

	<xs:complexType name="Source">
		<xs:annotation>
			<xs:documentation>A description of a related resource from which the described resource is derived.</xs:documentation>
		</xs:annotation>
		<xs:simpleContent>
			<xs:extension base="xs:string">
				<xs:attributeGroup ref="MetadataUrlAttribute"/>
			</xs:extension>
		</xs:simpleContent>
	</xs:complexType>

	<xs:complexType name="License">
		<xs:annotation>
			<xs:documentation>Describes the license of a resource.</xs:documentation>
		</xs:annotation>
		<xs:simpleContent>
			<xs:extension base="xs:string">
				<xs:attributeGroup ref="MetadataUrlAttribute"/>
			</xs:extension>
		</xs:simpleContent>
	</xs:complexType>

	<xs:attributeGroup name="CommonMediaAttributes">
		<xs:attribute name="minwidth" use="optional" default="auto">
			<xs:annotation>
				<xs:documentation>Minimum width of this media object as <a href="#LengthPercentage">length percentage value</a> or "auto", which means that
				the application will calculate and select a minimum width.</xs:documentation>
			</xs:annotation>
			<xs:simpleType>
				<xs:union memberTypes="LengthPercentage Auto"/>
			</xs:simpleType>
		</xs:attribute>
		<xs:attribute name="maxwidth" use="optional" default="none">
			<xs:annotation>
				<xs:documentation>Maximal width of this media object as <a href="#LengthPercentage">length percentage value</a> or "none", which means that
				there should be no limit on the width of the object.</xs:documentation>
			</xs:annotation>
			<xs:simpleType>
				<xs:union memberTypes="LengthPercentage None"/>
			</xs:simpleType>
		</xs:attribute>
		<xs:attribute name="minheight" use="optional" default="auto">
			<xs:annotation>
				<xs:documentation>Minimum height of this media object as <a href="#LengthPercentage">length percentage value</a> or "auto", which means that
				the application will calculate and select a minimum height.
				</xs:documentation>
			</xs:annotation>
			<xs:simpleType>
				<xs:union memberTypes="LengthPercentage Auto"/>
			</xs:simpleType>
		</xs:attribute>
		<xs:attribute name="maxheight" use="optional" default="none">
			<xs:annotation>
				<xs:documentation>Maximal height of this media object as <a href="#LengthPercentage">length percentage value</a> or "none", which means that
				there should be no limit on the height of the object.</xs:documentation>
			</xs:annotation>
			<xs:simpleType>
				<xs:union memberTypes="LengthPercentage None"/>
			</xs:simpleType>
		</xs:attribute>
	</xs:attributeGroup>

	<xs:complexType name="Picture">
		<xs:annotation>
			<xs:documentation>Displays a picture loaded from a local image file.
				The image file can contain either a raster graphic graphic (for example, a PNG file) or a vector graphic (for example, an SVG file).
			</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="metadata" type="Metadata" minOccurs="1" maxOccurs="1"/>
		</xs:sequence>
		<xs:attributeGroup ref="CommonContentElementAttributes"/>
		<xs:attribute name="filepath" type="xs:string" use="required">
			<xs:annotation>
				<xs:documentation>Path to the image file relative to the current document.</xs:documentation>
			</xs:annotation>
		</xs:attribute>
		<xs:attributeGroup ref="CommonMediaAttributes"/>
	</xs:complexType>

	<xs:complexType name="Audio">
		<xs:annotation>
			<xs:documentation>Audio player that can be used to play an audio file.</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="metadata" type="Metadata" minOccurs="1" maxOccurs="1"/>
		</xs:sequence>
		<xs:attributeGroup ref="CommonContentElementAttributes"/>
		<xs:attribute name="filepath" type="xs:string" use="required">
			<xs:annotation>
				<xs:documentation>Path to the audio file relative to the current document.</xs:documentation>
			</xs:annotation>
		</xs:attribute>
	</xs:complexType>

	<xs:complexType name="Video">
		<xs:annotation>
			<xs:documentation>Plays a video loaded from a local video file (for example, an MP4 file).</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="metadata" type="Metadata" minOccurs="1" maxOccurs="1"/>
		</xs:sequence>
		<xs:attributeGroup ref="CommonContentElementAttributes"/>
		<xs:attribute name="filepath" type="xs:string" use="required">
			<xs:annotation>
				<xs:documentation>Path to the video file relative to the current document.</xs:documentation>
			</xs:annotation>
		</xs:attribute>
		<xs:attributeGroup ref="CommonMediaAttributes"/>
		<xs:attributeGroup ref="ContentLoadingAttributes"/>
	</xs:complexType>

	<xs:complexType name="Ref" mixed="true">
		<xs:annotation>
			<xs:documentation>A reference to another part of the course.</xs:documentation>
			<xs:appinfo>
				<sch:pattern>
					<sch:rule context="edml:ref">
						<sch:assert test="not(.//edml:ref | .//edml:link | .//edml:button)">
							References may not contain other reference elements.
						</sch:assert>
					</sch:rule>
				</sch:pattern>
			</xs:appinfo>
		</xs:annotation>
		<xs:sequence minOccurs="0" maxOccurs="unbounded">
			<xs:choice>
				<xs:group ref="InlineGroup"/>
			</xs:choice>
		</xs:sequence>
		<xs:attributeGroup ref="CommonContentElementAttributes"/>
		<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:complexType>

	<xs:complexType name="AutoRef">
		<xs:annotation>
			<xs:documentation>A reference to a part of the course with automatically generated text content. This element must be empty and will be replaced
			by a link such as "Example 2" or "Page Vector spaces" depending on the referenced element in the "to" attribute.</xs:documentation>
		</xs:annotation>
		<xs:attributeGroup ref="CommonContentElementAttributes"/>
		<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:complexType>

	<xs:complexType name="Link" mixed="true">
		<xs:annotation>
			<xs:documentation>Link to an external resource, such as a website or an email address.</xs:documentation>
			<xs:appinfo>
				<sch:pattern>
					<sch:rule context="edml:link">
						<sch:assert test="not(.//edml:ref | .//edml:link | .//edml:button)">
							Links may not contain other reference elements.
						</sch:assert>
					</sch:rule>
				</sch:pattern>
			</xs:appinfo>
		</xs:annotation>
		<xs:sequence minOccurs="0" maxOccurs="unbounded">
			<xs:group ref="InlineGroup"/>
		</xs:sequence>
		<xs:attributeGroup ref="CommonContentElementAttributes"/>
		<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:attribute name="markexternal" type="xs:boolean" default="true">
			<xs:annotation>
				<xs:documentation>
					Whether or the hyperlink should be visually marked as an external link or not. By default, external
					links are marked to show the user that they lead to another website.
				</xs:documentation>
			</xs:annotation>
		</xs:attribute>
		<xs:attribute name="target" type="LinkTarget" default="blank">
			<xs:annotation>
				<xs:documentation>
					Controls how the link should be opened: In a new tab (blank) or in the same tab (self).
				</xs:documentation>
			</xs:annotation>
		</xs:attribute>
	</xs:complexType>

	<xs:simpleType name="LinkTarget">
		<xs:annotation>
			<xs:documentation>
				Controls how a link should be opened.
			</xs:documentation>
		</xs:annotation>
		<xs:restriction base="xs:NMTOKEN">
			<xs:enumeration value="self">
				<xs:annotation>
					<xs:documentation>
						Open the link in this tab.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="blank">
				<xs:annotation>
					<xs:documentation>
						Open the link in a blank new tab.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
		</xs:restriction>
	</xs:simpleType>

	<xs:complexType name="Mark" mixed="true">
		<xs:annotation>
			<xs:documentation>Inline element that can be used to give its content a name and/or to assign semantic roles to its content.</xs:documentation>
			<xs:appinfo>
				<edmldoc:example><![CDATA[Ein <mark name="vektorraum" role="definition">Vektorraum</mark> ist eine Menge ...]]></edmldoc:example>
			</xs:appinfo>
		</xs:annotation>
		<xs:sequence>
			<xs:group ref="InlineGroup" minOccurs="0" maxOccurs="unbounded"/>
		</xs:sequence>
		<xs:attributeGroup ref="CommonContentElementAttributes"/>
		<xs:attribute name="role" type="TokenList" default="">
			<xs:annotation>
				<xs:documentation>Whitespace-separated list of semantic roles that should be applied to the content of this element.</xs:documentation>
			</xs:annotation>
		</xs:attribute>
	</xs:complexType>

	<xs:complexType name="Note" mixed="true">
		<xs:annotation>
			<xs:documentation>A note that provides additional information or comments from the author. Notes are numbered per page and their
				content is shown at the bottom of the page.</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:group ref="InlineGroup" minOccurs="0" maxOccurs="unbounded"/>
		</xs:sequence>
		<xs:attributeGroup ref="CommonContentElementAttributes"/>
	</xs:complexType>

	<xs:complexType name="Flex">
		<xs:annotation>
			<xs:documentation>Block element for a flex container that contains one or more flex items.</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 flex container.</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:attribute name="minwidth" default="auto">
			<xs:annotation>
				<xs:documentation>
					Minimum width of this flex item. The special value "auto" means that the application will calculate
					and select a minimum width.
				</xs:documentation>
			</xs:annotation>
			<xs:simpleType>
				<xs:union memberTypes="LengthPercentage Auto"/>
			</xs:simpleType>
		</xs:attribute>
		<xs:attribute name="maxwidth" default="none">
			<xs:annotation>
				<xs:documentation>
					Maximal width of this flex item. The special value "none" means that there should be no limit on the
					width of the flex item.
				</xs:documentation>
			</xs:annotation>
			<xs:simpleType>
				<xs:union memberTypes="LengthPercentage None"/>
			</xs:simpleType>
		</xs:attribute>
	</xs:complexType>

	<xs:attributeGroup name="FlexContainerAttributes">
		<xs:attribute name="flexdirection" type="FlexDirection" default="row">
			<xs:annotation>
				<xs:documentation>The direction flex items are placed in the flex container. This is the main axis of the container.</xs:documentation>
			</xs:annotation>
		</xs:attribute>
		<xs:attribute name="flexwrap" type="FlexWrap" default="nowrap">
			<xs:annotation>
				<xs:documentation>Defines whether the flex items are forced in a single line or wrapped into multiple lines if neccessary.</xs:documentation>
			</xs:annotation>
		</xs:attribute>
		<xs:attribute name="justifycontent" type="FlexItemAlignment" default="stretch">
			<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="FlexItemSimpleAlignment" default="stretch">
			<xs:annotation>
				<xs:documentation>The alignment of the flex items along the cross axis.</xs:documentation>
			</xs:annotation>
		</xs:attribute>
		<xs:attribute name="aligncontent" type="FlexItemAlignment" default="stretch">
			<xs:annotation>
				<xs:documentation>The alignment of flex items along the cross axis when there is extra space in the cross axis as a result of wrapping.</xs:documentation>
			</xs:annotation>
		</xs:attribute>
		<xs:attribute name="rowgap" type="LengthPercentage" default="0">
			<xs:annotation>
				<xs:documentation>
					The size of the gap between rows as <a href="#LengthPercentage">length percentage value</a>.
				</xs:documentation>
			</xs:annotation>
		</xs:attribute>
		<xs:attribute name="columngap" type="LengthPercentage" default="0">
			<xs:annotation>
				<xs:documentation>
					The size of the gap between flex columns as <a href="#LengthPercentage">length percentage value</a>.
				</xs:documentation>
			</xs:annotation>
		</xs:attribute>
	</xs:attributeGroup>

	<xs:simpleType name="FlexDirection">
		<xs:annotation>
			<xs:documentation>Direction in which flex items are placed in the flex container.</xs:documentation>
		</xs:annotation>
		<xs:restriction base="xs:NMTOKEN">
			<xs:enumeration value="row">
				<xs:annotation>
					<xs:documentation>Left to right.</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="rowreverse">
				<xs:annotation>
					<xs:documentation>Right to left.</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="column">
				<xs:annotation>
					<xs:documentation>Top to bottom.</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="columnreverse">
				<xs:annotation>
					<xs:documentation>Bottom to top.</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
		</xs:restriction>
	</xs:simpleType>

	<xs:simpleType name="FlexWrap">
		<xs:annotation>
			<xs:documentation>Values for the wrap attribute of flex containers.</xs:documentation>
		</xs:annotation>
		<xs:restriction base="xs:NMTOKEN">
			<xs:enumeration value="nowrap">
				<xs:annotation>
					<xs:documentation>Place all items in one line.</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="wrap">
				<xs:annotation>
					<xs:documentation>Wrap items from top to bottom.</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="wrapreverse">
				<xs:annotation>
					<xs:documentation>Wrap items from bottom to top.</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
		</xs:restriction>
	</xs:simpleType>

	<xs:simpleType name="FlexItemAlignment">
		<xs:annotation>
			<xs:documentation>Alignment of the flex items in a flex container along an axis of the flex container.</xs:documentation>
		</xs:annotation>
		<xs:restriction base="xs:NMTOKEN">
			<xs:enumeration value="stretch">
				<xs:annotation>
					<xs:documentation>Stretch all flex items proportionally so that they completely fill the axis while still respecting their maxwidth or maxheight values.</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="center">
				<xs:annotation>
					<xs:documentation>Center flex items in the middle of the axis.</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="start">
				<xs:annotation>
					<xs:documentation>Align items towards the start of the axis.</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="end">
				<xs:annotation>
					<xs:documentation>Align items towards the end of the axis.</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="spacebetween">
				<xs:annotation>
					<xs:documentation>Distribute the items evenly so that the space between each pair of adjacent items is the same
						and so that there is no space before the first and after the last item.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="spacearound">
				<xs:annotation>
					<xs:documentation>Distribute the items evenly so that the space between each pair of adjacent items is the same
						and the space before the first and after the last item is half the space between each pair of adjacent items.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="spaceevenly">
				<xs:annotation>
					<xs:documentation>Distribute the items evenly so that the space between each pair of adjacent items is the same
						and the space before the first and after the last item is the same as the space between each pair of adjacent items.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
		</xs:restriction>
	</xs:simpleType>

	<xs:simpleType name="FlexItemSimpleAlignment">
		<xs:annotation>
			<xs:documentation>A simple alignment of flex items in a flex container along an axis of the flex container.</xs:documentation>
		</xs:annotation>
		<xs:restriction base="xs:NMTOKEN">
			<xs:enumeration value="stretch">
				<xs:annotation>
					<xs:documentation>Stretch all flex items proportionally so that they completely fill the axis while still respecting their maxwidth or maxheight values.</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="center">
				<xs:annotation>
					<xs:documentation>Center flex items in the middle of the axis.</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="start">
				<xs:annotation>
					<xs:documentation>Align items towards the start of the axis.</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="end">
				<xs:annotation>
					<xs:documentation>Align items towards the end of the axis.</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
		</xs:restriction>
	</xs:simpleType>

	<xs:attributeGroup name="FlexItemAttributes">
		<xs:attribute name="order" type="xs:integer" default="0">
			<xs:annotation>
				<xs:documentation>The order of this item in the flex container.</xs:documentation>
			</xs:annotation>
		</xs:attribute>
		<xs:attribute name="flexgrow" type="xs:decimal" default="0">
			<xs:annotation>
				<xs:documentation>Specifies how much of the remaining space in the flex container should be assigned to this item.</xs:documentation>
			</xs:annotation>
		</xs:attribute>
		<xs:attribute name="flexshrink" type="xs:decimal" default="1">
			<xs:annotation>
				<xs:documentation>Flex shrink factor of this flex item.</xs:documentation>
			</xs:annotation>
		</xs:attribute>
		<xs:attribute name="flexbasis" default="auto">
			<xs:annotation>
				<xs:documentation>Initial main size of this flex item as <a href="#LengthPercentage">length percentage value</a> or "auto", which means that the size
				is automatically calculated.</xs:documentation>
			</xs:annotation>
			<xs:simpleType>
				<xs:union memberTypes="LengthPercentage Auto"/>
			</xs:simpleType>
		</xs:attribute>
		<xs:attribute name="alignself" default="auto">
			<xs:annotation>
				<xs:documentation>When this has a value other than "auto", it overrides this flex item's alignitems value in the surrounding flex container.</xs:documentation>
			</xs:annotation>
			<xs:simpleType>
				<xs:union memberTypes="FlexItemSimpleAlignment Auto"/>
			</xs:simpleType>
		</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.
				Note that attributes such as "format" and "fullnumbering" will be
				inherited if a list occurs inside of another list.
			</xs:documentation>
		</xs:annotation>
		<xs:sequence minOccurs="1" maxOccurs="unbounded">
			<xs:element name="listitem" type="ListItem"/>
		</xs:sequence>
		<xs:attributeGroup ref="CommonContentElementAttributes"/>
		<xs:attribute name="format" type="LabelFormat" use="optional" default="arabic">
			<xs:annotation>
				<xs:documentation>Format used for the automatically generated label of the items in this list.</xs:documentation>
			</xs:annotation>
		</xs:attribute>
		<xs:attribute name="separator" type="xs:string" use="optional" default=".">
			<xs:annotation>
				<xs:documentation>Separator used in the automatically generated label of the items in this list.</xs:documentation>
			</xs:annotation>
		</xs:attribute>
		<xs:attribute name="lastsep" type="xs:boolean" use="optional" default="true">
			<xs:annotation>
				<xs:documentation>Controls whether the last separator should be shown in the automatically generated label of the items in this list.
				</xs:documentation>
			</xs:annotation>
		</xs:attribute>
		<xs:attributeGroup ref="IndentAttribute"/>
		<xs:attribute name="fullnumbering" type="xs:boolean" default="false">
			<xs:annotation>
				<xs:documentation>
					Whether or not the automatically generated labels of a list item of this list should include the
					full numbering of all of its parent navigation items or only its number in the list of the children
					of its parent.
				</xs:documentation>
			</xs:annotation>
		</xs:attribute>
	</xs:complexType>

	<xs:complexType name="ListItem">
		<xs:annotation>
			<xs:documentation>Item of a list.</xs:documentation>
		</xs:annotation>
		<xs:sequence minOccurs="0" maxOccurs="unbounded">
			<xs:group ref="BlockGroup"/>
		</xs:sequence>
		<xs:attributeGroup ref="CommonContentElementAttributes"/>
		<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:complexType>

	<xs:attributeGroup name="RowAttributes">
		<xs:attribute name="valign" type="VerticalAlignment" default="middle">
			<xs:annotation>
				<xs:documentation>Vertical alignment of the cells in this row. Can be overwritten for an individual cell
					in this row by setting the "valign" attribute of the "cell" element to a different value.
					Note: The official default value of the corresponding attribute in CSS is "baseline", but most
					browsers override this value with "middle" in their user agent stylesheets. Therefore, we use
					"middle" as default value.
				</xs:documentation>
			</xs:annotation>
		</xs:attribute>
		<xs:attribute name="minheight" default="auto">
			<xs:annotation>
				<xs:documentation>Minimum height of the table row as <a href="#LengthPercentage">length percentage value</a>.</xs:documentation>
			</xs:annotation>
			<xs:simpleType>
				<xs:union memberTypes="LengthPercentage Auto"/>
			</xs:simpleType>
		</xs:attribute>
	</xs:attributeGroup>

	<xs:complexType name="Row">
		<xs:annotation>
			<xs:documentation>A row that is part of the body of a table. A row consists of a collection of cells.</xs:documentation>
		</xs:annotation>
		<xs:sequence minOccurs="1" maxOccurs="unbounded">
			<xs:element name="cell" type="Cell"/>
		</xs:sequence>
		<xs:attributeGroup ref="CommonContentElementAttributes"/>
		<xs:attributeGroup ref="RowAttributes"/>
	</xs:complexType>

	<xs:complexType name="HeadRow">
		<xs:annotation>
			<xs:documentation>A row of a table that is specified as head of the table.</xs:documentation>
		</xs:annotation>
		<xs:sequence minOccurs="1" maxOccurs="unbounded">
			<xs:element name="cell" type="Cell"/>
		</xs:sequence>
		<xs:attributeGroup ref="CommonContentElementAttributes"/>
		<xs:attributeGroup ref="RowAttributes"/>
		<xs:attribute name="fixed" type="xs:boolean" default="false">
			<xs:annotation>
				<xs:documentation>Whether or not the head row should be fixed when scrolling vertically through a table with a specified maximal height.
				This attribute has no effect when the maxheight attribute of the table is set to none.</xs:documentation>
			</xs:annotation>
		</xs:attribute>
	</xs:complexType>

	<xs:complexType name="Cell">
		<xs:annotation>
			<xs:documentation>A cell of a table row.</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:group ref="BlockGroup" minOccurs="0" maxOccurs="unbounded"/>
		</xs:sequence>
		<xs:attribute name="align" type="HorizontalAlignment">
			<xs:annotation>
				<xs:documentation>Individual horizontal alignment of this cell. If this attribute is set, it takes precedence over
				the <code>align</code> attribute in the <code>colspec</code> element for the column containing this cell.</xs:documentation>
			</xs:annotation>
		</xs:attribute>
		<xs:attribute name="valign" type="VerticalAlignment">
			<xs:annotation>
				<xs:documentation>Individual vertical alignment of this cell. If this attribute is set, it takes precedence over
				the <code>valign</code> attribute of the <code>row</code> element containing this cell.</xs:documentation>
			</xs:annotation>
		</xs:attribute>
	</xs:complexType>

	<xs:complexType name="Table">
		<xs:annotation>
			<xs:documentation>A table consisting of rows and cells. The table layout can be changed with the optional <code>colspecs</code> element.
			</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="colspecs" type="Colspecs" minOccurs="0" maxOccurs="1">
				<xs:unique name="ColspecColumnName">
					<xs:selector xpath="edml:colspec"/>
					<xs:field xpath="@column"/>
				</xs:unique>
			</xs:element>
			<xs:element name="headrow" type="HeadRow" minOccurs="0"/>
			<xs:element name="row" type="Row" maxOccurs="unbounded"/>
		</xs:sequence>
		<xs:attributeGroup ref="CommonContentElementAttributes"/>
		<xs:attributeGroup ref="TableAttributes"/>
	</xs:complexType>

	<xs:complexType name="Colspecs">
		<xs:annotation>
			<xs:documentation>Contains layout specifications of the table columns in a table.
			Every <code>table</code> element can have its own <code>colspecs</code> element.
			The <code>colspec</code> child elements appearing in this element describe the layout of columns in that table.
			Every such element is responsible for one column.
			</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="colspec" type="Colspec" minOccurs="0" maxOccurs="unbounded"/>
		</xs:sequence>
	</xs:complexType>

	<xs:complexType name="Colspec">
		<xs:annotation>
			<xs:documentation>Element used to specify the layout of one column in a table.</xs:documentation>
		</xs:annotation>
		<xs:attribute name="column" type="xs:positiveInteger" use="required">
			<xs:annotation>
				<xs:documentation>The number of the column in the table, from top to bottom starting with one, that this colspec element will affect.</xs:documentation>
			</xs:annotation>
		</xs:attribute>
		<xs:attribute name="align" type="HorizontalAlignment" default="center">
			<xs:annotation>
				<xs:documentation>Horizontal alignment of the cells in this column.
				Can be overwritten for an individual cell in this column by setting the <code>align</code> attribute of the <code>cell</code> element to a different value. </xs:documentation>
			</xs:annotation>
		</xs:attribute>
		<xs:attribute name="minwidth" default="auto">
			<xs:annotation>
				<xs:documentation>Minimum width of the column as <a href="#LengthPercentage">length percentage value</a> or "auto", which means
				that the application will calculate and select a minimum width.</xs:documentation>
			</xs:annotation>
			<xs:simpleType>
				<xs:union memberTypes="LengthPercentage Auto"/>
			</xs:simpleType>
		</xs:attribute>
		<xs:attribute name="maxwidth" default="none">
			<xs:annotation>
				<xs:documentation>Maximum width of the column as <a href="#LengthPercentage">length percentage value</a> or "none", which means
				there should be no limit on the width of the column.</xs:documentation>
			</xs:annotation>
			<xs:simpleType>
				<xs:union memberTypes="LengthPercentage None"/>
			</xs:simpleType>
		</xs:attribute>
		<xs:attribute name="fixed" type="xs:boolean" default="false">
			<xs:annotation>
				<xs:documentation>Whether or not this column should be fixed when scrolling horizontally through the table. This feature is only supported on the first (left most) column.</xs:documentation>
			</xs:annotation>
		</xs:attribute>
		<xs:attribute name="sortedby" default="none">
			<xs:annotation>
				<xs:documentation>When this attribute is set to a value other than none, the table will be sorted accordingly by this column when the page is loaded as long
					as the table is specified as sortable by the sortable attribute on the table. When this attribute is set on more than one column, the column with the highest column number that has this attribute set will be chosen as sort column.
				</xs:documentation>
			</xs:annotation>
			<xs:simpleType>
				<xs:union memberTypes="TableColumnSortingOrder None"/>
			</xs:simpleType>
		</xs:attribute>
	</xs:complexType>

	<xs:simpleType name="TableColumnSortingOrder">
		<xs:annotation>
			<xs:documentation>A way to sort a table by a column.</xs:documentation>
		</xs:annotation>
		<xs:restriction base="xs:NMTOKEN">
			<xs:enumeration value="ascending">
				<xs:annotation>
					<xs:documentation>Sort in ascending order by the inner text of the column entry.</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="descending">
				<xs:annotation>
					<xs:documentation>Sort in descending order by the inner text of the column entry.</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
		</xs:restriction>
	</xs:simpleType>

	<xs:attributeGroup name="TableAttributes">
		<xs:attribute name="border" type="xs:boolean" use="optional" default="true">
			<xs:annotation>
				<xs:documentation xml:lang="en">
					Controls whether this table should have a border.
				</xs:documentation>
				<xs:documentation xml:lang="de">
					Bestimmt, ob die Tabelle einen Rand haben soll.
				</xs:documentation>
			</xs:annotation>
		</xs:attribute>
		<xs:attribute name="striped" default="auto">
			<xs:annotation>
				<xs:documentation>Whether or not the backgrounds of the rows of this table should be alternating between a light and dark color. When set to auto,
					the application will apply a default behavior.</xs:documentation>
			</xs:annotation>
			<xs:simpleType>
				<xs:union memberTypes="xs:boolean Auto"/>
			</xs:simpleType>
		</xs:attribute>
		<xs:attribute name="sortable" type="xs:boolean" default="false">
			<xs:annotation>
				<xs:documentation xml:lang="en">
					Whether or not the user is allowed to sort the table by a column of his or her choice.
				</xs:documentation>
				<xs:documentation xml:lang="de">
					Bestimmt, ob die Tabelle vom Benutzer nach einer auswählbaren Spalte sortiert werden darf.
				</xs:documentation>
			</xs:annotation>
		</xs:attribute>
		<xs:attribute name="maxheight" default="none">
			<xs:annotation>
				<xs:documentation xml:lang="en">
					Maximum height of the table. The special value "none" means that the height of the table will be
					automatically calculated from its content.
				</xs:documentation>
				<xs:documentation xml:lang="de">
					Maximale Höhe der Tabelle. Der Spezialwert "none" bedeutet, dass die Höhe der Tabelle automatisch
					aus ihrem Inhalt ermittelt wird.
				</xs:documentation>
			</xs:annotation>
			<xs:simpleType>
				<xs:union memberTypes="LengthPercentage None"/>
			</xs:simpleType>
		</xs:attribute>
	</xs:attributeGroup>

	<xs:group name="InlineInputValueGroup">
		<xs:choice>
			<!-- General input values -->
			<xs:element name="string" type="StringInputValue" minOccurs="1" maxOccurs="unbounded"/>
			<xs:element name="boolean" type="BooleanInputValue" minOccurs="1" maxOccurs="1"/>
			<xs:element name="choice" type="ChoiceInputValue" minOccurs="1" maxOccurs="1"/>

			<!-- Mathematical input values -->
			<xs:element name="number" type="NumberInputValue" minOccurs="1" maxOccurs="unbounded"/>
			<xs:element name="exponential" type="ExponentialInputValue" minOccurs="1" maxOccurs="unbounded"/>
			<xs:element name="expression" type="ExpressionInputValue" minOccurs="1" maxOccurs="unbounded"/>
			<xs:element name="set" type="SetInputValue" minOccurs="1" maxOccurs="unbounded"/>
			<xs:element name="vector" type="VectorInputValue" minOccurs="1" maxOccurs="unbounded"/>
			<xs:element name="matrix" type="MatrixInputValue" minOccurs="1" maxOccurs="unbounded"/>
			<xs:element name="interval" type="IntervalInputValue" minOccurs="1" maxOccurs="unbounded"/>
			<xs:element name="linearspan" type="LinearSpanInputValue" minOccurs="1" maxOccurs="unbounded"/>
			<xs:element name="affinespace" type="AffineSpaceInputValue" minOccurs="1" maxOccurs="unbounded"/>

			<!-- Natural sciences related input values -->
			<xs:element name="unit" type="UnitInputValue" minOccurs="1" maxOccurs="unbounded"/>
			<xs:element name="quantity" type="QuantityInputValue" minOccurs="1" maxOccurs="unbounded"/>
			<xs:element name="molecular" type="MolecularInputValue" minOccurs="1" maxOccurs="unbounded"/>
		</xs:choice>
	</xs:group>

	<xs:group name="BlockInputValueGroup">
		<xs:choice>
			<xs:element name="order" type="OrderInputValue" minOccurs="1" maxOccurs="1"/>
			<xs:element name="matching" type="MatchingInputValue" minOccurs="1" maxOccurs="1"/>
			<xs:element name="reaction" type="ReactionInputValue" minOccurs="1" maxOccurs="1"/>
			<xs:element name="sourcecode" type="SourceCodeInputValue" minOccurs="1" maxOccurs="1"/>
		</xs:choice>
	</xs:group>

	<xs:attributeGroup name="CommonInputFieldAttributes">
		<xs:attribute name="penalty" type="xs:nonNegativeInteger">
			<xs:annotation>
				<xs:documentation>Number of credit points the user gets deducted for an incorrect solution of this input field.
				When this attribute is not set, the following default behavior applies: For input fields containing boolean input values,
				the default penalty is one, or, if the element is contained in a booleangroup, the default penalty specified in the booleangroup applies.
				For all other input elements, the default penalty is zero.</xs:documentation>
			</xs:annotation>
		</xs:attribute>
		<xs:attribute name="model" type="xs:Name" use="optional">
			<xs:annotation>
				<xs:documentation>Name of the model to use for values in this input field. If this attribute is not set, the default input model is used.</xs:documentation>
			</xs:annotation>
		</xs:attribute>
	</xs:attributeGroup>

	<xs:attributeGroup name="CommonInputElementAttributes">
		<xs:attribute name="check" type="xs:boolean" default="true">
			<xs:annotation>
				<xs:documentation xml:lang="en">
					Whether or not the correctness of the user input in this input element should be checked by the
					player. This is set to true by default.
				</xs:documentation>
				<xs:documentation xml:lang="de">
					Gibt an, ob die Korrektheit der Benutzereingabe in diesem Eingabeelement vom Player überprüft werden
					soll. Diese Einstellung ist standardmäßig aktiviert.
				</xs:documentation>
			</xs:annotation>
		</xs:attribute>
	</xs:attributeGroup>

	<xs:attributeGroup name="RevealAttribute">
		<xs:attribute name="reveal" type="xs:nonNegativeInteger" default="1">
			<xs:annotation>
				<xs:documentation xml:lang="en">
					Number of failed attempts (checking of an incorrect value) after which the user is allowed to see
					the content of the solutionhint element associated with this input element. If there is no
					"solutionhint" element associated to this input element, then the attribute has no effect.
				</xs:documentation>
				<xs:documentation xml:lang="de">
					Anzahl der Fehlversuche (Überprüfungen von falschen Eingaben) nach denen der Benutzer den Inhalt des
					Lösungshinweises, der an dieses Element gebunden ist, anzeigen darf. Falls kein Lösungshinweis an
					dieses Element gebunden ist, das das Attribut keine Auswirkungen.
				</xs:documentation>
			</xs:annotation>
		</xs:attribute>
	</xs:attributeGroup>

	<xs:complexType name="Label" mixed="true">
		<xs:annotation>
			<xs:documentation>
				This element marks its content as a label for the input element specified with the "for" attribute. This
				improves the accessibility of the course. Moreover, for boolean input fields, the user can click on the
				label in addition to the input field itself to change the value of the input field.
			</xs:documentation>
		</xs:annotation>
		<xs:sequence minOccurs="0" maxOccurs="unbounded">
			<xs:group ref="InlineGroup"/>
		</xs:sequence>
		<xs:attributeGroup ref="CommonContentElementAttributes"/>
		<xs:attribute name="for" use="required" type="xs:Name">
			<xs:annotation>
				<xs:documentation xml:lang="en">
					Name of the input element which this label describes.
				</xs:documentation>
				<xs:documentation xml:lang="de">
					Name des Eingabefeldes, welches durch dieses Element beschrieben wird.
				</xs:documentation>
			</xs:annotation>
		</xs:attribute>
	</xs:complexType>

	<xs:complexType name="Button" mixed="true">
		<xs:annotation>
			<xs:documentation>
				A button that can reference a part of the course.
			</xs:documentation>
			<xs:appinfo>
				<sch:pattern>
					<sch:rule context="edml:ref">
						<sch:assert test="not(.//edml:ref | .//edml:link | .//edml:button)">
							Buttons may not contain other reference elements.
						</sch:assert>
					</sch:rule>
				</sch:pattern>
			</xs:appinfo>
		</xs:annotation>
		<xs:sequence minOccurs="0" maxOccurs="unbounded">
			<xs:choice>
				<xs:group ref="InlineGroup"/>
			</xs:choice>
		</xs:sequence>
		<xs:attributeGroup ref="CommonContentElementAttributes"/>
		<xs:attribute name="to" type="xs:Name">
			<xs:annotation>
				<xs:documentation xml:lang="en">
					Name of the target element in the course to which the user is directed when clicking the button.
				</xs:documentation>
				<xs:documentation xml:lang="de">
					Name des Zielelements im Kurs, zu welchem der Nutzer geleitet wird, wenn er auf den Knopf drückt.
				</xs:documentation>
			</xs:annotation>
		</xs:attribute>
	</xs:complexType>

	<xs:complexType name="InlineInput">
		<xs:annotation>
			<xs:documentation>
				Inline element for an input field in which the user can input a value that is checked against the specified solution.
			</xs:documentation>
			<xs:appinfo>
				<edmldoc:property name="solved" datatypes="boolean" examplevalue="true" nullable="true">
					<xs:annotation>
						<xs:documentation>
							Whether or not the input field is completely solved by the user.
						</xs:documentation>
					</xs:annotation>
				</edmldoc:property>
				<edmldoc:property name="type" datatypes="string" examplevalue="vector" nullable="false">
					<xs:annotation>
						<xs:documentation>
							Type of the input field. This is the name of the input value element inside this element.
						</xs:documentation>
					</xs:annotation>
				</edmldoc:property>
			</xs:appinfo>
		</xs:annotation>
		<xs:sequence>
			<xs:group ref="InlineInputValueGroup"/>
		</xs:sequence>
		<xs:attributeGroup ref="CommonContentElementAttributes"/>
		<xs:attributeGroup ref="CommonInputElementAttributes"/>
		<xs:attributeGroup ref="CommonInputFieldAttributes"/>
		<xs:attributeGroup ref="RevealAttribute"/>
		<xs:attribute name="width" use="optional" default="auto">
			<xs:annotation>
				<xs:documentation xml:lang="en">
					Desired width of this input element. The special value "auto" means that the width of the element
					will be calculated automatically.
				</xs:documentation>
				<xs:documentation xml:lang="de">
					Gewünschte Breite des Eingabefeldes. Der Spezialwert "auto" bedeutet, dass die Breite automatisch
					bestimmt wird.
				</xs:documentation>
			</xs:annotation>
			<xs:simpleType>
				<xs:union memberTypes="LengthPercentage Auto"/>
			</xs:simpleType>
		</xs:attribute>
	</xs:complexType>

	<xs:complexType name="BlockInput">
		<xs:annotation>
			<xs:documentation>Block element for user input in which the user has to solve specific problems.</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:group ref="BlockInputValueGroup"/>
		</xs:sequence>
		<xs:attributeGroup ref="CommonContentElementAttributes"/>
		<xs:attributeGroup ref="CommonInputElementAttributes"/>
		<xs:attributeGroup ref="CommonInputFieldAttributes"/>
		<xs:attributeGroup ref="RevealAttribute"/>
		<xs:attribute name="align" type="HorizontalAlignment" default="center">
			<xs:annotation>
				<xs:documentation xml:lang="en">
					Horizontal alignment of the content of this input element.
				</xs:documentation>
				<xs:documentation xml:lang="de">
					Horizontale Ausrichtung des Inhalts in diesem Eingabeelement.
				</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: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: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>Yotta, denoting a factor of 10<sup>24</sup>.</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="Z">
				<xs:annotation>
					<xs:documentation>Zetta, denoting a factor of 10<sup>21</sup>.</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="E">
				<xs:annotation>
					<xs:documentation>Exa, denoting a factor of 10<sup>18</sup>.</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="P">
				<xs:annotation>
					<xs:documentation>Peta, denoting a factor of 10<sup>15</sup>.</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="T">
				<xs:annotation>
					<xs:documentation>Tera, denoting a factor of 10<sup>12</sup>.</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="G">
				<xs:annotation>
					<xs:documentation>Giga, denoting a factor of 10<sup>9</sup>.</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="M">
				<xs:annotation>
					<xs:documentation>Mega, denoting a factor of 10<sup>6</sup>.</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="k">
				<xs:annotation>
					<xs:documentation>Kilo, denoting a factor of 10<sup>3</sup>.</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="h">
				<xs:annotation>
					<xs:documentation>Hecto, denoting a factor of 10<sup>2</sup>.</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="da">
				<xs:annotation>
					<xs:documentation>Deca, denoting a factor of 10.</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="d">
				<xs:annotation>
					<xs:documentation>Deci, denoting a factor of 10<sup>-1</sup>.</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="c">
				<xs:annotation>
					<xs:documentation>Centi, denoting a factor of 10<sup>-2</sup>.</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="m">
				<xs:annotation>
					<xs:documentation>Milli, denoting a factor of 10<sup>-3</sup>.</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="μ">
				<xs:annotation>
					<xs:documentation>Micro, denoting a factor of 10<sup>-6</sup>.</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="n">
				<xs:annotation>
					<xs:documentation>Nano, denoting a factor of 10<sup>-9</sup>.</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="p">
				<xs:annotation>
					<xs:documentation>Pico, denoting a factor of 10<sup>-12</sup>.</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="f">
				<xs:annotation>
					<xs:documentation>Femto, denoting a factor of 10<sup>-15</sup>.</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="a">
				<xs:annotation>
					<xs:documentation>Atto, denoting a factor of 10<sup>-18</sup>.</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="z">
				<xs:annotation>
					<xs:documentation>Zepto, denoting a factor of 10<sup>-21</sup>.</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="y">
				<xs:annotation>
					<xs:documentation>Yocto, denoting a factor of 10<sup>-24</sup>.</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 of a physical unit.</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="g">
				<xs:annotation>
					<xs:documentation>Gram</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:enumeration value="min">
				<xs:annotation>
					<xs:documentation>Minute</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="h">
				<xs:annotation>
					<xs:documentation>Hour</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="d">
				<xs:annotation>
					<xs:documentation>Day</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="B">
				<xs:annotation>
					<xs:documentation>Bell</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:simpleType name="ReactionType">
		<xs:annotation>
			<xs:documentation>Type of a chemical reaction.</xs:documentation>
		</xs:annotation>	
		<xs:restriction base="xs:NMTOKEN">
			<xs:enumeration value="equilibrium">
				<xs:annotation><xs:documentation>A reaction that should be displayed as chemical equilibrium (&#x21CC;).</xs:documentation></xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="forward">
				<xs:annotation><xs:documentation>A reaction that should be displayed as a net foward reaction (&#x2192;).</xs:documentation></xs:annotation>
				</xs:enumeration>
			<xs:enumeration value="reverse">
				<xs:annotation><xs:documentation>A reaction that should be displayed as a reverse reaction (&#x2190;).</xs:documentation></xs:annotation>
				</xs:enumeration>
		</xs:restriction>
	</xs:simpleType>

	<xs:complexType name="StringInputModel">
		<xs:annotation>
			<xs:documentation>
				Settings element inside the <code>inputmodel</code> element which is used to specify the settings for string input fields.
			</xs:documentation>
		</xs:annotation>
		<xs: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" default="unbounded">
			<xs:annotation>
				<xs:documentation xml:lang="en">
					Maximum length of the string that the user may enter.
				</xs:documentation>
				<xs:documentation xml:lang="de">
					Maximale Länge der Zeichenkette, die der Benutzer in das Eingabefeld eingeben darf.
				</xs:documentation>
			</xs:annotation>
			<xs:simpleType>
				<xs:union memberTypes="xs:positiveInteger Unbounded"/>
			</xs:simpleType>
		</xs:attribute>
		<xs:attribute name="casesensitive" type="xs:boolean" default="true">
			<xs:annotation>
				<xs:documentation>Whether or not the solution should be checked in a case sensitive way or not.</xs:documentation>
			</xs:annotation>
		</xs:attribute>
		<xs:attribute name="charactershints" type="xs:boolean" default="false">
			<xs:annotation>
				<xs:documentation>Whether or not to give live hints about the allowed characters when the user has not yet submitted the input value.</xs:documentation>
			</xs:annotation>
		</xs:attribute>
		<xs:attribute name="minlengthhints" type="xs:boolean" default="false">
			<xs:annotation>
				<xs:documentation>Whether or not to give live hints about the allowed minimal length when the user has not yet submitted the input value.</xs:documentation>
			</xs:annotation>
		</xs:attribute>
		<xs:attribute name="maxlengthhints" type="xs:boolean" default="false">
			<xs:annotation>
				<xs:documentation>Whether or not to give live hints about the allowed maximal length when the user has not yet submitted the input value.</xs:documentation>
			</xs:annotation>
		</xs:attribute>
		<xs:attribute name="trim" type="xs:boolean" default="true">
			<xs:annotation>
				<xs:documentation>Whether or not whitespace at the beginning and end of the string (both the user input and the solution string) should be ignored.
				</xs:documentation>
			</xs:annotation>
		</xs:attribute>
	</xs:complexType>

	<xs:complexType name="OrderInputModel">
		<xs:annotation>
			<xs:documentation>
				Settings element inside the <code>inputmodel</code> element which is used to specify the settings for order input fields.
			</xs:documentation>
		</xs:annotation>
	</xs:complexType>

	<xs:complexType name="MatchingInputModel">
		<xs:annotation>
			<xs:documentation>
				Settings element inside the <code>inputmodel</code> element which is used to specify the settings for matching input fields.
			</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="dragitems" minOccurs="0" type="DragItemsModel"/>
			<xs:element name="dropitems" minOccurs="0" type="DropItemsModel"/>
		</xs:sequence>
	</xs:complexType>

	<xs:complexType name="DragItemsModel">
		<xs:annotation>
			<xs:documentation>Model element in which settings of drag items of matching input elements can be changed.</xs:documentation>
		</xs:annotation>
		<xs:attribute name="shuffle" type="xs:boolean" default="false">
			<xs:annotation>
				<xs:documentation>
					Whether or not the drag items should be randomly shuffled each time the page is loaded.
				</xs:documentation>
			</xs:annotation>
		</xs:attribute>
		<xs:attribute name="maxuse" type="xs:positiveInteger" default="1">
			<xs:annotation>
				<xs:documentation>
					Decides how often the user can use each drag item in the matching problem.
				</xs:documentation>
			</xs:annotation>
		</xs:attribute>
	</xs:complexType>

	<xs:complexType name="DropItemsModel">
		<xs:annotation>
			<xs:documentation>Model element in which settings of drop items of matching input elements can be changed.</xs:documentation>
		</xs:annotation>
		<xs:attribute name="shuffle" type="xs:boolean" default="false">
			<xs:annotation>
				<xs:documentation>
					Whether or not the drop items should be randomly shuffled each time the page is loaded.
				</xs:documentation>
			</xs:annotation>
		</xs:attribute>
		<xs:attribute name="maxuse" type="xs:positiveInteger" default="1">
			<xs:annotation>
				<xs:documentation>
					Decides how often the user can use each drop item in the matching problem.
				</xs:documentation>
			</xs:annotation>
		</xs:attribute>
	</xs: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: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: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: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:attribute name="base" default="10" type="NumberBase">
			<xs:annotation>
				<xs:documentation>Base of the standard positional number system in which the number is expected from the user and written in the solution.
				</xs:documentation>
			</xs:annotation>
		</xs:attribute>
		<xs:attribute name="minfracdigits" default="0" type="xs:nonNegativeInteger">
			<xs:annotation>
				<xs:documentation>Minimum number of fractional digits (digits after the radix point) that have to appear in the users input.</xs:documentation>
			</xs:annotation>
		</xs:attribute>
		<xs:attribute name="maxfracdigits" use="optional" default="unbounded">
			<xs:annotation>
				<xs:documentation>Maximum number of fractional digits (digits after the radix point) that are allowed in the users input.</xs:documentation>
			</xs:annotation>
			<xs:simpleType>
				<xs:union memberTypes="xs:nonNegativeInteger Unbounded"/>
			</xs:simpleType>
		</xs:attribute>
		<xs:attribute name="minintdigits" default="0" type="xs:nonNegativeInteger">
			<xs:annotation>
				<xs:documentation>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" default="unbounded">
			<xs:annotation>
				<xs:documentation>Maximum number of integer digits (digits before the radix point) that are allowed in the users input.</xs:documentation>
			</xs:annotation>
			<xs:simpleType>
				<xs:union memberTypes="xs:nonNegativeInteger Unbounded"/>
			</xs:simpleType>
		</xs:attribute>
		<xs:attribute name="minfracdigitshints" type="xs:boolean" default="false">
			<xs:annotation>
				<xs:documentation>Whether or not to give live hints about the minimum number of allowed fractional digits (digits after the radix point)
					when the user has not yet submitted the input value.</xs:documentation>
			</xs:annotation>
		</xs:attribute>
		<xs:attribute name="maxfracdigitshints" type="xs:boolean" default="false">
			<xs:annotation>
				<xs:documentation>Whether or not to give live hints about the maximum number of allowed fractional digits (digits after the radix point)
					when the user has not yet submitted the input value.</xs:documentation>
			</xs:annotation>
		</xs:attribute>
		<xs:attribute name="minintdigitshints" type="xs:boolean" default="false">
			<xs:annotation>
				<xs:documentation>Whether or not to give live hints about the minimum number of allowed integer digits (digits before the radix point)
					when the user has not yet submitted the input value.</xs:documentation>
			</xs:annotation>
		</xs:attribute>
		<xs:attribute name="maxintdigitshints" type="xs:boolean" default="false">
			<xs:annotation>
				<xs:documentation>Whether or not to give live hints about the maximum number of allowed integer digits (digits before the radix point)
					when the user has not yet submitted the input value.</xs:documentation>
			</xs:annotation>
		</xs:attribute>
		<xs:attribute name="lowertolerance" default="0" type="NonNegativeDecimal">
			<xs:annotation>
				<xs:documentation>If this value is LT and the solution is x, then any value between x-LT and x is considered a correct value.</xs:documentation>
			</xs:annotation>
		</xs:attribute>
		<xs:attribute name="uppertolerance" default="0" type="NonNegativeDecimal">
			<xs:annotation>
				<xs:documentation>If this value is UT and the solution is x, then any value between x and x+UT is considered a correct value.</xs:documentation>
			</xs:annotation>
		</xs:attribute>
		<xs:attribute name="lowerreltolerance" default="0" type="NonNegativeDecimal">
			<xs:annotation>
				<xs:documentation>If this value is LRT and the solution is x, then any value between x-LRT*|x| and x is considered a correct value.</xs:documentation>
			</xs:annotation>
		</xs:attribute>
		<xs:attribute name="upperreltolerance" default="0" type="NonNegativeDecimal">
			<xs:annotation>
				<xs:documentation>If this value is URT and the solution is x, then any value between x and x+URT*|x| is considered a correct value.</xs:documentation>
			</xs:annotation>
		</xs:attribute>
		<xs:attributeGroup ref="SignificantModelAttributes"/>
	</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:sequence>
			<xs:element name="mantissa" minOccurs="0" type="MantissaInputModel"/>
			<xs:element name="exponent" minOccurs="0" type="ExponentInputModel"/>
		</xs:sequence>
		<xs:attribute name="base" default="10" type="xs:positiveInteger">
			<xs:annotation>
				<xs:documentation>The base which is used to describe the number.</xs:documentation>
			</xs:annotation>
		</xs:attribute>
		<xs:attribute name="lowertolerance" default="0" type="NonNegativeDecimal">
			<xs:annotation>
				<xs:documentation>If this value is LT and the solution is x, then any value between x-LT and x is considered a correct value.</xs:documentation>
			</xs:annotation>
		</xs:attribute>
		<xs:attribute name="uppertolerance" default="0" type="NonNegativeDecimal">
			<xs:annotation>
				<xs:documentation>If this value is UT and the solution is x, then any value between x and x+UT is considered a correct value.</xs:documentation>
			</xs:annotation>
		</xs:attribute>
		<xs:attribute name="lowerreltolerance" default="0" type="NonNegativeDecimal">
			<xs:annotation>
				<xs:documentation>If this value is LRT and the solution is x, then any value between x-LRT*|x| and x is considered a correct value.</xs:documentation>
			</xs:annotation>
		</xs:attribute>
		<xs:attribute name="upperreltolerance" default="0" type="NonNegativeDecimal">
			<xs:annotation>
				<xs:documentation>If this value is URT and the solution is x, then any value between x and x+URT*|x| is considered a correct value.</xs:documentation>
			</xs:annotation>
		</xs:attribute>
		<xs:attribute name="scientific" type="xs:boolean" default="false">
			<xs:annotation>
				<xs:documentation>
					When set to true, the mantissa in the user input must be between 1.0 (inclusive) and 10.0
					(exclusive) for the input to be correct.
				</xs:documentation>
			</xs:annotation>
		</xs:attribute>
		<xs:attribute name="engineering" type="xs:boolean" default="false">
			<xs:annotation>
				<xs:documentation>
					When set to true, the exponent in the user input must be a whole number divisible by 3 for the
					input to be correct.
				</xs:documentation>
			</xs:annotation>
		</xs:attribute>
	</xs:complexType>

	<xs:complexType name="MantissaInputModel">
		<xs:annotation>
			<xs:documentation>Settings element inside the <code>exponential</code> input model which is used to specify attributes for the mantissa
			of exponential input fields.</xs:documentation>
		</xs:annotation>
		<xs:attribute name="minfracdigits" default="0" type="xs:nonNegativeInteger">
			<xs:annotation>
				<xs:documentation>Minimum number of fractional digits (digits after the radix point) that have to appear in the users input.</xs:documentation>
			</xs:annotation>
		</xs:attribute>
		<xs:attribute name="maxfracdigits" use="optional" default="unbounded">
			<xs:annotation>
				<xs:documentation>Maximum number of fractional digits (digits after the radix point) that are allowed in the users input.</xs:documentation>
			</xs:annotation>
			<xs:simpleType>
				<xs:union memberTypes="xs:nonNegativeInteger Unbounded"/>
			</xs:simpleType>
		</xs:attribute>
		<xs:attribute name="minintdigits" default="0" type="xs:nonNegativeInteger">
			<xs:annotation>
				<xs:documentation>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" default="unbounded">
			<xs:annotation>
				<xs:documentation>Maximum number of integer digits (digits before the radix point) that are allowed in the users input.</xs:documentation>
			</xs:annotation>
			<xs:simpleType>
				<xs:union memberTypes="xs:nonNegativeInteger Unbounded"/>
			</xs:simpleType>
		</xs:attribute>
		<xs:attribute name="minfracdigitshints" type="xs:boolean" default="false">
			<xs:annotation>
				<xs:documentation>Whether or not to give live hints about the minimum number of allowed fractional digits (digits after the radix point)
					when the user has not yet submitted the input value.</xs:documentation>
			</xs:annotation>
		</xs:attribute>
		<xs:attribute name="maxfracdigitshints" type="xs:boolean" default="false">
			<xs:annotation>
				<xs:documentation>Whether or not to give live hints about the maximum number of allowed fractional digits (digits after the radix point)
					when the user has not yet submitted the input value.</xs:documentation>
			</xs:annotation>
		</xs:attribute>
		<xs:attribute name="minintdigitshints" type="xs:boolean" default="false">
			<xs:annotation>
				<xs:documentation>Whether or not to give live hints about the minimum number of allowed integer digits (digits before the radix point)
					when the user has not yet submitted the input value.</xs:documentation>
			</xs:annotation>
		</xs:attribute>
		<xs:attribute name="maxintdigitshints" type="xs:boolean" default="false">
			<xs:annotation>
				<xs:documentation>Whether or not to give live hints about the maximum number of allowed integer digits (digits before the radix point)
					when the user has not yet submitted the input value.</xs:documentation>
			</xs:annotation>
		</xs:attribute>
		<xs:attribute name="lowertolerance" default="0" type="NonNegativeDecimal">
			<xs:annotation>
				<xs:documentation>If this value is LT and the solution is x, then any value between x-LT and x is considered a correct value.</xs:documentation>
			</xs:annotation>
		</xs:attribute>
		<xs:attribute name="uppertolerance" default="0" type="NonNegativeDecimal">
			<xs:annotation>
				<xs:documentation>If this value is UT and the solution is x, then any value between x and x+UT is considered a correct value.</xs:documentation>
			</xs:annotation>
		</xs:attribute>
		<xs:attribute name="lowerreltolerance" default="0" type="NonNegativeDecimal">
			<xs:annotation>
				<xs:documentation>If this value is LRT and the solution is x, then any value between x-LRT*|x| and x is considered a correct value.</xs:documentation>
			</xs:annotation>
		</xs:attribute>
		<xs:attribute name="upperreltolerance" default="0" type="NonNegativeDecimal">
			<xs:annotation>
				<xs:documentation>If this value is URT and the solution is x, then any value between x and x+URT*|x| is considered a correct value.</xs:documentation>
			</xs:annotation>
		</xs:attribute>
		<xs:attributeGroup ref="SignificantModelAttributes"/>
	</xs:complexType>

	<xs:complexType name="ExponentInputModel">
		<xs:annotation>
			<xs:documentation>Settings element inside the <code>exponential</code> input model which is used to specify attributes for the exponent
				of exponential input fields.</xs:documentation>
		</xs:annotation>
		<xs:attribute name="minfracdigits" default="0" type="xs:nonNegativeInteger">
			<xs:annotation>
				<xs:documentation>Minimum number of fractional digits (digits after the radix point) that have to appear in the users input.</xs:documentation>
			</xs:annotation>
		</xs:attribute>
		<xs:attribute name="maxfracdigits" use="optional" default="unbounded">
			<xs:annotation>
				<xs:documentation>Maximum number of fractional digits (digits after the radix point) that are allowed in the users input.</xs:documentation>
			</xs:annotation>
			<xs:simpleType>
				<xs:union memberTypes="xs:nonNegativeInteger Unbounded"/>
			</xs:simpleType>
		</xs:attribute>
		<xs:attribute name="minintdigits" default="0" type="xs:nonNegativeInteger">
			<xs:annotation>
				<xs:documentation>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" default="unbounded">
			<xs:annotation>
				<xs:documentation>Maximum number of integer digits (digits before the radix point) that are allowed in the users input.</xs:documentation>
			</xs:annotation>
			<xs:simpleType>
				<xs:union memberTypes="xs:nonNegativeInteger Unbounded"/>
			</xs:simpleType>
		</xs:attribute>
		<xs:attribute name="minfracdigitshints" type="xs:boolean" default="false">
			<xs:annotation>
				<xs:documentation>Whether or not to give live hints about the minimum number of allowed fractional digits (digits after the radix point)
					when the user has not yet submitted the input value.</xs:documentation>
			</xs:annotation>
		</xs:attribute>
		<xs:attribute name="maxfracdigitshints" type="xs:boolean" default="false">
			<xs:annotation>
				<xs:documentation>Whether or not to give live hints about the maximum number of allowed fractional digits (digits after the radix point)
					when the user has not yet submitted the input value.</xs:documentation>
			</xs:annotation>
		</xs:attribute>
		<xs:attribute name="minintdigitshints" type="xs:boolean" default="false">
			<xs:annotation>
				<xs:documentation>Whether or not to give live hints about the minimum number of allowed integer digits (digits before the radix point)
					when the user has not yet submitted the input value.</xs:documentation>
			</xs:annotation>
		</xs:attribute>
		<xs:attribute name="maxintdigitshints" type="xs:boolean" default="false">
			<xs:annotation>
				<xs:documentation>Whether or not to give live hints about the maximum number of allowed integer digits (digits before the radix point)
					when the user has not yet submitted the input value.</xs:documentation>
			</xs:annotation>
		</xs:attribute>
		<xs:attribute name="lowertolerance" default="0" type="NonNegativeDecimal">
			<xs:annotation>
				<xs:documentation>If this value is LT and the solution is x, then any value between x-LT and x is considered a correct value.</xs:documentation>
			</xs:annotation>
		</xs:attribute>
		<xs:attribute name="uppertolerance" default="0" type="NonNegativeDecimal">
			<xs:annotation>
				<xs:documentation>If this value is UT and the solution is x, then any value between x and x+UT is considered a correct value.</xs:documentation>
			</xs:annotation>
		</xs:attribute>
		<xs:attribute name="lowerreltolerance" default="0" type="NonNegativeDecimal">
			<xs:annotation>
				<xs:documentation>If this value is LRT and the solution is x, then any value between x-LRT*|x| and x is considered a correct value.</xs:documentation>
			</xs:annotation>
		</xs:attribute>
		<xs:attribute name="upperreltolerance" default="0" type="NonNegativeDecimal">
			<xs:annotation>
				<xs:documentation>If this value is URT and the solution is x, then any value between x and x+URT*|x| is considered a correct value.</xs:documentation>
			</xs:annotation>
		</xs:attribute>
		<xs:attributeGroup ref="SignificantModelAttributes"/>
	</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:attribute name="useonly" use="optional" default="all">
			<xs:annotation>
				<xs:documentation>Whitespace-separated list of expression node types that are allowed to appear in the expression or the special value "all",
					which means that all types are allowed.
				</xs:documentation>
			</xs:annotation>
			<xs:simpleType>
				<xs:union memberTypes="ExpressionNodeTypeList All"/>
			</xs:simpleType>
		</xs:attribute>
		<xs:attribute name="usenot" default="" type="ExpressionNodeTypeList">
			<xs:annotation>
				<xs:documentation>Whitespace-separated list of expression node types that are forbidden to occur in the expression.</xs:documentation>
			</xs:annotation>
		</xs:attribute>
		<xs:attribute name="useonce" default="" type="ExpressionNodeTypeList">
			<xs:annotation>
				<xs:documentation>Whitespace-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" default="all">
			<xs:annotation>
				<xs:documentation>Whitespace-separated list of expression node types that are allowed for the root node of the expression,
					or the special value "all" which means that all types are allowed for the root element.
				</xs:documentation>
			</xs:annotation>
			<xs:simpleType>
				<xs:union memberTypes="ExpressionNodeTypeList All"/>
			</xs:simpleType>
		</xs:attribute>
		<xs:attribute name="simplified" default="false" type="xs:boolean">
			<xs:annotation>
				<xs:documentation>If this attribute is set to true, the expression entered by the user must be simplified for this field to be correct.
					This means that the collections of node types and node values appearing in the user expression tree and the expression tree of its simplification
					must agree without order but with counting.
				</xs:documentation>
			</xs:annotation>
		</xs:attribute>
		<xs:attribute name="expanded" default="false" type="xs:boolean">
			<xs:annotation>
				<xs:documentation>If this attribute is set to true, the expression entered by the user must be fully expanded for this field to be correct.
					This means that the collections of node types and node values appearing in the user expression tree and the expression tree of its expanded form
					must agree without order but with counting.
				</xs:documentation>
			</xs:annotation>
		</xs:attribute>
		<xs:attribute name="testmode" type="ExpressionTestMode" default="equality">
			<xs:annotation>
				<xs:documentation>The test mode defines in what way the expression entered by the user is compared with the expression in the solution. By default, they must be equal.</xs:documentation>
			</xs:annotation>
		</xs:attribute>
	</xs:complexType>

	<xs:simpleType name="ExpressionTestMode">
		<xs:annotation>
			<xs:documentation>An expression test mode defines in what way the expression entered by the user in an expression field is compared with the expression in the solution.</xs:documentation>
		</xs:annotation>
		<xs:union memberTypes="SimpleExpressionTestMode DerivativeExpressionTestMode"/>
	</xs:simpleType>

	<xs:simpleType name="SimpleExpressionTestMode">
		<xs:annotation>
			<xs:documentation>A simple test mode two compare an expression entered by the user with the solution of an expression input field.</xs:documentation>
		</xs:annotation>
		<xs:restriction base="xs:NMTOKEN">
			<xs:enumeration value="equality">
				<xs:annotation>
					<xs:documentation>Test whether the expression entered by the user and the solution expression yield the same values for all variable values.</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="verbatim">
				<xs:annotation>
					<xs:documentation>Test whether the expression entered by the user is structurally equal to the solution expression.
						This means that the collections of node types and node values appearing in the user expression tree and the solution expression tree
						must agree without order but with counting.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
		</xs:restriction>
	</xs:simpleType>

	<xs:simpleType name="DerivativeExpressionTestMode">
		<xs:annotation>
			<xs:documentation>A test mode for an expression input field where the user expression and the solution expression must have the same derivatives.
				It must be a string of the form "derivative by x" where "x" is the variable with respect to which the derivatives shall be taken.</xs:documentation>
		</xs:annotation>
		<xs:restriction base="xs:NMTOKENS">
			<xs:pattern value="derivative by ([a-z]|[A-Z])+"/>
		</xs:restriction>
	</xs:simpleType>

	<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: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" default="unbounded">
			<xs:annotation>
				<xs:documentation>Maximum number of elements that the user may put into the set or "unbounded", which means that
					there should be no upper bound on the size of the set.
				</xs:documentation>
			</xs:annotation>
			<xs:simpleType>
				<xs:union memberTypes="xs:positiveInteger Unbounded"/>
			</xs:simpleType>
		</xs:attribute>
		<xs:attribute name="of" use="optional" default="auto">
			<xs:annotation>
				<xs:documentation>Whitespace-separated list of allowed element types that the user may put into this set or "auto", which means that
					the system will look for all element types that appear in the solution and allow only these.</xs:documentation>
			</xs:annotation>
			<xs:simpleType>
				<xs:union memberTypes="SetElementValueTypeList Auto"/>
			</xs:simpleType>
		</xs:attribute>
		<xs:attribute name="minsizehints" type="xs:boolean" default="false">
			<xs:annotation>
				<xs:documentation>Whether or not to give live hints about the allowed minimum size of the set
					when the user has not yet submitted the input value.
				</xs:documentation>
			</xs:annotation>
		</xs:attribute>
		<xs:attribute name="maxsizehints" type="xs:boolean" default="false">
			<xs:annotation>
				<xs:documentation>Whether or not to give live hints about the allowed maximum size of the set
					when the user has not yet submitted the input value.
				</xs:documentation>
			</xs:annotation>
		</xs:attribute>
		<xs:attribute name="ofhints" type="xs:boolean" default="false">
			<xs:annotation>
				<xs:documentation>Whether or not to give live hints about the allowed element types in the set
					when the user has not yet submitted the input value.
				</xs:documentation>
			</xs:annotation>
		</xs:attribute>
	</xs: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:attribute name="minsize" type="xs:positiveInteger" default="1">
			<xs:annotation>
				<xs:documentation>Minimum number of components in this vector.</xs:documentation>
			</xs:annotation>
		</xs:attribute>
		<xs:attribute name="maxsize" default="unbounded">
			<xs:annotation>
				<xs:documentation>Maximum number of components in this vector or the special value "unbounded", which means that there is no upper bound on the
					size of the vector.
				</xs:documentation>
			</xs:annotation>
			<xs:simpleType>
				<xs:union memberTypes="xs:positiveInteger Unbounded"/>
			</xs:simpleType>
		</xs:attribute>
		<xs:attribute name="defaultsize" default="auto">
			<xs:annotation>
				<xs:documentation>Initial number of components in this vector that are already there when the user
					loads the page. When this attribute is set to auto, the default size is the size of the first vector
					written as solution in this input value element.</xs:documentation>
			</xs:annotation>
			<xs:simpleType>
				<xs:union memberTypes="xs:positiveInteger Auto"/>
			</xs:simpleType>
		</xs:attribute>
		<xs:attribute name="type" type="VectorType" default="column">
			<xs:annotation>
				<xs:documentation>Type of the vector (column vector or row vector).</xs:documentation>
			</xs:annotation>
		</xs:attribute>
	</xs:complexType>

	<xs:simpleType name="VectorType">
		<xs:annotation>
			<xs:documentation>Type of a vector (column vector or row vector).</xs:documentation>
		</xs:annotation>
		<xs:restriction base="xs:NMTOKEN">
			<xs:enumeration value="column">
				<xs:annotation>
					<xs:documentation>Column vector</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="row">
				<xs:annotation>
					<xs:documentation>Row vector</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
		</xs:restriction>
	</xs:simpleType>

	<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:attribute name="minrows" type="xs:positiveInteger" default="1">
			<xs:annotation>
				<xs:documentation>Minimum number of rows that the user is allowed to put in the matrix.</xs:documentation>
			</xs:annotation>
		</xs:attribute>
		<xs:attribute name="maxrows" default="unbounded">
			<xs:annotation>
				<xs:documentation>Maximum number of rows that the user is allowed to put in the matrix.</xs:documentation>
			</xs:annotation>
			<xs:simpleType>
				<xs:union memberTypes="xs:positiveInteger Unbounded"/>
			</xs:simpleType>
		</xs:attribute>
		<xs:attribute name="defaultrows" default="auto">
			<xs:annotation>
				<xs:documentation>Initial number of rows in this matrix that are already there when the user loads
					the page. When this attribute is set to auto, the matrix initially has as many rows as the first
					matrix written as solution in this input value element.</xs:documentation>
			</xs:annotation>
			<xs:simpleType>
				<xs:union memberTypes="xs:positiveInteger Auto"/>
			</xs:simpleType>
		</xs:attribute>
		<xs:attribute name="mincolumns" type="xs:positiveInteger" default="1">
			<xs:annotation>
				<xs:documentation>Minimum number of columns that the user is allowed to put in the matrix.</xs:documentation>
			</xs:annotation>
		</xs:attribute>
		<xs:attribute name="maxcolumns" default="unbounded">
			<xs:annotation>
				<xs:documentation>Maximum number of columns that the user is allowed to put in the matrix.</xs:documentation>
			</xs:annotation>
			<xs:simpleType>
				<xs:union memberTypes="xs:positiveInteger Unbounded"/>
			</xs:simpleType>
		</xs:attribute>
		<xs:attribute name="defaultcolumns" default="auto">
			<xs:annotation>
				<xs:documentation>Initial number of columns in this matrix that are already there when the user loads
					the page. When this attribute is set to auto, the matrix initially has as many columns as the first
					matrix written as solution in this input value element.</xs:documentation>
			</xs:annotation>
			<xs:simpleType>
				<xs:union memberTypes="xs:positiveInteger Auto"/>
			</xs:simpleType>
		</xs:attribute>
	</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:attribute name="closure" type="IntervalClosureType" default="closed">
			<xs:annotation>
				<xs:documentation>Specifies the correct type of the interval. This decides which of its endpoints should belong to it.</xs:documentation>
			</xs:annotation>
		</xs:attribute>
		<xs:attribute name="fixclosure" type="xs:boolean" default="false">
			<xs:annotation>
				<xs:documentation>
					Specifies whether the interval type should be already filled in for the user with the type defined in the "closed" attribute.
					If this attribute is set to true, the user can not change the interval type.
					Otherwise, the user has to specify the interval type on his or her own.
				</xs:documentation>
			</xs:annotation>
		</xs:attribute>
	</xs:complexType>

	<xs:complexType name="LinearSpanInputModel">
		<xs:annotation>
			<xs:documentation>
				Settings element inside the <code>inputmodel</code> element which is used to specify the settings for <code>linearspan</code> input fields.
			</xs:documentation>
		</xs:annotation>
		<xs:attribute name="maxvectorcount" default="unbounded">
			<xs:annotation>
				<xs:documentation>Maximum number of vectors that are allowed to be present in the collection of spanning
					vectors entered by the user in order for this field to be correct.</xs:documentation>
			</xs:annotation>
			<xs:simpleType>
				<xs:union memberTypes="xs:positiveInteger Unbounded"/>
			</xs:simpleType>
		</xs:attribute>
		<xs:attribute name="minvectorcount" type="xs:nonNegativeInteger" default="0">
			<xs:annotation>
				<xs:documentation>Minimum number of vectors that have to be present in the collection of spanning
					vectors entered by the user in order for this field to be correct.</xs:documentation>
			</xs:annotation>
		</xs:attribute>
		<xs:attribute name="basis" type="xs:boolean" default="false">
			<xs:annotation>
				<xs:documentation xml:lang="en">
					Whether or not the vectors entered by the user must be linearly independent, in addition to the
					other conditions, for this input field to be correct.
				</xs:documentation>
				<xs:documentation xml:lang="de">
					Gibt an, ob die vom Nutzer eingegebenen Vektoren, zusätzlich zu den anderen Bedingungen, linear
					unabhängig sein müssen, damit dieses Eingabefeld als richtig ausgefüllt gilt.
				</xs:documentation>
			</xs:annotation>
		</xs:attribute>
		<xs:attribute name="orthogonal" type="xs:boolean" default="false">
			<xs:annotation>
				<xs:documentation xml:lang="en">
					Whether or not the vectors entered by the user must be pairwise orthogonal with respect
					to the standard inner product, in addition to the other conditions, for this input field to be
					correct.
				</xs:documentation>
				<xs:documentation xml:lang="de">
					Gibt an, ob die vom Nutzer eingegebenen Vektoren, zusätzlich zu den anderen Bedingungen, paarweise
					orthogonal bezüglich des Standardskalarproduktes sein müssen, damit dieses Eingabefeld als richtig
					ausgefüllt gilt.
				</xs:documentation>
			</xs:annotation>
		</xs:attribute>
		<xs:attribute name="normed" type="xs:boolean" default="false">
			<xs:annotation>
				<xs:documentation xml:lang="en">
					Whether or not the vectors entered by the user must be normed, that is, have Euclidean length one,
					in addition to the other conditions, for this input field to be correct.
				</xs:documentation>
				<xs:documentation xml:lang="de">
					Gibt an, ob die vom Nutzer eingegebenen Vektoren, zusätzlich zu den anderen Bedingungen, die
					Euklidische Länge Eins haben müssen, damit dieses Eingabefeld als richtig ausgefüllt gilt.
				</xs:documentation>
			</xs:annotation>
		</xs:attribute>
		<xs:attribute name="flexvectorsize" type="xs:boolean" default="false">
			<xs:annotation>
				<xs:documentation xml:lang="en">
					When this attribute is set to true, the user must select and find out the size of the vectors in the
					subspace (their number of components) on his or her own. Otherwise, the size is fixed as in the
					solution.
				</xs:documentation>
				<xs:documentation xml:lang="de">
					Bestimmt darüber, ob der Nutzer die Größe der Vektoren im Unterraum selbst herausfinden muss und
					einstellen kann. Wenn das Attribut deaktiviert ist, ist die Größe der Vektoren fest vorgegeben wie
					in der Lösung.
				</xs:documentation>
			</xs:annotation>
		</xs:attribute>
	</xs:complexType>

	<xs:complexType name="AffineSpaceInputModel">
		<xs:annotation>
			<xs:documentation>Settings element inside the <code>inputmodel</code> element which is used to specify the settings for <code>affinespace</code> input fields.
			</xs:documentation>
		</xs:annotation>
	</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:attribute name="useonly" default="all">
			<xs:annotation>
				<xs:documentation>
					Whitespace-separated list of unit symbols that the user is allowed to use,
					or the special value "all", which means that all unit symbols are allowed.
				</xs:documentation>
			</xs:annotation>
			<xs:simpleType>
				<xs:union memberTypes="UnitSymbolList All"/>
			</xs:simpleType>
		</xs:attribute>
		<xs:attribute name="usenot" type="UnitSymbolList" default="">
			<xs:annotation>
				<xs:documentation>
					Whitespace-separated list of unit symbols that the user is forbidden to use.
				</xs:documentation>
			</xs:annotation>
		</xs:attribute>
		<xs:attribute name="prefixes" default="all">
			<xs:annotation>
				<xs:documentation>
					Whitespace-separated list of unit prefixes that the user is allowed to use,
					or the special value "all", which means that all unit prefixes are allowed.
				</xs:documentation>
			</xs:annotation>
			<xs:simpleType>
				<xs:union memberTypes="UnitPrefixList All"/>
			</xs:simpleType>
		</xs:attribute>
		<xs:attribute name="useonlyhints" type="xs:boolean" default="false">
			<xs:annotation>
				<xs:documentation>Whether or not to give live hints about the list of allowed unit symbols
					when the user has not yet submitted the input value.</xs:documentation>
			</xs:annotation>
		</xs:attribute>
		<xs:attribute name="usenothints" type="xs:boolean" default="false">
			<xs:annotation>
				<xs:documentation>Whether or not to give live hints about the list of forbidden unit symbols
					when the user has not yet submitted the input value.</xs:documentation>
			</xs:annotation>
		</xs:attribute>
		<xs:attribute name="prefixeshints" type="xs:boolean" default="false">
			<xs:annotation>
				<xs:documentation>Whether or not to give live hints about the list of allowed unit prefixes
					when the user has not yet submitted the input value.</xs:documentation>
			</xs:annotation>
		</xs:attribute>
		<xs:attribute name="preferredforms" default="none">
			<xs:annotation>
				<xs:documentation>Either the special value none or a whitespace-separated list of preferred unit values. When such a list of unit values is given, the user
					is expected to enter exactly one of these. If a unit value which is equivalent to the solution is entered but which is not
					in the list, a warning is shown to the user but the input field is considered correct.</xs:documentation>
			</xs:annotation>
			<xs:simpleType>
				<xs:union memberTypes="UnitValueList None"/>
			</xs:simpleType>
		</xs:attribute>
	</xs:complexType>

	<xs:attributeGroup name="SignificantValueAttributes">
		<xs:attribute name="significant">
			<xs:annotation>
				<xs:documentation>
					When set to a value different to none, this attribute defines the number of significant digits that are expected from
					the user in order for the input to be correct. The significant digits are counted from left to right.
					The treatment of trailing zeros in whole numbers in the user input can be controlled with the signifciancecheck attribute.
				</xs:documentation>
				<xs:appinfo>
					<edmldoc:modelattribute/>
				</xs:appinfo>
			</xs:annotation>
			<xs:simpleType>
				<xs:union memberTypes="xs:positiveInteger None"/>
			</xs:simpleType>
		</xs:attribute>
		<xs:attribute name="significancecheck" type="SignificanceCheckMode">
			<xs:annotation>
				<xs:documentation>
					Controls whether, when the significant attribute is set to a value different to none, trailing zeros in whole numbers in
					the user input should be counted as significant whenever this makes the input correct (lax mode) or not (strict mode).
				</xs:documentation>
				<xs:appinfo>
					<edmldoc:modelattribute/>
				</xs:appinfo>
			</xs:annotation>
		</xs:attribute>
	</xs:attributeGroup>

	<xs:attributeGroup name="SignificantModelAttributes">
		<xs:attribute name="significant" default="none">
			<xs:annotation>
				<xs:documentation>
					When set to a value different to none, this attribute defines the number of significant digits that are expected from
					the user in order for the input to be correct. The significant digits are counted from left to right.
					The treatment of trailing zeros in whole numbers in the user input can be controlled with the significancecheck attribute.
				</xs:documentation>
			</xs:annotation>
			<xs:simpleType>
				<xs:union memberTypes="xs:positiveInteger None"/>
			</xs:simpleType>
		</xs:attribute>
		<xs:attribute name="significancecheck" type="SignificanceCheckMode" default="lax">
			<xs:annotation>
				<xs:documentation>
					Controls whether, when the significant attribute is set to a value different to none, trailing zeros in whole numbers in
					the user input should be counted as significant whenever this makes the input correct (lax mode) or not (strict mode).
				</xs:documentation>
			</xs:annotation>
		</xs:attribute>
	</xs:attributeGroup>

	<xs:simpleType name="SignificanceCheckMode">
		<xs:annotation>
			<xs:documentation>
				Check mode that decides how the significance of a user input is checked against the wanted significance specified in the input field.
			</xs:documentation>
		</xs:annotation>
		<xs:restriction base="xs:NMTOKEN">
			<xs:enumeration value="lax">
				<xs:annotation>
					<xs:documentation>
						In the lax mode, trailing zeros in whole numbers in the user input are counted as significant whenever this makes the
						input correct. This essentially means that the significance of the user input is considered as a set of digit numbers
						instead of a single number of digits and the system chooses the best fitting one.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="strict">
				<xs:annotation>
					<xs:documentation>
						In the strict mode, trailing zeros in whole numbers in the user input are always counted as non-significant. This means that the
						significance of the user input is always a well-defined number of digits that has to agree exactly with
						the wanted significance specified in the input field.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
		</xs:restriction>
	</xs:simpleType>

	<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: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:complexType>

	<xs:complexType name="ReactionInputModel">
		<xs:annotation>
			<xs:documentation>
				Settings element inside the <code>inputmodel</code> element which is used to specify the settings for
				reaction input fields. The settings related to educts and products (such as the fixing of their numbers)
				can be specified by adding the respective child element and specifying the attributes there.
			</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="educts" type="ReactionEductsModel" minOccurs="0"/>
			<xs:element name="products" type="ReactionProductsModel" minOccurs="0"/>
		</xs:sequence>
		<xs:attribute name="type" type="ReactionType" default="equilibrium">
			<xs:annotation>
				<xs:documentation>Describes the type of the chemical reaction. This decides what symbol is placed between the educts and the products.</xs:documentation>
			</xs:annotation>
		</xs:attribute>
		<xs:attribute name="reduced" type="xs:boolean" default="false">
			<xs:annotation>
				<xs:documentation>Whether or not the user should be force to reduce the entered coefficients in this reaction to the smallest
					possible positive integers.</xs:documentation>
			</xs:annotation>
		</xs:attribute>
	</xs:complexType>

	<xs:complexType name="SourceCodeInputModel">
		<xs:annotation>
			<xs:documentation>
				Settings element inside the <code>inputmodel</code> element which is used to specify the settings for source code input fields.
			</xs:documentation>
		</xs:annotation>
		<xs:attribute name="type" default="file" type="SourceCodeInputType">
			<xs:annotation>
				<xs:documentation>Controls what kind of source code input is expected: Multiple source code files (project), only one source code file (file), several
					functions (functions) or statements (statements).</xs:documentation>
			</xs:annotation>
		</xs:attribute>
	</xs:complexType>

	<xs:complexType name="StringInputValue">
		<xs:annotation>
			<xs:documentation>
				Input value inside an <code>input</code> element representing a string, such as "Hello World!".
				By the default, the user input and the solution string are trimmed (whitespace at the beginning and end is removed) before they
				are compared. This can be changed with the <code>trim</code> attribute. Whitespace in the middle of the string
				is respected both in the solution and the user input. Newline characters are ignored and cannot be inserted by the user.
			</xs:documentation>
			<xs:appinfo>
				<edmldoc:property name="value" datatypes="string" examplevalue="Hello World" nullable="true">
					<xs:annotation>
						<xs:documentation>
							String entered by the user.
						</xs:documentation>
					</xs:annotation>
				</edmldoc:property>
				<sch:pattern>
					<sch:rule context="edml:string[@minlength][@maxlength]">
						<sch:assert test="@maxlength = 'unbounded' or @minlength &lt;= @maxlength">
							The minlength attribute value of a string element must be less than or equal to the maxlength attribute value.
						</sch:assert>
					</sch:rule>
				</sch:pattern>
			</xs:appinfo>
		</xs:annotation>
		<xs:simpleContent>
			<xs:extension base="xs:string">
				<xs:attributeGroup ref="CommonInputValueAttributes"/>
				<xs:attribute name="cloze" type="xs:boolean" use="optional">
					<xs:annotation>
						<xs:documentation>Controls whether or not the string field should be displayed like an item of a cloze test.</xs:documentation>
						<xs:appinfo>
							<edmldoc:modelattribute/>
						</xs:appinfo>
					</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:appinfo>
							<edmldoc:modelattribute/>
						</xs:appinfo>
					</xs:annotation>
				</xs:attribute>
				<xs:attribute name="minlength" type="xs:nonNegativeInteger">
					<xs:annotation>
						<xs:documentation>Minimum length of the string that the user may enter.</xs:documentation>
						<xs:appinfo>
							<edmldoc:modelattribute/>
						</xs:appinfo>
					</xs:annotation>
				</xs:attribute>
				<xs:attribute name="maxlength" use="optional">
					<xs:annotation>
						<xs:documentation>Maximum length of the string that the user may enter.</xs:documentation>
						<xs:appinfo>
							<edmldoc:modelattribute/>
						</xs:appinfo>
					</xs:annotation>
					<xs:simpleType>
						<xs:union memberTypes="xs:positiveInteger Unbounded"/>
					</xs:simpleType>
				</xs:attribute>
				<xs:attribute name="casesensitive" type="xs:boolean">
					<xs:annotation>
						<xs:documentation>Whether or not the solution should be checked in a case sensitive way or not.</xs:documentation>
						<xs:appinfo>
							<edmldoc:modelattribute/>
						</xs:appinfo>
					</xs:annotation>
				</xs:attribute>
				<xs:attribute name="charactershints" type="xs:boolean">
					<xs:annotation>
						<xs:documentation>Whether or not to give live hints about the allowed characters when the user has not yet submitted the input value.</xs:documentation>
						<xs:appinfo>
							<edmldoc:modelattribute/>
						</xs:appinfo>
					</xs:annotation>
				</xs:attribute>
				<xs:attribute name="minlengthhints" type="xs:boolean">
					<xs:annotation>
						<xs:documentation>Whether or not to give live hints about the allowed minimal length when the user has not yet submitted the input value.</xs:documentation>
						<xs:appinfo>
							<edmldoc:modelattribute/>
						</xs:appinfo>
					</xs:annotation>
				</xs:attribute>
				<xs:attribute name="maxlengthhints" type="xs:boolean">
					<xs:annotation>
						<xs:documentation>Whether or not to give live hints about the allowed maximal length when the user has not yet submitted the input value.</xs:documentation>
						<xs:appinfo>
							<edmldoc:modelattribute/>
						</xs:appinfo>
					</xs:annotation>
				</xs:attribute>
				<xs:attribute name="trim" type="xs:boolean">
					<xs:annotation>
						<xs:documentation>Whether or not whitespace at the beginning and end of the string (both the user input and the solution string) should be ignored.
						</xs:documentation>
						<xs:appinfo>
							<edmldoc:modelattribute/>
						</xs:appinfo>
					</xs:annotation>
				</xs:attribute>
			</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:appinfo>
				<edmldoc:property name="value" datatypes="boolean" examplevalue="false" nullable="true">
					<xs:annotation>
						<xs:documentation>
							The boolean valued entered by the user.
						</xs:documentation>
					</xs:annotation>
				</edmldoc:property>
			</xs:appinfo>
		</xs:annotation>
		<xs:simpleContent>
			<xs:extension base="xs:boolean">
				<xs:attributeGroup ref="CommonInputValueAttributes"/>
			</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:appinfo>
				<edmldoc:property name="value" datatypes="int" examplevalue="1" nullable="true">
					<xs:annotation>
						<xs:documentation>
							The number (starting with 1) of the item which the user has chosen.
						</xs:documentation>
					</xs:annotation>
				</edmldoc:property>
			</xs:appinfo>
		</xs:annotation>
		<xs:sequence>
			<xs:element minOccurs="1" maxOccurs="unbounded" name="option" type="ChoiceOption"/>
		</xs:sequence>
		<xs:attributeGroup ref="CommonInputValueAttributes"/>
		<xs:attribute name="shuffle" use="optional" type="xs:boolean">
			<xs:annotation>
				<xs:documentation>Whether or not the available options should be shuffled randomly
					each time the page is loaded.</xs:documentation>
				<xs:appinfo>
					<edmldoc:modelattribute/>
				</xs:appinfo>
			</xs:annotation>
		</xs:attribute>
	</xs:complexType>

	<xs:complexType name="ChoiceOption" mixed="true">
		<xs:annotation>
			<xs:documentation>
				An option of a choice input value.
			</xs:documentation>
		</xs:annotation>
		<xs:group ref="InlineGroup" minOccurs="0" maxOccurs="unbounded"/>
		<xs:attribute name="credits" type="xs:nonNegativeInteger" default="1">
			<xs:annotation>
				<xs:documentation>Number of credits the users gets awarded for enabling this option.</xs:documentation>
			</xs:annotation>
		</xs:attribute>		
		<xs:attribute name="correct" type="xs:boolean" default="false" use="optional">
			<xs:annotation>
				<xs:documentation>Whether or not this option is a correct solution of the input field.</xs:documentation>
			</xs:annotation>
		</xs:attribute>	
	</xs:complexType>

	<xs:complexType name="OrderInputValue">
		<xs:annotation>
			<xs:documentation>Input value element in which the user has to bring several items in a correct order.</xs:documentation>
			<xs:appinfo>
				<edmldoc:property name="value" datatypes="int[]" examplevalue="[1,5,4,3,2]" nullable="true">
					<xs:annotation>
						<xs:documentation>
							Permutation entered by the user. Each item of the array is a number (starting with 1) of
							the orderitem. This length of the array is equal to the number of orderitems.
						</xs:documentation>
					</xs:annotation>
				</edmldoc:property>
				<edmldoc:example><![CDATA[<input>
	<!-- A must appear before B, B must appear before C and A must appear before D -->
	<order>
		<items>
			<item>
				<p>A</p>
			</item>
			<item>
				<p>B</p>
			</item>
			<item>
				<p>C</p>
			</item>
			<item>
				<p>D</p>
			</item>
		</items>
		<chains>
			<chain credits="2">1 2 3</chain>
			<chain>1 4</chain>
	</chains>
	<order>
</input>]]></edmldoc:example>
			</xs:appinfo>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="orderitems" type="OrderItems"/>
			<xs:element name="chains" type="OrderChains"/>
		</xs:sequence>
		<xs:attributeGroup ref="CommonInputValueAttributes"/>
	</xs:complexType>

	<xs:complexType name="OrderItems">
		<xs:annotation>
			<xs:documentation>Contains the items of an order input value.</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="item" minOccurs="1" maxOccurs="unbounded" type="InputItem"/>
		</xs:sequence>
	</xs:complexType>

	<xs:complexType name="InputItem">
		<xs:annotation>
			<xs:documentation>An item of an order or matching input value.</xs:documentation>
		</xs:annotation>
		<xs:sequence minOccurs="0" maxOccurs="unbounded">
			<xs:group ref="BlockGroup"/>
		</xs:sequence>
	</xs:complexType>

	<xs:complexType name="OrderChains">
		<xs:annotation>
			<xs:documentation>Contains the chains of an order input value.</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="chain" minOccurs="1" maxOccurs="unbounded" type="OrderChain"/>
		</xs:sequence>
	</xs:complexType>

	<xs:complexType name="OrderChain">
		<xs:annotation>
			<xs:documentation>
				A chain of an order input value.
				Every item whose index appears in a chain before another item must be put before that item by the user.
			</xs:documentation>
		</xs:annotation>
		<xs:simpleContent>
			<xs:extension base="InputItemIndexList">
				<xs:attribute name="credits" use="optional" default="1" type="xs:nonNegativeInteger">
					<xs:annotation>
						<xs:documentation>Number of credit points the user gets awarded for ordering the items in compliance with this chain.</xs:documentation>
					</xs:annotation>
				</xs:attribute>
			</xs:extension>
		</xs:simpleContent>
	</xs:complexType>

	<xs:simpleType name="InputItemIndexList">
		<xs:annotation>
			<xs:documentation>A space-separated list of one or more order or matching input value item indices.</xs:documentation>
		</xs:annotation>
		<xs:restriction base="PositiveIntegerList">
			<xs:minLength value="1"/>
		</xs:restriction>
	</xs:simpleType>
	
	<xs:simpleType name="PositiveIntegerList">
		<xs:annotation>
			<xs:documentation>A space-separated list of positive integers.</xs:documentation>
		</xs:annotation>
		<xs:list itemType="xs:positiveInteger"/>
	</xs:simpleType>

	<xs:complexType name="MatchingInputValue">
		<xs:annotation>
			<xs:documentation>
				Input value element in which the user has to drag items to so-called drop items.
				For every correct match, the users gets a specified number of credits.
			</xs:documentation>
			<xs:appinfo>
				<edmldoc:property name="value" datatypes="int[][]" examplevalue="[[1,1],[2,2],[3,4]]" nullable="true">
					<xs:annotation>
						<xs:documentation>
							Array of pairs. Each pair represents a matching entered by the user. The first item of a
							pair is the number of the dragitem and the second item is the number of the dropitem. The
							number of the dragitems and dropitems both start with 1.
						</xs:documentation>
					</xs:annotation>
				</edmldoc:property>
				<edmldoc:example><![CDATA[<matching>
	<dragitems>
		<item>
			<p>Red</p>
		</item>
		<item>
			<p>Green</p>
		</item>
		<item>
			<p>Blue</p>
		</item>
	</dragitems>
	<dropitems>
		<item>
			<p>(255,0,0)</p>
		</item>
		<item>
			<p>(0,255,0)</p>
		</item>
		<item>
			<p>(0,0,255)</p>
		</item>
		<item>
			<p>(255,255,255)</p>
		</item>
	</dropitems>
	<matches>
		<match credits="5">1 1</match>
		<match credits="3">2 2</match>
		<match>3 3</match>
	</matches>
</matching>]]></edmldoc:example>
			</xs:appinfo>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="dragitems" type="DragItems"/>
			<xs:element name="dropitems" type="DropItems"/>
			<xs:element name="matches" type="Matches"/>
		</xs:sequence>
		<xs:attributeGroup ref="CommonInputValueAttributes"/>
	</xs:complexType>

	<xs:complexType name="DragItems">
		<xs:annotation>
			<xs:documentation>Contains the drag items of a matching input value.</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="item" minOccurs="1" maxOccurs="unbounded" type="InputItem"/>
		</xs:sequence>
		<xs:attribute name="shuffle" type="xs:boolean">
			<xs:annotation>
				<xs:documentation>
					Whether or not the drag items should be randomly shuffled each time the page is loaded.
				</xs:documentation>
				<xs:appinfo>
					<edmldoc:modelattribute/>
				</xs:appinfo>
			</xs:annotation>
		</xs:attribute>
		<xs:attribute name="maxuse" type="xs:positiveInteger">
			<xs:annotation>
				<xs:documentation>
					Decides how often the user can use each drag item in the matching problem.
				</xs:documentation>
				<xs:appinfo>
					<edmldoc:modelattribute/>
				</xs:appinfo>
			</xs:annotation>
		</xs:attribute>
	</xs:complexType>

	<xs:complexType name="DropItems">
		<xs:annotation>
			<xs:documentation>Contains the drop items of a matching input value.</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="item" minOccurs="1" maxOccurs="unbounded" type="InputItem"/>
		</xs:sequence>
		<xs:attribute name="shuffle" type="xs:boolean">
			<xs:annotation>
				<xs:documentation>
					Whether or not the drop items should be randomly shuffled each time the page is loaded.
				</xs:documentation>
				<xs:appinfo>
					<edmldoc:modelattribute/>
				</xs:appinfo>
			</xs:annotation>
		</xs:attribute>
		<xs:attribute name="maxuse" type="xs:positiveInteger">
			<xs:annotation>
				<xs:documentation>
					Decides how often the user can use each drop item in the matching problem.
				</xs:documentation>
				<xs:appinfo>
					<edmldoc:modelattribute/>
				</xs:appinfo>
			</xs:annotation>
		</xs:attribute>
	</xs:complexType>

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

	<xs:complexType name="Match">
		<xs:annotation>
			<xs:documentation>Describes a correct match between a drag and a drop item of a matching input value.
			The content of this element must consist of two numbers separated by a space character.
			The first number is the drag item number and the second number is the drop item number, as defined in the parent <code>matching</code> element.
			</xs:documentation>
			<xs:appinfo>
				<edmldoc:example><![CDATA[<match credits="5">1 2</match>]]></edmldoc:example>
			</xs:appinfo>
		</xs:annotation>
		<xs:simpleContent>
			<xs:extension base="MatchingNumberPair">
				<xs:attribute name="credits" use="optional" default="1" type="xs:nonNegativeInteger">
					<xs:annotation>
						<xs:documentation>Number of credit points the user gets awarded for matching the two items.</xs:documentation>
					</xs:annotation>
				</xs:attribute>
			</xs:extension>
		</xs:simpleContent>
	</xs:complexType>

	<xs:simpleType name="MatchingNumberPair">
		<xs:annotation>
			<xs:documentation>A space-separated list of exactly two numbers: a drag item number followed by a drop item number.</xs:documentation>
		</xs:annotation>
		<xs:restriction base="PositiveIntegerList">
			<xs:length value="2"/>
		</xs:restriction>
	</xs:simpleType>

	<xs:complexType name="NumberInputValue">
		<xs:annotation>
			<xs:documentation>
				Input value representing a number. The correct number can be either given as a direct value such as "-20.123"
				or as an expression that can also involve parameters defined in this containers. The expression is interpreted by the Computer Algebra System
				and must evaluate to a number.
				It is possible to specify a different base than the standard base 10. All integers between 1 and 35 are valid bases. Note that both the input from the user and the value written in the solution are interpreted as numbers with respect to the base in use.
			</xs:documentation>
			<xs:appinfo>
				<edmldoc:property name="value" datatypes="double" examplevalue="25.65" nullable="true">
					<xs:annotation>
						<xs:documentation>
							Number entered into the input field by the user.
						</xs:documentation>
					</xs:annotation>
				</edmldoc:property>
			</xs:appinfo>
		</xs:annotation>
		<xs:simpleContent>
			<xs:extension base="xs:string">
				<xs:attributeGroup ref="CommonInputValueAttributes"/>
				<xs:attribute name="base" type="NumberBase">
					<xs:annotation>
						<xs:documentation>Base of the standard positional number system in which the number is expected from the user and written in the solution.
						</xs:documentation>
						<xs:appinfo>
							<edmldoc:modelattribute/>
						</xs:appinfo>
					</xs:annotation>
				</xs:attribute>
				<xs:attribute name="minfracdigits" type="xs:nonNegativeInteger">
					<xs:annotation>
						<xs:documentation>Minimum number of fractional digits (digits after the radix point) that have to appear in the users input.</xs:documentation>
						<xs:appinfo>
							<edmldoc:modelattribute/>
						</xs:appinfo>
					</xs:annotation>
				</xs:attribute>
				<xs:attribute name="maxfracdigits" use="optional">
					<xs:annotation>
						<xs:documentation>Maximum number of fractional digits (digits after the radix point) that are allowed in the users input.</xs:documentation>
						<xs:appinfo>
							<edmldoc:modelattribute/>
						</xs:appinfo>
					</xs:annotation>
					<xs:simpleType>
						<xs:union memberTypes="xs:nonNegativeInteger Unbounded"/>
					</xs:simpleType>
				</xs:attribute>
				<xs:attribute name="minintdigits" type="xs:nonNegativeInteger">
					<xs:annotation>
						<xs:documentation>Minimum number of integer digits (digits before the radix point) that have to be present in the users input.</xs:documentation>
						<xs:appinfo>
							<edmldoc:modelattribute/>
						</xs:appinfo>
					</xs:annotation>
				</xs:attribute>
				<xs:attribute name="maxintdigits" use="optional">
					<xs:annotation>
						<xs:documentation>Maximum number of integer digits (digits before the radix point) that are allowed in the users input.</xs:documentation>
						<xs:appinfo>
							<edmldoc:modelattribute/>
						</xs:appinfo>
					</xs:annotation>
					<xs:simpleType>
						<xs:union memberTypes="xs:nonNegativeInteger Unbounded"/>
					</xs:simpleType>
				</xs:attribute>
				<xs:attribute name="minfracdigitshints" type="xs:boolean">
					<xs:annotation>
						<xs:documentation>Whether or not to give live hints about the minimum number of allowed fractional digits (digits after the radix point)
							when the user has not yet submitted the input value.</xs:documentation>
						<xs:appinfo>
							<edmldoc:modelattribute/>
						</xs:appinfo>
					</xs:annotation>
				</xs:attribute>
				<xs:attribute name="maxfracdigitshints" type="xs:boolean">
					<xs:annotation>
						<xs:documentation>Whether or not to give live hints about the maximum number of allowed fractional digits (digits after the radix point)
							when the user has not yet submitted the input value.</xs:documentation>
						<xs:appinfo>
							<edmldoc:modelattribute/>
						</xs:appinfo>
					</xs:annotation>
				</xs:attribute>
				<xs:attribute name="minintdigitshints" type="xs:boolean">
					<xs:annotation>
						<xs:documentation>Whether or not to give live hints about the minimum number of allowed integer digits (digits before the radix point)
							when the user has not yet submitted the input value.</xs:documentation>
						<xs:appinfo>
							<edmldoc:modelattribute/>
						</xs:appinfo>
					</xs:annotation>
				</xs:attribute>
				<xs:attribute name="maxintdigitshints" type="xs:boolean">
					<xs:annotation>
						<xs:documentation>Whether or not to give live hints about the maximum number of allowed integer digits (digits before the radix point)
							when the user has not yet submitted the input value.</xs:documentation>
						<xs:appinfo>
							<edmldoc:modelattribute/>
						</xs:appinfo>
					</xs:annotation>
				</xs:attribute>
				<xs:attribute name="lowertolerance" 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:appinfo>
							<edmldoc:modelattribute/>
						</xs:appinfo>
					</xs:annotation>
				</xs:attribute>
				<xs:attribute name="uppertolerance" 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:appinfo>
							<edmldoc:modelattribute/>
						</xs:appinfo>
					</xs:annotation>
				</xs:attribute>
				<xs:attribute name="lowerreltolerance" 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:appinfo>
							<edmldoc:modelattribute/>
						</xs:appinfo>
					</xs:annotation>
				</xs:attribute>
				<xs:attribute name="upperreltolerance" 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:appinfo>
							<edmldoc:modelattribute/>
						</xs:appinfo>
					</xs:annotation>
				</xs:attribute>
				<xs:attributeGroup ref="SignificantValueAttributes"/>
			</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".
				Here, the number "-2.01" is called the mantissa, "10" the base and "5" the exponent.
			</xs:documentation>
			<xs:appinfo>
				<edmldoc:property name="value" datatypes="double" nullable="true" examplevalue="435">
					<xs:annotation>
						<xs:documentation>
							Total result of the exponential expression entered by the user (mantissa * base ^ exponent).
						</xs:documentation>
					</xs:annotation>
				</edmldoc:property>
				<edmldoc:property name="mantissa" datatypes="double" nullable="true" examplevalue="4.35">
					<xs:annotation>
						<xs:documentation>
							Mantissa entered by the user.
						</xs:documentation>
					</xs:annotation>
				</edmldoc:property>
				<edmldoc:property name="exponent" datatypes="double" nullable="true" examplevalue="2">
					<xs:annotation>
						<xs:documentation>
							Exponent entered by the user.
						</xs:documentation>
					</xs:annotation>
				</edmldoc:property>
				<edmldoc:property name="base" datatypes="double" nullable="false" examplevalue="10">
					<xs:annotation>
						<xs:documentation>
							Base number as defined in the input field. This is not part of the user input.
						</xs:documentation>
					</xs:annotation>
				</edmldoc:property>
			</xs:appinfo>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="mantissa" minOccurs="1" maxOccurs="1" type="MantissaInputValue"/>
			<xs:element name="exponent" minOccurs="0" maxOccurs="1" type="ExponentInputValue"/>
		</xs:sequence>
		<xs:attributeGroup ref="CommonInputValueAttributes"/>
		<xs:attribute name="base" type="xs:positiveInteger">
			<xs:annotation>
				<xs:documentation>The base which is used to describe the number.</xs:documentation>
				<xs:appinfo>
					<edmldoc:modelattribute/>
				</xs:appinfo>
			</xs:annotation>
		</xs:attribute>
		<xs:attribute name="lowertolerance" 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:appinfo>
					<edmldoc:modelattribute/>
				</xs:appinfo>
			</xs:annotation>
		</xs:attribute>
		<xs:attribute name="uppertolerance" 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:appinfo>
					<edmldoc:modelattribute/>
				</xs:appinfo>
			</xs:annotation>
		</xs:attribute>
		<xs:attribute name="lowerreltolerance" 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:appinfo>
					<edmldoc:modelattribute/>
				</xs:appinfo>
			</xs:annotation>
		</xs:attribute>
		<xs:attribute name="upperreltolerance" 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:appinfo>
					<edmldoc:modelattribute/>
				</xs:appinfo>
			</xs:annotation>
		</xs:attribute>
		<xs:attribute name="scientific" type="xs:boolean">
			<xs:annotation>
				<xs:documentation>
					When set to true, the mantissa in the user input must be a single digit between 1 and 9 for the input to be correct.
				</xs:documentation>
				<xs:appinfo>
					<edmldoc:modelattribute/>
				</xs:appinfo>
			</xs:annotation>
		</xs:attribute>
		<xs:attribute name="engineering" type="xs:boolean">
			<xs:annotation>
				<xs:documentation>
					When set to true, the exponent in the user input must be a whole number divisible by 3 for the input to be correct.
				</xs:documentation>
				<xs:appinfo>
					<edmldoc:modelattribute/>
				</xs:appinfo>
			</xs:annotation>
		</xs:attribute>
	</xs:complexType>

	<xs:complexType name="MantissaInputValue">
		<xs:annotation>
			<xs:documentation>The coefficient before the base power in an exponential input value element.</xs:documentation>
		</xs:annotation>
		<xs:simpleContent>
			<xs:extension base="xs:string">
				<xs:attribute name="minfracdigits" type="xs:nonNegativeInteger">
					<xs:annotation>
						<xs:documentation>Minimum number of fractional digits (digits after the radix point) that have to appear in the users input.</xs:documentation>
						<xs:appinfo>
							<edmldoc:modelattribute/>
						</xs:appinfo>
					</xs:annotation>
				</xs:attribute>
				<xs:attribute name="maxfracdigits" use="optional">
					<xs:annotation>
						<xs:documentation>Maximum number of fractional digits (digits after the radix point) that are allowed in the users input.</xs:documentation>
						<xs:appinfo>
							<edmldoc:modelattribute/>
						</xs:appinfo>
					</xs:annotation>
					<xs:simpleType>
						<xs:union memberTypes="xs:nonNegativeInteger Unbounded"/>
					</xs:simpleType>
				</xs:attribute>
				<xs:attribute name="minintdigits" type="xs:nonNegativeInteger">
					<xs:annotation>
						<xs:documentation>Minimum number of integer digits (digits before the radix point) that have to be present in the users input.</xs:documentation>
						<xs:appinfo>
							<edmldoc:modelattribute/>
						</xs:appinfo>
					</xs:annotation>
				</xs:attribute>
				<xs:attribute name="maxintdigits" use="optional">
					<xs:annotation>
						<xs:documentation>Maximum number of integer digits (digits before the radix point) that are allowed in the users input.</xs:documentation>
						<xs:appinfo>
							<edmldoc:modelattribute/>
						</xs:appinfo>
					</xs:annotation>
					<xs:simpleType>
						<xs:union memberTypes="xs:nonNegativeInteger Unbounded"/>
					</xs:simpleType>
				</xs:attribute>
				<xs:attribute name="minfracdigitshints" type="xs:boolean">
					<xs:annotation>
						<xs:documentation>Whether or not to give live hints about the minimum number of allowed fractional digits (digits after the radix point)
							when the user has not yet submitted the input value.</xs:documentation>
						<xs:appinfo>
							<edmldoc:modelattribute/>
						</xs:appinfo>
					</xs:annotation>
				</xs:attribute>
				<xs:attribute name="maxfracdigitshints" type="xs:boolean">
					<xs:annotation>
						<xs:documentation>Whether or not to give live hints about the maximum number of allowed fractional digits (digits after the radix point)
							when the user has not yet submitted the input value.</xs:documentation>
						<xs:appinfo>
							<edmldoc:modelattribute/>
						</xs:appinfo>
					</xs:annotation>
				</xs:attribute>
				<xs:attribute name="minintdigitshints" type="xs:boolean">
					<xs:annotation>
						<xs:documentation>Whether or not to give live hints about the minimum number of allowed integer digits (digits before the radix point)
							when the user has not yet submitted the input value.</xs:documentation>
						<xs:appinfo>
							<edmldoc:modelattribute/>
						</xs:appinfo>
					</xs:annotation>
				</xs:attribute>
				<xs:attribute name="maxintdigitshints" type="xs:boolean">
					<xs:annotation>
						<xs:documentation>Whether or not to give live hints about the maximum number of allowed integer digits (digits before the radix point)
							when the user has not yet submitted the input value.</xs:documentation>
						<xs:appinfo>
							<edmldoc:modelattribute/>
						</xs:appinfo>
					</xs:annotation>
				</xs:attribute>
				<xs:attribute name="lowertolerance" 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:appinfo>
							<edmldoc:modelattribute/>
						</xs:appinfo>
					</xs:annotation>
				</xs:attribute>
				<xs:attribute name="uppertolerance" 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:appinfo>
							<edmldoc:modelattribute/>
						</xs:appinfo>
					</xs:annotation>
				</xs:attribute>
				<xs:attribute name="lowerreltolerance" 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:appinfo>
							<edmldoc:modelattribute/>
						</xs:appinfo>
					</xs:annotation>
				</xs:attribute>
				<xs:attribute name="upperreltolerance" 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:appinfo>
							<edmldoc:modelattribute/>
						</xs:appinfo>
					</xs:annotation>
				</xs:attribute>
				<xs:attributeGroup ref="SignificantValueAttributes"/>
			</xs:extension>
		</xs:simpleContent>
	</xs:complexType>

	<xs:complexType name="ExponentInputValue">
		<xs:annotation>
			<xs:documentation>The exponent of an exponential input value element.</xs:documentation>
		</xs:annotation>
		<xs:simpleContent>
			<xs:extension base="xs:string">
				<xs:attribute name="minfracdigits" type="xs:nonNegativeInteger">
					<xs:annotation>
						<xs:documentation>Minimum number of fractional digits (digits after the radix point) that have to appear in the users input.</xs:documentation>
						<xs:appinfo>
							<edmldoc:modelattribute/>
						</xs:appinfo>
					</xs:annotation>
				</xs:attribute>
				<xs:attribute name="maxfracdigits" use="optional">
					<xs:annotation>
						<xs:documentation>Maximum number of fractional digits (digits after the radix point) that are allowed in the users input.</xs:documentation>
						<xs:appinfo>
							<edmldoc:modelattribute/>
						</xs:appinfo>
					</xs:annotation>
					<xs:simpleType>
						<xs:union memberTypes="xs:nonNegativeInteger Unbounded"/>
					</xs:simpleType>
				</xs:attribute>
				<xs:attribute name="minintdigits" type="xs:nonNegativeInteger">
					<xs:annotation>
						<xs:documentation>Minimum number of integer digits (digits before the radix point) that have to be present in the users input.</xs:documentation>
						<xs:appinfo>
							<edmldoc:modelattribute/>
						</xs:appinfo>
					</xs:annotation>
				</xs:attribute>
				<xs:attribute name="maxintdigits" use="optional">
					<xs:annotation>
						<xs:documentation>Maximum number of integer digits (digits before the radix point) that are allowed in the users input.</xs:documentation>
						<xs:appinfo>
							<edmldoc:modelattribute/>
						</xs:appinfo>
					</xs:annotation>
					<xs:simpleType>
						<xs:union memberTypes="xs:nonNegativeInteger Unbounded"/>
					</xs:simpleType>
				</xs:attribute>
				<xs:attribute name="minfracdigitshints" type="xs:boolean">
					<xs:annotation>
						<xs:documentation>Whether or not to give live hints about the minimum number of allowed fractional digits (digits after the radix point)
							when the user has not yet submitted the input value.</xs:documentation>
						<xs:appinfo>
							<edmldoc:modelattribute/>
						</xs:appinfo>
					</xs:annotation>
				</xs:attribute>
				<xs:attribute name="maxfracdigitshints" type="xs:boolean">
					<xs:annotation>
						<xs:documentation>Whether or not to give live hints about the maximum number of allowed fractional digits (digits after the radix point)
							when the user has not yet submitted the input value.</xs:documentation>
						<xs:appinfo>
							<edmldoc:modelattribute/>
						</xs:appinfo>
					</xs:annotation>
				</xs:attribute>
				<xs:attribute name="minintdigitshints" type="xs:boolean">
					<xs:annotation>
						<xs:documentation>Whether or not to give live hints about the minimum number of allowed integer digits (digits before the radix point)
							when the user has not yet submitted the input value.</xs:documentation>
						<xs:appinfo>
							<edmldoc:modelattribute/>
						</xs:appinfo>
					</xs:annotation>
				</xs:attribute>
				<xs:attribute name="maxintdigitshints" type="xs:boolean">
					<xs:annotation>
						<xs:documentation>Whether or not to give live hints about the maximum number of allowed integer digits (digits before the radix point)
							when the user has not yet submitted the input value.</xs:documentation>
						<xs:appinfo>
							<edmldoc:modelattribute/>
						</xs:appinfo>
					</xs:annotation>
				</xs:attribute>
				<xs:attribute name="lowertolerance" 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:appinfo>
							<edmldoc:modelattribute/>
						</xs:appinfo>
					</xs:annotation>
				</xs:attribute>
				<xs:attribute name="uppertolerance" 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:appinfo>
							<edmldoc:modelattribute/>
						</xs:appinfo>
					</xs:annotation>
				</xs:attribute>
				<xs:attribute name="lowerreltolerance" 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:appinfo>
							<edmldoc:modelattribute/>
						</xs:appinfo>
					</xs:annotation>
				</xs:attribute>
				<xs:attribute name="upperreltolerance" 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:appinfo>
							<edmldoc:modelattribute/>
						</xs:appinfo>
					</xs:annotation>
				</xs:attribute>
				<xs:attributeGroup ref="SignificantValueAttributes"/>
			</xs:extension>
		</xs:simpleContent>
	</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 written 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="factorial">
				<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>abs(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="sin">
				<xs:annotation>
					<xs:documentation>Operator of the form <code>sin(a)</code>.</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="cos">
				<xs:annotation>
					<xs:documentation>Operator of the form <code>cos(a)</code>.</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="tan">
				<xs:annotation>
					<xs:documentation>Operator of the form <code>tan(a)</code>.</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="asin">
				<xs:annotation>
					<xs:documentation>Operator of the form <code>sinh(a)</code>.</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="acos">
				<xs:annotation>
					<xs:documentation>Operator of the form <code>cosh(a)</code>.</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="atan">
				<xs:annotation>
					<xs:documentation>Operator of the form <code>tanh(a)</code>.</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="sinh">
				<xs:annotation>
					<xs:documentation>Operator of the form <code>sinh(a)</code>.</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="cosh">
				<xs:annotation>
					<xs:documentation>Operator of the form <code>cosh(a)</code>.</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="tanh">
				<xs:annotation>
					<xs:documentation>Operator of the form <code>tanh(a)</code>.</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="exp">
				<xs:annotation>
					<xs:documentation>Operator of the form <code>exp(a)</code>.</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="log">
				<xs:annotation>
					<xs:documentation>Operator of the form <code>log(a)</code>.</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="log10">
				<xs:annotation>
					<xs:documentation>Operator of the form <code>log10(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 the following 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>)</li>
					<li>variable (such as <code>x</code> or <code>alpha</code>, every alphabetic string which is not a predefined symbol)</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>functions: absolute value (<code>abs(a)</code>), square root (<code>sqrt(a)</code>) and other functions</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 must always be written out when a multiplication is meant. For example, <code>2xy</code> is an invalid expression but <code>2*x*y</code> is valid.
				</p>
			</xs:documentation>
			<xs:appinfo>
				<edmldoc:property name="value" datatypes="string" nullable="true" examplevalue="2*x*x">
					<xs:annotation>
						<xs:documentation>
							Original unmodified expression entered by the user.
						</xs:documentation>
					</xs:annotation>
				</edmldoc:property>
			</xs:appinfo>
		</xs:annotation>
		<xs:simpleContent>
			<xs:extension base="xs:string">
				<xs:attributeGroup ref="CommonInputValueAttributes"/>
				<xs:attribute name="useonly" use="optional">
					<xs:annotation>
						<xs:documentation>Whitespace-separated list of expression node types that are allowed to appear in the expression or the special value "all",
							which means that all types are allowed.
						</xs:documentation>
						<xs:appinfo>
							<edmldoc:modelattribute/>
						</xs:appinfo>
					</xs:annotation>
					<xs:simpleType>
						<xs:union memberTypes="ExpressionNodeTypeList All"/>
					</xs:simpleType>
				</xs:attribute>
				<xs:attribute name="usenot" type="ExpressionNodeTypeList">
					<xs:annotation>
						<xs:documentation>Whitespace-separated list of expression node types that are forbidden to occur in the expression.</xs:documentation>
						<xs:appinfo>
							<edmldoc:modelattribute/>
						</xs:appinfo>
					</xs:annotation>
				</xs:attribute>
				<xs:attribute name="useonce" type="ExpressionNodeTypeList">
					<xs:annotation>
						<xs:documentation>Whitespace-separated list of expression node types that have to appear exactly once in the expression.</xs:documentation>
						<xs:appinfo>
							<edmldoc:modelattribute/>
						</xs:appinfo>
					</xs:annotation>
				</xs:attribute>
				<xs:attribute name="expect">
					<xs:annotation>
						<xs:documentation>Whitespace-separated list of expression node types that are allowed for the root node of the expression,
							or the special value "all" which means that all types are allowed for the root element.
						</xs:documentation>
						<xs:appinfo>
							<edmldoc:modelattribute/>
						</xs:appinfo>
					</xs:annotation>
					<xs:simpleType>
						<xs:union memberTypes="ExpressionNodeTypeList All"/>
					</xs:simpleType>
				</xs:attribute>
				<xs:attribute name="simplified" type="xs:boolean">
					<xs:annotation>
						<xs:documentation>If this attribute is set to true, the expression entered by the user must be simplified for this field to be correct.
							This means that the collections of node types and node values appearing in the user expression tree and the expression tree of its simplification
							must agree without order but with counting.
						</xs:documentation>
						<xs:appinfo>
							<edmldoc:modelattribute/>
						</xs:appinfo>
					</xs:annotation>
				</xs:attribute>
				<xs:attribute name="expanded" type="xs:boolean">
					<xs:annotation>
						<xs:documentation>If this attribute is set to true, the expression entered by the user must be fully expanded for this field to be correct.
							This means that the collections of node types and node values appearing in the user expression tree and the expression tree of its expanded form
							must agree without order but with counting.
						</xs:documentation>
						<xs:appinfo>
							<edmldoc:modelattribute/>
						</xs:appinfo>
					</xs:annotation>
				</xs:attribute>
				<xs:attribute name="testmode" type="ExpressionTestMode">
					<xs:annotation>
						<xs:documentation>The test mode defines in what way the expression entered by the user is compared with the expression in the solution.
							By default, they must be equal.</xs:documentation>
						<xs:appinfo>
							<edmldoc:modelattribute/>
						</xs:appinfo>
					</xs:annotation>
				</xs:attribute>
			</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:appinfo>
				<xs:appinfo>
					<edmldoc:property name="value" datatypes="dictionary[]" nullable="true"
									  examplevalue="[{type:'number', value:'5'}, {type:'number', value:'-5'}]">
						<xs:annotation>
							<xs:documentation>
								Array of the set elements entered by the user. Each item is a dictionary with the
								items "type" and "value".
							</xs:documentation>
						</xs:annotation>
					</edmldoc:property>
				</xs:appinfo>
				<sch:pattern>
					<sch:rule context="edml:set[@minsize][@maxsize]">
						<sch:assert test="@maxsize = 'unbounded' or @minsize &lt;= @maxsize">
							The minsize attribute value of a set element must be less than or equal to the maxsize attribute value.
						</sch:assert>
					</sch:rule>
				</sch:pattern>
			</xs:appinfo>
		</xs:annotation>
		<xs:sequence>
			<xs:choice 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:choice>
		</xs:sequence>
		<xs:attributeGroup ref="CommonInputValueAttributes"/>
		<xs:attribute name="minsize" type="xs:nonNegativeInteger">
			<xs:annotation>
				<xs:documentation>Minimum number of elements that the user may put into the set.</xs:documentation>
				<xs:appinfo>
					<edmldoc:modelattribute/>
				</xs:appinfo>
			</xs:annotation>
		</xs:attribute>
		<xs:attribute name="maxsize">
			<xs:annotation>
				<xs:documentation>Maximum number of elements that the user may put into the set or "unbounded", which means that
					there should be no upper bound on the size of the set.
				</xs:documentation>
				<xs:appinfo>
					<edmldoc:modelattribute/>
				</xs:appinfo>
			</xs:annotation>
			<xs:simpleType>
				<xs:union memberTypes="xs:positiveInteger Unbounded"/>
			</xs:simpleType>
		</xs:attribute>
		<xs:attribute name="of">
			<xs:annotation>
				<xs:documentation>Whitespace-separated list of allowed element types that the user may put into this set or "auto", which means that
					the system will look for all element types that appear in the solution and allow only these.</xs:documentation>
				<xs:appinfo>
					<edmldoc:modelattribute/>
				</xs:appinfo>
			</xs:annotation>
			<xs:simpleType>
				<xs:union memberTypes="SetElementValueTypeList Auto"/>
			</xs:simpleType>
		</xs:attribute>
		<xs:attribute name="minsizehints" type="xs:boolean">
			<xs:annotation>
				<xs:documentation>Whether or not to give live hints about the allowed minimum size of the set
					when the user has not yet submitted the input value.
				</xs:documentation>
				<xs:appinfo>
					<edmldoc:modelattribute/>
				</xs:appinfo>
			</xs:annotation>
		</xs:attribute>
		<xs:attribute name="maxsizehints" type="xs:boolean">
			<xs:annotation>
				<xs:documentation>Whether or not to give live hints about the allowed maximum size of the set
					when the user has not yet submitted the input value.
				</xs:documentation>
				<xs:appinfo>
					<edmldoc:modelattribute/>
				</xs:appinfo>
			</xs:annotation>
		</xs:attribute>
		<xs:attribute name="ofhints" type="xs:boolean">
			<xs:annotation>
				<xs:documentation>Whether or not to give live hints about the allowed element types in the set
					when the user has not yet submitted the input value.
				</xs:documentation>
				<xs:appinfo>
					<edmldoc:modelattribute/>
				</xs:appinfo>
			</xs:annotation>
		</xs:attribute>
	</xs:complexType>

	<xs:simpleType name="SetElementValueTypeList">
		<xs:annotation>
			<xs:documentation>A list of input value types that can appear in a set.</xs:documentation>
		</xs:annotation>
		<xs:list itemType="SetElementInputValueType"/>
	</xs:simpleType>

	<xs:simpleType name="SetElementInputValueType">
		<xs:annotation>
			<xs:documentation>Describes a type of input elements that can appear in a set.</xs:documentation>
		</xs:annotation>
		<xs:restriction base="xs:NMTOKEN">
			<xs:enumeration value="number">
				<xs:annotation>
					<xs:documentation>Number elements.</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="exponential">
				<xs:annotation>
					<xs:documentation>Exponential elements.</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="expression">
				<xs:annotation>
					<xs:documentation>Expression elements.</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="set">
				<xs:annotation>
					<xs:documentation>Set elements with any content. Note that it is currently not possible to restrict this type further. </xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="vector">
				<xs:annotation>
					<xs:documentation>Vector elements with any content.</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="vectorofexpressions">
				<xs:annotation>
					<xs:documentation>Vector elements with only expression elements as content.</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="vectorofnumbers">
				<xs:annotation>
					<xs:documentation>Vector elements with only number elements as content.</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="vectorofstrings">
				<xs:annotation>
					<xs:documentation>Vector elements with only number elements as content.</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="matrix">
				<xs:annotation>
					<xs:documentation>Matrix elements with any content.</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="matrixofexpressions">
				<xs:annotation>
					<xs:documentation>Matrix elements with only expression elements as content.</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="matrixofnumbers">
				<xs:annotation>
					<xs:documentation>Matrix elements with only number elements as content.</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="matrixofstrings">
				<xs:annotation>
					<xs:documentation>Matrix elements with only number elements as content.</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="interval">
				<xs:annotation>
					<xs:documentation>Interval elements.</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="intervalofexpressions">
				<xs:annotation>
					<xs:documentation>Interval element with only expression elements as bounds.</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="intervalofnumbers">
				<xs:annotation>
					<xs:documentation>Interval elements with only number elements as bounds.</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="string">
				<xs:annotation>
					<xs:documentation>String elements.</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
		</xs:restriction>
	</xs:simpleType>

	<xs:complexType name="VectorInputValue">
		<xs:annotation>
			<xs:documentation>
				Input value representing a vector of either numbers of mathematical expressions. It is not
				allowed to mix these two input value types in one vector, that is, if one component of the vector is an
				expression, then all components of the vector have to be expressions.
			</xs:documentation>
			<xs:appinfo>
				<edmldoc:property name="value" datatypes="double[] string[]" examplevalue="[2.5, 4.4, -66]"
								nullable="true">
					<xs:annotation>
						<xs:documentation>
							Vector entered by the user. In the case of expression elements inside the vector, this
							property holds an array of strings instead of doubles.
						</xs:documentation>
					</xs:annotation>
				</edmldoc:property>
			</xs:appinfo>
		</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:attributeGroup ref="CommonInputValueAttributes"/>
		<xs:attribute name="minsize" type="xs:positiveInteger">
			<xs:annotation>
				<xs:documentation>Minimum number of components in this vector.</xs:documentation>
				<xs:appinfo>
					<edmldoc:modelattribute/>
				</xs:appinfo>
			</xs:annotation>
		</xs:attribute>
		<xs:attribute name="maxsize">
			<xs:annotation>
				<xs:documentation>Maximum number of components in this vector or the special value "unbounded", which means that there is no upper bound on the
					size of the vector.
				</xs:documentation>
				<xs:appinfo>
					<edmldoc:modelattribute/>
				</xs:appinfo>
			</xs:annotation>
			<xs:simpleType>
				<xs:union memberTypes="xs:positiveInteger Unbounded"/>
			</xs:simpleType>
		</xs:attribute>
		<xs:attribute name="defaultsize">
			<xs:annotation>
				<xs:documentation>Initial number of components in this vector that are already there when the user
					loads the page. When this attribute is set to auto, the default size is the size of the first vector
					written as solution in this input value element.</xs:documentation>
				<xs:appinfo>
					<edmldoc:modelattribute/>
				</xs:appinfo>
			</xs:annotation>
			<xs:simpleType>
				<xs:union memberTypes="xs:positiveInteger Auto"/>
			</xs:simpleType>
		</xs:attribute>
		<xs:attribute name="type" type="VectorType">
			<xs:annotation>
				<xs:documentation>Type of the vector (column vector or row vector).</xs:documentation>
				<xs:appinfo>
					<edmldoc:modelattribute/>
				</xs:appinfo>
			</xs:annotation>
		</xs:attribute>
	</xs:complexType>

	<xs:complexType name="MatrixInputValue">
		<xs:annotation>
			<xs:documentation>
				Input value representing a matrix of numbers or expressions. A matrix has to consist either only of numbers or only of expressions.
				The user may add or remove columns in the matrix.
			</xs:documentation>
			<xs:appinfo>
				<edmldoc:property name="value" datatypes="double[][] string[][]"
								examplevalue="[[2.5,0,0],[4.4,3,0],[0,0,1]]" nullable="true">
					<xs:annotation>
						<xs:documentation>
							Matrix entered by the user. In the case of expression elements inside the matrix, this
							property holds a two-dimensional array of strings instead of doubles.
						</xs:documentation>
					</xs:annotation>
				</edmldoc:property>
				<sch:pattern>
					<sch:rule context="edml:matrix">
						<sch:assert test="(edml:matrixrow/edml:number and not(edml:matrixrow/edml:expression)) or (not(edml:matrixrow/edml:number) and edml:matrixrow/edml:expression)">
							A matrix has to consist either only of numbers or only of expressions. The two types shall not be mixed inside a matrix.
						</sch:assert>
					</sch:rule>
				</sch:pattern>
			</xs:appinfo>
		</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:attribute name="minrows" type="xs:positiveInteger">
			<xs:annotation>
				<xs:documentation>Minimum number of rows that the user is allowed to put in the matrix.</xs:documentation>
				<xs:appinfo>
					<edmldoc:modelattribute/>
				</xs:appinfo>
			</xs:annotation>
		</xs:attribute>
		<xs:attribute name="maxrows">
			<xs:annotation>
				<xs:documentation>Maximum number of rows that the user is allowed to put in the matrix.</xs:documentation>
				<xs:appinfo>
					<edmldoc:modelattribute/>
				</xs:appinfo>
			</xs:annotation>
			<xs:simpleType>
				<xs:union memberTypes="xs:positiveInteger Unbounded"/>
			</xs:simpleType>
		</xs:attribute>
		<xs:attribute name="defaultrows">
			<xs:annotation>
				<xs:documentation>Initial number of rows in this matrix that are already there when the user loads
					the page. When this attribute is set to auto, the matrix initially has as many rows as the first
					matrix written as solution in this input value element.</xs:documentation>
				<xs:appinfo>
					<edmldoc:modelattribute/>
				</xs:appinfo>
			</xs:annotation>
			<xs:simpleType>
				<xs:union memberTypes="xs:positiveInteger Auto"/>
			</xs:simpleType>
		</xs:attribute>
		<xs:attribute name="mincolumns" type="xs:positiveInteger">
			<xs:annotation>
				<xs:documentation>Minimum number of columns that the user is allowed to put in the matrix.</xs:documentation>
				<xs:appinfo>
					<edmldoc:modelattribute/>
				</xs:appinfo>
			</xs:annotation>
		</xs:attribute>
		<xs:attribute name="maxcolumns">
			<xs:annotation>
				<xs:documentation>Maximum number of columns that the user is allowed to put in the matrix.</xs:documentation>
				<xs:appinfo>
					<edmldoc:modelattribute/>
				</xs:appinfo>
			</xs:annotation>
			<xs:simpleType>
				<xs:union memberTypes="xs:positiveInteger Unbounded"/>
			</xs:simpleType>
		</xs:attribute>
		<xs:attribute name="defaultcolumns">
			<xs:annotation>
				<xs:documentation>Initial number of columns in this matrix that are already there when the user loads
					the page. When this attribute is set to auto, the matrix initially has as many columns as the first
					matrix written as solution in this input value element.</xs:documentation>
				<xs:appinfo>
					<edmldoc:modelattribute/>
				</xs:appinfo>
			</xs:annotation>
			<xs:simpleType>
				<xs:union memberTypes="xs:positiveInteger Auto"/>
			</xs:simpleType>
		</xs:attribute>
	</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="IntervalClosureType">
		<xs:annotation>
			<xs:documentation>Specifies the type of an interval.</xs:documentation>
		</xs:annotation>
		<xs:restriction base="xs:NMTOKEN">
			<xs:enumeration value="closed">
				<xs:annotation>
					<xs:documentation>Interval of type [a;b].</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="closedopen">
				<xs:annotation>
					<xs:documentation>Interval of type [a;b).</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="open">
				<xs:annotation>
					<xs:documentation>Interval of type (a;b).</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="openclosed">
				<xs:annotation>
					<xs:documentation>Interval of type (a;b].</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
		</xs:restriction>
	</xs:simpleType>

	<xs:complexType name="IntervalInputValue">
		<xs:annotation>
			<xs:documentation>
				Input value representing an interval, such as "[2;10)", those endpoints are numbers or expressions.
			</xs:documentation>
			<xs:appinfo>
				<edmldoc:property name="value" datatypes="double[]" nullable="true" examplevalue="[2.3,Infinity]">
					<xs:annotation>
						<xs:documentation>
							The lower and upper bounds of the interval as entered by the user as an array of doubles.
							Note that Infinity is regarded as a valid value of the double type.
						</xs:documentation>
					</xs:annotation>
				</edmldoc:property>
				<edmldoc:property name="closure" datatypes="string" nullable="true" examplevalue="closedopen">
					<xs:annotation>
						<xs:documentation>
							Closure of the interval as entered by the user. One of "open", "closedopen", "openclosed"
							or "closed".
						</xs:documentation>
					</xs:annotation>
				</edmldoc:property>
			</xs:appinfo>
		</xs:annotation>
		<xs:sequence>
			<xs:choice>
				<xs:element name="number" type="NumberInputValue"/>
				<xs:element name="expression" type="ExpressionInputValue"/>
			</xs:choice>
			<xs:choice>
				<xs:element name="number" type="NumberInputValue"/>
				<xs:element name="expression" type="ExpressionInputValue"/>
			</xs:choice>
		</xs:sequence>
		<xs:attributeGroup ref="CommonInputValueAttributes"/>
		<xs:attribute name="closure" type="IntervalClosureType">
			<xs:annotation>
				<xs:documentation>Specifies the correct type of the interval. This decides which of its endpoints should belong to it.</xs:documentation>
				<xs:appinfo>
					<edmldoc:modelattribute/>
				</xs:appinfo>
			</xs:annotation>
		</xs:attribute>
		<xs:attribute name="fixclosure" type="xs:boolean">
			<xs:annotation>
				<xs:documentation>
					Specifies whether the interval type should be already filled in for the user with the type defined in the "closed" attribute.
					If this attribute is set to true, the user can not change the interval type.
					Otherwise, the user has to specify the interval type on his or her own.
				</xs:documentation>
				<xs:appinfo>
					<edmldoc:modelattribute/>
				</xs:appinfo>
			</xs:annotation>
		</xs:attribute>
	</xs:complexType>

	<xs:complexType name="LinearSpanInputValue">
		<xs:annotation>
			<xs:documentation>Input value where the user has to enter a collection of vectors in a vector space R^n for
				some fixed n. The input field is correct if the collection of vectors entered by the user span the same
				linear subspace of R^n as the vectors written in the solution of this input field, all of which must
				have the same size n. The trivial linear subspace can be represented in the solution with a vector
				consisting only of zeros. By the language defaults, the user is only allowed to enter vectors of size n
				into the field, where n is taken from the solution. This can be changed with the flexvectorsize
				attribute.
			</xs:documentation>
			<xs:appinfo>
				<sch:pattern>
					<sch:rule context="edml:linearspan/edml:vector">
						<sch:assert test="count(edml:number)=count(*)">
							A vector in a linear span has to consist of numbers only.
						</sch:assert>
					</sch:rule>
					<sch:rule context="edml:linearspan">
						<sch:assert test="count(edml:vector[count(edml:number)=count(current()/edml:vector[1]/edml:number)])=count(edml:vector)">
							All vectors in a linear span must have the same size.
						</sch:assert>
					</sch:rule>
					<sch:rule context="edml:linearspan[@minvectorcount][@maxvectorcount]">
						<sch:assert test="@maxvectorcount = 'unbounded' or @minvectorcount &lt;= @maxvectorcount">
							Attribute minvectorcount must be less than or equal to maxvectorcount.
						</sch:assert>
					</sch:rule>
				</sch:pattern>
				<edmldoc:property name="value" datatypes="double[][]" nullable="true"
								examplevalue="[[1.5,-6,0],[0,0,1],[1.25,1,1]]">
					<xs:annotation>
						<xs:documentation>
							The spanning vectors entered by the user as an array of coordinate vectors.
						</xs:documentation>
					</xs:annotation>
				</edmldoc:property>
			</xs:appinfo>
		</xs:annotation>
		<xs:sequence minOccurs="1" maxOccurs="unbounded">
			<xs:element name="vector" type="VectorInputValue"/>
		</xs:sequence>
		<xs:attributeGroup ref="CommonInputValueAttributes"/>
		<xs:attribute name="maxvectorcount">
			<xs:annotation>
				<xs:documentation>Maximum number of vectors that are allowed to be present in the collection of spanning
					vectors entered by the user in order for this field to be correct.</xs:documentation>
				<xs:appinfo>
					<edmldoc:modelattribute/>
				</xs:appinfo>
			</xs:annotation>
			<xs:simpleType>
				<xs:union memberTypes="xs:positiveInteger Unbounded"/>
			</xs:simpleType>
		</xs:attribute>
		<xs:attribute name="minvectorcount" type="xs:nonNegativeInteger">
			<xs:annotation>
				<xs:documentation>Minimum number of vectors that have to be present in the collection of spanning
					vectors entered by the user in order for this field to be correct.</xs:documentation>
				<xs:appinfo>
					<edmldoc:modelattribute/>
				</xs:appinfo>
			</xs:annotation>
		</xs:attribute>
		<xs:attribute name="basis" type="xs:boolean">
			<xs:annotation>
				<xs:documentation xml:lang="en">
					Whether or not the vectors entered by the user must be linearly independent, in addition to the
					other conditions, for this input field to be correct.
				</xs:documentation>
				<xs:documentation xml:lang="de">
					Gibt an, ob die vom Nutzer eingegebenen Vektoren, zusätzlich zu den anderen Bedingungen, linear
					unabhängig sein müssen, damit dieses Eingabefeld als richtig ausgefüllt gilt.
				</xs:documentation>
				<xs:appinfo>
					<edmldoc:modelattribute/>
				</xs:appinfo>
			</xs:annotation>
		</xs:attribute>
		<xs:attribute name="orthogonal" type="xs:boolean">
			<xs:annotation>
				<xs:documentation xml:lang="en">
					Whether or not the vectors entered by the user must be pairwise orthogonal with respect
					to the standard inner product, in addition to the other conditions, for this input field to be
					correct.
				</xs:documentation>
				<xs:documentation xml:lang="de">
					Gibt an, ob die vom Nutzer eingegebenen Vektoren, zusätzlich zu den anderen Bedingungen, paarweise
					orthogonal bezüglich des Standardskalarproduktes sein müssen, damit dieses Eingabefeld als richtig
					ausgefüllt gilt.
				</xs:documentation>
				<xs:appinfo>
					<edmldoc:modelattribute/>
				</xs:appinfo>
			</xs:annotation>
		</xs:attribute>
		<xs:attribute name="normed" type="xs:boolean">
			<xs:annotation>
				<xs:documentation xml:lang="en">
					Whether or not the vectors entered by the user must be normed, that is, have Euclidean length one,
					in addition to the other conditions, for this input field to be correct.
				</xs:documentation>
				<xs:documentation xml:lang="de">
					Gibt an, ob die vom Nutzer eingegebenen Vektoren, zusätzlich zu den anderen Bedingungen, die
					Euklidische Länge Eins haben müssen, damit dieses Eingabefeld als richtig ausgefüllt gilt.
				</xs:documentation>
				<xs:appinfo>
					<edmldoc:modelattribute/>
				</xs:appinfo>
			</xs:annotation>
		</xs:attribute>
		<xs:attribute name="flexvectorsize" type="xs:boolean">
			<xs:annotation>
				<xs:documentation xml:lang="en">
					When this attribute is set to true, the user must select and find out the size of the vectors in the
					subspace (their number of components) on his or her own. Otherwise, the size is fixed as in the
					solution.
				</xs:documentation>
				<xs:documentation xml:lang="de">
					Bestimmt darüber, ob der Nutzer die Größe der Vektoren im Unterraum selbst herausfinden muss und
					einstellen kann. Wenn das Attribut deaktiviert ist, ist die Größe der Vektoren fest vorgegeben wie
					in der Lösung.
				</xs:documentation>
				<xs:appinfo>
					<edmldoc:modelattribute/>
				</xs:appinfo>
			</xs:annotation>
		</xs:attribute>
	</xs:complexType>

	<xs:complexType name="AffineSpaceInputValue">
		<xs:annotation>
			<xs:documentation>Input value where the user has to enter an affine subspace U = P + V of R^n by entering a
				point P of U and the direction space V of U. The direction space V is a linear subspace of R^n that is
				given as the linear span of some vectors entered by the user. The point P and the linear subspace V must
				lie in the same vector space R^n for this field to have a correct solution. The value of n is deduced
				from the point in the solution and the user is only allowed to enter vectors of size n into this field.
			</xs:documentation>
			<xs:appinfo>
				<sch:pattern>
					<sch:rule context="edml:affinespace">
						<sch:assert test="count(edml:vector/edml:number)=count(edml:linearspan/edml:vector[1]/edml:number)">
							The base point and the direction space of an affine space must lie in the same vector space.
						</sch:assert>
					</sch:rule>
				</sch:pattern>
				<edmldoc:property name="point" datatypes="double[]" nullable="true" examplevalue="[2, 3, -5.5]">
					<xs:annotation>
						<xs:documentation>
							The point of the affine space entered by the user as coordinate vector.
						</xs:documentation>
					</xs:annotation>
				</edmldoc:property>
				<edmldoc:property name="directions" datatypes="double[][]" examplevalue="[[1,0,0],[0,-6.7,0]]"
								nullable="true">
					<xs:annotation>
						<xs:documentation>
							The vectors spanning the direction subspace of the affine space entered by the user.
						</xs:documentation>
					</xs:annotation>
				</edmldoc:property>
			</xs:appinfo>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="vector" type="VectorInputValue"/>
			<xs:element name="linearspan" type="LinearSpanInputValue"/>
		</xs:sequence>
		<xs:attributeGroup ref="CommonInputValueAttributes"/>
	</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:appinfo>
				<edmldoc:property name="value" datatypes="string" examplevalue="m*s^-2" nullable="true">
					<xs:annotation>
						<xs:documentation>
							Unit entered by the user. The format is the same as in the XML file.
						</xs:documentation>
					</xs:annotation>
				</edmldoc:property>
			</xs:appinfo>
		</xs:annotation>
		<xs:simpleContent>
			<xs:extension base="UnitValue">
				<xs:attributeGroup ref="CommonInputValueAttributes"/>
				<xs:attribute name="useonly">
					<xs:annotation>
						<xs:documentation>
							Whitespace-separated list of unit symbols that the user is allowed to use,
							or the special value "all", which means that all unit symbols are allowed.
						</xs:documentation>
						<xs:appinfo>
							<edmldoc:modelattribute/>
						</xs:appinfo>
					</xs:annotation>
					<xs:simpleType>
						<xs:union memberTypes="UnitSymbolList All"/>
					</xs:simpleType>
				</xs:attribute>
				<xs:attribute name="usenot" type="UnitSymbolList">
					<xs:annotation>
						<xs:documentation>
							Whitespace-separated list of unit symbols that the user is forbidden to use.
						</xs:documentation>
						<xs:appinfo>
							<edmldoc:modelattribute/>
						</xs:appinfo>
					</xs:annotation>
				</xs:attribute>
				<xs:attribute name="prefixes">
					<xs:annotation>
						<xs:documentation>
							Whitespace-separated list of unit prefixes that the user is allowed to use,
							or the special value "all", which means that all unit prefixes are allowed.
						</xs:documentation>
						<xs:appinfo>
							<edmldoc:modelattribute/>
						</xs:appinfo>
					</xs:annotation>
					<xs:simpleType>
						<xs:union memberTypes="UnitPrefixList All"/>
					</xs:simpleType>
				</xs:attribute>
				<xs:attribute name="useonlyhints" type="xs:boolean">
					<xs:annotation>
						<xs:documentation>Whether or not to give live hints about the list of allowed unit symbols
							when the user has not yet submitted the input value.</xs:documentation>
						<xs:appinfo>
							<edmldoc:modelattribute/>
						</xs:appinfo>
					</xs:annotation>
				</xs:attribute>
				<xs:attribute name="usenothints" type="xs:boolean">
					<xs:annotation>
						<xs:documentation>Whether or not to give live hints about the list of forbidden unit symbols
							when the user has not yet submitted the input value.</xs:documentation>
						<xs:appinfo>
							<edmldoc:modelattribute/>
						</xs:appinfo>
					</xs:annotation>
				</xs:attribute>
				<xs:attribute name="prefixeshints" type="xs:boolean">
					<xs:annotation>
						<xs:documentation>Whether or not to give live hints about the list of allowed unit prefixes
							when the user has not yet submitted the input value.</xs:documentation>
						<xs:appinfo>
							<edmldoc:modelattribute/>
						</xs:appinfo>
					</xs:annotation>
				</xs:attribute>
				<xs:attribute name="preferredforms">
					<xs:annotation>
						<xs:documentation>Either the special value none or a whitespace-separated list of preferred unit values. When such a list of unit values is given, the user
						is expected to enter exactly one of these. If a unit value which is equivalent to the solution is entered but which is not
						in the list, a warning is shown to the user but the input field is considered correct.</xs:documentation>
						<xs:appinfo>
							<edmldoc:modelattribute/>
						</xs:appinfo>
					</xs:annotation>
					<xs:simpleType>
						<xs:union memberTypes="UnitValueList None"/>
					</xs:simpleType>
				</xs:attribute>
			</xs:extension>
		</xs:simpleContent>
	</xs:complexType>

	<xs:simpleType name="UnitValue">
		<xs:annotation>
			<xs:documentation>A string representing the unit of a physical quantity, such as "kg" or "m*s^-1".
				It must be a sequence of unit symbols separated by *. No whitespace is allowed.
				Every unit symbol consists of an optional prefix (such as k, m or μ) followed by an actual unit (such as m, mol or ohm).
				Furthermore, after every unit symbol one may optionally write ^ followed by a number.
				For example, "mmol^2*kg*μcd^-2" is a valid unit string but "μμ^2" is not valid.
				Quantities without any unit can be represented in this element with the empty string.
			</xs:documentation>
		</xs:annotation>
		<xs:restriction base="xs:string">
			<xs:pattern
				value="((Y|Z|E|P|T|G|M|k|h|da|d|c|m|μ|n|p|f|a|z|y)?(s|m|kg|A|K|mol|cd|rad|sr|Hz|N|Pa|J|W|C|V|F|ohm|S|Wb|T|H|celsius|lm|lx|Bq|Gy|Sv|kat|B)|min|h|d)(\^\-?\d+)?(\*((Y|Z|E|P|T|G|M|k|h|da|d|c|m|μ|n|p|f|a|z|y)?(s|m|kg|A|K|mol|cd|rad|sr|Hz|N|Pa|J|W|C|V|F|ohm|S|Wb|T|H|celsius|lm|lx|Bq|Gy|Sv|kat|B)|min|h|d)(\^\-?\d+)?)*"></xs:pattern>
		</xs:restriction>
	</xs:simpleType>

	<xs:simpleType name="UnitValueList">
		<xs:annotation>
			<xs:documentation>A whitespace-separated list of unit values.</xs:documentation>
		</xs:annotation>
		<xs:list itemType="UnitValue"/>
	</xs:simpleType>

	<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:appinfo>
				<edmldoc:property name="value" datatypes="double" nullable="true" examplevalue="23.56">
					<xs:annotation>
						<xs:documentation>
							The numeric value of the quantity input value element. In the case of an exponential element
							inside this element, this property is computed from the mantissa, base and exponent.
						</xs:documentation>
					</xs:annotation>
				</edmldoc:property>
				<edmldoc:property name="value" datatypes="string" nullable="true" examplevalue="kg*m^2">
					<xs:annotation>
						<xs:documentation>
							The unit entered by the user. The format is the same as in the XML file.
						</xs:documentation>
					</xs:annotation>
				</edmldoc:property>
			</xs:appinfo>
		</xs:annotation>
		<xs:sequence>
			<xs:choice>
				<xs:element name="number" type="NumberInputValue"/>
				<xs:element name="exponential" type="ExponentialInputValue"/>
			</xs:choice>
			<xs:element name="unit" type="UnitInputValue"/>
		</xs:sequence>
		<xs:attributeGroup ref="CommonInputValueAttributes"/>
	</xs:complexType>

	<xs:complexType name="MolecularInputValue">
		<xs:annotation>
			<xs:documentation>An molecular formula input value, such as "H2O".</xs:documentation>
			<xs:appinfo>
				<edmldoc:example><![CDATA[<molecular>H2O</molecular>]]></edmldoc:example>
				<edmldoc:property name="value" datatypes="string" examplevalue="H_2O" nullable="true">
					<xs:annotation>
						<xs:documentation>
							Molecular formular as entered by the user. The format is the same as in the XML file.
						</xs:documentation>
					</xs:annotation>
				</edmldoc:property>
			</xs:appinfo>
		</xs:annotation>
		<xs:simpleContent>
			<xs:extension base="MolecularFormula">
				<xs:attributeGroup ref="CommonInputValueAttributes"/>
			</xs:extension>
		</xs:simpleContent>
	</xs:complexType>

	<xs:simpleType name="MolecularFormula">
		<xs:annotation>
			<xs:documentation>A molecular formula, such as "H2O", "CH3OOH" or "Ca3(PO4)2".</xs:documentation>
		</xs:annotation>
		<xs:restriction base="xs:string">
			<!-- The following regex is exactly the same as below, just intented to make it easier to read:
			(
				(
					[A-Z][a-z]?
					\d*\^?\d*[\+-]?
				)
				|
				(
					\(
					(
						(
							[A-Z][a-z]?
							\d*\^?\d*[\+-]?
						)
						|
						(
							\[
							(
								[A-Z][a-z]?
								\d*\^?\d*[\+-]?
							)+
							\]
							\d*\^?\d*[\+-]?
						)
					)+
					\)
					\d*\^?\d*[\+-]?
				)
				|
				(
					\[
					(
						(
							[A-Z][a-z]?
							\d*\^?\d*[\+-]?
						)
						|
						(
							\(
							(
								[A-Z][a-z]?
								\d*\^?\d*[\+-]?
							)+
							\)
							\d*\^?\d*[\+-]?
						)
					)+
					\]
					\d*\^?\d*[\+-]?
				)
			)+
			!-->
			<xs:pattern value="(([A-Z][a-z]?\d*\^?\d*[\+-]?)|(\((([A-Z][a-z]?\d*\^?\d*[\+-]?)|(\[([A-Z][a-z]?\d*\^?\d*[\+-]?)+\]\d*\^?\d*[\+-]?))+\)\d*\^?\d*[\+-]?)|(\[(([A-Z][a-z]?\d*\^?\d*[\+-]?)|(\(([A-Z][a-z]?\d*\^?\d*[\+-]?)+\)\d*\^?\d*[\+-]?))+\]\d*\^?\d*[\+-]?))+"/>
		</xs:restriction>
	</xs:simpleType>

	<xs:complexType name="ReactionInputValue">
		<xs:annotation>
			<xs:documentation>Shows a chemical reaction to the user and prompts him to enter correct stoichiometric coefficients for the reagents that result in
			a balanced reaction. Each coefficient must be a positive integer.</xs:documentation>
			<xs:appinfo>
				<edmldoc:property name="products" datatypes="string[]" nullable="true" examplevalue="[H_2, O_2]">
					<xs:annotation>
						<xs:documentation>
							The products of the reaction (left part of the chemical reaction).
						</xs:documentation>
					</xs:annotation>
				</edmldoc:property>
				<edmldoc:property name="productcoefficients" datatypes="int[]" nullable="true" examplevalue="[2, 1]">
					<xs:annotation>
						<xs:documentation>
							The coefficients of the products of the chemical reaction.
						</xs:documentation>
					</xs:annotation>
				</edmldoc:property>
				<edmldoc:property name="educts" datatypes="string[]" nullable="true" examplevalue="[H_2O]">
					<xs:annotation>
						<xs:documentation>
							The educts of the reaction (right part of the chemical reaction).
						</xs:documentation>
					</xs:annotation>
				</edmldoc:property>
				<edmldoc:property name="eductcoefficients" datatypes="int[]" nullable="true" examplevalue="[1]">
					<xs:annotation>
						<xs:documentation>
							The coefficients of the educts of the chemical reaction.
						</xs:documentation>
					</xs:annotation>
				</edmldoc:property>
				<edmldoc:example><![CDATA[<reaction type="forward">
	<educts>
		<molecule>CH4</molecule>
		<molecule>O2</molecule>
	</educts>
	<product>
		<molecule>H2O</molecule>
		<molecule>CO2</molecule>
	</product>
</reaction>]]></edmldoc:example>
			</xs:appinfo>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="educts" type="ReactionEducts"/>
			<xs:element name="products" type="ReactionProducts"/>
		</xs:sequence>
		<xs:attributeGroup ref="CommonInputValueAttributes"/>
		<xs:attribute name="type" type="ReactionType">
			<xs:annotation>
				<xs:documentation>Describes the type of the chemical reaction. This decides what symbol is placed between the educts and the products.</xs:documentation>
				<xs:appinfo>
					<edmldoc:modelattribute/>
				</xs:appinfo>
			</xs:annotation>
		</xs:attribute>
		<xs:attribute name="reduced" type="xs:boolean">
			<xs:annotation>
				<xs:documentation>Whether or not the user should be force to reduce the entered coefficients in this reaction to the smallest
					possible positive integers.</xs:documentation>
				<xs:appinfo>
					<edmldoc:modelattribute/>
				</xs:appinfo>
			</xs:annotation>
		</xs:attribute>
	</xs:complexType>

	<xs:complexType name="ReactionEducts">
		<xs:annotation>
			<xs:documentation>Contains the list of all educts of a chemical reaction.</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="molecule" type="ReactionMolecule" minOccurs="1" maxOccurs="unbounded"/>
		</xs:sequence>
		<xs:attribute name="fixed" type="xs:boolean">
			<xs:annotation>
				<xs:documentation>If the number of educts of the reaction should be fixed and revealed to the user as
					given in the solution. When set to false, the number of educts must be found out.</xs:documentation>
				<xs:appinfo>
					<edmldoc:modelattribute/>
				</xs:appinfo>
			</xs:annotation>
		</xs:attribute>
	</xs:complexType>

	<xs:complexType name="ReactionEductsModel">
		<xs:annotation>
			<xs:documentation>Settings element inside the <code>reaction</code> input model which is used to specify
				settings related to the educts.</xs:documentation>
		</xs:annotation>
		<xs:attribute name="fixed" type="xs:boolean" default="false">
			<xs:annotation>
				<xs:documentation>If the number of educts of the reaction should be fixed and revealed to the user as
					given in the solution. When set to false, the number of educts must be found out.</xs:documentation>
				<xs:appinfo>
					<edmldoc:modelattribute/>
				</xs:appinfo>
			</xs:annotation>
		</xs:attribute>
	</xs:complexType>

	<xs:complexType name="ReactionProducts">
		<xs:annotation>
			<xs:documentation>Contains the list of all products of a chemical reaction.</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="molecule" type="ReactionMolecule" minOccurs="1" maxOccurs="unbounded"/>
		</xs:sequence>
		<xs:attribute name="fixed" type="xs:boolean">
			<xs:annotation>
				<xs:documentation>If the number of products of the reaction should be fixed and revealed to the user as
					given in the solution. When set to false, the number of products must be found out.</xs:documentation>
				<xs:appinfo>
					<edmldoc:modelattribute/>
				</xs:appinfo>
			</xs:annotation>
		</xs:attribute>
	</xs:complexType>

	<xs:complexType name="ReactionProductsModel">
		<xs:annotation>
			<xs:documentation>Settings element inside the <code>reaction</code> input model which is used to specify
				settings related to the products.</xs:documentation>
		</xs:annotation>
		<xs:attribute name="fixed" type="xs:boolean" default="false">
			<xs:annotation>
				<xs:documentation>If the number of products of the reaction should be fixed and revealed to the user as
					given in the solution. When set to false, the number of products must be found out.</xs:documentation>
				<xs:appinfo>
					<edmldoc:modelattribute/>
				</xs:appinfo>
			</xs:annotation>
		</xs:attribute>
	</xs:complexType>

	<xs:complexType name="ReactionMolecule">
		<xs:annotation>
			<xs:documentation>A molecule that takes part in a chemical reaction given by a molecular formular.
			The format is the same as for the <code>molecular</code> element.</xs:documentation>
			<xs:appinfo>
				<edmldoc:example><![CDATA[<molecule>H2O</molecule>]]></edmldoc:example>
			</xs:appinfo>
		</xs:annotation>
		<xs:simpleContent>
			<xs:extension base="MolecularFormula">
				<xs:attribute name="coefficient" type="xs:positiveInteger">
					<xs:annotation>
						<xs:documentation>Provides a predefined and fixed coefficient that will be used and displayed for this molecule.
						If this attribute is not set, the user must enter the coefficient of this molecule on his or her own.</xs:documentation>
					</xs:annotation>
				</xs:attribute>
				<xs:attribute name="fixed" type="xs:boolean" default="false">
					<xs:annotation>
						<xs:documentation>Specifies whether the molecular formular (not the coefficient) should be fixed and shown to the user.
						If this attribute is enabled, the molecular formular is shown to the user and cannot be changed by the user.
						Otherwise, the user must enter the molecular formular.</xs:documentation>
					</xs:annotation>
				</xs:attribute>
			</xs:extension>
		</xs:simpleContent>
	</xs:complexType>

	<xs:complexType name="Calculate">
		<xs:annotation>
			<xs:documentation>Calculates a number or mathematical expression from a given input expression. The input
				expression is processed by the Computer Algebra System (CAS) and can involve parameters that are defined
				by the "parameter" element in the surrounding container. These are then replaced by the values of the
				respective parameters. All other variables in the input expression are treated as unknown variables.
				When the "calc" element is contained in an "m" element, its output is LaTeX code. Otherwise, the
				output of this element is in a simple arithmetic format specific to the CAS where fractions are written
				in the format a/b and multiplication is written a*b.
			</xs:documentation>
			<xs:appinfo>
				<edmldoc:example><![CDATA[<exercisebox>
	<parameter identifier="a">
		<value>1</value>
		<value>2</value>
	</parameter>
	<p>What are the zeros of the polynomial <m><calc>2*a</calc>+x</m>?</p>
</exercisebox>]]></edmldoc:example>
			</xs:appinfo>
		</xs:annotation>
		<xs:simpleContent>
			<xs:extension base="xs:string">
				<xs:attribute name="simplify" type="xs:boolean" default="true">
					<xs:annotation>
						<xs:documentation xml:lang="en">
							Whether or not the result of the calculation should be simplified.
						</xs:documentation>
						<xs:documentation xml:lang="de">
							Gibt an, ob das Ergebnis der Berechnung vereinfacht werden soll.
						</xs:documentation>
					</xs:annotation>
				</xs:attribute>
				<xs:attribute name="numberformat" type="CalculateNumberFormat" default="fractions">
					<xs:annotation>
						<xs:documentation xml:lang="en">
							Decides in what format numbers should appear in the output of this element. Can either be
							one of "fractions" or "decimals" or a value of the form "decimals n" where n is the number
							of places after the decimal separator that should be shown.
						</xs:documentation>
						<xs:documentation xml:lang="de">
							Das Zahlenformat, welches für Zahlen in der Ausgabe dieses Elements benutzt werden soll.
							Der Wert muss "fractions" oder "decimals" sein oder ein Wert der Form "decimals n", wobei n
							die Anzahl der Nachkommastellen ist, die angezeigt werden sollen.
						</xs:documentation>
					</xs:annotation>
				</xs:attribute>
				<xs:attribute name="trailingzeros" type="xs:boolean" default="true">
					<xs:annotation>
						<xs:documentation xml:lang="en">
							Controls whether trailing zeros should be displayed when the numberformat attribute is set
							to display a fixed number of places.
						</xs:documentation>
						<xs:documentation xml:lang="de">
							Bestimmt ob Nullen als hinterste Stellen im Nachkommaanteil der Zahl angezeigt werden
							sollen, wenn das Zahlenformat mit dem numberformat Attribut auf eine feste Anzahl Stellen
							eingestellt ist.
						</xs:documentation>
					</xs:annotation>
				</xs:attribute>
			</xs:extension>
		</xs:simpleContent>
	</xs:complexType>

	<xs:simpleType name="CalculateNumberFormat">
		<xs:annotation>
			<xs:documentation>
				Format in which a number is displayed. Can either be one of "fractions" or "decimals" or a value of the
				form "decimals n" where n is the number of places after the decimal separator that should be shown.
			</xs:documentation>
		</xs:annotation>
		<xs:union>
			<xs:simpleType>
				<xs:restriction base="xs:string">
					<xs:enumeration value="fractions">
						<xs:annotation>
							<xs:documentation>Format numbers as fractions.</xs:documentation>
						</xs:annotation>
					</xs:enumeration>
					<xs:enumeration value="decimals">
						<xs:annotation>
							<xs:documentation>Format numbers as decimal numbers.</xs:documentation>
						</xs:annotation>
					</xs:enumeration>
				</xs:restriction>
			</xs:simpleType>
			<xs:simpleType>
				<xs:restriction base="xs:string">
					<xs:pattern value="decimals (\d)+"/>
				</xs:restriction>
			</xs:simpleType>
		</xs:union>
	</xs:simpleType>

	<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 an input element
				by setting <code>to</code> attribute to the name of an "input", "inputblock" or "booleangroup" element
				on the same page in which the solution hint is defined. 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.
				Solution hints are not displayed during tests.
			</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="Step"/>
		</xs:sequence>
		<xs:attributeGroup ref="CommonContentElementAttributes"/>
		<xs:attribute name="to" type="xs:Name" use="optional">
			<xs:annotation>
				<xs:documentation xml:lang="en">
					When set, links this solution hint to the input element of the page with the given name. Must be
					the name of an "input", "inputblock" or "booleangroup" element.
				</xs:documentation>
				<xs:documentation xml:lang="de">
					Wenn dieses Attribut gesetzt ist, wird der Lösungshinweis an das Eingabeelement der Seite gebunden,
					welches den Namen hat, der im Attribut angegeben ist. Es muss sich um den Namen eines "input",
					"inputblock" oder "booleangroup" Elements handeln.
				</xs:documentation>
			</xs:annotation>
		</xs:attribute>
		<xs:attribute name="mode" type="SolutionHintMode" default="sequence">
			<xs:annotation>
				<xs:documentation>
					Whether the steps of this element should be displayed in sequence (sequence) or with several steps
					visible at once where the new ones are appended below the last one (append).
				</xs:documentation>
			</xs:annotation>
		</xs:attribute>
	</xs:complexType>

	<xs:simpleType name="SolutionHintMode">
		<xs:annotation>
			<xs:documentation>
				Mode in which the steps of a solutionhint element are displayed.
			</xs:documentation>
		</xs:annotation>
		<xs:restriction base="xs:NMTOKEN">
			<xs:enumeration value="sequence">
				<xs:annotation>
					<xs:documentation>
						Display the steps in sequence, one after another. Only one step is visible at a time.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="append">
				<xs:annotation>
					<xs:documentation>
						Append every new step below the last one. Several steps can be visible at once.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
		</xs:restriction>
	</xs:simpleType>
	
	<xs:complexType name="Help">
		<xs:annotation>
			<xs:documentation>A collapsable help block that consists of one or multiple steps. This element can be used to give the user help on how to solve
			an exercise or to give technical assistance with the course.</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="Step"/>
		</xs:sequence>
		<xs:attributeGroup ref="CommonContentElementAttributes"/>
		<xs:attribute name="open" type="xs:boolean" default="true">
			<xs:annotation> 
				<xs:documentation>Whether or not the help block should be initially open or not.</xs:documentation>
			</xs:annotation>
		</xs:attribute>
	</xs:complexType>

	<xs:complexType name="Step">
		<xs:annotation>
			<xs:documentation>A step of a solution hint or a help block.</xs:documentation>
		</xs:annotation>
		<xs:sequence minOccurs="0" maxOccurs="unbounded">
			<xs:group ref="BlockGroup"/>
		</xs:sequence>
		<xs:attributeGroup ref="CommonContentElementAttributes"/>
	</xs:complexType>

	<xs:complexType name="BooleanGroup">
		<xs:annotation>
			<xs:documentation>A block element whose purpose is to group together boolean
				input fields into single or multiple choice questions. It affects all input elements with boolean values inside this element.
			</xs:documentation>
			<xs:appinfo>
				<sch:pattern>
					<sch:rule context="edml:booleangroup[@minselection][@maxselection]">
						<sch:assert test="@maxselection = 'unbounded' or @minselection &lt;= @maxselection">
							The minselection attribute value of a booleangroup element must be less than or equal to the maxselection attribute value.
						</sch:assert>
					</sch:rule>
				</sch:pattern>
			</xs:appinfo>
		</xs:annotation>
		<xs:sequence minOccurs="0" maxOccurs="unbounded">
			<xs:group ref="BlockGroup"/>
		</xs:sequence>
		<xs:attributeGroup ref="CommonContentElementAttributes"/>
		<xs:attributeGroup ref="CommonInputElementAttributes"/>
		<xs:attributeGroup ref="RevealAttribute"/>
		<xs:attribute name="minselection" use="optional" default="1" type="xs:nonNegativeInteger">
			<xs:annotation>
				<xs:documentation>Minimum number of boolean inputs the user has to select in this boolean group before he or she can check his or her results.</xs:documentation>
			</xs:annotation>
		</xs:attribute>
		<xs:attribute name="maxselection" use="optional" default="unbounded">
			<xs:annotation>
				<xs:documentation>Maximum number of boolean inputs the user can select in this boolean group and still check his or her results.</xs:documentation>
			</xs:annotation>
			<xs:simpleType>
				<xs:union memberTypes="xs:positiveInteger Unbounded"/>
			</xs:simpleType>
		</xs:attribute>
		<xs:attribute name="expectedselection" default="none">
			<xs:annotation>
				<xs:documentation>When set to a value different to none, this specifies the number of correctly selected boolean inputs in this boolean group that the user has to
				select in order for the boolean group to count as correct. If this attribute is set to none, the user is expected to select all boolean inputs in the group
				marked as correct.</xs:documentation>
			</xs:annotation>
			<xs:simpleType>
				<xs:union memberTypes="xs:positiveInteger None"/>
			</xs:simpleType>
		</xs:attribute>
		<xs:attribute name="maxtotalcredits" use="optional" default="unbounded">
			<xs:annotation>
				<xs:documentation>Total maximal number of credit points the user can earn in this boolean group from boolean input fields.</xs:documentation>
			</xs:annotation>
			<xs:simpleType>
				<xs:union memberTypes="xs:nonNegativeInteger Unbounded"/>
			</xs:simpleType>
		</xs:attribute>
		<xs:attribute name="maxtotalpenalty" use="optional" default="unbounded">
			<xs:annotation>
				<xs:documentation>Total maximal number of credit points the user can get deducted in this boolean group from boolean input fields.</xs:documentation>
			</xs:annotation>
			<xs:simpleType>
				<xs:union memberTypes="xs:nonNegativeInteger Unbounded"/>
			</xs:simpleType>
		</xs:attribute>
		<xs:attribute name="feedback" use="optional" type="InputGroupFeedbackMode" default="group">
			<xs:annotation>
				<xs:documentation>Whether to give the user only feedback about the correctness of the group result (group) or about all individual boolean fields (detailed).
				</xs:documentation>
			</xs:annotation>
		</xs:attribute>
		<xs:attribute name="defaultpenalty" default="1" type="xs:nonNegativeInteger">
			<xs:annotation>
				<xs:documentation>Specifies the default penalty of all boolean input fields inside this booleangroup.</xs:documentation>
			</xs:annotation>
		</xs:attribute>
		<xs:attribute name="toggle" default="false" type="xs:boolean">
			<xs:annotation>
				<xs:documentation>
					Whether or not all boolean input fields contained in this boolean group should be displayed as
					toggleable regions. If there are labels associated to these input fields, then they are part of the
					toggleable regions.
				</xs:documentation>
			</xs:annotation>
		</xs:attribute>
	</xs:complexType>

	<xs:simpleType name="InputGroupFeedbackMode">
		<xs:annotation>
			<xs:documentation>Enumeration that decides about the type of feedback for input groups which the user receives when checking his or her results.
			</xs:documentation>
		</xs:annotation>
		<xs:restriction base="xs:NMTOKEN">
			<xs:enumeration value="group">
				<xs:annotation>
					<xs:documentation>Only give feedback about the correctness of the whole group.</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="detailed">
				<xs:annotation>
					<xs:documentation>Give feedback about the correctness of the whole group and all individual input fields.</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
		</xs:restriction>
	</xs:simpleType>

	<xs:complexType name="StringGroup">
		<xs:annotation>
			<xs:documentation>A string group element allows to user to see all the solutions of string input fields
				contained in the string group and to drag them onto these fields. The solutions are shuffled randomly
				and shown as a list of draggable boxes below the content of the string group. All block and inline
				elements contained the string group are displayed as usual in addition to the list of solutions.
			</xs:documentation>
		</xs:annotation>
		<xs:sequence minOccurs="0" maxOccurs="unbounded">
			<xs:group ref="BlockGroup"/>
		</xs:sequence>
		<xs:attributeGroup ref="CommonContentElementAttributes"/>
	</xs:complexType>

	<xs:simpleType name="Length">
		<xs:annotation>
			<xs:documentation><p>A length consists of a decimal number followed by a unit, such as <code>20px</code>, <code>150.75em</code> or <code>22.5ex</code>.
			The following units are allowed:</p>
			<ul>
				<li><code>px</code>: Pixels</li>
				<li><code>cm</code>: Centimeters</li>
				<li><code>in</code>: Inches</li>
				<li><code>em</code>: Unit equal to the <a href="https://en.wikipedia.org/wiki/Em_(typography)">em quad size</a> of the font typeface of the
				current element.</li>
				<li><code>ex</code>: Unit equal to the <a href="https://en.wikipedia.org/wiki/X-height">x-height</a> of the font typeface of the current element.</li>
			</ul>
			<p>Additionally, the zero value <code>0</code> is allowed without any unit as a special case. No whitespace or newline characters are allowed.</p>
			<p>Each such value is a valid element of the <a href="https://w3c.github.io/csswg-drafts/css-values-4/#lengths">CSS length data type</a>
			according to the CSS4 specification, but the CSS4 specification allows more units.</p></xs:documentation>
		</xs:annotation>
		<xs:restriction base="xs:string">
			<xs:pattern value="0|([0-9]+(\.[0-9]+)?(px|cm|in|em|ex))"/>
		</xs:restriction>
	</xs:simpleType>

	<xs:simpleType name="LengthPercentage">
		<xs:annotation>
			<xs:documentation><p>Either a <a href="#Length">length</a>, such as <code>20px</code> or <code>5.5ex</code>, or a decimal number followed by a
			percentage sign, such as <code>50%</code> or <code>25.75%</code>. Percentage values are relative to the parent element of the concerned element.</p>
			<p>No whitespace or newline characters are allowed.</p>
			<p>Each such value is a valid element of the
			<a href="https://w3c.github.io/csswg-drafts/css-values-4/#typedef-length-percentage">CSS length-percentage data type</a> according to the CSS4
			specification, but the CSS4 specification allows more length units.</p></xs:documentation>
		</xs:annotation>
		<xs:restriction base="xs:string">
			<xs:pattern value="0|([0-9]+(\.[0-9]+)?(px|cm|in|em|ex|%))"/>
		</xs:restriction>
	</xs:simpleType>

	<xs:simpleType name="Auto">
		<xs:annotation>
			<xs:documentation>Type whose only value is "auto". This specifies that the corresponding attribute should have a smart default value or be automatically calculated based
				on other values by the application.</xs:documentation>
		</xs:annotation>
		<xs:restriction base="xs:NMTOKEN">
			<xs:enumeration value="auto">
				<xs:annotation>
					<xs:documentation>Value should be automatically determined.</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
		</xs:restriction>
	</xs:simpleType>

	<xs:simpleType name="None">
		<xs:annotation>
			<xs:documentation>Type whose only value is "none". This specifies the absense of a value.</xs:documentation>
		</xs:annotation>
		<xs:restriction base="xs:NMTOKEN">
			<xs:enumeration value="none">
				<xs:annotation>
					<xs:documentation>Value is absent.</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
		</xs:restriction>
	</xs:simpleType>

	<xs:simpleType name="Unbounded">
		<xs:annotation>
			<xs:documentation>Type whose only value is "unbounded". This is used to specify that some value should not have an upper bound.</xs:documentation>
		</xs:annotation>
		<xs:restriction base="xs:NMTOKEN">
			<xs:enumeration value="unbounded">
				<xs:annotation>
					<xs:documentation>Value has no upper bound.</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
		</xs:restriction>
	</xs:simpleType>

	<xs:simpleType name="All">
		<xs:annotation>
			<xs:documentation>Type whose only value is "all". This is used to specify the whole of some collection.</xs:documentation>
		</xs:annotation>
		<xs:restriction base="xs:NMTOKEN">
			<xs:enumeration value="all">
				<xs:annotation>
					<xs:documentation>Include all available elements in the collection.</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
		</xs:restriction>
	</xs:simpleType>

	<xs:simpleType name="TokenList">
		<xs:annotation>
			<xs:documentation>A whitespace-separated list of tags.</xs:documentation>
		</xs:annotation>
		<xs:list itemType="xs:NMTOKEN"/>
	</xs:simpleType>
</xs:schema>
