<!--
	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.
-->
<xs:schema targetNamespace="org.apache.felix.ipojo.extender"
	xmlns="org.apache.felix.ipojo.extender"
	xmlns:xs="http://www.w3.org/2001/XMLSchema"
	elementFormDefault="qualified">
	<xs:element name="extender" type="ExtenderType"></xs:element>
	<xs:complexType name="ExtenderType">
		<xs:attribute name="onArrival" type="xs:string" use="required"></xs:attribute>
		<xs:attribute name="onDeparture" type="xs:string" use="required"></xs:attribute>
		<xs:attribute name="extension" type="xs:string" use="required"></xs:attribute>
	</xs:complexType>	
</xs:schema>