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

   R2ML - The REWERSE I1 Rule Markup Language.
   Version: 0.3 Publication date:  July 10, 2006
   
   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: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-07-10</dc:date>
      <dc:rights>http://www.gnu.org/copyleft/lesser.html</dc:rights>
   </rdf:Description> 
</rdf:RDF>


R2ML.xsd - R2ML Rule markup Language W3C XML Schema 

Copyright (C)  2006  Adrian Giurca, Gerd Wagner.

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/2006/R2ML" 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/2006/R2ML  http://www.rewerse.net/I1/R2ML/0.3/r2ml.xsd">


Changes in version 0.3

- The content model of r2ml:Implication was changed. An r2ml:Implication consist from an r2ml:antecedent and a r2ml:consequent, both consisting of  r2ml:LogicalFormula. 

- Adding new types of quantified formula for handling integrity constraints: r2ml:AtLeastQuantifiedFormula, r2ml:AtMostQuantifiedFormula and r2ml:AtLeastAndAtMostQuantifiedFormula.  They use new attributes: r2ml:minCardinality and r2ml:maxCardinality  to specify cardinality constraints.

- r2ml:Term has a new optional attribute r2ml:isMultivalued of type xs:boolean. By default the value of this attribute is 'false'. The intended meaning of this attribute is to declare if the corresponding term is or is not multivalued. A term is multivalued iff a collection is expected to be the result of its evaluation.

- The content model of ObjectDescriptionAtom was changed. No order of slots is imposed.
- r2ml:Negation and r2ml:qf.Negation elements are no longer abstract.
- r2ml:object attribute was changed to r2ml:objectID
- The role r2ml:arguments from r2ml:RoleFunctionTerm was replaced with r2ml:contextArgument
- r2ml:DataOperationTerm must have at least one argument i.e. r2ml:agruments is no longer optional.
- All names from the type xs:anyURI are replaced with qualified names (xs:QName). 
- r2ml:name attribute has type xs:NCName
- r2ml:deleteActionExpression has a r2ml:contextArgument content.


Changes in Ver 0.2:

-The namespace URI is set to http://www.rewerse.net/I1/2006/R2ML 
-All attributes of the form "xxxxxxID" which corresponds to class references involved in functional associations without a role name are replaced with the class name i.e. "xxxxxx". For example, "functorID" is replaced with "functor", "referencePropertyID" with "referenceProperty", etc. 
-Change the GenericAtom definition by adding the new types r2ml:Predicate and r2ml:PredicateType and the corresponding attribute references. 
-The r2ml:PredicateType enumeration is now complete. 
-The current content model of r2ml:SourceCode allow any kind of contents. 
-Content change in r2ml:ProductionRule to allow both r2ml:postcondition and r2ml:producedAction (or not xor). 
-Content change in the role r2ml:postcondition which became similar with r2ml:condition 
-Content change in r2ml:AssignAction. Now supports both object terms and data terms. 
-Changed the name r2ml:refProperty to r2ml:referenceProperty. 
-->
 <!-- 

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"/>
 <xs:element name="Vocabulary" type="r2ml:Vocabulary" abstract="false"/>
 <!-- 

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"/>
 <xs:element name="ReactionRule" type="r2ml:ReactionRule" 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="false" substitutionGroup="r2ml:LogicalFormula"/>
 <xs:element name="StrongNegation" type="r2ml:StrongNegation" abstract="false" substitutionGroup="r2ml:Negation"/>
 <xs:element name="NegationAsFailure" type="r2ml:NegationAsFailure" 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"/>
 <xs:element name="AtLeastQuantifiedFormula" type="r2ml:AtLeastQuantifiedFormula" abstract="false" substitutionGroup="r2ml:QuantifiedFormula"/>
 <xs:element name="AtMostQuantifiedFormula" type="r2ml:AtMostQuantifiedFormula" abstract="false" substitutionGroup="r2ml:QuantifiedFormula"/>
 <xs:element name="AtLeastAndAtMostQuantifiedFormula" type="r2ml:AtLeastAndAtMostQuantifiedFormula" abstract="false" substitutionGroup="r2ml:QuantifiedFormula"/>
 <!-- 

Elements for quantifier free formulas

-->
 <xs:element name="qf.DNF" type="r2ml:qf.DNF" abstract="true"/>
 <xs:element name="qf.LiteralConjunction" type="r2ml:qf.LiteralConjunction" abstract="false" substitutionGroup="r2ml:qf.DNF"/>
 <xs:element name="qf.AndOrNafNegFormula" type="r2ml:qf.AndOrNafNegFormula" abstract="true" substitutionGroup="r2ml:LogicalFormula"/>
 <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.Negation" type="r2ml:qf.Negation" abstract="false" substitutionGroup="r2ml:qf.AndOrNafNegFormula"/>
 <xs:element name="qf.StrongNegation" type="r2ml:qf.StrongNegation" abstract="false" substitutionGroup="r2ml:qf.Negation"/>
 <xs:element name="qf.NegationAsFailure" type="r2ml:qf.NegationAsFailure" abstract="false" substitutionGroup="r2ml:qf.Negation"/>
 <!--

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="DatatypePredicateAtom" type="r2ml:DatatypePredicateAtom" 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:Term"/>
 <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="ObjectVariable" type="r2ml:ObjectVariable" abstract="false" substitutionGroup="r2ml:ObjectTerm"/>
 <xs:element name="Object" type="r2ml:Object" abstract="false" substitutionGroup="r2ml:ObjectTerm"/>
 <xs:element name="Constant" type="r2ml:Constant" abstract="false" substitutionGroup="r2ml:Term"/>
 <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="antecedent" type="r2ml:antecedent" abstract="false"/>
 <xs:element name="consequent" type="r2ml:consequent" abstract="false"/>
 <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="objectArguments" 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:element ref="r2ml:Vocabulary" minOccurs="0" maxOccurs="unbounded"/>
   <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 ref="r2ml:RuleSet" maxOccurs="unbounded"/>
  </xs:sequence>
 </xs:complexType>
 <!-- 

Rule Set 

-->
 <xs:complexType name="RuleSet" abstract="true">
  <xs:sequence>
   <xs:element ref="r2ml:Vocabulary" minOccurs="0" maxOccurs="unbounded"/>
  </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 ref="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 ref="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 ref="r2ml:ReactionRule" maxOccurs="unbounded"/>
    </xs:sequence>
   </xs:extension>
  </xs:complexContent>
 </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 type -->
 <xs:complexType name="SourceCode">
  <xs:complexContent>
   <xs:extension base="xs:anyType">
    <xs:attribute name="language" type="xs:string" use="optional"/>
   </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:attribute ref="r2ml:id" use="optional"/>
 </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: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:extension>
  </xs:complexContent>
 </xs:complexType>
 <!-- 

Production Rule

-->
 <xs:complexType name="ProductionRule" abstract="false">
  <xs:complexContent>
   <xs:extension base="r2ml:Rule">
    <xs:sequence>
     <xs:element ref="r2ml:conditions"/>
     <xs:element ref="r2ml:producedAction"/>
     <xs:element ref="r2ml:postcondition" minOccurs="0"/>
    </xs:sequence>
   </xs:extension>
  </xs:complexContent>
 </xs:complexType>
 <!-- 

Reaction 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: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:antecedent"/>
     <xs:element ref="r2ml:consequent"/>
    </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="false">
  <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 NegationAsFailure -->
 <xs:complexType name="NegationAsFailure" 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 maxOccurs="unbounded">
      <xs:element ref="r2ml:Variable" maxOccurs="unbounded"/>
      <xs:element ref="r2ml:ObjectVariable" maxOccurs="unbounded"/>
      <xs:element ref="r2ml:DataVariable" 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:sequence>
     <xs:element ref="r2ml:LogicalFormula"/>
    </xs:sequence>
   </xs:extension>
  </xs:complexContent>
 </xs:complexType>
 <!-- -->
 <xs:complexType name="AtLeastQuantifiedFormula" abstract="false">
  <xs:complexContent>
   <xs:extension base="r2ml:QuantifiedFormula">
       <xs:sequence>
     <xs:element ref="r2ml:LogicalFormula"/>
    </xs:sequence>
    <xs:attribute ref="r2ml:minCardinality"/>
   </xs:extension>
  </xs:complexContent>
 </xs:complexType>
 <!-- -->
 <xs:complexType name="AtMostQuantifiedFormula" abstract="false">
  <xs:complexContent>
   <xs:extension base="r2ml:QuantifiedFormula">
       <xs:sequence>
     <xs:element ref="r2ml:LogicalFormula"/>
    </xs:sequence>
    <xs:attribute ref="r2ml:maxCardinality"/>
   </xs:extension>
  </xs:complexContent>
 </xs:complexType>
 <!-- -->
 <xs:complexType name="AtLeastAndAtMostQuantifiedFormula" abstract="false">
  <xs:complexContent>
   <xs:extension base="r2ml:QuantifiedFormula">
       <xs:sequence>
     <xs:element ref="r2ml:LogicalFormula"/>
    </xs:sequence>
    <xs:attribute ref="r2ml:minCardinality"/>
    <xs:attribute ref="r2ml:maxCardinality"/>
   </xs:extension>
  </xs:complexContent>
 </xs:complexType>
 <!-- R2Ml quantifier free formulas -->
 <!-- DNF -->
 <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: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="false">
  <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 NegationAsFailure (quantifier free)-->
 <xs:complexType name="qf.NegationAsFailure" 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" abstract="false">
  <xs:complexContent>
   <xs:extension base="r2ml:Atom">
    <xs:sequence>
     <xs:element ref="r2ml:arguments"/>
    </xs:sequence>
    <xs:attribute ref="r2ml:predicate" use="required"/>
    <xs:attribute ref="r2ml:predicateType" use="optional"/>
   </xs:extension>
  </xs:complexContent>
 </xs:complexType>
 <!-- 

R2ML basic atoms 

-->
 <!--Data atoms -->
 <!-- DataPredicateAtom -->
 <xs:complexType name="DatatypePredicateAtom" abstract="false">
  <xs:complexContent>
   <xs:extension base="r2ml:DataAtom">
    <xs:sequence>
     <xs:element ref="r2ml:dataArguments"/>
    </xs:sequence>
    <xs:attribute ref="r2ml:datatypePredicate" 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:class" 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"/>
    </xs:sequence>
    <xs:attribute ref="r2ml:datatype" 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 ref="r2ml:subject"/>
     <xs:choice maxOccurs="unbounded">
      <xs:element ref="r2ml:ObjectSlot" minOccurs="0" maxOccurs="unbounded"/>
      <xs:element ref="r2ml:DataSlot" minOccurs="0" maxOccurs="unbounded"/>
     </xs:choice>
    </xs:sequence>
    <xs:attribute ref="r2ml:baseType" use="optional"/>
    <xs:attribute ref="r2ml:class" 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 ref="r2ml:subject"/>
     <xs:element ref="r2ml:value"/>
    </xs:sequence>
    <xs:attribute ref="r2ml:attribute" 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:all>
     <xs:element ref="r2ml:dataArguments" minOccurs="0"/>
     <xs:element ref="r2ml:objectArguments"/>
    </xs:all>
    <xs:attribute ref="r2ml:associationPredicate" 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 ref="r2ml:object"/>
    </xs:sequence>
    <xs:attribute ref="r2ml:referenceProperty" 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:Term"/>
  </xs:complexContent>
 </xs:complexType>
 <!-- Object slot -->
 <xs:complexType name="ObjectSlot" abstract="false">
  <xs:complexContent>
   <xs:extension base="r2ml:Slot">
    <xs:sequence>
     <xs:element ref="r2ml:object"/>
    </xs:sequence>
    <xs:attribute ref="r2ml:referenceProperty" 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 ref="r2ml:value"/>
    </xs:sequence>
    <xs:attribute ref="r2ml:attribute" use="required"/>
   </xs:extension>
  </xs:complexContent>
 </xs:complexType>
 <!-- 

R2ML core terms 

-->
 <!--The abstract concept of Term -->
 <xs:complexType name="Term">
  <xs:attribute ref="r2ml:isMultivalued" use="optional"/>
 </xs:complexType>
 <!-- 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="Constant" abstract="false">
  <xs:complexContent>
   <xs:extension base="r2ml:Term">
    <xs:attribute ref="r2ml:constID" 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:class" use="optional"/>
   </xs:extension>
  </xs:complexContent>
 </xs:complexType>
 <!-- Object name -->
 <xs:complexType name="Object" abstract="false">
  <xs:complexContent>
   <xs:extension base="r2ml:ObjectTerm">
    <xs:attribute ref="r2ml:objectID" use="required"/>
    <xs:attribute ref="r2ml:class" 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:datatype" 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:datatype" 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:functor" 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"/>
     <xs:element ref="r2ml:arguments" minOccurs="0"/>
    </xs:sequence>
    <xs:attribute ref="r2ml:operation" 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 ref="r2ml:contextArgument"/>
    </xs:sequence>
    <xs:attribute ref="r2ml:referenceProperty" 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 ref="r2ml:contextArgument" minOccurs="0"/>
     <xs:element ref="r2ml:arguments"/>
    </xs:sequence>
    <xs:attribute ref="r2ml:operation" use="required"/>
   </xs:extension>
  </xs:complexContent>
 </xs:complexType>
 <!-- AttributeFunctionTerm -->
 <xs:complexType name="AttributeFunctionTerm">
  <xs:complexContent>
   <xs:extension base="r2ml:DataFunctionTerm">
    <xs:sequence>
     <xs:element ref="r2ml:contextArgument"/>
    </xs:sequence>
    <xs:attribute ref="r2ml:attribute" 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 ref="r2ml:dataArguments"/>
    </xs:sequence>
    <xs:attribute ref="r2ml:datatypeFunction" 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"/>
 <!-- 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:operation" 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 ref="r2ml:contextArgument"/>
     <xs:element ref="r2ml:arguments" minOccurs="0"/>
    </xs:sequence>
    <xs:attribute ref="r2ml:operation" 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:contextArgument"/>
     <xs:element ref="r2ml:Term"/>
    </xs:sequence>
    <xs:attribute ref="r2ml:property" 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:class" 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:contextArgument"/>
    </xs:sequence>
    <xs:attribute ref="r2ml:class" 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 ref="r2ml:arguments" minOccurs="0"/>
    </xs:sequence>
    <xs:attribute ref="r2ml:event" use="optional"/>
    <xs:attribute ref="r2ml:eventType" 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:Atom"/>
   <xs:element ref="r2ml:qf.LiteralConjunction" maxOccurs="unbounded"/>
  </xs:choice>
 </xs:complexType>
 <!-- postcondition -->
 <xs:complexType name="postcondition" abstract="false">
  <xs:sequence>
   <xs:element ref="r2ml:qf.AndOrNafNegFormula" maxOccurs="unbounded"/>
  </xs:sequence>
 </xs:complexType>
 <!-- antecedent -->
 <xs:complexType name="antecedent" abstract="false">
  <xs:sequence>
   <xs:element ref="r2ml:LogicalFormula"/>
  </xs:sequence>
 </xs:complexType>
 <!-- consequent -->
 <xs:complexType name="consequent" abstract="false">
  <xs:sequence>
   <xs:element ref="r2ml:LogicalFormula"/>
  </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:Object"/>
   <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:sequence>
   <xs:element ref="r2ml:DataTerm" minOccurs="0" maxOccurs="unbounded"/>
  </xs:sequence>
 </xs:complexType>
 <!-- role objectArgument -->
 <xs:complexType name="objectArguments" abstract="false">
  <xs:sequence>
   <xs:element ref="r2ml:ObjectTerm" minOccurs="2" maxOccurs="unbounded"/>
  </xs:sequence>
 </xs:complexType>
 <!-- Vocabulary elements and attributes -->
 <!-- R2ML class -->
 <xs:simpleType name="Class">
  <xs:restriction base="xs:QName"/>
 </xs:simpleType>
 <!-- R2ML property -->
 <xs:simpleType name="Property">
  <xs:restriction base="xs:QName"/>
 </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:QName"/>
 </xs:simpleType>
 <!-- R2ML datatype -->
 <xs:simpleType name="Datatype">
  <xs:restriction base="xs:QName"/>
 </xs:simpleType>
 <!--  R2ML ReferenceProperty -->
 <xs:simpleType name="ReferenceProperty">
  <xs:restriction base="xs:QName"/>
 </xs:simpleType>
 <!-- R2ML association predicate -->
 <xs:simpleType name="AssociationPredicate">
  <xs:restriction base="xs:QName"/>
 </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:QName"/>
 </xs:simpleType>
 <!-- R2ML datatype predicate (similar with swrl built-in predicates) -->
 <xs:simpleType name="DatatypePredicate">
  <xs:restriction base="xs:QName"/>
 </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:QName"/>
 </xs:simpleType>
 <!-- R2ML generic functor -->
 <xs:simpleType name="Functor">
  <xs:restriction base="xs:QName"/>
 </xs:simpleType>
 <!-- R2ML generic predicate -->
 <xs:simpleType name="Predicate">
  <xs:restriction base="xs:QName"/>
 </xs:simpleType>
 <!-- R2ML Vocabulary -->
 <xs:simpleType name="Vocabulary">
  <xs:restriction base="xs:QName"/>
 </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="GenericPredicate"/>
   <xs:enumeration value="ObjectClassificationPredicate"/>
   <xs:enumeration value="AttributionPredicate"/>
   <xs:enumeration value="AssociationPredicate"/>
   <xs:enumeration value="EqualityPredicate"/>
   <xs:enumeration value="InequalityPredicate"/>
   <xs:enumeration value="DatatypePredicate"/>
   <xs:enumeration value="DataClassificationPredicate"/>
  </xs:restriction>
 </xs:simpleType>
 <!-- EventType type-->
 <xs:simpleType name="EventType">
  <xs:restriction base="xs:QName"/>
 </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 Object  i.e. the type for object variables and object constants-->
 <xs:attribute name="class" type="r2ml:Class"/>
 <!-- appear in  ObjectDescriptionAtom -->
 <xs:attribute name="baseType" type="r2ml:Class"/>
 <!-- appear in referencePropertyAtom -->
 <xs:attribute name="referenceProperty" type="r2ml:ReferenceProperty"/>
 <!-- appear in AttributeDataTermPair, AttributionAtom, AttributeFunctionTerm -->
 <xs:attribute name="attribute" type="r2ml:Attribute"/>
 <!-- appear in ObjectOperationTerm and DataOperationTerm  and is a reference to an UML Operation -->
 <xs:attribute name="operation" type="r2ml:Operation"/>
 <!-- appear in GenericAtom -->
 <xs:attribute name="predicate" type="r2ml:Predicate"/>
 <xs:attribute name="predicateType" type="r2ml:PredicateType"/>
 <!-- appear in a AssociationAtom -->
 <xs:attribute name="associationPredicate" type="r2ml:AssociationPredicate"/>
 <!-- appear in AssignAction -->
 <xs:attribute name="property" type="r2ml:Property"/>
 <!-- appear in a BuiltinPredicateAtom -->
 <xs:attribute name="datatypePredicate" type="r2ml:DatatypePredicate"/>
 <!-- appear in nany named entity: ObjectVariable DataVariable -->
 <xs:attribute name="name" type="xs:NCName"/>
 <!-- 	appear in Object -->
 <xs:attribute name="objectID" type="xs:QName"/>
 <xs:attribute name="constID" type="xs:QName"/>
 <!-- appear in BuiltinFunctionTerm -->
 <xs:attribute name="datatypeFunction" type="r2ml:DatatypeFunction"/>
 <!-- appear in DataClassificationAtom -->
 <xs:attribute name="datatype" type="r2ml:Datatype"/>
 <!-- appear in all elements that can be identified by an ID -->
 <xs:attribute name="id" type="xs:ID"/>
 <!-- cardinalities -->
 <xs:attribute name="minCardinality" type="xs:positiveInteger"/>
 <xs:attribute name="maxCardinality" type="xs:positiveInteger"/>
 <!-- multivalued terms -->
 <xs:attribute name="isMultivalued" type="xs:boolean"/>
 <!-- appear in PlainLiteral -->
 <xs:attribute name="languageTag" type="xs:normalizedString"/>
 <xs:attribute name="lexicalValue" type="xs:string"/>
 <!-- appear in Atomic event expression -->
 <xs:attribute name="event" type="xs:ID"/>
 <xs:attribute name="eventType" type="r2ml:EventType"/>
 <xs:attribute name="sender" type="r2ml:Sender"/>
 <!-- appear in FunctionalTerm -->
 <xs:attribute name="functor" type="r2ml:Functor"/>
</xs:schema>
