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

	<xs:annotation>
		<xs:appinfo>
			<sch:ns prefix="edml" uri="http://mint-kolleg.kit.edu/edML"/>
		</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="1" maxOccurs="1" type="CourseSettings"/>
			<xs:sequence>
				<xs:element ref="variant" minOccurs="1" maxOccurs="unbounded"/>
			</xs:sequence>
		</xs:sequence>
		<xs:attributeGroup ref="RootAttributes"/>
		<xs:attribute name="edmlversion" type="xs:NMTOKEN" use="required" fixed="0.4.0">
			<xs:annotation>
				<xs:documentation>Version of the education markup language that this course is written in. Must match the language version of this schema.</xs:documentation>
			</xs:annotation>
		</xs:attribute>
	</xs:complexType>

	<xs:complexType name="CourseSettings">
		<xs:annotation>
			<xs:documentation>Contains all global course settings.</xs:documentation>
		</xs:annotation>
		<xs:all>
			<xs:element name="defaultvariant" minOccurs="0" maxOccurs="1" type="xs:language">
				<xs:annotation>
					<xs:documentation>Sets the default variant of the course by specifying its language.</xs:documentation>
				</xs:annotation>
			</xs:element>
			<xs:element name="inputmodels" minOccurs="0" maxOccurs="1" type="InputModels"/>
			<xs:element name="styles" minOccurs="0" maxOccurs="1" type="Styles"/>
		</xs:all>
	</xs:complexType>

	<xs:complexType name="Styles">
		<xs:annotation>
			<xs:documentation>Contains one or more style assignments to elements with specified roles.</xs:documentation>
			<xs:appinfo>
				<edmldoc:example>
					<edmldoc:code><![CDATA[<styles>
	<style role="base">
		color: blue;
	</style>
	<style role="acid">
		color: red;
	</style>
</styles>]]></edmldoc:code>
				</edmldoc:example>
			</xs:appinfo>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="style" type="Style" minOccurs="1" maxOccurs="unbounded"/>
		</xs:sequence>
	</xs:complexType>

	<xs:complexType name="Style">
		<xs:annotation>
			<xs:documentation>Assigns a list of style declarations to all elements with a specified role.</xs:documentation>
			<xs:appinfo>
				<edmldoc:example>
					<edmldoc:code><![CDATA[<style role="term">
	font-weight: bold;
</style>]]></edmldoc:code>
				</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="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="navigation" type="Navigation"/>
			<xs:element name="pages" type="Pages"/>
		</xs:sequence>
		<xs:attribute name="lang" use="required" type="xs:language">
			<xs:annotation>
				<xs:documentation>Language of this course variant according to RFC 5646, must be unique among all course variants in this course.</xs:documentation>
			</xs:annotation>
		</xs:attribute>
		<xs: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="RootAttributes"/>
	</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 either a course variant, a page, a container or a panel.</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:group ref="InlineGroup" minOccurs="0" maxOccurs="unbounded"/>
		</xs:sequence>
		<xs:attribute name="short" use="optional" type="xs:string">
			<xs:annotation>
				<xs:documentation>Alternative short version of the title that can be used in situations where the full title can not be displayed.</xs:documentation>
			</xs:annotation>
		</xs:attribute>
	</xs:complexType>

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

	<xs:complexType name="NavigationList">
		<xs:annotation>
			<xs:documentation>A list of one or more navigation items or tests in the navigation menu.</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:choice maxOccurs="unbounded">
				<xs:element name="navitem" type="NavigationItem"/>
				<xs:element name="test" type="Test"/>
			</xs:choice>
		</xs:sequence>
		<xs:attribute name="format" type="LabelFormat" use="optional" default="arabic">
			<xs:annotation>
				<xs:documentation>Format used for the automatically generated label of the navigation items in this list.</xs:documentation>
			</xs:annotation>
		</xs:attribute>
		<xs:attribute name="separator" type="xs:string" use="optional" default=".">
			<xs:annotation>
				<xs:documentation>Separator used in the automatically generated label of the navigation items in this list.</xs:documentation>
			</xs:annotation>
		</xs:attribute>
		<xs:attribute name="lastsep" type="xs:boolean" use="optional" default="false">
			<xs:annotation>
				<xs:documentation>Controls whether the last separator should be shown in the automatically generated label of the navigation items in this list.
				</xs:documentation>
			</xs:annotation>
		</xs:attribute>
	</xs:complexType>

	<xs:complexType name="Test">
		<xs:annotation>
			<xs:documentation>A Test is a special part of the navigation menu which consists of one or more test items.
				Each test item links to a test page that must be worked through by the user in order to complete the test.</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="title" type="Title"/>
			<xs:element name="testlist" minOccurs="0" type="TestList"/>
		</xs:sequence>
	</xs:complexType>

	<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, which the user must work through as part of the test.</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="ref" type="Ref"/>
			<xs:element name="testlist" minOccurs="0" type="TestList"/>
		</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>One item in the navigation menu of the course variant.</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:choice minOccurs="0" maxOccurs="1">
				<xs:element name="ref" type="Ref"/>
				<xs:element name="link" type="Link"/>
			</xs:choice>
			<xs:element name="navlist" type="NavigationList" minOccurs="0" maxOccurs="1"/>
		</xs:sequence>
		<xs:attribute name="name" type="xs:Name" use="optional">
			<xs:annotation>
				<xs:documentation>Name of this navigation item, must be unique among all names in this course variant.</xs:documentation>
			</xs:annotation>
		</xs:attribute>
		<xs:attribute name="tags" type="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" use="optional" default="true">
			<xs:annotation>
				<xs:documentation>Whether or not this navigation item increases the counter for the automatically generated labels.</xs:documentation>
			</xs:annotation>
		</xs:attribute>
		<xs:attribute name="label" type="xs:string" use="optional">
			<xs:annotation>
				<xs:documentation>Custom label of this navigation item, overrides any automatically generated labels.</xs:documentation>
			</xs:annotation>
		</xs:attribute>
		<xs:attributeGroup ref="DifficultyAttribute"/>
	</xs:complexType>

	<xs:simpleType name="NavigationItemRoleList">
		<xs:annotation>
			<xs:documentation>A 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>Name of this page, must be unique among all names in this course variant.</xs:documentation>
			</xs:annotation>
		</xs:attribute>
		<xs:attribute name="tags" type="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="RootAttributes"/>
	</xs:complexType>

	<xs:attributeGroup name="RootAttributes">
		<xs:attribute ref="xml:base"/>
	</xs:attributeGroup>

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

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

	<xs:element name="variant" type="Variant">
		<xs:unique name="Variant_Name">
			<xs:selector xpath=".//*"/>
			<xs:field xpath="@name"/>
		</xs:unique>
		<xs:keyref name="Variant_Ref" refer="Variant_Name">
			<xs:selector xpath=".//edml:ref"/>
			<xs:field xpath="@to"/>
		</xs:keyref>
	</xs:element>

	<xs:element name="page" type="Page">
		<xs:unique name="Page_Name">
			<xs:selector xpath=".//*"/>
			<xs:field xpath="@name"/>
		</xs:unique>
		<xs:unique name="Page_InputName">
			<xs:selector xpath=".//edml:input"/>
			<xs:field xpath="@name"/>
		</xs:unique>
		<xs:keyref name="Page_SolutionHint" refer="Page_InputName">
			<xs:selector xpath="edml:solutionhint"/>
			<xs:field xpath="@to"/>
		</xs:keyref>
	</xs:element>

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

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

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

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

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

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

	<xs:complexType name="ParameterRange">
		<xs:annotation>
			<xs:documentation>Uniformly generates a random value from a specified range for a parameter.
				The start and end values for the range must be defined in the child elements.
				In contrast to the values appearing direct in the parameter element, these two values must be numbers.
			</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="value" minOccurs="2" maxOccurs="2" type="NumericParameterValue"/>
		</xs:sequence>
		<xs:attributeGroup ref="ParameterWeightAttribute"/>
		<xs:attribute name="step" use="optional" default="continuous">
			<xs:annotation>
				<xs:documentation>If the step value is a number, then 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.
					On the other hand, if the special value "continuous" is used, the range is a continuous interval.
				</xs:documentation>
			</xs:annotation>
			<xs:simpleType>
				<xs:union memberTypes="PositiveDecimal Continuous"/>
			</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="Box">
		<xs:sequence>
			<xs:element name="title" type="Title" minOccurs="0" maxOccurs="1"/>
			<xs:element name="parameter" minOccurs="0" maxOccurs="unbounded" type="Parameter"/>
			<xs:group ref="BlockGroup" minOccurs="0" maxOccurs="unbounded"/>
		</xs:sequence>
		<xs:attributeGroup ref="CommonContainerAttributes"/>
		<xs:attributeGroup ref="CommonBoxAttributes"/>
	</xs:complexType>

	<xs:attributeGroup name="CommonBoxAttributes">
		<xs:attribute name="subtype" type="xs:Name">
			<xs:annotation>
				<xs:documentation>An optional subtype that further describes the content type of this box. For example, a theorembox can have the subtype "lemma".
				</xs:documentation>
			</xs:annotation>
		</xs:attribute>
	</xs:attributeGroup>

	<xs:attributeGroup name="DifficultyAttribute">
		<xs:attribute name="difficulty" type="xs: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:sequence>
			<xs:element name="title" type="Title" minOccurs="0" maxOccurs="1"/>
			<xs:sequence minOccurs="0" maxOccurs="unbounded">
				<xs:sequence>
					<xs:element name="parameter" minOccurs="0" maxOccurs="unbounded" type="Parameter"/>
					<xs:group ref="BlockGroup"/>
				</xs:sequence>
			</xs:sequence>
		</xs:sequence>
		<xs:attributeGroup ref="CommonContainerAttributes"/>
		<xs:attributeGroup ref="CommonBoxAttributes"/>
		<xs:attributeGroup ref="DifficultyAttribute"/>
	</xs:complexType>

	<xs:complexType name="ExampleBox">
		<xs:sequence>
			<xs:element name="title" type="Title" minOccurs="0" maxOccurs="1"/>
			<xs:sequence minOccurs="0" maxOccurs="unbounded">
				<xs:sequence>
					<xs:element name="parameter" minOccurs="0" maxOccurs="unbounded" type="Parameter"/>
					<xs:group ref="BlockGroup"/>
				</xs:sequence>
			</xs:sequence>
		</xs:sequence>
		<xs:attributeGroup ref="CommonContainerAttributes"/>
		<xs:attributeGroup ref="CommonBoxAttributes"/>
		<xs:attributeGroup ref="DifficultyAttribute"/>
	</xs:complexType>

	<xs:complexType name="GroupView">
		<xs:annotation>
			<xs:documentation>A view that wraps a sequence of containers and has an optional title.</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="title" type="Title" minOccurs="0" maxOccurs="1"/>
			<xs:sequence minOccurs="1" maxOccurs="unbounded">
				<xs:group ref="ContainerGroup"/>
			</xs:sequence>
		</xs:sequence>
		<xs:attributeGroup ref="CommonContainerAttributes"/>
		<xs:attributeGroup ref="DifficultyAttribute"/>
	</xs: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.</xs:documentation>
			<xs:appinfo>
				<edmldoc:hint>This element should not be used to hold solutions. For this task, use the <code>solutionhint</code> element.</edmldoc:hint>
			</xs:appinfo>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="title" type="Title" minOccurs="0" maxOccurs="1"/>
			<xs:element name="groupview" type="TitledGroupView" minOccurs="1" maxOccurs="unbounded"/>
		</xs:sequence>
		<xs:attributeGroup ref="CommonContainerAttributes"/>
		<xs: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.</xs:documentation>
			<xs:appinfo>
				<edmldoc:hint>This element should not be used to hold solutions. For this task, use the <code>solutionhint</code> element.</edmldoc:hint>
			</xs:appinfo>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="title" type="Title" minOccurs="0" maxOccurs="1"/>
			<xs:element name="groupview" type="TitledGroupView" minOccurs="1" maxOccurs="unbounded"/>
		</xs:sequence>
		<xs:attributeGroup ref="CommonContainerAttributes"/>
	</xs:complexType>

	<xs:complexType name="CarouselView">
		<xs:annotation>
			<xs:documentation>A view that warps a sequence of group views (with optional titles) and displays them in a carousel. Only one of the group views
				is visible at once and the user can go to the next or previous one on demand.
			</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="title" type="Title" minOccurs="0" maxOccurs="1"/>
			<xs:element name="groupview" type="GroupView" minOccurs="1" maxOccurs="unbounded"/>
		</xs:sequence>
		<xs: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:group name="ContainerGroup">
		<xs:choice>
			<xs:group ref="BoxGroup"/>
			<xs:group ref="ViewGroup"/>
		</xs:choice>
	</xs:group>

	<xs:group name="BoxGroup">
		<xs:choice>
			<xs:element name="textbox" type="Box">
				<xs:annotation>
					<xs:documentation>A container with block content.</xs:documentation>
				</xs:annotation>
			</xs:element>
			<xs:element name="infobox" type="Box">
				<xs:annotation>
					<xs:documentation>A container with block content tagged as information.</xs:documentation>
				</xs:annotation>
			</xs:element>
			<xs:element name="hintbox" type="Box">
				<xs:annotation>
					<xs:documentation>A container with block content tagged as a hint.</xs:documentation>
				</xs:annotation>
			</xs:element>
			<xs:element name="helpbox" type="Box">
				<xs:annotation>
					<xs:documentation>A container with block content tagged as help.</xs:documentation>
				</xs:annotation>
			</xs:element>
			<xs:element name="remarkbox" type="Box">
				<xs:annotation>
					<xs:documentation>A container with block content tagged as remark.</xs:documentation>
				</xs:annotation>
			</xs:element>
			<xs:element name="examplebox" type="ExampleBox">
				<xs:annotation>
					<xs:documentation>A container with block content tagged as example.</xs:documentation>
				</xs:annotation>
			</xs:element>
			<xs:element name="theorembox" type="Box">
				<xs:annotation>
					<xs:documentation>A container with block content tagged as theorem.</xs:documentation>
				</xs:annotation>
			</xs:element>
			<xs:element name="proofbox" type="Box">
				<xs:annotation>
					<xs:documentation>A container with block content tagged as a proof.</xs:documentation>
				</xs:annotation>
			</xs:element>
			<xs:element name="definitionbox" type="Box">
				<xs:annotation>
					<xs:documentation>A container with block content tagged as a definition.</xs:documentation>
				</xs:annotation>
			</xs:element>
			<xs:element name="experimentbox" type="Box">
				<xs:annotation>
					<xs:documentation>A container with block content tagged as an experiment.</xs:documentation>
				</xs:annotation>
			</xs:element>
			<xs:element name="exercisebox" type="ExerciseBox">
				<xs:annotation>
					<xs:documentation>A container with block content tagged as exercise.</xs:documentation>
				</xs:annotation>
			</xs:element>
			<xs:element name="conventionbox" type="Box">
				<xs:annotation>
					<xs:documentation>A box whose content is a convention. A convention is a determination that is valid for the whole course or a part of the course.
					</xs:documentation>
				</xs:annotation>
			</xs:element>
			<xs:element name="formulabox" type="Box">
				<xs:annotation>
					<xs:documentation>A box whose main purpose is to present a formula to the user.</xs:documentation>
				</xs:annotation>
			</xs:element>
			<xs:element name="applicationbox" type="Box">
				<xs:annotation>
					<xs:documentation>A box for content that describes an application of other content.</xs:documentation>
				</xs:annotation>
			</xs:element>
		</xs:choice>
	</xs:group>

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

	<xs:attributeGroup name="CommonContainerAttributes">
		<xs:attribute name="name" type="xs:Name" use="optional">
			<xs:annotation>
				<xs:documentation>Name of this container, must be unique among all names in this course variant.</xs:documentation>
			</xs:annotation>
		</xs:attribute>
		<xs:attribute name="tags" type="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" use="optional">
			<xs:annotation>
				<xs:documentation>Name of this content element, must be unique among all names in this course variant.</xs:documentation>
			</xs:annotation>
		</xs:attribute>
		<xs:attribute name="tags" type="TokenList" use="optional" default="">
			<xs:annotation>
				<xs:documentation>Whitespace-separated list of tags for this content element.</xs:documentation>
			</xs:annotation>
		</xs:attribute>
	</xs:attributeGroup>

	<xs:group name="InlineGroup">
		<xs:choice>
			<xs:element name="strong" type="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="calculate" type="Calculate"/>
			<xs:element name="note" type="Note"/>
		</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: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: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: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: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="accordion" type="Accordion"/>
			<xs:element name="tabset" type="TabSet"/>
			<xs:element name="externmedia" type="ExternMedia"/>
			<xs:element name="inputblock" type="BlockInput"/>
		</xs:choice>
	</xs:group>

	<xs:complexType name="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: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: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="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>
					<edmldoc:code><![CDATA[<p>In Java, classes are defined using the <code lang="java">class</code> keyword.</p>]]></edmldoc:code>
				</edmldoc:example>
			</xs:appinfo>
		</xs:annotation>
		<xs:simpleContent>
			<xs:extension base="xs:string">
				<xs:attributeGroup ref="CommonContentElementAttributes"/>
				<xs:attributeGroup ref="CodeAttributes"/>
			</xs:extension>
		</xs:simpleContent>
	</xs:complexType>

	<xs:complexType name="Math" mixed="true">
		<xs:annotation>
			<xs:documentation>Math formula with LaTeX content. Will be displayed with MathJax.</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:element minOccurs="0" maxOccurs="unbounded" name="calculate" type="Calculate"/>
		</xs:sequence>
		<xs:attributeGroup ref="CommonContentElementAttributes"/>
		<xs:attribute name="display" type="MathDisplayStyle" default="inline">
			<xs:annotation>
				<xs:documentation>Determines whether this formula should be displayed as an inline element or block element.</xs:documentation>
			</xs:annotation>
		</xs:attribute>
		<xs:attribute name="align" type="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: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:annotation>
		<xs:sequence>
			<xs:element name="initialcontent" minOccurs="0" maxOccurs="1" type="SourceCodeInitialContent"/>
		</xs:sequence>
		<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:appinfo>
					<edmldoc:experimental/>
				</xs:appinfo>
			</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. Note that every <code>metadata</code>
				element should contain at least one <code>license</code> child element, even through this is currently not validated by the schema.</xs:documentation>
			<xs: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="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: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: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:complexType>

	<xs:complexType name="Mark" mixed="true">
		<xs:annotation>
			<xs:documentation>Inline element that can be used to give its content a name and/or to assign semantic roles to its content.</xs:documentation>
			<xs:appinfo>
				<edmldoc:example>
					<edmldoc:code><![CDATA[Ein <mark name="vektorraum" role="definition">Vektorraum</mark> ist eine Menge ...]]></edmldoc:code>
				</edmldoc:example>
			</xs:appinfo>
		</xs:annotation>
		<xs:sequence>
			<xs:group ref="InlineGroup" minOccurs="0" maxOccurs="unbounded"/>
		</xs:sequence>
		<xs:attributeGroup ref="CommonContentElementAttributes"/>
		<xs:attribute name="role" type="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 that will be displayed as a flexbox.</xs:documentation>
		</xs:annotation>
		<xs:sequence minOccurs="1" maxOccurs="unbounded">
			<xs:element name="flexitem" type="FlexItem"/>
		</xs:sequence>
		<xs:attributeGroup ref="CommonContentElementAttributes"/>
		<xs:attributeGroup ref="FlexContainerAttributes"/>
	</xs:complexType>

	<xs:complexType name="FlexItem">
		<xs:annotation>
			<xs:documentation>An item of a flexbox.</xs:documentation>
		</xs:annotation>
		<xs:sequence minOccurs="0" maxOccurs="unbounded">
			<xs:group ref="BlockGroup"/>
		</xs:sequence>
		<xs:attributeGroup ref="CommonContentElementAttributes"/>
		<xs:attributeGroup ref="FlexItemAttributes"/>
	</xs:complexType>

	<xs:attributeGroup name="FlexContainerAttributes">
		<xs:attribute name="flexdirection" type="FlexDirection" default="row">
			<xs:annotation>
				<xs:documentation>The direction flex items are placed in the flex container.</xs:documentation>
			</xs:annotation>
		</xs:attribute>
		<xs:attribute name="flexwrap" type="FlexWrap" default="nowrap">
			<xs:annotation>
				<xs:documentation>Defines whether the flex items are forced in a single line or can be flowed into multiple lines.</xs:documentation>
			</xs:annotation>
		</xs:attribute>
		<xs:attribute name="justifycontent" type="FlexJustifyContent" default="normal">
			<xs:annotation>
				<xs:documentation>The alignment of the flex items along the main axis.</xs:documentation>
			</xs:annotation>
		</xs:attribute>
		<xs:attribute name="alignitems" type="FlexAlignItems" default="normal">
			<xs:annotation>
				<xs:documentation>Defines the default behavior for how flex items are laid out along the cross axis on the current line.</xs:documentation>
			</xs:annotation>
		</xs:attribute>
		<xs:attribute name="aligncontent" type="FlexAlignContent" default="normal">
			<xs:annotation>
				<xs:documentation>Aligns a flex container’s lines within when there is extra space in the cross-axis.</xs:documentation>
			</xs:annotation>
		</xs:attribute>
		<xs:attribute name="rowgap" default="normal">
			<xs:annotation>
				<xs:documentation>
					The space between flex items as <a href="#LengthPercentage">length percentage value</a> or the special value "normal".
				</xs:documentation>
			</xs:annotation>
			<xs:simpleType>
				<xs:union memberTypes="LengthPercentage Normal"/>
			</xs:simpleType>
		</xs:attribute>
		<xs:attribute name="columngap" default="normal">
			<xs:annotation>
				<xs:documentation>
					The space between flex items as <a href="#LengthPercentage">length percentage value</a> or the special value "normal".
				</xs:documentation>
			</xs:annotation>
			<xs:simpleType>
				<xs:union memberTypes="LengthPercentage Normal"/>
			</xs:simpleType>
		</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:enumeration>
			<xs:enumeration value="rowreverse"></xs:enumeration>
			<xs:enumeration value="column"></xs:enumeration>
			<xs:enumeration value="columnreverse"></xs:enumeration>
		</xs:restriction>
	</xs:simpleType>

	<xs:simpleType name="FlexWrap">
		<xs:annotation>
			<xs:documentation>Values for the wrap attribute of flex containers.</xs:documentation>
		</xs:annotation>
		<xs:restriction base="xs:NMTOKEN">
			<xs:enumeration value="nowrap"></xs:enumeration>
			<xs:enumeration value="wrap"></xs:enumeration>
			<xs:enumeration value="wrapreverse"></xs:enumeration>
		</xs:restriction>
	</xs:simpleType>

	<xs:simpleType name="FlexJustifyContent">
		<xs:annotation>
			<xs:documentation>Values for the justifycontent attribute of flex containers.</xs:documentation>
		</xs:annotation>
		<xs:restriction base="xs:NMTOKEN">
			<xs:enumeration value="normal"></xs:enumeration>
			<xs:enumeration value="spacebetween"></xs:enumeration>
			<xs:enumeration value="spacearound"></xs:enumeration>
			<xs:enumeration value="spaceevenly"></xs:enumeration>
			<xs:enumeration value="stretch"></xs:enumeration>
			<xs:enumeration value="center"></xs:enumeration>
			<xs:enumeration value="start"></xs:enumeration>
			<xs:enumeration value="end"></xs:enumeration>
			<xs:enumeration value="flexstart"></xs:enumeration>
			<xs:enumeration value="flexend"></xs:enumeration>
		</xs:restriction>
	</xs:simpleType>

	<xs:simpleType name="FlexAlignItems">
		<xs:annotation>
			<xs:documentation>Values for the alignitems attribute of flex containers.</xs:documentation>
		</xs:annotation>
		<xs:restriction base="xs:NMTOKEN">
			<xs:enumeration value="normal"></xs:enumeration>
			<xs:enumeration value="stretch"></xs:enumeration>
			<xs:enumeration value="center"></xs:enumeration>
			<xs:enumeration value="start"></xs:enumeration>
			<xs:enumeration value="end"></xs:enumeration>
			<xs:enumeration value="selfstart"></xs:enumeration>
			<xs:enumeration value="selfend"></xs:enumeration>
			<xs:enumeration value="flexstart"></xs:enumeration>
			<xs:enumeration value="flexend"></xs:enumeration>
		</xs:restriction>
	</xs:simpleType>

	<xs:simpleType name="FlexAlignContent">
		<xs:annotation>
			<xs:documentation>Values for the aligncontent attribute of flex containers.</xs:documentation>
		</xs:annotation>
		<xs:restriction base="xs:NMTOKEN">
			<xs:enumeration value="normal"></xs:enumeration>
			<xs:enumeration value="baseline"></xs:enumeration>
			<xs:enumeration value="spacebetween"></xs:enumeration>
			<xs:enumeration value="spacearound"></xs:enumeration>
			<xs:enumeration value="spaceevenly"></xs:enumeration>
			<xs:enumeration value="stretch"></xs:enumeration>
			<xs:enumeration value="center"></xs:enumeration>
			<xs:enumeration value="start"></xs:enumeration>
			<xs:enumeration value="end"></xs:enumeration>
			<xs:enumeration value="flexstart"></xs:enumeration>
			<xs:enumeration value="flexend"></xs:enumeration>
		</xs:restriction>
	</xs:simpleType>

	<xs:attributeGroup name="FlexItemAttributes">
		<xs:attribute name="order" type="xs:integer" default="0">
			<xs:annotation>
				<xs:documentation>The order of this item in the flex container.</xs:documentation>
			</xs:annotation>
		</xs:attribute>
		<xs:attribute name="flexgrow" type="xs:decimal" default="0">
			<xs:annotation>
				<xs:documentation>Specifies how much of the remaining space in the flex container should be assigned to this item.</xs:documentation>
			</xs:annotation>
		</xs:attribute>
		<xs:attribute name="flexshrink" type="xs:decimal" default="1">
			<xs:annotation>
				<xs:documentation>Flex shrink factor of this flex item.</xs:documentation>
			</xs:annotation>
		</xs:attribute>
		<xs:attribute name="flexbasis" 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" type="FlexAlignSelf" default="auto">
			<xs:annotation>
				<xs:documentation>Overrides this flex item's alignitems value.</xs:documentation>
			</xs:annotation>
		</xs:attribute>
	</xs:attributeGroup>

	<xs:simpleType name="FlexAlignSelf">
		<xs:restriction base="xs:NMTOKEN">
			<xs:enumeration value="auto"></xs:enumeration>
			<xs:enumeration value="normal"></xs:enumeration>
			<xs:enumeration value="stretch"></xs:enumeration>
			<xs:enumeration value="baseline"></xs:enumeration>
			<xs:enumeration value="center"></xs:enumeration>
			<xs:enumeration value="start"></xs:enumeration>
			<xs:enumeration value="end"></xs:enumeration>
			<xs:enumeration value="selfstart"></xs:enumeration>
			<xs:enumeration value="selfend"></xs:enumeration>
			<xs:enumeration value="flexstart"></xs:enumeration>
			<xs:enumeration value="flexend"></xs:enumeration>
		</xs:restriction>
	</xs:simpleType>

	<xs:complexType name="List">
		<xs:annotation>
			<xs:documentation>A list, can be either numbered or unnumbered depending on the used format.
				Note that attributes such as "format" and "fullnumbering" will be
				inherited if a list occurs inside of another list.
			</xs:documentation>
		</xs:annotation>
		<xs:sequence minOccurs="1" maxOccurs="unbounded">
			<xs:element name="listitem" type="ListItem"/>
		</xs:sequence>
		<xs:attributeGroup ref="CommonContentElementAttributes"/>
		<xs:attribute name="format" type="LabelFormat" use="optional" default="arabic">
			<xs:annotation>
				<xs:documentation>Format used for the automatically generated label of the items in this list.</xs:documentation>
			</xs:annotation>
		</xs:attribute>
		<xs:attribute name="separator" type="xs:string" use="optional" default=".">
			<xs:annotation>
				<xs:documentation>Separator used in the automatically generated label of the items in this list.</xs:documentation>
			</xs:annotation>
		</xs:attribute>
		<xs:attribute name="lastsep" type="xs:boolean" use="optional" default="true">
			<xs:annotation>
				<xs:documentation>Controls whether the last separator should be shown in the automatically generated label of the items in this list.
				</xs:documentation>
			</xs:annotation>
		</xs:attribute>
		<xs:attributeGroup ref="IndentAttribute"/>
		<xs:attribute name="fullnumbering" type="xs:boolean" default="false">
			<xs:annotation>
				<xs:documentation>Whether or not the automatically generated labels of a list item of this list should include the full numbering of all of its parent
					navigation items or only its number in the list of the children of its parent.</xs:documentation>
			</xs:annotation>
		</xs:attribute>
	</xs:complexType>

	<xs:complexType name="ListItem">
		<xs:annotation>
			<xs:documentation>Item of a list.</xs:documentation>
		</xs:annotation>
		<xs: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
					<code>valign</code> attribute of the <code>cell</code> element to a different 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:attribute name="maxheight" default="none">
			<xs:annotation>
				<xs:documentation>Maximum width of the table row as <a href="#LengthPercentage">length percentage value</a>.</xs:documentation>
			</xs:annotation>
			<xs:simpleType>
				<xs:union memberTypes="LengthPercentage None"/>
			</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 through the table.</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 through the table. This feature is only supported on the first (left most) column.</xs:documentation>
			</xs:annotation>
		</xs:attribute>
	</xs:complexType>

	<xs:attributeGroup name="TableAttributes">
		<xs:attribute name="border" type="xs:boolean" use="optional" default="true">
			<xs:annotation>
				<xs:documentation>Controls whether this table should have a border.</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:attributeGroup>

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

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

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

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

	<xs:attributeGroup name="CommonInputElementAttributes">
		<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:attribute name="reveal" type="xs:nonNegativeInteger">
			<xs:annotation>
				<xs:documentation>Enables the user to see the solution values stored in this input element after
				the given number of failed attempts. When not provided, the user is never allowed to see the solution values.</xs:documentation>
			</xs:annotation>
		</xs:attribute>
	</xs:attributeGroup>

	<xs:complexType name="InlineInput">
		<xs:annotation>
			<xs:documentation>
				Inline element for an input field in which the user can input a value that is checked against the specified solution.
			</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:group ref="InlineInputValueGroup"/>
		</xs:sequence>
		<xs:attributeGroup ref="CommonContentElementAttributes"/>
		<xs:attributeGroup ref="CommonInputElementAttributes"/>
		<xs:attribute name="width" use="optional" default="auto">
			<xs:annotation>
				<xs:documentation>Desired width of this input element as <a href="#LengthPercentage">length percentage value</a> or "auto",
				which means that the application will decide about the width of the input element.</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:attribute name="align" type="HorizontalAlignment" default="center">
			<xs:annotation>
				<xs:documentation>Horizontal alignment of the content of this input element.</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>Maximum length of the string that the user may enter.</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 a single digit between 1 and 9 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="verbatim" default="false" type="xs:boolean">
			<xs:annotation>
				<xs:documentation>If this attribute is set to true, the expression entered by the user must be 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:attribute>
	</xs:complexType>

	<xs:complexType name="SetInputModel">
		<xs:annotation>
			<xs:documentation>
				Settings element inside the <code>inputmodel</code> element which is used to specify the settings for set input fields.
			</xs:documentation>
		</xs:annotation><xs: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" type="xs:positiveInteger">
			<xs:annotation>
				<xs:documentation>Initial number of components in this vector that are already there when the user loads the page.</xs:documentation>
			</xs:annotation>
		</xs:attribute>
		<xs:attribute name="minsizehints" type="xs:boolean" default="false">
			<xs:annotation>
				<xs:documentation>Whether or not to give live hints about the allowed minimum size of the vector
					when the user has not yet submitted the input value.
				</xs:documentation>
			</xs:annotation>
		</xs:attribute>
		<xs:attribute name="maxsizehints" type="xs:boolean" default="false">
			<xs:annotation>
				<xs:documentation>Whether or not to give live hints about the allowed maximum size of the vector
					when the user has not yet submitted the input value.
				</xs:documentation>
			</xs:annotation>
		</xs:attribute>
		<xs: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 allowed rows in this matrix.</xs:documentation>
			</xs:annotation>
		</xs:attribute>
		<xs:attribute name="maxrows" default="unbounded">
			<xs:annotation>
				<xs:documentation>Maximum number of allowed rows in this matrix.</xs:documentation>
			</xs:annotation>
			<xs:simpleType>
				<xs:union memberTypes="xs:positiveInteger Unbounded"/>
			</xs:simpleType>
		</xs:attribute>
		<xs:attribute name="defaultrows" type="xs:positiveInteger">
			<xs:annotation>
				<xs:documentation>Initial number of rows in this matrix that are already there when the user loads the page.</xs:documentation>
			</xs:annotation>
		</xs:attribute>
		<xs:attribute name="mincolumns" type="xs:positiveInteger" default="1">
			<xs:annotation>
				<xs:documentation>Minimum number of allowed columns in this matrix.</xs:documentation>
			</xs:annotation>
		</xs:attribute>
		<xs:attribute name="maxcolumns" default="unbounded">
			<xs:annotation>
				<xs:documentation>Maximum number of allowed columns in this matrix.</xs:documentation>
			</xs:annotation>
			<xs:simpleType>
				<xs:union memberTypes="xs:positiveInteger Unbounded"/>
			</xs:simpleType>
		</xs:attribute>
		<xs:attribute name="defaultcolumns" type="xs:positiveInteger">
			<xs:annotation>
				<xs:documentation>Initial number of columns in this matrix that are already there when the user loads the page.</xs:documentation>
			</xs:annotation>
		</xs:attribute>
		<xs:attribute name="minrowshints" type="xs:boolean" default="false">
			<xs:annotation>
				<xs:documentation>Whether or not to give live hints about the allowed minimum number of rows in the matrix
					when the user has not yet submitted the input value.
				</xs:documentation>
			</xs:annotation>
		</xs:attribute>
		<xs:attribute name="maxrowshints" type="xs:boolean" default="false">
			<xs:annotation>
				<xs:documentation>Whether or not to give live hints about the allowed maximum number of rows in the matrix
					when the user has not yet submitted the input value.
				</xs:documentation>
			</xs:annotation>
		</xs:attribute>
		<xs:attribute name="mincolumnshints" type="xs:boolean" default="false">
			<xs:annotation>
				<xs:documentation>Whether or not to give live hints about the allowed minimum number of columns in the matrix
					when the user has not yet submitted the input value.
				</xs:documentation>
			</xs:annotation>
		</xs:attribute>
		<xs:attribute name="maxcolumnshints" type="xs:boolean" default="false">
			<xs:annotation>
				<xs:documentation>Whether or not to give live hints about the allowed maximum number of columns in the matrix
					when the user has not yet submitted the input value.
				</xs:documentation>
			</xs:annotation>
		</xs:attribute>
	</xs: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="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="UnitSymbolList 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.
			</xs:documentation>
			<xs:appinfo>
				<edmldoc:experimental/>
			</xs:appinfo>
		</xs:annotation>
		<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:attribute name="fixed" type="xs:boolean" default="false">
			<xs:annotation>
				<xs:documentation>Whether or not the number of educts and products of the reaction
					should be fixed and be revealed to the user as defined in the solution. If this attribute is not set to true, then the user must
					find out about the number of educts and products on his or her own.</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>
			<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: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: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:experimental/>
				<edmldoc:example>
					<edmldoc:description>In the order input element, A must appear before B, B must appear before C and A must appear before D:</edmldoc:description>
					<edmldoc:code><![CDATA[<input>
	<order>
		<items>
			<item>
				<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:code>
				</edmldoc:example>
			</xs:appinfo>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="items" 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:experimental/>
				<edmldoc:example>
					<edmldoc:description>In the following exercise, the user has to drag color names to RGB triples:</edmldoc:description>
					<edmldoc:code><![CDATA[<matching>
	<dragitems>
		<item>
			<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:code>
				</edmldoc:example>
			</xs:appinfo>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="dragitems" type="DragItems"/>
			<xs:element name="dropitems" type="DropItems"/>
			<xs:element name="matches" type="Matches"/>
		</xs:sequence>
		<xs:attributeGroup ref="CommonInputValueAttributes"/>
		<xs:attribute name="shuffle" type="xs:boolean">
			<xs:annotation>
				<xs:documentation>
					Whether or not the drag and drop items should be shuffled randomly
					each time the page is loaded.
				</xs:documentation>
				<xs:appinfo>
					<edmldoc:modelattribute/>
				</xs:appinfo>
			</xs:annotation>
		</xs:attribute>
		<xs:attribute name="dragusage" 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:attribute name="dropusage" 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="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>
					<edmldoc:code><![CDATA[<match credits="5">1 2</match>]]></edmldoc:code>
				</edmldoc:example>
			</xs:appinfo>
		</xs:annotation>
		<xs:simpleContent>
			<xs:extension base="MatchingNumberPair">
				<xs:attribute name="credits" use="optional" default="1" type="xs:nonNegativeInteger">
					<xs:annotation>
						<xs:documentation>Number of credit points the user gets awarded for matching the two items.</xs:documentation>
					</xs:annotation>
				</xs:attribute>
			</xs:extension>
		</xs:simpleContent>
	</xs:complexType>

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

	<xs:complexType name="NumberInputValue">
		<xs:annotation>
			<xs:documentation>
				Input value representing a number. The correct number can be either given as a direct value such as "-20.123"
				or as an expression that can also involve parameters defined in this containers. The expression is interpreted by the Computer Algebra System
				and must evaluate to a number.
				It is possible to specify a different base than the standard base 10. All integers between 1 and 35 are valid bases. Note that both the input from the user and the value written in the solution are interpreted as numbers with respect to the base in use.
			</xs:documentation>
		</xs:annotation>
		<xs:simpleContent>
			<xs:extension base="xs:string">
				<xs:attributeGroup ref="CommonInputValueAttributes"/>
				<xs: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>
				<sch:pattern>
					<sch:rule context="edml:exponential[@lowertolerance][@uppertolerance]">
						<sch:assert test="@lowertolerance &lt;= @uppertolerance">
							The lowertolerance attribute value of an exponential element must be less than or equal to the uppertolerance attribute value.
						</sch:assert>
					</sch:rule>
					<sch:rule context="edml:exponential[@lowerreltolerance][@upperreltolerance]">
						<sch:assert test="@lowerreltolerance &lt;= @upperreltolerance">
							The lowerreltolerance attribute value of an exponential element must be less than or equal to the upperreltolerance attribute value.
						</sch:assert>
					</sch:rule>
				</sch:pattern>
			</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 writte in positional notation, possibly with a sign.</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="constant">
				<xs:annotation>
					<xs:documentation>A constant like <code>pi</code>.</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="variable">
				<xs:annotation>
					<xs:documentation>A variable like <code>x</code>.</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="faculty">
				<xs:annotation>
					<xs:documentation>Operator of the form <code>a!</code>.</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="negation">
				<xs:annotation>
					<xs:documentation>Operator of the form <code>-a</code>.</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="abs">
				<xs:annotation>
					<xs:documentation>Operator of the form <code>|a|</code>.</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="sqrt">
				<xs:annotation>
					<xs:documentation>Operator of the form <code>sqrt(a)</code>.</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="power">
				<xs:annotation>
					<xs:documentation>Operator of the form <code>a^b</code>.</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="product">
				<xs:annotation>
					<xs:documentation>Operator of the form <code>a*b</code>.</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="fraction">
				<xs:annotation>
					<xs:documentation>Operator of the form <code>a/b</code>.</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="sum">
				<xs:annotation>
					<xs:documentation>Operator of the form <code>a+b</code>.</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="difference">
				<xs:annotation>
					<xs:documentation>Operator of the form <code>a-b</code>.</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
		</xs:restriction>
	</xs:simpleType>

	<xs:complexType name="ExpressionInputValue">
		<xs:annotation>
			<xs:documentation>
				<p>Input value representing a mathematical expression, such as <code>"2*x+1"</code>.
				The expression is parsed into a binary tree consisting of nodes that are either leafs or operators.
				There are 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>absolute value (<code>|a|</code>), square root (<code>sqrt(a)</code>)</li>
					<li>power (<code>a^b</code>)</li>
					<li>product (<code>a*b</code>), fraction (<code>a/b</code>)</li>
					<li>sum (<code>a+b</code>), difference (<code>a-b</code>)</li>
				</ul>
				<p>
				Leaf nodes are considered to have the highest precedence.
				For example, the expression <code>-2.22</code> is parsed into a single number node,
				while the expression <code>-x</code> is parsed into a tree with a negation node as root node and one node for the variable <code>x</code> as child node.
				</p>
				<p>The user may use brackets to change the order of operators.
					For example, the expression <code>-(2.22)</code> is parsed into a tree whose root is a negation node.
				</p>
				<p>
				The multiplication sign 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: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="verbatim" type="xs:boolean">
					<xs:annotation>
						<xs:documentation>If this attribute is set to true, the expression entered by the user must be 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: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>
				<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 a fixed amount of numbers or expressions.
				For example, <code>(1,2,3)</code> is a vector of numbers and <code>(2*x,3*x,x)</code> is a vector of expressions.</xs:documentation>
		</xs:annotation>
		<xs:choice>
			<xs:element name="number" type="NumberInputValue" minOccurs="1" maxOccurs="unbounded"/>
			<xs:element name="expression" type="ExpressionInputValue" minOccurs="1" maxOccurs="unbounded"/>
			<xs:element name="string" type="StringInputValue" minOccurs="1" maxOccurs="unbounded"/>
		</xs:choice>
		<xs:attributeGroup ref="CommonInputValueAttributes"/>
		<xs: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" type="xs:positiveInteger">
			<xs:annotation>
				<xs:documentation>Initial number of components in this vector that are already there when the user loads the page.</xs:documentation>
				<xs:appinfo>
					<edmldoc:modelattribute/>
				</xs:appinfo>
			</xs:annotation>
		</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 vector
					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 vector
					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="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, expressions or strings.</xs:documentation>
		</xs:annotation>
		<xs:choice>
			<xs:sequence minOccurs="1" maxOccurs="unbounded">
				<xs:element name="matrixrow" type="MatrixInputValueRow"/>
			</xs:sequence>
		</xs:choice>
		<xs:attributeGroup ref="CommonInputValueAttributes"/>
		<xs:attribute name="minrows" type="xs:positiveInteger">
			<xs:annotation>
				<xs:documentation>Minimum number of allowed rows in this matrix.</xs:documentation>
				<xs:appinfo>
					<edmldoc:modelattribute/>
				</xs:appinfo>
			</xs:annotation>
		</xs:attribute>
		<xs:attribute name="maxrows">
			<xs:annotation>
				<xs:documentation>Maximum number of allowed rows in this 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" type="xs:positiveInteger">
			<xs:annotation>
				<xs:documentation>Initial number of rows in this matrix that are already there when the user loads the page.</xs:documentation>
				<xs:appinfo>
					<edmldoc:modelattribute/>
				</xs:appinfo>
			</xs:annotation>
		</xs:attribute>
		<xs:attribute name="mincolumns" type="xs:positiveInteger">
			<xs:annotation>
				<xs:documentation>Minimum number of allowed columns in this matrix.</xs:documentation>
				<xs:appinfo>
					<edmldoc:modelattribute/>
				</xs:appinfo>
			</xs:annotation>
		</xs:attribute>
		<xs:attribute name="maxcolumns">
			<xs:annotation>
				<xs:documentation>Maximum number of allowed columns in this 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" type="xs:positiveInteger">
			<xs:annotation>
				<xs:documentation>Initial number of columns in this matrix that are already there when the user loads the page.</xs:documentation>
				<xs:appinfo>
					<edmldoc:modelattribute/>
				</xs:appinfo>
			</xs:annotation>
		</xs:attribute>
		<xs:attribute name="minrowshints" type="xs:boolean">
			<xs:annotation>
				<xs:documentation>Whether or not to give live hints about the allowed minimum number of rows in the matrix
					when the user has not yet submitted the input value.
				</xs:documentation>
				<xs:appinfo>
					<edmldoc:modelattribute/>
				</xs:appinfo>
			</xs:annotation>
		</xs:attribute>
		<xs:attribute name="maxrowshints" type="xs:boolean">
			<xs:annotation>
				<xs:documentation>Whether or not to give live hints about the allowed maximum number of rows in the matrix
					when the user has not yet submitted the input value.
				</xs:documentation>
				<xs:appinfo>
					<edmldoc:modelattribute/>
				</xs:appinfo>
			</xs:annotation>
		</xs:attribute>
		<xs:attribute name="mincolumnshints" type="xs:boolean">
			<xs:annotation>
				<xs:documentation>Whether or not to give live hints about the allowed minimum number of columns in the matrix
					when the user has not yet submitted the input value.
				</xs:documentation>
				<xs:appinfo>
					<edmldoc:modelattribute/>
				</xs:appinfo>
			</xs:annotation>
		</xs:attribute>
		<xs:attribute name="maxcolumnshints" type="xs:boolean">
			<xs:annotation>
				<xs:documentation>Whether or not to give live hints about the allowed maximum number of columns in the matrix
					when the user has not yet submitted the input value.
				</xs:documentation>
				<xs:appinfo>
					<edmldoc:modelattribute/>
				</xs:appinfo>
			</xs:annotation>
		</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:element name="string" type="StringInputValue" minOccurs="1" maxOccurs="unbounded"/>
		</xs:choice>
	</xs:complexType>

	<xs:simpleType name="IntervalClosureType">
		<xs:annotation>
			<xs:documentation>Specifies the type of an interval.</xs:documentation>
		</xs:annotation>
		<xs:restriction base="xs:NMTOKEN">
			<xs:enumeration value="closed">
				<xs:annotation>
					<xs:documentation>Interval of type [a;b].</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="closedopen">
				<xs:annotation>
					<xs:documentation>Interval of type [a;b).</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="open">
				<xs:annotation>
					<xs:documentation>Interval of type (a;b).</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="openclosed">
				<xs:annotation>
					<xs:documentation>Interval of type (a;b].</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
		</xs:restriction>
	</xs:simpleType>

	<xs:complexType name="IntervalInputValue">
		<xs:annotation>
			<xs:documentation>Input value representing an interval, such as "[2;10)", those endpoints are numbers or expressions.</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:choice>
				<xs:element name="number" type="NumberInputValue"/>
				<xs:element name="expression" type="ExpressionInputValue"/>
			</xs:choice>
			<xs:choice>
				<xs:element name="number" type="NumberInputValue"/>
				<xs:element name="expression" type="ExpressionInputValue"/>
			</xs:choice>
		</xs:sequence>
		<xs:attributeGroup ref="CommonInputValueAttributes"/>
		<xs:attribute name="closure" type="IntervalClosureType">
			<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="WordInputValue">
		<xs:annotation>
			<xs:documentation>Input value representing a word in the sense of theoretical computer science, such as "aab" or the empty word "epsilon"
			</xs:documentation>
		</xs:annotation>
	</xs:complexType>

	<xs:complexType name="UnitInputValue">
		<xs:annotation>
			<xs:documentation>Input value representing unit or a combination of units, such as "kg" or "m*s^-2".</xs:documentation>
		</xs:annotation>
		<xs:simpleContent>
			<xs:extension base="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="UnitSymbolList 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:annotation>
		<xs:sequence>
			<xs:choice>
				<xs:element name="number" type="NumberInputValue"/>
				<xs:element name="exponential" type="ExponentialInputValue"/>
				<xs:element name="expression" type="ExpressionInputValue"/>
			</xs:choice>
			<xs:element name="unit" type="UnitInputValue"/>
		</xs:sequence>
		<xs:attributeGroup ref="CommonInputValueAttributes"/>
		<xs:attribute name="significant">
			<xs:annotation>
				<xs:documentation>When given, 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. Trailing zeros in whole numbers in the user input are counted
					as significant whenever this makes the input correct.</xs:documentation>
				<xs:appinfo>
					<edmldoc:modelattribute/>
				</xs:appinfo>
			</xs:annotation>
			<xs:simpleType>
				<xs:union memberTypes="xs:positiveInteger None"/>
			</xs:simpleType>
		</xs:attribute>
	</xs:complexType>

	<xs:complexType name="MolecularInputValue">
		<xs:annotation>
			<xs:documentation>An molecular formula input value, such as "H2O".</xs:documentation>
			<xs:appinfo>
				<edmldoc:example>
					<edmldoc:code><![CDATA[<molecular>H2O</molecular>]]></edmldoc:code>
				</edmldoc:example>
			</xs:appinfo>
		</xs:annotation>
		<xs:simpleContent>
			<xs:extension base="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">
			<xs:pattern value="(([A-Z][a-z]?\d*)|(\(([A-Z][a-z]?\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:experimental/>
				<edmldoc:example>
					<edmldoc:code><![CDATA[<reaction type="forward">
	<educts>
		<molecule>CH4</molecule>
		<molecule>O2</molecule>
	</educts>
	<product>
		<molecule>H2O</molecule>
		<molecule>CO2</molecule>
	</product>
</reaction>]]></edmldoc:code>
				</edmldoc:example>
			</xs:appinfo>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="educts" type="ReactionEducts"/>
			<xs:element name="products" type="ReactionProducts"/>
		</xs:sequence>
		<xs:attributeGroup ref="CommonInputValueAttributes"/>
		<xs: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:attribute name="fixed" type="xs:boolean">
			<xs:annotation>
				<xs:documentation>Whether or not the number of educts and products of the reaction
					should be fixed and be revealed to the user as defined in the solution. If this attribute is not set to true, then the user must
					find out about the number of educts and products on his or her own.</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:appinfo>
				<edmldoc:experimental/>
			</xs:appinfo>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="molecule" type="ReactionMolecule" minOccurs="1" maxOccurs="unbounded"/>
		</xs:sequence>
	</xs:complexType>

	<xs:complexType name="ReactionProducts">
		<xs:annotation>
			<xs:documentation>Contains the list of all products of a chemical reaction.</xs:documentation>
			<xs:appinfo>
				<edmldoc:experimental/>
			</xs:appinfo>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="molecule" type="ReactionMolecule" minOccurs="1" maxOccurs="unbounded"/>
		</xs:sequence>
	</xs:complexType>

	<xs:complexType name="ReactionMolecule">
		<xs:annotation>
			<xs:documentation>A molecule that takes part in a chemical reaction given by a molecular formular.
			The format is the same as for the <code>molecular</code> element.</xs:documentation>
			<xs:appinfo>
				<edmldoc:experimental/>
				<edmldoc:example>
					<edmldoc:code><![CDATA[<molecule>H2O</molecule>]]></edmldoc:code>
				</edmldoc:example>
			</xs:appinfo>
		</xs:annotation>
		<xs:simpleContent>
			<xs:extension base="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 decimal value from an expression that can involve parameters and replaces this element with the computed value.
			</xs:documentation>
			<xs:appinfo>
				<edmldoc:example>
					<edmldoc:description>
						When a parameter with identifier <code>a</code> is defined in a container, one could write the following somewhere in its content:
					</edmldoc:description>
					<edmldoc:code><![CDATA[<p>Please enter twice the value of <calculate>2*a</calculate>:</p>]]></edmldoc:code>
				</edmldoc:example>
			</xs:appinfo>
		</xs:annotation>
		<xs:simpleContent>
			<xs:extension base="xs:string"/>
		</xs:simpleContent>
	</xs:complexType>

	<xs:simpleType name="PositiveDecimal">
		<xs:annotation>
			<xs:documentation>Same as xs:decimal, expect that the value must be strictly greater than 0.</xs:documentation>
		</xs:annotation>
		<xs:restriction base="xs:decimal">
			<xs:minExclusive value="0"/>
		</xs:restriction>
	</xs:simpleType>

	<xs:simpleType name="NonNegativeDecimal">
		<xs:annotation>
			<xs:documentation>Same as xs:decimal, expect that the value must be greater than or equal to 0.</xs:documentation>
		</xs:annotation>
		<xs:restriction base="xs:decimal">
			<xs:minInclusive value="0"/>
		</xs:restriction>
	</xs:simpleType>

	<xs:complexType name="SolutionHint">
		<xs:annotation>
			<xs:documentation>
				A hint to a solution consisting of one or multiple steps. This element can be linked to a specific input element by setting
				<code>to</code> attribute. It then appears only as side note to this input element and not in the position of the text where it is placed itself.
				If the <code>to</code> attribute is not set, then this element appears as a collapsable box exactly where it is placed in the text.
			</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:element minOccurs="0" maxOccurs="1" name="title" type="Title"/>
			<xs:element minOccurs="1" maxOccurs="unbounded" name="step" type="Step"/>
		</xs:sequence>
		<xs:attributeGroup ref="CommonContentElementAttributes"/>
		<xs:attribute name="to" type="xs:Name" use="optional">
			<xs:annotation>
				<xs:documentation>When set, links this solution hint to the input element with the given name.</xs:documentation>
			</xs:annotation>
		</xs:attribute>
	</xs:complexType>
	
	<xs:complexType name="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: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="None xs:positiveInteger"/>
			</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: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: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))"/>
		</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|%))"/>
		</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: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: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:enumeration>
		</xs:restriction>
	</xs:simpleType>

	<xs:simpleType name="Continuous">
		<xs:annotation>
			<xs:documentation>Type whose only value is "continuous". This is used to specify that a range should be continuous.</xs:documentation>
		</xs:annotation>
		<xs:restriction base="xs:NMTOKEN">
			<xs:enumeration value="continuous"></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:enumeration>
		</xs:restriction>
	</xs:simpleType>

	<xs:simpleType name="Normal">
		<xs:annotation>
			<xs:documentation>Type whose only value is "normal".</xs:documentation>
		</xs:annotation>
		<xs:restriction base="xs:NMTOKEN">
			<xs:enumeration value="normal"></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>
