<?xml version="1.0" encoding="UTF-8"?>
<xs:schema targetNamespace="urn:publicid:IDN+www.sims.berkeley.edu:schema:syllabusapp:syllabus:200404:en" elementFormDefault="qualified" attributeFormDefault="unqualified" xmlns:xs="http://www.w3.org/2001/XMLSchema" xmlns:s="urn:publicid:IDN+www.sims.berkeley.edu:schema:syllabusapp:syllabus:200404:en">
	<xs:element name="course" type="s:CourseType">
		<xs:annotation>
			<xs:documentation>Keys maintain the relationship between textbook codes and the text readings, as well as teachers and class lecturers.</xs:documentation>
		</xs:annotation>
		<!--<xs:key name="TeacherKey">
			<xs:selector xpath=".//s:teacher"/>
			<xs:field xpath="s:initials"/>
		</xs:key>
		<xs:key name="TextbookKey">
			<xs:selector xpath=".//s:textbook"/>
			<xs:field xpath="s:textbookCode"/>
		</xs:key>
		<xs:keyref name="TextbookCodeReference" refer="s:TextbookKey">
			<xs:selector xpath=".//s:textbookReading"/>
			<xs:field xpath="s:code"/>
		</xs:keyref>
		<xs:keyref name="teacherCodeReference" refer="s:TeacherKey">
			<xs:selector xpath=".//s:class"/>
			<xs:field xpath="s:lecturer"/>
		</xs:keyref>-->
	</xs:element>
	<xs:complexType name="CourseType">
		<xs:annotation>
			<xs:documentation>The root element of the schema is course, since we realized that the syllabus information is really a child element of a greater set of information about the course. Basic information like course title, description, and units are grouped in a GeneralInformation wrapper, followed by the syllabus elements themselves.</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="generalInformation" type="s:GeneralInformationType"/>
			<xs:element name="syllabus" type="s:SyllabusType" maxOccurs="unbounded"/>
			<xs:element name="updated" type="s:UpdateType"/>
		</xs:sequence>
	</xs:complexType>
	<xs:complexType name="GeneralInformationType">
		<xs:annotation>
			<xs:documentation>This is the wrapper class for all the basic course information that we capture in addition to the actual syllabus.</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="title" type="xs:string"/>
			<xs:choice>
				<xs:element name="units" type="xs:integer"/>
				<xs:element name="unitOptions" type="s:UnitOptionsType"/>
			</xs:choice>
			<xs:element name="website" type="s:CourseWebsiteType" maxOccurs="unbounded"/>
			<xs:element name="departmentListing" type="s:DepartmentListingType" maxOccurs="unbounded"/>
			<xs:element name="schedule" type="s:ScheduleType"/>
			<xs:element name="teachingTeam" type="s:TeachingTeamType"/>
			<xs:element name="gradingOptionCode" type="s:GradingOptionCodeType"/>
			<xs:element name="textList" type="s:TextListType"/>
			<xs:element name="mailingList" type="xs:anyURI" minOccurs="0"/>
			<xs:element name="description" type="s:htmlContent" minOccurs="0"/>
			<xs:element name="descriptionURL" type="xs:anyURI" minOccurs="0"/>
			<xs:element name="gradingCriteria" type="s:GradingCriteriaType" minOccurs="0"/>
			<xs:element name="courseResource" type="s:CourseResourceType" minOccurs="0" maxOccurs="unbounded"/>
		</xs:sequence>
	</xs:complexType>
	<xs:complexType name="UnitOptionsType">
		<xs:annotation>
			<xs:documentation>If a course has variable unit options, editors can use this element to list the possible unit values.</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="option" type="xs:integer" minOccurs="2" maxOccurs="unbounded"/>
		</xs:sequence>
	</xs:complexType>
	<xs:complexType name="CourseWebsiteType">
		<xs:annotation>
			<xs:documentation>Since there can be many types of course websites, any number can be included in the xml instance, and an enumerated attribute allows for differentiation. Current website types incude a main site (assumed when there is no attribute), wiki, and blog. The enumeration can be expanded to include any new web trend that comes along.</xs:documentation>
		</xs:annotation>
		<xs:simpleContent>
			<xs:extension base="xs:anyURI">
				<xs:attribute name="type" type="s:WebsiteType"/>
			</xs:extension>
		</xs:simpleContent>
	</xs:complexType>
	<xs:simpleType name="WebsiteType">
		<xs:annotation>
			<xs:documentation>See explanation of CourseWebsiteType, above.</xs:documentation>
		</xs:annotation>
		<xs:restriction base="xs:string">
			<xs:enumeration value="wiki"/>
			<xs:enumeration value="blog"/>
		</xs:restriction>
	</xs:simpleType>
	<xs:complexType name="DepartmentListingType">
		<xs:annotation>
			<xs:documentation>Basic information about each department in which a course is listed - a course might have any number of department listings. Department codes are maintained in the BABL codelist.</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="name" type="xs:string"/>
			<xs:element name="code" type="s:BerkeleyAcademicDepartmentCodeType"/>
			<xs:element name="courseNumber" type="xs:string"/>
			<xs:element name="courseNumberSuffix" type="xs:string" minOccurs="0"/>
			<xs:element name="website" type="xs:anyURI" minOccurs="0"/>
		</xs:sequence>
	</xs:complexType>
	<xs:simpleType name="BerkeleyAcademicDepartmentCodeType">
		<xs:annotation>
			<xs:documentation>Based on babl BerkeleyAcademicDepartmentCodeContentType - these are the departments for which SIMS classes might be cross listed (i.e. those in which SIMS professors have cross-appointments). Any wider adoption of Sylvia will require additions to this codelist.</xs:documentation>
		</xs:annotation>
		<xs:restriction base="xs:string">
			<xs:enumeration value="COMPSCI">
				<xs:annotation>
					<xs:appinfo>Computer Science</xs:appinfo>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="CYPLAN">
				<xs:annotation>
					<xs:appinfo>City and Regional Planning</xs:appinfo>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="ECON">
				<xs:annotation>
					<xs:appinfo>Economics</xs:appinfo>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="EECS">
				<xs:annotation>
					<xs:appinfo>Electrical Engineering and Computer Science</xs:appinfo>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="ENG">
				<xs:annotation>
					<xs:appinfo>Engineering</xs:appinfo>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="INFOSYS">
				<xs:annotation>
					<xs:appinfo>Information Management and Systems</xs:appinfo>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="IEOR">
				<xs:annotation>
					<xs:appinfo>Industrial Engineering and Operations Research</xs:appinfo>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="LAW">
				<xs:annotation>
					<xs:appinfo>Boalt School of Law</xs:appinfo>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="ME">
				<xs:annotation>
					<xs:appinfo>Mechanical Engineering</xs:appinfo>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="MBA">
				<xs:annotation>
					<xs:appinfo>Haas School of Business</xs:appinfo>
				</xs:annotation>
			</xs:enumeration>
		</xs:restriction>
	</xs:simpleType>
	<xs:complexType name="ScheduleType">
		<xs:annotation>
			<xs:documentation>Schedule type indicates year, semester, and start and end dates for a class. This allows for a syllabus to be reused year-to-year with the same class numbering, as the application automatically adjusts for the schedule dates.</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="year" type="xs:gYear"/>
			<xs:element name="semester" type="s:SemesterType"/>
			<xs:element name="startDate" type="xs:date"/>
			<xs:element name="endDate" type="xs:date"/>
		</xs:sequence>
	</xs:complexType>
	<xs:simpleType name="SemesterType">
		<xs:annotation>
			<xs:documentation>Based on babl BerkeleyTermCodeContentType.</xs:documentation>
		</xs:annotation>
		<xs:restriction base="xs:string">
			<xs:enumeration value="F">
				<xs:annotation>
					<xs:appinfo>Fall</xs:appinfo>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="S">
				<xs:annotation>
					<xs:appinfo>Spring</xs:appinfo>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="Su">
				<xs:annotation>
					<xs:appinfo>Summer</xs:appinfo>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="W">
				<xs:annotation>
					<xs:appinfo>Winter</xs:appinfo>
				</xs:annotation>
			</xs:enumeration>
		</xs:restriction>
	</xs:simpleType>
	<xs:complexType name="TeachingTeamType">
		<xs:annotation>
			<xs:documentation>Since some classes setup an email that is directed to all teachers and TA's, the teaching team has its own contact child element.</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="contact" type="s:ContactInformationType" minOccurs="0"/>
			<xs:element name="teacher" type="s:TeacherType" maxOccurs="unbounded"/>
		</xs:sequence>
	</xs:complexType>
	<xs:complexType name="ContactInformationType">
		<xs:annotation>
			<xs:documentation>Contact information is pretty self-explanatory.</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="email" type="xs:anyURI" maxOccurs="unbounded"/>
			<xs:element name="phone" type="s:PhoneType" minOccurs="0" maxOccurs="unbounded"/>
			<xs:element name="website" type="xs:anyURI" minOccurs="0"/>
		</xs:sequence>
	</xs:complexType>
	<xs:complexType name="PhoneType">
		<xs:annotation>
			<xs:documentation>An enumerated codelist allows for an attribute indicating the type of phone.</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="type" type="s:PhoneTypeCode"/>
			<xs:element name="number" type="xs:string"/>
		</xs:sequence>
	</xs:complexType>
	<xs:simpleType name="PhoneTypeCode">
		<xs:annotation>
			<xs:documentation>See annotation for PhoneType, above.</xs:documentation>
		</xs:annotation>
		<xs:restriction base="xs:string">
			<xs:enumeration value="Office"/>
			<xs:enumeration value="Mobile"/>
			<xs:enumeration value="Home"/>
		</xs:restriction>
	</xs:simpleType>
	<xs:complexType name="TeacherType">
		<xs:annotation>
			<xs:documentation>This element includes all necessary information about teachers for the class. The enumerated  typeCode corresponds to Berkeley's official categorization. teacherCode is an xsd key which is referenced in the lecture element which is a child of class, below. Normally teacherCode would be a teacher's initials.</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="typeCode" type="s:TeacherTypeCodeType"/>
			<xs:element name="initials" type="xs:string"/>
			<xs:element name="name" type="s:NameType"/>
			<xs:element name="contact" type="s:ContactInformationType" maxOccurs="unbounded"/>
			<xs:element name="officeHours" type="s:OfficeHoursType" minOccurs="0" maxOccurs="unbounded"/>
		</xs:sequence>
	</xs:complexType>
	<xs:simpleType name="TeacherTypeCodeType">
		<xs:annotation>
			<xs:documentation>See documentation for TeacherType, above.</xs:documentation>
		</xs:annotation>
		<xs:restriction base="xs:string">
			<xs:enumeration value="Professor"/>
			<xs:enumeration value="Assistant Professor"/>
			<xs:enumeration value="Associate Professor"/>
			<xs:enumeration value="Adjunct Professor"/>
			<xs:enumeration value="Instructor"/>
			<xs:enumeration value="Lecturer"/>
			<xs:enumeration value="GSI"/>
			<xs:enumeration value="TA"/>
			<xs:enumeration value="Tutor"/>
			<xs:enumeration value="Reader"/>
		</xs:restriction>
	</xs:simpleType>
	<xs:complexType name="NameType">
		<xs:annotation>
			<xs:documentation>Our name element give the editor a choice between one full name string (intended mostly for use with institutional names) and personal name group which includes given name, middle name(s), and family name.</xs:documentation>
		</xs:annotation>
		<xs:choice>
			<xs:element name="fullName" type="xs:string"/>
			<xs:group ref="s:personalName"/>
		</xs:choice>
	</xs:complexType>
	<xs:group name="personalName">
		<xs:annotation>
			<xs:documentation>See documentation for NameType, above.</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="givenName" type="xs:string"/>
			<xs:element name="middleName" type="xs:string" minOccurs="0" maxOccurs="unbounded"/>
			<xs:element name="familyName" type="xs:string"/>
			<xs:element name="suffix" type="xs:string" minOccurs="0"/>
		</xs:sequence>
	</xs:group>
	<xs:complexType name="OfficeHoursType">
		<xs:annotation>
			<xs:documentation>This element holds information on teacher office hours - it includes the dayPattern element, which indicates a series of days and times and is reused in the actual syllabus element.</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="dayPattern" type="s:DayPatternType"/>
			<xs:element name="location" type="xs:string"/>
			<xs:element name="comment" type="s:htmlContent" minOccurs="0"/>
		</xs:sequence>
	</xs:complexType>
	<xs:complexType name="DayPatternType">
		<xs:annotation>
			<xs:documentation>DayPattern is composed of one or more sets of days and times within that day. For instance, a teacher might have office hours on Wednesday from 2-3 and Thursday from 10-11.</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="dayTime" type="s:DayTimeType" maxOccurs="unbounded"/>
		</xs:sequence>
	</xs:complexType>
	<xs:complexType name="DayTimeType">
		<xs:annotation>
			<xs:documentation>A particular day and time - see documentation for DayPatternType, above.</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="dayOfWeek" type="s:DayOfWeekType"/>
			<xs:element name="timeSpan" type="s:TimeSpanType"/>
		</xs:sequence>
	</xs:complexType>
	<xs:simpleType name="DayOfWeekType">
		<xs:annotation>
			<xs:appinfo>
				<xs:documentation>Based on BABL DayOfWeekType, code list for days of the week.</xs:documentation>
			</xs:appinfo>
		</xs:annotation>
		<xs:restriction base="xs:string">
			<xs:enumeration value="Su">
				<xs:annotation>
					<xs:appinfo>Sunday</xs:appinfo>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="M">
				<xs:annotation>
					<xs:appinfo>Monday</xs:appinfo>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="Tu">
				<xs:annotation>
					<xs:appinfo>Tuesday</xs:appinfo>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="W">
				<xs:annotation>
					<xs:appinfo>Wednesday</xs:appinfo>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="Th">
				<xs:annotation>
					<xs:appinfo>Thursday</xs:appinfo>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="F">
				<xs:annotation>
					<xs:appinfo>Friday</xs:appinfo>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="Sa">
				<xs:annotation>
					<xs:appinfo>Saturday</xs:appinfo>
				</xs:annotation>
			</xs:enumeration>
		</xs:restriction>
	</xs:simpleType>
	<xs:complexType name="TimeSpanType">
		<xs:annotation>
			<xs:documentation>A simple time span type includes a start time and end time.</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="startTime" type="xs:time"/>
			<xs:element name="endTime" type="xs:time"/>
		</xs:sequence>
	</xs:complexType>
	<xs:simpleType name="GradingOptionCodeType">
		<xs:annotation>
			<xs:documentation>Based on babl BerkeleyGradingOptionCodeContentType - these are all the valid UC Berkeley grading options.</xs:documentation>
		</xs:annotation>
		<xs:restriction base="xs:token">
			<xs:enumeration value="LG">
				<xs:annotation>
					<xs:appinfo>Letter Grade only</xs:appinfo>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="PNP">
				<xs:annotation>
					<xs:appinfo>Pass/No Pass only</xs:appinfo>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="SU">
				<xs:annotation>
					<xs:appinfo>Satisfactory/Unsatisfactory only</xs:appinfo>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="LPS">
				<xs:annotation>
					<xs:appinfo>Letter Grade or Pass/NoPass or Satisfactory/Unsatisfactory</xs:appinfo>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="IP">
				<xs:annotation>
					<xs:appinfo>In Progress</xs:appinfo>
				</xs:annotation>
			</xs:enumeration>
		</xs:restriction>
	</xs:simpleType>
	<xs:complexType name="TextListType">
		<xs:annotation>
			<xs:documentation>Based on expert feedback, we decided that having an optionally empty text wrapper class would be better for processing than having text and reader elements which might or might not be present. So here is that wrapper class.</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="textbook" type="s:TextbookType" minOccurs="0" maxOccurs="unbounded"/>
			<xs:element name="reader" type="s:ReaderType" minOccurs="0" maxOccurs="unbounded"/>
		</xs:sequence>
	</xs:complexType>
	<xs:complexType name="TextbookType">
		<xs:annotation>
			<xs:documentation>The textbook element includes all the basic bibliographic information. The textbookCode is an xsd key referenced in the textReading element, below. The volume information is captured as a group so it can be reused in some of the reading types, below. Also, the requirement enumeration allows teachers to indicate to students which books are really necessary.</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="code" type="xs:string"/>
			<xs:group ref="s:volumeType"/>
			<xs:element name="requirement" type="s:RequirementType"/>
			<xs:element name="website" type="xs:anyURI" minOccurs="0"/>
			<xs:element name="comment" type="s:htmlContent" minOccurs="0"/>
		</xs:sequence>
	</xs:complexType>
	<xs:group name="volumeType">
		<xs:annotation>
			<xs:documentation>Basic bibliographic information used in TextbookType, AnthologyReadingType, and ChapterReadingType.</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="title" type="xs:string"/>
			<xs:choice>
				<xs:element name="author" type="s:NameType" maxOccurs="unbounded"/>
				<xs:element name="editor" type="s:NameType" maxOccurs="unbounded"/>
			</xs:choice>
			<xs:element name="publisher" type="xs:string" minOccurs="0"/>
			<xs:element name="publisherLocation" type="xs:string" minOccurs="0"/>
			<xs:element name="publishDate" type="xs:string" minOccurs="0"/>
			<xs:element name="isbn" type="xs:string" minOccurs="0"/>
		</xs:sequence>
	</xs:group>
	<xs:simpleType name="RequirementType">
		<xs:annotation>
			<xs:documentation>See documentation for TextbookType, above.</xs:documentation>
		</xs:annotation>
		<xs:restriction base="xs:string">
			<xs:enumeration value="Required"/>
			<xs:enumeration value="Skim"/>
			<xs:enumeration value="Recommended"/>
			<xs:enumeration value="Optional"/>
			<xs:enumeration value="Alternate"/>
		</xs:restriction>
	</xs:simpleType>
	<xs:complexType name="ReaderType">
		<xs:annotation>
			<xs:documentation>Information about the course reader includes copy store and optional comments.</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="copyStore" type="xs:string"/>
			<xs:element name="comment" type="s:htmlContent" minOccurs="0"/>
		</xs:sequence>
	</xs:complexType>
	<xs:complexType name="GradingCriteriaType">
		<xs:annotation>
			<xs:documentation>GradingCriteria allows a teacher to indicate the percentages by which the final grade will be determined (i.e. Exams 50%, Project 50%).</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="criterion" type="s:CriterionType" maxOccurs="unbounded"/>
			<xs:element name="comment" type="s:htmlContent" minOccurs="0"/>
		</xs:sequence>
	</xs:complexType>
	<xs:complexType name="CriterionType">
		<xs:annotation>
			<xs:documentation>A grading criterion is composed of one area of class requirements and the percentage at which it will enter into the final grade. See gradingCriterion, above.</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="area" type="xs:string"/>
			<xs:element name="percentage" type="xs:integer"/>
		</xs:sequence>
	</xs:complexType>
	<xs:complexType name="CourseResourceType">
		<xs:annotation>
			<xs:documentation>Based on the more general ResourceType, below, but we include an optional group attribute in case professors want to group their course resources under some more specific headings.</xs:documentation>
		</xs:annotation>
		<xs:complexContent>
			<xs:extension base="s:ResourceType">
				<xs:attribute name="group" type="xs:string"/>
			</xs:extension>
		</xs:complexContent>
	</xs:complexType>
	<xs:complexType name="ResourceType">
		<xs:annotation>
			<xs:documentation>Resources, which can be applied to the course, a class, a reading, or an assignment, are a bit of a catch-all element for professors to include any extra content they feel will be helpful for the syllabus.</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="title" type="xs:string"/>
			<xs:element name="url" type="xs:anyURI" minOccurs="0"/>
			<xs:element name="comment" type="s:htmlContent" minOccurs="0"/>
		</xs:sequence>
	</xs:complexType>
	<xs:complexType name="SyllabusType">
		<xs:annotation>
			<xs:documentation>The syllabus element is the heart of the schema. A course will have one syllabus for every type of meeting conducted - for instance, a course with both lecture and lab will have one syllabus for each. These meeting types are based on official Berkeley designations and are contained in a BABL codelist. In general, each syllabus indicates the time and place to meet, as well as information about classes, assignments, and exams.</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="instructionFormatCode" type="s:InstructionFormatCodeType"/>
			<xs:element name="dayPattern" type="s:DayPatternType"/>
			<xs:element name="location" type="xs:string"/>
			<xs:element name="classes" type="s:ClassesType"/>
			<xs:element name="assignments" type="s:AssignmentsType" minOccurs="0"/>
			<xs:element name="exams" type="s:ExamsType" minOccurs="0"/>
		</xs:sequence>
	</xs:complexType>
	<xs:simpleType name="InstructionFormatCodeType">
		<xs:annotation>
			<xs:appinfo>
				<xs:documentation>Based on babl BerkeleyInstructionFormatCodeContentType - these are all the valid UC Berkeley grading options.</xs:documentation>
			</xs:appinfo>
		</xs:annotation>
		<xs:restriction base="xs:token">
			<xs:enumeration value="LEC">
				<xs:annotation>
					<xs:appinfo>Lecture</xs:appinfo>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="DIS">
				<xs:annotation>
					<xs:appinfo>Discussion</xs:appinfo>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="LAB">
				<xs:annotation>
					<xs:appinfo>Laboratory</xs:appinfo>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="SEM">
				<xs:annotation>
					<xs:appinfo>Seminar</xs:appinfo>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="STD">
				<xs:annotation>
					<xs:appinfo>Studio</xs:appinfo>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="WOR">
				<xs:annotation>
					<xs:appinfo>Workshop</xs:appinfo>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="FLD">
				<xs:annotation>
					<xs:appinfo>Field Study</xs:appinfo>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="COL">
				<xs:annotation>
					<xs:appinfo>Colloquium</xs:appinfo>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="CLC">
				<xs:annotation>
					<xs:appinfo>Clinic</xs:appinfo>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="TUT">
				<xs:annotation>
					<xs:appinfo>Tutorial</xs:appinfo>
				</xs:annotation>
			</xs:enumeration>
		</xs:restriction>
	</xs:simpleType>
	<xs:complexType name="ClassesType">
		<xs:annotation>
			<xs:documentation>Individual classes can optionally be grouped into components if the course is organized around larger themes. If components are chosen, then each class must be the child of components - mixing and matching component classes and stand-alone classes is not allowed. So the children of the ClassesType will either be a series of components with classes as their children, or just a series of classes.</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:choice>
				<xs:element name="component" type="s:ComponentType" maxOccurs="unbounded"/>
				<xs:element name="class" type="s:ClassType" maxOccurs="unbounded"/>
			</xs:choice>
		</xs:sequence>
	</xs:complexType>
	<xs:complexType name="ComponentType">
		<xs:annotation>
			<xs:documentation>If the syllabus groups classes into components (see ClassesType, above), then each component has a title, optional description, and child class elements.</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="title" type="xs:string"/>
			<xs:element name="description" type="s:htmlContent" minOccurs="0"/>
			<xs:element name="class" type="s:ClassType" maxOccurs="unbounded"/>
		</xs:sequence>
	</xs:complexType>
	<xs:complexType name="ClassType">
		<xs:annotation>
			<xs:documentation>The class element is slightly complicated. Title is required, along with either a class number or class date. If a number is used, the application automatically maps this to the appropriate calendar date based on the ScheduleType, above. For makeup classes or others falling out of the general pattern of class meetings, users can indicate a specific class date instead. Optional elements include class description and an element indicating that there is a holiday. A choice is given between lecturer, keyed to the TeacherType teacherCodes above, or guest lecturer. Also optional are discussion leader and readings and resources for the class.</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="title" type="xs:string"/>
			<xs:choice>
				<xs:element name="number" type="xs:integer"/>
				<xs:element name="date" type="xs:date"/>
			</xs:choice>
			<xs:choice>
				<xs:element name="lecturer" type="xs:string" minOccurs="0" maxOccurs="unbounded"/>
				<xs:element name="guestLecturer" type="s:GuestLecturerType" minOccurs="0" maxOccurs="unbounded"/>
			</xs:choice>
			<xs:element name="description" type="s:htmlContent" minOccurs="0"/>
			<xs:element name="holiday" type="xs:boolean" minOccurs="0"/>
			<xs:element name="discussionLeader" type="s:NameType" minOccurs="0" maxOccurs="unbounded"/>
			<xs:element name="readingList" type="s:ReadingListType"/>
			<xs:element name="resourceList" type="s:ResourceListType"/>
		</xs:sequence>
	</xs:complexType>
	<xs:complexType name="GuestLecturerType">
		<xs:annotation>
			<xs:documentation>Guest lecturers' names must be included, along with optional affiliation and contact information.</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="name" type="s:NameType"/>
			<xs:element name="affiliation" type="xs:string" minOccurs="0"/>
			<xs:element name="contact" type="s:ContactInformationType" minOccurs="0"/>
		</xs:sequence>
	</xs:complexType>
	<xs:complexType name="ReadingListType">
		<xs:annotation>
			<xs:documentation>Based on expert feedback, we decided that having an optionally empty reading wrapper class would be better for processing than having reading elements which might or might not be present. So here is that wrapper class.</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:element ref="s:reading" minOccurs="0" maxOccurs="unbounded"/>
		</xs:sequence>
	</xs:complexType>
	<xs:element name="reading" type="s:ReadingType" abstract="true"/>
	<xs:complexType name="ReadingType" abstract="true">
		<xs:annotation>
			<xs:documentation>Readings are modeled as a substitution group with four elements common to all reading types. Those four elements are included here, and this element forms the basis for all the more specific reading types in the substitution group.</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="requirement" type="s:RequirementType"/>
			<xs:element name="pageSpan" type="xs:string" minOccurs="0"/>
			<xs:element name="url" type="xs:anyURI" minOccurs="0"/>
			<xs:element name="comment" type="s:htmlContent" minOccurs="0"/>
		</xs:sequence>
	</xs:complexType>
	<xs:simpleType name="MediumType">
		<xs:annotation>
			<xs:documentation>Medium indicates where a student can find the reading. It is used for all reading types except website reading, which is obviously online.</xs:documentation>
		</xs:annotation>
		<xs:restriction base="xs:string">
			<xs:enumeration value="Handout"/>
			<xs:enumeration value="Online"/>
			<xs:enumeration value="Reader"/>
			<xs:enumeration value="Textbook"/>
		</xs:restriction>
	</xs:simpleType>
	<xs:element name="anthologyReading" type="s:AnthologyReadingType" substitutionGroup="s:reading"/>
	<xs:complexType name="AnthologyReadingType">
		<xs:complexContent>
			<xs:annotation>
				<xs:documentation>Anthology reading is used to assign a chapter or article from a book that is a collection of pieces by difference authors. Since the anthology might be a textbook or a chapter from a non-required text, editors can choose between using just the code for a textbook or the full volume group (see documentation for TextbookType, above).</xs:documentation>
			</xs:annotation>
			<xs:extension base="s:ReadingType">
				<xs:sequence>
					<xs:element name="medium" type="s:MediumType"/>
					<xs:element name="articleTitle" type="xs:string"/>
					<xs:element name="articleAuthor" type="s:NameType" maxOccurs="unbounded"/>
					<xs:choice>
						<xs:group ref="s:volumeType"/>
						<xs:element name="textbookCode" type="xs:string"/>
					</xs:choice>
				</xs:sequence>
			</xs:extension>
		</xs:complexContent>
	</xs:complexType>
	<xs:element name="billReading" type="s:BillReadingType" substitutionGroup="s:reading"/>
	<xs:complexType name="BillReadingType">
		<xs:annotation>
			<xs:documentation>Used for encoding a legal bill or law as a reading.</xs:documentation>
		</xs:annotation>
		<xs:complexContent>
			<xs:extension base="s:ReadingType">
				<xs:sequence>
					<xs:element name="medium" type="s:MediumType"/>
					<xs:element name="number" type="xs:string"/>
					<xs:element name="title" type="xs:string"/>
					<xs:element name="date" type="xs:gYear"/>
				</xs:sequence>
			</xs:extension>
		</xs:complexContent>
	</xs:complexType>
	<xs:element name="briefReading" type="s:BriefReadingType" substitutionGroup="s:reading"/>
	<xs:complexType name="BriefReadingType">
		<xs:annotation>
			<xs:documentation>Used for encoding a legal brief as a reading.</xs:documentation>
		</xs:annotation>
		<xs:complexContent>
			<xs:extension base="s:ReadingType">
				<xs:sequence>
					<xs:element name="medium" type="s:MediumType"/>
					<xs:element name="title" type="xs:string"/>
					<xs:element name="circuit" type="xs:string"/>
					<xs:element name="case" type="xs:string"/>
					<xs:element name="date" type="xs:gYear"/>
				</xs:sequence>
			</xs:extension>
		</xs:complexContent>
	</xs:complexType>
	<xs:element name="caseReading" type="s:CaseReadingType" substitutionGroup="s:reading"/>
	<xs:complexType name="CaseReadingType">
		<xs:annotation>
			<xs:documentation>Used for encoding a court case as a reading.</xs:documentation>
		</xs:annotation>
		<xs:complexContent>
			<xs:extension base="s:ReadingType">
				<xs:sequence>
					<xs:element name="medium" type="s:MediumType"/>
					<xs:element name="title" type="xs:string"/>
					<xs:element name="number" type="xs:string"/>
					<xs:element name="circuit" type="xs:string"/>
					<xs:element name="date" type="xs:gYear"/>
				</xs:sequence>
			</xs:extension>
		</xs:complexContent>
	</xs:complexType>
	<xs:element name="chapterReading" type="s:ChapterReadingType" substitutionGroup="s:reading"/>
	<xs:complexType name="ChapterReadingType">
		<xs:annotation>
			<xs:documentation>Chapter reading is used to assign a chapter from a book by a single author or authors (as opposed to AnthologyReadingType, above). Since the book might be a textbook or a chapter from a non-required text, editors can choose between using just the code for a textbook or the full volume group (see documentation for TextbookType, above).</xs:documentation>
		</xs:annotation>
		<xs:complexContent>
			<xs:extension base="s:ReadingType">
				<xs:sequence>
					<xs:element name="medium" type="s:MediumType"/>
					<xs:element name="chapterNumber" type="xs:string"/>
					<xs:element name="chapterTitle" type="xs:string" minOccurs="0"/>
					<xs:choice>
						<xs:group ref="s:volumeType"/>
						<xs:element name="textbookCode" type="xs:string"/>
					</xs:choice>
				</xs:sequence>
			</xs:extension>
		</xs:complexContent>
	</xs:complexType>
	<xs:element name="journalReading" type="s:JournalReadingType" substitutionGroup="s:reading"/>
	<xs:complexType name="JournalReadingType">
		<xs:annotation>
			<xs:documentation>Used for assigning an article from a journal, either online or in paper form.</xs:documentation>
		</xs:annotation>
		<xs:complexContent>
			<xs:extension base="s:ReadingType">
				<xs:sequence>
					<xs:element name="medium" type="s:MediumType"/>
					<xs:element name="articleTitle" type="xs:string"/>
					<xs:element name="articleAuthor" type="s:NameType" maxOccurs="unbounded"/>
					<xs:element name="journalTitle" type="xs:string"/>
					<xs:element name="volume" type="xs:string" minOccurs="0"/>
					<xs:element name="publishDate" type="xs:string" minOccurs="0"/>
				</xs:sequence>
			</xs:extension>
		</xs:complexContent>
	</xs:complexType>
	<xs:element name="websiteReading" type="s:WebsiteReadingType" substitutionGroup="s:reading"/>
	<xs:complexType name="WebsiteReadingType">
		<xs:annotation>
			<xs:documentation>Website reading is intended for when students should be perusing a website generally or a piece available online, though articles from online journals might be better modeled using JournalReadingType, above.</xs:documentation>
		</xs:annotation>
		<xs:complexContent>
			<xs:extension base="s:ReadingType">
				<xs:sequence>
					<xs:choice>
						<xs:element name="author" type="s:NameType" minOccurs="0" maxOccurs="unbounded"/>
						<xs:element name="editor" type="s:NameType" minOccurs="0" maxOccurs="unbounded"/>
					</xs:choice>
					<xs:element name="title" type="xs:string" minOccurs="0"/>
					<xs:element name="websiteName" type="xs:string" minOccurs="0"/>
					<xs:element name="date" type="xs:string" minOccurs="0"/>
				</xs:sequence>
			</xs:extension>
		</xs:complexContent>
	</xs:complexType>
	<xs:complexType name="ResourceListType">
		<xs:annotation>
			<xs:documentation>Based on expert feedback, we decided that having an optionally empty resource wrapper class would be better for processing than having resource elements which might or might not be present. So here is that wrapper class.</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="resource" type="s:ResourceType" minOccurs="0" maxOccurs="unbounded"/>
		</xs:sequence>
	</xs:complexType>
	<xs:complexType name="AssignmentsType">
		<xs:annotation>
			<xs:documentation>A wrapper element for the syllabus assignments.</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="assignment" type="s:AssignmentType" maxOccurs="unbounded"/>
		</xs:sequence>
	</xs:complexType>
	<xs:complexType name="AssignmentType">
		<xs:annotation>
			<xs:documentation>All assignments have a title and either an assigned day of class, corresponding to one of the class numbers, or an assigned date, if it is assigned outside of the normal class schedule. When an assignedDayOfClass is used, the application automatically maps it to the appropriate calendar date based on the course ScheduleType, above. Similar handling is used for dueDayOfClass or dueDate. Optionall, teachers can include a dueTime. Assignment descriptions can be included in the syllabus or, if the assignment is long and/or complicated, teachers can create a seperate web page for the description and include just the link here. Similar handling is used for answers. Percentage indicates how much this assignment will count towards the final grade. Resources can optionally be included, and a required status enumeration tells the student if the assignment is graded, ungraded, or optional.</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="title" type="xs:string"/>
			<xs:element name="status" type="s:StatusType"/>
			<xs:choice>
				<xs:element name="assignedDate" type="xs:date"/>
				<xs:element name="assignedDayOfClass" type="xs:int"/>
			</xs:choice>
			<xs:choice>
				<xs:element name="dueDate" type="xs:date"/>
				<xs:element name="dueDayOfClass" type="xs:int"/>
			</xs:choice>
			<xs:element name="dueTime" type="xs:time" minOccurs="0"/>
			<xs:element name="description" type="s:htmlContent" minOccurs="0"/>
			<xs:element name="descriptionURL" type="xs:anyURI" minOccurs="0"/>
			<xs:element name="answers" type="s:htmlContent" minOccurs="0"/>
			<xs:element name="answersURL" type="xs:anyURI" minOccurs="0"/>
			<xs:element name="percentage" type="xs:integer" minOccurs="0"/>
			<xs:element name="resource" type="s:ResourceType" minOccurs="0" maxOccurs="unbounded"/>
		</xs:sequence>
	</xs:complexType>
	<xs:simpleType name="StatusType">
		<xs:annotation>
			<xs:documentation>An enumeration indicates the status of an assignment - see AssignmentType, above.</xs:documentation>
		</xs:annotation>
		<xs:restriction base="xs:string">
			<xs:enumeration value="Graded"/>
			<xs:enumeration value="Ungraded"/>
			<xs:enumeration value="Optional"/>
		</xs:restriction>
	</xs:simpleType>
	<xs:complexType name="ExamsType">
		<xs:annotation>
			<xs:documentation>Wrapper class for the exams in the syllabus.</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:element ref="s:exam" maxOccurs="unbounded"/>
		</xs:sequence>
	</xs:complexType>
	<xs:element name="exam" type="s:ExamType" abstract="true"/>
	<xs:complexType name="ExamType" abstract="true">
		<xs:annotation>
			<xs:documentation>Though we had originally assumed that take home exams would be modeled as assignments, our users expressed desire for a dedicated take home exam element. So we decided to use a substituion group. Both sorts of exams have a code (indicating type of exam), percentage of final grade, and comments. These general elements form the basis for the more specific exam types, below.</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="code" type="s:ExamCodeType"/>
			<xs:element name="percentage" type="xs:integer" minOccurs="0"/>
			<xs:element name="comment" type="s:htmlContent" minOccurs="0"/>
		</xs:sequence>
	</xs:complexType>
	<xs:simpleType name="ExamCodeType">
		<xs:annotation>
			<xs:documentation>See ExamType, above.</xs:documentation>
		</xs:annotation>
		<xs:restriction base="xs:string">
			<xs:enumeration value="Entrance"/>
			<xs:enumeration value="Placement"/>
			<xs:enumeration value="Quiz"/>
			<xs:enumeration value="Midterm"/>
			<xs:enumeration value="Final"/>
		</xs:restriction>
	</xs:simpleType>
	<xs:element name="takeHomeExam" type="s:TakeHomeExamType" substitutionGroup="s:exam"/>
	<xs:complexType name="TakeHomeExamType">
		<xs:annotation>
			<xs:documentation>Like assignments, a take home exam has a start and end date and can use day of class, corresponding to one of the class numbers, or an date, if it is happening outside of the normal class schedule. When a DayOfClass is used, the application automatically maps it to the appropriate calendar date based on the course ScheduleType, above.</xs:documentation>
		</xs:annotation>
		<xs:complexContent>
			<xs:extension base="s:ExamType">
				<xs:sequence>
					<xs:choice>
						<xs:element name="startDate" type="xs:date"/>
						<xs:element name="startDayOfClass" type="xs:int"/>
					</xs:choice>
					<xs:choice>
						<xs:element name="endDate" type="xs:date"/>
						<xs:element name="endDayOfClass" type="xs:int"/>
					</xs:choice>
					<xs:element name="dueTime" type="xs:time" minOccurs="0"/>
				</xs:sequence>
			</xs:extension>
		</xs:complexContent>
	</xs:complexType>
	<xs:element name="inClassExam" type="s:InClassExam" substitutionGroup="s:exam"/>
	<xs:complexType name="InClassExam">
		<xs:annotation>
			<xs:documentation>Much like assignments, an in class exam can have an exam day of class, corresponding to one of the class numbers, or an exam date, if it is happening outside of the normal class schedule. When an examDayOfClass is used, the application automatically maps it to the appropriate calendar date based on the course ScheduleType, above. Time span shows when the exam is (generally needed only with examDate, since examDayOfClass would presume the usual class meeting time). Location of the exam must be included.</xs:documentation>
		</xs:annotation>
		<xs:complexContent>
			<xs:extension base="s:ExamType">
				<xs:sequence>
					<xs:choice>
						<xs:element name="examDate" type="xs:date"/>
						<xs:element name="examDayOfClass" type="xs:int"/>
					</xs:choice>
					<xs:element name="timeSpan" type="s:TimeSpanType"/>
					<xs:element name="location" type="xs:string"/>
				</xs:sequence>
			</xs:extension>
		</xs:complexContent>
	</xs:complexType>
	<xs:complexType name="UpdateType">
		<xs:annotation>
			<xs:documentation>Some elements used to keep track of when the syllabus was last updated. We hope to maintain this information programmatically in the finished app.</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="updateDate" type="xs:date"/>
			<xs:element name="updateBy" type="xs:string"/>
			<xs:element name="comment" type="s:htmlContent" minOccurs="0"/>
		</xs:sequence>
	</xs:complexType>
	<xs:complexType name="htmlContent" mixed="true">
		<xs:annotation>
			<xs:documentation>Users often want to include basic HTML tags in description, comment, and similar elements. Substitution groups are used so the HTML tags can be nested arbitrarily. This htmlContent element contains any number of abstract htmlTag elements, which are substituted by the various HTMLType elements below.</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:element ref="s:htmlTag" minOccurs="0" maxOccurs="unbounded"/>
		</xs:sequence>
	</xs:complexType>
	<xs:element name="htmlTag" type="s:HTMLType" abstract="true">
		<xs:annotation>
			<xs:documentation>The abstract element which is the basis for our HTML substitution group, see htmlContent, above.</xs:documentation>
		</xs:annotation>
	</xs:element>
	<xs:complexType name="CSSType" mixed="true">
		<xs:annotation>
			<xs:documentation>To accommodate alternate transforms using proprietary CSS, some HTML tags allow for a class attribute.</xs:documentation>
		</xs:annotation>
		<xs:complexContent mixed="true">
			<xs:extension base="s:HTMLType">
				<xs:attribute name="class" type="xs:string"/>
			</xs:extension>
		</xs:complexContent>
	</xs:complexType>
	<xs:complexType name="HTMLType" mixed="true">
		<xs:annotation>
			<xs:documentation>These HTML tags can be combined and nested arbitrarily based on our HTML substitution group. See htmlContent, above.</xs:documentation>
		</xs:annotation>
		<xs:choice minOccurs="0" maxOccurs="unbounded">
			<xs:element ref="s:p"/>
			<xs:element ref="s:a"/>
			<xs:element ref="s:b"/>
			<xs:element ref="s:br"/>
			<xs:element ref="s:i"/>
			<xs:element ref="s:em"/>
			<xs:element ref="s:ul"/>
			<xs:element ref="s:ol"/>
			<xs:element ref="s:dl"/>
			<xs:element ref="s:div"/>
			<xs:element ref="s:span"/>
		</xs:choice>
	</xs:complexType>
	<xs:element name="p" type="s:CSSType" substitutionGroup="s:htmlTag"/>
	<xs:element name="a" type="s:linkType" substitutionGroup="s:htmlTag"/>
	<xs:element name="b" type="s:HTMLType" substitutionGroup="s:htmlTag"/>
	<xs:element name="br" type="s:HTMLType" substitutionGroup="s:htmlTag"/>
	<xs:element name="i" type="s:HTMLType" substitutionGroup="s:htmlTag"/>
	<xs:element name="em" type="s:HTMLType" substitutionGroup="s:htmlTag"/>
	<xs:element name="ul" type="s:listType" substitutionGroup="s:htmlTag"/>
	<xs:element name="ol" type="s:listType" substitutionGroup="s:htmlTag"/>
	<xs:element name="dl" type="s:listType" substitutionGroup="s:htmlTag"/>
	<xs:element name="li" type="s:HTMLType" substitutionGroup="s:htmlTag"/>
	<xs:element name="div" type="s:CSSType" substitutionGroup="s:htmlTag"/>
	<xs:element name="span" type="s:CSSType" substitutionGroup="s:htmlTag"/>
	<xs:complexType name="listType" mixed="true">
		<xs:annotation>
			<xs:documentation>The list elements (ul,ol,dl) can contain the li tags.</xs:documentation>
		</xs:annotation>
		<xs:complexContent mixed="true">
			<xs:extension base="s:HTMLType">
				<xs:sequence>
					<xs:element ref="s:li" maxOccurs="unbounded"/>
				</xs:sequence>
			</xs:extension>
		</xs:complexContent>
	</xs:complexType>
	<xs:complexType name="linkType" mixed="true">
		<xs:annotation>
			<xs:documentation>The HTML anchor tag is allowed its href attribute.</xs:documentation>
		</xs:annotation>
		<xs:complexContent mixed="true">
			<xs:extension base="s:HTMLType">
				<xs:attribute name="href" type="xs:anyURI"/>
			</xs:extension>
		</xs:complexContent>
	</xs:complexType>
</xs:schema>

