<?xml version="1.0" encoding="UTF-8"?>
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema" xmlns:r2ml="http://oxygen.informatik.tu-cottbus.de/R2ML/0.1/" xmlns:dc="http://purl.org/dc/elements/1.1/" targetNamespace="http://oxygen.informatik.tu-cottbus.de/R2ML/0.1/" elementFormDefault="qualified" attributeFormDefault="qualified" version="0.1" xml:lang="en">
	<!--

   R2ML - The REWERSE I1 Rule Markup Language. 
   
   URL: http://www.rewerse.net/I1
   
   The R2ML email address is:  I1.r2ml@googlemail.com

 Tested with W3C validator (XSV version: XSV 2.10-1 of 2005/04/22 13:10:49)  http://www.w3.org/2001/03/webdata/xsv 

<rdf:RDF  xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"   xmlns:dc="http://purl.org/dc/elements/1.1/">
   <rdf:Description rdf:about="R2ML XML schema">
      <dc:subject>The REWERSE I1 Rule Markup Language</dc:subject>
      <dc:creator>Adrian Giurca</dc:creator>
      <dc:contributor>Gerd Wagner</dc:contributor>
      <dc:contributor>Sergey Lukichev</dc:contributor>
      <dc:title>R2ML W3C XML Schema </dc:title>
      <dc:description>REWERSE I1 Rules Markup Language</dc:description> 
      <dc:type>text/xml</dc:type>
      <dc:source>R2ML.xsd</dc:source>
      <dc:date>2006-03-30</dc:date>
      <dc:rights>http://www.gnu.org/copyleft/lesser.html</dc:rights>
   </rdf:Description> 
</rdf:RDF>


$Rev: 919 $ $Date: 2006-04-10 17:11:43 +0200 (Mon, 10 Apr 2006) $ $Author: giurca $


R2ML.xsd - R2ML Rule markup Language W3C XML Schema 

Copyright (C)  2006  Adrian Giurca, Gerd Wagner and Sergey Lukichev.

This is a 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 2.1 of the License, or (at your option) any later version.

 This schema 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 a copy of the GNU Lesser General Public License along with R2ML schema; if not go to http://www.gnu.org/copyleft/lesser.html  
 or write to the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA

Standard root element
<r2ml:RuleBase xmlns:r2ml="http://www.rewerse.net/I1/R2ML/0.1/" xmlns:dc="http://purl.org/dc/elements/1.1/" 
						  xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
						  xsi:schemaLocation="http://www.rewerse.net/I1/R2ML/0.1/  http://www.rewerse.net/I1/R2ML/0.1/r2ml.xsd">
-->
	<!-- 

Dublin Core namespace  used in annotations

-->
	<xs:import namespace="http://purl.org/dc/elements/1.1/" schemaLocation="http://dublincore.org/schemas/xmls/qdc/2006/01/06/dc.xsd"/>
	<!-- 

Elements for annotations 

-->
	<xs:element name="Documentation" type="r2ml:Documentation" abstract="false"/>
	<xs:element name="SourceCode" type="r2ml:SourceCode" abstract="false"/>
	<xs:element name="RuleText" type="r2ml:RuleText" abstract="false"/>
	<!-- 

Elements for rule sets 

-->
	<xs:element name="RuleBase" type="r2ml:RuleBase" abstract="false"/>
	<xs:element name="RuleSet" type="r2ml:RuleSet" abstract="true"/>
	<xs:element name="DerivationRuleSet" type="r2ml:DerivationRuleSet" abstract="false" substitutionGroup="r2ml:RuleSet"/>
	<xs:element name="IntegrityRuleSet" type="r2ml:IntegrityRuleSet" abstract="false" substitutionGroup="r2ml:RuleSet"/>
	<xs:element name="ProductionRuleSet" type="r2ml:ProductionRuleSet" abstract="false" substitutionGroup="r2ml:RuleSet"/>
	<xs:element name="ReactionRuleSet" type="r2ml:ReactionRuleSet" abstract="false" substitutionGroup="r2ml:RuleSet"/>
	<!-- 

Elements for rules 

-->
	<xs:element name="Rule" type="r2ml:Rule" abstract="true"/>
	<xs:element name="IntegrityRule" type="r2ml:IntegrityRule" abstract="true" substitutionGroup="r2ml:Rule"/>
	<xs:element name="AlethicIntegrityRule" type="r2ml:AlethicIntegrityRule" abstract="false" substitutionGroup="r2ml:IntegrityRule"/>
	<xs:element name="DeonticIntegrityRule" type="r2ml:DeonticIntegrityRule" abstract="false" substitutionGroup="r2ml:IntegrityRule"/>
	<xs:element name="DerivationRule" type="r2ml:DerivationRule" abstract="false" substitutionGroup="r2ml:Rule"/>
	<xs:element name="ProductionRule" type="r2ml:ProductionRule" abstract="false" substitutionGroup="r2ml:Rule"/>
	<!-- 

Elements  for formulas 

-->
	<xs:element name="LogicalFormula" type="r2ml:LogicalFormula" abstract="true"/>
	<xs:element name="Implication" type="r2ml:Implication" abstract="false" substitutionGroup="r2ml:LogicalFormula"/>
	<xs:element name="Conjunction" type="r2ml:Conjunction" abstract="false" substitutionGroup="r2ml:LogicalFormula"/>
	<xs:element name="Disjunction" type="r2ml:Disjunction" abstract="false" substitutionGroup="r2ml:LogicalFormula"/>
	<xs:element name="Negation" type="r2ml:Negation" abstract="true" substitutionGroup="r2ml:LogicalFormula"/>
	<xs:element name="StrongNegation" type="r2ml:StrongNegation" abstract="false" substitutionGroup="r2ml:Negation"/>
	<xs:element name="WeakNegation" type="r2ml:WeakNegation" abstract="false" substitutionGroup="r2ml:Negation"/>
	<xs:element name="QuantifiedFormula" type="r2ml:QuantifiedFormula" abstract="true" substitutionGroup="r2ml:LogicalFormula"/>
	<xs:element name="UniversallyQuantifiedFormula" type="r2ml:UniversallyQuantifiedFormula" abstract="false" substitutionGroup="r2ml:QuantifiedFormula"/>
	<xs:element name="ExistentiallyQuantifiedFormula" type="r2ml:ExistentiallyQuantifiedFormula" abstract="false" substitutionGroup="r2ml:QuantifiedFormula"/>
	<!-- 

Elements for quantifier free formulas

-->
	<xs:element name="qf.LiteralConjunction" type="r2ml:qf.LiteralConjunction" abstract="false" substitutionGroup="r2ml:qf.DNF"/>
	<xs:element name="qf.Conjunction" type="r2ml:qf.Conjunction" abstract="false" substitutionGroup="r2ml:qf.AndOrNafNegFormula"/>
	<xs:element name="qf.Disjunction" type="r2ml:qf.Disjunction" abstract="false" substitutionGroup="r2ml:qf.AndOrNafNegFormula"/>
	<xs:element name="qf.StrongNegation" type="r2ml:qf.StrongNegation" abstract="false" substitutionGroup="r2ml:qf.AndOrNafNegFormula"/>
	<xs:element name="qf.WeakNegation" type="r2ml:qf.WeakNegation" abstract="false" substitutionGroup="r2ml:qf.AndOrNafNegFormula"/>

<!--

Elements for core atoms 

-->
	<xs:element name="Atom" type="r2ml:Atom" abstract="true" substitutionGroup="r2ml:qf.AndOrNafNegFormula"/>
	<xs:element name="GenericAtom" type="r2ml:GenericAtom" abstract="false" substitutionGroup="r2ml:Atom"/>
	<xs:element name="DataAtom" abstract="true" substitutionGroup="r2ml:Atom"/>
	<xs:element name="ObjectAtom" abstract="true" substitutionGroup="r2ml:Atom"/>
	<!-- 

Elements for R2ML basic atoms

-->
	<xs:element name="ObjectClassificationAtom" type="r2ml:ObjectClassificationAtom" substitutionGroup="r2ml:ObjectAtom"/>
	<xs:element name="EqualityAtom" type="r2ml:EqualityAtom" substitutionGroup="r2ml:ObjectAtom"/>
	<xs:element name="InequalityAtom" type="r2ml:InequalityAtom" substitutionGroup="r2ml:ObjectAtom"/>
	<xs:element name="DataPredicateAtom" type="r2ml:DataPredicateAtom" substitutionGroup="r2ml:DataAtom"/>
	<!-- 

Elements for R2ML relational atoms

-->
	<xs:element name="AttributionAtom" type="r2ml:AttributionAtom" substitutionGroup="r2ml:ObjectAtom"/>
	<xs:element name="ObjectDescriptionAtom" type="r2ml:ObjectDescriptionAtom" substitutionGroup="r2ml:ObjectAtom"/>
	<xs:element name="AssociationAtom" type="r2ml:AssociationAtom" substitutionGroup="r2ml:ObjectAtom"/>
	<xs:element name="ReferencePropertyAtom" type="r2ml:ReferencePropertyAtom" substitutionGroup="r2ml:ObjectAtom"/>
	<xs:element name="DataClassificationAtom" type="r2ml:DataClassificationAtom" substitutionGroup="r2ml:DataAtom"/>
	<!--

Elements for constructing slots 

-->
	<xs:element name="Slot" type="r2ml:Slot" abstract="true" substitutionGroup="r2ml:FunctionTerm"/>
	<xs:element name="ObjectSlot" type="r2ml:ObjectSlot" abstract="false" substitutionGroup="r2ml:Slot"/>
	<xs:element name="DataSlot" type="r2ml:DataSlot" abstract="false" substitutionGroup="r2ml:Slot"/>
	<!-- 

Elements for constructing terms 

-->
	<xs:element name="Term" type="r2ml:Term" abstract="true"/>
	<xs:element name="ObjectTerm" type="r2ml:ObjectTerm" abstract="true" substitutionGroup="r2ml:Term"/>
	<xs:element name="DataTerm" type="r2ml:DataTerm" abstract="true" substitutionGroup="r2ml:Term"/>
	<!-- 

Elements for constructing basic terms 

-->
	<xs:element name="Variable" type="r2ml:Variable" abstract="false" substitutionGroup="r2ml:Term"/>
	<xs:element name="IndividualConstant" type="r2ml:IndividualConstant" abstract="false" substitutionGroup="r2ml:Term"/>
	<xs:element name="ObjectVariable" type="r2ml:ObjectVariable" abstract="false" substitutionGroup="r2ml:ObjectTerm"/>
	<xs:element name="ObjectName" type="r2ml:ObjectName" abstract="false" substitutionGroup="r2ml:ObjectTerm"/>
	<xs:element name="DataVariable" type="r2ml:DataVariable" abstract="false" substitutionGroup="r2ml:DataTerm"/>
	<xs:element name="TypedLiteral" type="r2ml:TypedLiteral" abstract="false" substitutionGroup="r2ml:DataTerm"/>
	<xs:element name="PlainLiteral" type="r2ml:PlainLiteral" abstract="false" substitutionGroup="r2ml:DataTerm"/>
	<!--

 Elements for constructing functional terms 

-->
	<xs:element name="FunctionTerm" type="r2ml:FunctionTerm" abstract="false" substitutionGroup="r2ml:Term"/>
	<xs:element name="ObjectOperationTerm" type="r2ml:ObjectOperationTerm" abstract="false" substitutionGroup="r2ml:ObjectTerm"/>
	<xs:element name="RoleFunctionTerm" type="r2ml:RoleFunctionTerm" abstract="false" substitutionGroup="r2ml:ObjectTerm"/>
	<xs:element name="DataOperationTerm" type="r2ml:DataOperationTerm" abstract="false" substitutionGroup="r2ml:DataFunctionTerm"/>
	<xs:element name="AttributeFunctionTerm" type="r2ml:AttributeFunctionTerm" abstract="false" substitutionGroup="r2ml:DataFunctionTerm"/>
	<xs:element name="DatatypeFunctionTerm" type="r2ml:DatatypeFunctionTerm" abstract="false" substitutionGroup="r2ml:DataFunctionTerm"/>
	<!--

Elements  for actions 

-->
	<xs:element name="SOAPRPCAction" type="r2ml:SOAPRPCAction" abstract="false" substitutionGroup="r2ml:SOAPAction"/>
	<xs:element name="SOAPAction" type="r2ml:SOAPAction" abstract="false" substitutionGroup="r2ml:MessageActionExpression"/>
	<xs:element name="MessageActionExpression" type="r2ml:MessageActionExpression" abstract="true" substitutionGroup="r2ml:ActionExpression"/>
	<xs:element name="InvokeActionExpression" type="r2ml:InvokeActionExpression" abstract="false" substitutionGroup="r2ml:ActionExpression"/>
	<xs:element name="AssignActionExpression" type="r2ml:AssignActionExpression" abstract="false" substitutionGroup="r2ml:ActionExpression"/>
	<xs:element name="CreateActionExpression" type="r2ml:CreateActionExpression" abstract="false" substitutionGroup="r2ml:ActionExpression"/>
	<xs:element name="DeleteActionExpression" type="r2ml:DeleteActionExpression" abstract="false" substitutionGroup="r2ml:ActionExpression"/>
	<!-- 

Elements for events 

-->
	<xs:element name="SOAPMessage" type="r2ml:SOAPMessage" abstract="false" substitutionGroup="r2ml:MessageEventExpression"/>
	<xs:element name="MessageEventExpression" type="r2ml:MessageEventExpression" abstract="false" substitutionGroup="r2ml:AtomicEventExpression"/>
	<xs:element name="AtomicEventExpression" type="r2ml:AtomicEventExpression" abstract="false" substitutionGroup="r2ml:EventExpression"/>
	<xs:element name="AndNotEventExpression" type="r2ml:AndNotEventExpression" abstract="false" substitutionGroup="r2ml:EventExpression"/>
	<xs:element name="SequenceEventExpression" type="r2ml:SequenceEventExpression" abstract="false" substitutionGroup="r2ml:EventExpression"/>
	<xs:element name="ParallelEventExpression" type="r2ml:ParallelEventExpression" abstract="false" substitutionGroup="r2ml:EventExpression"/>
	<xs:element name="ChoiceEventExpression" type="r2ml:ChoiceEventExpression" abstract="false" substitutionGroup="r2ml:EventExpression"/>
	<xs:element name="EventExpression" type="r2ml:EventExpression" abstract="true"/>
	<!-- 

Elements for roles 

-->
	<xs:element name="constraint" type="r2ml:constraint" abstract="false"/>
	<xs:element name="conditions" type="r2ml:condition" abstract="false"/>
	<xs:element name="conclusion" type="r2ml:conclusion"/>
	<xs:element name="postcondition" type="r2ml:postcondition" abstract="false"/>
	<xs:element name="producedAction" type="r2ml:producedAction" abstract="false"/>
	<xs:element name="triggeringEvent" type="r2ml:triggeringEvent" abstract="false"/>
	<xs:element name="subject" type="r2ml:subject" abstract="false"/>
	<xs:element name="object" type="r2ml:object" abstract="false"/>
	<xs:element name="value" type="r2ml:value" abstract="false"/>
	<xs:element name="arguments" type="r2ml:arguments" abstract="false"/>
	<xs:element name="dataArguments" type="r2ml:dataArguments" abstract="false"/>
	<xs:element name="objectArgument" type="r2ml:objectArguments" abstract="false"/>
	<xs:element name="contextArgument" type="r2ml:contextArgument" abstract="false"/>
	<!--
Rule Base. Capture a collection of rules. The collection contains derivation rules in a form of a DerivationRuleSet, 
production rules in a form of a ProductionRuleSet or reaction rules in a form of ReactionRulesSet.
Any rule base may have an ID for unique identification.
 -->
	<xs:complexType name="RuleBase" abstract="false">
		<xs:sequence>
		    <xs:choice minOccurs="0" maxOccurs="unbounded">
		    <xs:element ref="r2ml:Variable" minOccurs="0" maxOccurs="unbounded"/>
			 <xs:element ref="r2ml:ObjectVariable"  minOccurs="0" maxOccurs="unbounded"/>
			 <xs:element ref="r2ml:DataVariable"  minOccurs="0" maxOccurs="unbounded"/>
			</xs:choice>
			<xs:element name="Vocabulary" type="r2ml:Vocabulary" minOccurs="0" maxOccurs="unbounded"/>
			<xs:element ref="r2ml:RuleSet" maxOccurs="unbounded"/>
		</xs:sequence>
	</xs:complexType>
	<xs:complexType name="RuleSet" abstract="true">
		<xs:sequence>
			<xs:element name="Vocabulary" type="r2ml:Vocabulary" minOccurs="0" maxOccurs="unbounded"/>
			<xs:choice>
				<xs:element name="IntegrityRuleSet" type="r2ml:IntegrityRuleSet" minOccurs="0"/>
				<xs:element name="DerivationRuleSet" type="r2ml:DerivationRuleSet" minOccurs="0"/>
				<xs:element name="ProductionRuleSet" type="r2ml:ProductionRuleSet" minOccurs="0"/>
				<xs:element name="ReactionRuleSet" type="r2ml:ReactionRuleSet" minOccurs="0"/>
			</xs:choice>
		</xs:sequence>
		<xs:attribute ref="r2ml:id" use="optional"/>
	</xs:complexType>
	<!--

   IntegrityRuleSet. This element is designed  to capture a set of integrity rules (integrity constraints). Each rule set  it is identified by its unique ID

-->
	<xs:complexType name="IntegrityRuleSet" abstract="false">
		<xs:complexContent>
			<xs:extension base="r2ml:RuleSet">
				<xs:sequence>
					<xs:element ref="r2ml:IntegrityRule" maxOccurs="unbounded"/>
				</xs:sequence>
			</xs:extension>
		</xs:complexContent>
	</xs:complexType>
	<!--

 DerivationRuleSet. This element is designed  to capture a set of derivation rules. Each rule set  it is identified by its unique ID

-->
	<xs:complexType name="DerivationRuleSet" abstract="false">
		<xs:complexContent>
			<xs:extension base="r2ml:RuleSet">
				<xs:sequence>
					<xs:element name="DerivationRule" type="r2ml:DerivationRule" maxOccurs="unbounded"/>
				</xs:sequence>
			</xs:extension>
		</xs:complexContent>
	</xs:complexType>
	<!--

 ProductionRuleSet. This element is designed  to capture a set of production rules. Each rule set it is identified by its unique ID
 
-->
	<xs:complexType name="ProductionRuleSet" abstract="false">
		<xs:complexContent>
			<xs:extension base="r2ml:RuleSet">
				<xs:sequence>
					<xs:element name="ProductionRule" type="r2ml:ProductionRule" maxOccurs="unbounded"/>
				</xs:sequence>
			</xs:extension>
		</xs:complexContent>
	</xs:complexType>
	<!--

 ReactionRuleSet. This element is designed  to capture a set of reaction rules. Each rule set it is identified by its unique ID

 -->
	<xs:complexType name="ReactionRuleSet" abstract="false">
		<xs:complexContent>
			<xs:extension base="r2ml:RuleSet">
				<xs:sequence>
					<xs:element name="ReactionRule" type="r2ml:ReactionRule" maxOccurs="unbounded"/>
				</xs:sequence>
			</xs:extension>
		</xs:complexContent>
	</xs:complexType>
	<!-- 

The abstract concept of rule 

-->
	<xs:complexType name="Rule" abstract="true">
		<xs:sequence>
			<xs:element ref="r2ml:Documentation" minOccurs="0"/>
		</xs:sequence>
	</xs:complexType>
	<!-- 

R2ML types for rule annotations 

-->
	<xs:complexType name="Documentation" abstract="false">
		<xs:choice minOccurs="0" maxOccurs="unbounded">
			<xs:element ref="r2ml:RuleText" minOccurs="0" maxOccurs="unbounded"/>
			<xs:element ref="r2ml:SourceCode" minOccurs="0" maxOccurs="unbounded"/>
			<xs:element ref="dc:subject" minOccurs="0" maxOccurs="unbounded"/>
			<xs:element ref="dc:creator" minOccurs="0" maxOccurs="unbounded"/>
			<xs:element ref="dc:contributor" minOccurs="0" maxOccurs="unbounded"/>
			<xs:element ref="dc:title" minOccurs="0" maxOccurs="unbounded"/>
			<xs:element ref="dc:description" minOccurs="0" maxOccurs="unbounded"/>
			<xs:element ref="dc:source" minOccurs="0" maxOccurs="unbounded"/>
			<xs:element ref="dc:type" minOccurs="0" maxOccurs="unbounded"/>
			<xs:element ref="dc:date" minOccurs="0" maxOccurs="unbounded"/>
		</xs:choice>
	</xs:complexType>
	<!-- R2ML RuleText element -->
	<xs:complexType name="RuleText">
		<xs:simpleContent>
			<xs:extension base="xs:string">
				<xs:attribute name="textFormat" type="xs:string" use="optional"/>
				<xs:attribute name="ruleVocabularyDiagram" type="xs:anyURI" use="optional"/>
				<xs:attribute name="ruleDiagram" type="xs:anyURI" use="optional"/>
			</xs:extension>
		</xs:simpleContent>
	</xs:complexType>
	<!-- R2ML SourceCode element -->
	<xs:complexType name="SourceCode">
		<xs:simpleContent>
			<xs:extension base="xs:string">
				<xs:attribute name="language" type="xs:normalizedString" use="optional"/>
			</xs:extension>
		</xs:simpleContent>
	</xs:complexType>
	<!--

R2ML  Rules  definitions

 
Integrity Rules 
-->
	<!-- Abstract Integrity Rule -->
	<xs:complexType name="IntegrityRule" abstract="true">
		<xs:complexContent>
			<xs:extension base="r2ml:Rule">
				<xs:sequence>
					<xs:element ref="r2ml:constraint"/>
				</xs:sequence>
				<xs:attribute ref="r2ml:id" use="optional"/>
			</xs:extension>
		</xs:complexContent>
	</xs:complexType>
	<!-- Alethic Integrity Rule -->
	<xs:complexType name="AlethicIntegrityRule" abstract="false">
		<xs:complexContent>
			<xs:extension base="r2ml:IntegrityRule"/>
		</xs:complexContent>
	</xs:complexType>
	<!-- Deontic Integrity Rule -->
	<xs:complexType name="DeonticIntegrityRule" abstract="false">
		<xs:complexContent>
			<xs:extension base="r2ml:IntegrityRule"/>
		</xs:complexContent>
	</xs:complexType>
	<!-- 

Derivation Rule 

-->
	<xs:complexType name="DerivationRule" abstract="false">
		<xs:complexContent>
			<xs:extension base="r2ml:Rule">
				<xs:sequence>
					<xs:element ref="r2ml:conditions"/>
					<xs:element ref="r2ml:conclusion"/>
				</xs:sequence>
				<xs:attribute ref="r2ml:id" use="optional"/>
			</xs:extension>
		</xs:complexContent>
	</xs:complexType>
	<!-- 

Production Rule

-->
	<xs:complexType name="ProductionRule" abstract="false">
		<xs:complexContent>
			<xs:extension base="r2ml:Rule">
				<xs:sequence>
					<xs:element name="conditions" type="r2ml:condition"/>
					<xs:choice>
						<xs:element ref="r2ml:postcondition" minOccurs="0"/>
						<xs:element ref="r2ml:producedAction"/>
					</xs:choice>
				</xs:sequence>
				<xs:attribute ref="r2ml:id" use="optional"/>
			</xs:extension>
		</xs:complexContent>
	</xs:complexType>
	<!-- 

Reaction Rule

-->
	<xs:element name="ReactionRule" type="r2ml:ReactionRule" abstract="false" substitutionGroup="r2ml:Rule"/>
	<xs:complexType name="ReactionRule" abstract="false">
		<xs:complexContent>
			<xs:extension base="r2ml:Rule">
				<xs:sequence>
					<xs:element ref="r2ml:triggeringEvent"/>
					<xs:element ref="r2ml:conditions" minOccurs="0"/>
					<xs:element ref="r2ml:producedAction"/>
					<xs:element ref="r2ml:postcondition" minOccurs="0"/>
				</xs:sequence>
				<xs:attribute ref="r2ml:id" use="optional"/>
			</xs:extension>
		</xs:complexContent>
	</xs:complexType>
	<!--

R2ML formulas 

-->
	<!-- LogicalFormula  -->
	<xs:complexType name="LogicalFormula" abstract="true"/>
	<!-- Implication -->
	<xs:complexType name="Implication" abstract="false">
		<xs:complexContent>
			<xs:extension base="r2ml:LogicalFormula">
				<xs:sequence>
					<xs:element ref="r2ml:LogicalFormula" minOccurs="2" maxOccurs="2"/>
				</xs:sequence>
			</xs:extension>
		</xs:complexContent>
	</xs:complexType>
	<!-- Conjunction -->
	<xs:complexType name="Conjunction" abstract="false">
		<xs:complexContent>
			<xs:extension base="r2ml:LogicalFormula">
				<xs:sequence>
					<xs:element ref="r2ml:LogicalFormula" minOccurs="2" maxOccurs="unbounded"/>
				</xs:sequence>
			</xs:extension>
		</xs:complexContent>
	</xs:complexType>
	<!-- Disjunction -->
	<xs:complexType name="Disjunction" abstract="false">
		<xs:complexContent>
			<xs:extension base="r2ml:LogicalFormula">
				<xs:sequence>
					<xs:element ref="r2ml:LogicalFormula" minOccurs="2" maxOccurs="unbounded"/>
				</xs:sequence>
			</xs:extension>
		</xs:complexContent>
	</xs:complexType>
	<!-- negation-->
	<xs:complexType name="Negation" abstract="true">
		<xs:complexContent>
			<xs:extension base="r2ml:LogicalFormula"/>
		</xs:complexContent>
	</xs:complexType>
	<!-- Strong (explicit) negation -->
	<xs:complexType name="StrongNegation" abstract="false">
		<xs:complexContent>
			<xs:extension base="r2ml:Negation">
				<xs:sequence>
					<xs:element ref="r2ml:Atom"/>
				</xs:sequence>
			</xs:extension>
		</xs:complexContent>
	</xs:complexType>
	<!-- Weak negation or WeakNegation -->
	<xs:complexType name="WeakNegation" abstract="false">
		<xs:complexContent>
			<xs:extension base="r2ml:Negation">
				<xs:sequence>
					<xs:element ref="r2ml:Atom"/>
				</xs:sequence>
			</xs:extension>
		</xs:complexContent>
	</xs:complexType>
	<!-- QuantifiedFormula -->
	<xs:complexType name="QuantifiedFormula" abstract="true">
		<xs:complexContent>
			<xs:extension base="r2ml:LogicalFormula">
				<xs:sequence>
					<xs:choice minOccurs="0" maxOccurs="unbounded">
					<xs:element ref="r2ml:Variable" minOccurs="0" maxOccurs="unbounded"/>
					 <xs:element ref="r2ml:ObjectVariable" minOccurs="0" maxOccurs="unbounded"/>
					 <xs:element ref="r2ml:DataVariable"  minOccurs="0" maxOccurs="unbounded"/>
				</xs:choice>
				</xs:sequence>
			</xs:extension>
		</xs:complexContent>
	</xs:complexType>
	<!-- UniversallyQuantifiedFormula -->
	<xs:complexType name="UniversallyQuantifiedFormula" abstract="false">
		<xs:complexContent>
			<xs:extension base="r2ml:QuantifiedFormula">
				<xs:sequence>
					<xs:element ref="r2ml:LogicalFormula"/>
				</xs:sequence>
			</xs:extension>
		</xs:complexContent>
	</xs:complexType>
	<!-- ExistentiallyQuantifiedFormula -->
	<xs:complexType name="ExistentiallyQuantifiedFormula" abstract="false">
		<xs:complexContent>
			<xs:extension base="r2ml:QuantifiedFormula"/>
		</xs:complexContent>
	</xs:complexType>
	
	<!-- R2Ml quantifier free formulas -->
	<!-- DNF -->
	<xs:element name="qf.DNF" type="r2ml:qf.DNF" abstract="true"/>
	<xs:complexType name="qf.DNF" abstract="true"/>
	<!-- LiteralConjunction -->
	<xs:complexType name="qf.LiteralConjunction" abstract="false">
		<xs:complexContent>
			<xs:extension base="r2ml:qf.DNF">
				<xs:sequence>
					<xs:element ref="r2ml:Atom" maxOccurs="unbounded"/>
				</xs:sequence>
			</xs:extension>
		</xs:complexContent>
	</xs:complexType>
	<!-- AndOrNafNegFormula  (quantifier free) -->
	<xs:element name="qf.AndOrNafNegFormula" type="r2ml:qf.AndOrNafNegFormula" abstract="true" substitutionGroup="r2ml:LogicalFormula"/>
	<xs:complexType name="qf.AndOrNafNegFormula" abstract="true">
		<xs:complexContent>
			<xs:restriction base="r2ml:LogicalFormula"/>
		</xs:complexContent>
	</xs:complexType>
	<!-- Conjunction (quantifier free)-->
	<xs:complexType name="qf.Conjunction" abstract="false">
		<xs:complexContent>
			<xs:extension base="r2ml:qf.AndOrNafNegFormula">
				<xs:sequence>
					<xs:element ref="r2ml:qf.AndOrNafNegFormula" minOccurs="2" maxOccurs="unbounded"/>
				</xs:sequence>
			</xs:extension>
		</xs:complexContent>
	</xs:complexType>
	<!-- Disjunction (quantifier free)-->
	<xs:complexType name="qf.Disjunction" abstract="false">
		<xs:complexContent>
			<xs:extension base="r2ml:qf.AndOrNafNegFormula">
				<xs:sequence>
					<xs:element ref="r2ml:qf.AndOrNafNegFormula" minOccurs="2" maxOccurs="unbounded"/>
				</xs:sequence>
			</xs:extension>
		</xs:complexContent>
	</xs:complexType>
	<!-- negation (quantifier free)-->
	<xs:complexType name="qf.Negation" abstract="true">
		<xs:complexContent>
			<xs:extension base="r2ml:qf.AndOrNafNegFormula"/>
		</xs:complexContent>
	</xs:complexType>
	<!-- strong (explicit) negation (quantifier free)-->
	<xs:complexType name="qf.StrongNegation" abstract="false">
		<xs:complexContent>
			<xs:extension base="r2ml:qf.Negation">
				<xs:sequence>
					<xs:element ref="r2ml:Atom"/>
				</xs:sequence>
			</xs:extension>
		</xs:complexContent>
	</xs:complexType>
	<!-- weak negation or WeakNegation (quantifier free)-->
	<xs:complexType name="qf.WeakNegation" abstract="false">
		<xs:complexContent>
			<xs:extension base="r2ml:qf.Negation">
				<xs:sequence>
					<xs:element ref="r2ml:Atom"/>
				</xs:sequence>
			</xs:extension>
		</xs:complexContent>
	</xs:complexType>
	<!-- 

R2ML ATOMS 

-->
	<!-- 

R2ML core atoms 

-->
	<!-- Abstract Atom -->
	<xs:complexType name="Atom" abstract="true">
		<xs:complexContent>
			<xs:extension base="r2ml:qf.AndOrNafNegFormula">
				<xs:attribute ref="r2ml:isNegated" use="optional"/>
			</xs:extension>
		</xs:complexContent>
	</xs:complexType>
	<!-- DataAtom and ObjectAtom -->
	<xs:complexType name="DataAtom" abstract="true">
		<xs:complexContent>
			<xs:extension base="r2ml:Atom"/>
		</xs:complexContent>
	</xs:complexType>
	<xs:complexType name="ObjectAtom" abstract="true">
		<xs:complexContent>
			<xs:extension base="r2ml:Atom"/>
		</xs:complexContent>
	</xs:complexType>
	<!-- generic Atom -->
	<xs:complexType name="GenericAtom">
		<xs:complexContent>
			<xs:extension base="r2ml:Atom">
				<xs:sequence>
					<xs:element ref="r2ml:arguments"/>
				</xs:sequence>
				<xs:attribute name="predicateID" type="xs:anyURI" use="required"/>
				<xs:attribute name="predicatTypeID" type="r2ml:PredicateType" use="optional"/>
			</xs:extension>
		</xs:complexContent>
	</xs:complexType>
	<!-- 

R2ML basic atoms 

-->
	<!--Data atoms -->
	<!-- DataPredicateAtom -->
	<xs:complexType name="DataPredicateAtom" abstract="false">
		<xs:complexContent>
			<xs:extension base="r2ml:DataAtom">
				<xs:sequence>
					<xs:element ref="r2ml:dataArguments"/>
				</xs:sequence>
				<xs:attribute ref="r2ml:dataPredicateID" use="required"/>
			</xs:extension>
		</xs:complexContent>
	</xs:complexType>
	<!-- Object Atoms -->
	<!-- ObjectClassificationAtom - An object classification atom  refers to a class and consists of an object term.  -->
	<xs:complexType name="ObjectClassificationAtom" abstract="false">
		<xs:complexContent>
			<xs:extension base="r2ml:ObjectAtom">
				<xs:sequence>
					<xs:element ref="r2ml:ObjectTerm"/>
				</xs:sequence>
				<xs:attribute ref="r2ml:classID" use="required"/>
			</xs:extension>
		</xs:complexContent>
	</xs:complexType>
	<!-- Equality Atom -->
	<xs:complexType name="EqualityAtom" abstract="false">
		<xs:complexContent>
			<xs:extension base="r2ml:ObjectAtom">
				<xs:sequence>
					<xs:element ref="r2ml:ObjectTerm" minOccurs="2" maxOccurs="2"/>
				</xs:sequence>
			</xs:extension>
		</xs:complexContent>
	</xs:complexType>
	<!-- Inequality Atom -->
	<xs:complexType name="InequalityAtom" abstract="false">
		<xs:complexContent>
			<xs:extension base="r2ml:ObjectAtom">
				<xs:sequence>
					<xs:element ref="r2ml:ObjectTerm" minOccurs="2" maxOccurs="2"/>
				</xs:sequence>
			</xs:extension>
		</xs:complexContent>
	</xs:complexType>
	<!-- 

R2ML relational atoms 

-->
	<!--Data atoms -->
	<!-- Data classification atom -->
	<xs:complexType name="DataClassificationAtom" abstract="false">
		<xs:complexContent>
			<xs:extension base="r2ml:DataAtom">
				<xs:sequence>
					<xs:element ref="r2ml:DataTerm" maxOccurs="2"/>
				</xs:sequence>
				<xs:attribute ref="r2ml:dataTypeID" use="required"/>
			</xs:extension>
		</xs:complexContent>
	</xs:complexType>
	<!--  Object Atoms -->
	<!-- ObjectDescriptionAtom - An object description atom refers to a class as a base type and to zero or more classes as categories, and consists of a number of slots 
(object slots and data slots). Any instance of such atom refers to one particular object (the context argument).-->
	<xs:complexType name="ObjectDescriptionAtom" abstract="false">
		<xs:complexContent>
			<xs:extension base="r2ml:ObjectAtom">
				<xs:sequence>
					<xs:element name="subject" type="r2ml:subject"/>
					<xs:element ref="r2ml:ObjectSlot" minOccurs="0" maxOccurs="unbounded"/>
					<xs:element ref="r2ml:DataSlot" minOccurs="0" maxOccurs="unbounded"/>
				</xs:sequence>
				<xs:attribute ref="r2ml:baseTypeID" use="required"/>
				<xs:attribute ref="r2ml:classID" use="required"/>
			</xs:extension>
		</xs:complexContent>
	</xs:complexType>
	<!-- Attribution Atom - An attribution atom has a reference to an attribute and consists of an object term as ”subject”, and a data term as ”value”.-->
	<xs:complexType name="AttributionAtom" abstract="false">
		<xs:complexContent>
			<xs:extension base="r2ml:ObjectAtom">
				<xs:sequence>
					<xs:element name="subject" type="r2ml:subject"/>
					<xs:element name="value" type="r2ml:value"/>
				</xs:sequence>
				<xs:attribute ref="r2ml:attributeID" use="required"/>
			</xs:extension>
		</xs:complexContent>
	</xs:complexType>
	<!-- Asociation Atom  - An association atom  is constructed using an nary predicate as association predicate, a collection of data terms as ”data arguments” and a 
collection of object terms as ”object arguments”.-->
	<xs:complexType name="AssociationAtom" abstract="false">
		<xs:complexContent>
			<xs:extension base="r2ml:ObjectAtom">
				<xs:sequence>
					<xs:element name="dataArguments" type="r2ml:dataArguments" minOccurs="0"/>
					<xs:element name="objectArguments" type="r2ml:objectArguments"/>
				</xs:sequence>
				<xs:attribute ref="r2ml:associationPredicateID" use="required"/>
			</xs:extension>
		</xs:complexContent>
	</xs:complexType>
	<!-- ReferencePropertyAtom -->
	<xs:complexType name="ReferencePropertyAtom" abstract="false">
		<xs:complexContent>
			<xs:extension base="r2ml:ObjectAtom">
				<xs:sequence>
					<xs:element ref="r2ml:subject"/>
					<xs:element name="object" type="r2ml:object"/>
				</xs:sequence>
				<xs:attribute ref="r2ml:refPropertyID" use="required"/>
			</xs:extension>
		</xs:complexContent>
	</xs:complexType>
	<!-- R2ML Slots -->
	<!-- The abstract concept of  slot -->
	<xs:complexType name="Slot" abstract="true">
		<xs:complexContent>
			<xs:extension base="r2ml:FunctionTerm"/>
		</xs:complexContent>
	</xs:complexType>
	<!-- Object slot -->
	<xs:complexType name="ObjectSlot" abstract="false">
		<xs:complexContent>
			<xs:extension base="r2ml:Slot">
				<xs:sequence>
					<xs:element name="object" type="r2ml:object"/>
				</xs:sequence>
				<xs:attribute ref="r2ml:refPropertyID" use="required"/>
			</xs:extension>
		</xs:complexContent>
	</xs:complexType>
	<!-- data slot -->
	<xs:complexType name="DataSlot">
		<xs:complexContent>
			<xs:extension base="r2ml:Slot">
				<xs:sequence>
					<xs:element name="value" type="r2ml:value"/>
				</xs:sequence>
				<xs:attribute ref="r2ml:attributeID" use="required"/>
			</xs:extension>
		</xs:complexContent>
	</xs:complexType>
	<!-- 

R2ML core terms 

-->
	<!--The abstract concept of Term -->
	<xs:complexType name="Term"/>
	<!-- The abstract concept of ObjectTerm -->
	<xs:complexType name="ObjectTerm" abstract="true">
		<xs:complexContent>
			<xs:restriction base="r2ml:Term"/>
		</xs:complexContent>
	</xs:complexType>
	<!-- The abstract concept of Data Term -->
	<xs:complexType name="DataTerm" abstract="true">
		<xs:complexContent>
			<xs:restriction base="r2ml:Term"/>
		</xs:complexContent>
	</xs:complexType>
	<!-- 

R2ML basic terms 

-->
	<!-- R2ML generic variable -->
	<xs:complexType name="Variable" abstract="false">
		<xs:complexContent>
			<xs:extension base="r2ml:Term">
				<xs:attribute ref="r2ml:name" use="required"/>
			</xs:extension>
		</xs:complexContent>
	</xs:complexType>
	<!-- R2ML generic individual -->
	<xs:complexType name="IndividualConstant" abstract="false">
		<xs:complexContent>
			<xs:extension base="r2ml:Term">
				<xs:attribute ref="r2ml:individualConstantID" use="required"/>
			</xs:extension>
		</xs:complexContent>
	</xs:complexType>
	<!-- ObjectVariable -->
	<xs:complexType name="ObjectVariable" abstract="false">
		<xs:complexContent>
			<xs:extension base="r2ml:ObjectTerm">
				<xs:attribute ref="r2ml:name" use="required"/>
				<xs:attribute ref="r2ml:classID" use="optional"/>
			</xs:extension>
		</xs:complexContent>
	</xs:complexType>
	<!-- Object name -->
	<xs:complexType name="ObjectName" abstract="false">
		<xs:complexContent>
			<xs:extension base="r2ml:ObjectTerm">
				<xs:attribute ref="r2ml:objectID" use="required"/>
				<xs:attribute ref="r2ml:classID" use="optional"/>
			</xs:extension>
		</xs:complexContent>
	</xs:complexType>
	<!-- Data variable -->
	<xs:complexType name="DataVariable" abstract="false">
		<xs:complexContent>
			<xs:extension base="r2ml:DataTerm">
				<xs:attribute ref="r2ml:name" use="required"/>
				<xs:attribute ref="r2ml:dataTypeID" use="optional"/>
			</xs:extension>
		</xs:complexContent>
	</xs:complexType>
	<!-- Data Literal -->
	<xs:element name="DataLiteral" type="r2ml:DataLiteral" abstract="true" substitutionGroup="r2ml:DataTerm"/>
	<xs:complexType name="DataLiteral" abstract="true">
		<xs:complexContent>
			<xs:extension base="r2ml:DataTerm">
				<xs:attribute ref="r2ml:lexicalValue" use="required"/>
			</xs:extension>
		</xs:complexContent>
	</xs:complexType>
	<!-- Plain Literal -->
	<xs:complexType name="PlainLiteral" abstract="false">
		<xs:complexContent>
			<xs:extension base="r2ml:DataLiteral">
				<xs:attribute name="languageTag" use="required"/>
			</xs:extension>
		</xs:complexContent>
	</xs:complexType>
	<!-- Typed literal -->
	<xs:complexType name="TypedLiteral" abstract="false">
		<xs:complexContent>
			<xs:extension base="r2ml:DataLiteral">
				<xs:attribute ref="r2ml:type" use="required"/>
			</xs:extension>
		</xs:complexContent>
	</xs:complexType>
	<!--

 R2ML functional terms 

-->
	<!-- FunctionalTerm -->
	<xs:complexType name="FunctionTerm" abstract="false">
		<xs:complexContent>
			<xs:extension base="r2ml:Term">
				<xs:sequence>
					<xs:element ref="r2ml:arguments"/>
				</xs:sequence>
				<xs:attribute ref="r2ml:functorID" use="required"/>
			</xs:extension>
		</xs:complexContent>
	</xs:complexType>
	<!-- ObjectOperationTerm -->
	<xs:complexType name="ObjectOperationTerm" abstract="false">
		<xs:complexContent>
			<xs:extension base="r2ml:ObjectTerm">
				<xs:sequence>
					<xs:element ref="r2ml:contextArgument" minOccurs="0"/>
					<xs:element ref="r2ml:arguments" minOccurs="0"/>
				</xs:sequence>
				<xs:attribute ref="r2ml:operationID" use="required"/>
			</xs:extension>
		</xs:complexContent>
	</xs:complexType>
	<!-- Role Function Term. A role function corresponds to a functional association end (of a binary association) in a UML class model. -->
	<xs:complexType name="RoleFunctionTerm" abstract="false">
		<xs:complexContent>
			<xs:extension base="r2ml:ObjectTerm">
				<xs:sequence>
					<xs:element name="argument" type="r2ml:arguments" minOccurs="0"/>
				</xs:sequence>
				<xs:attribute ref="r2ml:refPropertyID" use="required"/>
			</xs:extension>
		</xs:complexContent>
	</xs:complexType>
	<!-- Data function term -->
	<xs:element name="DataFunctionTerm" type="r2ml:DataFunctionTerm" abstract="true" substitutionGroup="r2ml:DataTerm"/>
	<xs:complexType name="DataFunctionTerm" abstract="true">
		<xs:complexContent>
			<xs:restriction base="r2ml:DataTerm"/>
		</xs:complexContent>
	</xs:complexType>
	<!-- Data operation term -->
	<xs:complexType name="DataOperationTerm">
		<xs:complexContent>
			<xs:extension base="r2ml:DataFunctionTerm">
				<xs:sequence>
					<xs:element name="contextArgument" type="r2ml:contextArgument" minOccurs="0"/>
					<xs:element name="arguments" type="r2ml:arguments" minOccurs="0"/>
				</xs:sequence>
				<xs:attribute ref="r2ml:operationID" use="required"/>
			</xs:extension>
		</xs:complexContent>
	</xs:complexType>
	<!-- AttributeFunctionTerm -->
	<xs:complexType name="AttributeFunctionTerm">
		<xs:complexContent>
			<xs:extension base="r2ml:DataFunctionTerm">
				<xs:sequence>
					<xs:element name="contextArgument" type="r2ml:contextArgument"/>
				</xs:sequence>
				<xs:attribute ref="r2ml:attributeID" use="required"/>
			</xs:extension>
		</xs:complexContent>
	</xs:complexType>
	<!-- DatatypeFunctionTerm -->
	<xs:complexType name="DatatypeFunctionTerm" abstract="false">
		<xs:complexContent>
			<xs:extension base="r2ml:DataFunctionTerm">
				<xs:sequence>
					<xs:element name="dataArguments" type="r2ml:dataArguments"/>
				</xs:sequence>
				<xs:attribute ref="r2ml:datatypeFunctionID" use="required"/>
			</xs:extension>
		</xs:complexContent>
	</xs:complexType>
	<!-- 

The abstract concept of Action

-->
	<xs:element name="ActionExpression" abstract="true"/>
	<xs:complexType name="ActionExpression" abstract="true">
		<xs:sequence>
			<xs:element name="contextArgument" type="r2ml:contextArgument" minOccurs="0"/>
		</xs:sequence>
	</xs:complexType>
	<!-- Message action -->
	<xs:complexType name="MessageActionExpression" abstract="true">
		<xs:complexContent>
			<xs:extension base="r2ml:ActionExpression"/>
		</xs:complexContent>
	</xs:complexType>
	<!-- SOAP action -->
	<xs:complexType name="SOAPAction" abstract="false">
		<xs:complexContent>
			<xs:extension base="r2ml:MessageActionExpression"/>
		</xs:complexContent>
	</xs:complexType>
	<!-- SOAP rpc action -->
	<xs:complexType name="SOAPRPCAction" abstract="false">
		<xs:complexContent>
			<xs:extension base="r2ml:SOAPAction">
				<xs:sequence>
					<xs:element ref="r2ml:arguments" maxOccurs="unbounded"/>
				</xs:sequence>
				<xs:attribute ref="r2ml:operationID" use="required"/>
			</xs:extension>
		</xs:complexContent>
	</xs:complexType>
	<!-- 
Invoke action 
-->
	<xs:complexType name="InvokeActionExpression" abstract="false">
		<xs:complexContent>
			<xs:extension base="r2ml:ActionExpression">
				<xs:sequence>
					<xs:element name="argument" type="r2ml:arguments" minOccurs="0"/>
				</xs:sequence>
				<xs:attribute ref="r2ml:operationID" use="required"/>
			</xs:extension>
		</xs:complexContent>
	</xs:complexType>
	<!-- 
Assign action 
-->
	<xs:complexType name="AssignActionExpression" abstract="false">
		<xs:complexContent>
			<xs:extension base="r2ml:ActionExpression">
				<xs:sequence>
					<xs:element ref="r2ml:DataTerm"/>
				</xs:sequence>
				<xs:attribute ref="r2ml:propertyID" use="required"/>
			</xs:extension>
		</xs:complexContent>
	</xs:complexType>
	<!-- 
Create Action 
-->
	<xs:complexType name="CreateActionExpression" abstract="false">
		<xs:complexContent>
			<xs:extension base="r2ml:ActionExpression">
				<xs:sequence>
					<xs:element ref="r2ml:Slot" minOccurs="0" maxOccurs="unbounded"/>
				</xs:sequence>
				<xs:attribute ref="r2ml:classID" use="required"/>
			</xs:extension>
		</xs:complexContent>
	</xs:complexType>
	<!--
Delete Action 
-->
	<xs:complexType name="DeleteActionExpression" abstract="false">
		<xs:complexContent>
			<xs:extension base="r2ml:ActionExpression">
				<xs:sequence>
					<xs:element ref="r2ml:ObjectTerm"/>
				</xs:sequence>
				<xs:attribute ref="r2ml:classID" use="required"/>
			</xs:extension>
		</xs:complexContent>
	</xs:complexType>
	<!-- Event Expression -->
	<xs:complexType name="EventExpression" abstract="true">
		<xs:attribute name="startTime" type="xs:dateTime" use="required"/>
		<xs:attribute name="duration" type="xs:duration" use="required"/>
		<xs:attribute name="occurTime" type="xs:dateTime" use="optional"/>
	</xs:complexType>
	<!-- Atomic event expression -->
	<xs:complexType name="AtomicEventExpression" abstract="false">
		<xs:complexContent>
			<xs:extension base="r2ml:EventExpression">
				<xs:sequence>
					<xs:element name="arguments" type="r2ml:arguments"/>
				</xs:sequence>
				<xs:attribute ref="r2ml:eventID" use="optional"/>
				<xs:attribute ref="r2ml:eventTypeID" use="required"/>
			</xs:extension>
		</xs:complexContent>
	</xs:complexType>
	<!-- AndNotEventExpression -->
	<xs:complexType name="AndNotEventExpression" abstract="false">
		<xs:complexContent>
			<xs:extension base="r2ml:EventExpression">
				<xs:sequence>
					<xs:element ref="r2ml:EventExpression" minOccurs="2" maxOccurs="unbounded"/>
				</xs:sequence>
				<xs:attribute name="timeWindow" type="xs:duration" use="required"/>
			</xs:extension>
		</xs:complexContent>
	</xs:complexType>
	<!-- SequenceEventExpression -->
	<xs:complexType name="SequenceEventExpression" abstract="false">
		<xs:complexContent>
			<xs:extension base="r2ml:EventExpression">
				<xs:sequence>
					<xs:element ref="r2ml:EventExpression" minOccurs="2" maxOccurs="unbounded"/>
				</xs:sequence>
				<xs:attribute name="timeWindow" type="xs:duration" use="required"/>
			</xs:extension>
		</xs:complexContent>
	</xs:complexType>
	<!-- ParallelEventExpression -->
	<xs:complexType name="ParallelEventExpression" abstract="false">
		<xs:complexContent>
			<xs:extension base="r2ml:EventExpression">
				<xs:sequence>
					<xs:element ref="r2ml:EventExpression" minOccurs="2" maxOccurs="unbounded"/>
				</xs:sequence>
				<xs:attribute name="timeWindow" type="xs:duration" use="required"/>
			</xs:extension>
		</xs:complexContent>
	</xs:complexType>
	<!-- ChoiceEventExpression -->
	<xs:complexType name="ChoiceEventExpression" abstract="false">
		<xs:complexContent>
			<xs:extension base="r2ml:EventExpression">
				<xs:sequence>
					<xs:element ref="r2ml:EventExpression" maxOccurs="unbounded"/>
				</xs:sequence>
				<xs:attribute name="minOccurs" type="xs:nonNegativeInteger"/>
				<xs:attribute name="maxOccurs" type="xs:nonNegativeInteger"/>
			</xs:extension>
		</xs:complexContent>
	</xs:complexType>
	<!-- MessageEventExpression -->
	<xs:complexType name="MessageEventExpression" abstract="false">
		<xs:complexContent>
			<xs:extension base="r2ml:AtomicEventExpression">
				<xs:attribute ref="r2ml:sender" use="required"/>
			</xs:extension>
		</xs:complexContent>
	</xs:complexType>
	<!-- SOAPMessage -->
	<xs:complexType name="SOAPMessage" abstract="false">
		<xs:complexContent>
			<xs:extension base="r2ml:MessageEventExpression"/>
		</xs:complexContent>
	</xs:complexType>
	<!-- 

Role elements 

-->
	<!-- constraint  (appear in integrity rules) -->
	<xs:complexType name="constraint" abstract="false">
		<xs:sequence>
			<xs:element ref="r2ml:QuantifiedFormula"/>
		</xs:sequence>
	</xs:complexType>
	<!-- condition -->
	<xs:complexType name="condition" abstract="false">
		<xs:sequence>
			<xs:element ref="r2ml:qf.AndOrNafNegFormula" maxOccurs="unbounded"/>
		</xs:sequence>
	</xs:complexType>
	<!-- conclusion -->
	<xs:complexType name="conclusion" abstract="false">
		<xs:choice>
			<xs:element ref="r2ml:qf.LiteralConjunction" maxOccurs="unbounded"/>
			<xs:element ref="r2ml:Atom"/>
		</xs:choice>
	</xs:complexType>
	<!-- postcondition -->
	<xs:complexType name="postcondition" abstract="false">
		<xs:sequence>
			<xs:element ref="r2ml:qf.AndOrNafNegFormula" minOccurs="0"/>
		</xs:sequence>
	</xs:complexType>
	<!-- produced action (appear in production rules and reaction rules)-->
	<xs:complexType name="producedAction" abstract="false">
		<xs:sequence>
			<xs:element ref="r2ml:ActionExpression"/>
		</xs:sequence>
	</xs:complexType>
	<!-- triggeringEvent  (appear in event expressions)-->
	<xs:complexType name="triggeringEvent" abstract="false">
		<xs:sequence>
			<xs:element ref="r2ml:EventExpression"/>
		</xs:sequence>
	</xs:complexType>
	<!-- roles that appear in atoms -->
	<!-- role subject -->
	<xs:complexType name="subject" abstract="false">
		<xs:choice>
			<xs:element ref="r2ml:ObjectTerm"/>
		</xs:choice>
	</xs:complexType>
	<!-- role object -->
	<xs:complexType name="object" abstract="false">
		<xs:choice>
			<xs:element ref="r2ml:ObjectTerm"/>
		</xs:choice>
	</xs:complexType>
	<!-- role value -->
	<xs:complexType name="value" abstract="false">
		<xs:choice>
			<xs:element ref="r2ml:DataTerm"/>
		</xs:choice>
	</xs:complexType>
	<!-- role genericArguments -->
	<xs:complexType name="genericArguments" abstract="false">
		<xs:choice>
			<xs:element ref="r2ml:Variable"/>
			<xs:element ref="r2ml:IndividualConstant"/>
			<xs:element ref="r2ml:FunctionTerm"/>
		</xs:choice>
	</xs:complexType>
	<!-- role argument -->
	<xs:complexType name="arguments" abstract="false">
		<xs:sequence>
			<xs:element ref="r2ml:Term" minOccurs="0" maxOccurs="unbounded"/>
		</xs:sequence>
	</xs:complexType>
	<!-- role contextArgument -->
	<xs:complexType name="contextArgument" abstract="false">
		<xs:sequence>
			<xs:element ref="r2ml:ObjectTerm"/>
		</xs:sequence>
	</xs:complexType>
	<!-- role dataArgument -->
	<xs:complexType name="dataArguments" abstract="false">
		<xs:choice>
			<xs:element ref="r2ml:DataTerm" minOccurs="0" maxOccurs="unbounded"/>
		</xs:choice>
	</xs:complexType>
	<!-- role objectArgument -->
	<xs:complexType name="objectArguments" abstract="false">
		<xs:choice>
			<xs:element ref="r2ml:ObjectTerm" minOccurs="2" maxOccurs="unbounded"/>
		</xs:choice>
	</xs:complexType>
	<!-- Vocabulary elements and attributes -->
	<!-- R2ML class -->
	<xs:simpleType name="Class">
		<xs:restriction base="xs:anyURI"/>
	</xs:simpleType>
	<!-- R2ML property -->
	<xs:simpleType name="Property">
		<xs:restriction base="xs:anyURI"/>
	</xs:simpleType>
	<!-- Operation  - An object operation is a special type of user-defined function that corresponds to an object-valued operation in a UML class model.-->
	<xs:simpleType name="Operation">
		<xs:restriction base="xs:anyURI"/>
	</xs:simpleType>
	<!-- R2ML datatype -->
	<xs:simpleType name="Datatype">
		<xs:restriction base="xs:anyURI"/>
	</xs:simpleType>
	<!--  R2ML ReferenceProperty -->
	<xs:simpleType name="ReferenceProperty">
		<xs:restriction base="xs:anyURI"/>
	</xs:simpleType>
	<!-- R2ML association predicate -->
	<xs:simpleType name="AssociationPredicate">
		<xs:restriction base="xs:anyURI"/>
	</xs:simpleType>
	<!-- Attribute - An attribute is a special type of user-defined function that corresponds to a data-valued property in a UML class model.-->
	<xs:simpleType name="Attribute">
		<xs:restriction base="xs:anyURI"/>
	</xs:simpleType>
	<!-- R2ML datatype predicate (similar with swrl built-in predicates) -->
	<xs:simpleType name="DatatypePredicate">
		<xs:restriction base="xs:anyURI"/>
	</xs:simpleType>
	<!-- R2ML DatatypeFunction  - A data operation is a special type of user-defined function that corresponds to a data-valued operation in a UML class model.-->
	<xs:simpleType name="DatatypeFunction">
		<xs:restriction base="xs:anyURI"/>
	</xs:simpleType>
	<!-- R2ML generic functor -->
	<xs:simpleType name="Functor">
		<xs:restriction base="xs:anyURI"/>
	</xs:simpleType>
	<!-- R2ML Vocabulary -->
	<xs:simpleType name="Vocabulary">
		<xs:restriction base="xs:anyURI"/>
	</xs:simpleType>
	<!-- Predicate type is an enumeration of supported predicates names in R2ML -->
	<xs:simpleType name="PredicateType">
		<xs:restriction base="xs:string">
			<xs:enumeration value="ObjectClassificationAtom"/>
			<xs:enumeration value="ObjectDescriptionAtom"/>
			<xs:enumeration value="AttributionAtom"/>
			<!-- etc -->
		</xs:restriction>
	</xs:simpleType>
	<!-- EventType type-->
	<xs:simpleType name="EventType">
		<xs:restriction base="xs:anyURI"/>
	</xs:simpleType>
	<!-- Sender type -->
	<xs:simpleType name="Sender">
		<xs:restriction base="xs:anyURI"/>
	</xs:simpleType>
	<!-- Appear in Atom -->
	<xs:attribute name="isNegated" type="xs:boolean"/>
	<!-- Appear in ObjectVariable and ObjectName  i.e. the type for object variables and object constants-->
	<xs:attribute name="classID" type="r2ml:Class"/>
	<!-- appear in  ObjectDescriptionAtom -->
	<xs:attribute name="baseTypeID" type="r2ml:Class"/>
	<!-- appear in referencePropertyAtom -->
	<xs:attribute name="refPropertyID" type="r2ml:ReferenceProperty"/>
	<!-- appear in AttributeDataTermPair, AttributionAtom, AttributeFunctionTerm -->
	<xs:attribute name="attributeID" type="r2ml:Attribute"/>
	<!-- appear in ObjectOperationTerm and DataOperationTerm  and is a reference to an UML Operation -->
	<xs:attribute name="operationID" type="r2ml:Operation"/>
	<!-- appear in a AssociationAtom -->
	<xs:attribute name="associationPredicateID" type="r2ml:AssociationPredicate"/>
	<!-- appear in AssignAction -->
	<xs:attribute name="propertyID" type="r2ml:Property"/>
	<!-- appear in a BuiltinPredicateAtom -->
	<xs:attribute name="dataPredicateID" type="r2ml:DatatypePredicate"/>
	<!-- appear in nany named entity: ObjectVariable DataVariable -->
	<xs:attribute name="name" type="xs:NCName"/>
	<!-- appear in generic individual constant -->
	<xs:attribute name="individualConstantID" type="xs:anyURI"/>
	<!-- 	appear in ObjectName -->
	<xs:attribute name="objectID" type="xs:anyURI"/>
	<!-- appear in BuiltinFunctionTerm -->
	<xs:attribute name="datatypeFunctionID" type="r2ml:DatatypeFunction"/>
	<!-- appear in DataClassificationAtom -->
	<xs:attribute name="dataTypeID" type="r2ml:Datatype"/>
	<!-- appear in all elements that can be identified by an ID -->
	<xs:attribute name="id" type="xs:ID"/>
	<!-- appear in PlainLiteral -->
	<xs:attribute name="languageTag" type="xs:normalizedString"/>
	<!-- is an attribute appearing in TypedLiteral. The value must be an RDF:Datatype -->
	<xs:attribute name="type" type="xs:anySimpleType"/>
	<xs:attribute name="lexicalValue" type="xs:normalizedString"/>
	<!-- appear in Atomic event expression -->
	<xs:attribute name="eventID" type="xs:ID"/>
	<xs:attribute name="eventTypeID" type="r2ml:EventType"/>
	<xs:attribute name="sender" type="r2ml:Sender"/>
	<!-- appear in FunctionalTerm -->
	<xs:attribute name="functorID" type="r2ml:Functor"/>
</xs:schema>
