<?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.
-->
<xsd:schema xmlns="http://activemq.apache.org/camel/schema/spring/integration"
  xmlns:xsd="http://www.w3.org/2001/XMLSchema"
  xmlns:beans="http://www.springframework.org/schema/beans"
  xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xmlns:camel-spring="http://activemq.apache.org/camel/schema/spring"
  targetNamespace="http://activemq.apache.org/camel/schema/spring/integration"
  elementFormDefault="qualified"
  attributeFormDefault="unqualified">

  <xsd:import namespace="http://www.springframework.org/schema/beans" schemaLocation="http://www.springframework.org/schema/beans/spring-beans.xsd"/>
  <xsd:import namespace="http://activemq.apache.org/camel/schema/spring" schemaLocation="http://activemq.apache.org/camel/schema/spring/camel-spring.xsd"/>

  <xsd:complexType name="camelEndpointType">
  	<xsd:sequence>
  		<xsd:element ref="camel-spring:camelContext" minOccurs="0" />
  		<xsd:element name="camelContextRef" type="xsd:string" minOccurs="0" />
  	</xsd:sequence>
  	<xsd:attribute name="id" type="xsd:ID" use="required" />
  	<xsd:attribute name="camelEndpointUri" type="xsd:string" />
  	<xsd:attribute name="requestChannel" type="xsd:string" use="required" />
  	<xsd:attribute name="replyChannel" type="xsd:string" />
  	<xsd:attribute name="expectReply" type="xsd:boolean" default="true"/>
  </xsd:complexType>

  <xsd:element name="camelSource">
     <xsd:complexType>
        <xsd:annotation>
			<xsd:documentation>
	          Defines a camel-source for handling the Camel context message in Spring Integration message bus.
			</xsd:documentation>
		</xsd:annotation>
        <xsd:complexContent>
          <xsd:extension base="camelEndpointType">
	       <xsd:attribute name="requestTimeout" type="xsd:long"/>
		   <xsd:attribute name="replyTimeout" type="xsd:long"/>
		  </xsd:extension>
		</xsd:complexContent>
     </xsd:complexType>
  </xsd:element>

  <xsd:element name="camelTarget" type="camelEndpointType">
        <xsd:annotation>
			<xsd:documentation>
	          Defines a camel-target to feed Spring Integration message to the Camel context.
			</xsd:documentation>
		</xsd:annotation>
  </xsd:element>
</xsd:schema>
