<?xml version='1.0'?>
<!-- NOTE: this file is autogenerated by Apache XBean -->

<xs:schema elementFormDefault='qualified'
           targetNamespace='http://activemq.org/ra/1.0'
           xmlns:xs='http://www.w3.org/2001/XMLSchema'
           xmlns:tns='http://activemq.org/ra/1.0'>

  <!-- element for type: org.apache.activemq.ra.ActiveMQActivationSpec -->
  <xs:element name='activationSpec'>
    <xs:annotation>
      <xs:documentation><![CDATA[
        Configures the inbound JMS consumer specification using ActiveMQ
      ]]></xs:documentation>
    </xs:annotation>
    <xs:complexType>
      <xs:sequence>
        <xs:element name='activeMQDestination' minOccurs='0' maxOccurs='1'>
          <xs:annotation>
            <xs:documentation><![CDATA[
              A helper method mostly for use in Dependency Injection containers
which allows you to customize the destination and destinationType properties
from a single ActiveMQDestination POJO
            ]]></xs:documentation>
          </xs:annotation>
          <xs:complexType>
            <xs:sequence minOccurs='0' maxOccurs='1'><xs:any namespace='##other'/></xs:sequence>
          </xs:complexType>
        </xs:element>
        <xs:element name='resourceAdapter' minOccurs='0' maxOccurs='1'>
          <xs:complexType>
            <xs:choice minOccurs='0' maxOccurs='1'>
              <xs:element ref='tns:resourceAdapter'/>
              <xs:any namespace='##other'/>
            </xs:choice>
          </xs:complexType>
        </xs:element>
        <xs:any namespace='##other'/>
      </xs:sequence>
      <xs:attribute name='acknowledgeMode' type='xs:string'/>
      <xs:attribute name='activeMQDestination' type='xs:string'>
        <xs:annotation>
          <xs:documentation><![CDATA[
            A helper method mostly for use in Dependency Injection containers
which allows you to customize the destination and destinationType properties
from a single ActiveMQDestination POJO
          ]]></xs:documentation>
        </xs:annotation>
      </xs:attribute>
      <xs:attribute name='backOffMultiplier' type='xs:short'/>
      <xs:attribute name='clientId' type='xs:string'/>
      <xs:attribute name='destination' type='xs:string'/>
      <xs:attribute name='destinationType' type='xs:string'/>
      <xs:attribute name='enableBatch' type='xs:string'/>
      <xs:attribute name='initialRedeliveryDelay' type='xs:long'/>
      <xs:attribute name='maxMessagesPerBatch' type='xs:string'/>
      <xs:attribute name='maxMessagesPerSessions' type='xs:string'/>
      <xs:attribute name='maxSessions' type='xs:string'/>
      <xs:attribute name='maximumRedeliveries' type='xs:integer'/>
      <xs:attribute name='messageSelector' type='xs:string'/>
      <xs:attribute name='noLocal' type='xs:string'/>
      <xs:attribute name='password' type='xs:string'/>
      <xs:attribute name='resourceAdapter' type='xs:string'/>
      <xs:attribute name='subscriptionDurability' type='xs:string'/>
      <xs:attribute name='subscriptionName' type='xs:string'/>
      <xs:attribute name='useExponentialBackOff' type='xs:boolean'/>
      <xs:attribute name='useRAManagedTransaction' type='xs:string'/>
      <xs:attribute name='userName' type='xs:string'/>
      <xs:attribute name='id' type='xs:ID'/>
      <xs:anyAttribute namespace='##other' processContents='lax'/>
    </xs:complexType>
  </xs:element>


  <!-- element for type: org.apache.activemq.ra.ActiveMQManagedConnectionFactory -->
  <xs:element name='managedConnectionFactory'>
    <xs:complexType>
      <xs:sequence>
        <xs:element name='allPrefetchValues' minOccurs='0' maxOccurs='1'>
          <xs:complexType>
            <xs:sequence minOccurs='0' maxOccurs='1'><xs:any namespace='##other'/></xs:sequence>
          </xs:complexType>
        </xs:element>
        <xs:element name='durableTopicPrefetch' minOccurs='0' maxOccurs='1'>
          <xs:complexType>
            <xs:sequence minOccurs='0' maxOccurs='1'><xs:any namespace='##other'/></xs:sequence>
          </xs:complexType>
        </xs:element>
        <xs:element name='inputStreamPrefetch' minOccurs='0' maxOccurs='1'>
          <xs:complexType>
            <xs:sequence minOccurs='0' maxOccurs='1'><xs:any namespace='##other'/></xs:sequence>
          </xs:complexType>
        </xs:element>
        <xs:element name='logWriter' minOccurs='0' maxOccurs='1'>
          <xs:complexType>
            <xs:sequence minOccurs='0' maxOccurs='1'><xs:any namespace='##other'/></xs:sequence>
          </xs:complexType>
        </xs:element>
        <xs:element name='maximumRedeliveries' minOccurs='0' maxOccurs='1'>
          <xs:complexType>
            <xs:sequence minOccurs='0' maxOccurs='1'><xs:any namespace='##other'/></xs:sequence>
          </xs:complexType>
        </xs:element>
        <xs:element name='queueBrowserPrefetch' minOccurs='0' maxOccurs='1'>
          <xs:complexType>
            <xs:sequence minOccurs='0' maxOccurs='1'><xs:any namespace='##other'/></xs:sequence>
          </xs:complexType>
        </xs:element>
        <xs:element name='queuePrefetch' minOccurs='0' maxOccurs='1'>
          <xs:complexType>
            <xs:sequence minOccurs='0' maxOccurs='1'><xs:any namespace='##other'/></xs:sequence>
          </xs:complexType>
        </xs:element>
        <xs:element name='redeliveryUseExponentialBackOff' minOccurs='0' maxOccurs='1'>
          <xs:complexType>
            <xs:sequence minOccurs='0' maxOccurs='1'><xs:any namespace='##other'/></xs:sequence>
          </xs:complexType>
        </xs:element>
        <xs:element name='resourceAdapter' minOccurs='0' maxOccurs='1'>
          <xs:complexType>
            <xs:choice minOccurs='0' maxOccurs='1'>
              <xs:element ref='tns:resourceAdapter'/>
              <xs:any namespace='##other'/>
            </xs:choice>
          </xs:complexType>
        </xs:element>
        <xs:element name='topicPrefetch' minOccurs='0' maxOccurs='1'>
          <xs:complexType>
            <xs:sequence minOccurs='0' maxOccurs='1'><xs:any namespace='##other'/></xs:sequence>
          </xs:complexType>
        </xs:element>
        <xs:element name='useInboundSession' minOccurs='0' maxOccurs='1'>
          <xs:complexType>
            <xs:sequence minOccurs='0' maxOccurs='1'><xs:any namespace='##other'/></xs:sequence>
          </xs:complexType>
        </xs:element>
        <xs:any namespace='##other'/>
      </xs:sequence>
      <xs:attribute name='allPrefetchValues' type='xs:string'/>
      <xs:attribute name='clientid' type='xs:string'/>
      <xs:attribute name='durableTopicPrefetch' type='xs:string'/>
      <xs:attribute name='initialRedeliveryDelay' type='xs:long'/>
      <xs:attribute name='inputStreamPrefetch' type='xs:string'/>
      <xs:attribute name='logWriter' type='xs:string'/>
      <xs:attribute name='maximumRedeliveries' type='xs:string'/>
      <xs:attribute name='password' type='xs:string'/>
      <xs:attribute name='queueBrowserPrefetch' type='xs:string'/>
      <xs:attribute name='queuePrefetch' type='xs:string'/>
      <xs:attribute name='redeliveryBackOffMultiplier' type='xs:short'/>
      <xs:attribute name='redeliveryUseExponentialBackOff' type='xs:string'/>
      <xs:attribute name='resourceAdapter' type='xs:string'/>
      <xs:attribute name='topicPrefetch' type='xs:string'/>
      <xs:attribute name='useInboundSession' type='xs:string'/>
      <xs:attribute name='userName' type='xs:string'/>
      <xs:attribute name='id' type='xs:ID'/>
      <xs:anyAttribute namespace='##other' processContents='lax'/>
    </xs:complexType>
  </xs:element>


  <!-- element for type: org.apache.activemq.ra.ActiveMQResourceAdapter -->
  <xs:element name='resourceAdapter'>
    <xs:annotation>
      <xs:documentation><![CDATA[
        The JCA Resource Adaptor for ActiveMQ
      ]]></xs:documentation>
    </xs:annotation>
    <xs:complexType>
      <xs:sequence>
        <xs:element name='allPrefetchValues' minOccurs='0' maxOccurs='1'>
          <xs:complexType>
            <xs:sequence minOccurs='0' maxOccurs='1'><xs:any namespace='##other'/></xs:sequence>
          </xs:complexType>
        </xs:element>
        <xs:element name='connectionFactory' minOccurs='0' maxOccurs='1'>
          <xs:annotation>
            <xs:documentation><![CDATA[
              This allows a connection factory to be configured and shared between a ResourceAdaptor and outbound messaging.
Note that setting the connectionFactory will overload many of the properties on this POJO such as the redelivery
and prefetch policies; the properties on the connectionFactory will be used instead.
            ]]></xs:documentation>
          </xs:annotation>
          <xs:complexType>
            <xs:sequence minOccurs='0' maxOccurs='1'><xs:any namespace='##other'/></xs:sequence>
          </xs:complexType>
        </xs:element>
        <xs:element name='durableTopicPrefetch' minOccurs='0' maxOccurs='1'>
          <xs:complexType>
            <xs:sequence minOccurs='0' maxOccurs='1'><xs:any namespace='##other'/></xs:sequence>
          </xs:complexType>
        </xs:element>
        <xs:element name='inputStreamPrefetch' minOccurs='0' maxOccurs='1'>
          <xs:complexType>
            <xs:sequence minOccurs='0' maxOccurs='1'><xs:any namespace='##other'/></xs:sequence>
          </xs:complexType>
        </xs:element>
        <xs:element name='maximumRedeliveries' minOccurs='0' maxOccurs='1'>
          <xs:complexType>
            <xs:sequence minOccurs='0' maxOccurs='1'><xs:any namespace='##other'/></xs:sequence>
          </xs:complexType>
        </xs:element>
        <xs:element name='queueBrowserPrefetch' minOccurs='0' maxOccurs='1'>
          <xs:complexType>
            <xs:sequence minOccurs='0' maxOccurs='1'><xs:any namespace='##other'/></xs:sequence>
          </xs:complexType>
        </xs:element>
        <xs:element name='queuePrefetch' minOccurs='0' maxOccurs='1'>
          <xs:complexType>
            <xs:sequence minOccurs='0' maxOccurs='1'><xs:any namespace='##other'/></xs:sequence>
          </xs:complexType>
        </xs:element>
        <xs:element name='redeliveryUseExponentialBackOff' minOccurs='0' maxOccurs='1'>
          <xs:complexType>
            <xs:sequence minOccurs='0' maxOccurs='1'><xs:any namespace='##other'/></xs:sequence>
          </xs:complexType>
        </xs:element>
        <xs:element name='topicPrefetch' minOccurs='0' maxOccurs='1'>
          <xs:complexType>
            <xs:sequence minOccurs='0' maxOccurs='1'><xs:any namespace='##other'/></xs:sequence>
          </xs:complexType>
        </xs:element>
        <xs:element name='useInboundSession' minOccurs='0' maxOccurs='1'>
          <xs:complexType>
            <xs:sequence minOccurs='0' maxOccurs='1'><xs:any namespace='##other'/></xs:sequence>
          </xs:complexType>
        </xs:element>
        <xs:any namespace='##other'/>
      </xs:sequence>
      <xs:attribute name='allPrefetchValues' type='xs:string'/>
      <xs:attribute name='brokerXmlConfig' type='xs:string'>
        <xs:annotation>
          <xs:documentation><![CDATA[
            Sets the <a href="http://activemq.org/Xml+Configuration">XML
configuration file </a> used to configure the ActiveMQ broker via Spring
if using embedded mode.
          ]]></xs:documentation>
        </xs:annotation>
      </xs:attribute>
      <xs:attribute name='clientid' type='xs:string'/>
      <xs:attribute name='connectionFactory' type='xs:string'>
        <xs:annotation>
          <xs:documentation><![CDATA[
            This allows a connection factory to be configured and shared between a ResourceAdaptor and outbound messaging.
Note that setting the connectionFactory will overload many of the properties on this POJO such as the redelivery
and prefetch policies; the properties on the connectionFactory will be used instead.
          ]]></xs:documentation>
        </xs:annotation>
      </xs:attribute>
      <xs:attribute name='durableTopicPrefetch' type='xs:string'/>
      <xs:attribute name='initialRedeliveryDelay' type='xs:long'/>
      <xs:attribute name='inputStreamPrefetch' type='xs:string'/>
      <xs:attribute name='maximumRedeliveries' type='xs:string'/>
      <xs:attribute name='password' type='xs:string'/>
      <xs:attribute name='queueBrowserPrefetch' type='xs:string'/>
      <xs:attribute name='queuePrefetch' type='xs:string'/>
      <xs:attribute name='redeliveryBackOffMultiplier' type='xs:short'/>
      <xs:attribute name='redeliveryUseExponentialBackOff' type='xs:string'/>
      <xs:attribute name='serverUrl' type='xs:string'/>
      <xs:attribute name='topicPrefetch' type='xs:string'/>
      <xs:attribute name='useInboundSession' type='xs:string'/>
      <xs:attribute name='userName' type='xs:string'/>
      <xs:attribute name='id' type='xs:ID'/>
      <xs:anyAttribute namespace='##other' processContents='lax'/>
    </xs:complexType>
  </xs:element>


</xs:schema>
