<?xml version="1.0" encoding="UTF-8"?>
<!--
   * This file is part of the Vamsas Client version 0.2. 
   * Copyright 2010 by Jim Procter, Iain Milne, Pierre Marguerite, 
   *  Andrew Waterhouse and Dominik Lindner.
   * 
   * Earlier versions have also been incorporated into Jalview version 2.4 
   * since 2008, and TOPALi version 2 since 2007.
   * 
   * The Vamsas Client is free software: you can redistribute it and/or modify
   * it under the terms of the GNU Lesser General Public License as published by
   * the Free Software Foundation, either version 3 of the License, or
   * (at your option) any later version.
   *  
   * The Vamsas Client is distributed in the hope that it will be useful,
   * but WITHOUT ANY WARRANTY; without even the implied warranty of
   * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   * GNU Lesser General Public License for more details.
   * 
   * You should have received a copy of the GNU Lesser General Public License
   * along with the Vamsas Client.  If not, see <http://www.gnu.org/licenses/>.
-->
<!-- edited with XMLSPY v5 rel. 4 U (http://www.xmlspy.com) by MSD (EMBL OUTSTATION THE EBI WELLCOME TRUST GENOME CAMPUS) -->
<!-- edited with XMLSpy v2006 sp1 U (http://www.altova.com) by ioh[ (o[ih[oh) -->
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema"
	xmlns:vamsas="http://www.vamsas.ac.uk/schemas/1.0/vamsasTypes"
	targetNamespace="http://www.vamsas.ac.uk/schemas/1.0/vamsasTypes" elementFormDefault="qualified"
	attributeFormDefault="unqualified">
	<xs:annotation>
		<xs:documentation> Vorba ID - Vamsas Object Request Broker Address ID (name needs to be
			worked on): Suggest it could be of the form documentRoot/datasetName/SequenceUID for a
			dataset sequence. Alignment sequence: documentRoot/datasetName/AlignmentId/SequenceUID
			for an aligned form of a dataset sequence </xs:documentation>
	</xs:annotation>
	<xs:element name="VAMSAS">
		<xs:annotation>
			<xs:documentation> contains unassociated trees and a number of analysis sets
			</xs:documentation>
		</xs:annotation>
		<xs:complexType>
			<xs:sequence>
				<xs:element ref="vamsas:Tree" minOccurs="0" maxOccurs="unbounded"/>
				<xs:element ref="vamsas:DataSet" minOccurs="0" maxOccurs="unbounded"/>
			</xs:sequence>
			<xs:attribute name="id" type="xs:ID" use="optional">
				<xs:annotation>
					<xs:documentation> Primary Key for vamsas object referencing </xs:documentation>
				</xs:annotation>
			</xs:attribute>
			<xs:attribute name="modifiable" type="vamsas:locks" use="optional"/>
		</xs:complexType>
	</xs:element>
	<xs:annotation>
		<xs:documentation> Properties. Generally, these are mutable so an application should check
			them each time. This may change depending on the context of the property
		</xs:documentation>
	</xs:annotation>
	<xs:element name="Tree">
		<xs:complexType>
			<xs:annotation>
				<xs:documentation> Contains a named collection of trees </xs:documentation>
				<xs:documentation> TODO: define way of referencing leaves of global tree for any
					sequence/alignment object. SUggestion 1: Each named tree leafnode has a unique
					id (which may be unique in combination with trees own vorba ID). Dataset
					sequences can be tagged with a property "vamsas:tree_leaf" </xs:documentation>
			</xs:annotation>
			<xs:sequence>
				<xs:element name="title" type="xs:string" minOccurs="0"/>
				<xs:element name="newick" maxOccurs="unbounded">
					<xs:complexType>
						<xs:simpleContent>
							<xs:extension base="xs:string">
								<xs:attribute name="title" type="xs:string" use="optional"/>
								<xs:attribute name="id" type="xs:ID" use="optional">
									<xs:annotation>
										<xs:documentation> Primary Key for vamsas object referencing
										</xs:documentation>
									</xs:annotation>
								</xs:attribute>
								<xs:attribute name="modifiable" type="vamsas:locks" use="optional"/>
							</xs:extension>
						</xs:simpleContent>
					</xs:complexType>
				</xs:element>
				<xs:element name="treenode" minOccurs="0" maxOccurs="unbounded">
					<xs:annotation>
						<xs:documentation> node identity and mapping data between tree
							representations and vamsas document objects </xs:documentation>
					</xs:annotation>
					<xs:complexType>
						<xs:complexContent>
							<xs:extension base="vamsas:nodeType">
								<xs:attribute name="treeId" type="xs:IDREFS">
									<xs:annotation>
										<xs:documentation> reference to one or more trees containing
											the node being described. </xs:documentation>
									</xs:annotation>
								</xs:attribute>
								<xs:attribute name="nodespec" type="xs:string">
									<xs:annotation>
										<xs:documentation> String uniquely identifying a particular
											node in the referenced tree according to the format of
											the tree representation that is referenced.
										</xs:documentation>
									</xs:annotation>
								</xs:attribute>

							</xs:extension>
						</xs:complexContent>
					</xs:complexType>
				</xs:element>
				<xs:element ref="vamsas:property" minOccurs="0" maxOccurs="unbounded"/>
				<xs:element ref="vamsas:Provenance"/>
			</xs:sequence>
			<xs:attribute name="id" type="xs:ID" use="optional">
				<xs:annotation>
					<xs:documentation> Primary Key for vamsas object referencing </xs:documentation>
				</xs:annotation>
			</xs:attribute>
			<xs:attribute name="modifiable" type="vamsas:locks" use="optional"/>
		</xs:complexType>
	</xs:element>
	<xs:complexType name="referenceType">
		<xs:annotation>
			<xs:documentation> base type for citing arbitrary links between vamsas objects
			</xs:documentation>
		</xs:annotation>
		<xs:simpleContent>
			<xs:extension base="xs:string">
				<xs:annotation>
					<xs:documentation> Optional human readable description of the relationship
					</xs:documentation>
				</xs:annotation>
				<xs:attribute name="id" type="xs:ID" use="optional">
					<xs:annotation>
						<xs:documentation> Primary Key for vamsas object referencing
						</xs:documentation>
					</xs:annotation>
				</xs:attribute>
				<xs:attribute name="refs" type="xs:IDREFS">
					<xs:annotation>
						<xs:documentation>List of one or more vamsas object
						references</xs:documentation>
					</xs:annotation>
				</xs:attribute>
			</xs:extension>
		</xs:simpleContent>
	</xs:complexType>
	<xs:complexType name="nodeType">
		<xs:sequence>
			<xs:element name="name" type="xs:string" minOccurs="0" maxOccurs="1">
				<xs:annotation>
					<xs:documentation>Short name for this node</xs:documentation>
				</xs:annotation>
			</xs:element>
			<xs:element name="description" type="xs:string" minOccurs="0" maxOccurs="1">
				<xs:annotation>
					<xs:documentation>Descriptive text for this node</xs:documentation>
				</xs:annotation>
			</xs:element>
			<xs:element name="vref" type="vamsas:referenceType" minOccurs="0" maxOccurs="unbounded">
				<xs:annotation>
					<xs:documentation>Direct associations between this node and any vamsas
					objects</xs:documentation>
				</xs:annotation>
			</xs:element>
			<xs:element ref="vamsas:property" minOccurs="0" maxOccurs="unbounded"/>
		</xs:sequence>
		<xs:attribute name="id" type="xs:ID" use="optional">
			<xs:annotation>
				<xs:documentation> Primary Key for vamsas object referencing </xs:documentation>
			</xs:annotation>
		</xs:attribute>
		<xs:attribute name="modifiable" type="vamsas:locks" use="optional"/>
	</xs:complexType>
	<xs:element name="property">
		<xs:complexType>
			<xs:simpleContent>
				<xs:annotation>
					<xs:documentation> Named and typed property string </xs:documentation>
				</xs:annotation>
				<xs:extension base="xs:string">
					<xs:attribute name="name" type="xs:string" use="required"/>
					<xs:attribute name="type" type="xs:string" use="required">
						<xs:annotation>
							<xs:documentation> The type specifies how the property will be parsed.
								Empty property strings are allowed, and can be used to prototype the
								input to a document. TODO: specify allowed types </xs:documentation>
						</xs:annotation>
					</xs:attribute>
				</xs:extension>
			</xs:simpleContent>
		</xs:complexType>
	</xs:element>
	<xs:element name="link">
		<xs:complexType>
			<xs:annotation>
				<xs:documentation> Primitive labelled URI object </xs:documentation>
			</xs:annotation>
			<xs:simpleContent>
				<xs:extension base="xs:string">
					<xs:attribute name="href" type="xs:anyURI">
						<xs:annotation>
							<xs:documentation>The URI</xs:documentation>
						</xs:annotation>
					</xs:attribute>
				</xs:extension>
			</xs:simpleContent>
		</xs:complexType>
	</xs:element>
	<xs:complexType name="rangeType" abstract="true">
		<xs:annotation>
			<xs:documentation> Specify an ordered set of positions and/or regions on the principle
				dimension of some associated vamsas object </xs:documentation>
			<xs:documentation> Keeping to jaxb-1.0 specification for the moment - this choice should
				become a substitution group when we use jaxb-2.0 capable bindings
			</xs:documentation>
		</xs:annotation>
		<xs:choice>
			<xs:element name="pos" maxOccurs="unbounded">
				<xs:annotation>
					<xs:documentation> a position within the associated object's coordinate system
					</xs:documentation>
				</xs:annotation>
				<xs:complexType>
					<xs:attribute name="i" type="xs:int" use="required"/>
				</xs:complexType>
			</xs:element>
			<xs:element name="seg" maxOccurs="unbounded">
				<xs:annotation>
					<xs:documentation> a region from start to end, with flag for inclusivity of
						terminii </xs:documentation>
				</xs:annotation>
				<xs:complexType>
					<xs:attribute name="start" type="xs:int" use="required"/>
					<xs:attribute name="end" type="xs:int" use="required"/>
					<xs:attribute name="inclusive" type="xs:boolean" use="required">
						<xs:annotation>
							<xs:documentation> when false, a consecutive range like 'start=1, end=2'
								means the region lying after position 1 and before position 2
							</xs:documentation>
						</xs:annotation>
					</xs:attribute>
				</xs:complexType>
			</xs:element>
		</xs:choice>
		<!--  Do we really need this - a position could be just a seg with start=end and inclusive=true -->
	</xs:complexType>
	<xs:complexType name="rangeAnnotation">
		<xs:annotation>
			<xs:documentation> Annotation for a rangeSpec - values can be attached for the whole
				specification, and to each position within the spec. following the orientation
				specified by the ordered set of rangeSpec (pos, seg) elements. </xs:documentation>
		</xs:annotation>
		<xs:complexContent>
			<xs:extension base="vamsas:rangeType">
				<xs:sequence>
					<xs:element name="label" type="xs:string" minOccurs="0">
						<xs:annotation>
							<xs:documentation> Short, meaningful name for the annotation - if this
								is absent, then the type string should be used in its place.
							</xs:documentation>
						</xs:annotation>
					</xs:element>
					<xs:element name="description" type="xs:string" minOccurs="0">
						<xs:annotation>
							<xs:documentation> Human readable description of the annotation
							</xs:documentation>
						</xs:annotation>
					</xs:element>
					<xs:element name="status" type="xs:string" minOccurs="0">
						<xs:annotation>
							<xs:documentation> TODO: specify this - we have considered taking the GO
								evidence codes as a model for assessing a measure of quality to an
								annotation. </xs:documentation>
						</xs:annotation>
					</xs:element>
					<xs:element ref="vamsas:annotationElement" minOccurs="0" maxOccurs="unbounded">
						<xs:annotation>
							<xs:documentation> Annotation Element position maps to ordered positions
								defined by the sequence of rangeType pos positions or concatenated
								seg start/end segments. </xs:documentation>
						</xs:annotation>
					</xs:element>
					<xs:element name="score" minOccurs="0" maxOccurs="unbounded">
						<xs:annotation>
							<xs:documentation> Ordered set of optionally named float values for the
								whole annotation </xs:documentation>
						</xs:annotation>
						<xs:complexType>
							<xs:simpleContent>
								<xs:extension base="xs:float">
									<xs:attribute name="name" type="xs:string" use="optional"
										default="score"/>
								</xs:extension>
							</xs:simpleContent>
						</xs:complexType>
					</xs:element>
					<xs:element ref="vamsas:link" minOccurs="0" maxOccurs="unbounded"/>
					<xs:element ref="vamsas:property" minOccurs="0" maxOccurs="unbounded">
						<xs:annotation>
							<xs:documentation> Note:These are mutable so an application should check
								them each time. </xs:documentation>
						</xs:annotation>
					</xs:element>
				</xs:sequence>
				<xs:attribute name="id" type="xs:ID" use="optional">
					<xs:annotation>
						<xs:documentation> Primary Key for vamsas object referencing
						</xs:documentation>
					</xs:annotation>
				</xs:attribute>
				<xs:attribute name="modifiable" type="vamsas:locks" use="optional"/>
				<xs:attribute name="group" type="xs:string" use="optional" default="">
					<xs:annotation>
						<xs:documentation> Annotation with the same non-empty group name are grouped
							together </xs:documentation>
					</xs:annotation>
				</xs:attribute>
				<xs:attribute name="type" type="xs:string" use="required">
					<xs:annotation>
						<xs:documentation> A Das Feature has both a type and a Type ID. We go the
							route of requiring the type string to be taken from a controlled
							vocabulary if an application expects others to make sense of it. The
							type may qualified - so uniprot:CHAIN is a valid type name, and
							considered distinct from someotherDB:CHAIN </xs:documentation>
					</xs:annotation>
				</xs:attribute>
			</xs:extension>
		</xs:complexContent>
	</xs:complexType>
	<xs:element name="param">
		<xs:complexType>
			<xs:annotation>
				<xs:documentation> Specifies a named and typed value used to perform some data
					transformation. </xs:documentation>
				<xs:documentation> LATER: experiment with xml validation of property set prototypes
					for services </xs:documentation>
			</xs:annotation>
			<xs:simpleContent>
				<xs:annotation>
					<xs:documentation> Named and typed property string </xs:documentation>
				</xs:annotation>
				<xs:extension base="xs:string">
					<xs:attribute name="name" type="xs:string" use="required"/>
					<xs:attribute name="type" type="xs:string" use="required">
						<xs:annotation>
							<xs:documentation> The type specifies how the property will be parsed.
								Empty property strings are allowed, and can be used to prototype the
								input to a document. TODO: specify allowed types </xs:documentation>
						</xs:annotation>
					</xs:attribute>
				</xs:extension>
			</xs:simpleContent>
		</xs:complexType>
	</xs:element>
	<xs:element name="input">
		<xs:complexType>
			<xs:annotation>
				<xs:documentation> Selects all or part of a collection of vamsas objects as a named
					input to some transformation process. Many inputs with the same name imply a
					group input (such as a collection of sequences) </xs:documentation>
			</xs:annotation>
			<xs:complexContent>
				<xs:extension base="vamsas:rangeType">
					<xs:attribute name="name" type="xs:string" use="required"/>
					<xs:attribute name="objRef" type="xs:IDREFS" use="optional">
						<xs:annotation>
							<xs:documentation> Reference Frame for rangeType specfication
							</xs:documentation>
						</xs:annotation>
					</xs:attribute>
				</xs:extension>
			</xs:complexContent>
		</xs:complexType>
	</xs:element>
	<xs:element name="Provenance">
		<xs:complexType>
			<xs:annotation>
				<xs:documentation> Defines the origin and series of operations applied directly to
					the object that references it. </xs:documentation>
			</xs:annotation>
			<xs:sequence>
				<xs:element name="entry" maxOccurs="unbounded">
					<xs:complexType>
						<xs:sequence>
							<xs:element name="User" type="xs:string">
								<xs:annotation>
									<xs:documentation> Who </xs:documentation>
								</xs:annotation>
							</xs:element>
							<xs:element name="App" type="xs:string">
								<xs:annotation>
									<xs:documentation> With which application </xs:documentation>
								</xs:annotation>
							</xs:element>
							<xs:element name="Action" type="xs:string">
								<xs:annotation>
									<xs:documentation> Did what </xs:documentation>
								</xs:annotation>
							</xs:element>
							<xs:element name="Date" type="xs:dateTime">
								<xs:annotation>
									<xs:documentation> When</xs:documentation>
								</xs:annotation>
							</xs:element>
							<xs:element ref="vamsas:property" minOccurs="0" maxOccurs="unbounded">
								<xs:annotation>
									<xs:documentation> additional information </xs:documentation>
								</xs:annotation>
							</xs:element>
							<xs:element ref="vamsas:param" minOccurs="0" maxOccurs="unbounded">
								<xs:annotation>
									<xs:documentation> parameter for the action </xs:documentation>
								</xs:annotation>
							</xs:element>
							<xs:element ref="vamsas:input" minOccurs="0" maxOccurs="unbounded">
								<xs:annotation>
									<xs:documentation> bioinformatic objects input to action
									</xs:documentation>
								</xs:annotation>
							</xs:element>
						</xs:sequence>
						<xs:attribute name="id" type="xs:ID" use="optional">
							<xs:annotation>
								<xs:documentation> Primary Key for vamsas object referencing
								</xs:documentation>
							</xs:annotation>
						</xs:attribute>
					</xs:complexType>
				</xs:element>
			</xs:sequence>
		</xs:complexType>
	</xs:element>
	<xs:element name="DataSet">
		<xs:complexType>
			<xs:annotation>
				<xs:documentation> A collection of sequences, alignments, trees and other things. </xs:documentation>
				<xs:documentation> TODO: Add a title field and properties for programs that can
					present the user with different distinct datasets For the moment, the program
					just presents them as a list and perhaps lets the user work out which dataset it
					wants based on the alignments that it contains. (Dominik and Jim 7th June 2007)
				</xs:documentation>
			</xs:annotation>
			<xs:sequence>
				<xs:element name="Sequence" maxOccurs="unbounded">
					<xs:complexType>
						<xs:annotation>
							<xs:documentation> a primary or secondary sequence record from which all
								other sequences may be derived </xs:documentation>
						</xs:annotation>
						<xs:complexContent>
							<xs:extension base="vamsas:SequenceType">
								<xs:sequence>
									<xs:element name="dbRef" minOccurs="0" maxOccurs="unbounded">
										<xs:annotation>
											<xs:documentation> Store a list of database references
												for this sequence record - with optional mapping
												from database sequence to the given sequence record </xs:documentation>
											<xs:documentation/>
											<xs:documentation/>
										</xs:annotation>
										<xs:complexType>
											<xs:sequence>
												<xs:element name="map" minOccurs="0"
												maxOccurs="unbounded">
												<xs:annotation>
												<xs:documentation>
													the local mapType maps from the parent
													sequence coordinate frame to the reference
													frame defined by the dbRef element.
													The mapped mapType is the mapped range defined
													on the dbRef element's reference frame.
													Conventionally, the unit attribute defaults to 1, or
													will be inferred from the local sequence's
													dictionary type and any dictionary type associated
													with the database being mapped to. 
													However, it may be used to avoid ambiguity.
												</xs:documentation>
												</xs:annotation>
												<xs:complexType>
												<xs:complexContent>
													<xs:extension base="vamsas:mapType">
														<xs:attribute name="id" type="xs:ID"/>
													</xs:extension>
												</xs:complexContent>
												</xs:complexType>
												</xs:element>
												<xs:element ref="vamsas:link" minOccurs="0"
												maxOccurs="unbounded"/>
												<xs:element ref="vamsas:property" minOccurs="0"
												maxOccurs="unbounded"/>
											</xs:sequence>
											<xs:attribute name="source" type="xs:string"
												use="required">
												<xs:annotation>
												<xs:documentation> TODO Database Naming
												Convention: either start using LSID (so
												change type to URI) or leave this as an
												uncontrolled/unspecified string ID
												</xs:documentation>
												</xs:annotation>
											</xs:attribute>
											<xs:attribute name="version" type="xs:string"
												use="required">
												<xs:annotation>
												<xs:documentation> Version must be specified -
												</xs:documentation>
												</xs:annotation>
											</xs:attribute>
											<xs:attribute name="accessionId" type="xs:string"
												use="required">
												<xs:annotation>
												<xs:documentation> TODO: make some specification
												of the database field from which this
												accessionId is taken from - should that be a
												special property of the dbRef object ?
												</xs:documentation>
												</xs:annotation>
											</xs:attribute>
											<xs:attribute name="id" type="xs:ID" use="optional">
												<xs:annotation>
												<xs:documentation> Primary Key for vamsas object
												referencing </xs:documentation>
												</xs:annotation>
											</xs:attribute>
										</xs:complexType>
									</xs:element>
									<xs:element name="vxref" type="vamsas:referenceType"
										minOccurs="0" maxOccurs="unbounded">
										<xs:annotation>
											<xs:documentation> explicitly named cross reference to
												other objects in the document. </xs:documentation>
										</xs:annotation>
									</xs:element>
								</xs:sequence>
								<xs:attribute name="id" type="xs:ID" use="optional">
									<xs:annotation>
										<xs:documentation> Primary Key for vamsas object referencing
										</xs:documentation>
									</xs:annotation>
								</xs:attribute>
								<xs:attribute name="dictionary" type="xs:string" use="required">
									<xs:annotation>
										<xs:documentation> symbol class for sequence
										</xs:documentation>
									</xs:annotation>
								</xs:attribute>
							</xs:extension>
						</xs:complexContent>
					</xs:complexType>
				</xs:element>
				<xs:element name="sequenceMapping" minOccurs="0" maxOccurs="unbounded">
					<xs:complexType>
						<xs:annotation>
							<xs:documentation> 
								A mapping between the specified 'local' and 'mapped' sequence coordinate frames. 
								The step size between each coordinate frame depends on the sequence
								dictionary types, or alternatively specified in the optional unit
								attribute on each range element. </xs:documentation>
						</xs:annotation>
						<xs:complexContent>
							<xs:extension base="vamsas:mapType">
								<xs:sequence>
									<xs:element ref="vamsas:Provenance"/>
								</xs:sequence>
								<xs:attribute name="loc" type="xs:IDREF" use="required">
									<xs:annotation>
										<xs:documentation> Object on which the local
											range is defined. </xs:documentation>
									</xs:annotation>
								</xs:attribute>
								<xs:attribute name="map" type="xs:IDREF" use="required">
									<xs:annotation>
										<xs:documentation>Object on which the mapped
											range is defined. </xs:documentation>
									</xs:annotation>
								</xs:attribute>
								<xs:attribute name="id" type="xs:ID" use="optional"/>
							</xs:extension>
						</xs:complexContent>
					</xs:complexType>
				</xs:element>
				<xs:element name="DataSetAnnotations" minOccurs="0" maxOccurs="unbounded">
					<xs:complexType>
						<xs:annotation>
							<xs:documentation> Annotate over positions and regions of a dataset
								sequence </xs:documentation>
						</xs:annotation>
						<xs:complexContent>
							<xs:extension base="vamsas:rangeAnnotation">
								<xs:sequence>
									<xs:element ref="vamsas:Provenance"/>
								</xs:sequence>
								<xs:attribute name="seqRef" type="xs:IDREFS" use="required">
									<xs:annotation>
										<xs:documentation> annotation is associated with a
											particular dataset sequence </xs:documentation>
									</xs:annotation>
								</xs:attribute>
							</xs:extension>
						</xs:complexContent>
					</xs:complexType>
				</xs:element>
				<xs:element name="Alignment" minOccurs="0" maxOccurs="unbounded">
					<xs:complexType>
						<xs:sequence>
							<xs:element name="AlignmentAnnotation" minOccurs="0"
								maxOccurs="unbounded">
								<xs:annotation>
									<xs:documentation> This is annotation over the coordinate frame
										defined by all the columns in the alignment.
									</xs:documentation>
								</xs:annotation>
								<xs:complexType>
									<xs:complexContent>
										<xs:extension base="vamsas:rangeAnnotation">
											<xs:sequence>
												<xs:element ref="vamsas:Provenance"/>
											</xs:sequence>
											<xs:attribute name="graph" type="xs:boolean"
												use="required">
												<xs:annotation>
												<xs:documentation> TODO: decide if this flag is
												redundant - when true it would suggest that
												the annotationElement values together form a
												graph </xs:documentation>
												</xs:annotation>
											</xs:attribute>
											<xs:attribute name="seqrefs" type="xs:IDREFS"
												use="optional">
												<xs:annotation>
												<xs:documentation> annotation is associated with
												a range on a particular group of alignment
												sequences</xs:documentation>
												</xs:annotation>
											</xs:attribute>

										</xs:extension>
									</xs:complexContent>
								</xs:complexType>
							</xs:element>
							<xs:element ref="vamsas:Tree" minOccurs="0" maxOccurs="unbounded"/>
							<xs:element name="alignmentSequence" maxOccurs="unbounded">
								<xs:complexType>
									<xs:complexContent>
										<xs:extension base="vamsas:SequenceType">
											<xs:sequence>
												<xs:element name="AlignmentSequenceAnnotation"
												minOccurs="0" maxOccurs="unbounded">
												<xs:complexType>
												<xs:annotation>
												<xs:documentation> Annotate over
												positions and regions of the
												ungapped sequence in the context of
												the alignment </xs:documentation>
												<xs:documentation/>
												</xs:annotation>
												<xs:complexContent>
												<xs:extension
												base="vamsas:rangeAnnotation">
												<xs:sequence>
												<xs:element
												ref="vamsas:Provenance"/>
												</xs:sequence>
												<xs:attribute name="graph"
												type="xs:boolean" use="required">
												<xs:annotation>
												<xs:documentation> TODO:
												decide if this flag is
												redundant - when true it
												would suggest that the
												annotationElement values
												together form a graph
												</xs:documentation>
												</xs:annotation>
												</xs:attribute>
												</xs:extension>
												</xs:complexContent>
												<!--  								
															This replaces the flat list of sequenceFeatures.
															<xs:element name="AlignmentFeatures" minOccurs="0" maxOccurs="unbounded"><xs:complexType><xs:annotation>
															<xs:documentation>Annotate over positions and regions of the alignment</xs:documentation>
															</xs:annotation><xs:complexContent>
															<xs:extension base="vamsas:rangeFeature">								
															<xs:attribute name="seqRef" type="xs:IDREF" use="optional">
															<xs:annotation><xs:documentation>annotation may be associated with a particular sequence lying within the same reference frame as the rangeType's objRef</xs:documentation></xs:annotation>
															</xs:attribute>
															</xs:extension>
															</xs:complexContent></xs:complexType></xs:element> -->
												</xs:complexType>
												</xs:element>
											</xs:sequence>
											<xs:attribute name="id" type="xs:ID" use="optional">
												<xs:annotation>
												<xs:documentation> Primary Key for vamsas object
												referencing </xs:documentation>
												</xs:annotation>
											</xs:attribute>
											<xs:attribute name="refid" type="xs:IDREF"
												use="required">
												<xs:annotation>
												<xs:documentation> Dataset Sequence from which
												this alignment sequence is taken from
												</xs:documentation>
												</xs:annotation>
											</xs:attribute>
										</xs:extension>
									</xs:complexContent>
								</xs:complexType>
							</xs:element>
							<xs:element ref="vamsas:property" minOccurs="0" maxOccurs="unbounded">
								<xs:annotation>
									<xs:documentation> typical properties may be additional
										alignment score objects </xs:documentation>
								</xs:annotation>
							</xs:element>
							<xs:element ref="vamsas:Provenance"/>
						</xs:sequence>
						<xs:attribute name="gapChar" type="xs:string" use="required"/>
						<xs:attribute name="aligned" type="xs:boolean" use="optional"/>
						<xs:attribute name="id" type="xs:ID" use="optional">
							<xs:annotation>
								<xs:documentation> Primary Key for vamsas object referencing
								</xs:documentation>
							</xs:annotation>
						</xs:attribute>
						<xs:attribute name="modifiable" type="vamsas:locks" use="optional"/>
					</xs:complexType>
				</xs:element>
				<xs:element ref="vamsas:Tree" minOccurs="0" maxOccurs="unbounded"/>
				<xs:element ref="vamsas:Provenance"/>
			</xs:sequence>
			<xs:attribute name="id" type="xs:ID" use="optional">
				<xs:annotation>
					<xs:documentation> Primary Key for vamsas object referencing </xs:documentation>
				</xs:annotation>
			</xs:attribute>
		</xs:complexType>
	</xs:element>
	<xs:element name="annotationElement">
		<xs:complexType>
			<xs:annotation>
				<xs:documentation> per-site symbolic and/or quantitative annotation </xs:documentation>
				<xs:documentation> SecondaryStructure and display character (from Jalview) have been
					subsumed into the glyph element </xs:documentation>
			</xs:annotation>
			<xs:sequence>
				<xs:element name="description" type="xs:string" minOccurs="0">
					<xs:annotation>
						<xs:documentation> Free text at this position </xs:documentation>
					</xs:annotation>
				</xs:element>
				<xs:element name="glyph" minOccurs="0" maxOccurs="unbounded">
					<xs:annotation>
						<xs:documentation> Discrete symbol - possibly graphically represented
						</xs:documentation>
					</xs:annotation>
					<xs:complexType>
						<xs:simpleContent>
							<xs:extension base="xs:string">
								<xs:attribute name="dict" type="xs:string" use="optional"
									default="utf8">
									<xs:annotation>
										<xs:documentation> specifies the symbol dictionary for this
											glyph - eg utf8 (the default), aasecstr_3 or
											kd_hydrophobicity - the content is not validated so
											applications must ensure they gracefully deal with
											invalid entries here </xs:documentation>
										<xs:documentation> TODO: specify a minimum list of glyph
											dictionaries to get us started and provide a way for the
											vamsasClient to validate their content if regexes are
											specified </xs:documentation>
									</xs:annotation>
								</xs:attribute>
							</xs:extension>
						</xs:simpleContent>
					</xs:complexType>
				</xs:element>
				<xs:element name="value" type="xs:float" minOccurs="0" maxOccurs="unbounded">
					<xs:annotation>
						<xs:documentation> Ordered set of float values - an application may treat
							the values together as a vector with common support for a set of
							annotation elements - but this is, again, not validated so applications
							should deal gracefully with varying numbers of dimensions
						</xs:documentation>
					</xs:annotation>
				</xs:element>
			</xs:sequence>
			<xs:attribute name="position" type="xs:integer" use="required">
				<xs:annotation>
					<xs:documentation> position with respect to the coordinate frame defined by a
						rangeType specification </xs:documentation>
				</xs:annotation>
			</xs:attribute>
			<xs:attribute name="after" type="xs:boolean" use="optional" default="false">
				<xs:annotation>
					<xs:documentation> true means the annotation element appears between the
						specified position and the next </xs:documentation>
				</xs:annotation>
			</xs:attribute>
			<xs:attribute name="id" type="xs:ID" use="optional">
				<xs:annotation>
					<xs:documentation> Primary Key for vamsas object referencing </xs:documentation>
				</xs:annotation>
			</xs:attribute>
		</xs:complexType>
	</xs:element>
	<xs:complexType name="SequenceType">
		<xs:sequence>
			<xs:element name="sequence" type="xs:string"/>
			<xs:element name="name" type="xs:string"/>
			<xs:element name="description" type="xs:string" minOccurs="0"/>
			<xs:element ref="vamsas:property" minOccurs="0" maxOccurs="unbounded">
				<xs:annotation>
					<xs:documentation> additional typed properties </xs:documentation>
				</xs:annotation>
			</xs:element>
		</xs:sequence>
		<xs:attribute name="start" type="xs:integer" use="required"/>
		<xs:attribute name="end" type="xs:integer" use="required"/>
	</xs:complexType>
	<xs:element name="ApplicationData">
		<xs:complexType>
			<xs:annotation>
				<xs:documentation> Data specific to a particular type and version of vamsas
					application </xs:documentation>
			</xs:annotation>
			<xs:complexContent>
				<xs:extension base="vamsas:appData">
					<xs:sequence>
						<xs:element name="User" minOccurs="0" maxOccurs="unbounded">
							<xs:complexType>
								<xs:complexContent>
									<xs:extension base="vamsas:appData">
										<xs:annotation>
											<xs:documentation> Data available to just a particular
												user </xs:documentation>
										</xs:annotation>
										<xs:attribute name="fullname" type="xs:string"
											use="required"/>
										<xs:attribute name="organization" type="xs:string"
											use="required"/>
									</xs:extension>
								</xs:complexContent>
							</xs:complexType>
						</xs:element>
						<xs:element name="Common" minOccurs="0">
							<xs:complexType>
								<xs:complexContent>
									<xs:extension base="vamsas:appData"/>
								</xs:complexContent>
							</xs:complexType>
						</xs:element>
						<xs:element name="Instance" minOccurs="0" maxOccurs="unbounded">
							<xs:complexType>
								<xs:complexContent>
									<xs:extension base="vamsas:appData">
										<xs:annotation>
											<xs:documentation> Data available to just a specific
												instance of the application </xs:documentation>
											<xs:documentation> VAMSAS/Pierre: Is this data volatile
												? Application instances may not be accessible after
												the session has closed - the user may have to be
												presented with the option of picking up the data in
												that instance </xs:documentation>
										</xs:annotation>
										<xs:attribute name="urn" type="xs:string" use="required"/>
									</xs:extension>
								</xs:complexContent>
							</xs:complexType>
						</xs:element>
					</xs:sequence>
					<xs:attribute name="version" type="xs:string" use="required">
						<xs:annotation>
							<xs:documentation> Version string describing the application specific
								data storage version used</xs:documentation>
						</xs:annotation>
					</xs:attribute>
					<xs:attribute name="name" type="xs:string" use="required">
						<xs:annotation>
							<xs:documentation> Canonical name of application </xs:documentation>
						</xs:annotation>
					</xs:attribute>
				</xs:extension>
			</xs:complexContent>
		</xs:complexType>
	</xs:element>
	<xs:element name="Attachment">
		<xs:complexType>
			<xs:complexContent>
				<xs:extension base="vamsas:appData">
					<xs:annotation>
						<xs:documentation> General data container to attach a typed data object to
							any vamsas object </xs:documentation>
					</xs:annotation>
					<xs:attribute name="compressed" type="xs:boolean" use="optional" default="false">
						<xs:annotation>
							<xs:documentation> true implies data will be decompresses with Zip
								before presenting to application </xs:documentation>
						</xs:annotation>
					</xs:attribute>
					<xs:attribute name="type" type="xs:string" use="required">
						<xs:annotation>
							<xs:documentation> Type of arbitrary data - TODO: decide format - use
								(extended) MIME types ? </xs:documentation>
						</xs:annotation>
					</xs:attribute>
					<xs:attribute name="objectref" type="xs:IDREF" use="required">
						<xs:annotation>
							<xs:documentation> Object the arbitrary data is associated with
							</xs:documentation>
						</xs:annotation>
					</xs:attribute>
					<xs:attribute name="id" type="xs:ID" use="optional">
						<xs:annotation>
							<xs:documentation> Primary Key for vamsas object referencing
							</xs:documentation>
						</xs:annotation>
					</xs:attribute>
				</xs:extension>
			</xs:complexContent>
		</xs:complexType>
	</xs:element>
	<xs:complexType name="appData">
		<xs:choice>
			<xs:element name="data" type="xs:base64Binary"/>
			<xs:element name="dataReference" type="xs:string"/>
		</xs:choice>
	</xs:complexType>
	<xs:complexType name="mapType">
		<xs:annotation>
			<xs:documentation> Two sets of ranges defined between objects - usually sequences, indicating which
				regions on each are mapped. </xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="local" type="vamsas:mapRangeType">
				<xs:annotation>
					<xs:documentation>
						
					</xs:documentation>
				</xs:annotation>
			</xs:element>
			<xs:element name="mapped" type="vamsas:mapRangeType">
				<xs:annotation>
					<xs:documentation>
						
					</xs:documentation>
				</xs:annotation>
			</xs:element>
		</xs:sequence>
		</xs:complexType>
	
	<xs:complexType name="mapRangeType">
		<xs:complexContent>
			<xs:extension base="vamsas:rangeType">
				<xs:attribute name="unit" type="xs:positiveInteger" use="optional">
					<xs:annotation>
						<xs:documentation> number of dictionary symbol widths involved in each
							mapped position on this sequence (for example, 3 for a dna sequence exon
							region that is being mapped to a protein sequence). This is optional,
							since the unit can be usually be inferred from the dictionary type of
							each sequence involved in the mapping. </xs:documentation>
					</xs:annotation>
				</xs:attribute>
			</xs:extension>
		</xs:complexContent>	
	</xs:complexType>

	<xs:simpleType name="locks">
		<xs:annotation>
			<xs:documentation> Contains lock information: locktype:ApplicationHandle locktype is
				'local' or 'full' A lock is only valid if the ApplicationHandle resolves to a living
				application in the vamsas session. A local lock means that the application has
				locked changes to all local properties on the object. A full lock means that the
				application has locked changes to all properties on the object, and any objects that
				it holds references to. </xs:documentation>
		</xs:annotation>
		<xs:restriction base="xs:string"/>
	</xs:simpleType>
</xs:schema>