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

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

  <!-- element for type: org.activemq.xbean.XBeanBrokerService -->
  <xs:element name='broker'>
    <xs:complexType>
      <xs:sequence>
        <xs:element name='abstractApplicationContext' minOccurs='0' maxOccurs='1'>
          <xs:complexType>
            <xs:sequence minOccurs='0' maxOccurs='1'><xs:any/></xs:sequence>
          </xs:complexType>
        </xs:element>
      </xs:sequence>
      <xs:attribute name='abstractApplicationContext' type='xs:string'/>
      <xs:attribute name='start' type='xs:boolean'/>
      <xs:anyAttribute namespace='##other' processContents='lax'/>
    </xs:complexType>
  </xs:element>


  <!-- element for type: org.activemq.network.DemandForwardingBridge -->
  <xs:element name='demandForwardingBridge'>
    <xs:complexType>
      <xs:sequence>
        <xs:element name='localBroker' minOccurs='0' maxOccurs='1'>
          <xs:complexType>
            <xs:sequence minOccurs='0' maxOccurs='1'><xs:any/></xs:sequence>
          </xs:complexType>
        </xs:element>
        <xs:element name='remoteBroker' minOccurs='0' maxOccurs='1'>
          <xs:complexType>
            <xs:sequence minOccurs='0' maxOccurs='1'><xs:any/></xs:sequence>
          </xs:complexType>
        </xs:element>
      </xs:sequence>
      <xs:attribute name='clientId' type='xs:string'/>
      <xs:attribute name='destinationFilter' type='xs:string'/>
      <xs:attribute name='dispatchAsync' type='xs:boolean'/>
      <xs:attribute name='localBroker' type='xs:string'/>
      <xs:attribute name='prefetchSize' type='xs:integer'/>
      <xs:attribute name='remoteBroker' type='xs:string'/>
      <xs:anyAttribute namespace='##other' processContents='lax'/>
    </xs:complexType>
  </xs:element>


  <!-- element for type: org.activemq.broker.region.policy.FixedSizedSubscriptionRecoveryPolicy -->
  <xs:element name='fixedSizedSubscriptionRecoveryPolicy'>
    <xs:complexType>
      <xs:sequence>
        <xs:element name='buffer' minOccurs='0' maxOccurs='1'>
          <xs:complexType>
            <xs:sequence minOccurs='0' maxOccurs='1'><xs:any/></xs:sequence>
          </xs:complexType>
        </xs:element>
      </xs:sequence>
      <xs:attribute name='buffer' type='xs:string'/>
      <xs:attribute name='maximumSize' type='xs:integer'/>
      <xs:attribute name='useSharedBuffer' type='xs:boolean'/>
      <xs:anyAttribute namespace='##other' processContents='lax'/>
    </xs:complexType>
  </xs:element>


  <!-- element for type: org.activemq.network.ForwardingBridge -->
  <xs:element name='forwardingBridge'>
    <xs:complexType>
      <xs:sequence>
        <xs:element name='localBroker' minOccurs='0' maxOccurs='1'>
          <xs:complexType>
            <xs:sequence minOccurs='0' maxOccurs='1'><xs:any/></xs:sequence>
          </xs:complexType>
        </xs:element>
        <xs:element name='remoteBroker' minOccurs='0' maxOccurs='1'>
          <xs:complexType>
            <xs:sequence minOccurs='0' maxOccurs='1'><xs:any/></xs:sequence>
          </xs:complexType>
        </xs:element>
      </xs:sequence>
      <xs:attribute name='clientId' type='xs:string'/>
      <xs:attribute name='destinationFilter' type='xs:string'/>
      <xs:attribute name='dispatchAsync' type='xs:boolean'/>
      <xs:attribute name='localBroker' type='xs:string'/>
      <xs:attribute name='prefetchSize' type='xs:integer'/>
      <xs:attribute name='remoteBroker' type='xs:string'/>
      <xs:anyAttribute namespace='##other' processContents='lax'/>
    </xs:complexType>
  </xs:element>


  <!-- element for type: org.activemq.network.jms.InboundQueueBridge -->
  <xs:element name='inboundQueueBridge'>
    <xs:complexType>
      <xs:attribute name='inboundQueueName' type='xs:string'/>
      <xs:anyAttribute namespace='##other' processContents='lax'/>
    </xs:complexType>
  </xs:element>


  <!-- element for type: org.activemq.network.jms.InboundTopicBridge -->
  <xs:element name='inboundTopicBridge'>
    <xs:complexType>
      <xs:attribute name='inboundTopicName' type='xs:string'/>
      <xs:anyAttribute namespace='##other' processContents='lax'/>
    </xs:complexType>
  </xs:element>


  <!-- element for type: org.activemq.store.jdbc.JDBCPersistenceAdapter -->
  <xs:element name='jdbcPersistenceAdapter'>
    <xs:complexType>
      <xs:sequence>
        <xs:element name='adapter' minOccurs='0' maxOccurs='1'>
          <xs:complexType>
            <xs:sequence minOccurs='0' maxOccurs='1'><xs:any/></xs:sequence>
          </xs:complexType>
        </xs:element>
        <xs:element name='dataSource' minOccurs='0' maxOccurs='1'>
          <xs:complexType>
            <xs:sequence minOccurs='0' maxOccurs='1'><xs:any/></xs:sequence>
          </xs:complexType>
        </xs:element>
        <xs:element name='ds' minOccurs='0' maxOccurs='1'>
          <xs:complexType>
            <xs:sequence minOccurs='0' maxOccurs='1'><xs:any/></xs:sequence>
          </xs:complexType>
        </xs:element>
        <xs:element name='scheduledThreadPoolExecutor' minOccurs='0' maxOccurs='1'>
          <xs:complexType>
            <xs:sequence minOccurs='0' maxOccurs='1'><xs:any/></xs:sequence>
          </xs:complexType>
        </xs:element>
        <xs:element name='wireFormat' minOccurs='0' maxOccurs='1'>
          <xs:complexType>
            <xs:sequence minOccurs='0' maxOccurs='1'><xs:any/></xs:sequence>
          </xs:complexType>
        </xs:element>
      </xs:sequence>
      <xs:attribute name='adapter' type='xs:string'/>
      <xs:attribute name='adapterClass' type='xs:string'/>
      <xs:attribute name='cleanupPeriod' type='xs:integer'/>
      <xs:attribute name='dataSource' type='xs:string'/>
      <xs:attribute name='ds' type='xs:string'/>
      <xs:attribute name='scheduledThreadPoolExecutor' type='xs:string'/>
      <xs:attribute name='useExternalMessageReferences' type='xs:boolean'/>
      <xs:attribute name='wireFormat' type='xs:string'/>
      <xs:anyAttribute namespace='##other' processContents='lax'/>
    </xs:complexType>
  </xs:element>


  <!-- element for type: org.activemq.network.jms.JmsQueueConnector -->
  <xs:element name='jmsQueueConnector'>
    <xs:complexType>
      <xs:sequence>
        <xs:element name='inboundQueueBridges' minOccurs='0' maxOccurs='1'>
          <xs:complexType>
            <xs:sequence minOccurs='0' maxOccurs='unbounded'><xs:any/></xs:sequence>
          </xs:complexType>
        </xs:element>
        <xs:element name='localQueueConnection' minOccurs='0' maxOccurs='1'>
          <xs:complexType>
            <xs:sequence minOccurs='0' maxOccurs='1'><xs:any/></xs:sequence>
          </xs:complexType>
        </xs:element>
        <xs:element name='localQueueConnectionFactory' minOccurs='0' maxOccurs='1'>
          <xs:complexType>
            <xs:sequence minOccurs='0' maxOccurs='1'><xs:any/></xs:sequence>
          </xs:complexType>
        </xs:element>
        <xs:element name='outboundQueueBridges' minOccurs='0' maxOccurs='1'>
          <xs:complexType>
            <xs:sequence minOccurs='0' maxOccurs='unbounded'><xs:any/></xs:sequence>
          </xs:complexType>
        </xs:element>
        <xs:element name='outboundQueueConnection' minOccurs='0' maxOccurs='1'>
          <xs:complexType>
            <xs:sequence minOccurs='0' maxOccurs='1'><xs:any/></xs:sequence>
          </xs:complexType>
        </xs:element>
        <xs:element name='outboundQueueConnectionFactory' minOccurs='0' maxOccurs='1'>
          <xs:complexType>
            <xs:sequence minOccurs='0' maxOccurs='1'><xs:any/></xs:sequence>
          </xs:complexType>
        </xs:element>
      </xs:sequence>
      <xs:attribute name='localConnectionFactoryName' type='xs:string'/>
      <xs:attribute name='localPassword' type='xs:string'/>
      <xs:attribute name='localQueueConnection' type='xs:string'/>
      <xs:attribute name='localQueueConnectionFactory' type='xs:string'/>
      <xs:attribute name='localUsername' type='xs:string'/>
      <xs:attribute name='outboundPassword' type='xs:string'/>
      <xs:attribute name='outboundQueueConnection' type='xs:string'/>
      <xs:attribute name='outboundQueueConnectionFactory' type='xs:string'/>
      <xs:attribute name='outboundQueueConnectionFactoryName' type='xs:string'/>
      <xs:attribute name='outboundUsername' type='xs:string'/>
      <xs:attribute name='replyToDestinationCacheSize' type='xs:integer'/>
      <xs:anyAttribute namespace='##other' processContents='lax'/>
    </xs:complexType>
  </xs:element>


  <!-- element for type: org.activemq.network.jms.JmsTopicConnector -->
  <xs:element name='jmsTopicConnector'>
    <xs:complexType>
      <xs:sequence>
        <xs:element name='inboundTopicBridges' minOccurs='0' maxOccurs='1'>
          <xs:complexType>
            <xs:sequence minOccurs='0' maxOccurs='unbounded'><xs:any/></xs:sequence>
          </xs:complexType>
        </xs:element>
        <xs:element name='localTopicConnection' minOccurs='0' maxOccurs='1'>
          <xs:complexType>
            <xs:sequence minOccurs='0' maxOccurs='1'><xs:any/></xs:sequence>
          </xs:complexType>
        </xs:element>
        <xs:element name='localTopicConnectionFactory' minOccurs='0' maxOccurs='1'>
          <xs:complexType>
            <xs:sequence minOccurs='0' maxOccurs='1'><xs:any/></xs:sequence>
          </xs:complexType>
        </xs:element>
        <xs:element name='outboundTopicBridges' minOccurs='0' maxOccurs='1'>
          <xs:complexType>
            <xs:sequence minOccurs='0' maxOccurs='unbounded'><xs:any/></xs:sequence>
          </xs:complexType>
        </xs:element>
        <xs:element name='outboundTopicConnection' minOccurs='0' maxOccurs='1'>
          <xs:complexType>
            <xs:sequence minOccurs='0' maxOccurs='1'><xs:any/></xs:sequence>
          </xs:complexType>
        </xs:element>
        <xs:element name='outboundTopicConnectionFactory' minOccurs='0' maxOccurs='1'>
          <xs:complexType>
            <xs:sequence minOccurs='0' maxOccurs='1'><xs:any/></xs:sequence>
          </xs:complexType>
        </xs:element>
      </xs:sequence>
      <xs:attribute name='localConnectionFactoryName' type='xs:string'/>
      <xs:attribute name='localPassword' type='xs:string'/>
      <xs:attribute name='localTopicConnection' type='xs:string'/>
      <xs:attribute name='localTopicConnectionFactory' type='xs:string'/>
      <xs:attribute name='localUsername' type='xs:string'/>
      <xs:attribute name='outboundPassword' type='xs:string'/>
      <xs:attribute name='outboundTopicConnection' type='xs:string'/>
      <xs:attribute name='outboundTopicConnectionFactory' type='xs:string'/>
      <xs:attribute name='outboundTopicConnectionFactoryName' type='xs:string'/>
      <xs:attribute name='outboundUsername' type='xs:string'/>
      <xs:attribute name='replyToDestinationCacheSize' type='xs:integer'/>
      <xs:anyAttribute namespace='##other' processContents='lax'/>
    </xs:complexType>
  </xs:element>


  <!-- element for type: org.activemq.store.journal.JournalPersistenceAdapter -->
  <xs:element name='journalPersistenceAdapter'>
    <xs:complexType>
      <xs:sequence>
        <xs:element name='journal' minOccurs='0' maxOccurs='1'>
          <xs:complexType>
            <xs:sequence minOccurs='0' maxOccurs='1'><xs:any/></xs:sequence>
          </xs:complexType>
        </xs:element>
        <xs:element name='longTermPersistence' minOccurs='0' maxOccurs='1'>
          <xs:complexType>
            <xs:sequence minOccurs='0' maxOccurs='1'><xs:any/></xs:sequence>
          </xs:complexType>
        </xs:element>
        <xs:element name='memManager' minOccurs='0' maxOccurs='1'>
          <xs:complexType>
            <xs:sequence minOccurs='0' maxOccurs='1'><xs:any/></xs:sequence>
          </xs:complexType>
        </xs:element>
        <xs:element name='taskRunnerFactory' minOccurs='0' maxOccurs='1'>
          <xs:complexType>
            <xs:sequence minOccurs='0' maxOccurs='1'><xs:any/></xs:sequence>
          </xs:complexType>
        </xs:element>
      </xs:sequence>
      <xs:attribute name='journal' type='xs:string'/>
      <xs:attribute name='longTermPersistence' type='xs:string'/>
      <xs:attribute name='maxCheckpointMessageAddSize' type='xs:integer'/>
      <xs:attribute name='maxCheckpointWorkers' type='xs:integer'/>
      <xs:attribute name='memManager' type='xs:string'/>
      <xs:attribute name='taskRunnerFactory' type='xs:string'/>
      <xs:attribute name='useExternalMessageReferences' type='xs:boolean'/>
      <xs:anyAttribute namespace='##other' processContents='lax'/>
    </xs:complexType>
  </xs:element>


  <!-- element for type: org.activemq.store.PersistenceAdapterFactoryBean -->
  <xs:element name='journaledJDBC'>
    <xs:complexType>
      <xs:anyAttribute namespace='##other' processContents='lax'/>
    </xs:complexType>
  </xs:element>


  <!-- element for type: org.activemq.broker.region.policy.LastImageSubscriptionRecoveryPolicy -->
  <xs:element name='lastImageSubscriptionRecoveryPolicy'>
    <xs:complexType>
      <xs:anyAttribute namespace='##other' processContents='lax'/>
    </xs:complexType>
  </xs:element>


  <!-- element for type: org.activemq.broker.jmx.ManagementContext -->
  <xs:element name='managementContext'>
    <xs:complexType>
      <xs:sequence>
        <xs:element name='server' minOccurs='0' maxOccurs='1'>
          <xs:complexType>
            <xs:sequence minOccurs='0' maxOccurs='1'><xs:any/></xs:sequence>
          </xs:complexType>
        </xs:element>
      </xs:sequence>
      <xs:attribute name='connectorPath' type='xs:string'/>
      <xs:attribute name='connectorPort' type='xs:integer'/>
      <xs:attribute name='createConnector' type='xs:boolean'/>
      <xs:attribute name='createMBeanServer' type='xs:boolean'/>
      <xs:attribute name='jmxDomainName' type='xs:string'/>
      <xs:attribute name='server' type='xs:string'/>
      <xs:attribute name='useMBeanServer' type='xs:boolean'/>
      <xs:anyAttribute namespace='##other' processContents='lax'/>
    </xs:complexType>
  </xs:element>


  <!-- element for type: org.activemq.store.memory.MemoryPersistenceAdapter -->
  <xs:element name='memoryPersistenceAdapter'>
    <xs:complexType>
      <xs:attribute name='useExternalMessageReferences' type='xs:boolean'/>
      <xs:anyAttribute namespace='##other' processContents='lax'/>
    </xs:complexType>
  </xs:element>


  <!-- element for type: org.activemq.network.NetworkConnector -->
  <xs:element name='networkConnector'>
    <xs:complexType>
      <xs:sequence>
        <xs:element name='discoveryAgent' minOccurs='0' maxOccurs='1'>
          <xs:complexType>
            <xs:sequence minOccurs='0' maxOccurs='1'><xs:any/></xs:sequence>
          </xs:complexType>
        </xs:element>
      </xs:sequence>
      <xs:attribute name='brokerName' type='xs:string'/>
      <xs:attribute name='discoveryAgent' type='xs:string'/>
      <xs:attribute name='localURI' type='xsd:string'/>
      <xs:attribute name='localUri' type='xsd:string'/>
      <xs:attribute name='uri' type='xsd:string'/>
      <xs:anyAttribute namespace='##other' processContents='lax'/>
    </xs:complexType>
  </xs:element>


  <!-- element for type: org.activemq.broker.region.policy.NoSubscriptionRecoveryPolicy -->
  <xs:element name='noSubscriptionRecoveryPolicy'>
    <xs:complexType>
      <xs:anyAttribute namespace='##other' processContents='lax'/>
    </xs:complexType>
  </xs:element>


  <!-- element for type: org.activemq.network.jms.OutboundQueueBridge -->
  <xs:element name='outboundQueueBridge'>
    <xs:complexType>
      <xs:attribute name='outboundQueueName' type='xs:string'/>
      <xs:anyAttribute namespace='##other' processContents='lax'/>
    </xs:complexType>
  </xs:element>


  <!-- element for type: org.activemq.network.jms.OutboundTopicBridge -->
  <xs:element name='outboundTopicBridge'>
    <xs:complexType>
      <xs:attribute name='outboundTopicName' type='xs:string'/>
      <xs:anyAttribute namespace='##other' processContents='lax'/>
    </xs:complexType>
  </xs:element>


  <!-- element for type: org.activemq.broker.region.policy.PolicyEntry -->
  <xs:element name='policyEntry'>
    <xs:complexType>
      <xs:sequence>
        <xs:element name='dispatchPolicy' minOccurs='0' maxOccurs='1'>
          <xs:complexType>
            <xs:sequence minOccurs='0' maxOccurs='1'><xs:any/></xs:sequence>
          </xs:complexType>
        </xs:element>
        <xs:element name='redeliveryPolicy' minOccurs='0' maxOccurs='1'>
          <xs:complexType>
            <xs:sequence minOccurs='0' maxOccurs='1'><xs:any/></xs:sequence>
          </xs:complexType>
        </xs:element>
        <xs:element name='subscriptionRecoveryPolicy' minOccurs='0' maxOccurs='1'>
          <xs:complexType>
            <xs:sequence minOccurs='0' maxOccurs='1'><xs:any/></xs:sequence>
          </xs:complexType>
        </xs:element>
      </xs:sequence>
      <xs:attribute name='dispatchPolicy' type='xs:string'/>
      <xs:attribute name='redeliveryPolicy' type='xs:string'/>
      <xs:attribute name='subscriptionRecoveryPolicy' type='xs:string'/>
      <xs:anyAttribute namespace='##other' processContents='lax'/>
    </xs:complexType>
  </xs:element>


  <!-- element for type: org.activemq.broker.region.policy.PolicyMap -->
  <xs:element name='policyMap'>
    <xs:complexType>
      <xs:sequence>
        <xs:element name='defaultEntry' minOccurs='0' maxOccurs='1'>
          <xs:complexType>
            <xs:sequence minOccurs='0' maxOccurs='1'><xs:any/></xs:sequence>
          </xs:complexType>
        </xs:element>
        <xs:element name='policyEntries' minOccurs='0' maxOccurs='1'>
          <xs:complexType>
            <xs:sequence minOccurs='0' maxOccurs='unbounded'><xs:any/></xs:sequence>
          </xs:complexType>
        </xs:element>
      </xs:sequence>
      <xs:attribute name='defaultEntry' type='xs:string'/>
      <xs:anyAttribute namespace='##other' processContents='lax'/>
    </xs:complexType>
  </xs:element>


  <!-- element for type: org.activemq.proxy.ProxyConnector -->
  <xs:element name='proxyConnector'>
    <xs:complexType>
      <xs:sequence>
        <xs:element name='server' minOccurs='0' maxOccurs='1'>
          <xs:complexType>
            <xs:sequence minOccurs='0' maxOccurs='1'><xs:any/></xs:sequence>
          </xs:complexType>
        </xs:element>
      </xs:sequence>
      <xs:attribute name='bind' type='xsd:string'/>
      <xs:attribute name='localUri' type='xsd:string'/>
      <xs:attribute name='remote' type='xsd:string'/>
      <xs:attribute name='server' type='xs:string'/>
      <xs:anyAttribute namespace='##other' processContents='lax'/>
    </xs:complexType>
  </xs:element>


  <!-- element for type: org.activemq.store.journal.QuickJournalPersistenceAdapter -->
  <xs:element name='quickJournalPersistenceAdapter'>
    <xs:complexType>
      <xs:sequence>
        <xs:element name='journal' minOccurs='0' maxOccurs='1'>
          <xs:complexType>
            <xs:sequence minOccurs='0' maxOccurs='1'><xs:any/></xs:sequence>
          </xs:complexType>
        </xs:element>
        <xs:element name='longTermPersistence' minOccurs='0' maxOccurs='1'>
          <xs:complexType>
            <xs:sequence minOccurs='0' maxOccurs='1'><xs:any/></xs:sequence>
          </xs:complexType>
        </xs:element>
        <xs:element name='memManager' minOccurs='0' maxOccurs='1'>
          <xs:complexType>
            <xs:sequence minOccurs='0' maxOccurs='1'><xs:any/></xs:sequence>
          </xs:complexType>
        </xs:element>
        <xs:element name='taskRunnerFactory' minOccurs='0' maxOccurs='1'>
          <xs:complexType>
            <xs:sequence minOccurs='0' maxOccurs='1'><xs:any/></xs:sequence>
          </xs:complexType>
        </xs:element>
      </xs:sequence>
      <xs:attribute name='journal' type='xs:string'/>
      <xs:attribute name='longTermPersistence' type='xs:string'/>
      <xs:attribute name='maxCheckpointMessageAddSize' type='xs:integer'/>
      <xs:attribute name='maxCheckpointWorkers' type='xs:integer'/>
      <xs:attribute name='memManager' type='xs:string'/>
      <xs:attribute name='taskRunnerFactory' type='xs:string'/>
      <xs:attribute name='useExternalMessageReferences' type='xs:boolean'/>
      <xs:anyAttribute namespace='##other' processContents='lax'/>
    </xs:complexType>
  </xs:element>


  <!-- element for type: org.activemq.broker.region.policy.RoundRobinDispatchPolicy -->
  <xs:element name='roundRobinDispatchPolicy'>
    <xs:complexType>
      <xs:anyAttribute namespace='##other' processContents='lax'/>
    </xs:complexType>
  </xs:element>


  <!-- element for type: org.activemq.broker.region.policy.SimpleDispatchPolicy -->
  <xs:element name='simpleDispatchPolicy'>
    <xs:complexType>
      <xs:anyAttribute namespace='##other' processContents='lax'/>
    </xs:complexType>
  </xs:element>


  <!-- element for type: org.activemq.network.jms.SimpleJmsMessageConvertor -->
  <xs:element name='simpleJmsMessageConvertor'>
    <xs:complexType>
      <xs:anyAttribute namespace='##other' processContents='lax'/>
    </xs:complexType>
  </xs:element>


  <!-- element for type: org.activemq.broker.region.policy.StrictOrderDispatchPolicy -->
  <xs:element name='strictOrderDispatchPolicy'>
    <xs:complexType>
      <xs:anyAttribute namespace='##other' processContents='lax'/>
    </xs:complexType>
  </xs:element>


  <!-- element for type: org.activemq.broker.region.policy.TimedSubscriptionRecoveryPolicy -->
  <xs:element name='timedSubscriptionRecoveryPolicy'>
    <xs:complexType>
      <xs:attribute name='recoverDuration' type='xs:long'/>
      <xs:anyAttribute namespace='##other' processContents='lax'/>
    </xs:complexType>
  </xs:element>


  <!-- element for type: org.activemq.broker.TransportConnector -->
  <xs:element name='transportConnector'>
    <xs:complexType>
      <xs:sequence>
        <xs:element name='broker' minOccurs='0' maxOccurs='1'>
          <xs:complexType>
            <xs:sequence minOccurs='0' maxOccurs='1'><xs:any/></xs:sequence>
          </xs:complexType>
        </xs:element>
        <xs:element name='brokerInfo' minOccurs='0' maxOccurs='1'>
          <xs:complexType>
            <xs:sequence minOccurs='0' maxOccurs='1'><xs:any/></xs:sequence>
          </xs:complexType>
        </xs:element>
        <xs:element name='server' minOccurs='0' maxOccurs='1'>
          <xs:complexType>
            <xs:sequence minOccurs='0' maxOccurs='1'><xs:any/></xs:sequence>
          </xs:complexType>
        </xs:element>
        <xs:element name='taskRunnerFactory' minOccurs='0' maxOccurs='1'>
          <xs:complexType>
            <xs:sequence minOccurs='0' maxOccurs='1'><xs:any/></xs:sequence>
          </xs:complexType>
        </xs:element>
      </xs:sequence>
      <xs:attribute name='broker' type='xs:string'/>
      <xs:attribute name='brokerInfo' type='xs:string'/>
      <xs:attribute name='brokerName' type='xs:string'/>
      <xs:attribute name='server' type='xs:string'/>
      <xs:attribute name='taskRunnerFactory' type='xs:string'/>
      <xs:attribute name='uri' type='xsd:string'/>
      <xs:anyAttribute namespace='##other' processContents='lax'/>
    </xs:complexType>
  </xs:element>


  <!-- element for type: org.activemq.memory.UsageManager -->
  <xs:element name='usageManager'>
    <xs:complexType>
      <xs:sequence>
        <xs:element name='parent' minOccurs='0' maxOccurs='1'>
          <xs:complexType>
            <xs:sequence minOccurs='0' maxOccurs='1'><xs:any/></xs:sequence>
          </xs:complexType>
        </xs:element>
      </xs:sequence>
      <xs:attribute name='limit' type='xs:long'/>
      <xs:attribute name='parent' type='xs:string'/>
      <xs:attribute name='percentUsage' type='xs:integer'/>
      <xs:attribute name='percentUsageMinDelta' type='xs:integer'/>
      <xs:anyAttribute namespace='##other' processContents='lax'/>
    </xs:complexType>
  </xs:element>


</xs:schema>
