<?xml version="1.0" encoding="UTF-8"?>
<!--
  ~ Licensed to the Apache Software Foundation (ASF) under one
  ~ or more contributor license agreements. See the NOTICE file
  ~ distributed with this work for additional information
  ~ regarding copyright ownership. The ASF licenses this file
  ~ to you under the Apache License, Version 2.0 (the
  ~ "License"); you may not use this file except in compliance
  ~ with the License. You may obtain a copy of the License at
  ~
  ~ http://www.apache.org/licenses/LICENSE-2.0
  ~
  ~ Unless required by applicable law or agreed to in writing,
  ~ software distributed under the License is distributed on an
  ~ "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
  ~ KIND, either express or implied. See the License for the
  ~ specific language governing permissions and limitations
  ~ under the License.
  -->

<!-- Created by Eran Chinthaka -->
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema" elementFormDefault="qualified" attributeFormDefault="unqualified">
	<xs:element name="module">
		<xs:complexType>
			<xs:sequence>
				<xs:element name="Description" minOccurs="0"/>
				<xs:element name="InFlow" minOccurs="0">
					<xs:complexType>
						<xs:sequence>
							<xs:element name="handler"  type="handlerType"  minOccurs="0" maxOccurs="unbounded"/>
						</xs:sequence>
					</xs:complexType>
				</xs:element>
				<xs:element name="OutFlow" minOccurs="0">
					<xs:complexType>
						<xs:sequence>
							<xs:element name="handler"  type="handlerType" minOccurs="0" maxOccurs="unbounded"/>
						</xs:sequence>
					</xs:complexType>
				</xs:element>
				<xs:element ref="parameter" minOccurs="0" maxOccurs="unbounded"/>
				<xs:element ref="operation" minOccurs="0"/>
				<xs:element name="OutFaultFlow" minOccurs="0">
					<xs:complexType>
						<xs:sequence>
							<xs:element  name="handler"  type="handlerType" minOccurs="0" maxOccurs="unbounded"/>
						</xs:sequence>
					</xs:complexType>
				</xs:element>
				<xs:element name="InFaultFlow" minOccurs="0">
					<xs:complexType>
						<xs:sequence>
							<xs:element  name="handler"  type="handlerType"  minOccurs="0" maxOccurs="unbounded"/>
						</xs:sequence>
					</xs:complexType>
				</xs:element>
			</xs:sequence>
			<xs:attribute name="name" type="xs:string" use="optional"/>
			<xs:attribute name="class" type="xs:string" use="optional"/>
		</xs:complexType>
	</xs:element>
	<xs:element name="order">
		<xs:complexType>
			<xs:attribute name="phase" type="xs:string" use="required"/>
			<xs:attribute name="after" type="xs:string" use="optional"/>
			<xs:attribute name="before" type="xs:string" use="optional"/>
			<xs:attribute name="phaseFirst" type="xs:string" use="optional"/>
			<xs:attribute name="phaseLast" type="xs:string" use="optional"/>
		</xs:complexType>
	</xs:element>

		<xs:complexType name="handlerType">
			<xs:sequence>
				<xs:element ref="order"/>
			</xs:sequence>
			<xs:attribute name="name" type="xs:string" use="required"/>
			<xs:attribute name="class" type="xs:string" use="required"/>
		</xs:complexType>

	<xs:element name="parameter">
		<xs:complexType>
			<xs:attribute name="name" type="xs:string" use="required"/>
			<xs:attribute name="locked" type="xs:boolean" use="optional" default="false"/>
		</xs:complexType>
	</xs:element>
	<xs:element name="operation">
		<xs:complexType>
			<xs:sequence>
				<xs:element name="messageReceiver" minOccurs="0">
					<xs:complexType>
						<xs:attribute name="class"/>
					</xs:complexType>
				</xs:element>
				<xs:element ref="parameter"/>
			</xs:sequence>
			<xs:attribute name="name" type="xs:string" use="required"/>
			<xs:attribute name="mep" type="xs:anyURI" use="required"/>
		</xs:complexType>
	</xs:element>
</xs:schema>
