Schema "mule.xsd"
Target Namespace:
http://www.mulesoft.org/schema/mule/core
Defined Components:
258 global elements, 56 local elements, 253 complexTypes, 16 simpleTypes, 13 element groups, 14 attribute groups
Default Namespace-Qualified Form:
Local Elements: qualified; Local Attributes: unqualified
Schema Location:
http://www.mulesoft.org/schema/mule/core/3.3/mule.xsd; see XML source
Imports Schemas (3):
spring-beans-3.1.xsd [src], spring-context-3.1.xsd [src], xml.xsd [src]
Imported by Schemas (51):
_mule-all-included.xsd, mule-ajax.xsd [src], mule-atom.xsd [src], mule-axis.xsd [src], mule-bpm.xsd [src], mule-client.xsd [src], mule-cxf.xsd [src], mule-ejb.xsd [src], mule-email.xsd [src], mule-file.xsd [src], mule-ftp.xsd [src], mule-http.xsd [src], mule-https.xsd [src], mule-imap.xsd [src], mule-imaps.xsd [src], mule-jaas.xsd [src], mule-jbossts.xsd [src], mule-jdbc.xsd [src], mule-jersey.xsd [src], mule-jetty-ssl.xsd [src], mule-jetty.xsd [src], mule-jms.xsd [src], mule-jnp.xsd [src], mule-json.xsd [src], mule-management.xsd [src], mule-multicast.xsd [src], mule-ognl.xsd [src], mule-pattern.xsd [src], mule-pgp.xsd [src], mule-pop3.xsd [src], mule-pop3s.xsd [src], mule-quartz.xsd [src], mule-rmi.xsd [src], mule-rss.xsd [src], mule-scripting.xsd [src], mule-servlet.xsd [src], mule-sftp.xsd [src], mule-smtp.xsd [src], mule-smtps.xsd [src], mule-spring-security.xsd [src], mule-ssl.xsd [src], mule-stdio.xsd [src], mule-sxc.xsd [src], mule-tcp.xsd [src], mule-test.xsd [src], mule-tls.xsd [src], mule-udp.xsd [src], mule-vm.xsd [src], mule-ws.xsd [src], mule-xml.xsd [src], mule-xmpp.xsd [src]
All Element Summary
abstract-agent A placeholder for agent elements.
Type:
Content:
complex, attr. wildcard, 1 element
Abstract:
(may not be used directly in instance XML documents)
Subst.Gr:
may be substituted with 12 elements
Defined:
globally; see XML source
Used:
at 13 locations
abstract-async-reply-router A placeholder for an async reply router element.
Type:
Content:
empty
Abstract:
(may not be used directly in instance XML documents)
Subst.Gr:
may be substituted with 3 elements
Defined:
globally; see XML source
Used:
abstract-caching-strategy A placeholder for caching strategies elements.
Type:
Content:
complex, 1 attribute, attr. wildcard, 1 element
Abstract:
(may not be used directly in instance XML documents)
Subst.Gr:
affiliated to substitution group abstract-extension
Defined:
globally; see XML source
Used:
never
abstract-catch-all-strategy A placeholder for catch-all strategy elements.
Type:
Content:
empty
Abstract:
(may not be used directly in instance XML documents)
Subst.Gr:
may be substituted with 4 elements
Defined:
globally; see XML source
Used:
abstract-component A placeholder for a component element.
Type:
Content:
complex, attr. wildcard, 3 elements
Abstract:
(may not be used directly in instance XML documents)
Subst.Gr:
affiliated to substitution group abstract-message-processor; may be substituted with 16 elements
Defined:
globally; see XML source
Used:
at 19 locations
abstract-connector A placeholder for connector elements.
Type:
Content:
complex, 1 attribute, attr. wildcard, 1 element
Abstract:
(may not be used directly in instance XML documents)
Subst.Gr:
may be substituted with 44 elements
Defined:
globally; see XML source
Used:
at 45 locations
abstract-entry-point-resolver A placeholder for an entry point resolver element.
Type:
Content:
empty
Abstract:
(may not be used directly in instance XML documents)
Subst.Gr:
may be substituted with 7 elements
Defined:
globally; see XML source
Used:
abstract-entry-point-resolver-set A placeholder for entry point resolver set elements.
Type:
Content:
empty
Abstract:
(may not be used directly in instance XML documents)
Subst.Gr:
may be substituted with 3 elements
Defined:
globally; see XML source
Used:
abstract-exception-strategy A placeholder for an exception strategy element.
Type:
Content:
complex, attr. wildcard, 1 element
Abstract:
(may not be used directly in instance XML documents)
Subst.Gr:
affiliated to substitution group legacy-abstract-exception-strategy; may be substituted with 5 elements
Defined:
globally; see XML source
Used:
abstract-extension A placeholder for arbitrary extensions as children of the 'mule' element.
Type:
Content:
complex, attr. wildcard, 1 element
Abstract:
(may not be used directly in instance XML documents)
Subst.Gr:
may be substituted with 11 elements
Defined:
globally; see XML source
Used:
at 13 locations
abstract-filter A placeholder for filter elements, which control which messages are handled.
Type:
Content:
complex, attr. wildcard, 1 element
Abstract:
(may not be used directly in instance XML documents)
Subst.Gr:
affiliated to substitution group abstract-message-processor; may be substituted with 30 elements
Defined:
globally; see XML source
Used:
at 40 locations
abstract-flow-construct A placeholder for a flow construct element.
Type:
Content:
complex, 3 attributes, attr. wildcard, 1 element
Abstract:
(may not be used directly in instance XML documents)
Subst.Gr:
may be substituted with 9 elements
Defined:
globally; see XML source
Used:
at 10 locations
abstract-global-endpoint A placeholder for global endpoint elements.
Type:
Content:
complex, 1 attribute, attr. wildcard, 1 element
Abstract:
(may not be used directly in instance XML documents)
Subst.Gr:
may be substituted with 32 elements
Defined:
globally; see XML source
Used:
at 33 locations
abstract-global-intercepting-message-processor A placeholder for intercepting router elements.
Type:
Content:
complex, 1 attribute, attr. wildcard, 1 element
Abstract:
(may not be used directly in instance XML documents)
Subst.Gr:
affiliated to substitution group abstract-intercepting-message-processor; may be substituted with 4 elements
Defined:
globally; see XML source
Used:
abstract-inbound-endpoint A placeholder for inbound endpoint elements.
Type:
Content:
complex, 1 attribute, attr. wildcard, 1 element
Abstract:
(may not be used directly in instance XML documents)
Subst.Gr:
may be substituted with 30 elements
Defined:
globally; see XML source
Used:
at 40 locations
abstract-inbound-router A placeholder for inbound router elements, which control how incoming messages are handled.
Type:
Content:
complex, attr. wildcard, 1 element
Abstract:
(may not be used directly in instance XML documents)
Subst.Gr:
may be substituted with 10 elements
Defined:
globally; see XML source
Used:
at 12 locations
abstract-intercepting-message-processor A placeholder for intercepting router elements.
Type:
Content:
complex, attr. wildcard, 1 element
Abstract:
(may not be used directly in instance XML documents)
Subst.Gr:
affiliated to substitution group abstract-message-processor; may be substituted with 23 elements
Defined:
globally; see XML source
Used:
at 21 locations
abstract-interceptor A placeholder for an interceptor element.
Type:
Content:
complex, attr. wildcard, 1 element
Abstract:
(may not be used directly in instance XML documents)
Subst.Gr:
affiliated to substitution group abstract-message-processor; may be substituted with 3 elements
Defined:
globally; see XML source
Used:
abstract-interceptor-stack A placeholder for interceptor stack elements.
Type:
Content:
complex, 1 attribute, attr. wildcard, 2 elements
Abstract:
(may not be used directly in instance XML documents)
Subst.Gr:
may be substituted with 1 element
Defined:
globally; see XML source
Used:
abstract-lifecycle-adapter-factory
Type:
Content:
empty
Abstract:
(may not be used directly in instance XML documents)
Subst.Gr:
may be substituted with 1 element
Defined:
globally; see XML source
Used:
abstract-message-info-mapping Maps the attributes of the current message to known message elements in Mule, namely Message ID and CorrrelationID.
Type:
Content:
empty
Abstract:
(may not be used directly in instance XML documents)
Subst.Gr:
may be substituted with 2 elements
Defined:
globally; see XML source
Used:
abstract-message-processor A placeholder for message processor elements.
Type:
Content:
complex, attr. wildcard, 1 element
Abstract:
(may not be used directly in instance XML documents)
Subst.Gr:
may be substituted with 181 elements
Defined:
globally; see XML source
Used:
at 22 locations
abstract-message-source A placeholder for message source elements.
Type:
Content:
complex, attr. wildcard, 1 element
Abstract:
(may not be used directly in instance XML documents)
Subst.Gr:
may be substituted with 3 elements
Defined:
globally; see XML source
Used:
abstract-mixed-content-extension A placeholder for arbitrary extensions as children of the 'mule' element.
Type:
Content:
mixed (allows character data), attr. wildcard, 1 element
Abstract:
(may not be used directly in instance XML documents)
Subst.Gr:
may be substituted with 3 elements
Defined:
globally; see XML source
Used:
abstract-mixed-content-message-processor A placeholder for message processor elements.
Type:
Content:
complex, attr. wildcard, 1 element
Abstract:
(may not be used directly in instance XML documents)
Subst.Gr:
may be substituted with 1 element
Defined:
globally; see XML source
Used:
abstract-model A placeholder for model elements.
Type:
Content:
complex, 1 attribute, attr. wildcard, 5 elements
Abstract:
(may not be used directly in instance XML documents)
Subst.Gr:
may be substituted with 2 elements
Defined:
globally; see XML source
Used:
abstract-multi-transaction A placeholder for multi-transaction elements.
Type:
Content:
empty, 2 attributes
Abstract:
(may not be used directly in instance XML documents)
Defined:
globally; see XML source
Used:
abstract-object-factory
Type:
Content:
complex, 2 elements
Abstract:
(may not be used directly in instance XML documents)
Subst.Gr:
may be substituted with 3 elements
Defined:
globally; see XML source
Used:
abstract-object-store A placeholder for an object store that can be used by routers to maintain state.
Type:
Content:
empty
Abstract:
(may not be used directly in instance XML documents)
Subst.Gr:
may be substituted with 6 elements
Defined:
globally; see XML source
Used:
abstract-observer-message-processor A placeholder for message processors that observe the message but do not mutate it used for exmaple for logging.
Type:
Content:
complex, attr. wildcard, 1 element
Abstract:
(may not be used directly in instance XML documents)
Subst.Gr:
affiliated to substitution group abstract-message-processor; may be substituted with 1 element
Defined:
globally; see XML source
Used:
abstract-outbound-endpoint A placeholder for outbound endpoint elements.
Type:
Content:
complex, 1 attribute, attr. wildcard, 1 element
Abstract:
(may not be used directly in instance XML documents)
Subst.Gr:
may be substituted with 25 elements
Defined:
globally; see XML source
Used:
at 39 locations
abstract-outbound-router A placeholder for outbound router elements, which control how outgoing messages are delivered to the outbound endpoints.
Type:
Content:
complex, attr. wildcard, 1 element
Abstract:
(may not be used directly in instance XML documents)
Subst.Gr:
may be substituted with 17 elements
Defined:
globally; see XML source
Used:
at 18 locations
abstract-pooling-profile
Type:
Content:
empty
Abstract:
(may not be used directly in instance XML documents)
Subst.Gr:
may be substituted with 1 element
Defined:
globally; see XML source
Used:
abstract-processing-strategy The processing strategy to be used for processing a pipeline of message processors (e.g. in a Flow)
Type:
Content:
complex, 1 attribute, attr. wildcard, 1 element
Abstract:
(may not be used directly in instance XML documents)
Subst.Gr:
may be substituted with 5 elements
Defined:
globally; see XML source
Used:
abstract-queue-profile A placeholder for a queue profile, which controls how messages are queued.
Type:
Content:
empty
Abstract:
(may not be used directly in instance XML documents)
Subst.Gr:
may be substituted with 1 element
Defined:
globally; see XML source
Used:
abstract-queue-store A placeholder for queue store elements.
Type:
Content:
complex, attr. wildcard, 1 element
Abstract:
(may not be used directly in instance XML documents)
Subst.Gr:
may be substituted with 6 elements
Defined:
globally; see XML source
Used:
abstract-reconnect-notifier A placeholder for a reconnection notifier element.
Type:
Content:
empty
Abstract:
(may not be used directly in instance XML documents)
Subst.Gr:
may be substituted with 2 elements
Defined:
globally; see XML source
Used:
abstract-reconnection-strategy A placeholder for a reconnection strategy element.
Type:
Content:
complex, 1 attribute, 1 element
Abstract:
(may not be used directly in instance XML documents)
Subst.Gr:
may be substituted with 3 elements
Defined:
globally; see XML source
Used:
abstract-redelivery-policy A placeholder for a redelivery policy.
Type:
Content:
complex, 1 attribute, attr. wildcard, 2 elements
Abstract:
(may not be used directly in instance XML documents)
Subst.Gr:
may be substituted with 1 element
Defined:
globally; see XML source
Used:
abstract-routing-message-processor A placeholder for intercepting router elements.
Type:
Content:
complex, attr. wildcard, 1 element
Abstract:
(may not be used directly in instance XML documents)
Subst.Gr:
affiliated to substitution group abstract-message-processor; may be substituted with 7 elements
Defined:
globally; see XML source
Used:
abstract-security-filter A placeholder for security filter elements, which control access to the system.
Type:
Content:
complex, attr. wildcard, 1 element
Abstract:
(may not be used directly in instance XML documents)
Subst.Gr:
affiliated to substitution group abstract-message-processor; may be substituted with 8 elements
Defined:
globally; see XML source
Used:
abstract-security-manager A security manager is a container for security providers.
Type:
Content:
complex, 2 attributes, attr. wildcard, 1 element
Abstract:
(may not be used directly in instance XML documents)
Subst.Gr:
may be substituted with 4 elements
Defined:
globally; see XML source
Used:
abstract-service A placeholder for a service element.
Type:
Content:
complex, 1 attribute, attr. wildcard, 1 element
Abstract:
(may not be used directly in instance XML documents)
Subst.Gr:
may be substituted with 2 elements
Defined:
globally; see XML source
Used:
abstract-service-threading-profile A placeholder for the service threading profile element.
Type:
Content:
empty
Abstract:
(may not be used directly in instance XML documents)
Subst.Gr:
may be substituted with 1 element
Defined:
globally; see XML source
Used:
abstract-transaction A placeholder for transaction elements.
Type:
Content:
empty, 2 attributes
Abstract:
(may not be used directly in instance XML documents)
Subst.Gr:
may be substituted with 6 elements
Defined:
globally; see XML source
Used:
abstract-transaction-manager A placeholder for transaction manager elements, which are used to coordinate transactions.
Type:
Content:
complex, attr. wildcard, 1 element
Abstract:
(may not be used directly in instance XML documents)
Subst.Gr:
may be substituted with 8 elements
Defined:
globally; see XML source
Used:
abstract-transformer A placeholder for transformer elements.
Type:
Content:
complex, attr. wildcard, 1 element
Abstract:
(may not be used directly in instance XML documents)
Subst.Gr:
affiliated to substitution group abstract-message-processor; may be substituted with 80 elements
Defined:
globally; see XML source
Used:
at 85 locations
abstract-xa-transaction A placeholder for XA transaction elements.
Type:
Content:
empty, 2 attributes
Abstract:
(may not be used directly in instance XML documents)
Defined:
globally; see XML source
Used:
add-message-properties Add a set of message properties.
Type:
Content:
complex, 2 attributes, 4 elements
Defined:
add-message-property Add a message property.
Type:
Content:
empty, 3 attributes
Defined:
alias
Type:
anonymous complexType
Content:
empty, 2 attributes
Defined:
Includes:
definitions of 2 attributes
all Sends the same message to multiple message processors or outbound endpoints.
Type:
Content:
complex, 1 attribute, attr. wildcard, 5 elements
Subst.Gr:
Defined:
globally; see XML source
Used:
never
and-filter Returns true only if all the enclosed filters return true.
Type:
Content:
complex, 1 attribute, attr. wildcard, 2 elements
Subst.Gr:
may substitute for elements: abstract-filter, abstract-message-processor
Defined:
globally; see XML source
Used:
never
annotations
Type:
Content:
complex, elem. wildcard
Defined:
locally at 2 locations
append-string-transformer A transformer that appends a string to a string payload.
Type:
Content:
complex, 6 attributes, attr. wildcard, 1 element
Subst.Gr:
may substitute for elements: abstract-transformer, abstract-message-processor
Defined:
globally; see XML source
Used:
never
array-entry-point-resolver Delivers the message to a method that takes a single array as argument.
Type:
Content:
complex, 2 attributes, 3 elements
Subst.Gr:
may substitute for element abstract-entry-point-resolver
Defined:
globally; see XML source
Used:
never
async Processes the nested list of message processors asynchronously using a thread pool
Type:
Content:
complex, 2 attributes, attr. wildcard, 4 elements
Subst.Gr:
may substitute for element abstract-message-processor
Defined:
globally; see XML source
Used:
never
async-reply The elements within 'async-reply' describe how asynchronous replies are handled.
Type:
Content:
complex, 2 attributes, 5 elements
Defined:
locally witnin baseServiceType complexType; see XML source
asynchronous-processing-strategy Processing strategy that uses a thread pool to process the pipeline of message processors asynchronously in a worker thread.
Type:
Content:
complex, 7 attributes, attr. wildcard, 1 element
Subst.Gr:
may substitute for element abstract-processing-strategy
Defined:
globally; see XML source
Used:
never
auto-transformer A transformer that uses the transform discovery mechanism to convert the message payload.
Type:
Content:
complex, 5 attributes, attr. wildcard, 1 element
Subst.Gr:
may substitute for elements: abstract-transformer, abstract-message-processor
Defined:
globally; see XML source
Used:
never
base64-decoder-transformer A transformer that base64 decodes a message to give an array of bytes.
Type:
Content:
complex, 5 attributes, attr. wildcard, 1 element
Subst.Gr:
may substitute for elements: abstract-transformer, abstract-message-processor
Defined:
globally; see XML source
Used:
never
base64-encoder-transformer A transformer that base64 encodes a string or byte array message.
Type:
Content:
complex, 5 attributes, attr. wildcard, 1 element
Subst.Gr:
may substitute for elements: abstract-transformer, abstract-message-processor
Defined:
globally; see XML source
Used:
never
bean-builder-transformer A transformer that uses expressions to configure a simple bean object.
Type:
anonymous complexType (extension of abstractTransformerType)
Content:
complex, 7 attributes, attr. wildcard, 2 elements
Subst.Gr:
may substitute for elements: abstract-transformer, abstract-message-processor
Defined:
globally; see XML source
Includes:
definitions of 2 attributes, 1 element
Used:
never
bean-property
Type:
anonymous complexType
Content:
empty, 5 attributes
Defined:
Includes:
definitions of 2 attributes
bean-to-map-transformer Conversts a simple bean object to a Map. every property on the bean will become an entry in the result {{java.util.Map}}.
Type:
Content:
complex, 5 attributes, attr. wildcard, 1 element
Subst.Gr:
may substitute for elements: abstract-transformer, abstract-message-processor
Defined:
globally; see XML source
Used:
never
binding A binding associates a Mule endpoint with an injected Java interface.
Type:
Content:
complex, 2 attributes, 1 element
Defined:
bridge Deprecated.
Type:
Content:
complex, 12 attributes, attr. wildcard, 5 elements
Subst.Gr:
may substitute for element abstract-flow-construct
Defined:
globally; see XML source
Used:
never
byte-array-to-hex-string-transformer A transformer that converts a byte array to a string of hexadecimal digits.
Type:
Content:
complex, 5 attributes, attr. wildcard, 1 element
Subst.Gr:
may substitute for elements: abstract-transformer, abstract-message-processor
Defined:
globally; see XML source
Used:
never
byte-array-to-object-transformer A transformer that converts a byte array to an object (either deserializing or converting to a string).
Type:
Content:
complex, 5 attributes, attr. wildcard, 1 element
Subst.Gr:
may substitute for elements: abstract-transformer, abstract-message-processor
Defined:
globally; see XML source
Used:
never
byte-array-to-serializable-transformer A transformer that converts a byte array to an object (deserializing the object).
Type:
Content:
complex, 5 attributes, attr. wildcard, 1 element
Subst.Gr:
may substitute for elements: abstract-transformer, abstract-message-processor
Defined:
globally; see XML source
Used:
never
byte-array-to-string-transformer A transformer that converts a byte array to a string.
Type:
Content:
complex, 5 attributes, attr. wildcard, 1 element
Subst.Gr:
may substitute for elements: abstract-transformer, abstract-message-processor
Defined:
globally; see XML source
Used:
never
callable-entry-point-resolver An entry point resolver for components that implement the Callable interface.
Type:
Content:
empty
Subst.Gr:
may substitute for element abstract-entry-point-resolver
Defined:
globally; see XML source
Used:
never
catch-exception-strategy Exception strategy used to handle exceptions.
Type:
Content:
complex, 3 attributes, attr. wildcard, 4 elements
Subst.Gr:
Defined:
globally; see XML source
Used:
never
chaining-router Sends the message through multiple endpoints using the result of the first invocation as the input for the next.
Type:
Content:
complex, 3 attributes, attr. wildcard, 6 elements
Subst.Gr:
may substitute for element abstract-outbound-router
Defined:
globally; see XML source
Used:
never
choice Sends the message to the first endpoint whose condition has been satisfied.
Type:
Content:
complex, attr. wildcard, 3 elements
Subst.Gr:
Defined:
globally; see XML source
Used:
never
choice-exception-strategy Exception strategy used to route to different exception strategies.
Type:
Content:
complex, 1 attribute, attr. wildcard, 2 elements
Subst.Gr:
Defined:
globally; see XML source
Used:
never
collection-aggregator Configures a Collection Response Router.
Type:
Content:
complex, 4 attributes, attr. wildcard, 2 elements
Subst.Gr:
Defined:
globally; see XML source
Used:
never
collection-aggregator-router Configures a Collection Response Router.
Type:
Content:
complex, 2 attributes, attr. wildcard, 1 element
Subst.Gr:
may substitute for element abstract-inbound-router
Defined:
globally; see XML source
Used:
never
collection-async-reply-router Configures a Collection Response Router.
Type:
Content:
complex, 1 element
Subst.Gr:
may substitute for element abstract-async-reply-router
Defined:
globally; see XML source
Used:
never
collection-splitter The collection splitter accepts a collection of objects and splits the collection invoking the next message processor with each item in the collection in sequence.
Type:
anonymous complexType (extension of baseSplitterType)
Content:
complex, 1 attribute, attr. wildcard, 2 elements
Subst.Gr:
Defined:
globally; see XML source
Used:
combine-collections-transformer Takes a payload which is a Collection of Collections and turns into a single List.
Type:
Content:
complex, 1 attribute, attr. wildcard, 1 element
Subst.Gr:
Defined:
globally; see XML source
Used:
never
commit-transaction These exceptions will be considered "delivered" after handling by the exception strategy.
Type:
Content:
empty, 1 attribute
Defined:
component A simple POJO (Plain Old Java Object) component that will be invoked by Mule when a message is received.
Type:
Content:
complex, 1 attribute, attr. wildcard, 8 elements
Subst.Gr:
may substitute for elements: abstract-component, abstract-message-processor
Defined:
globally; see XML source
Used:
never
composite-source
Type:
Content:
complex, attr. wildcard, 3 elements
Subst.Gr:
may substitute for element abstract-message-source
Defined:
globally; see XML source
Used:
never
configuration Specifies defaults and general settings for the Mule instance.
Type:
Content:
complex, 7 attributes, attr. wildcard, 7 elements
Defined:
globally; see XML source
Used:
copy-attachments A transformer that copy inbound attachment to outbound attachment scope by name or regular expression.
Type:
Content:
complex, 1 attribute, attr. wildcard, 1 element
Subst.Gr:
may substitute for elements: abstract-transformer, abstract-message-processor
Defined:
globally; see XML source
Used:
never
copy-properties A transformer that copy properties from inbound to outbound scope by name or regular expression.
Type:
Content:
complex, 1 attribute, attr. wildcard, 1 element
Subst.Gr:
may substitute for elements: abstract-transformer, abstract-message-processor
Defined:
globally; see XML source
Used:
never
correlation-resequencer-router Holds back a group of messages and resequences them using each message's correlation sequence property.
Type:
Content:
complex, 2 attributes, attr. wildcard, 1 element
Subst.Gr:
may substitute for element abstract-inbound-router
Defined:
globally; see XML source
Used:
never
custom-agent
Type:
Content:
complex, 2 attributes, attr. wildcard, 2 elements
Subst.Gr:
may substitute for element abstract-agent
Defined:
globally; see XML source
Used:
never
custom-aggregator Configures a custom message aggregator.
Type:
anonymous complexType (extension of baseAggregatorType)
Content:
complex, 5 attributes, attr. wildcard, 3 elements
Subst.Gr:
Defined:
globally; see XML source
Includes:
definitions of 1 attribute, 1 element
Used:
never
custom-async-reply-router
Type:
Content:
complex, 1 attribute, 2 elements
Subst.Gr:
may substitute for element abstract-async-reply-router
Defined:
globally; see XML source
Used:
never
custom-catch-all-strategy
Type:
Content:
complex, 1 attribute, 1 element
Subst.Gr:
may substitute for element abstract-catch-all-strategy
Defined:
globally; see XML source
Used:
never
custom-connector A user-defined connector.
Type:
Content:
complex, 5 attributes, attr. wildcard, 6 elements
Subst.Gr:
may substitute for element abstract-connector
Defined:
globally; see XML source
Used:
never
custom-correlation-aggregator-router Configures a custom message aggregator.
Type:
Content:
complex, 3 attributes, attr. wildcard, 2 elements
Subst.Gr:
may substitute for element abstract-inbound-router
Defined:
globally; see XML source
Used:
never
custom-encryption-strategy A custom implementation of EncryptionStrategy.
Type:
Content:
complex, 2 attributes, 1 element
Defined:
locally witnin securityManagerType complexType; see XML source
custom-entry-point-resolver A custom entry point resolver.
Type:
Content:
complex, 1 attribute, 1 element
Subst.Gr:
may substitute for element abstract-entry-point-resolver
Defined:
globally; see XML source
Used:
never
custom-entry-point-resolver-set A custom entry point resolver set.
Type:
Content:
complex, 1 attribute, 1 element
Subst.Gr:
may substitute for element abstract-entry-point-resolver-set
Defined:
globally; see XML source
Used:
never
custom-exception-strategy A user-defined exception strategy.
Type:
Content:
complex, 4 attributes, attr. wildcard, 7 elements
Subst.Gr:
Defined:
globally; see XML source
Used:
never
custom-filter A user-implemented filter.
Type:
Content:
complex, 2 attributes, attr. wildcard, 2 elements
Subst.Gr:
may substitute for elements: abstract-filter, abstract-message-processor
Defined:
globally; see XML source
Used:
never
custom-forwarding-catch-all-strategy
Type:
Content:
complex, 1 attribute, 2 elements
Subst.Gr:
may substitute for element abstract-catch-all-strategy
Defined:
globally; see XML source
Used:
never
custom-inbound-router Allows for custom inbound routers to be configured.
Type:
Content:
complex, 1 attribute, attr. wildcard, 2 elements
Subst.Gr:
may substitute for element abstract-inbound-router
Defined:
globally; see XML source
Used:
never
custom-interceptor A user-implemented interceptor.
Type:
Content:
complex, 1 attribute, attr. wildcard, 2 elements
Subst.Gr:
may substitute for elements: abstract-interceptor, abstract-message-processor
Defined:
globally; see XML source
Used:
never
custom-lifecycle-adapter-factory
Type:
Content:
complex, 1 attribute, 1 element
Subst.Gr:
may substitute for element abstract-lifecycle-adapter-factory
Defined:
globally; see XML source
Used:
never
custom-message-info-mapping Allows configuraton of a custom implementation of MessageInfoMapping.
Type:
Content:
complex, 1 attribute, 1 element
Subst.Gr:
may substitute for element abstract-message-info-mapping
Defined:
globally; see XML source
Used:
never
custom-object-store A custom implementation of the ObjectStore interface.
Type:
Content:
complex, 1 attribute, 1 element
Subst.Gr:
may substitute for element abstract-object-store
Defined:
globally; see XML source
Used:
never
custom-outbound-router Allows you to configure a custom outbound router by specifying the custom router class and by using Spring properties.
Type:
Content:
complex, 3 attributes, attr. wildcard, 7 elements
Subst.Gr:
may substitute for element abstract-outbound-router
Defined:
globally; see XML source
Used:
never
custom-processing-strategy Allows for the configuration of a custom processing strategy that implements 'org.mule.api.construct.PipelineProcessingStrategy'.
Type:
Content:
complex, 2 attributes, attr. wildcard, 2 elements
Subst.Gr:
may substitute for element abstract-processing-strategy
Defined:
globally; see XML source
Used:
never
custom-processor
Type:
Content:
complex, 2 attributes, attr. wildcard, 2 elements
Subst.Gr:
may substitute for element abstract-message-processor
Defined:
globally; see XML source
Used:
custom-queue-store
Type:
Content:
complex, 2 attributes, attr. wildcard, 2 elements
Subst.Gr:
may substitute for element abstract-queue-store
Defined:
globally; see XML source
Used:
custom-router
Type:
Content:
complex, 2 attributes, attr. wildcard, 6 elements
Subst.Gr:
Defined:
globally; see XML source
Includes:
definitions of 1 attribute, 1 element
Used:
never
custom-security-filter Allows developers to configure custom security filters
Type:
Content:
complex, 1 attribute, attr. wildcard, 2 elements
Subst.Gr:
Defined:
globally; see XML source
Used:
never
custom-security-provider A custom implementation of SecurityProvider.
Type:
Content:
complex, 2 attributes, 1 element
Defined:
locally witnin securityManagerType complexType; see XML source
custom-service A user-implemented service (typically used only in testing).
Type:
Content:
complex, 3 attributes, attr. wildcard, 9 elements
Subst.Gr:
may substitute for element abstract-service
Defined:
globally; see XML source
Used:
never
custom-source
Type:
Content:
complex, 1 attribute, attr. wildcard, 2 elements
Subst.Gr:
may substitute for element abstract-message-source
Defined:
globally; see XML source
Used:
never
custom-splitter Configures a custom message splitter.
Type:
anonymous complexType (extension of baseSplitterType)
Content:
complex, 2 attributes, attr. wildcard, 3 elements
Subst.Gr:
Defined:
globally; see XML source
Includes:
definitions of 1 attribute, 1 element
Used:
never
custom-transaction A user-defined or otherwise unsupported third-party transactions.
Type:
Content:
empty, 4 attributes
Subst.Gr:
may substitute for element abstract-transaction
Defined:
globally; see XML source
Used:
never
custom-transaction-manager A user-implemented transaction manager.
Type:
Content:
complex, 1 attribute, attr. wildcard, 3 elements
Subst.Gr:
may substitute for element abstract-transaction-manager
Defined:
globally; see XML source
Used:
never
custom-transformer A user-implemented transformer.
Type:
Content:
complex, 6 attributes, attr. wildcard, 2 elements
Subst.Gr:
may substitute for elements: abstract-transformer, abstract-message-processor
Defined:
globally; see XML source
Used:
never
dead-letter-queue Message processor to call if a message exceeds its redelivery count without being processed successfully
Type:
Content:
complex, attr. wildcard, 4 elements
Defined:
decrypt-transformer A transformer that decrypts a message.
Type:
Content:
complex, 6 attributes, attr. wildcard, 1 element
Subst.Gr:
may substitute for elements: abstract-transformer, abstract-message-processor
Defined:
globally; see XML source
Used:
never
default-dispatcher-threading-profile The default dispatching threading profile, which modifies the default-threading-profile values and is used by endpoints for dispatching messages.
Type:
Content:
empty, 7 attributes
Defined:
locally witnin configurationType complexType; see XML source
default-exception-strategy Provides default exception handling.
Type:
Content:
complex, 4 attributes, attr. wildcard, 6 elements
Subst.Gr:
may substitute for element legacy-abstract-exception-strategy
Defined:
globally; see XML source
Used:
never
default-in-memory-queue-store The default in-memory queue store for the application.
Type:
Content:
complex, attr. wildcard, 1 element
Subst.Gr:
may substitute for element abstract-queue-store
Defined:
globally; see XML source
Used:
never
default-persistent-queue-store The default persistent queue store for the application.
Type:
Content:
complex, attr. wildcard, 1 element
Subst.Gr:
may substitute for element abstract-queue-store
Defined:
globally; see XML source
Used:
never
default-receiver-threading-profile The default receiving threading profile, which modifies the default-threading-profile values and is used by endpoints for receiving messages.
Type:
Content:
empty, 7 attributes
Defined:
locally witnin configurationType complexType; see XML source
default-service-exception-strategy Deprecated: Use default-exception-strategy instead.
Type:
Content:
complex, 4 attributes, attr. wildcard, 6 elements
Subst.Gr:
may substitute for element legacy-abstract-exception-strategy
Defined:
globally; see XML source
Used:
never
default-service-threading-profile The default service threading profile, which modifies the default-threading-profile and is used by services for processing messages.
Type:
Content:
empty, 7 attributes
Defined:
locally witnin configurationType complexType; see XML source
default-threading-profile The default threading profile, used by components and by endpoints for dispatching and receiving if no more specific configuration is given.
Type:
Content:
empty, 7 attributes
Defined:
locally witnin configurationType complexType; see XML source
delete-message-property Delete message properties matching a regular expression or wildcard.
Type:
Content:
empty, 1 attribute
Defined:
description
Type:
Content:
mixed (allows character data)
Defined:
locally at 6 locations
disable-notification Blocks the association of an event with a particular interface.
Type:
Content:
empty, 4 attributes
Defined:
dispatcher-threading-profile The threading profile to use when a connector dispatches messages.
Type:
Content:
empty, 7 attributes
Defined:
locally witnin connectorType complexType; see XML source
echo-component Logs the message and returns the payload as the result.
Type:
Content:
complex, attr. wildcard, 3 elements
Subst.Gr:
may substitute for elements: abstract-component, abstract-message-processor
Defined:
globally; see XML source
Used:
never
encrypt-transformer A transformer that encrypts a message.
Type:
Content:
complex, 6 attributes, attr. wildcard, 1 element
Subst.Gr:
may substitute for elements: abstract-transformer, abstract-message-processor
Defined:
globally; see XML source
Used:
never
encryption-security-filter A filter that provides password-based encyption.
Type:
Content:
complex, 1 attribute, attr. wildcard, 1 element
Subst.Gr:
Defined:
globally; see XML source
Used:
never
endpoint A global endpoint, which acts as a template that can be used to construct an inbound or outbound endpoint elsewhere in the configuration by referencing the global endpoint name.
Type:
Content:
complex, 11 attributes, attr. wildcard, 16 elements
Subst.Gr:
may substitute for element abstract-global-endpoint
Defined:
globally; see XML source
Used:
never
endpoint-selector-router Selects the outgoing endpoint based on an expression evaluator ("header:endpoint" by default).
Type:
Content:
complex, 7 attributes, attr. wildcard, 6 elements
Subst.Gr:
may substitute for element abstract-outbound-router
Defined:
globally; see XML source
Used:
never
enrich
Type:
Content:
empty, 2 attributes
Defined:
locally witnin messageEnricherType complexType; see XML source
enricher Enriches the current message, using expressins to define source and target, with the result of processing a nested message processor.
Type:
Content:
complex, 2 attributes, attr. wildcard, 5 elements
Subst.Gr:
may substitute for element abstract-message-processor
Defined:
globally; see XML source
Used:
never
entry-point-resolver-set An extensible set of entry point resolvers.
Type:
Content:
complex, 1 element
Subst.Gr:
may substitute for element abstract-entry-point-resolver-set
Defined:
globally; see XML source
Used:
never
environment The JNDI environment.
Type:
Content:
complex, 2 attributes, 4 elements
Defined:
exception-based-router Sends a message over an endpoint by selecting the first endpoint that can connect to the transport.
Type:
Content:
complex, 3 attributes, attr. wildcard, 6 elements
Subst.Gr:
may substitute for element abstract-outbound-router
Defined:
globally; see XML source
Used:
never
exception-strategy Exception strategy used to reference global exceptions within a flow or service.
Type:
Content:
complex, 1 attribute, attr. wildcard, 1 element
Subst.Gr:
Defined:
globally; see XML source
Used:
never
exception-type-filter A filter that matches the type of an exception.
Type:
Content:
complex, 2 attributes, attr. wildcard, 1 element
Subst.Gr:
may substitute for elements: abstract-filter, abstract-message-processor
Defined:
globally; see XML source
Used:
never
exclude-entry-point Explicitly excludes a named method from receiving the message.
Type:
Content:
empty, 1 attribute
Defined:
exclude-object-methods If specified, methods in the Java Object interface are not included in the list of possible methods that can receive the message.
Type:
xsd:anyType
Content:
any
Defined:
expression-component
Type:
Content:
mixed (allows character data), 1 attribute, attr. wildcard, 1 element
Subst.Gr:
may substitute for element abstract-mixed-content-message-processor
Defined:
globally; see XML source
Includes:
definition of 1 attribute
Used:
never
expression-filter A filter that can evaluate a range of expressions.
Type:
Content:
complex, 5 attributes, attr. wildcard, 1 element
Subst.Gr:
may substitute for elements: abstract-filter, abstract-message-processor
Defined:
globally; see XML source
Used:
never
expression-language Configuration of Mule Expression Language
Type:
anonymous complexType (extension of abstractMixedContentExtensionType)
Content:
mixed (allows character data), 1 attribute, attr. wildcard, 4 elements
Defined:
locally witnin configurationType complexType; see XML source
Includes:
definitions of 1 attribute, 3 elements
expression-message-info-mapping Allows expressions to be configured to extract the message information.
Type:
Content:
empty, 2 attributes
Subst.Gr:
may substitute for element abstract-message-info-mapping
Defined:
globally; see XML source
Used:
never
expression-recipient-list-router Sends the same message to multiple endpoints over the same endpoint, or implements routing-slip behavior where the next destination for the message is determined from message properties or the payload.
Type:
Content:
complex, 7 attributes, attr. wildcard, 6 elements
Subst.Gr:
may substitute for element abstract-outbound-router
Defined:
globally; see XML source
Used:
never
expression-splitter-router Splits the message based on an expression.
Type:
Content:
complex, 9 attributes, attr. wildcard, 6 elements
Subst.Gr:
may substitute for element abstract-outbound-router
Defined:
globally; see XML source
Used:
never
expression-transformer A transformer that evaluates one or more expressions on the current message.
Type:
Content:
complex, 9 attributes, attr. wildcard, 2 elements
Subst.Gr:
may substitute for elements: abstract-transformer, abstract-message-processor
Defined:
globally; see XML source
Used:
never
extract
Type:
Content:
empty, 4 attributes
Defined:
file-queue-store A simple file-based queue store.
Type:
Content:
complex, attr. wildcard, 1 element
Subst.Gr:
may substitute for element abstract-queue-store
Defined:
globally; see XML source
Used:
never
filter A filter that is defined elsewhere (at the global level, or as a Spring bean).
Type:
Content:
complex, 1 attribute, attr. wildcard, 1 element
Subst.Gr:
may substitute for elements: abstract-filter, abstract-message-processor
Defined:
globally; see XML source
Used:
never
filtering-router Uses filters to determine whether the message matches a particular criteria and if so will route the message to the endpoint configured on the router.
Type:
Content:
complex, 3 attributes, attr. wildcard, 6 elements
Subst.Gr:
may substitute for element abstract-outbound-router
Defined:
globally; see XML source
Used:
never
first-successful Sends a message to a list of message processors until one processes it successfully
Type:
anonymous complexType (extension of processorWithAtLeastOneTargetType)
Content:
complex, 1 attribute, attr. wildcard, 4 elements
Subst.Gr:
Defined:
globally; see XML source
Includes:
definition of 1 attribute
Used:
never
flow A pipeline of message processors processed using a given processingStrategy when either a new message is received from a message source, or when a new message is recieved via a flow-ref or programativally.
Type:
Content:
complex, 3 attributes, attr. wildcard, 10 elements
Defined:
globally; see XML source
Used:
flow-ref Allows a 'flow' to be referenced such that the message processing will continue in the referenced flow before returning.
Type:
anonymous complexType (extension of abstractMessageProcessorType)
Content:
complex, 1 attribute, attr. wildcard, 1 element
Subst.Gr:
may substitute for element abstract-message-processor
Defined:
globally; see XML source
Includes:
definition of 1 attribute
Used:
never
foreach
Type:
Content:
complex, 4 attributes, attr. wildcard, 4 elements
Subst.Gr:
Defined:
globally; see XML source
Used:
never
forwarding-catch-all-strategy Forwards the message to the specified endpoint if no outbound routers match.
Type:
Content:
complex, 1 element
Subst.Gr:
may substitute for element abstract-catch-all-strategy
Defined:
globally; see XML source
Used:
never
forwarding-router Allows messages to be forwarded to the outbound routers without first being processed by a component.
Type:
Content:
complex, attr. wildcard, 1 element
Subst.Gr:
may substitute for element abstract-inbound-router
Defined:
globally; see XML source
Used:
never
global-functions
Type:
anonymous complexType
Content:
mixed (allows character data), 1 attribute
Defined:
Includes:
definition of 1 attribute
global-property A global property is a named string.
Type:
Content:
complex, 2 attributes, attr. wildcard, 1 element
Defined:
globally; see XML source
Used:
gzip-compress-transformer A transformer that compresses a byte array using gzip.
Type:
Content:
complex, 5 attributes, attr. wildcard, 1 element
Subst.Gr:
may substitute for elements: abstract-transformer, abstract-message-processor
Defined:
globally; see XML source
Used:
never
gzip-uncompress-transformer A transformer that uncompresses a byte array using gzip.
Type:
Content:
complex, 5 attributes, attr. wildcard, 1 element
Subst.Gr:
may substitute for elements: abstract-transformer, abstract-message-processor
Defined:
globally; see XML source
Used:
never
hex-string-to-byte-array-transformer A transformer that converts a string of hexadecimal digits to a byte array.
Type:
Content:
complex, 5 attributes, attr. wildcard, 1 element
Subst.Gr:
may substitute for elements: abstract-transformer, abstract-message-processor
Defined:
globally; see XML source
Used:
never
idempotent-message-filter Ensures that only unique messages are received by a service by checking the unique ID of the incoming message.
Type:
Content:
complex, 5 attributes, attr. wildcard, 2 elements
Subst.Gr:
Defined:
globally; see XML source
Used:
never
idempotent-receiver-router Ensures that only unique messages are received by a service by checking the unique ID of the incoming message.
Type:
Content:
complex, 1 attribute, attr. wildcard, 2 elements
Subst.Gr:
may substitute for element abstract-inbound-router
Defined:
globally; see XML source
Used:
never
idempotent-redelivery-policy Defines a policy for processing the redelivery of the same message
Type:
Content:
complex, 4 attributes, attr. wildcard, 2 elements
Subst.Gr:
may substitute for element abstract-redelivery-policy
Defined:
globally; see XML source
Used:
never
idempotent-secure-hash-message-filter Ensures that only unique messages are received by a service by calculating the hash of the message itself using a message digest algorithm.
Type:
anonymous complexType (extension of idempotentMessageFilterType)
Content:
complex, 6 attributes, attr. wildcard, 2 elements
Subst.Gr:
Defined:
globally; see XML source
Includes:
definition of 1 attribute
Used:
never
idempotent-secure-hash-receiver-router Ensures that only unique messages are received by a service by calculating the hash of the message itself using a message digest algorithm.
Type:
Content:
complex, 1 attribute, attr. wildcard, 2 elements
Subst.Gr:
may substitute for element abstract-inbound-router
Defined:
globally; see XML source
Used:
never
import
Type:
anonymous complexType
Content:
empty, 2 attributes
Defined:
Includes:
definitions of 2 attributes
in-memory-store An optionally bounded in-memory store for message IDs with periodic expiry of old entries.
Type:
Content:
empty, 4 attributes
Subst.Gr:
may substitute for element abstract-object-store
Defined:
globally; see XML source
Used:
never
inbound The elements within 'inbound' describe how a service receives messages.
Type:
Content:
complex, 8 elements
Defined:
locally witnin baseServiceType complexType; see XML source
inbound-endpoint An inbound endpoint receives messages via the associated transport.
Type:
Content:
complex, 11 attributes, attr. wildcard, 16 elements
Subst.Gr:
may substitute for element abstract-inbound-endpoint
Defined:
globally; see XML source
Used:
never
include-entry-point A possible method for delivery.
Type:
Content:
empty, 1 attribute
Defined:
globally; see XML source
Used:
interceptor-stack
Type:
Content:
complex, 1 attribute, attr. wildcard, 2 elements
Subst.Gr:
may substitute for element abstract-interceptor-stack
Defined:
globally; see XML source
Used:
never
interceptor-stack (type refInterceptorStackType) A reference to a stack of intereceptors defined globally.
Type:
Content:
empty, 1 attribute
Defined:
invoke Invokes the method of a given object using method arguments expressed using mule expressions.
Type:
Content:
complex, 5 attributes, attr. wildcard, 1 element
Subst.Gr:
may substitute for element abstract-message-processor
Defined:
globally; see XML source
Used:
jboss-transaction-manager The JBoss transaction manager.
Type:
Content:
complex, 1 attribute, attr. wildcard, 1 element
Subst.Gr:
may substitute for element abstract-transaction-manager
Defined:
globally; see XML source
Used:
never
jndi-provider-properties Direct setting of JNDI properties (allows access to the full Spring map entry).
Type:
Content:
complex, 2 attributes, 4 elements
Defined:
locally witnin jndiConnectorType complexType; see XML source
jndi-provider-property Direct setting of a JNDI property.
Type:
Content:
empty, 3 attributes
Defined:
locally witnin jndiConnectorType complexType; see XML source
jndi-transaction-manager Retrieves a named transaction manager factory from JNDI.
Type:
anonymous complexType (extension of jndiTransactionManagerType)
Content:
complex, 1 attribute, attr. wildcard, 2 elements
Subst.Gr:
may substitute for element abstract-transaction-manager
Defined:
globally; see XML source
Includes:
definition of 1 attribute
Used:
never
jrun-transaction-manager The JRun transaction manager.
Type:
Content:
complex, 1 attribute, attr. wildcard, 1 element
Subst.Gr:
may substitute for element abstract-transaction-manager
Defined:
globally; see XML source
Used:
never
legacy-abstract-exception-strategy Legacy placeholder for an exception strategy element.
Type:
Content:
complex, attr. wildcard, 1 element
Abstract:
(may not be used directly in instance XML documents)
Subst.Gr:
may be substituted with 7 elements
Defined:
globally; see XML source
Used:
at 11 locations
legacy-entry-point-resolver-set An extensible set of entry point resolvers (which determine how a message is passed to a component in Java) that already contains resolvers to implement the standard logic.
Type:
Content:
complex, 1 element
Subst.Gr:
may substitute for element abstract-entry-point-resolver-set
Defined:
globally; see XML source
Used:
never
list-message-splitter-router The Filtering List Message Splitter accepts a list of objects that is split each object being routed to different endpoints.
Type:
Content:
complex, 6 attributes, attr. wildcard, 6 elements
Subst.Gr:
may substitute for element abstract-outbound-router
Defined:
globally; see XML source
Used:
never
log-component Logs the message content (or content length if it is a large message).
Type:
Content:
complex, attr. wildcard, 3 elements
Subst.Gr:
may substitute for elements: abstract-component, abstract-message-processor
Defined:
globally; see XML source
Used:
never
logger Performs logging using an expression that determines what should be logged.
Type:
Content:
complex, 3 attributes, attr. wildcard, 1 element
Subst.Gr:
Defined:
globally; see XML source
Used:
never
logging-catch-all-strategy Does nothing with the message but simply logs (using the WARN log level) the fact that the message was not dispatched because no routing path was defined.
Type:
Content:
empty
Subst.Gr:
may substitute for element abstract-catch-all-strategy
Defined:
globally; see XML source
Used:
never
logging-interceptor The logging interceptor (ported from 1.x).
Type:
Content:
complex, attr. wildcard, 1 element
Subst.Gr:
may substitute for elements: abstract-interceptor, abstract-message-processor
Defined:
globally; see XML source
Used:
never
managed-store Managed Object Store
Type:
Content:
empty, 5 attributes
Subst.Gr:
may substitute for element abstract-object-store
Defined:
globally; see XML source
Used:
never
map-splitter The map splitter accepts a map of objects and splits the collection invoking the next message processor with each item in the collection in sequence.
Type:
anonymous complexType (extension of baseSplitterType)
Content:
complex, 1 attribute, attr. wildcard, 2 elements
Subst.Gr:
Defined:
globally; see XML source
Used:
never
map-to-bean-transformer Creates and object of type @return-class and populates values of a {{java.util.Map}} as bean properties on the object.
Type:
Content:
complex, 5 attributes, attr. wildcard, 1 element
Subst.Gr:
may substitute for elements: abstract-transformer, abstract-message-processor
Defined:
globally; see XML source
Used:
never
message-chunk-aggregator Combines two or more messages into a single message by matching messages with a given Correlation ID.
Type:
Content:
complex, 4 attributes, attr. wildcard, 2 elements
Subst.Gr:
Defined:
globally; see XML source
Used:
never
message-chunk-splitter The collection splitter accepts a collection of objects and splits the collection invoking the next message processor with each item in the collection in sequence.
Type:
anonymous complexType (extension of baseSplitterType)
Content:
complex, 2 attributes, attr. wildcard, 2 elements
Subst.Gr:
Defined:
globally; see XML source
Includes:
definition of 1 attribute
Used:
never
message-chunking-aggregator-router Combines two or more messages into a single message by matching messages with a given Correlation ID.
Type:
Content:
complex, 2 attributes, attr. wildcard, 1 element
Subst.Gr:
may substitute for element abstract-inbound-router
Defined:
globally; see XML source
Used:
never
message-chunking-router Allows you to split a single message into a number of fixed-length messages that will all be routed to the same endpoint.
Type:
Content:
complex, 5 attributes, attr. wildcard, 6 elements
Subst.Gr:
may substitute for element abstract-outbound-router
Defined:
globally; see XML source
Used:
never
message-filter A message processor that uses a filter to determine whether to process an event.
Type:
Content:
complex, 3 attributes, attr. wildcard, 2 elements
Subst.Gr:
Defined:
globally; see XML source
Used:
never
message-properties-transformer A transformer that can add, delete or rename message properties.
Type:
Content:
complex, 7 attributes, attr. wildcard, 5 elements
Subst.Gr:
may substitute for elements: abstract-transformer, abstract-message-processor
Defined:
globally; see XML source
Used:
never
message-property-filter A filter that matches properties on a message.
Type:
Content:
complex, 4 attributes, attr. wildcard, 1 element
Subst.Gr:
may substitute for elements: abstract-filter, abstract-message-processor
Defined:
globally; see XML source
Used:
never
method-entry-point-resolver Delivers the message to a named method.
Type:
Content:
complex, 1 attribute, 1 element
Subst.Gr:
may substitute for element abstract-entry-point-resolver
Defined:
globally; see XML source
Used:
never
model The container for a set of services, providing basic settings and processing for all the services it contains.
Type:
Content:
complex, 2 attributes, attr. wildcard, 6 elements
Subst.Gr:
may substitute for element abstract-model
Defined:
globally; see XML source
Used:
never
mule Either the root element of a Mule configuration, or a "top-level" element in a Spring configuration that contains further Mule elements.
Type:
Content:
complex, 1 attribute, attr. wildcard, 30 elements
Defined:
globally; see XML source
Used:
never
multicasting-router Sends the same message over multiple endpoints.
Type:
Content:
complex, 3 attributes, attr. wildcard, 6 elements
Subst.Gr:
may substitute for element abstract-outbound-router
Defined:
globally; see XML source
Used:
never
no-arguments-entry-point-resolver Calls a method without arguments (the message is not passed to the component).
Type:
Content:
complex, 2 attributes, 3 elements
Subst.Gr:
may substitute for element abstract-entry-point-resolver
Defined:
globally; see XML source
Used:
never
not-filter Inverts the enclosed filter.
Type:
Content:
complex, 1 attribute, attr. wildcard, 2 elements
Subst.Gr:
may substitute for elements: abstract-filter, abstract-message-processor
Defined:
globally; see XML source
Used:
never
notification Associates an event with an interface.
Type:
Content:
empty, 4 attributes
Defined:
notification-listener Registers a bean as a listener with the notification system.
Type:
anonymous complexType
Content:
empty, 2 attributes
Defined:
Includes:
definitions of 2 attributes
notifications Registers listeners for notifications and associates interfaces with particular events.
Type:
Content:
complex, 1 attribute, attr. wildcard, 4 elements
Defined:
globally; see XML source
Used:
null-component Throws an exception if it receives a message.
Type:
Content:
complex, attr. wildcard, 3 elements
Subst.Gr:
may substitute for elements: abstract-component, abstract-message-processor
Defined:
globally; see XML source
Used:
never
object-to-byte-array-transformer A transformer that serializes all objects except strings (which are converted using getBytes()).
Type:
Content:
complex, 5 attributes, attr. wildcard, 1 element
Subst.Gr:
may substitute for elements: abstract-transformer, abstract-message-processor
Defined:
globally; see XML source
Used:
never
object-to-string-transformer A transformer that gives a human-readable description of various types (useful for debugging).
Type:
Content:
complex, 5 attributes, attr. wildcard, 1 element
Subst.Gr:
may substitute for elements: abstract-transformer, abstract-message-processor
Defined:
globally; see XML source
Used:
never
on-redelivery-attempts-exceeded
Type:
anonymous complexType (extension of annotatedType)
Content:
complex, attr. wildcard, 4 elements
Defined:
or-filter Returns true if any of the enclosed filters returns true.
Type:
Content:
complex, 1 attribute, attr. wildcard, 2 elements
Subst.Gr:
may substitute for elements: abstract-filter, abstract-message-processor
Defined:
globally; see XML source
Used:
never
otherwise
Type:
Content:
complex, 3 elements
Defined:
outbound The elements within 'outbound' describe how a service sends or dispatches messages.
Type:
Content:
complex, 1 attribute, 2 elements
Defined:
locally witnin baseServiceType complexType; see XML source
outbound-endpoint An outbound endpoint sends messages via the associated transport.
Type:
Content:
complex, 11 attributes, attr. wildcard, 16 elements
Subst.Gr:
may substitute for element abstract-outbound-endpoint
Defined:
globally; see XML source
Used:
never
parse-template A transformer that parses a template in a given location
Type:
Content:
complex, 6 attributes, attr. wildcard, 1 element
Subst.Gr:
may substitute for elements: abstract-transformer, abstract-message-processor
Defined:
globally; see XML source
Used:
never
pass-through-router This router always matches and simply sends or dispatches message via the endpoint that is configured.
Type:
Content:
complex, 1 attribute, attr. wildcard, 4 elements
Subst.Gr:
may substitute for element abstract-outbound-router
Defined:
globally; see XML source
Used:
never
password-encryption-strategy Provides password-based encryption using JCE.
Type:
Content:
empty, 4 attributes
Defined:
locally witnin securityManagerType complexType; see XML source
payload-type-filter A filter that matches the type of the payload.
Type:
Content:
complex, 2 attributes, attr. wildcard, 1 element
Subst.Gr:
may substitute for elements: abstract-filter, abstract-message-processor
Defined:
globally; see XML source
Used:
never
poll Polls the nested message processor for new messages
Type:
Content:
complex, 1 attribute, attr. wildcard, 4 elements
Subst.Gr:
may substitute for element abstract-message-source
Defined:
globally; see XML source
Used:
never
pooled-component A pooled POJO (Plain Old Java Object) component that will be invoked by Mule when a message is received.
Type:
Content:
complex, 1 attribute, attr. wildcard, 9 elements
Subst.Gr:
may substitute for elements: abstract-component, abstract-message-processor
Defined:
globally; see XML source
Used:
never
pooling-profile
Type:
Content:
empty, 5 attributes
Subst.Gr:
may substitute for element abstract-pooling-profile
Defined:
globally; see XML source
Used:
never
processor A reference to a message processor defined elsewhere.
Type:
Content:
complex, 1 attribute, attr. wildcard, 1 element
Subst.Gr:
may substitute for element abstract-message-processor
Defined:
globally; see XML source
Used:
processor-chain The use of globally defined processor-chain element is deprecated since Mule 3.2.
Type:
Content:
complex, 1 attribute, attr. wildcard, 5 elements
Subst.Gr:
may substitute for element abstract-message-processor
Defined:
globally; see XML source
Used:
properties A map of Mule properties.
Type:
Content:
complex, 2 attributes, 4 elements
Defined:
globally; see XML source
Used:
property Sets a Mule property.
Type:
Content:
empty, 3 attributes
Defined:
property-entry-point-resolver Uses a message property to select the component method to be called.
Type:
Content:
empty, 2 attributes
Subst.Gr:
may substitute for element abstract-entry-point-resolver
Defined:
globally; see XML source
Used:
never
prototype-object
Type:
Content:
complex, 1 attribute, 2 elements
Subst.Gr:
may substitute for element abstract-object-factory
Defined:
globally; see XML source
Used:
never
queue-profile Specifies the properties of an internal Mule queue.
Type:
Content:
complex, 1 attribute, 1 element
Subst.Gr:
may substitute for element abstract-queue-profile
Defined:
globally; see XML source
Used:
never
queue-store A reference to a queue store defined elsewhere.
Type:
Content:
complex, 1 attribute, attr. wildcard, 1 element
Subst.Gr:
may substitute for element abstract-queue-store
Defined:
globally; see XML source
Used:
never
queued-asynchronous-processing-strategy Decouples the recieving of a new message from it's processing using a queue.
Type:
Content:
complex, 9 attributes, attr. wildcard, 2 elements
Subst.Gr:
may substitute for element abstract-processing-strategy
Defined:
globally; see XML source
Used:
never
queued-thread-per-processor-processing-strategy EXPERIMENTAL: Decouples the processing of each message processor using a queue.
Type:
Content:
complex, 9 attributes, attr. wildcard, 2 elements
Subst.Gr:
may substitute for element abstract-processing-strategy
Defined:
globally; see XML source
Used:
never
receiver-threading-profile The threading profile to use when a connector receives messages.
Type:
Content:
empty, 7 attributes
Defined:
locally witnin connectorType complexType; see XML source
recipient-list Sends the same message to multiple endpoints, over the same endpoint, or implements routing-slip behavior where the next destination for the message is determined from message properties or the payload.
Type:
Content:
complex, 4 attributes, attr. wildcard, 2 elements
Subst.Gr:
Defined:
globally; see XML source
Includes:
definition of 1 element
Used:
never
recipient-list-exception-based-router Sends a message over an endpoint by selecting the first endpoint that can connect to the transport.
Type:
Content:
complex, 7 attributes, attr. wildcard, 5 elements
Subst.Gr:
may substitute for element abstract-outbound-router
Defined:
globally; see XML source
Used:
never
recipients
Type:
Content:
complex, 1 attribute, 22 elements, 2 elem. wildcards
Defined:
locally at 2 locations
reconnect A reconnection strategy that allows the user to configure how many times a reconnection should be attempted and how long to wait between attempts.
Type:
Content:
complex, 3 attributes, 1 element
Subst.Gr:
may substitute for element abstract-reconnection-strategy
Defined:
globally; see XML source
Used:
never
reconnect-custom-notifier A user-defined reconnection notifier.
Type:
Content:
complex, 1 attribute, 1 element
Subst.Gr:
may substitute for element abstract-reconnect-notifier
Defined:
globally; see XML source
Used:
never
reconnect-custom-strategy A user-defined reconnection strategy.
Type:
Content:
complex, 2 attributes, 2 elements
Subst.Gr:
may substitute for element abstract-reconnection-strategy
Defined:
globally; see XML source
Used:
never
reconnect-forever A reconnection strategy that retries an infinite number of times at the specified frequency.
Type:
Content:
complex, 2 attributes, 1 element
Subst.Gr:
may substitute for element abstract-reconnection-strategy
Defined:
globally; see XML source
Used:
never
reconnect-notifier Fires a ConnectionNotification upon each reconnection attempt.
Type:
Content:
empty
Subst.Gr:
may substitute for element abstract-reconnect-notifier
Defined:
globally; see XML source
Used:
never
reflection-entry-point-resolver Generates a list of candidate methods from the component via reflections.
Type:
Content:
complex, 1 attribute, 2 elements
Subst.Gr:
may substitute for element abstract-entry-point-resolver
Defined:
globally; see XML source
Used:
never
regex-filter A filter that matches string messages against a regular expression.
Type:
Content:
complex, 3 attributes, attr. wildcard, 1 element
Subst.Gr:
may substitute for elements: abstract-filter, abstract-message-processor
Defined:
globally; see XML source
Used:
never
remove-attachment A transformer that removes an attachment in the outbound scope.
Type:
Content:
complex, 1 attribute, attr. wildcard, 1 element
Subst.Gr:
may substitute for elements: abstract-transformer, abstract-message-processor
Defined:
globally; see XML source
Used:
never
remove-property A transformer that remove outbound message properties by name or regular expression.
Type:
Content:
complex, 1 attribute, attr. wildcard, 1 element
Subst.Gr:
may substitute for elements: abstract-transformer, abstract-message-processor
Defined:
globally; see XML source
Used:
never
remove-session-variable A transformer that remove session variables by name or regular expression.
Type:
Content:
complex, 1 attribute, attr. wildcard, 1 element
Subst.Gr:
may substitute for elements: abstract-transformer, abstract-message-processor
Defined:
globally; see XML source
Used:
never
remove-variable A transformer that remove variables by name or regular expression.
Type:
Content:
complex, 1 attribute, attr. wildcard, 1 element
Subst.Gr:
may substitute for elements: abstract-transformer, abstract-message-processor
Defined:
globally; see XML source
Used:
never
rename-message-property Rename a message property.
Type:
Content:
empty, 3 attributes
Defined:
reply-to Defines where the message should be routed after the recipient of the message to which this service dispatches has finished with it.
Type:
Content:
empty, 2 attributes
Defined:
request-reply Provides support for the asynchronous request/reply pattern where a message is sent via a one-way outbound endpoint and an asynchronous response is received via a seperate inbound one-way endpoint.
Type:
Content:
complex, 2 attributes, attr. wildcard, 5 elements
Subst.Gr:
may substitute for element abstract-message-processor
Defined:
globally; see XML source
Used:
never
resequencer Holds back a group of messages and resequences them using each message's correlation sequence property.
Type:
Content:
complex, 4 attributes, attr. wildcard, 2 elements
Subst.Gr:
Defined:
globally; see XML source
Used:
never
resin-transaction-manager The Resin transaction manager.
Type:
Content:
complex, 1 attribute, attr. wildcard, 1 element
Subst.Gr:
may substitute for element abstract-transaction-manager
Defined:
globally; see XML source
Used:
never
response
Type:
anonymous complexType
Content:
complex, 8 elements
Defined:
globally; see XML source
Used:
response (in flow) An outbound endpoint
Type:
anonymous complexType
Content:
complex, 3 elements
Defined:
locally witnin flowType complexType; see XML source
return-argument If all expressions return null or NullPayload on this transformer, this flag will cause the source payload to be returned without modification.
Type:
anonymous complexType
Content:
empty, 4 attributes
Defined:
Includes:
definition of 1 attribute
return-data Defines the data to return from the service once it has been invoked.
Type:
anonymous complexType
Content:
mixed (allows character data), 1 attribute
Defined:
locally witnin staticComponentType complexType; see XML source
Includes:
definition of 1 attribute
rollback-exception-strategy Exception strategy used to rollback inbound message.
Type:
Content:
complex, 4 attributes, attr. wildcard, 5 elements
Subst.Gr:
Defined:
globally; see XML source
Used:
never
rollback-transaction These exceptions will be redelivered/rolled back after handling by the exception strategy.
Type:
Content:
empty, 1 attribute
Defined:
round-robin Send each message received to the next message processor in the circular list of targets
Type:
Content:
complex, attr. wildcard, 4 elements
Subst.Gr:
Defined:
globally; see XML source
Used:
never
secret-key-encryption-strategy Provides secret key-based encryption using JCE.
Type:
Content:
empty, 3 attributes
Defined:
locally witnin securityManagerType complexType; see XML source
security-manager The default security manager.
Type:
Content:
complex, 2 attributes, attr. wildcard, 5 elements
Subst.Gr:
may substitute for element abstract-security-manager
Defined:
globally; see XML source
Used:
never
seda-model A staged event-driven architecture (SEDA) model has separate threads and queues for each service.
Type:
Content:
complex, 2 attributes, attr. wildcard, 6 elements
Subst.Gr:
may substitute for element abstract-model
Defined:
globally; see XML source
Used:
never
selective-consumer-router Applies one or more filters to the incoming message.
Type:
Content:
complex, attr. wildcard, 2 elements
Subst.Gr:
may substitute for element abstract-inbound-router
Defined:
globally; see XML source
Used:
never
sequence-router Sends the same message sequentially over multiple endpoints.
Type:
Content:
complex, 3 attributes, attr. wildcard, 6 elements
Subst.Gr:
may substitute for element abstract-outbound-router
Defined:
globally; see XML source
Used:
never
serializable-to-byte-array-transformer A transformer that converts an object to a byte array (serializing the object).
Type:
Content:
complex, 5 attributes, attr. wildcard, 1 element
Subst.Gr:
may substitute for elements: abstract-transformer, abstract-message-processor
Defined:
globally; see XML source
Used:
never
service Describes how to receive messages, deliver them to a component, and handle the results (if any).
Type:
Content:
complex, 3 attributes, attr. wildcard, 10 elements
Subst.Gr:
may substitute for element abstract-service
Defined:
globally; see XML source
Used:
never
service-overrides Service overrides allow the connector to be further configured/customized by allowing parts of the transport implementation to be overridden, for example, the message receiver or dispatcher implementation, or the message adaptor that is used.
Type:
Content:
empty, 14 attributes
Defined:
locally witnin connectorType complexType; see XML source
set-attachment A transformer that adds an attachment to the outbound scope.
Type:
Content:
complex, 3 attributes, attr. wildcard, 1 element
Subst.Gr:
may substitute for elements: abstract-transformer, abstract-message-processor
Defined:
globally; see XML source
Used:
never
set-payload A transformer that sets the paylaod with the provided value
Type:
Content:
complex, 6 attributes, attr. wildcard, 1 element
Subst.Gr:
may substitute for elements: abstract-transformer, abstract-message-processor
Defined:
globally; see XML source
Used:
never
set-property A transformer that adds outbound message properties.
Type:
Content:
complex, 2 attributes, attr. wildcard, 1 element
Subst.Gr:
may substitute for elements: abstract-transformer, abstract-message-processor
Defined:
globally; see XML source
Used:
never
set-session-variable A transformer that adds session variables.
Type:
Content:
complex, 2 attributes, attr. wildcard, 1 element
Subst.Gr:
may substitute for elements: abstract-transformer, abstract-message-processor
Defined:
globally; see XML source
Used:
never
set-variable A transformer that adds variables.
Type:
Content:
complex, 2 attributes, attr. wildcard, 1 element
Subst.Gr:
may substitute for elements: abstract-transformer, abstract-message-processor
Defined:
globally; see XML source
Used:
never
simple-in-memory-queue-store A simple in-memeory queue store.
Type:
Content:
complex, attr. wildcard, 1 element
Subst.Gr:
may substitute for element abstract-queue-store
Defined:
globally; see XML source
Used:
never
simple-service Deprecated.
Type:
Content:
complex, 11 attributes, attr. wildcard, 5 elements
Subst.Gr:
may substitute for element abstract-flow-construct
Defined:
globally; see XML source
Used:
never
simple-text-file-store A simple object store that stores String objects by key to a text file.
Type:
Content:
empty, 5 attributes
Subst.Gr:
may substitute for element abstract-object-store
Defined:
globally; see XML source
Used:
never
single-async-reply-router Configures a Single Response Router.
Type:
Content:
complex, 1 element
Subst.Gr:
may substitute for element abstract-async-reply-router
Defined:
globally; see XML source
Used:
never
singleton-object
Type:
Content:
complex, 1 attribute, 2 elements
Subst.Gr:
may substitute for element abstract-object-factory
Defined:
globally; see XML source
Used:
never
splitter The simple splitter splits incoming message into parts using the configured expression passing on each part in turn to the next message processor
Type:
anonymous complexType (extension of baseSplitterType)
Content:
complex, 4 attributes, attr. wildcard, 2 elements
Subst.Gr:
Defined:
globally; see XML source
Used:
spring-object
Type:
Content:
complex, 1 attribute, 2 elements
Subst.Gr:
may substitute for element abstract-object-factory
Defined:
globally; see XML source
Used:
never
spring-object-store A Spring bean that implements the ObjectStore interface.
Type:
Content:
empty, 1 attribute
Subst.Gr:
may substitute for element abstract-object-store
Defined:
globally; see XML source
Used:
never
static-component A service that will return static data as a result.
Type:
Content:
complex, attr. wildcard, 4 elements
Subst.Gr:
may substitute for elements: abstract-component, abstract-message-processor
Defined:
globally; see XML source
Used:
never
static-recipient-list-router Sends the same message to multiple endpoints over the same endpoint, or implements routing-slip behavior where the next destination for the message is determined from message properties or the payload.
Type:
Content:
complex, 6 attributes, attr. wildcard, 6 elements
Subst.Gr:
may substitute for element abstract-outbound-router
Defined:
globally; see XML source
Used:
never
string-to-byte-array-transformer A transformer that converts a string to a byte array.
Type:
Content:
complex, 5 attributes, attr. wildcard, 1 element
Subst.Gr:
may substitute for elements: abstract-transformer, abstract-message-processor
Defined:
globally; see XML source
Used:
never
sub-flow A chain of message processors processed synchronously that can be referenced and reused.
Type:
Content:
complex, 1 attribute, attr. wildcard, 5 elements
Defined:
globally; see XML source
Used:
thread-per-processor-processing-strategy EXPERIMENTAL: Uses a thread pool to process each message processors asynchronously in a worker thread.
Type:
Content:
complex, 7 attributes, attr. wildcard, 1 element
Subst.Gr:
may substitute for element abstract-processing-strategy
Defined:
globally; see XML source
Used:
never
threading-profile The threading profile to use for the service.
Type:
Content:
empty, 7 attributes
Subst.Gr:
may substitute for element abstract-service-threading-profile
Defined:
globally; see XML source
Used:
never
timer-interceptor The timer interceptor (ported from 1.x).
Type:
Content:
complex, attr. wildcard, 1 element
Subst.Gr:
may substitute for elements: abstract-interceptor, abstract-message-processor
Defined:
globally; see XML source
Used:
never
transactional Processes the nest list of message processors within a transaction
Type:
Content:
complex, 1 attribute, attr. wildcard, 5 elements
Subst.Gr:
may substitute for element abstract-message-processor
Defined:
globally; see XML source
Used:
never
transformer A reference to a transformer defined elsewhere.
Type:
Content:
complex, 1 attribute, attr. wildcard, 1 element
Subst.Gr:
may substitute for elements: abstract-transformer, abstract-message-processor
Defined:
globally; see XML source
Used:
never
until-successful Attempts to route a message to the message processor it contains in an asynchronous manner.
Type:
anonymous complexType (extension of processorWithExactlyOneTargetType)
Content:
complex, 6 attributes, attr. wildcard, 4 elements
Subst.Gr:
Defined:
globally; see XML source
Includes:
definitions of 6 attributes
Used:
never
username-password-filter Authenticates a message based on username and password expressions.
Type:
Content:
complex, 2 attributes, attr. wildcard, 1 element
Subst.Gr:
Defined:
globally; see XML source
Used:
never
validator Deprecated.
Type:
Content:
complex, 12 attributes, attr. wildcard, 6 elements
Subst.Gr:
may substitute for element abstract-flow-construct
Defined:
globally; see XML source
Used:
never
value-extractor-transformer Extracts values from a given source using regular expressions and uses that values to enrich the mule message.
Type:
Content:
complex, 6 attributes, attr. wildcard, 2 elements
Subst.Gr:
may substitute for elements: abstract-transformer, abstract-message-processor
Defined:
globally; see XML source
Used:
never
weblogic-transaction-manager The WebLogic transaction manager.
Type:
Content:
complex, attr. wildcard, 2 elements
Subst.Gr:
may substitute for element abstract-transaction-manager
Defined:
globally; see XML source
Used:
never
websphere-transaction-manager The WebSphere transaction manager.
Type:
Content:
complex, 1 attribute, attr. wildcard, 1 element
Subst.Gr:
may substitute for element abstract-transaction-manager
Defined:
globally; see XML source
Used:
never
when
Type:
Content:
complex, 3 attributes, 3 elements
Defined:
wildcard-filter A filter that matches string messages against wildcards.
Type:
Content:
complex, 3 attributes, attr. wildcard, 1 element
Subst.Gr:
may substitute for elements: abstract-filter, abstract-message-processor
Defined:
globally; see XML source
Used:
never
wire-tap The WireTap inbound router allows you to route certain messages to a different endpoint as well as to the component.
Type:
Content:
complex, attr. wildcard, 5 elements
Subst.Gr:
Defined:
globally; see XML source
Includes:
definition of 1 element
Used:
never
wire-tap-router The WireTap inbound router allows you to route certain messages to a different endpoint as well as to the component.
Type:
Content:
complex, attr. wildcard, 3 elements
Subst.Gr:
may substitute for element abstract-inbound-router
Defined:
globally; see XML source
Used:
never
xa-transaction An XA transaction.
Type:
Content:
empty, 3 attributes
Subst.Gr:
may substitute for element abstract-transaction
Defined:
globally; see XML source
Used:
never
xml-entity-decoder-transformer A transformer that decodes a string containing XML entities.
Type:
Content:
complex, 5 attributes, attr. wildcard, 1 element
Subst.Gr:
may substitute for elements: abstract-transformer, abstract-message-processor
Defined:
globally; see XML source
Used:
never
xml-entity-encoder-transformer A transformer that encodes a string using XML entities.
Type:
Content:
complex, 5 attributes, attr. wildcard, 1 element
Subst.Gr:
may substitute for elements: abstract-transformer, abstract-message-processor
Defined:
globally; see XML source
Used:
never
Complex Type Summary
Content:
complex, attr. wildcard, 1 element
Defined:
globally; see XML source
Used:
Content:
empty
Defined:
globally; see XML source
Used:
Content:
complex, 1 attribute, attr. wildcard, 1 element
Defined:
globally; see XML source
Includes:
definition of 1 attribute
Used:
Content:
empty
Defined:
globally; see XML source
Used:
Content:
complex, attr. wildcard, 3 elements
Defined:
globally; see XML source
Used:
at 11 locations
Content:
complex, 1 attribute, attr. wildcard, 1 element
Defined:
globally; see XML source
Includes:
definition of 1 attribute
Used:
Content:
empty
Defined:
globally; see XML source
Used:
Content:
empty
Defined:
globally; see XML source
Used:
Content:
complex, 3 attributes, attr. wildcard, 6 elements
Defined:
globally; see XML source
Includes:
definitions of 2 elements
Used:
Content:
complex, attr. wildcard, 1 element
Defined:
globally; see XML source
Used:
at 11 locations
Content:
complex, 1 attribute, attr. wildcard, 1 element
Defined:
globally; see XML source
Includes:
definition of 1 attribute
Used:
at 17 locations
Content:
complex, 3 attributes, attr. wildcard, 1 element
Defined:
globally; see XML source
Includes:
definitions of 3 attributes
Used:
Content:
complex, 1 attribute, attr. wildcard, 1 element
Defined:
globally; see XML source
Includes:
definition of 1 attribute
Used:
Content:
complex, 1 attribute, attr. wildcard, 1 element
Defined:
globally; see XML source
Includes:
definition of 1 attribute
Used:
Content:
complex, 1 attribute, attr. wildcard, 1 element
Defined:
globally; see XML source
Includes:
definition of 1 attribute
Used:
Content:
complex, attr. wildcard, 1 element
Defined:
globally; see XML source
Used:
Content:
complex, attr. wildcard, 1 element
Defined:
globally; see XML source
Used:
at 10 locations
Content:
complex, 1 attribute, attr. wildcard, 2 elements
Defined:
globally; see XML source
Includes:
definitions of 1 attribute, 1 element
Used:
Content:
complex, attr. wildcard, 1 element
Defined:
globally; see XML source
Used:
Allows a lifecycle adaptor factory to be implemented, which allows an alternative custom lifecycle adaptor to be used if required instead of the default implementation that propagates the Mule lifecycle to component implementations.
Content:
empty
Defined:
globally; see XML source
Used:
Content:
empty
Defined:
globally; see XML source
Used:
Content:
empty
Abstract:
(cannot be assigned directly to elements used in instance XML documents)
Defined:
globally; see XML source
Used:
Content:
complex, attr. wildcard, 1 element
Defined:
globally; see XML source
Used:
at 20 locations
Content:
complex, attr. wildcard, 1 element
Defined:
globally; see XML source
Used:
Content:
mixed (allows character data), attr. wildcard, 1 element
Defined:
globally; see XML source
Used:
Content:
complex, attr. wildcard, 1 element
Defined:
globally; see XML source
Used:
Content:
complex, 1 attribute, attr. wildcard, 5 elements
Defined:
globally; see XML source
Includes:
definitions of 1 attribute, 2 elements
Used:
Content:
empty, 4 attributes
Defined:
globally; see XML source
Includes:
definitions of 4 attributes
Used:
Content:
complex, 3 attributes, attr. wildcard, 1 element
Defined:
globally; see XML source
Includes:
definitions of 3 attributes
Used:
An object factory is used to obtain object instances.
Content:
complex, 2 elements
Defined:
globally; see XML source
Used:
Content:
empty
Defined:
globally; see XML source
Used:
Content:
complex, attr. wildcard, 1 element
Defined:
globally; see XML source
Used:
Content:
complex, 1 attribute, attr. wildcard, 1 element
Defined:
globally; see XML source
Includes:
definition of 1 attribute
Used:
Content:
complex, attr. wildcard, 1 element
Defined:
globally; see XML source
Used:
Content:
empty
Defined:
globally; see XML source
Used:
Content:
empty
Defined:
globally; see XML source
Used:
Content:
complex, attr. wildcard, 1 element
Abstract:
(cannot be assigned directly to elements used in instance XML documents)
Defined:
globally; see XML source
Used:
Content:
complex, 1 attribute, 1 element
Defined:
globally; see XML source
Includes:
definitions of 1 attribute, 1 element
Used:
Content:
empty
Defined:
globally; see XML source
Used:
Content:
complex, 1 attribute, attr. wildcard, 2 elements
Defined:
globally; see XML source
Includes:
definitions of 1 attribute, 1 element
Used:
Content:
complex, attr. wildcard, 1 element
Defined:
globally; see XML source
Used:
Content:
complex, attr. wildcard, 1 element
Defined:
globally; see XML source
Used:
at 10 locations
Content:
complex, 2 attributes, attr. wildcard, 1 element
Defined:
globally; see XML source
Includes:
definitions of 2 attributes
Used:
Content:
empty
Defined:
globally; see XML source
Used:
Content:
complex, 1 attribute, attr. wildcard, 1 element
Defined:
globally; see XML source
Includes:
definition of 1 attribute
Used:
Content:
complex, 1 attribute, attr. wildcard, 5 elements
Defined:
globally; see XML source
Includes:
definitions of 1 attribute, 1 element
Used:
Content:
complex, attr. wildcard, 1 element
Defined:
globally; see XML source
Used:
Content:
empty, 2 attributes
Defined:
globally; see XML source
Includes:
definitions of 2 attributes
Used:
Content:
complex, 5 attributes, attr. wildcard, 1 element
Defined:
globally; see XML source
Includes:
definitions of 4 attributes
Used:
at 60 locations
Content:
mixed (allows character data), attr. wildcard, 1 element
Abstract:
(cannot be assigned directly to elements used in instance XML documents)
Defined:
globally; see XML source
Includes:
definitions of attr. wildcard, 1 element
Used:
Content:
complex, attr. wildcard, 1 element
Abstract:
(cannot be assigned directly to elements used in instance XML documents)
Defined:
globally; see XML source
Includes:
definitions of attr. wildcard, 1 element
Used:
at 33 locations
Content:
complex, elem. wildcard
Defined:
globally; see XML source
Includes:
definition of elem. wildcard
Used:
Content:
complex, 6 attributes, attr. wildcard, 1 element
Defined:
globally; see XML source
Includes:
definition of 1 attribute
Used:
Content:
complex, 7 attributes, attr. wildcard, 1 element
Defined:
globally; see XML source
Includes:
definitions of 2 attributes
Used:
Content:
complex, 2 attributes, 5 elements
Defined:
globally; see XML source
Includes:
definitions of 2 attributes, 5 elements
Used:
Content:
complex, 1 element
Defined:
globally; see XML source
Includes:
definition of 1 element
Used:
Content:
complex, 2 attributes, attr. wildcard, 4 elements
Defined:
globally; see XML source
Includes:
definitions of 2 attributes
Used:
Content:
complex, 2 attributes, attr. wildcard, 1 element
Defined:
globally; see XML source
Includes:
definitions of 2 attributes
Used:
Content:
complex, 4 attributes, attr. wildcard, 2 elements
Defined:
globally; see XML source
Includes:
definitions of 4 attributes, 1 element
Used:
Content:
empty, 1 attribute
Defined:
globally; see XML source
Includes:
definition of 1 attribute
Used:
Base support for a flow construct.
Content:
complex, 4 attributes, attr. wildcard, 2 elements
Defined:
globally; see XML source
Includes:
definitions of 1 attribute, 1 element
Used:
Content:
complex, 1 attribute, attr. wildcard, 5 elements
Defined:
globally; see XML source
Includes:
definition of 1 element
Used:
Base support for a model-based wrapper around the POJO service (SEDA, Streaming, etc.)
Content:
complex, 2 attributes, attr. wildcard, 8 elements
Defined:
globally; see XML source
Includes:
definitions of 1 attribute, 7 elements
Used:
Content:
complex, attr. wildcard, 4 elements
Defined:
globally; see XML source
Used:
Content:
complex, 1 attribute, attr. wildcard, 2 elements
Defined:
globally; see XML source
Includes:
definition of 1 element
Used:
Content:
empty, 2 attributes
Defined:
globally; see XML source
Used:
A bridge with a single inbound endpoint and a single outbound endpoint.
Content:
complex, 12 attributes, attr. wildcard, 5 elements
Defined:
globally; see XML source
Includes:
definitions of 7 attributes, 3 elements
Used:
Content:
complex, 3 attributes, attr. wildcard, 1 element
Defined:
globally; see XML source
Includes:
definition of 1 attribute
Used:
Content:
complex, 3 attributes, attr. wildcard, 4 elements
Defined:
globally; see XML source
Used:
Content:
complex, 1 attribute, attr. wildcard, 2 elements
Defined:
globally; see XML source
Includes:
definitions of 1 attribute, 1 element
Used:
Content:
complex, 5 attributes, attr. wildcard, 6 elements
Defined:
globally; see XML source
Includes:
definitions of 2 attributes
Used:
Content:
complex, 1 attribute, attr. wildcard, 2 elements
Defined:
globally; see XML source
Includes:
definition of 1 element
Used:
Content:
complex, attr. wildcard, 1 element
Defined:
globally; see XML source
Used:
Content:
complex, attr. wildcard, 1 element
Defined:
globally; see XML source
Used:
at 11 locations
Content:
complex, 2 attributes, 3 elements
Defined:
globally; see XML source
Includes:
definitions of 1 attribute, 1 element
Used:
Content:
complex, attr. wildcard, 3 elements
Defined:
globally; see XML source
Used:
Content:
complex, 7 attributes, attr. wildcard, 7 elements
Defined:
globally; see XML source
Includes:
definitions of 7 attributes, 6 elements
Used:
Content:
complex, 4 attributes, attr. wildcard, 6 elements
Defined:
globally; see XML source
Includes:
definitions of 3 attributes, 5 elements
Used:
at 17 locations
Content:
complex, 1 attribute, attr. wildcard, 1 element
Defined:
globally; see XML source
Includes:
definition of 1 attribute
Used:
Content:
complex, 1 attribute, attr. wildcard, 1 element
Defined:
globally; see XML source
Includes:
definition of 1 attribute
Used:
Content:
complex, 2 attributes, attr. wildcard, 2 elements
Defined:
globally; see XML source
Includes:
definitions of 2 attributes, 1 element
Used:
Content:
complex, 1 attribute, 2 elements
Defined:
globally; see XML source
Includes:
definitions of 1 attribute, 1 element
Used:
Content:
complex, 1 attribute, 1 element
Defined:
globally; see XML source
Includes:
definitions of 1 attribute, 1 element
Used:
Content:
complex, 5 attributes, attr. wildcard, 6 elements
Defined:
globally; see XML source
Includes:
definition of 1 attribute
Used:
Content:
complex, 3 attributes, attr. wildcard, 2 elements
Defined:
globally; see XML source
Includes:
definitions of 1 attribute, 1 element
Used:
Content:
complex, 2 attributes, 1 element
Defined:
globally; see XML source
Includes:
definitions of 1 attribute, 1 element
Used:
Content:
complex, 1 attribute, 1 element
Defined:
globally; see XML source
Includes:
definitions of 1 attribute, 1 element
Used:
Content:
complex, 1 attribute, 1 element
Defined:
globally; see XML source
Includes:
definitions of 1 attribute, 1 element
Used:
Content:
complex, 4 attributes, attr. wildcard, 7 elements
Defined:
globally; see XML source
Includes:
definitions of 1 attribute, 1 element
Used:
Content:
complex, 2 attributes, attr. wildcard, 2 elements
Defined:
globally; see XML source
Includes:
definitions of 1 attribute, 1 element
Used:
Content:
complex, 1 attribute, 2 elements
Defined:
globally; see XML source
Includes:
definitions of 1 attribute, 1 element
Used:
Content:
complex, 1 attribute, attr. wildcard, 2 elements
Defined:
globally; see XML source
Includes:
definitions of 1 attribute, 1 element
Used:
Content:
complex, 1 attribute, attr. wildcard, 2 elements
Defined:
globally; see XML source
Includes:
definitions of 1 attribute, 1 element
Used:
Content:
complex, 1 attribute, 1 element
Defined:
globally; see XML source
Includes:
definitions of 1 attribute, 1 element
Used:
Content:
complex, 1 attribute, 1 element
Defined:
globally; see XML source
Includes:
definitions of 1 attribute, 1 element
Used:
Content:
complex, 2 attributes, attr. wildcard, 2 elements
Defined:
globally; see XML source
Includes:
definitions of 2 attributes, 1 element
Used:
Content:
complex, 1 attribute, attr. wildcard, 2 elements
Defined:
globally; see XML source
Includes:
definitions of 1 attribute, 1 element
Used:
Content:
complex, 1 attribute, 1 element
Defined:
globally; see XML source
Includes:
definitions of 1 attribute, 1 element
Used:
Content:
complex, 3 attributes, attr. wildcard, 7 elements
Defined:
globally; see XML source
Includes:
definitions of 1 attribute, 2 elements
Used:
Content:
complex, 2 attributes, attr. wildcard, 2 elements
Defined:
globally; see XML source
Includes:
definitions of 1 attribute, 1 element
Used:
Content:
complex, 2 attributes, attr. wildcard, 2 elements
Defined:
globally; see XML source
Includes:
definitions of 2 attributes, 1 element
Used:
Content:
complex, 1 attribute, attr. wildcard, 2 elements
Defined:
globally; see XML source
Includes:
definitions of 1 attribute, 1 element
Used:
Content:
complex, 2 attributes, 1 element
Defined:
globally; see XML source
Includes:
definitions of 1 attribute, 1 element
Used:
Content:
complex, 3 attributes, attr. wildcard, 9 elements
Defined:
globally; see XML source
Includes:
definitions of 1 attribute, 1 element
Used:
Content:
complex, 1 attribute, attr. wildcard, 3 elements
Defined:
globally; see XML source
Includes:
definitions of 1 attribute, 1 element
Used:
Content:
empty, 4 attributes
Defined:
globally; see XML source
Includes:
definitions of 2 attributes
Used:
Content:
complex, 6 attributes, attr. wildcard, 2 elements
Defined:
globally; see XML source
Includes:
definitions of 1 attribute, 1 element
Used:
Content:
mixed (allows character data), 3 attributes
Defined:
globally; see XML source
Includes:
definitions of 3 attributes
Used:
Content:
complex, attr. wildcard, 3 elements
Defined:
globally; see XML source
Used:
Content:
complex, 1 attribute, attr. wildcard, 8 elements
Defined:
globally; see XML source
Includes:
definitions of 1 attribute, 3 elements
Used:
Content:
complex, 2 attributes, attr. wildcard, 6 elements
Defined:
globally; see XML source
Used:
Content:
complex, attr. wildcard, 1 element
Defined:
globally; see XML source
Used:
Content:
empty, 4 attributes
Defined:
globally; see XML source
Includes:
definitions of 4 attributes
Used:
Content:
mixed (allows character data)
Defined:
globally; see XML source
Used:
Content:
empty, 4 attributes
Defined:
globally; see XML source
Includes:
definitions of 4 attributes
Used:
Content:
complex, 1 attribute, attr. wildcard, 1 element
Defined:
globally; see XML source
Includes:
definition of 1 attribute
Used:
An encryption strategy provides support for a specific encryption algorithm.
Content:
empty, 1 attribute
Defined:
globally; see XML source
Includes:
definition of 1 attribute
Used:
Content:
complex, 6 attributes, attr. wildcard, 1 element
Defined:
globally; see XML source
Includes:
definition of 1 attribute
Used:
Content:
empty, 2 attributes
Defined:
globally; see XML source
Includes:
definitions of 2 attributes
Used:
Content:
complex, 7 attributes, attr. wildcard, 6 elements
Defined:
globally; see XML source
Includes:
definition of 1 attribute
Used:
Content:
empty, 1 attribute
Defined:
globally; see XML source
Includes:
definition of 1 attribute
Used:
Base type for every exception strategy.
Content:
complex, attr. wildcard, 1 element
Defined:
globally; see XML source
Used:
Content:
complex, 5 attributes, attr. wildcard, 1 element
Defined:
globally; see XML source
Includes:
definitions of 4 attributes
Used:
Content:
empty, 2 attributes
Defined:
globally; see XML source
Includes:
definitions of 2 attributes
Used:
Content:
complex, 7 attributes, attr. wildcard, 6 elements
Defined:
globally; see XML source
Includes:
definition of 1 element
Used:
Content:
complex, 7 attributes, attr. wildcard, 5 elements
Defined:
globally; see XML source
Includes:
definition of 1 attribute
Used:
Content:
complex, 9 attributes, attr. wildcard, 6 elements
Defined:
globally; see XML source
Used:
Content:
complex, 9 attributes, attr. wildcard, 2 elements
Defined:
globally; see XML source
Includes:
definitions of 1 attribute, 1 element
Used:
Content:
complex, 1 element
Defined:
globally; see XML source
Includes:
definition of 1 element
Used:
Content:
empty, 2 attributes
Defined:
globally; see XML source
Used:
Content:
empty, 4 attributes
Defined:
globally; see XML source
Used:
Content:
complex, attr. wildcard, 2 elements
Defined:
globally; see XML source
Includes:
definition of 1 element
Used:
Content:
complex, 3 attributes, attr. wildcard, 6 elements
Defined:
globally; see XML source
Includes:
definition of 1 element
Used:
Content:
complex, 3 attributes, attr. wildcard, 10 elements
Defined:
globally; see XML source
Includes:
definitions of 3 attributes, 4 elements
Used:
Content:
complex, 4 attributes, attr. wildcard, 4 elements
Defined:
globally; see XML source
Includes:
definitions of 4 attributes
Used:
Content:
complex, 1 element
Defined:
globally; see XML source
Includes:
definition of 1 element
Used:
Content:
complex, 1 element
Defined:
globally; see XML source
Includes:
definition of 1 element
Used:
never
Content:
complex, 11 attributes, attr. wildcard, 16 elements
Defined:
globally; see XML source
Used:
at 11 locations
Content:
complex, 10 attributes, attr. wildcard, 16 elements
Defined:
globally; see XML source
Used:
at 12 locations
Content:
complex, 11 attributes, attr. wildcard, 15 elements
Defined:
globally; see XML source
Used:
Content:
complex, 2 attributes, attr. wildcard, 1 element
Defined:
globally; see XML source
Includes:
definitions of 2 attributes
Used:
Content:
complex, 5 attributes, attr. wildcard, 2 elements
Defined:
globally; see XML source
Includes:
definitions of 4 attributes, 1 element
Used:
Content:
complex, 1 attribute, attr. wildcard, 2 elements
Defined:
globally; see XML source
Includes:
definitions of 1 attribute, 1 element
Used:
Content:
complex, 4 attributes, attr. wildcard, 2 elements
Defined:
globally; see XML source
Includes:
definitions of 3 attributes
Used:
Content:
complex, 1 attribute, attr. wildcard, 2 elements
Defined:
globally; see XML source
Includes:
definitions of 1 attribute, 1 element
Used:
Content:
complex, 8 elements
Defined:
globally; see XML source
Includes:
definitions of 8 elements
Used:
Content:
complex, 11 attributes, attr. wildcard, 16 elements
Defined:
globally; see XML source
Used:
at 12 locations
Content:
complex, 10 attributes, attr. wildcard, 16 elements
Defined:
globally; see XML source
Used:
at 10 locations
Content:
complex, 11 attributes, attr. wildcard, 15 elements
Defined:
globally; see XML source
Used:
Content:
complex, 5 attributes, attr. wildcard, 1 element
Defined:
globally; see XML source
Includes:
definitions of 5 attributes
Used:
Content:
complex, 8 attributes, attr. wildcard, 8 elements
Defined:
globally; see XML source
Includes:
definitions of 4 attributes, 2 elements
Used:
Content:
complex, attr. wildcard, 2 elements
Defined:
globally; see XML source
Includes:
definition of 1 element
Used:
Content:
empty, 1 attribute
Defined:
globally; see XML source
Includes:
definition of 1 attribute
Used:
Content:
empty, 3 attributes
Defined:
globally; see XML source
Includes:
definitions of 2 attributes
Used:
at 12 locations
Content:
complex, 1 attribute, 22 elements, 2 elem. wildcards
Defined:
globally; see XML source
Used:
Content:
complex, 3 attributes, attr. wildcard, 1 element
Defined:
globally; see XML source
Includes:
definitions of 3 attributes
Used:
Content:
empty
Defined:
globally; see XML source
Used:
Content:
empty, 5 attributes
Defined:
globally; see XML source
Includes:
definitions of 5 attributes
Used:
Content:
complex, 2 attributes, 4 elements
Defined:
globally; see XML source
Used:
Content:
complex, 2 attributes, attr. wildcard, 1 element
Defined:
globally; see XML source
Used:
Content:
complex, 2 attributes, attr. wildcard, 5 elements
Defined:
globally; see XML source
Includes:
definitions of 2 attributes, 1 element
Used:
Content:
complex, 3 attributes, attr. wildcard, 2 elements
Defined:
globally; see XML source
Includes:
definitions of 2 attributes, 1 element
Used:
Content:
complex, 1 attribute, attr. wildcard, 5 elements
Defined:
globally; see XML source
Includes:
definitions of 1 attribute, 1 element
Used:
Content:
complex, 7 attributes, attr. wildcard, 5 elements
Defined:
globally; see XML source
Includes:
definitions of 2 attributes, 4 elements
Used:
Content:
complex, 3 attributes, attr. wildcard, 6 elements
Defined:
globally; see XML source
Used:
Content:
complex, 1 attribute, 1 element
Defined:
globally; see XML source
Includes:
definition of 1 element
Used:
Content:
empty, 1 attribute
Defined:
globally; see XML source
Includes:
definition of 1 attribute
Used:
Content:
complex, 1 attribute, attr. wildcard, 30 elements
Defined:
globally; see XML source
Includes:
definitions of 1 attribute, 1 element
Used:
Content:
complex, 3 attributes, attr. wildcard, 6 elements
Defined:
globally; see XML source
Includes:
definition of 1 element
Used:
Content:
empty, 1 attribute
Defined:
globally; see XML source
Includes:
definition of 1 attribute
Used:
Content:
empty, 3 attributes
Defined:
globally; see XML source
Includes:
definitions of 2 attributes
Used:
Content:
complex, 1 attribute, attr. wildcard, 4 elements
Defined:
globally; see XML source
Includes:
definitions of 1 attribute, 3 elements
Used:
Content:
complex, 3 elements
Defined:
globally; see XML source
Used:
Content:
complex, 1 attribute, 2 elements
Defined:
globally; see XML source
Includes:
definitions of 1 attribute, 2 elements
Used:
Content:
complex, 11 attributes, attr. wildcard, 16 elements
Defined:
globally; see XML source
Used:
at 11 locations
Content:
complex, 10 attributes, attr. wildcard, 16 elements
Defined:
globally; see XML source
Used:
Content:
complex, 11 attributes, attr. wildcard, 15 elements
Defined:
globally; see XML source
Used:
Content:
complex, 1 attribute, attr. wildcard, 4 elements
Defined:
globally; see XML source
Includes:
definition of 1 element
Used:
Content:
complex, 6 attributes, attr. wildcard, 1 element
Defined:
globally; see XML source
Includes:
definition of 1 attribute
Used:
Content:
empty, 4 attributes
Defined:
globally; see XML source
Includes:
definitions of 3 attributes
Used:
Content:
complex, 2 attributes, attr. wildcard, 1 element
Defined:
globally; see XML source
Includes:
definition of 1 attribute
Used:
Content:
complex, 2 attributes, 1 element
Defined:
globally; see XML source
Includes:
definitions of 2 attributes, 1 element
Used:
Content:
complex, 1 attribute, attr. wildcard, 4 elements
Defined:
globally; see XML source
Includes:
definition of 1 attribute
Used:
Content:
complex, 1 attribute, attr. wildcard, 9 elements
Defined:
globally; see XML source
Includes:
definition of 1 element
Used:
A pooling profile is used to configure the pooling behaviour of Mule components.
Content:
empty, 5 attributes
Defined:
globally; see XML source
Includes:
definitions of 5 attributes
Used:
Content:
complex, 1 attribute, attr. wildcard, 1 element
Defined:
globally; see XML source
Includes:
definition of 1 attribute
Used:
Content:
complex, attr. wildcard, 4 elements
Defined:
globally; see XML source
Used:
Content:
complex, attr. wildcard, 4 elements
Defined:
globally; see XML source
Used:
Content:
empty, 2 attributes
Defined:
globally; see XML source
Includes:
definition of 1 attribute
Used:
Object factory that creates and returns a new 'prototype' object instance every time it is called.
Content:
complex, 1 attribute, 2 elements
Defined:
globally; see XML source
Includes:
definition of 1 attribute
Used:
Content:
complex, 9 attributes, attr. wildcard, 2 elements
Defined:
globally; see XML source
Includes:
definitions of 2 attributes, 1 element
Used:
Content:
complex, 1 attribute, 1 element
Defined:
globally; see XML source
Includes:
definitions of 1 attribute, 1 element
Used:
Content:
complex, 1 attribute, 1 element
Defined:
globally; see XML source
Includes:
definitions of 1 attribute, 1 element
Used:
Content:
complex, 2 attributes, 2 elements
Defined:
globally; see XML source
Includes:
definitions of 1 attribute, 1 element
Used:
Content:
complex, 2 attributes, 1 element
Defined:
globally; see XML source
Includes:
definition of 1 attribute
Used:
Content:
empty
Defined:
globally; see XML source
Used:
Content:
complex, 3 attributes, 1 element
Defined:
globally; see XML source
Includes:
definitions of 2 attributes
Used:
Used to reference another exception strategy within flow, service or global exception strategy.
Content:
complex, 1 attribute, attr. wildcard, 1 element
Defined:
globally; see XML source
Includes:
definition of 1 attribute
Used:
Content:
empty, 1 attribute
Defined:
globally; see XML source
Includes:
definition of 1 attribute
Used:
never
Content:
complex, 1 attribute, attr. wildcard, 1 element
Defined:
globally; see XML source
Includes:
definition of 1 attribute
Used:
Content:
empty, 1 attribute
Defined:
globally; see XML source
Includes:
definition of 1 attribute
Used:
Content:
complex, 1 attribute, 2 elements
Defined:
globally; see XML source
Includes:
definitions of 2 elements
Used:
Content:
complex, 1 attribute, attr. wildcard, 1 element
Defined:
globally; see XML source
Includes:
definition of 1 attribute
Used:
Content:
complex, 1 attribute, attr. wildcard, 1 element
Defined:
globally; see XML source
Includes:
definition of 1 attribute
Used:
Content:
complex, 1 attribute, attr. wildcard, 1 element
Defined:
globally; see XML source
Includes:
definition of 1 attribute
Used:
Content:
complex, 3 attributes, attr. wildcard, 1 element
Defined:
globally; see XML source
Includes:
definition of 1 attribute
Used:
Content:
complex, 1 attribute, attr. wildcard, 1 element
Defined:
globally; see XML source
Includes:
definition of 1 attribute
Used:
Content:
complex, 1 attribute, attr. wildcard, 1 element
Defined:
globally; see XML source
Includes:
definition of 1 attribute
Used:
Content:
complex, 1 attribute, attr. wildcard, 1 element
Defined:
globally; see XML source
Includes:
definition of 1 attribute
Used:
Content:
complex, 2 attributes, attr. wildcard, 5 elements
Defined:
globally; see XML source
Includes:
definitions of 2 attributes, 1 element
Used:
Content:
complex, 4 attributes, attr. wildcard, 5 elements
Defined:
globally; see XML source
Includes:
definitions of 1 attribute, 1 element
Used:
Content:
complex, 6 attributes, attr. wildcard, 6 elements
Defined:
globally; see XML source
Includes:
definitions of 3 attributes
Used:
Content:
complex, 4 attributes, attr. wildcard, 1 element
Defined:
globally; see XML source
Includes:
definition of 1 attribute
Used:
Content:
empty, 3 attributes
Defined:
globally; see XML source
Includes:
definitions of 2 attributes
Used:
The default security manager (type 'defaultSecurityManagerType') provides basic support for security functions.
Content:
complex, 2 attributes, attr. wildcard, 5 elements
Defined:
globally; see XML source
Includes:
definitions of 4 elements
Used:
A security provider is a source of specific security-related functionality.
Content:
empty, 1 attribute
Defined:
globally; see XML source
Includes:
definition of 1 attribute
Used:
Content:
complex, 2 attributes, attr. wildcard, 6 elements
Defined:
globally; see XML source
Includes:
definitions of 1 attribute, 1 element
Used:
Content:
complex, 3 attributes, attr. wildcard, 10 elements
Defined:
globally; see XML source
Includes:
definitions of 1 attribute, 2 elements
Used:
Content:
complex, attr. wildcard, 3 elements
Defined:
globally; see XML source
Includes:
definitions of 2 elements
Used:
Content:
complex, 4 attributes, attr. wildcard, 6 elements
Defined:
globally; see XML source
Includes:
definition of 1 attribute
Used:
Content:
empty, 14 attributes
Defined:
globally; see XML source
Includes:
definitions of 14 attributes
Used:
Content:
complex, 3 attributes, attr. wildcard, 1 element
Defined:
globally; see XML source
Includes:
definitions of 3 attributes
Used:
Content:
complex, 6 attributes, attr. wildcard, 1 element
Defined:
globally; see XML source
Includes:
definition of 1 attribute
Used:
Content:
complex, 2 attributes, attr. wildcard, 1 element
Defined:
globally; see XML source
Includes:
definitions of 2 attributes
Used:
Content:
complex, 2 attributes, attr. wildcard, 1 element
Defined:
globally; see XML source
Includes:
definitions of 2 attributes
Used:
A simple request-response service, with no outbound router.
Content:
complex, 11 attributes, attr. wildcard, 5 elements
Defined:
globally; see XML source
Includes:
definitions of 6 attributes, 3 elements
Used:
Content:
complex, 3 attributes, attr. wildcard, 6 elements
Defined:
globally; see XML source
Includes:
definition of 1 element
Used:
Content:
complex, attr. wildcard, 4 elements
Defined:
globally; see XML source
Used:
Object factory that creates and always returns a singleton object instance.
Content:
complex, 1 attribute, 2 elements
Defined:
globally; see XML source
Includes:
definition of 1 attribute
Used:
Object factory used to obtain Spring bean instances.
Content:
complex, 1 attribute, 2 elements
Defined:
globally; see XML source
Includes:
definition of 1 attribute
Used:
Content:
empty, 1 attribute
Defined:
globally; see XML source
Includes:
definition of 1 attribute
Used:
Content:
complex, attr. wildcard, 4 elements
Defined:
globally; see XML source
Includes:
definition of 1 element
Used:
Content:
complex, 6 attributes, attr. wildcard, 6 elements
Defined:
globally; see XML source
Includes:
definitions of 3 attributes, 1 element
Used:
Content:
complex, 1 attribute, attr. wildcard, 5 elements
Defined:
globally; see XML source
Includes:
definitions of 1 attribute, 1 element
Used:
Content:
empty, 5 attributes
Defined:
globally; see XML source
Includes:
definition of 1 attribute
Used:
Content:
empty, 7 attributes
Defined:
globally; see XML source
Includes:
definitions of 3 attributes
Used:
Configure client key stores.
Content:
empty, 4 attributes
Defined:
globally; see XML source
Includes:
definitions of 4 attributes
Used:
Configures key stores.
Content:
empty, 7 attributes
Defined:
globally; see XML source
Includes:
definitions of 7 attributes
Used:
Configures the global Java protocol handler.
Content:
empty, 1 attribute
Defined:
globally; see XML source
Includes:
definition of 1 attribute
Used:
Configures a direct trust store.
Content:
empty, 8 attributes
Defined:
globally; see XML source
Includes:
definitions of 6 attributes
Used:
Configures a trust store.
Content:
empty, 2 attributes
Defined:
globally; see XML source
Includes:
definitions of 2 attributes
Used:
Content:
complex, 6 attributes, attr. wildcard, 6 elements
Defined:
globally; see XML source
Includes:
definitions of 2 attributes
Used:
Content:
complex, 1 attribute, attr. wildcard, 1 element
Defined:
globally; see XML source
Includes:
definition of 1 attribute
Used:
Content:
complex, 2 attributes, attr. wildcard, 1 element
Defined:
globally; see XML source
Includes:
definition of 1 attribute
Used:
Content:
complex, 1 attribute, attr. wildcard, 2 elements
Defined:
globally; see XML source
Includes:
definition of 1 element
Used:
Content:
complex, 2 attributes, attr. wildcard, 1 element
Defined:
globally; see XML source
Includes:
definitions of 2 attributes
Used:
A validator with a single request-response inbound endpoint and a single outbound endpoint.
Content:
complex, 12 attributes, attr. wildcard, 6 elements
Defined:
globally; see XML source
Includes:
definitions of 8 attributes, 4 elements
Used:
Content:
complex, 6 attributes, attr. wildcard, 2 elements
Defined:
globally; see XML source
Includes:
definitions of 1 attribute, 1 element
Used:
Content:
empty, 2 attributes
Defined:
globally; see XML source
Includes:
definitions of 2 attributes
Used:
Content:
complex, 3 attributes, 3 elements
Defined:
globally; see XML source
Includes:
definitions of 3 attributes
Used:
Content:
complex, 3 attributes, attr. wildcard, 1 element
Defined:
globally; see XML source
Used:
Content:
complex, attr. wildcard, 3 elements
Defined:
globally; see XML source
Includes:
definition of 1 element
Used:
Content:
empty, 3 attributes
Defined:
globally; see XML source
Includes:
definition of 1 attribute
Used:
Simple Type Summary
Defined:
globally; see XML source
Used:
at 12 locations
Defined:
globally; see XML source
Used:
A type that defines a Java keystore..
Defined:
globally; see XML source
Used:
A custom xsd:string-like type that cannot be empty.
Defined:
globally; see XML source
Used:
at 12 locations
Defined:
globally; see XML source
Used:
A type that defines a Mule-style property placeholder.
Defined:
globally; see XML source
Used:
Defined:
globally; see XML source
Used:
never
Defined:
globally; see XML source
Used:
A custom xsd:boolean type that also allows for Ant-style property placeholders.
Defined:
globally; see XML source
Used:
at 133 locations
A custom xsd:NMTOKEN-like type that also allows for Ant-style property placeholders and a leading "[".
Defined:
globally; see XML source
Used:
at 50 locations
A custom xsd:int type that also allows for Ant-style property placeholders.
Defined:
globally; see XML source
Used:
at 79 locations
A custom xsd:long type that also allows for Ant-style property placeholders.
Defined:
globally; see XML source
Used:
at 25 locations
A custom xsd:NMTOKEN type that also allows for Ant-style property placeholders.
Defined:
globally; see XML source
Used:
at 36 locations
A custom xsd:int type that also allows for Ant-style property placeholders and restricts the int value to a valid port number.
Defined:
globally; see XML source
Used:
at 15 locations
Defined:
globally; see XML source
Used:
Defined:
globally; see XML source
Used:
Element Group Summary
Content:
Defined:
globally; see XML source
Includes:
definitions of 3 elements
Used:
Content:
Defined:
globally; see XML source
Includes:
definitions of 2 elements
Used:
Content:
Defined:
globally; see XML source
Includes:
definitions of 2 elements
Used:
Content:
Defined:
globally; see XML source
Includes:
definitions of 2 elements
Used:
Content:
Defined:
globally; see XML source
Includes:
definition of 1 element
Used:
Content:
Defined:
globally; see XML source
Includes:
definitions of 8 elements
Used:
Content:
Defined:
globally; see XML source
Includes:
definitions of 2 elements
Used:
Content:
Defined:
globally; see XML source
Includes:
definitions of 2 elements
Used:
Content:
Defined:
globally; see XML source
Includes:
definitions of 3 elements
Used:
at 21 locations
Content:
Defined:
globally; see XML source
Includes:
definitions of 2 elements
Used:
Content:
Defined:
globally; see XML source
Includes:
definitions of 24 elements
Used:
Content:
Defined:
globally; see XML source
Includes:
definitions of 2 elements
Used:
Content:
Defined:
globally; see XML source
Includes:
definitions of 4 elements
Used:
Attribute Group Summary
Content:
Defined:
globally; see XML source
Includes:
definition of 1 attribute
Used:
at 13 locations
Content:
Defined:
globally; see XML source
Includes:
definitions of 4 attributes
Used:
Content:
Defined:
globally; see XML source
Includes:
definition of 1 attribute
Used:
Content:
Defined:
globally; see XML source
Includes:
definitions of 2 attributes
Used:
at 12 locations
Content:
Defined:
globally; see XML source
Includes:
definition of 1 attribute
Used:
Content:
Defined:
globally; see XML source
Includes:
definition of 1 attribute
Used:
Content:
Defined:
globally; see XML source
Includes:
definitions of 2 attributes
Used:
Content:
Defined:
globally; see XML source
Includes:
definitions of 3 attributes
Used:
Content:
Defined:
globally; see XML source
Includes:
definition of 1 attribute
Used:
Content:
Defined:
globally; see XML source
Includes:
definition of 1 attribute
Used:
never
Content:
Defined:
globally; see XML source
Includes:
definitions of 3 attributes
Used:
Content:
Defined:
globally; see XML source
Includes:
definitions of 6 attributes
Used:
Content:
Defined:
globally; see XML source
Includes:
definition of 1 attribute
Used:
Content:
Defined:
globally; see XML source
Includes:
definitions of 4 attributes
Used:
XML Source
<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<xsd:schema attributeFormDefault="unqualified" elementFormDefault="qualified" targetNamespace="http://www.mulesoft.org/schema/mule/core" xmlns="http://www.mulesoft.org/schema/mule/core" xmlns:spring="http://www.springframework.org/schema/beans" xmlns:spring-context="http://www.springframework.org/schema/context" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
<xsd:import namespace="http://www.w3.org/XML/1998/namespace"/>
<!--==============================================================-->
<!-- Structure -->
<!--==============================================================-->
<!-- This defines the structure in abstract terms (except for a few simple/unique things like
global properties). We then provide some implementations below. Other modules
can provide other implementations.
-->
<xsd:complexType name="annotationsType">
<xsd:sequence>
<xsd:any maxOccurs="unbounded" minOccurs="0" processContents="lax"/>
</xsd:sequence>
</xsd:complexType>
<xsd:complexType abstract="true" name="annotatedType">
<xsd:sequence>
<xsd:element minOccurs="0" name="annotations" type="annotationsType"/>
</xsd:sequence>
<xsd:anyAttribute namespace="##other" processContents="lax">
<xsd:annotation>
<xsd:documentation>
Allow any third-parties to annotate these elements with global attributes. All types for
top-level elements must extend this.
</xsd:documentation>
</xsd:annotation>
</xsd:anyAttribute>
</xsd:complexType>
<xsd:complexType abstract="true" mixed="true" name="annotatedMixedContentType">
<xsd:sequence>
<xsd:element minOccurs="0" name="annotations" type="annotationsType"/>
</xsd:sequence>
<xsd:anyAttribute namespace="##other" processContents="lax">
<xsd:annotation>
<xsd:documentation>
Allow any third-parties to annotate these elements with global attributes
</xsd:documentation>
</xsd:annotation>
</xsd:anyAttribute>
</xsd:complexType>
<xsd:element name="mule" type="muleType">
<xsd:annotation>
<xsd:documentation>
Either the root element of a Mule configuration, or a "top-level" element in a Spring configuration that contains further Mule elements.
</xsd:documentation>
</xsd:annotation>
</xsd:element>
<xsd:complexType name="muleType">
<xsd:complexContent>
<xsd:extension base="annotatedType">
<xsd:sequence>
<xsd:element minOccurs="0" name="description" type="descriptionType">
<xsd:annotation>
<xsd:documentation>
Holds any kind of documentation that accompanies this configuration file. It is intended to be "human readable" only and is not used by the system.
</xsd:documentation>
</xsd:annotation>
</xsd:element>
<xsd:choice maxOccurs="unbounded" minOccurs="0">
<xsd:group ref="springRootElements"/>
<xsd:group ref="muleRootElements"/>
</xsd:choice>
</xsd:sequence>
<xsd:attribute name="version" type="xsd:string"/>
</xsd:extension>
</xsd:complexContent>
</xsd:complexType>
<xsd:group name="springRootElements">
<xsd:choice>
<xsd:element ref="spring:beans">
<xsd:annotation>
<xsd:documentation>
Allows the embedding of any Spring elements.
</xsd:documentation>
</xsd:annotation>
</xsd:element>
<xsd:element ref="spring:bean">
<xsd:annotation>
<xsd:documentation>
Allows Spring beans to be defined alongside Mule elements.
</xsd:documentation>
</xsd:annotation>
</xsd:element>
<xsd:annotation>
<xsd:documentation>
Allows Spring property placeholders to be configured directly in the Mule configuration file.
</xsd:documentation>
</xsd:annotation>
</xsd:element>
<xsd:element ref="spring:ref">
<xsd:annotation>
<xsd:documentation>
Allows to reference Spring beans alongside Mule elements.
</xsd:documentation>
</xsd:annotation>
</xsd:element>
</xsd:choice>
</xsd:group>
<xsd:group name="muleRootElements">
<xsd:choice>
<xsd:element ref="global-property"/>
<xsd:element ref="configuration"/>
<xsd:element ref="notifications"/>
<xsd:element ref="abstract-extension"/>
<xsd:element ref="abstract-agent"/>
<xsd:element ref="abstract-security-manager"/>
<xsd:element ref="abstract-transaction-manager"/>
<xsd:element ref="abstract-connector"/>
<xsd:element ref="abstract-global-endpoint"/>
<xsd:element ref="abstract-exception-strategy"/>
<xsd:element ref="abstract-flow-construct"/>
<xsd:element ref="flow"/>
<xsd:element ref="sub-flow"/>
<xsd:element ref="abstract-model"/>
<xsd:element ref="abstract-interceptor-stack"/>
<xsd:element ref="abstract-filter"/>
<xsd:element ref="abstract-transformer"/>
<xsd:element ref="processor-chain"/>
<xsd:element ref="custom-processor"/>
<xsd:element ref="invoke"/>
<xsd:element maxOccurs="unbounded" minOccurs="0" ref="custom-queue-store"/>
<xsd:element maxOccurs="unbounded" minOccurs="0" ref="abstract-processing-strategy"/>
</xsd:choice>
</xsd:group>
<xsd:complexType name="descriptionType">
<xsd:complexContent mixed="true">
<xsd:extension base="xsd:anyType"/>
</xsd:complexContent>
</xsd:complexType>
<xsd:element name="global-property" type="globalPropertyType">
<xsd:annotation>
<xsd:documentation>
A global property is a named string. It can be inserted in most attribute values using standard (ant-style) Spring placeholders.
</xsd:documentation>
</xsd:annotation>
</xsd:element>
<xsd:element name="configuration" type="configurationType">
<xsd:annotation>
<xsd:documentation>
Specifies defaults and general settings for the Mule instance.
</xsd:documentation>
</xsd:annotation>
</xsd:element>
<xsd:element name="notifications" type="notificationManagerType">
<xsd:annotation>
<xsd:documentation>
Registers listeners for notifications and associates interfaces with particular events.
</xsd:documentation>
</xsd:annotation>
</xsd:element>
<xsd:element abstract="true" name="abstract-extension" type="abstractExtensionType">
<xsd:annotation>
<xsd:documentation>
A placeholder for arbitrary extensions as children of the 'mule' element. Other transports and modules can extend this if they need to add global elements to the configuration (but consider the more specific elements like abstract-connector first).
</xsd:documentation>
</xsd:annotation>
</xsd:element>
<xsd:complexType name="abstractExtensionType">
<xsd:complexContent>
<xsd:extension base="annotatedType"/>
</xsd:complexContent>
</xsd:complexType>
<xsd:element abstract="true" name="abstract-mixed-content-extension" type="abstractMixedContentExtensionType">
<xsd:annotation>
<xsd:documentation>
A placeholder for arbitrary extensions as children of the 'mule' element. Other transports and modules can extend this if they need to add global elements with mixed content to the configuration (but consider the more specific elements like abstract-connector first).
</xsd:documentation>
</xsd:annotation>
</xsd:element>
<xsd:complexType name="abstractMixedContentExtensionType">
<xsd:complexContent mixed="true">
<xsd:extension base="annotatedMixedContentType"/>
</xsd:complexContent>
</xsd:complexType>
<xsd:element name="expression-component" substitutionGroup="abstract-mixed-content-message-processor">
<xsd:complexType>
<xsd:complexContent mixed="true">
<xsd:attribute name="file" use="optional"/>
</xsd:extension>
</xsd:complexContent>
</xsd:complexType>
</xsd:element>
<xsd:element abstract="true" name="abstract-connector" type="abstractConnectorType">
<xsd:annotation>
<xsd:documentation>
A placeholder for connector elements. Connector elements allow properties to be configured across all endpoints that use the same transport. If multiple connectors are defined for the same transport, each endpoint must name which connector is being used.
</xsd:documentation>
</xsd:annotation>
</xsd:element>
<xsd:complexType name="abstractConnectorType">
<xsd:complexContent>
<xsd:extension base="annotatedType">
<xsd:attribute name="name" type="substitutableName" use="required">
<xsd:annotation>
<xsd:documentation>
Identifies the connector so that other elements can reference it.
</xsd:documentation>
</xsd:annotation>
</xsd:attribute>
</xsd:extension>
</xsd:complexContent>
</xsd:complexType>
<!-- Agents -->
<xsd:element abstract="true" name="abstract-agent" type="abstractAgentType">
<xsd:annotation>
<xsd:documentation>
A placeholder for agent elements. Are used to run processes as part of the server instance.
</xsd:documentation>
</xsd:annotation>
</xsd:element>
<xsd:complexType name="abstractAgentType">
<xsd:complexContent>
<xsd:extension base="annotatedType"/>
</xsd:complexContent>
</xsd:complexType>
<xsd:element name="custom-agent" substitutionGroup="abstract-agent" type="customAgentType"/>
<xsd:complexType name="customAgentType">
<xsd:complexContent>
<xsd:extension base="abstractAgentType">
<xsd:sequence>
<xsd:element maxOccurs="unbounded" minOccurs="0" ref="spring:property"/>
</xsd:sequence>
<xsd:attribute name="class" type="substitutableClass" use="required"/>
<xsd:attribute name="name" type="substitutableName" use="required">
<xsd:annotation>
<xsd:documentation>
Identifies the agent in the registry.
</xsd:documentation>
</xsd:annotation>
</xsd:attribute>
</xsd:extension>
</xsd:complexContent>
</xsd:complexType>
<xsd:element abstract="true" name="abstract-queue-store" type="abstractQueueStoreType">
<xsd:annotation>
<xsd:documentation>
A placeholder for queue store elements.
</xsd:documentation>
</xsd:annotation>
</xsd:element>
<xsd:complexType abstract="true" name="abstractQueueStoreType">
<xsd:complexContent>
<xsd:extension base="annotatedType"/>
</xsd:complexContent>
</xsd:complexType>
<xsd:complexType name="defaultQueueStoreType">
<xsd:complexContent>
<xsd:extension base="abstractQueueStoreType"/>
</xsd:complexContent>
</xsd:complexType>
<xsd:element name="queue-store" substitutionGroup="abstract-queue-store" type="refQueueStoreType">
<xsd:annotation>
<xsd:documentation>
A reference to a queue store defined elsewhere.
</xsd:documentation>
</xsd:annotation>
</xsd:element>
<xsd:complexType name="refQueueStoreType">
<xsd:complexContent>
<xsd:extension base="abstractQueueStoreType">
<xsd:attribute name="ref" type="xsd:string" use="required">
<xsd:annotation>
<xsd:documentation>
The name of the queue store to use.
</xsd:documentation>
</xsd:annotation>
</xsd:attribute>
</xsd:extension>
</xsd:complexContent>
</xsd:complexType>
<xsd:element name="custom-queue-store" substitutionGroup="abstract-queue-store" type="customQueueStoreType"/>
<xsd:complexType name="customQueueStoreType">
<xsd:complexContent>
<xsd:extension base="abstractQueueStoreType">
<xsd:sequence>
<xsd:element maxOccurs="unbounded" minOccurs="0" ref="spring:property"/>
</xsd:sequence>
<xsd:attribute name="class" type="substitutableClass" use="required"/>
<xsd:attribute name="name" type="substitutableName" use="optional">
<xsd:annotation>
<xsd:documentation>
Identifies the store in the registry.
</xsd:documentation>
</xsd:annotation>
</xsd:attribute>
</xsd:extension>
</xsd:complexContent>
</xsd:complexType>
<xsd:element name="default-in-memory-queue-store" substitutionGroup="abstract-queue-store" type="defaultQueueStoreType">
<xsd:annotation>
<xsd:documentation>
The default in-memory queue store for the application.
</xsd:documentation>
</xsd:annotation>
</xsd:element>
<xsd:element name="default-persistent-queue-store" substitutionGroup="abstract-queue-store" type="defaultQueueStoreType">
<xsd:annotation>
<xsd:documentation>
The default persistent queue store for the application.
</xsd:documentation>
</xsd:annotation>
</xsd:element>
<xsd:element name="simple-in-memory-queue-store" substitutionGroup="abstract-queue-store" type="defaultQueueStoreType">
<xsd:annotation>
<xsd:documentation>
A simple in-memeory queue store.
</xsd:documentation>
</xsd:annotation>
</xsd:element>
<xsd:element name="file-queue-store" substitutionGroup="abstract-queue-store" type="defaultQueueStoreType">
<xsd:annotation>
<xsd:documentation>
A simple file-based queue store.
</xsd:documentation>
</xsd:annotation>
</xsd:element>
<xsd:element abstract="true" name="abstract-global-endpoint" type="abstractGlobalEndpointType">
<xsd:annotation>
<xsd:documentation>
A placeholder for global endpoint elements. Global endpoints are named templates that allow you to define an endpoint once and refer to it in several places. The same template can be used for both inbound and outbound endpoints.
</xsd:documentation>
</xsd:annotation>
</xsd:element>
<xsd:complexType name="abstractGlobalEndpointType">
<xsd:complexContent>
<xsd:extension base="annotatedType">
<xsd:attribute name="name" type="substitutableName" use="required">
<xsd:annotation>
<xsd:documentation>
Identifies the endpoint so that other elements can reference it. This name can also be referenced in the MuleClient.
</xsd:documentation>
</xsd:annotation>
</xsd:attribute>
</xsd:extension>
</xsd:complexContent>
</xsd:complexType>
<xsd:element abstract="true" name="abstract-inbound-endpoint" type="abstractInboundEndpointType">
<xsd:annotation>
<xsd:documentation>
A placeholder for inbound endpoint elements. Inbound endpoints receive messages from the underlying transport. The message payload is then delivered to the component for processing.
</xsd:documentation>
</xsd:annotation>
</xsd:element>
<xsd:complexType name="abstractInboundEndpointType">
<xsd:complexContent>
<xsd:extension base="annotatedType">
<xsd:attribute name="name" type="substitutableName">
<xsd:annotation>
<xsd:documentation>
Identifies the endpoint in the registry. There is no need to set the 'name' attribute on inbound or outbound endpoints, only on global endpoints.
</xsd:documentation>
</xsd:annotation>
</xsd:attribute>
</xsd:extension>
</xsd:complexContent>
</xsd:complexType>
<xsd:element abstract="true" name="abstract-outbound-endpoint" type="abstractOutboundEndpointType">
<xsd:annotation>
<xsd:documentation>
A placeholder for outbound endpoint elements. Outbound endpoints dispatch messages to the underlying transport.
</xsd:documentation>
</xsd:annotation>
</xsd:element>
<xsd:complexType name="abstractOutboundEndpointType">
<xsd:complexContent>
<xsd:extension base="annotatedType">
<xsd:attribute name="name" type="substitutableName">
<xsd:annotation>
<xsd:documentation>
Identifies the endpoint in the registry. There is not need to set the 'name' attribute on inbound or outbound endpoints, only on global endpoints.
</xsd:documentation>
</xsd:annotation>
</xsd:attribute>
</xsd:extension>
</xsd:complexContent>
</xsd:complexType>
<!-- Message Processors -->
<xsd:element abstract="true" name="abstract-message-processor" type="abstractMessageProcessorType">
<xsd:annotation>
<xsd:documentation>
A placeholder for message processor elements.
</xsd:documentation>
</xsd:annotation>
</xsd:element>
<xsd:complexType name="abstractMessageProcessorType">
<xsd:complexContent>
<xsd:extension base="annotatedType"/>
</xsd:complexContent>
</xsd:complexType>
<xsd:annotation>
<xsd:documentation>
A placeholder for message processor elements.
</xsd:documentation>
</xsd:annotation>
</xsd:element>
<xsd:complexContent>
<xsd:extension base="annotatedMixedContentType"/>
</xsd:complexContent>
</xsd:complexType>
<xsd:element abstract="true" name="abstract-observer-message-processor" substitutionGroup="abstract-message-processor" type="abstractObserverMessageProcessorType">
<xsd:annotation>
<xsd:documentation>
A placeholder for message processors that observe the message but do not mutate it used for exmaple for logging.
</xsd:documentation>
</xsd:annotation>
</xsd:element>
<xsd:complexType name="abstractObserverMessageProcessorType">
<xsd:complexContent>
<xsd:extension base="abstractMessageProcessorType"/>
</xsd:complexContent>
</xsd:complexType>
<xsd:choice>
<xsd:element ref="abstract-message-processor">
<xsd:annotation>
<xsd:documentation>
A message processor
</xsd:documentation>
</xsd:annotation>
</xsd:element>
<xsd:element ref="abstract-outbound-endpoint">
<xsd:annotation>
<xsd:documentation>
An outbound endpoint
</xsd:documentation>
</xsd:annotation>
</xsd:element>
</xsd:choice>
</xsd:group>
<xsd:element name="processor" substitutionGroup="abstract-message-processor" type="refMessageProcessorType">
<xsd:annotation>
<xsd:documentation>
A reference to a message processor defined elsewhere.
</xsd:documentation>
</xsd:annotation>
</xsd:element>
<xsd:complexType name="refMessageProcessorType">
<xsd:complexContent>
<xsd:extension base="abstractMessageProcessorType">
<xsd:attribute name="ref" type="xsd:string" use="required">
<xsd:annotation>
<xsd:documentation>
The name of the message processor to use.
</xsd:documentation>
</xsd:annotation>
</xsd:attribute>
</xsd:extension>
</xsd:complexContent>
</xsd:complexType>
<xsd:element name="custom-processor" substitutionGroup="abstract-message-processor" type="customMessageProcessorType"/>
<xsd:complexType name="customMessageProcessorType">
<xsd:complexContent>
<xsd:extension base="abstractMessageProcessorType">
<xsd:sequence>
<xsd:element maxOccurs="unbounded" minOccurs="0" ref="spring:property"/>
</xsd:sequence>
<xsd:attribute name="class" type="substitutableClass" use="required"/>
<xsd:attribute name="name" type="substitutableName" use="optional">
<xsd:annotation>
<xsd:documentation>
Identifies the message processor in the registry.
</xsd:documentation>
</xsd:annotation>
</xsd:attribute>
</xsd:extension>
</xsd:complexContent>
</xsd:complexType>
<xsd:element name="processor-chain" substitutionGroup="abstract-message-processor" type="messageProcessorChainType">
<xsd:annotation>
<xsd:documentation>
The use of globally defined processor-chain element is deprecated since Mule 3.2. Use sub-flow instead.
</xsd:documentation>
</xsd:annotation>
</xsd:element>
<xsd:element name="sub-flow" type="subFlowType">
<xsd:annotation>
<xsd:documentation>
A chain of message processors processed synchronously that can be referenced and reused.
</xsd:documentation>
</xsd:annotation>
</xsd:element>
<xsd:complexType name="subFlowType">
<xsd:complexContent>
<xsd:extension base="annotatedType">
<xsd:sequence>
<xsd:element minOccurs="0" name="description" type="descriptionType">
<xsd:annotation>
<xsd:documentation>
This can hold any kind of documentation related to the sub-flow. It is intended to be
"human readable" only and is not used by the system.
</xsd:documentation>
</xsd:annotation>
</xsd:element>
<xsd:group maxOccurs="unbounded" ref="messageProcessorOrOutboundEndpoint"/>
</xsd:sequence>
<xsd:attribute name="name" type="nonBlankString" use="required">
<xsd:annotation>
<xsd:documentation>
Identifies the sub-flow in the registry.
</xsd:documentation>
</xsd:annotation>
</xsd:attribute>
</xsd:extension>
</xsd:complexContent>
</xsd:complexType>
<xsd:complexType name="messageProcessorChainType">
<xsd:complexContent>
<xsd:extension base="abstractMessageProcessorType">
<xsd:sequence>
<xsd:element minOccurs="0" name="description" type="descriptionType">
<xsd:annotation>
<xsd:documentation>
This can hold any kind of documentation related to the processor chain. It is intended to be "human readable" only and
is not used by the system.
</xsd:documentation>
</xsd:annotation>
</xsd:element>
<xsd:group maxOccurs="unbounded" ref="messageProcessorOrOutboundEndpoint"/>
</xsd:sequence>
<xsd:attribute name="name" type="substitutableName" use="optional">
<xsd:annotation>
<xsd:documentation>
Identifies the message processor in the registry.
</xsd:documentation>
</xsd:annotation>
</xsd:attribute>
</xsd:extension>
</xsd:complexContent>
</xsd:complexType>
<xsd:element name="invoke" substitutionGroup="abstract-message-processor" type="invokeType">
<xsd:annotation>
<xsd:documentation>
Invokes the method of a given object using method arguments expressed using mule expressions.
</xsd:documentation>
</xsd:annotation>
</xsd:element>
<xsd:complexType name="invokeType">
<xsd:complexContent>
<xsd:extension base="abstractMessageProcessorType">
<xsd:attribute name="object-ref" type="xsd:string">
<xsd:annotation>
<xsd:documentation>
Reference to the object whose method will be invoked.
</xsd:documentation>
</xsd:annotation>
</xsd:attribute>
<xsd:attribute name="method" type="xsd:string">
<xsd:annotation>
<xsd:documentation>
The name of the method to be invoked.
</xsd:documentation>
</xsd:annotation>
</xsd:attribute>
<xsd:attribute name="methodArguments" type="xsd:string">
<xsd:annotation>
<xsd:documentation>
Comma-seperated list of mule expression that when evaluated are the arguments for the method invocation
</xsd:documentation>
</xsd:annotation>
</xsd:attribute>
<xsd:attribute name="methodArgumentTypes" type="xsd:string">
<xsd:annotation>
<xsd:documentation>
Comma-seperated list of mule expression that when evaluated are the arguments for the method invocation
</xsd:documentation>
</xsd:annotation>
</xsd:attribute>
<xsd:attribute name="name" type="substitutableName" use="optional">
<xsd:annotation>
<xsd:documentation>
Identifies the message processor in the registry.
</xsd:documentation>
</xsd:annotation>
</xsd:attribute>
</xsd:extension>
</xsd:complexContent>
</xsd:complexType>
<xsd:element name="enricher" substitutionGroup="abstract-message-processor" type="messageEnricherType">
<xsd:annotation>
<xsd:documentation>
Enriches the current message, using expressins to define source and target,
with the result of processing a nested message processor. Use the target and optionally sourcre attributes
for 1-1 enrichment. If you require n-m enrichment than use the child 'enrich' elements instead.
</xsd:documentation>
</xsd:annotation>
</xsd:element>
<xsd:complexType name="messageEnricherType">
<xsd:complexContent>
<xsd:extension base="abstractMessageProcessorType">
<xsd:sequence>
<xsd:element maxOccurs="unbounded" minOccurs="0" name="enrich" type="extractEnrichPairType"/>
</xsd:sequence>
<xsd:attribute name="source" type="xsd:string">
<xsd:annotation>
<xsd:documentation>
An evaluator expression used to extract a value from the result of the
enrichment message processor. If an
expression is not specified then the payload of the
message is used.
</xsd:documentation>
</xsd:annotation>
</xsd:attribute>
<xsd:attribute name="target" type="xsd:string">
<xsd:annotation>
<xsd:documentation>
The enricher expression used to enrich the current message with the result
the processing of the enrichement message processor specified.
</xsd:documentation>
</xsd:annotation>
</xsd:attribute>
</xsd:extension>
</xsd:complexContent>
</xsd:complexType>
<xsd:complexType name="extractEnrichPairType">
<xsd:attributeGroup ref="enricherSourceTargetAttributes"/>
</xsd:complexType>
<xsd:attributeGroup name="enricherSourceTargetAttributes">
<xsd:attribute name="source" type="xsd:string">
<xsd:annotation>
<xsd:documentation>
An evaluator expression used to extract a value from the result of the
enrichment message processor. If an
expression is not specified then the payload of the
message is used.
</xsd:documentation>
</xsd:annotation>
</xsd:attribute>
<xsd:attribute name="target" type="xsd:string" use="required">
<xsd:annotation>
<xsd:documentation>
The enricher expression used to enrich the current message with the result
the processing of the enrichement message processor specified.
</xsd:documentation>
</xsd:annotation>
</xsd:attribute>
</xsd:attributeGroup>
<xsd:element name="async" substitutionGroup="abstract-message-processor" type="asyncType">
<xsd:annotation>
<xsd:documentation>
Processes the nested list of message processors asynchronously using a thread pool
</xsd:documentation>
</xsd:annotation>
</xsd:element>
<xsd:complexType name="asyncType">
<xsd:complexContent>
<xsd:extension base="abstractMessageProcessorType">
<xsd:sequence>
<xsd:group maxOccurs="unbounded" ref="messageProcessorOrOutboundEndpoint"/>
</xsd:sequence>
<xsd:attribute default="queued-asynchronous" name="processingStrategy" use="optional">
<xsd:annotation>
<xsd:documentation>
Strategy used to process the configured message processors when exchange pattern is 'one-way'.
This attribute accepts either one of the enumerated strategies with default configuration options or a reference to a gloablly defined strategy.
</xsd:documentation>
</xsd:annotation>
<xsd:simpleType>
<xsd:union>
<xsd:simpleType>
<xsd:restriction base="xsd:string">
<xsd:annotation>
<xsd:documentation>
The name of a globally configured processing strategy
</xsd:documentation>
</xsd:annotation>
</xsd:restriction>
</xsd:simpleType>
<xsd:simpleType>
<xsd:restriction base="xsd:NMTOKEN">
<xsd:enumeration value="asynchronous">
<xsd:annotation>
<xsd:documentation>
Uses a thread pool to process the pipeline of message processors asynchronously.
</xsd:documentation>
</xsd:annotation>
</xsd:enumeration>
<xsd:enumeration value="queued-asynchronous">
<xsd:annotation>
<xsd:documentation>
Decouples the recieving of a new message from it's processing using a queue.
The queue is polled and a thread pool is used to process the pipeline of message processors asynchronously.
</xsd:documentation>
</xsd:annotation>
</xsd:enumeration>
</xsd:restriction>
</xsd:simpleType>
</xsd:union>
</xsd:simpleType>
</xsd:attribute>
<xsd:attribute name="name" type="xsd:string" use="optional">
<xsd:annotation>
<xsd:documentation>
Optional name that will be used to name the threads used by this flow.
</xsd:documentation>
</xsd:annotation>
</xsd:attribute>
</xsd:extension>
</xsd:complexContent>
</xsd:complexType>
<xsd:element name="request-reply" substitutionGroup="abstract-message-processor" type="requestReplyType">
<xsd:annotation>
<xsd:documentation>
Provides support for the asynchronous request/reply pattern where a message is sent via a one-way outbound endpoint
and an asynchronous response is received via a seperate inbound one-way endpoint. Message flow is blocked while
waiting for the reply message. Note: This does not currently support setting of replyTo property on the outbound message.
</xsd:documentation>
</xsd:annotation>
</xsd:element>
<xsd:complexType name="requestReplyType">
<xsd:complexContent>
<xsd:extension base="abstractMessageProcessorType">
<xsd:sequence>
<xsd:annotation>
<xsd:documentation>
The outbound endpoint or message processor that will perform the asynchronous request.
</xsd:documentation>
</xsd:annotation>
</xsd:group>
<xsd:element ref="abstract-inbound-endpoint">
<xsd:annotation>
<xsd:documentation>
The inbound endpoint from which the asynchronous reply message will be received.
</xsd:documentation>
</xsd:annotation>
</xsd:element>
</xsd:sequence>
<xsd:attribute name="timeout" type="substitutableInt" use="optional">
<xsd:annotation>
<xsd:documentation>
The time (ms) to wait for an asynchronous reply message to be received.
</xsd:documentation>
</xsd:annotation>
</xsd:attribute>
<xsd:attribute name="storePrefix" type="substitutableName">
<xsd:annotation>
<xsd:documentation>
Defines the prefix of the object store names.
</xsd:documentation>
</xsd:annotation>
</xsd:attribute>
</xsd:extension>
</xsd:complexContent>
</xsd:complexType>
<xsd:element name="logger" substitutionGroup="abstract-observer-message-processor" type="loggerType">
<xsd:annotation>
<xsd:documentation>
Performs logging using an expression that determines what should be logged. By default the current messages is
logged using the DEBUG level to the 'org.mule.api.processor.LoggerMessageProcessor' category but the level and
category can both be configured to suit your needs.
</xsd:documentation>
</xsd:annotation>
</xsd:element>
<xsd:complexType name="loggerType">
<xsd:complexContent>
<xsd:attribute name="message" type="xsd:string" use="optional">
<xsd:annotation>
<xsd:documentation>
Message that will be logged. Embedded expressions can be used to extract value from the current message. If no message is
specified then the current message is used.
</xsd:documentation>
</xsd:annotation>
</xsd:attribute>
<xsd:attribute name="level" use="optional">
<xsd:annotation>
<xsd:documentation>
The logging level to be used. Default is DEBUG.
</xsd:documentation>
</xsd:annotation>
<xsd:simpleType>
<xsd:restriction base="xsd:string">
<xsd:enumeration value="ERROR"/>
<xsd:enumeration value="WARN"/>
<xsd:enumeration value="INFO"/>
<xsd:enumeration value="DEBUG"/>
<xsd:enumeration value="TRACE"/>
</xsd:restriction>
</xsd:simpleType>
</xsd:attribute>
<xsd:attribute name="category" type="xsd:string" use="optional">
<xsd:annotation>
<xsd:documentation>
The log category to be used
</xsd:documentation>
</xsd:annotation>
</xsd:attribute>
</xsd:extension>
</xsd:complexContent>
</xsd:complexType>
<!-- TODO
<xsd:element name="seda-stage" substitutionGroup="abstract-message-processor">
<xsd:annotation>
<xsd:documentation>
Processes the nest list of message processors asychronously using a seda stage.
</xsd:documentation>
</xsd:annotation>
<xsd:complexType>
<xsd:complexContent>
<xsd:extension base="asyncType">
<xsd:sequence>
<xsd:element ref="queue-profile" minOccurs="0"/>
</xsd:sequence>
</xsd:extension>
</xsd:complexContent>
</xsd:complexType>
</xsd:element>
-->
<xsd:element name="transactional" substitutionGroup="abstract-message-processor" type="abstractTransactional">
<xsd:annotation>
<xsd:documentation>
Processes the nest list of message processors within a transaction
</xsd:documentation>
</xsd:annotation>
</xsd:element>
<xsd:complexType name="abstractTransactional">
<xsd:complexContent>
<xsd:extension base="abstractMessageProcessorType">
<xsd:sequence>
<xsd:group maxOccurs="unbounded" ref="messageProcessorOrOutboundEndpoint"/>
<xsd:element minOccurs="0" ref="abstract-exception-strategy"/>
</xsd:sequence>
<xsd:attribute default="ALWAYS_BEGIN" name="action" type="transactionalActionType"/>
</xsd:extension>
</xsd:complexContent>
</xsd:complexType>
<xsd:simpleType name="transactionalActionType">
<xsd:restriction base="xsd:NMTOKEN">
<xsd:enumeration value="ALWAYS_BEGIN"/>
<xsd:enumeration value="BEGIN_OR_JOIN"/>
</xsd:restriction>
</xsd:simpleType>
<!-- Message Sources -->
<xsd:element abstract="true" name="abstract-message-source" type="abstractMessageSourceType">
<xsd:annotation>
<xsd:documentation>
A placeholder for message source elements.
</xsd:documentation>
</xsd:annotation>
</xsd:element>
<xsd:complexType name="abstractMessageSourceType">
<xsd:complexContent>
<xsd:extension base="annotatedType"/>
</xsd:complexContent>
</xsd:complexType>
<xsd:choice>
<xsd:element ref="abstract-message-source">
<xsd:annotation>
<xsd:documentation>
A message source
</xsd:documentation>
</xsd:annotation>
</xsd:element>
<xsd:element ref="abstract-inbound-endpoint">
<xsd:annotation>
<xsd:documentation>
An inbound endpoint
</xsd:documentation>
</xsd:annotation>
</xsd:element>
</xsd:choice>
</xsd:group>
<xsd:element name="custom-source" substitutionGroup="abstract-message-source" type="customMessageSourceType"/>
<xsd:complexType name="customMessageSourceType">
<xsd:complexContent>
<xsd:extension base="abstractMessageSourceType">
<xsd:sequence>
<xsd:element maxOccurs="unbounded" minOccurs="0" ref="spring:property"/>
</xsd:sequence>
<xsd:attribute name="class" type="substitutableClass" use="required"/>
</xsd:extension>
</xsd:complexContent>
</xsd:complexType>
<xsd:element name="composite-source" substitutionGroup="abstract-message-source" type="compositeMessageSourceType"/>
<xsd:complexType name="compositeMessageSourceType">
<xsd:complexContent>
<xsd:extension base="abstractMessageSourceType">
<xsd:sequence maxOccurs="unbounded">
</xsd:sequence>
</xsd:extension>
</xsd:complexContent>
</xsd:complexType>
<xsd:complexType name="commonTransformerType">
<xsd:complexContent>
<xsd:extension base="abstractMessageProcessorType"/>
</xsd:complexContent>
</xsd:complexType>
<xsd:element abstract="true" name="abstract-transformer" substitutionGroup="abstract-message-processor" type="commonTransformerType">
<xsd:annotation>
<xsd:documentation>
A placeholder for transformer elements. Transformers convert message payloads.
</xsd:documentation>
</xsd:annotation>
</xsd:element>
<xsd:complexType name="abstractTransformerType">
<xsd:complexContent>
<xsd:extension base="commonTransformerType">
<xsd:attribute name="name" type="substitutableName">
<xsd:annotation>
<xsd:documentation>
Identifies the transformer so that other elements can reference it. Required if the transformer is defined at the global level.
</xsd:documentation>
</xsd:annotation>
</xsd:attribute>
<xsd:attribute name="returnClass" type="xsd:string">
<xsd:annotation>
<xsd:documentation>
The class of the message generated by the transformer. This is used if transformers are auto-selected and to validate that the transformer returns the correct type. Note that if you need to specify an array type you need postfix the class name with '[]'. For example, if you want return a an Orange[], you set the return class to 'org.mule.tck.testmodels.fruit.Orange[]'.
</xsd:documentation>
</xsd:annotation>
</xsd:attribute>
<xsd:attribute name="ignoreBadInput" type="substitutableBoolean">
<xsd:annotation>
<xsd:documentation>
Many transformers only accept certain classes. Such transformers are never called with inappropriate input (whatever the value of this attribute). If a transformer forms part of a chain and cannot accept the current message class, this flag controls whether the remaining part of the chain is evaluated. If true, the next transformer is called. If false the chain ends, keeping the result generated up to that point.
</xsd:documentation>
</xsd:annotation>
</xsd:attribute>
<xsd:attributeGroup ref="mimeTypeAttributes">
<xsd:annotation>
<xsd:documentation>
The mime type of the transformer's output
</xsd:documentation>
</xsd:annotation>
</xsd:attributeGroup>
<xsd:attribute name="encoding" type="xsd:string">
<xsd:annotation>
<xsd:documentation>
String encoding used for transformer output.
</xsd:documentation>
</xsd:annotation>
</xsd:attribute>
</xsd:extension>
</xsd:complexContent>
</xsd:complexType>
<xsd:complexType name="globalPropertyType">
<xsd:complexContent>
<xsd:extension base="annotatedType">
<xsd:attribute name="name" type="substitutableName" use="required">
<xsd:annotation>
<xsd:documentation>
The name of the property. This is used inside Spring placeholders.
</xsd:documentation>
</xsd:annotation>
</xsd:attribute>
<xsd:attribute name="value" type="xsd:string" use="required">
<xsd:annotation>
<xsd:documentation>
The value of the property. This replaces each occurence of a Spring placeholder.
</xsd:documentation>
</xsd:annotation>
</xsd:attribute>
</xsd:extension>
</xsd:complexContent>
</xsd:complexType>
<!-- seemed pointless making these simple container types abstract -->
<xsd:complexType name="inboundCollectionType">
<xsd:sequence>
<xsd:element maxOccurs="unbounded" minOccurs="0" ref="abstract-inbound-endpoint"/>
<xsd:choice maxOccurs="unbounded" minOccurs="0">
<xsd:element ref="abstract-inbound-router"/>
<xsd:element ref="abstract-transformer"/>
<xsd:element ref="splitter"/>
<xsd:element ref="collection-splitter"/>
<xsd:element ref="processor"/>
<xsd:element ref="custom-processor"/>
</xsd:choice>
<xsd:element minOccurs="0" ref="abstract-catch-all-strategy"/>
</xsd:sequence>
</xsd:complexType>
<xsd:element abstract="true" name="abstract-catch-all-strategy" type="abstractCatchAllStrategyType">
<xsd:annotation>
<xsd:documentation>
A placeholder for catch-all strategy elements.
</xsd:documentation>
</xsd:annotation>
</xsd:element>
<xsd:complexType name="abstractCatchAllStrategyType"/>
<xsd:element abstract="true" name="abstract-inbound-router" type="abstractInboundRouterType">
<xsd:annotation>
<xsd:documentation>
A placeholder for inbound router elements, which control how incoming messages are handled.
</xsd:documentation>
</xsd:annotation>
</xsd:element>
<xsd:complexType name="abstractInboundRouterType">
<xsd:complexContent>
<xsd:extension base="annotatedType"/>
</xsd:complexContent>
</xsd:complexType>
<xsd:element abstract="true" name="abstract-filter" substitutionGroup="abstract-message-processor" type="commonFilterType">
<xsd:annotation>
<xsd:documentation>
A placeholder for filter elements, which control which messages are handled.
</xsd:documentation>
</xsd:annotation>
</xsd:element>
<xsd:complexType name="commonFilterType">
<xsd:complexContent>
<xsd:extension base="abstractMessageProcessorType"/>
</xsd:complexContent>
</xsd:complexType>
<xsd:complexType name="abstractFilterType">
<xsd:complexContent>
<xsd:extension base="commonFilterType">
<xsd:attribute name="name" type="substitutableName">
<xsd:annotation>
<xsd:documentation>
Identifies the filter so that other elements can reference it. Required if the filter is defined at the global level.
</xsd:documentation>
</xsd:annotation>
</xsd:attribute>
</xsd:extension>
</xsd:complexContent>
</xsd:complexType>
<xsd:complexType name="outboundCollectionType">
<xsd:sequence>
<xsd:element maxOccurs="unbounded" ref="abstract-outbound-router"/>
<xsd:element minOccurs="0" ref="abstract-catch-all-strategy"/>
</xsd:sequence>
<xsd:attribute default="false" name="matchAll" type="substitutableBoolean">
<xsd:annotation>
<xsd:documentation>
If true, the output message will be sent to all routers. Otherwise, only the first matching router is used.
</xsd:documentation>
</xsd:annotation>
</xsd:attribute>
</xsd:complexType>
<xsd:element abstract="true" name="abstract-outbound-router" type="abstractOutboundRouterType">
<xsd:annotation>
<xsd:documentation>
A placeholder for outbound router elements, which control how outgoing messages are delivered to the outbound endpoints.
</xsd:documentation>
</xsd:annotation>
</xsd:element>
<xsd:complexType name="abstractOutboundRouterType">
<xsd:complexContent>
<xsd:extension base="annotatedType"/>
</xsd:complexContent>
</xsd:complexType>
<xsd:element abstract="true" name="abstract-transaction-manager" type="abstractTransactionManagerType">
<xsd:annotation>
<xsd:documentation>
A placeholder for transaction manager elements, which are used to coordinate transactions.
</xsd:documentation>
</xsd:annotation>
</xsd:element>
<xsd:complexType name="abstractTransactionManagerType">
<xsd:complexContent>
<xsd:extension base="annotatedType"/>
</xsd:complexContent>
</xsd:complexType>
<xsd:complexType name="configurationType">
<xsd:complexContent>
<xsd:extension base="annotatedType">
<xsd:sequence>
<xsd:element minOccurs="0" name="default-threading-profile" type="threadingProfileType">
<xsd:annotation>
<xsd:documentation>
The default threading profile, used by components and by endpoints for dispatching and receiving if no more specific configuration is given.
</xsd:documentation>
</xsd:annotation>
</xsd:element>
<xsd:element minOccurs="0" name="default-dispatcher-threading-profile" type="threadingProfileType">
<xsd:annotation>
<xsd:documentation>
The default dispatching threading profile, which modifies the default-threading-profile values and is used by endpoints for dispatching messages. This can also be configured on connectors, in which case the connector configuration is used instead of this default.
</xsd:documentation>
</xsd:annotation>
</xsd:element>
<xsd:element minOccurs="0" name="default-receiver-threading-profile" type="threadingProfileType">
<xsd:annotation>
<xsd:documentation>
The default receiving threading profile, which modifies the default-threading-profile values and is used by endpoints for receiving messages. This can also be configured on connectors, in which case the connector configuration is used instead of this default.
</xsd:documentation>
</xsd:annotation>
</xsd:element>
<xsd:element minOccurs="0" name="default-service-threading-profile" type="threadingProfileType">
<xsd:annotation>
<xsd:documentation>
The default service threading profile, which modifies the default-threading-profile and is used by services for processing messages. This can also be configured on models or services, in which case these configurations will be used instead of this default.
</xsd:documentation>
</xsd:annotation>
</xsd:element>
<xsd:element minOccurs="0" ref="abstract-reconnection-strategy">
<xsd:annotation>
<xsd:documentation>
The default reconnection strategy, used by connectors and endpoints. This can also be configured on connectors, in which case the connector configuration is used instead of this default.
</xsd:documentation>
</xsd:annotation>
</xsd:element>
<xsd:element minOccurs="0" name="expression-language">
<xsd:annotation>
<xsd:documentation>
Configuration of Mule Expression Language
</xsd:documentation>
</xsd:annotation>
<xsd:complexType>
<xsd:complexContent mixed="true">
<xsd:extension base="abstractMixedContentExtensionType">
<xsd:sequence>
<xsd:element maxOccurs="unbounded" minOccurs="0" name="import">
<xsd:complexType>
<xsd:attribute name="name" type="nonBlankString"/>
<xsd:attribute name="class" type="substitutableClass" use="required"/>
</xsd:complexType>
</xsd:element>
<xsd:element maxOccurs="unbounded" minOccurs="0" name="alias">
<xsd:complexType>
<xsd:attribute name="name" type="nonBlankString" use="required"/>
<xsd:attribute name="expression" type="nonBlankString" use="required"/>
</xsd:complexType>
</xsd:element>
<xsd:element maxOccurs="1" minOccurs="0" name="global-functions">
<xsd:complexType mixed="true">
<xsd:attribute name="file" type="nonBlankString"/>
</xsd:complexType>
</xsd:element>
</xsd:sequence>
<xsd:attribute default="true" name="autoResolveVariables" type="substitutableBoolean"/>
</xsd:extension>
</xsd:complexContent>
</xsd:complexType>
</xsd:element>
</xsd:sequence>
<xsd:attribute default="10000" name="defaultResponseTimeout" type="xsd:string">
<xsd:annotation>
<xsd:documentation>
The default period (ms) to wait for a synchronous response.
</xsd:documentation>
</xsd:annotation>
</xsd:attribute>
<xsd:attribute default="30000" name="defaultTransactionTimeout" type="xsd:string">
<xsd:annotation>
<xsd:documentation>
The default timeout (ms) for transactions. This can also be configured on transactions, in which case the transaction configuration is used instead of this default.
</xsd:documentation>
</xsd:annotation>
</xsd:attribute>
<xsd:attribute name="defaultExceptionStrategy-ref" type="xsd:string">
<xsd:annotation>
<xsd:documentation>
The default exception strategy for every flow / service. This must be a reference to a global exception strategy.
</xsd:documentation>
</xsd:annotation>
</xsd:attribute>
<xsd:attribute default="5000" name="shutdownTimeout" type="substitutableInt">
<xsd:annotation>
<xsd:documentation>
(As of Mule 2.2.2) The time in milliseconds to wait for any in-progress messages to finish processing before Mule shuts down. After this threshold has been reached, Mule starts interrupting threads, and messages can be lost. If you have a very large number of services in the same Mule instance, if you have components that take more than a couple seconds to process, or if you are using large payloads and/or slower transports, you should increase this value to allow more time for graceful shutdown. The value you specify is applied to services and separately to dispatchers, so the default value of 5000 milliseconds specifies that Mule has ten seconds to process and dispatch messages gracefully after shutdown is initiated.
</xsd:documentation>
</xsd:annotation>
</xsd:attribute>
<xsd:attribute default="true" name="useExtendedTransformations" type="substitutableBoolean">
<xsd:annotation>
<xsd:documentation>
Backwards Compatabilty Flag: Used to disable the new extended transformation support introduced in Mule 3.3 including enforcement of transformations, implicit transformations and no direct transformer lookup.
</xsd:documentation>
</xsd:annotation>
</xsd:attribute>
<xsd:attribute default="false" name="flowEndingWithOneWayEndpointReturnsNull" type="substitutableBoolean">
<xsd:annotation>
<xsd:documentation>
Backwards Compatabilty Flag: Used to revert to Mule 3.2 behaviour of one-way outbound endpoints when they are the last element inside a request-response flow. When true the value returned by the endpoint will be null, otherwise will be an echo of the received event.
</xsd:documentation>
</xsd:annotation>
</xsd:attribute>
<xsd:attribute default="false" name="enricherPropagatesSessionVariableChanges" type="substitutableBoolean">
<xsd:annotation>
<xsd:documentation>
Backwards Compatabilty Flag: Used to revert to Mule 3.1/3.2 behaviour of the message enricher so that session variables added or modified within an enricher are propagated up into the flow where the enricher is used.
</xsd:documentation>
</xsd:annotation>
</xsd:attribute>
</xsd:extension>
</xsd:complexContent>
</xsd:complexType>
<xsd:complexType name="notificationManagerType">
<xsd:complexContent>
<xsd:extension base="annotatedType">
<xsd:sequence>
<xsd:element maxOccurs="unbounded" minOccurs="0" name="notification" type="defineNotificationType">
<xsd:annotation>
<xsd:documentation>
Associates an event with an interface. Listeners that implement the interface will receive instances of the event.
</xsd:documentation>
</xsd:annotation>
</xsd:element>
<xsd:element maxOccurs="unbounded" minOccurs="0" name="disable-notification" type="disableNotificationType">
<xsd:annotation>
<xsd:documentation>
Blocks the association of an event with a particular interface. This filters events after the association with a particular interface (and so takes precedence).
</xsd:documentation>
</xsd:annotation>
</xsd:element>
<xsd:element maxOccurs="unbounded" minOccurs="0" name="notification-listener">
<xsd:annotation>
<xsd:documentation>
Registers a bean as a listener with the notification system. Events are dispatched by reflection - the listener will receive all events associated with any interfaces it implements. The relationship between interfaces and events is configured by the notification and disable-notification elements.
</xsd:documentation>
</xsd:annotation>
<xsd:complexType>
<xsd:attribute name="ref" type="xsd:string" use="required">
<xsd:annotation>
<xsd:documentation>
The bean that will receive notifications.
</xsd:documentation>
</xsd:annotation>
</xsd:attribute>
<xsd:attribute name="subscription" type="xsd:string">
<xsd:annotation>
<xsd:documentation>
An optional string that is compared with the event resource identifier. Only events with matching identifiers will be sent. If no value is given, all events are sent.
</xsd:documentation>
</xsd:annotation>
</xsd:attribute>
</xsd:complexType>
</xsd:element>
</xsd:sequence>
<xsd:attribute name="dynamic" type="substitutableBoolean">
<xsd:annotation>
<xsd:documentation>
If the notification manager is dynamic, listeners can be registered dynamically at runtime via the MuleContext, and the configured notification can be changed. Otherwise, some parts of Mule will cache notification configuration for efficiency and will not generate events for newly enabled notifications or listeners. The default value is false.
</xsd:documentation>
</xsd:annotation>
</xsd:attribute>
</xsd:extension>
</xsd:complexContent>
</xsd:complexType>
<xsd:complexType name="defineNotificationType">
<xsd:attribute name="event-class" type="substitutableClass">
<xsd:annotation>
<xsd:documentation>
The class associated with a notification event that will be delivered to the interface. This can be used instead of the 'event' attribute to specify a custom class.
</xsd:documentation>
</xsd:annotation>
</xsd:attribute>
<xsd:attribute name="event" type="notificationTypes">
<xsd:annotation>
<xsd:documentation>
The notification event to deliver.
</xsd:documentation>
</xsd:annotation>
</xsd:attribute>
<xsd:attribute name="interface-class" type="substitutableClass">
<xsd:annotation>
<xsd:documentation>
The interface (class name) that will receive the notification event.
</xsd:documentation>
</xsd:annotation>
</xsd:attribute>
<xsd:attribute name="interface" type="notificationTypes">
<xsd:annotation>
<xsd:documentation>
The interface that will receive the notification event.
</xsd:documentation>
</xsd:annotation>
</xsd:attribute>
</xsd:complexType>
<xsd:complexType name="disableNotificationType">
<xsd:attribute name="event-class" type="substitutableClass">
<xsd:annotation>
<xsd:documentation>
The class associated with an event that will no longer be delivered to any interface. This can be used instead of the 'event' attribute to specify a custom class.
</xsd:documentation>
</xsd:annotation>
</xsd:attribute>
<xsd:attribute name="event" type="notificationTypes">
<xsd:annotation>
<xsd:documentation>
The event you no longer want to deliver.
</xsd:documentation>
</xsd:annotation>
</xsd:attribute>
<xsd:attribute name="interface-class" type="substitutableClass">
<xsd:annotation>
<xsd:documentation>
The interface (class name) that will no longer receive the event.
</xsd:documentation>
</xsd:annotation>
</xsd:attribute>
<xsd:attribute name="interface" type="notificationTypes">
<xsd:annotation>
<xsd:documentation>
The interface that will no longer receive the event.
</xsd:documentation>
</xsd:annotation>
</xsd:attribute>
</xsd:complexType>
<xsd:simpleType name="notificationTypes">
<xsd:restriction base="xsd:NMTOKEN">
<xsd:enumeration value="CONTEXT"/>
<xsd:enumeration value="MODEL"/>
<xsd:enumeration value="SERVICE"/>
<xsd:enumeration value="SECURITY"/>
<xsd:enumeration value="ENDPOINT-MESSAGE"/>
<xsd:enumeration value="COMPONENT-MESSAGE"/>
<xsd:enumeration value="MANAGEMENT"/>
<xsd:enumeration value="MESSAGE-PROCESSOR"/>
<xsd:enumeration value="CONNECTION"/>
<xsd:enumeration value="REGISTRY"/>
<xsd:enumeration value="CUSTOM"/>
<xsd:enumeration value="EXCEPTION"/>
<xsd:enumeration value="TRANSACTION"/>
<xsd:enumeration value="ROUTING"/>
</xsd:restriction>
</xsd:simpleType>
<!--==============================================================-->
<!-- Models -->
<!--==============================================================-->
<xsd:element abstract="true" name="abstract-model" type="abstractModelType">
<xsd:annotation>
<xsd:documentation>
A placeholder for model elements. A model provides basic settings and processing for all the services it contains.
</xsd:documentation>
</xsd:annotation>
</xsd:element>
<xsd:complexType name="abstractModelType">
<xsd:complexContent>
<xsd:extension base="annotatedType">
<xsd:sequence>
<xsd:element minOccurs="0" ref="legacy-abstract-exception-strategy"/>
<xsd:group ref="entryPointResolvers"/>
<xsd:element maxOccurs="unbounded" minOccurs="0" ref="abstract-service"/>
</xsd:sequence>
<xsd:attribute name="name" type="nonBlankString">
<xsd:annotation>
<xsd:documentation>
The name used to identify this model.
</xsd:documentation>
</xsd:annotation>
</xsd:attribute>
</xsd:extension>
</xsd:complexContent>
</xsd:complexType>
<xsd:element name="seda-model" substitutionGroup="abstract-model" type="sedaModelType">
<xsd:annotation>
<xsd:documentation>
A staged event-driven architecture (SEDA) model has separate threads and queues for each service.
</xsd:documentation>
</xsd:annotation>
</xsd:element>
<xsd:complexType name="sedaModelType">
<xsd:complexContent>
<xsd:extension base="abstractModelType">
<xsd:sequence>
<xsd:element minOccurs="0" ref="abstract-queue-profile"/>
</xsd:sequence>
<xsd:attribute name="inherit" type="xsd:boolean">
<xsd:annotation>
<xsd:documentation>
If true, this model element is an extension of a previous model element with the same name.
</xsd:documentation>
</xsd:annotation>
</xsd:attribute>
</xsd:extension>
</xsd:complexContent>
</xsd:complexType>
<xsd:element name="model" substitutionGroup="abstract-model" type="defaultModelType">
<xsd:annotation>
<xsd:documentation>
The container for a set of services, providing basic settings and processing for all the services it contains.
</xsd:documentation>
</xsd:annotation>
</xsd:element>
<xsd:complexType name="defaultModelType">
<xsd:complexContent>
<xsd:extension base="sedaModelType"/>
</xsd:complexContent>
</xsd:complexType>
<!-- Model elements -->
<xsd:element abstract="true" name="abstract-queue-profile" type="abstractQueueProfileType">
<xsd:annotation>
<xsd:documentation>
A placeholder for a queue profile, which controls how messages are queued.
</xsd:documentation>
</xsd:annotation>
</xsd:element>
<xsd:complexType name="abstractQueueProfileType"/>
<!-- to give a cleaner config we allow either a set or an individual entry (but not both).-->
<xsd:group name="entryPointResolvers">
<xsd:choice>
<xsd:element minOccurs="0" ref="abstract-entry-point-resolver-set"/>
<!-- we could allow many of these, but it looks ugly -->
<xsd:element minOccurs="0" ref="abstract-entry-point-resolver"/>
</xsd:choice>
</xsd:group>
<xsd:element abstract="true" name="abstract-entry-point-resolver-set" type="abstractEntryPointResolverSetType">
<xsd:annotation>
<xsd:documentation>
A placeholder for entry point resolver set elements. These combine a group of entry point resolvers, trying them in turn until one succeeds.
</xsd:documentation>
</xsd:annotation>
</xsd:element>
<xsd:complexType name="abstractEntryPointResolverSetType"/>
<xsd:annotation>
<xsd:documentation>
An extensible set of entry point resolvers (which determine how a message is passed to a component in Java) that already contains resolvers to implement the standard logic. This is already provided by default and is only needed explicitly if it will be extended with other entry point resolvers. This element can be set on the model or component; the model value provides a default that individual component values can override.
</xsd:documentation>
</xsd:annotation>
</xsd:element>
<xsd:annotation>
<xsd:documentation>
An extensible set of entry point resolvers. These determine how a message is passed to a component in Java. Each entry point resolver is tried in turn until one succeeds in delivering the message to the component. This element can be set on the model or component; the model value provides a default that individual component values can override.
</xsd:documentation>
</xsd:annotation>
</xsd:element>
<xsd:complexType name="extensibleEntryPointResolverSet">
<xsd:complexContent>
<xsd:extension base="abstractEntryPointResolverSetType">
<xsd:sequence>
<xsd:element maxOccurs="unbounded" minOccurs="0" ref="abstract-entry-point-resolver"/>
</xsd:sequence>
</xsd:extension>
</xsd:complexContent>
</xsd:complexType>
<xsd:annotation>
<xsd:documentation>
A custom entry point resolver set. This allows user-supplied code to determine how a message is passed to a component in Java. This element can be set on the model or component; the model value provides a default that individual component values can override.
</xsd:documentation>
</xsd:annotation>
</xsd:element>
<xsd:complexType name="customEntryPointResolverSetType">
<xsd:complexContent>
<xsd:extension base="abstractEntryPointResolverSetType">
<xsd:sequence>
<xsd:element maxOccurs="unbounded" minOccurs="0" ref="spring:property">
<xsd:annotation>
<xsd:documentation>
Spring-style property element for custom configuration.
</xsd:documentation>
</xsd:annotation>
</xsd:element>
</xsd:sequence>
<xsd:attribute name="class" type="substitutableClass" use="required">
<xsd:annotation>
<xsd:documentation>
An implementation of the EntryPointResolverSet interface.
</xsd:documentation>
</xsd:annotation>
</xsd:attribute>
</xsd:extension>
</xsd:complexContent>
</xsd:complexType>
<xsd:element abstract="true" name="abstract-entry-point-resolver" type="abstractEntryPointResolverType">
<xsd:annotation>
<xsd:documentation>
A placeholder for an entry point resolver element. Entry point resolvers define how payloads are delivered to Java code by choosing the method to call.
</xsd:documentation>
</xsd:annotation>
</xsd:element>
<xsd:annotation>
<xsd:documentation>
An entry point resolver for components that implement the Callable interface. This passes a MuleEventContext to the component. This element can be set on the model or component; the model value provides a default that individual component values can override. This element can also be used directly or as part of a set of resolvers; the resolvers in a set are used in turn until one is successful.
</xsd:documentation>
</xsd:annotation>
</xsd:element>
<xsd:complexType name="abstractEntryPointResolverType"/>
<xsd:annotation>
<xsd:documentation>
A custom entry point resolver. This allows user-supplied code to determine how a message is passed to a component in Java. This element can be set on the model or component; the model value provides a default that individual component values can override. This element can also be used directly or as part of a set of resolvers; the resolvers in a set are used in turn until one is successful.
</xsd:documentation>
</xsd:annotation>
</xsd:element>
<xsd:complexType name="customEntryPointResolverType">
<xsd:complexContent>
<xsd:extension base="abstractEntryPointResolverType">
<xsd:sequence>
<xsd:element maxOccurs="unbounded" minOccurs="0" ref="spring:property">
<xsd:annotation>
<xsd:documentation>
Spring-style property element for custom configuration.
</xsd:documentation>
</xsd:annotation>
</xsd:element>
</xsd:sequence>
<xsd:attribute name="class" type="substitutableClass" use="required">
<xsd:annotation>
<xsd:documentation>
An implementation of the EntryPointResolver interface.
</xsd:documentation>
</xsd:annotation>
</xsd:attribute>
</xsd:extension>
</xsd:complexContent>
</xsd:complexType>
<xsd:complexType name="baseEntryPointResolverType">
<xsd:complexContent>
<xsd:extension base="abstractEntryPointResolverType">
<xsd:attribute name="acceptVoidMethods" type="substitutableBoolean">
<xsd:annotation>
<xsd:documentation>
Whether the resolver should call void methods. By default, void methods are not considered as possible candidates for message delivery.
</xsd:documentation>
</xsd:annotation>
</xsd:attribute>
</xsd:extension>
</xsd:complexContent>
</xsd:complexType>
<xsd:annotation>
<xsd:documentation>
Uses a message property to select the component method to be called. This element can be set on the model or component; the model value provides a default that individual component values can override. This element can also be used directly or as part of a set of resolvers; the resolvers in a set are used in turn until one is successful.
</xsd:documentation>
</xsd:annotation>
</xsd:element>
<xsd:complexType name="propertyEntryPointResolverType">
<xsd:complexContent>
<xsd:extension base="baseEntryPointResolverType">
<xsd:attribute name="property" type="substitutableName">
<xsd:annotation>
<xsd:documentation>
The name of the message property used to select a method on the component.
</xsd:documentation>
</xsd:annotation>
</xsd:attribute>
</xsd:extension>
</xsd:complexContent>
</xsd:complexType>
<xsd:annotation>
<xsd:documentation>
Delivers the message to a named method. This element can be set on the model or component; the model value provides a default that individual component values can override. This element can also be used directly or as part of a set of resolvers; the resolvers in a set are used in turn until one is successful.
</xsd:documentation>
</xsd:annotation>
</xsd:element>
<xsd:complexType name="methodEntryPointResolverType">
<xsd:complexContent>
<xsd:extension base="baseEntryPointResolverType">
<xsd:sequence>
<xsd:element maxOccurs="unbounded" minOccurs="1" ref="include-entry-point"/>
</xsd:sequence>
</xsd:extension>
</xsd:complexContent>
</xsd:complexType>
<xsd:annotation>
<xsd:documentation>
Generates a list of candidate methods from the component via reflections. This element can be set on the model or component; the model value provides a default that individual component values can override. This element can also be used directly or as part of a set of resolvers; the resolvers in a set are used in turn until one is successful.
</xsd:documentation>
</xsd:annotation>
</xsd:element>
<xsd:complexType name="reflectionEntryPointResolverType">
<xsd:complexContent>
<xsd:extension base="baseEntryPointResolverType">
<xsd:sequence>
<xsd:element minOccurs="0" name="exclude-object-methods">
<xsd:annotation>
<xsd:documentation>
If specified, methods in the Java Object interface are not included in the list of possible methods that can receive the message.
</xsd:documentation>
</xsd:annotation>
</xsd:element>
<xsd:element maxOccurs="unbounded" minOccurs="0" name="exclude-entry-point" type="methodType">
<xsd:annotation>
<xsd:documentation>
Explicitly excludes a named method from receiving the message.
</xsd:documentation>
</xsd:annotation>
</xsd:element>
</xsd:sequence>
</xsd:extension>
</xsd:complexContent>
</xsd:complexType>
<xsd:annotation>
<xsd:documentation>
Delivers the message to a method that takes a single array as argument. This element can be set on the model or component; the model value provides a default that individual component values can override. This element can also be used directly or as part of a set of resolvers; the resolvers in a set are used in turn until one is successful.
</xsd:documentation>
</xsd:annotation>
</xsd:element>
<xsd:annotation>
<xsd:documentation>
Calls a method without arguments (the message is not passed to the component).
</xsd:documentation>
</xsd:annotation>
</xsd:element>
<xsd:complexType name="complexEntryPointResolverType">
<xsd:complexContent>
<xsd:extension base="reflectionEntryPointResolverType">
<xsd:sequence>
<xsd:element maxOccurs="unbounded" minOccurs="0" ref="include-entry-point"/>
</xsd:sequence>
<xsd:attribute default="true" name="enableDiscovery" type="substitutableBoolean">
<xsd:annotation>
<xsd:documentation>
If no method names are configured, attempts to discover the method to invoke based on the inbound message type.
</xsd:documentation>
</xsd:annotation>
</xsd:attribute>
</xsd:extension>
</xsd:complexContent>
</xsd:complexType>
<xsd:element name="include-entry-point" type="methodType">
<xsd:annotation>
<xsd:documentation>
A possible method for delivery.
</xsd:documentation>
</xsd:annotation>
</xsd:element>
<xsd:complexType name="methodType">
<xsd:attribute name="method" type="nonBlankString">
<xsd:annotation>
<xsd:documentation>
The name of the method.
</xsd:documentation>
</xsd:annotation>
</xsd:attribute>
</xsd:complexType>
<!--==============================================================-->
<!-- Services -->
<!--==============================================================-->
<xsd:element abstract="true" name="abstract-service" type="abstractServiceType">
<xsd:annotation>
<xsd:documentation>
A placeholder for a service element. Services combine message routing with a component (typically a POJO).
</xsd:documentation>
</xsd:annotation>
</xsd:element>
<xsd:complexType name="abstractServiceType">
<xsd:complexContent>
<xsd:extension base="annotatedType">
<xsd:attribute name="name" type="nonBlankString" use="required">
<xsd:annotation>
<xsd:documentation>
The name used to identify this service.
</xsd:documentation>
</xsd:annotation>
</xsd:attribute>
</xsd:extension>
</xsd:complexContent>
</xsd:complexType>
<xsd:complexType name="baseServiceType">
<xsd:annotation>
<xsd:documentation>
Base support for a model-based wrapper around the POJO service (SEDA, Streaming, etc.)
</xsd:documentation>
</xsd:annotation>
<xsd:complexContent>
<xsd:extension base="abstractServiceType">
<xsd:sequence>
<xsd:element minOccurs="0" name="description" type="descriptionType">
<xsd:annotation>
<xsd:documentation>
This can hold any kind of documentation related to the service. It is intended to be "human readable" only and is not used by the system.
</xsd:documentation>
</xsd:annotation>
</xsd:element>
<xsd:element minOccurs="0" name="inbound" type="inboundCollectionType">
<xsd:annotation>
<xsd:documentation>
The elements within 'inbound' describe how a service receives messages.
</xsd:documentation>
</xsd:annotation>
</xsd:element>
<!-- minOccurs="0" to allow for <forwarding-router/> and/or default component -->
<xsd:element minOccurs="0" ref="abstract-component">
<xsd:annotation>
<xsd:documentation>
The service component that is invoked when incoming messages are received. If this element is not present, the service simply bridges the inbound and outbound using a pass-through component.
</xsd:documentation>
</xsd:annotation>
</xsd:element>
<xsd:element minOccurs="0" name="outbound" type="outboundCollectionType">
<xsd:annotation>
<xsd:documentation>
The elements within 'outbound' describe how a service sends or dispatches messages.
</xsd:documentation>
</xsd:annotation>
</xsd:element>
<xsd:element minOccurs="0" name="async-reply" type="asyncReplyCollectionType">
<xsd:annotation>
<xsd:documentation>
The elements within 'async-reply' describe how asynchronous replies are handled.
</xsd:documentation>
</xsd:annotation>
</xsd:element>
<xsd:element minOccurs="0" ref="legacy-abstract-exception-strategy"/>
<xsd:element minOccurs="0" ref="abstract-message-info-mapping">
<xsd:annotation>
<xsd:documentation>
The message info mapper used to extract key bits of the message
information, such as Message ID or Correlation ID. these
properties
are used by some routers and this mapping information tells Mule
where to get the information from in the current message.
</xsd:documentation>
</xsd:annotation>
</xsd:element>
</xsd:sequence>
<xsd:attribute default="started" name="initialState">
<xsd:annotation>
<xsd:documentation>
The initial state of the service. Usually a service is started automatically ("started"), but this attribute can be used to disable initial startup ("stopped") or start the service in a paused state ("paused").
</xsd:documentation>
</xsd:annotation>
<xsd:simpleType>
<xsd:restriction base="xsd:NMTOKEN">
<xsd:enumeration value="started"/>
<xsd:enumeration value="stopped"/>
<xsd:enumeration value="paused"/>
</xsd:restriction>
</xsd:simpleType>
</xsd:attribute>
</xsd:extension>
</xsd:complexContent>
</xsd:complexType>
<!-- This is left in for backwards-compatibility only, remove for next major version. -->
<xsd:element abstract="true" name="legacy-abstract-exception-strategy" type="exceptionStrategyType">
<xsd:annotation>
<xsd:documentation>
Legacy placeholder for an exception strategy element. Exception strategies define how Mule should react to errors.
</xsd:documentation>
</xsd:annotation>
</xsd:element>
<xsd:element abstract="true" name="abstract-exception-strategy" substitutionGroup="legacy-abstract-exception-strategy" type="exceptionStrategyType">
<xsd:annotation>
<xsd:documentation>
A placeholder for an exception strategy element. Exception strategies define how Mule should react to errors.
</xsd:documentation>
</xsd:annotation>
</xsd:element>
<xsd:complexType name="exceptionStrategyType">
<xsd:annotation>
<xsd:documentation>
Base type for every exception strategy.
</xsd:documentation>
</xsd:annotation>
<xsd:complexContent>
<xsd:extension base="annotatedType"/>
</xsd:complexContent>
</xsd:complexType>
<xsd:complexType name="referenceExceptionStrategyType">
<xsd:annotation>
<xsd:documentation>
Used to reference another exception strategy within flow, service or global exception strategy.
</xsd:documentation>
</xsd:annotation>
<xsd:complexContent>
<xsd:extension base="exceptionStrategyType">
<xsd:attribute name="ref" type="xsd:string" use="required">
<xsd:annotation>
<xsd:documentation>
The name of the filter to use.
</xsd:documentation>
</xsd:annotation>
</xsd:attribute>
</xsd:extension>
</xsd:complexContent>
</xsd:complexType>
<xsd:complexContent>
<xsd:extension base="exceptionStrategyType">
<xsd:attribute name="enableNotifications" type="xsd:boolean">
<xsd:annotation>
<xsd:documentation>
Determines whether ExceptionNotifications will be fired from this strategy when an exception occurs. Default is true.
</xsd:documentation>
</xsd:annotation>
</xsd:attribute>
<xsd:attribute name="name" type="substitutableName" use="optional">
<xsd:annotation>
<xsd:documentation>
Name of the exception strategy that will be used in ref attribute of 'exception-strategy' element
</xsd:documentation>
</xsd:annotation>
</xsd:attribute>
<xsd:attribute name="when" type="xsd:string" use="optional">
<xsd:annotation>
<xsd:documentation>
The expression that will be evaluated to determine if this exception strategy should be executed. This should always be a boolean expression.
</xsd:documentation>
</xsd:annotation>
</xsd:attribute>
</xsd:extension>
</xsd:complexContent>
</xsd:complexType>
<xsd:complexType name="abstractExceptionStrategyType">
<xsd:complexContent>
<xsd:sequence>
<xsd:element maxOccurs="1" minOccurs="0" name="commit-transaction" type="exceptionPatternType">
<xsd:annotation>
<xsd:documentation>
These exceptions will be considered "delivered" after handling by the exception strategy. Any exception not
accepted by this filter will be redelivered/rolled back.
You can set a comma-separated list of wildcard patterns that will be matched against the fully qualified class name of the current exception.
</xsd:documentation>
</xsd:annotation>
</xsd:element>
<xsd:element maxOccurs="1" minOccurs="0" name="rollback-transaction" type="exceptionPatternType">
<xsd:annotation>
<xsd:documentation>
These exceptions will be redelivered/rolled back after handling by the exception strategy.
You can set a comma-separated list of wildcard patterns that will be matched against the fully qualified class name of the current exception.
</xsd:documentation>
</xsd:annotation>
</xsd:element>
<xsd:group maxOccurs="1" minOccurs="0" ref="messageProcessorOrOutboundEndpoint">
<xsd:annotation>
<xsd:documentation>
Destination to which an ExceptionMessage will be sent; this could be an outbound endpoint, a router, or other message processor.
</xsd:documentation>
</xsd:annotation>
</xsd:group>
</xsd:sequence>
</xsd:extension>
</xsd:complexContent>
</xsd:complexType>
<xsd:complexType name="exceptionPatternType">
<xsd:attribute name="exception-pattern" type="xsd:string" use="required">
<xsd:annotation>
<xsd:documentation>
A comma-separated list of wildcard expressions that will be matched against the fully qualified classname of the current exception received by the ExceptionStrategy.
</xsd:documentation>
</xsd:annotation>
</xsd:attribute>
</xsd:complexType>
<!--==============================================================-->
<!-- Reconnection strategies -->
<!--==============================================================-->
<xsd:element abstract="true" name="abstract-reconnection-strategy" type="abstractReconnectionStrategyType">
<xsd:annotation>
<xsd:documentation>
A placeholder for a reconnection strategy element. Reconnection strategies define how Mule should attempt to handle a connection failure.
</xsd:documentation>
</xsd:annotation>
</xsd:element>
<xsd:complexType name="abstractReconnectionStrategyType">
<xsd:sequence>
<xsd:element maxOccurs="1" minOccurs="0" ref="abstract-reconnect-notifier"/>
</xsd:sequence>
<xsd:attribute default="true" name="blocking" type="substitutableBoolean">
<xsd:annotation>
<xsd:documentation>
If false, the reconnection strategy will run in a separate, non-blocking thread
</xsd:documentation>
</xsd:annotation>
</xsd:attribute>
</xsd:complexType>
<xsd:element abstract="true" name="abstract-reconnect-notifier" type="abstractReconnectNotifierType">
<xsd:annotation>
<xsd:documentation>
A placeholder for a reconnection notifier element. The RetryNotifier interface is a callback that allows actions to be performed after each reconnection attempt, e.g., firing server notification events on success or failure.
</xsd:documentation>
</xsd:annotation>
</xsd:element>
<xsd:complexType name="abstractReconnectNotifierType"/>
<xsd:element name="reconnect" substitutionGroup="abstract-reconnection-strategy" type="reconnectSimpleStrategyType">
<xsd:annotation>
<xsd:documentation>
A reconnection strategy that allows the user to configure how many times a reconnection should be attempted and how long to wait between attempts.
</xsd:documentation>
</xsd:annotation>
</xsd:element>
<xsd:complexType name="reconnectSimpleStrategyType">
<xsd:complexContent>
<xsd:extension base="abstractReconnectionStrategyType">
<xsd:attribute default="2000" name="frequency" type="substitutableLong">
<xsd:annotation>
<xsd:documentation>How often (in ms) to reconnect</xsd:documentation>
</xsd:annotation>
</xsd:attribute>
<xsd:attribute default="2" name="count" type="substitutableInt">
<xsd:annotation>
<xsd:documentation>How many reconnection attempts to make</xsd:documentation>
</xsd:annotation>
</xsd:attribute>
</xsd:extension>
</xsd:complexContent>
</xsd:complexType>
<xsd:element name="reconnect-forever" substitutionGroup="abstract-reconnection-strategy" type="reconnectForeverStrategyType">
<xsd:annotation>
<xsd:documentation>
A reconnection strategy that retries an infinite number of times at the specified frequency.
</xsd:documentation>
</xsd:annotation>
</xsd:element>
<xsd:complexType name="reconnectForeverStrategyType">
<xsd:complexContent>
<xsd:extension base="abstractReconnectionStrategyType">
<xsd:attribute default="2000" name="frequency" type="substitutableLong">
<xsd:annotation>
<xsd:documentation>How often (in ms) to reconnect</xsd:documentation>
</xsd:annotation>
</xsd:attribute>
</xsd:extension>
</xsd:complexContent>
</xsd:complexType>
<xsd:annotation>
<xsd:documentation>
A user-defined reconnection strategy.
</xsd:documentation>
</xsd:annotation>
</xsd:element>
<xsd:complexType name="reconnectCustomStrategyType">
<xsd:complexContent>
<xsd:extension base="abstractReconnectionStrategyType">
<xsd:sequence>
<xsd:element maxOccurs="unbounded" minOccurs="0" ref="spring:property"/>
</xsd:sequence>
<xsd:attribute name="class" type="substitutableClass" use="required">
<xsd:annotation>
<xsd:documentation>
A class that implements the RetryPolicyTemplate interface.
</xsd:documentation>
</xsd:annotation>
</xsd:attribute>
</xsd:extension>
</xsd:complexContent>
</xsd:complexType>
<xsd:element name="reconnect-notifier" substitutionGroup="abstract-reconnect-notifier" type="reconnectNotifierType">
<xsd:annotation>
<xsd:documentation>
Fires a ConnectionNotification upon each reconnection attempt.
</xsd:documentation>
</xsd:annotation>
</xsd:element>
<xsd:complexType name="reconnectNotifierType">
<xsd:complexContent>
<xsd:extension base="abstractReconnectNotifierType"/>
</xsd:complexContent>
</xsd:complexType>
<xsd:annotation>
<xsd:documentation>
A user-defined reconnection notifier.
</xsd:documentation>
</xsd:annotation>
</xsd:element>
<xsd:complexType name="reconnectCustomNotifierType">
<xsd:complexContent>
<xsd:extension base="abstractReconnectNotifierType">
<xsd:sequence>
<xsd:element maxOccurs="unbounded" minOccurs="0" ref="spring:property"/>
</xsd:sequence>
<xsd:attribute name="class" type="substitutableClass" use="required">
<xsd:annotation>
<xsd:documentation>
A class that implements the RetryNotifier interface.
</xsd:documentation>
</xsd:annotation>
</xsd:attribute>
</xsd:extension>
</xsd:complexContent>
</xsd:complexType>
<!--==============================================================-->
<xsd:complexType name="asyncReplyCollectionType">
<xsd:sequence>
<xsd:element maxOccurs="unbounded" minOccurs="1" ref="abstract-inbound-endpoint"/>
<xsd:choice maxOccurs="unbounded" minOccurs="0">
<xsd:element ref="abstract-async-reply-router"/>
<!-- Deprecated -->
<xsd:element ref="abstract-inbound-router"/>
<xsd:element ref="processor"/>
<xsd:element ref="custom-processor"/>
</xsd:choice>
</xsd:sequence>
<xsd:attribute name="timeout" type="substitutableInt">
<xsd:annotation>
<xsd:documentation>
The timeout (ms) to wait for a reply.
</xsd:documentation>
</xsd:annotation>
</xsd:attribute>
<xsd:attribute name="failOnTimeout" type="substitutableBoolean">
<xsd:annotation>
<xsd:documentation>
If the router times out before all expected events have been received, specifies whether an exception should be thrown (true) or the current events should be returned for processing (false). The default is true.
</xsd:documentation>
</xsd:annotation>
</xsd:attribute>
</xsd:complexType>
<xsd:element abstract="true" name="abstract-async-reply-router" type="abstractAsyncReplyRouterType">
<xsd:annotation>
<xsd:documentation>
A placeholder for an async reply router element. Asynchronous replies are handled via this router.
</xsd:documentation>
</xsd:annotation>
</xsd:element>
<xsd:complexType name="abstractAsyncReplyRouterType"/>
<xsd:element name="service" substitutionGroup="abstract-service" type="sedaServiceType">
<xsd:annotation>
<xsd:documentation>
Describes how to receive messages, deliver them to a component, and handle the results (if any).
</xsd:documentation>
</xsd:annotation>
</xsd:element>
<xsd:complexType name="sedaServiceType">
<xsd:complexContent>
<xsd:extension base="baseServiceType">
<xsd:sequence>
<xsd:element minOccurs="0" ref="abstract-service-threading-profile"/>
<xsd:element minOccurs="0" ref="abstract-queue-profile"/>
</xsd:sequence>
<xsd:attribute name="queueTimeout" type="substitutableInt">
<xsd:annotation>
<xsd:documentation>
The timeout used when taking messages from the service queue.
</xsd:documentation>
</xsd:annotation>
</xsd:attribute>
</xsd:extension>
</xsd:complexContent>
</xsd:complexType>
<xsd:element name="custom-service" substitutionGroup="abstract-service" type="customServiceType">
<xsd:annotation>
<xsd:documentation>
A user-implemented service (typically used only in testing).
</xsd:documentation>
</xsd:annotation>
</xsd:element>
<xsd:complexType name="customServiceType">
<xsd:complexContent>
<xsd:extension base="baseServiceType">
<xsd:sequence>
<xsd:element maxOccurs="unbounded" minOccurs="0" ref="spring:property">
<xsd:annotation>
<xsd:documentation>
Spring-style property element for custom configuration.
</xsd:documentation>
</xsd:annotation>
</xsd:element>
</xsd:sequence>
<xsd:attribute name="class" type="substitutableClass" use="required">
<xsd:annotation>
<xsd:documentation>
The class to use for the service.
</xsd:documentation>
</xsd:annotation>
</xsd:attribute>
</xsd:extension>
</xsd:complexContent>
</xsd:complexType>
<xsd:annotation>
<xsd:documentation>
A placeholder for the service threading profile element. Threading profiles define how thread pools are used by a service.
</xsd:documentation>
</xsd:annotation>
</xsd:element>
<xsd:complexType name="abstractServiceThreadingProfileType"/>
<!--==============================================================-->
<!-- Flow Constructs -->
<!--==============================================================-->
<xsd:element abstract="true" name="abstract-flow-construct" type="abstractFlowConstructType">
<xsd:annotation>
<xsd:documentation>
A placeholder for a flow construct element.
</xsd:documentation>
</xsd:annotation>
</xsd:element>
<xsd:complexType name="abstractFlowConstructType">
<xsd:complexContent>
<xsd:extension base="annotatedType">
<xsd:attribute name="name" type="nonBlankString" use="required">
<xsd:annotation>
<xsd:documentation>
The name used to identify this flow construct.
</xsd:documentation>
</xsd:annotation>
</xsd:attribute>
<xsd:attribute default="false" name="abstract" type="xsd:boolean" use="optional">
<xsd:annotation>
<xsd:documentation>
Determines if the flow construct is abstract (ie a parent that will be inherited in concrete constructs).
</xsd:documentation>
</xsd:annotation>
</xsd:attribute>
<xsd:attribute name="parent" type="xsd:NMTOKEN" use="optional">
<xsd:annotation>
<xsd:documentation>
Determines if the flow construct inherits part of its configuration from a parent construct.
</xsd:documentation>
</xsd:annotation>
</xsd:attribute>
</xsd:extension>
</xsd:complexContent>
</xsd:complexType>
<xsd:complexType name="baseFlowConstructType">
<xsd:annotation>
<xsd:documentation>
Base support for a flow construct.
</xsd:documentation>
</xsd:annotation>
<xsd:complexContent>
<xsd:extension base="abstractFlowConstructType">
<xsd:sequence>
<xsd:element minOccurs="0" name="description" type="descriptionType">
<xsd:annotation>
<xsd:documentation>
This can hold any kind of documentation related to the flow construct. It is intended to be "human readable" only and is not used by the system.
</xsd:documentation>
</xsd:annotation>
</xsd:element>
</xsd:sequence>
<xsd:attribute default="started" name="initialState">
<xsd:annotation>
<xsd:documentation>
The initial state of the flow. Usually a flow is started automatically ("started"), but this attribute can be used to disable initial startup ("stopped").
</xsd:documentation>
</xsd:annotation>
<xsd:simpleType>
<xsd:restriction base="xsd:NMTOKEN">
<xsd:enumeration value="started"/>
<xsd:enumeration value="stopped"/>
</xsd:restriction>
</xsd:simpleType>
</xsd:attribute>
</xsd:extension>
</xsd:complexContent>
</xsd:complexType>
<xsd:element name="flow" type="flowType">
<xsd:annotation>
<xsd:documentation>
A pipeline of message processors processed using a given processingStrategy when either a new message is received from a message source, or when a new message is
recieved via a flow-ref or programativally.
</xsd:documentation>
</xsd:annotation>
</xsd:element>
<xsd:complexType name="flowType">
<xsd:complexContent>
<xsd:extension base="annotatedType">
<xsd:sequence>
<xsd:element minOccurs="0" name="description" type="descriptionType">
<xsd:annotation>
<xsd:documentation>
This can hold any kind of documentation related to the flow construct. It is intended to be "human readable" only and is not used by the system.
</xsd:documentation>
</xsd:annotation>
</xsd:element>
<xsd:group minOccurs="0" ref="messageSourceOrInboundEndpoint"/>
<xsd:choice maxOccurs="unbounded" minOccurs="1">
<xsd:element name="response">
<xsd:annotation>
<xsd:documentation>
An outbound endpoint
</xsd:documentation>
</xsd:annotation>
<xsd:complexType>
<xsd:group maxOccurs="unbounded" ref="messageProcessorOrOutboundEndpoint"/>
</xsd:complexType>
</xsd:element>
</xsd:choice>
<xsd:element minOccurs="0" ref="legacy-abstract-exception-strategy"/>
<xsd:element minOccurs="0" ref="abstract-message-info-mapping">
<xsd:annotation>
<xsd:documentation>
The message info mapper used to extract key bits of the message information, such as Message ID or Correlation ID. these properties are used by some routers and this mapping information tells Mule where to get the information from in the current message.
</xsd:documentation>
</xsd:annotation>
</xsd:element>
</xsd:sequence>
<xsd:attribute name="name" type="nonBlankString" use="required">
<xsd:annotation>
<xsd:documentation>
The name used to identify this flow construct.
</xsd:documentation>
</xsd:annotation>
</xsd:attribute>
<xsd:attribute default="default" name="processingStrategy" use="optional">
<xsd:annotation>
<xsd:documentation>
Strategy used to process the configured message processors when exchange pattern is 'one-way'.
This attribute accepts either one of the enumerated strategies with default configuration options or a reference to a gloablly defined strategy.
</xsd:documentation>
</xsd:annotation>
<xsd:simpleType>
<xsd:union>
<xsd:simpleType>
<xsd:restriction base="xsd:string">
<xsd:annotation>
<xsd:documentation>
The name of a globally configured processing strategy
</xsd:documentation>
</xsd:annotation>
</xsd:restriction>
</xsd:simpleType>
<xsd:simpleType>
<xsd:restriction base="xsd:NMTOKEN">
<xsd:enumeration value="default">
<xsd:annotation>
<xsd:documentation>
This processing strategy uses the 'queued-asynchronous' strategy where possible, but if an event is synchronous it processes it synchronously rather than failing.
</xsd:documentation>
</xsd:annotation>
</xsd:enumeration>
<xsd:enumeration value="synchronous">
<xsd:annotation>
<xsd:documentation>
Processes all message processors in the calling thread.
</xsd:documentation>
</xsd:annotation>
</xsd:enumeration>
<xsd:enumeration value="asynchronous">
<xsd:annotation>
<xsd:documentation>
Uses a thread pool to process the pipeline of message processors asynchronously.
</xsd:documentation>
</xsd:annotation>
</xsd:enumeration>
<xsd:enumeration value="queued-asynchronous">
<xsd:annotation>
<xsd:documentation>
Decouples the recieving of a new message from it's processing using a queue.
The queue is polled and a thread pool is used to process the pipeline of message processors asynchronously.
</xsd:documentation>
</xsd:annotation>
</xsd:enumeration>
<xsd:enumeration value="thread-per-processor">
<xsd:annotation>
<xsd:documentation>
EXPERIMENTAL: Uses a thread pool to process each message processors asynchronously. (each processor has it's own thread pool currently)
</xsd:documentation>
</xsd:annotation>
</xsd:enumeration>
<xsd:enumeration value="queued-thread-per-processor">
<xsd:annotation>
<xsd:documentation>
EXPERIMENTAL: Decouples the processing of each message processor using a queue.
The queue is polled and use a thread pool to process each message processor asynchronously. (each processor has it's own thread pool currently)
</xsd:documentation>
</xsd:annotation>
</xsd:enumeration>
</xsd:restriction>
</xsd:simpleType>
</xsd:union>
</xsd:simpleType>
</xsd:attribute>
<xsd:attribute default="started" name="initialState">
<xsd:annotation>
<xsd:documentation>
The initial state of the flow. Usually a flow is started automatically ("started"), but this attribute can be used to disable initial startup ("stopped").
</xsd:documentation>
</xsd:annotation>
<xsd:simpleType>
<xsd:restriction base="xsd:NMTOKEN">
<xsd:enumeration value="started"/>
<xsd:enumeration value="stopped"/>
</xsd:restriction>
</xsd:simpleType>
</xsd:attribute>
</xsd:extension>
</xsd:complexContent>
</xsd:complexType>
<!-- Processing Strategies -->
<xsd:element abstract="true" name="abstract-processing-strategy" type="processingStrategyType">
<xsd:annotation>
<xsd:documentation>
The processing strategy to be used for processing a pipeline of message processors (e.g. in a Flow)
</xsd:documentation>
</xsd:annotation>
</xsd:element>
<xsd:complexType name="processingStrategyType">
<xsd:complexContent>
<xsd:extension base="annotatedType">
<xsd:attribute name="name" type="nonBlankString" use="required">
<xsd:annotation>
<xsd:documentation>
The name used to identify the processing strategy.
</xsd:documentation>
</xsd:annotation>
</xsd:attribute>
</xsd:extension>
</xsd:complexContent>
</xsd:complexType>
<xsd:annotation>
<xsd:documentation>
Processing strategy that uses a thread pool to process the pipeline of message processors asynchronously in a worker thread.
</xsd:documentation>
</xsd:annotation>
</xsd:element>
<xsd:complexType name="asynchronousProcessingStrategy">
<xsd:complexContent>
<xsd:extension base="processingStrategyType">
<xsd:attribute name="maxThreads" type="substitutableInt">
<xsd:annotation>
<xsd:documentation>
The maximum number of threads that will be used when under load.
</xsd:documentation>
</xsd:annotation>
</xsd:attribute>
<xsd:attribute name="minThreads" type="substitutableInt">
<xsd:annotation>
<xsd:documentation>
The number of idle threads that will kept in the pool when there is no load.
</xsd:documentation>
</xsd:annotation>
</xsd:attribute>
<xsd:attributeGroup ref="commonThreadPoolAttributes"/>
</xsd:extension>
</xsd:complexContent>
</xsd:complexType>
<xsd:annotation>
<xsd:documentation>
Decouples the recieving of a new message from it's processing using a queue.
The queue is polled and a thread pool is used to process the pipeline of message processors asynchonously in a worker thread.
</xsd:documentation>
</xsd:annotation>
</xsd:element>
<xsd:complexType name="queuedAsynchronousProcessingStrategy">
<xsd:complexContent>
<xsd:extension base="asynchronousProcessingStrategy">
<xsd:sequence>
<xsd:element minOccurs="0" ref="abstract-queue-store">
<xsd:annotation>
<xsd:documentation>
The queue store that stortes the queue's elements. If not specified, this will be the default-in-memory-queue-store.
</xsd:documentation>
</xsd:annotation>
</xsd:element>
</xsd:sequence>
<xsd:attribute name="queueTimeout" type="substitutableInt">
<xsd:annotation>
<xsd:documentation>
The timeout used when taking messages from the service queue.
</xsd:documentation>
</xsd:annotation>
</xsd:attribute>
<xsd:attribute name="maxQueueSize" type="substitutableInt">
<xsd:annotation>
<xsd:documentation>
Defines the maximum number of messages that can be queued.
</xsd:documentation>
</xsd:annotation>
</xsd:attribute>
</xsd:extension>
</xsd:complexContent>
</xsd:complexType>
<xsd:annotation>
<xsd:documentation>
EXPERIMENTAL: Uses a thread pool to process each message processors asynchronously in a worker thread. (each processor has it's own thread pool currently)
</xsd:documentation>
</xsd:annotation>
</xsd:element>
<xsd:annotation>
<xsd:documentation>
EXPERIMENTAL: Decouples the processing of each message processor using a queue.
The queue is polled and use a thread pool to process each message processor asynchronously in a worker thread. (each processor has it's own thread pool currently)
</xsd:documentation>
</xsd:annotation>
</xsd:element>
<xsd:annotation>
<xsd:documentation>
Allows for the configuration of a custom processing strategy that implements 'org.mule.api.construct.PipelineProcessingStrategy'.
</xsd:documentation>
</xsd:annotation>
</xsd:element>
<xsd:complexType name="customProcessingStrategy">
<xsd:complexContent>
<xsd:extension base="processingStrategyType">
<xsd:sequence>
<xsd:element maxOccurs="unbounded" minOccurs="0" ref="spring:property"/>
</xsd:sequence>
<xsd:attribute name="class" type="substitutableClass" use="required"/>
</xsd:extension>
</xsd:complexContent>
</xsd:complexType>
<xsd:element name="flow-ref" substitutionGroup="abstract-message-processor">
<xsd:annotation>
<xsd:documentation>
Allows a 'flow' to be referenced such that the message processing will continue in the referenced flow before returning. Message processing in the referenced 'flow' will occur within the context of the referenced flow and will therefore use it's exception strategy etc.
</xsd:documentation>
</xsd:annotation>
<xsd:complexType>
<xsd:complexContent>
<xsd:extension base="abstractMessageProcessorType">
<xsd:attribute name="name" type="xsd:string" use="required"/>
</xsd:extension>
</xsd:complexContent>
</xsd:complexType>
</xsd:element>
<xsd:element name="simple-service" substitutionGroup="abstract-flow-construct" type="simpleServiceType">
<xsd:annotation>
<xsd:documentation>
Deprecated. Use pattern:simple-service instead
</xsd:documentation>
</xsd:annotation>
</xsd:element>
<xsd:attributeGroup name="simpleServiceTypes">
<xsd:attribute name="type">
<xsd:annotation>
<xsd:documentation>
Defines the type of simple service.
</xsd:documentation>
</xsd:annotation>
<xsd:simpleType>
<xsd:restriction base="xsd:NMTOKEN">
<xsd:enumeration value="direct">
<xsd:annotation>
<xsd:documentation>
Pass the inbound messages unaltered to the component.
</xsd:documentation>
</xsd:annotation>
</xsd:enumeration>
<xsd:enumeration value="jax-ws">
<xsd:annotation>
<xsd:documentation>
Expose a JAX-WS annoted component as a web service. The CXF module is required to have this working.
</xsd:documentation>
</xsd:annotation>
</xsd:enumeration>
<xsd:enumeration value="jax-rs">
<xsd:annotation>
<xsd:documentation>
Expose a JAX-RS annoted component as a web service. The Jersey module is required to have this working.
</xsd:documentation>
</xsd:annotation>
</xsd:enumeration>
</xsd:restriction>
</xsd:simpleType>
</xsd:attribute>
</xsd:attributeGroup>
<xsd:complexType name="simpleServiceType">
<xsd:annotation>
<xsd:documentation>
A simple request-response service, with no outbound router.
</xsd:documentation>
</xsd:annotation>
<xsd:complexContent>
<xsd:extension base="baseFlowConstructType">
<xsd:sequence>
<xsd:element maxOccurs="1" minOccurs="0" ref="abstract-inbound-endpoint">
<xsd:annotation>
<xsd:documentation>
The endpoint on which messages are received.
</xsd:documentation>
</xsd:annotation>
</xsd:element>
<xsd:element maxOccurs="1" minOccurs="0" ref="abstract-component">
<xsd:annotation>
<xsd:documentation>
The component that is invoked when incoming messages are received.
</xsd:documentation>
</xsd:annotation>
</xsd:element>
<xsd:element minOccurs="0" ref="legacy-abstract-exception-strategy"/>
</xsd:sequence>
<xsd:attribute name="address" type="xsd:string">
<xsd:annotation>
<xsd:documentation>
The address on which this simple service is listening.
</xsd:documentation>
</xsd:annotation>
</xsd:attribute>
<xsd:attribute name="endpoint-ref" type="xsd:string">
<xsd:annotation>
<xsd:documentation>
The endpoint on which this simple service is listening.
</xsd:documentation>
</xsd:annotation>
</xsd:attribute>
<xsd:attribute name="transformer-refs" type="xsd:NMTOKENS">
<xsd:annotation>
<xsd:documentation>
A list of the transformers that will be applied (in order) to the message before it is delivered to the component.
</xsd:documentation>
</xsd:annotation>
</xsd:attribute>
<xsd:attribute name="responseTransformer-refs" type="xsd:NMTOKENS">
<xsd:annotation>
<xsd:documentation>
A list of the transformers that will be applied (in order) to the synchronous response before it is returned via the transport.
</xsd:documentation>
</xsd:annotation>
</xsd:attribute>
<xsd:attribute name="component-ref" type="xsd:string">
<xsd:annotation>
<xsd:documentation>
The component that is invoked when incoming messages are received.
</xsd:documentation>
</xsd:annotation>
</xsd:attribute>
<xsd:attribute name="component-class" type="substitutableClass">
<xsd:annotation>
<xsd:documentation>
Specifies a component class. This is a shortcut that is equivalent to providing a 'prototype-object' element.
</xsd:documentation>
</xsd:annotation>
</xsd:attribute>
<xsd:attributeGroup ref="simpleServiceTypes"/>
</xsd:extension>
</xsd:complexContent>
</xsd:complexType>
<xsd:element name="bridge" substitutionGroup="abstract-flow-construct" type="bridgeType">
<xsd:annotation>
<xsd:documentation>
Deprecated. Use pattern:bridge instead
</xsd:documentation>
</xsd:annotation>
</xsd:element>
<xsd:complexType name="bridgeType">
<xsd:annotation>
<xsd:documentation>
A bridge with a single inbound endpoint and a single outbound endpoint.
</xsd:documentation>
</xsd:annotation>
<xsd:complexContent>
<xsd:extension base="baseFlowConstructType">
<xsd:sequence>
<xsd:element maxOccurs="1" minOccurs="0" ref="abstract-inbound-endpoint">
<xsd:annotation>
<xsd:documentation>
The endpoint on which messages are received.
</xsd:documentation>
</xsd:annotation>
</xsd:element>
<xsd:element maxOccurs="1" minOccurs="0" ref="abstract-outbound-endpoint">
<xsd:annotation>
<xsd:documentation>
The endpoint to which messages are sent.
</xsd:documentation>
</xsd:annotation>
</xsd:element>
<xsd:element minOccurs="0" ref="legacy-abstract-exception-strategy"/>
</xsd:sequence>
<xsd:attribute name="inboundAddress" type="xsd:string">
<xsd:annotation>
<xsd:documentation>
The address on which this bridge is listening.
</xsd:documentation>
</xsd:annotation>
</xsd:attribute>
<xsd:attribute name="inboundEndpoint-ref" type="xsd:string">
<xsd:annotation>
<xsd:documentation>
The endpoint on which this bridge is listening.
</xsd:documentation>
</xsd:annotation>
</xsd:attribute>
<xsd:attribute name="outboundAddress" type="xsd:string">
<xsd:annotation>
<xsd:documentation>
The address to which messages are sent.
</xsd:documentation>
</xsd:annotation>
</xsd:attribute>
<xsd:attribute name="outboundEndpoint-ref" type="xsd:string">
<xsd:annotation>
<xsd:documentation>
The endpoint to which messages are sent.
</xsd:documentation>
</xsd:annotation>
</xsd:attribute>
<xsd:attribute name="transformer-refs" type="xsd:NMTOKENS">
<xsd:annotation>
<xsd:documentation>
A list of the transformers that will be applied (in order) to the message before it is delivered to the destination endpoint.
</xsd:documentation>
</xsd:annotation>
</xsd:attribute>
<xsd:attribute name="responseTransformer-refs" type="xsd:NMTOKENS">
<xsd:annotation>
<xsd:documentation>
A list of the transformers that will be applied (in order) to the synchronous response (if any) of the destination endpoint.
</xsd:documentation>
</xsd:annotation>
</xsd:attribute>
<xsd:attributeGroup ref="allExchangePatterns"/>
<xsd:attribute name="transacted" type="xsd:boolean">
<xsd:annotation>
<xsd:documentation>
Defines if the bridge will consume its inbound messages and dispatch its outbound ones within a transaction.
Attempt will be made to automatically select the most appropriate transaction manager (including XA): for more control, use child endpoints.
</xsd:documentation>
</xsd:annotation>
</xsd:attribute>
</xsd:extension>
</xsd:complexContent>
</xsd:complexType>
<xsd:element name="validator" substitutionGroup="abstract-flow-construct" type="validatorType">
<xsd:annotation>
<xsd:documentation>
Deprecated. Use pattern:validator instead
</xsd:documentation>
</xsd:annotation>
</xsd:element>
<xsd:complexType name="validatorType">
<xsd:annotation>
<xsd:documentation>
A validator with a single request-response inbound endpoint and a single outbound endpoint.
</xsd:documentation>
</xsd:annotation>
<xsd:complexContent>
<xsd:extension base="baseFlowConstructType">
<xsd:sequence>
<xsd:element maxOccurs="1" minOccurs="0" ref="abstract-inbound-endpoint">
<xsd:annotation>
<xsd:documentation>
The endpoint on which messages are received.
</xsd:documentation>
</xsd:annotation>
</xsd:element>
<xsd:element maxOccurs="1" minOccurs="0" ref="abstract-filter">
<xsd:annotation>
<xsd:documentation>
The filter to use to validate incoming message: accepted messages are considered valid.
</xsd:documentation>
</xsd:annotation>
</xsd:element>
<xsd:element maxOccurs="1" minOccurs="0" ref="abstract-outbound-endpoint">
<xsd:annotation>
<xsd:documentation>
The endpoint to which messages are sent.
</xsd:documentation>
</xsd:annotation>
</xsd:element>
<xsd:element minOccurs="0" ref="legacy-abstract-exception-strategy"/>
</xsd:sequence>
<xsd:attribute name="inboundAddress" type="xsd:string">
<xsd:annotation>
<xsd:documentation>
The address on which this bridge is listening.
</xsd:documentation>
</xsd:annotation>
</xsd:attribute>
<xsd:attribute name="inboundEndpoint-ref" type="xsd:string">
<xsd:annotation>
<xsd:documentation>
The endpoint on which this bridge is listening.
</xsd:documentation>
</xsd:annotation>
</xsd:attribute>
<xsd:attribute name="validationFilter-ref" type="xsd:string">
<xsd:annotation>
<xsd:documentation>
The filter to use to validate incoming message: accepted messages are considered valid.
</xsd:documentation>
</xsd:annotation>
</xsd:attribute>
<xsd:attribute name="outboundAddress" type="xsd:string">
<xsd:annotation>
<xsd:documentation>
The address to which messages are sent.
</xsd:documentation>
</xsd:annotation>
</xsd:attribute>
<xsd:attribute name="outboundEndpoint-ref" type="xsd:string">
<xsd:annotation>
<xsd:documentation>
The endpoint to which messages are sent.
</xsd:documentation>
</xsd:annotation>
</xsd:attribute>
<xsd:attribute name="ackExpression" type="xsd:string">
<xsd:annotation>
<xsd:documentation>
An expression used to build the content of the response in case a valid message has been received.
</xsd:documentation>
</xsd:annotation>
</xsd:attribute>
<xsd:attribute name="nackExpression" type="xsd:string">
<xsd:annotation>
<xsd:documentation>
An expression used to build the content of the response in case an invalid message has been received.
</xsd:documentation>
</xsd:annotation>
</xsd:attribute>
<xsd:attribute name="errorExpression" type="xsd:string">
<xsd:annotation>
<xsd:documentation>
An expression used to build the content of the response in case an error occurs during the outbound dispatch.
The outbound endpoint's exchange pattern must be request-response if errorExpression is used.
</xsd:documentation>
</xsd:annotation>
</xsd:attribute>
</xsd:extension>
</xsd:complexContent>
</xsd:complexType>
<!--==============================================================-->
<!-- Components -->
<!--==============================================================-->
<xsd:element abstract="true" name="abstract-component" substitutionGroup="abstract-message-processor" type="abstractComponentType">
<xsd:annotation>
<xsd:documentation>
A placeholder for a component element. A component is invoked when inbound messages are received by the service.
</xsd:documentation>
</xsd:annotation>
</xsd:element>
<xsd:complexType name="abstractComponentType">
<xsd:complexContent>
<xsd:extension base="abstractMessageProcessorType">
<xsd:group minOccurs="0" ref="interceptorGroup">
<xsd:annotation>
<xsd:documentation>
Interceptors that can be used to intercept component invocation.
</xsd:documentation>
</xsd:annotation>
</xsd:group>
</xsd:extension>
</xsd:complexContent>
</xsd:complexType>
<xsd:element name="component" substitutionGroup="abstract-component" type="defaultJavaComponentType">
<xsd:annotation>
<xsd:documentation>
A simple POJO (Plain Old Java Object) component that will be invoked by Mule when a message is received. The class or object instance to be used can be specified using a child object factory element, or via the 'class' attribute. If the 'class' attribute is used, an object factory cannot be configured as well. Using the 'class' attribute is equivilant to using the propotype object factory ('prototype-object' child element).
</xsd:documentation>
</xsd:annotation>
</xsd:element>
<xsd:complexType name="defaultJavaComponentType">
<xsd:complexContent>
<xsd:extension base="abstractComponentType">
<xsd:sequence>
<xsd:group ref="entryPointResolvers">
<xsd:annotation>
<xsd:documentation>
Entry point resolvers that are used to determine how a message is passed to a component.
</xsd:documentation>
</xsd:annotation>
</xsd:group>
<xsd:element minOccurs="0" ref="abstract-object-factory">
<xsd:annotation>
<xsd:documentation>
Object factory used to obtain the object instance that will be used for the component implementation. The object factory is responsible for object creation and may implement different patterns, such as singleton or prototype, or look up an instance from other object containers.
</xsd:documentation>
</xsd:annotation>
</xsd:element>
<xsd:element minOccurs="0" ref="abstract-lifecycle-adapter-factory"/>
<xsd:element maxOccurs="unbounded" minOccurs="0" name="binding" type="pojoBindingType">
<xsd:annotation>
<xsd:documentation>
A binding associates a Mule endpoint with an injected Java interface. This is like using Spring to inject a bean, but instead of calling a method on the bean, a message is sent to an endpoint.
</xsd:documentation>
</xsd:annotation>
</xsd:element>
</xsd:sequence>
<xsd:attribute name="class" type="substitutableClass">
<xsd:annotation>
<xsd:documentation>
Specifies a component class. This is a shortcut that is equivalent to providing a 'prototype-object' element.
</xsd:documentation>
</xsd:annotation>
</xsd:attribute>
</xsd:extension>
</xsd:complexContent>
</xsd:complexType>
<xsd:element name="pooled-component" substitutionGroup="abstract-component" type="pooledJavaComponentType">
<xsd:annotation>
<xsd:documentation>
A pooled POJO (Plain Old Java Object) component that will be invoked by Mule when a message is received. The instance can be specified via a factory or a class.
</xsd:documentation>
</xsd:annotation>
</xsd:element>
<xsd:complexType name="pooledJavaComponentType">
<xsd:complexContent>
<xsd:extension base="defaultJavaComponentType">
<xsd:sequence>
<xsd:element minOccurs="0" ref="abstract-pooling-profile">
<xsd:annotation>
<xsd:documentation>Characteristics of the object pool.</xsd:documentation>
</xsd:annotation>
</xsd:element>
</xsd:sequence>
</xsd:extension>
</xsd:complexContent>
</xsd:complexType>
<xsd:complexType name="pojoBindingType">
<xsd:sequence>
<xsd:element maxOccurs="unbounded" minOccurs="1" ref="abstract-outbound-endpoint"/>
</xsd:sequence>
<xsd:attribute name="interface" type="substitutableClass" use="required">
<xsd:annotation>
<xsd:documentation>
The interface to be injected. A proxy will be created that implements this interface by calling out to the endpoint.
</xsd:documentation>
</xsd:annotation>
</xsd:attribute>
<xsd:attribute name="method" use="optional">
<xsd:annotation>
<xsd:documentation>
The method on the interface that should be used. This can be omitted if the interface has a single method.
</xsd:documentation>
</xsd:annotation>
</xsd:attribute>
</xsd:complexType>
<xsd:complexType name="defaultComponentType">
<xsd:complexContent>
<xsd:extension base="abstractComponentType"/>
</xsd:complexContent>
</xsd:complexType>
<!-- don't expose this, it's not needed -->
<!-- xsd:element name="pass-through-component" type="defaultComponentType" substitutionGroup="abstract-component">
<xsd:annotation>
<xsd:documentation>
The default, "do nothing" component.
The message is simply transferred from inbound to outbound endpoints.
This is the default and need not be specified.
</xsd:documentation>
</xsd:annotation>
</xsd:element
-->
<xsd:element name="echo-component" substitutionGroup="abstract-component" type="defaultComponentType">
<xsd:annotation>
<xsd:documentation>
Logs the message and returns the payload as the result.
</xsd:documentation>
</xsd:annotation>
</xsd:element>
<xsd:element name="log-component" substitutionGroup="abstract-component" type="defaultComponentType">
<xsd:annotation>
<xsd:documentation>
Logs the message content (or content length if it is a large message).
</xsd:documentation>
</xsd:annotation>
</xsd:element>
<xsd:element name="null-component" substitutionGroup="abstract-component" type="defaultComponentType">
<xsd:annotation>
<xsd:documentation>
Throws an exception if it receives a message.
</xsd:documentation>
</xsd:annotation>
</xsd:element>
<xsd:element name="static-component" substitutionGroup="abstract-component" type="staticComponentType">
<xsd:annotation>
<xsd:documentation>
A service that will return static data as a result. The data returned can be read from a file or can be embedded directly in the XML.
</xsd:documentation>
</xsd:annotation>
</xsd:element>
<xsd:complexType name="staticComponentType">
<xsd:complexContent>
<xsd:extension base="abstractComponentType">
<xsd:sequence>
<xsd:element maxOccurs="1" minOccurs="0" name="return-data">
<xsd:annotation>
<xsd:documentation>
Defines the data to return from the service once it has been invoked. The return data can be located in a file, which you specify using the {{file}} attribute (specify a resource on the classpath or on disk), or the return data can be embedded directly in the XML.
</xsd:documentation>
</xsd:annotation>
<xsd:complexType mixed="true">
<xsd:attribute name="file" type="xsd:string">
<xsd:annotation>
<xsd:documentation>
The location of a file to load. The file can point to a resource on the classpath or on disk.
</xsd:documentation>
</xsd:annotation>
</xsd:attribute>
</xsd:complexType>
</xsd:element>
</xsd:sequence>
</xsd:extension>
</xsd:complexContent>
</xsd:complexType>
<!--==============================================================-->
<!-- Transactions -->
<!--==============================================================-->
<xsd:element abstract="true" name="abstract-transaction" type="abstractTransactionType">
<xsd:annotation>
<xsd:documentation>
A placeholder for transaction elements. Transactions allow a series of operations to be grouped together.
</xsd:documentation>
</xsd:annotation>
</xsd:element>
<xsd:element abstract="true" name="abstract-xa-transaction" type="abstractTransactionType">
<xsd:annotation>
<xsd:documentation>
A placeholder for XA transaction elements. XA transactions allow a series of operations to be grouped together spanning different transports, such as JMS and JDBC.
</xsd:documentation>
</xsd:annotation>
</xsd:element>
<xsd:element abstract="true" name="abstract-multi-transaction" type="abstractTransactionType">
<xsd:annotation>
<xsd:documentation>
A placeholder for multi-transaction elements.
Multi-transactions allow a series of operations to be grouped together spanning different
transports, e.g. JMS and JDBC, but without the overhead of XA. The trade-off is that XA
reliability guarantees aren't available, and services must be ready to handle duplicates.
This is very similar to a 1.5 PC concept. EE-only feature.
</xsd:documentation>
</xsd:annotation>
</xsd:element>
<xsd:complexType name="abstractTransactionType">
<xsd:attribute name="action" use="required">
<xsd:annotation>
<xsd:documentation>
The type of action the transaction should take, one of the following:
NONE - Never participate in a transaction.
ALWAYS_BEGIN - Always start a new transaction when receiving a message. An exception will be thrown if a transaction already exists.
BEGIN_OR_JOIN - If a transaction is already in progress when a message is received, join the transaction if possible. Otherwise, start a new transaction.
ALWAYS_JOIN - Always expects a transaction to be in progress when a message is received. If there is no transaction, an exception is thrown.
JOIN_IF_POSSIBLE - Join the current transaction if one is available. Otherwise, no transaction is created.
NOT_SUPPORTED - Execute outside any existent transaction
</xsd:documentation>
</xsd:annotation>
<xsd:simpleType>
<xsd:restriction base="xsd:NMTOKEN">
<xsd:enumeration value="NONE"/>
<xsd:enumeration value="ALWAYS_BEGIN"/>
<xsd:enumeration value="BEGIN_OR_JOIN"/>
<xsd:enumeration value="ALWAYS_JOIN"/>
<xsd:enumeration value="JOIN_IF_POSSIBLE"/>
<xsd:enumeration value="NOT_SUPPORTED"/>
</xsd:restriction>
</xsd:simpleType>
</xsd:attribute>
<xsd:attribute name="timeout" type="substitutableInt">
<xsd:annotation>
<xsd:documentation>
Timeout for the transaction (ms).
</xsd:documentation>
</xsd:annotation>
</xsd:attribute>
</xsd:complexType>
<xsd:complexType name="baseTransactionType">
<xsd:complexContent>
<xsd:extension base="abstractTransactionType"/>
</xsd:complexContent>
</xsd:complexType>
<xsd:element name="custom-transaction" substitutionGroup="abstract-transaction" type="customTransactionType">
<xsd:annotation>
<xsd:documentation>
A user-defined or otherwise unsupported third-party transactions.
</xsd:documentation>
</xsd:annotation>
</xsd:element>
<xsd:complexType name="customTransactionType">
<xsd:complexContent>
<xsd:extension base="baseTransactionType">
<xsd:attribute name="factory-class" type="substitutableClass">
<xsd:annotation>
<xsd:documentation>
A class that implements the TransactionFactory interface that will be instantiated and used to generate a transaction. This attribute and the 'factory-ref' attribute are mutually exclusive; one of the two is required.
</xsd:documentation>
</xsd:annotation>
</xsd:attribute>
<xsd:attribute name="factory-ref" type="xsd:string">
<xsd:annotation>
<xsd:documentation>
A bean that implements the TransactionFactory interface that will be used to generate a transaction. This attribute and the 'factory-class' attribute are mutually exclusive; one of the two is required.
</xsd:documentation>
</xsd:annotation>
</xsd:attribute>
</xsd:extension>
</xsd:complexContent>
</xsd:complexType>
<xsd:element name="xa-transaction" substitutionGroup="abstract-transaction" type="xaTransactionType">
<xsd:annotation>
<xsd:documentation>
An XA transaction.
</xsd:documentation>
</xsd:annotation>
</xsd:element>
<xsd:complexType name="xaTransactionType">
<xsd:complexContent>
<xsd:extension base="baseTransactionType">
<xsd:attribute name="interactWithExternal" type="xsd:boolean">
<xsd:annotation>
<xsd:documentation>
If this is set to "true", Mule interacts with transactions begun outside of Mule. E.g. if an external transaction is active, then BEGIN_OR_JOIN wil join it, and ALWAYS_BEGIN will cause an exception to be thrown.
</xsd:documentation>
</xsd:annotation>
</xsd:attribute>
</xsd:extension>
</xsd:complexContent>
</xsd:complexType>
<xsd:complexType name="transactionManagerType">
<xsd:complexContent>
<xsd:extension base="abstractTransactionManagerType">
<xsd:attribute default="transactionManager" name="name" type="substitutableName" use="optional">
<xsd:annotation>
<xsd:documentation>
An optional name for the transaction manager. The default value is "transactionManager".
</xsd:documentation>
</xsd:annotation>
</xsd:attribute>
</xsd:extension>
</xsd:complexContent>
</xsd:complexType>
<xsd:annotation>
<xsd:documentation>
The WebSphere transaction manager.
</xsd:documentation>
</xsd:annotation>
</xsd:element>
<xsd:element name="jboss-transaction-manager" substitutionGroup="abstract-transaction-manager" type="transactionManagerType">
<xsd:annotation>
<xsd:documentation>
The JBoss transaction manager.
</xsd:documentation>
</xsd:annotation>
</xsd:element>
<xsd:complexType name="jndiTransactionManagerType">
<xsd:complexContent>
<xsd:extension base="abstractTransactionManagerType">
<xsd:sequence>
<xsd:element maxOccurs="1" minOccurs="0" name="environment" type="mapType">
<xsd:annotation>
<xsd:documentation>
The JNDI environment.
</xsd:documentation>
</xsd:annotation>
</xsd:element>
</xsd:sequence>
</xsd:extension>
</xsd:complexContent>
</xsd:complexType>
<xsd:annotation>
<xsd:documentation>
The WebLogic transaction manager.
</xsd:documentation>
</xsd:annotation>
</xsd:element>
<xsd:element name="jrun-transaction-manager" substitutionGroup="abstract-transaction-manager" type="transactionManagerType">
<xsd:annotation>
<xsd:documentation>
The JRun transaction manager.
</xsd:documentation>
</xsd:annotation>
</xsd:element>
<xsd:element name="resin-transaction-manager" substitutionGroup="abstract-transaction-manager" type="transactionManagerType">
<xsd:annotation>
<xsd:documentation>
The Resin transaction manager.
</xsd:documentation>
</xsd:annotation>
</xsd:element>
<xsd:element name="jndi-transaction-manager" substitutionGroup="abstract-transaction-manager">
<xsd:annotation>
<xsd:documentation>
Retrieves a named transaction manager factory from JNDI.
</xsd:documentation>
</xsd:annotation>
<xsd:complexType>
<xsd:complexContent>
<xsd:extension base="jndiTransactionManagerType">
<xsd:attribute name="jndiName" type="xsd:string">
<xsd:annotation>
<xsd:documentation>
The name of the manager factory to retrieve (such as java:/TransactionManager).
</xsd:documentation>
</xsd:annotation>
</xsd:attribute>
</xsd:extension>
</xsd:complexContent>
</xsd:complexType>
</xsd:element>
<xsd:annotation>
<xsd:documentation>
A user-implemented transaction manager.
</xsd:documentation>
</xsd:annotation>
</xsd:element>
<xsd:complexType name="customTransactionManagerType">
<xsd:complexContent>
<xsd:extension base="jndiTransactionManagerType">
<xsd:sequence>
<xsd:element maxOccurs="unbounded" minOccurs="0" ref="spring:property">
<xsd:annotation>
<xsd:documentation>
Spring-style property element for custom configuration.
</xsd:documentation>
</xsd:annotation>
</xsd:element>
</xsd:sequence>
<xsd:attribute name="class" type="substitutableClass" use="required">
<xsd:annotation>
<xsd:documentation>
The class to instantiate to create a transaction manager.
</xsd:documentation>
</xsd:annotation>
</xsd:attribute>
</xsd:extension>
</xsd:complexContent>
</xsd:complexType>
<!--==============================================================-->
<!-- Endpoint elements -->
<!--==============================================================-->
<xsd:element name="endpoint" substitutionGroup="abstract-global-endpoint" type="globalEndpointType">
<xsd:annotation>
<xsd:documentation>
A global endpoint, which acts as a template that can be used to construct an inbound or outbound endpoint elsewhere in the configuration by referencing the global endpoint name. Each transport implements its own endpoint element, with a more friendly syntax, but this generic element can be used with any transport by supplying the correct address URI. For example, "vm://foo" describes a VM transport endpoint.
</xsd:documentation>
</xsd:annotation>
</xsd:element>
<xsd:complexContent>
<xsd:extension base="abstractGlobalEndpointType">
<xsd:group ref="defaultEndpointElements"/>
<xsd:attributeGroup ref="defaultEndpointAttributes"/>
</xsd:extension>
</xsd:complexContent>
</xsd:complexType>
<xsd:complexType name="globalEndpointType">
<xsd:complexContent>
<xsd:attributeGroup ref="allExchangePatterns"/>
</xsd:extension>
</xsd:complexContent>
</xsd:complexType>
<!-- extend this type for endpoints that support XA transactions -->
<xsd:complexType name="globalEndpointWithXaType">
<xsd:complexContent>
<xsd:extension base="abstractGlobalEndpointType">
<xsd:group ref="defaultXaEndpointElements"/>
<xsd:attributeGroup ref="defaultEndpointAttributes"/>
<xsd:attributeGroup ref="allExchangePatterns"/>
</xsd:extension>
</xsd:complexContent>
</xsd:complexType>
<xsd:element name="inbound-endpoint" substitutionGroup="abstract-inbound-endpoint" type="inboundEndpointType">
<xsd:annotation>
<xsd:documentation>
An inbound endpoint receives messages via the associated transport. As with global endpoints, each transport implements its own inbound endpoint element.
</xsd:documentation>
</xsd:annotation>
</xsd:element>
<xsd:complexContent>
<xsd:extension base="abstractInboundEndpointType">
<xsd:group ref="defaultEndpointElements"/>
<xsd:attributeGroup ref="defaultEndpointAttributes"/>
</xsd:extension>
</xsd:complexContent>
</xsd:complexType>
<xsd:complexType name="inboundEndpointType">
<xsd:complexContent>
<xsd:attributeGroup ref="allExchangePatterns"/>
</xsd:extension>
</xsd:complexContent>
</xsd:complexType>
<!-- extend this type for endpoints that support XA transactions -->
<xsd:complexType name="inboundEndpointWithXaType">
<xsd:complexContent>
<xsd:extension base="abstractInboundEndpointType">
<xsd:group ref="defaultXaEndpointElements"/>
<xsd:attributeGroup ref="defaultEndpointAttributes"/>
<xsd:attributeGroup ref="allExchangePatterns"/>
</xsd:extension>
</xsd:complexContent>
</xsd:complexType>
<xsd:element name="poll" substitutionGroup="abstract-message-source" type="pollInboundEndpointType">
<xsd:annotation>
<xsd:documentation>
Polls the nested message processor for new messages
</xsd:documentation>
</xsd:annotation>
</xsd:element>
<xsd:complexType name="pollInboundEndpointType">
<xsd:complexContent>
<xsd:extension base="abstractMessageSourceType">
<xsd:attribute default="1000" name="frequency" type="substitutableLong">
<xsd:annotation>
<xsd:documentation>
Polling frequency in milliseconds. Default frequency is 1000ms (1s).
</xsd:documentation>
</xsd:annotation>
</xsd:attribute>
</xsd:extension>
</xsd:complexContent>
</xsd:complexType>
<xsd:element name="outbound-endpoint" substitutionGroup="abstract-outbound-endpoint" type="outboundEndpointType">
<xsd:annotation>
<xsd:documentation>
An outbound endpoint sends messages via the associated transport. As with global endpoints, each transport implements its own outbound endpoint element.
</xsd:documentation>
</xsd:annotation>
</xsd:element>
<xsd:complexContent>
<xsd:extension base="abstractOutboundEndpointType">
<xsd:group ref="defaultEndpointElements"/>
<xsd:attributeGroup ref="defaultEndpointAttributes"/>
</xsd:extension>
</xsd:complexContent>
</xsd:complexType>
<xsd:complexType name="outboundEndpointType">
<xsd:complexContent>
<xsd:attributeGroup ref="allExchangePatterns"/>
</xsd:extension>
</xsd:complexContent>
</xsd:complexType>
<xsd:complexType name="outboundEndpointWithXaType">
<xsd:complexContent>
<xsd:extension base="abstractOutboundEndpointType">
<xsd:group ref="defaultXaEndpointElements"/>
<xsd:attributeGroup ref="allExchangePatterns"/>
<xsd:attributeGroup ref="defaultEndpointAttributes"/>
</xsd:extension>
</xsd:complexContent>
</xsd:complexType>
<xsd:element name="response">
<xsd:complexType>
<xsd:sequence>
<xsd:group maxOccurs="unbounded" minOccurs="1" ref="endpointMessageProcessorElements"/>
</xsd:sequence>
</xsd:complexType>
</xsd:element>
<!-- these include option/repeats - should be embedded once -->
<!-- these include option/repeats - should be embedded once -->
<xsd:sequence>
<xsd:group maxOccurs="unbounded" minOccurs="0" ref="endpointMessageProcessorElements"/>
<xsd:element minOccurs="0" ref="response"/>
<xsd:element minOccurs="0" ref="abstract-redelivery-policy"/>
<xsd:element minOccurs="0" ref="abstract-transaction"/>
</xsd:sequence>
</xsd:group>
<xsd:group name="defaultEndpointElements">
<xsd:sequence>
<xsd:element minOccurs="0" ref="abstract-reconnection-strategy"/>
<xsd:element minOccurs="0" ref="abstract-multi-transaction"/>
<xsd:group ref="propertiesGroup"/>
</xsd:sequence>
</xsd:group>
<xsd:group name="defaultXaEndpointElements">
<xsd:sequence>
<xsd:element minOccurs="0" ref="abstract-xa-transaction"/>
<xsd:group ref="propertiesGroup"/>
</xsd:sequence>
</xsd:group>
<xsd:choice>
<xsd:element ref="abstract-transformer"/>
<xsd:element ref="abstract-filter"/>
<xsd:element ref="abstract-security-filter"/>
<xsd:element ref="processor"/>
<xsd:element ref="custom-processor"/>
</xsd:choice>
</xsd:group>
<xsd:element abstract="true" name="abstract-security-filter" substitutionGroup="abstract-message-processor" type="abstractSecurityFilterType">
<xsd:annotation>
<xsd:documentation>
A placeholder for security filter elements, which control access to the system.
</xsd:documentation>
</xsd:annotation>
</xsd:element>
<xsd:complexType name="abstractSecurityFilterType">
<xsd:complexContent>
<xsd:extension base="abstractMessageProcessorType"/>
</xsd:complexContent>
</xsd:complexType>
<xsd:element name="username-password-filter" substitutionGroup="abstract-security-filter" type="usernamePasswordFilterType">
<xsd:annotation>
<xsd:documentation>
Authenticates a message based on username and password expressions.
</xsd:documentation>
</xsd:annotation>
</xsd:element>
<xsd:complexType name="usernamePasswordFilterType">
<xsd:complexContent>
<xsd:extension base="abstractSecurityFilterType">
<xsd:attribute name="username" type="xsd:string">
<xsd:annotation>
<xsd:documentation>
A Mule expression which extracts the username from the message. Defaults to #[header:inbound:username].
</xsd:documentation>
</xsd:annotation>
</xsd:attribute>
<xsd:attribute name="password" type="xsd:string">
<xsd:annotation>
<xsd:documentation>
A Mule expression which extracts the password from the message. Defaults to #[header:inbound:password].
</xsd:documentation>
</xsd:annotation>
</xsd:attribute>
</xsd:extension>
</xsd:complexContent>
</xsd:complexType>
<xsd:element name="custom-security-filter" substitutionGroup="abstract-security-filter" type="customSecurityFilterType">
<xsd:annotation>
<xsd:documentation>
Allows developers to configure custom security filters
</xsd:documentation>
</xsd:annotation>
</xsd:element>
<xsd:complexType name="customSecurityFilterType">
<xsd:complexContent>
<xsd:extension base="abstractSecurityFilterType">
<xsd:sequence>
<xsd:element maxOccurs="unbounded" minOccurs="0" ref="spring:property">
<xsd:annotation>
<xsd:documentation>
Spring-style property element for custom configuration.
</xsd:documentation>
</xsd:annotation>
</xsd:element>
</xsd:sequence>
<xsd:attribute name="class" type="substitutableClass" use="required"/>
</xsd:extension>
</xsd:complexContent>
</xsd:complexType>
<xsd:attributeGroup name="commonThreadPoolAttributes">
<xsd:attribute name="threadTTL" type="substitutableInt">
<xsd:annotation>
<xsd:documentation>
Determines how long an inactive thread is kept in the pool before being discarded.
</xsd:documentation>
</xsd:annotation>
</xsd:attribute>
<xsd:attribute name="poolExhaustedAction">
<xsd:annotation>
<xsd:documentation>
When the maximum pool size or queue size is bounded, this value determines how to handle incoming tasks. Possible values are: WAIT (wait until a thread becomes available; don't use this value if the minimum number of threads is zero, in which case a thread may never become available), DISCARD (throw away the current request and return), DISCARD_OLDEST (throw away the oldest request and return), ABORT (throw a RuntimeException), and RUN (the default; the thread making the execute request runs the task itself, which helps guard against lockup).
</xsd:documentation>
</xsd:annotation>
<xsd:simpleType>
<xsd:restriction base="xsd:NMTOKEN">
<xsd:enumeration value="WAIT"/>
<xsd:enumeration value="DISCARD"/>
<xsd:enumeration value="DISCARD_OLDEST"/>
<xsd:enumeration value="ABORT"/>
<xsd:enumeration value="RUN"/>
</xsd:restriction>
</xsd:simpleType>
</xsd:attribute>
<xsd:attribute name="threadWaitTimeout" type="substitutableInt">
<xsd:annotation>
<xsd:documentation>
How long to wait in milliseconds when the pool exhausted action is WAIT. If the value is negative, it will wait indefinitely.
</xsd:documentation>
</xsd:annotation>
</xsd:attribute>
<xsd:attribute name="maxBufferSize" type="substitutableInt">
<xsd:annotation>
<xsd:documentation>
Determines how many requests are queued when the pool is at maximum usage capacity and the pool exhausted action is WAIT. The buffer is used as an overflow.
</xsd:documentation>
</xsd:annotation>
</xsd:attribute>
</xsd:attributeGroup>
<xsd:attributeGroup name="defaultEndpointAttributes">
<xsd:attributeGroup ref="restrictedEndpointAttributes"/>
<!-- these next two attributes are mutually exclusive and one is required.
but there is no way to define this in a schema...
-->
<!-- endpoint references - dynamically checked to make sure not top level -->
<xsd:attribute name="ref" type="xsd:string">
<xsd:annotation>
<xsd:documentation>
A reference to a global endpoint, which is used as a template to construct this endpoint. A template fixes the address (protocol, path, host, etc.), and may specify initial values for various properties, but further properties can be defined locally (as long as they do not change the address in any way).
</xsd:documentation>
</xsd:annotation>
</xsd:attribute>
<!-- explicit or global endpoints -->
<xsd:attribute name="address" type="xsd:string">
<xsd:annotation>
<xsd:documentation>
The generic address for this endpoint. If this attribute is used, the protocol must be specified as part of the URI. Alternatively, most transports provide their own attributes for specifying the address (path, host, etc.). Note that the address attribute cannot be combined with 'ref' or with the transport-provided alternative attributes.
</xsd:documentation>
</xsd:annotation>
</xsd:attribute>
</xsd:attributeGroup>
<xsd:attributeGroup name="restrictedEndpointAttributes">
<xsd:attributeGroup ref="mimeTypeAttributes"/>
<xsd:attribute name="responseTimeout" type="substitutableInt">
<xsd:annotation>
<xsd:documentation>
The timeout for a response if making a synchronous endpoint call
</xsd:documentation>
</xsd:annotation>
</xsd:attribute>
<xsd:attribute name="encoding" type="xsd:string">
<xsd:annotation>
<xsd:documentation>
String encoding used for messages.
</xsd:documentation>
</xsd:annotation>
</xsd:attribute>
<xsd:attribute name="connector-ref" type="xsd:string">
<xsd:annotation>
<xsd:documentation>
The name of the connector associated with this endpoint. This must be specified if more than one connector is defined for this transport.
</xsd:documentation>
</xsd:annotation>
</xsd:attribute>
<xsd:attribute name="transformer-refs" type="xsd:NMTOKENS">
<xsd:annotation>
<xsd:documentation>
A list of the transformers that will be applied (in order) to the message before it is delivered to the component.
</xsd:documentation>
</xsd:annotation>
</xsd:attribute>
<xsd:attribute name="responseTransformer-refs" type="xsd:NMTOKENS">
<xsd:annotation>
<xsd:documentation>
A list of the transformers that will be applied (in order) to the synchronous response before it is returned via the transport.
</xsd:documentation>
</xsd:annotation>
</xsd:attribute>
<xsd:attribute name="disableTransportTransformer" type="substitutableBoolean" use="optional">
<xsd:annotation>
<xsd:documentation>
Don't use the default inbound/outbound/response transformer which corresponds to this endpoint's transport, if any.
</xsd:documentation>
</xsd:annotation>
</xsd:attribute>
</xsd:attributeGroup>
<xsd:complexType name="endpointRefType">
<xsd:attribute name="address" type="xsd:string">
<xsd:annotation>
<xsd:documentation>
The destination address for a reply message.
</xsd:documentation>
</xsd:annotation>
</xsd:attribute>
<xsd:attribute name="ref" type="xsd:string">
<xsd:annotation>
<xsd:documentation>
The reference name of a global endpoint to use. If this EndpointRef will be associated to a message such as a Reply-To address, this endpoint ref has to be available on the remote Mule instance that reads the Reply-To address.
</xsd:documentation>
</xsd:annotation>
</xsd:attribute>
</xsd:complexType>
<xsd:attributeGroup name="allExchangePatterns">
<xsd:attribute name="exchange-pattern">
<xsd:annotation>
<xsd:documentation/>
</xsd:annotation>
<xsd:simpleType>
<xsd:restriction base="xsd:NMTOKEN">
<xsd:enumeration value="one-way"/>
<xsd:enumeration value="request-response"/>
</xsd:restriction>
</xsd:simpleType>
</xsd:attribute>
</xsd:attributeGroup>
<xsd:attributeGroup name="oneWayOnlyExchangePattern">
<xsd:attribute name="exchange-pattern">
<xsd:annotation>
<xsd:documentation/>
</xsd:annotation>
<xsd:simpleType>
<xsd:restriction base="xsd:NMTOKEN">
<xsd:enumeration value="one-way"/>
</xsd:restriction>
</xsd:simpleType>
</xsd:attribute>
</xsd:attributeGroup>
<!--==============================================================-->
<!-- Filter elements -->
<!--==============================================================-->
<xsd:element name="filter" substitutionGroup="abstract-filter" type="refFilterType">
<xsd:annotation>
<xsd:documentation>
A filter that is defined elsewhere (at the global level, or as a Spring bean).
</xsd:documentation>
</xsd:annotation>
</xsd:element>
<xsd:complexType name="refFilterType">
<xsd:complexContent>
<xsd:extension base="commonFilterType">
<xsd:attribute name="ref" type="xsd:string" use="required">
<xsd:annotation>
<xsd:documentation>
The name of the filter to use.
</xsd:documentation>
</xsd:annotation>
</xsd:attribute>
</xsd:extension>
</xsd:complexContent>
</xsd:complexType>
<xsd:element name="not-filter" substitutionGroup="abstract-filter" type="unitaryFilterType">
<xsd:annotation>
<xsd:documentation>
Inverts the enclosed filter. For example, if the filter would normally return true for a specific message, it will now return false, and vice versa.
</xsd:documentation>
</xsd:annotation>
</xsd:element>
<xsd:complexType name="unitaryFilterType">
<xsd:complexContent>
<xsd:extension base="abstractFilterType">
<xsd:sequence>
<xsd:element ref="abstract-filter"/>
</xsd:sequence>
</xsd:extension>
</xsd:complexContent>
</xsd:complexType>
<xsd:element name="and-filter" substitutionGroup="abstract-filter" type="collectionFilterType">
<xsd:annotation>
<xsd:documentation>
Returns true only if all the enclosed filters return true.
</xsd:documentation>
</xsd:annotation>
</xsd:element>
<xsd:element name="or-filter" substitutionGroup="abstract-filter" type="collectionFilterType">
<xsd:annotation>
<xsd:documentation>
Returns true if any of the enclosed filters returns true.
</xsd:documentation>
</xsd:annotation>
</xsd:element>
<xsd:complexType name="collectionFilterType">
<xsd:complexContent>
<xsd:extension base="abstractFilterType">
<xsd:sequence>
<xsd:element maxOccurs="unbounded" minOccurs="2" ref="abstract-filter"/>
</xsd:sequence>
</xsd:extension>
</xsd:complexContent>
</xsd:complexType>
<xsd:element name="wildcard-filter" substitutionGroup="abstract-filter" type="wildcardFilterType">
<xsd:annotation>
<xsd:documentation>
A filter that matches string messages against wildcards. It performs matches with "*", for example, "jms.events.*" would catch "jms.events.customer" and "jms.events.receipts". This filter accepts a comma-separated list of patterns, so more than one filter pattern can be matched for a given argument: "jms.events.*, jms.actions.*" will match "jms.events.system" and "jms.actions" but not "jms.queue".
</xsd:documentation>
</xsd:annotation>
</xsd:element>
<xsd:complexType name="wildcardFilterType">
<xsd:complexContent>
<xsd:extension base="caseSensitivePatternFilterType"/>
</xsd:complexContent>
</xsd:complexType>
<xsd:element name="expression-filter" substitutionGroup="abstract-filter" type="expressionFilterType">
<xsd:annotation>
<xsd:documentation>
A filter that can evaluate a range of expressions. It supports some base expression types such as header, payload (payload type), regex, and wildcard.
</xsd:documentation>
</xsd:annotation>
</xsd:element>
<xsd:complexType name="expressionFilterType">
<xsd:complexContent>
<xsd:extension base="abstractFilterType">
<xsd:attribute name="evaluator" type="expressionFilterEvaluators" use="optional">
<xsd:annotation>
<xsd:documentation>
The expression evaluator to use. The expression filter supports some types such as header, payload, exception, wildcard, and regex, that are built-in filters not registered with the ExpressionEvaluatorManager. All others are registered with the ExpressionEvaluatorManager. Where XPath, bean, and ONGL are used, the expression should be a boolean expression.
</xsd:documentation>
</xsd:annotation>
</xsd:attribute>
<xsd:attribute name="expression" type="xsd:string" use="required">
<xsd:annotation>
<xsd:documentation>
The expression that will be evaluated. This should always be a boolean expression. The syntax of the expression will be determined by the expression language being used.
</xsd:documentation>
</xsd:annotation>
</xsd:attribute>
<xsd:attribute name="customEvaluator" type="substitutableName">
<xsd:annotation>
<xsd:documentation>
Must be set if the evaluator is set to custom. The custom evaluator must be registered with the ExpressionEvaluatorManager if it is to be used here.
</xsd:documentation>
</xsd:annotation>
</xsd:attribute>
<xsd:attribute name="nullReturnsTrue" type="substitutableBoolean">
<xsd:annotation>
<xsd:documentation>
Whether the filter should return true if the specified expression returns null.
</xsd:documentation>
</xsd:annotation>
</xsd:attribute>
</xsd:extension>
</xsd:complexContent>
</xsd:complexType>
<xsd:element name="regex-filter" substitutionGroup="abstract-filter" type="regexFilterType">
<xsd:annotation>
<xsd:documentation>
A filter that matches string messages against a regular expression. The Java regular expression engine (java.util.regex.Pattern) is used.
</xsd:documentation>
</xsd:annotation>
</xsd:element>
<xsd:complexType name="regexFilterType">
<xsd:complexContent>
<xsd:extension base="patternFilterType">
<xsd:attribute name="flags" type="xsd:string" use="optional">
<xsd:annotation>
<xsd:documentation>
Comma-separated list of flags for compiling the pattern. Valid values are CASE_INSENSITIVE, MULTILINE, DOTALL, UNICODE_CASE and CANON_EQ.
</xsd:documentation>
</xsd:annotation>
</xsd:attribute>
</xsd:extension>
</xsd:complexContent>
</xsd:complexType>
<xsd:complexType name="patternFilterType">
<xsd:complexContent>
<xsd:extension base="abstractFilterType">
<xsd:attribute name="pattern" type="xsd:string" use="required">
<xsd:annotation>
<xsd:documentation>
The property name and optionally a value to use when matching. If the expression is just a property name, the filter will check that the property exists. Users can also use '=' and '!=' to determine a specific value for a property.
</xsd:documentation>
</xsd:annotation>
</xsd:attribute>
</xsd:extension>
</xsd:complexContent>
</xsd:complexType>
<xsd:element name="message-property-filter" substitutionGroup="abstract-filter" type="scopedPropertyFilterType">
<xsd:annotation>
<xsd:documentation>
A filter that matches properties on a message. This can be very useful, as the message properties represent all the meta information about the message from the underlying transport, so for a message received over HTTP, you can check for HTTP headers and so forth. The pattern should be expressed as a key/value pair, such as "propertyName=value". If you want to compare more than one property, you can use the logic filters for And, Or, and Not expressions. By default, the comparison is case sensitive, which you can override with the 'caseSensitive' property.
</xsd:documentation>
</xsd:annotation>
</xsd:element>
<xsd:complexType name="scopedPropertyFilterType">
<xsd:complexContent>
<xsd:extension base="caseSensitivePatternFilterType">
<xsd:attribute default="outbound" name="scope">
<xsd:annotation>
<xsd:documentation>
Property scope to lookup the value from (default: outbound)
</xsd:documentation>
</xsd:annotation>
<xsd:simpleType>
<xsd:restriction base="xsd:NMTOKEN">
<xsd:enumeration value="inbound"/>
<xsd:enumeration value="invocation"/>
<xsd:enumeration value="outbound"/>
<xsd:enumeration value="session"/>
<xsd:enumeration value="application"/>
</xsd:restriction>
</xsd:simpleType>
</xsd:attribute>
</xsd:extension>
</xsd:complexContent>
</xsd:complexType>
<xsd:complexType name="caseSensitivePatternFilterType">
<xsd:complexContent>
<xsd:extension base="patternFilterType">
<xsd:attribute default="true" name="caseSensitive" type="substitutableBoolean">
<xsd:annotation>
<xsd:documentation>
If false, the comparison ignores case.
</xsd:documentation>
</xsd:annotation>
</xsd:attribute>
</xsd:extension>
</xsd:complexContent>
</xsd:complexType>
<xsd:element name="exception-type-filter" substitutionGroup="abstract-filter" type="typeFilterType">
<xsd:annotation>
<xsd:documentation>
A filter that matches the type of an exception.
</xsd:documentation>
</xsd:annotation>
</xsd:element>
<xsd:element name="payload-type-filter" substitutionGroup="abstract-filter" type="typeFilterType">
<xsd:annotation>
<xsd:documentation>
A filter that matches the type of the payload.
</xsd:documentation>
</xsd:annotation>
</xsd:element>
<xsd:complexType name="typeFilterType">
<xsd:complexContent>
<xsd:extension base="abstractFilterType">
<xsd:attribute name="expectedType" type="substitutableClass" use="required">
<xsd:annotation>
<xsd:documentation>
The expected class used in the comparison.
</xsd:documentation>
</xsd:annotation>
</xsd:attribute>
</xsd:extension>
</xsd:complexContent>
</xsd:complexType>
<xsd:element name="custom-filter" substitutionGroup="abstract-filter" type="customFilterType">
<xsd:annotation>
<xsd:documentation>
A user-implemented filter.
</xsd:documentation>
</xsd:annotation>
</xsd:element>
<xsd:complexType name="customFilterType">
<xsd:complexContent>
<xsd:extension base="abstractFilterType">
<xsd:sequence>
<xsd:element maxOccurs="unbounded" minOccurs="0" ref="spring:property">
<xsd:annotation>
<xsd:documentation>
Spring-style property element for custom configuration.
</xsd:documentation>
</xsd:annotation>
</xsd:element>
</xsd:sequence>
<xsd:attribute name="class" type="substitutableClass">
<xsd:annotation>
<xsd:documentation>
An implementation of the Filter interface.
</xsd:documentation>
</xsd:annotation>
</xsd:attribute>
</xsd:extension>
</xsd:complexContent>
</xsd:complexType>
<!--==============================================================-->
<!-- Interceptor elements -->
<!--==============================================================-->
<xsd:element abstract="true" name="abstract-interceptor-stack" type="abstractInterceptorStackType">
<xsd:annotation>
<xsd:documentation>
A placeholder for interceptor stack elements.
</xsd:documentation>
</xsd:annotation>
</xsd:element>
<xsd:complexType name="abstractInterceptorStackType">
<xsd:complexContent>
<xsd:extension base="annotatedType">
<xsd:sequence maxOccurs="unbounded">
<xsd:element ref="abstract-interceptor"/>
</xsd:sequence>
<xsd:attribute name="name" type="nonBlankString" use="required">
<xsd:annotation>
<xsd:documentation>
The name used to identify this interceptor stack.
</xsd:documentation>
</xsd:annotation>
</xsd:attribute>
</xsd:extension>
</xsd:complexContent>
</xsd:complexType>
<xsd:element name="interceptor-stack" substitutionGroup="abstract-interceptor-stack" type="abstractInterceptorStackType"/>
<xsd:element abstract="true" name="abstract-interceptor" substitutionGroup="abstract-message-processor" type="abstractInterceptorType">
<xsd:annotation>
<xsd:documentation>
A placeholder for an interceptor element.
</xsd:documentation>
</xsd:annotation>
</xsd:element>
<xsd:complexType name="abstractInterceptorType">
<xsd:complexContent>
<xsd:extension base="abstractMessageProcessorType"/>
</xsd:complexContent>
</xsd:complexType>
<xsd:group name="interceptorGroup">
<xsd:sequence>
<xsd:choice maxOccurs="unbounded">
<xsd:element ref="abstract-interceptor"/>
<xsd:element name="interceptor-stack" type="refInterceptorStackType">
<xsd:annotation>
<xsd:documentation>
A reference to a stack of intereceptors defined globally.
</xsd:documentation>
</xsd:annotation>
</xsd:element>
</xsd:choice>
</xsd:sequence>
</xsd:group>
<xsd:complexType name="refInterceptorStackType">
<xsd:attribute name="ref" type="xsd:string" use="required">
<xsd:annotation>
<xsd:documentation>
The name of the interceptor stack to use.
</xsd:documentation>
</xsd:annotation>
</xsd:attribute>
</xsd:complexType>
<xsd:element name="timer-interceptor" substitutionGroup="abstract-interceptor" type="abstractInterceptorType">
<xsd:annotation>
<xsd:documentation>
The timer interceptor (ported from 1.x).
</xsd:documentation>
</xsd:annotation>
</xsd:element>
<xsd:element name="logging-interceptor" substitutionGroup="abstract-interceptor" type="abstractInterceptorType">
<xsd:annotation>
<xsd:documentation>
The logging interceptor (ported from 1.x).
</xsd:documentation>
</xsd:annotation>
</xsd:element>
<xsd:element name="custom-interceptor" substitutionGroup="abstract-interceptor" type="customInterceptorType">
<xsd:annotation>
<xsd:documentation>
A user-implemented interceptor.
</xsd:documentation>
</xsd:annotation>
</xsd:element>
<xsd:complexType name="customInterceptorType">
<xsd:complexContent>
<xsd:extension base="abstractInterceptorType">
<xsd:sequence>
<xsd:element maxOccurs="unbounded" minOccurs="0" ref="spring:property">
<xsd:annotation>
<xsd:documentation>
Spring-style property element for custom configuration.
</xsd:documentation>
</xsd:annotation>
</xsd:element>
</xsd:sequence>
<xsd:attribute name="class" type="substitutableClass" use="required">
<xsd:annotation>
<xsd:documentation>
An implementation of the Interceptor interface.
</xsd:documentation>
</xsd:annotation>
</xsd:attribute>
</xsd:extension>
</xsd:complexContent>
</xsd:complexType>
<!-- security filters -->
<xsd:annotation>
<xsd:documentation>
A filter that provides password-based encyption.
</xsd:documentation>
</xsd:annotation>
</xsd:element>
<xsd:complexType name="encryptionSecurityFilterType">
<xsd:complexContent>
<xsd:extension base="abstractSecurityFilterType">
<xsd:attribute name="strategy-ref" type="xsd:string">
<xsd:annotation>
<xsd:documentation>
The name of the encryption strategy to use. This should be configured using the 'password-encryption-strategy' element, inside a 'security-manager' element at the top level.
</xsd:documentation>
</xsd:annotation>
</xsd:attribute>
</xsd:extension>
</xsd:complexContent>
</xsd:complexType>
<!--==============================================================-->
<!-- Transformer elements -->
<!--==============================================================-->
<xsd:element name="transformer" substitutionGroup="abstract-transformer" type="refTransformerType">
<xsd:annotation>
<xsd:documentation>
A reference to a transformer defined elsewhere.
</xsd:documentation>
</xsd:annotation>
</xsd:element>
<xsd:complexType name="refTransformerType">
<xsd:complexContent>
<xsd:extension base="commonTransformerType">
<xsd:attribute name="ref" type="xsd:string" use="required">
<xsd:annotation>
<xsd:documentation>
The name of the transformer to use.
</xsd:documentation>
</xsd:annotation>
</xsd:attribute>
</xsd:extension>
</xsd:complexContent>
</xsd:complexType>
<xsd:element name="auto-transformer" substitutionGroup="abstract-transformer" type="abstractTransformerType">
<xsd:annotation>
<xsd:documentation>
A transformer that uses the transform discovery mechanism to convert the message payload. This transformer works much better when transforming custom object types rather than Java types, because there is less chance for ambiguity.
</xsd:documentation>
</xsd:annotation>
</xsd:element>
<xsd:element name="custom-transformer" substitutionGroup="abstract-transformer" type="customTransformerType">
<xsd:annotation>
<xsd:documentation>
A user-implemented transformer.
</xsd:documentation>
</xsd:annotation>
</xsd:element>
<xsd:complexType name="customTransformerType">
<xsd:complexContent>
<xsd:extension base="abstractTransformerType">
<xsd:sequence>
<xsd:element maxOccurs="unbounded" minOccurs="0" ref="spring:property">
<xsd:annotation>
<xsd:documentation>
Spring-style property element for custom configuration.
</xsd:documentation>
</xsd:annotation>
</xsd:element>
</xsd:sequence>
<xsd:attribute name="class" type="substitutableClass" use="required">
<xsd:annotation>
<xsd:documentation>
An implementation of the Transformer interface.
</xsd:documentation>
</xsd:annotation>
</xsd:attribute>
</xsd:extension>
</xsd:complexContent>
</xsd:complexType>
<xsd:annotation>
<xsd:documentation>
A transformer that can add, delete or rename message properties.
</xsd:documentation>
</xsd:annotation>
</xsd:element>
<xsd:complexType name="messagePropertiesTransformerType">
<xsd:complexContent>
<xsd:extension base="abstractTransformerType">
<xsd:choice maxOccurs="unbounded" minOccurs="1">
<xsd:element maxOccurs="unbounded" minOccurs="0" name="delete-message-property" type="keyType">
<xsd:annotation>
<xsd:documentation>
Delete message properties matching a regular expression or wildcard.
</xsd:documentation>
</xsd:annotation>
</xsd:element>
<xsd:element maxOccurs="unbounded" minOccurs="0" name="add-message-property" type="keyValueType">
<xsd:annotation>
<xsd:documentation>
Add a message property.
</xsd:documentation>
</xsd:annotation>
</xsd:element>
<xsd:element maxOccurs="unbounded" minOccurs="0" name="rename-message-property" type="keyValueType">
<xsd:annotation>
<xsd:documentation>
Rename a message property.
</xsd:documentation>
</xsd:annotation>
</xsd:element>
<xsd:element maxOccurs="1" minOccurs="0" name="add-message-properties" type="mapType">
<xsd:annotation>
<xsd:documentation>
Add a set of message properties.
</xsd:documentation>
</xsd:annotation>
</xsd:element>
</xsd:choice>
<xsd:attribute default="true" name="overwrite" type="substitutableBoolean" use="optional">
<xsd:annotation>
<xsd:documentation>
If false, a property is not added if the message already contains a property with that name.
</xsd:documentation>
</xsd:annotation>
</xsd:attribute>
<xsd:attribute default="outbound" name="scope" use="optional">
<xsd:annotation>
<xsd:documentation>
Property scope to/from which properties are added/removed. The scope determines the lifespan of the properties. Default scope is outbound.
</xsd:documentation>
</xsd:annotation>
<xsd:simpleType>
<xsd:restriction base="xsd:NMTOKEN">
<xsd:enumeration value="invocation"/>
<xsd:enumeration value="outbound"/>
<xsd:enumeration value="session"/>
<xsd:enumeration value="application"/>
</xsd:restriction>
</xsd:simpleType>
</xsd:attribute>
</xsd:extension>
</xsd:complexContent>
</xsd:complexType>
<xsd:element name="set-property" substitutionGroup="abstract-transformer" type="setPropertyType">
<xsd:annotation>
<xsd:documentation>
A transformer that adds outbound message properties.
</xsd:documentation>
</xsd:annotation>
</xsd:element>
<xsd:complexType name="setPropertyType">
<xsd:complexContent>
<xsd:extension base="commonTransformerType">
<xsd:attribute name="propertyName" type="attributeType" use="required"/>
<xsd:attribute name="value" type="attributeType" use="required"/>
</xsd:extension>
</xsd:complexContent>
</xsd:complexType>
<xsd:element name="remove-property" substitutionGroup="abstract-transformer" type="removePropertyType">
<xsd:annotation>
<xsd:documentation>
A transformer that remove outbound message properties by name or regular expression.
</xsd:documentation>
</xsd:annotation>
</xsd:element>
<xsd:complexType name="removePropertyType">
<xsd:complexContent>
<xsd:extension base="commonTransformerType">
<xsd:attribute name="propertyName" type="attributeType" use="required"/>
</xsd:extension>
</xsd:complexContent>
</xsd:complexType>
<xsd:element name="copy-properties" substitutionGroup="abstract-transformer" type="copyPropertiesType">
<xsd:annotation>
<xsd:documentation>
A transformer that copy properties from inbound to outbound scope by name or regular expression.
</xsd:documentation>
</xsd:annotation>
</xsd:element>
<xsd:complexType name="copyPropertiesType">
<xsd:complexContent>
<xsd:extension base="commonTransformerType">
<xsd:attribute name="propertyName" type="attributeType" use="required"/>
</xsd:extension>
</xsd:complexContent>
</xsd:complexType>
<xsd:element name="set-variable" substitutionGroup="abstract-transformer" type="setVariableType">
<xsd:annotation>
<xsd:documentation>
A transformer that adds variables.
</xsd:documentation>
</xsd:annotation>
</xsd:element>
<xsd:complexType name="setVariableType">
<xsd:complexContent>
<xsd:extension base="commonTransformerType">
<xsd:attribute name="variableName" type="attributeType" use="required"/>
<xsd:attribute name="value" type="attributeType" use="required"/>
</xsd:extension>
</xsd:complexContent>
</xsd:complexType>
<xsd:element name="remove-variable" substitutionGroup="abstract-transformer" type="removeVariableType">
<xsd:annotation>
<xsd:documentation>
A transformer that remove variables by name or regular expression.
</xsd:documentation>
</xsd:annotation>
</xsd:element>
<xsd:complexType name="removeVariableType">
<xsd:complexContent>
<xsd:extension base="commonTransformerType">
<xsd:attribute name="variableName" type="attributeType" use="required"/>
</xsd:extension>
</xsd:complexContent>
</xsd:complexType>
<xsd:element name="set-session-variable" substitutionGroup="abstract-transformer" type="setVariableType">
<xsd:annotation>
<xsd:documentation>
A transformer that adds session variables.
</xsd:documentation>
</xsd:annotation>
</xsd:element>
<xsd:element name="remove-session-variable" substitutionGroup="abstract-transformer" type="removeVariableType">
<xsd:annotation>
<xsd:documentation>
A transformer that remove session variables by name or regular expression.
</xsd:documentation>
</xsd:annotation>
</xsd:element>
<xsd:element name="set-attachment" substitutionGroup="abstract-transformer" type="setAttachmentType">
<xsd:annotation>
<xsd:documentation>
A transformer that adds an attachment to the outbound scope.
</xsd:documentation>
</xsd:annotation>
</xsd:element>
<xsd:complexType name="setAttachmentType">
<xsd:complexContent>
<xsd:extension base="commonTransformerType">
<xsd:attribute name="attachmentName" type="attributeType" use="required"/>
<xsd:attribute name="value" type="attributeType" use="required"/>
<xsd:attribute name="contentType" type="attributeType" use="required"/>
</xsd:extension>
</xsd:complexContent>
</xsd:complexType>
<xsd:element name="remove-attachment" substitutionGroup="abstract-transformer" type="removeAttachmentType">
<xsd:annotation>
<xsd:documentation>
A transformer that removes an attachment in the outbound scope.
</xsd:documentation>
</xsd:annotation>
</xsd:element>
<xsd:complexType name="removeAttachmentType">
<xsd:complexContent>
<xsd:extension base="commonTransformerType">
<xsd:attribute name="attachmentName" type="attributeType" use="required"/>
</xsd:extension>
</xsd:complexContent>
</xsd:complexType>
<xsd:element name="copy-attachments" substitutionGroup="abstract-transformer" type="copyAttachmentType">
<xsd:annotation>
<xsd:documentation>
A transformer that copy inbound attachment to outbound attachment scope by name or regular expression.
</xsd:documentation>
</xsd:annotation>
</xsd:element>
<xsd:complexType name="copyAttachmentType">
<xsd:complexContent>
<xsd:extension base="commonTransformerType">
<xsd:attribute name="attachmentName" type="attributeType" use="required"/>
</xsd:extension>
</xsd:complexContent>
</xsd:complexType>
<xsd:element name="base64-encoder-transformer" substitutionGroup="abstract-transformer" type="abstractTransformerType">
<xsd:annotation>
<xsd:documentation>
A transformer that base64 encodes a string or byte array message.
</xsd:documentation>
</xsd:annotation>
</xsd:element>
<xsd:element name="base64-decoder-transformer" substitutionGroup="abstract-transformer" type="abstractTransformerType">
<xsd:annotation>
<xsd:documentation>
A transformer that base64 decodes a message to give an array of bytes.
</xsd:documentation>
</xsd:annotation>
</xsd:element>
<xsd:element name="xml-entity-encoder-transformer" substitutionGroup="abstract-transformer" type="abstractTransformerType">
<xsd:annotation>
<xsd:documentation>
A transformer that encodes a string using XML entities.
</xsd:documentation>
</xsd:annotation>
</xsd:element>
<xsd:element name="xml-entity-decoder-transformer" substitutionGroup="abstract-transformer" type="abstractTransformerType">
<xsd:annotation>
<xsd:documentation>
A transformer that decodes a string containing XML entities.
</xsd:documentation>
</xsd:annotation>
</xsd:element>
<xsd:element name="gzip-compress-transformer" substitutionGroup="abstract-transformer" type="abstractTransformerType">
<xsd:annotation>
<xsd:documentation>
A transformer that compresses a byte array using gzip.
</xsd:documentation>
</xsd:annotation>
</xsd:element>
<xsd:element name="gzip-uncompress-transformer" substitutionGroup="abstract-transformer" type="abstractTransformerType">
<xsd:annotation>
<xsd:documentation>
A transformer that uncompresses a byte array using gzip.
</xsd:documentation>
</xsd:annotation>
</xsd:element>
<xsd:annotation>
<xsd:documentation>
A transformer that converts a byte array to a string of hexadecimal digits.
</xsd:documentation>
</xsd:annotation>
</xsd:element>
<xsd:annotation>
<xsd:documentation>
A transformer that converts a string of hexadecimal digits to a byte array.
</xsd:documentation>
</xsd:annotation>
</xsd:element>
<xsd:element name="byte-array-to-object-transformer" substitutionGroup="abstract-transformer" type="abstractTransformerType">
<xsd:annotation>
<xsd:documentation>
A transformer that converts a byte array to an object (either deserializing or converting to a string).
</xsd:documentation>
</xsd:annotation>
</xsd:element>
<xsd:element name="object-to-byte-array-transformer" substitutionGroup="abstract-transformer" type="abstractTransformerType">
<xsd:annotation>
<xsd:documentation>
A transformer that serializes all objects except strings (which are converted using getBytes()).
</xsd:documentation>
</xsd:annotation>
</xsd:element>
<xsd:element name="object-to-string-transformer" substitutionGroup="abstract-transformer" type="abstractTransformerType">
<xsd:annotation>
<xsd:documentation>
A transformer that gives a human-readable description of various types (useful for debugging).
</xsd:documentation>
</xsd:annotation>
</xsd:element>
<xsd:annotation>
<xsd:documentation>
A transformer that converts a byte array to an object (deserializing the object).
</xsd:documentation>
</xsd:annotation>
</xsd:element>
<xsd:annotation>
<xsd:documentation>
A transformer that converts an object to a byte array (serializing the object).
</xsd:documentation>
</xsd:annotation>
</xsd:element>
<xsd:element name="byte-array-to-string-transformer" substitutionGroup="abstract-transformer" type="abstractTransformerType">
<xsd:annotation>
<xsd:documentation>
A transformer that converts a byte array to a string.
</xsd:documentation>
</xsd:annotation>
</xsd:element>
<xsd:element name="string-to-byte-array-transformer" substitutionGroup="abstract-transformer" type="abstractTransformerType">
<xsd:annotation>
<xsd:documentation>
A transformer that converts a string to a byte array.
</xsd:documentation>
</xsd:annotation>
</xsd:element>
<xsd:element name="map-to-bean-transformer" substitutionGroup="abstract-transformer" type="abstractTransformerType">
<xsd:annotation>
<xsd:documentation>
Creates and object of type @return-class and populates values of a {{java.util.Map}} as bean properties on the object.
The bean class name can also be passed in as a property on the Map (which gets removed once read). The {{MapToBean.CLASS_PROPERTY}} 'className' should be set as a fully qualified class name string.
</xsd:documentation>
</xsd:annotation>
</xsd:element>
<xsd:element name="bean-to-map-transformer" substitutionGroup="abstract-transformer" type="abstractTransformerType">
<xsd:annotation>
<xsd:documentation>
Conversts a simple bean object to a Map. every property on the bean will become an entry in the result {{java.util.Map}}. Note that only exposed bean properties with getter and setter methods will be added to the map.
</xsd:documentation>
</xsd:annotation>
</xsd:element>
<xsd:element name="append-string-transformer" substitutionGroup="abstract-transformer" type="appendStringTransformerType">
<xsd:annotation>
<xsd:documentation>
A transformer that appends a string to a string payload.
</xsd:documentation>
</xsd:annotation>
</xsd:element>
<xsd:complexType name="appendStringTransformerType">
<xsd:complexContent>
<xsd:extension base="abstractTransformerType">
<xsd:attribute name="message" type="xsd:string" use="required">
<xsd:annotation>
<xsd:documentation>
The string to append.
</xsd:documentation>
</xsd:annotation>
</xsd:attribute>
</xsd:extension>
</xsd:complexContent>
</xsd:complexType>
<xsd:element name="parse-template" substitutionGroup="abstract-transformer" type="parseTemplateTransformerType">
<xsd:annotation>
<xsd:documentation>
A transformer that parses a template in a given location
</xsd:documentation>
</xsd:annotation>
</xsd:element>
<xsd:complexType name="parseTemplateTransformerType">
<xsd:complexContent>
<xsd:extension base="abstractTransformerType">
<xsd:attribute name="location" type="xsd:string" use="required">
<xsd:annotation>
<xsd:documentation>
The location of the template. The order in which the transformer will attempt to load the file are: from the file system, from a URL or from the classpath.
</xsd:documentation>
</xsd:annotation>
</xsd:attribute>
</xsd:extension>
</xsd:complexContent>
</xsd:complexType>
<xsd:element name="set-payload" substitutionGroup="abstract-transformer" type="setPayloadTransformerType">
<xsd:annotation>
<xsd:documentation>
A transformer that sets the paylaod with the provided value
</xsd:documentation>
</xsd:annotation>
</xsd:element>
<xsd:complexType name="setPayloadTransformerType">
<xsd:complexContent>
<xsd:extension base="abstractTransformerType">
<xsd:attribute name="value" type="xsd:string" use="required">
<xsd:annotation>
<xsd:documentation>
The value to be set on the payload. Supports expressions.
</xsd:documentation>
</xsd:annotation>
</xsd:attribute>
</xsd:extension>
</xsd:complexContent>
</xsd:complexType>
<xsd:element name="encrypt-transformer" substitutionGroup="abstract-transformer" type="encryptionTransformerType">
<xsd:annotation>
<xsd:documentation>
A transformer that encrypts a message.
</xsd:documentation>
</xsd:annotation>
</xsd:element>
<xsd:element name="decrypt-transformer" substitutionGroup="abstract-transformer" type="encryptionTransformerType">
<xsd:annotation>
<xsd:documentation>
A transformer that decrypts a message.
</xsd:documentation>
</xsd:annotation>
</xsd:element>
<xsd:complexType name="encryptionTransformerType">
<xsd:complexContent>
<xsd:extension base="abstractTransformerType">
<xsd:attribute name="strategy-ref" type="xsd:string">
<xsd:annotation>
<xsd:documentation>
The name of the encryption strategy to use. This should be configured using the password-encryption-strategy element, inside a security-manager element at the top level.
</xsd:documentation>
</xsd:annotation>
</xsd:attribute>
</xsd:extension>
</xsd:complexContent>
</xsd:complexType>
<xsd:element name="bean-builder-transformer" substitutionGroup="abstract-transformer">
<xsd:annotation>
<xsd:documentation>
A transformer that uses expressions to configure a simple bean object. The user can specify a bean class or factory to create and one or more expressions that are used to configure properties on the bean.
</xsd:documentation>
</xsd:annotation>
<xsd:complexType>
<xsd:complexContent>
<xsd:extension base="abstractTransformerType">
<xsd:sequence maxOccurs="unbounded" minOccurs="1">
<xsd:element name="bean-property">
<xsd:complexType>
<xsd:attribute name="property-name" type="xsd:string" use="required">
<xsd:annotation>
<xsd:documentation>
The name of the bean property
</xsd:documentation>
</xsd:annotation>
</xsd:attribute>
<xsd:attributeGroup ref="expressionAttributes"/>
<xsd:attribute name="optional" type="substitutableBoolean" use="optional">
<xsd:annotation>
<xsd:documentation>
If the expression evaluates to null, whether to continue to the next expression without error.
</xsd:documentation>
</xsd:annotation>
</xsd:attribute>
</xsd:complexType>
</xsd:element>
</xsd:sequence>
<xsd:attribute name="beanClass" type="xsd:string">
<xsd:annotation>
<xsd:documentation>
The bean class to create
</xsd:documentation>
</xsd:annotation>
</xsd:attribute>
<xsd:attribute name="beanFactory-ref" type="xsd:string">
<xsd:annotation>
<xsd:documentation>
A Bean factory to use when creating the bean object. The factory must implement {{org.mule.api.object.ObjectFactory}}.
</xsd:documentation>
</xsd:annotation>
</xsd:attribute>
</xsd:extension>
</xsd:complexContent>
</xsd:complexType>
</xsd:element>
<xsd:element name="expression-transformer" substitutionGroup="abstract-transformer" type="expressionTransformerType">
<xsd:annotation>
<xsd:documentation>
A transformer that evaluates one or more expressions on the current message. Each expression equates to a parameter in the return message. The return message for two or more expressions will be an Object[].
</xsd:documentation>
</xsd:annotation>
</xsd:element>
<xsd:complexType name="expressionTransformerType">
<xsd:complexContent>
<xsd:extension base="abstractTransformerType">
<xsd:sequence maxOccurs="unbounded" minOccurs="0">
<xsd:element name="return-argument">
<xsd:annotation>
<xsd:documentation>
If all expressions return null or NullPayload on this transformer, this flag will cause the source payload to be returned without modification.
</xsd:documentation>
</xsd:annotation>
<xsd:complexType>
<xsd:attributeGroup ref="expressionAttributes"/>
<!--
-->
<xsd:attribute name="optional" type="substitutableBoolean" use="optional">
<xsd:annotation>
<xsd:documentation>
If the expression evaluates to null, specifies whether to continue to the next expression without error.
</xsd:documentation>
</xsd:annotation>
</xsd:attribute>
</xsd:complexType>
</xsd:element>
</xsd:sequence>
<xsd:attributeGroup ref="optionalExpressionAttributes"/>
<xsd:attribute name="returnSourceIfNull" type="xsd:boolean" use="optional">
<xsd:annotation>
<xsd:documentation>
If all expressions return null on this transformer, this flag will cause the source payload to be returned without modification.
</xsd:documentation>
</xsd:annotation>
</xsd:attribute>
</xsd:extension>
</xsd:complexContent>
</xsd:complexType>
<xsd:simpleType name="standardExpressionEvaluators">
<xsd:restriction base="substitutableName">
<xsd:enumeration value="attachment"/>
<xsd:enumeration value="attachments"/>
<xsd:enumeration value="attachments-list"/>
<xsd:enumeration value="bean"/>
<xsd:enumeration value="endpoint"/>
<xsd:enumeration value="exception-type"/>
<xsd:enumeration value="function"/>
<xsd:enumeration value="groovy"/>
<xsd:enumeration value="header"/>
<xsd:enumeration value="headers"/>
<xsd:enumeration value="headers-list"/>
<xsd:enumeration value="json"/>
<xsd:enumeration value="json-node"/>
<xsd:enumeration value="jxpath"/>
<xsd:enumeration value="map-payload"/>
<xsd:enumeration value="message"/>
<xsd:enumeration value="mule"/>
<xsd:enumeration value="ognl"/>
<xsd:enumeration value="payload"/>
<xsd:enumeration value="process"/>
<xsd:enumeration value="regex"/>
<xsd:enumeration value="string"/>
<xsd:enumeration value="variable"/>
<xsd:enumeration value="xpath"/>
<xsd:enumeration value="xpath2"/>
<xsd:enumeration value="xpath-node"/>
<xsd:enumeration value="custom"/>
</xsd:restriction>
</xsd:simpleType>
<xsd:simpleType name="expressionFilterEvaluators">
<xsd:restriction base="substitutableName">
<xsd:enumeration value="header"/>
<xsd:enumeration value="payload-type"/>
<xsd:enumeration value="exception-type"/>
<xsd:enumeration value="wildcard"/>
<xsd:enumeration value="regex"/>
<xsd:enumeration value="ognl"/>
<xsd:enumeration value="xpath"/>
<xsd:enumeration value="jxpath"/>
<xsd:enumeration value="groovy"/>
<xsd:enumeration value="bean"/>
<xsd:enumeration value="custom"/>
<xsd:enumeration value="registry"/>
<xsd:enumeration value="variable"/>
</xsd:restriction>
</xsd:simpleType>
<xsd:simpleType name="whenExpressionEvaluators">
<xsd:union>
<xsd:simpleType>
<xsd:restriction base="standardExpressionEvaluators"/>
</xsd:simpleType>
<xsd:simpleType>
<xsd:restriction base="substitutableName">
<xsd:enumeration value="payload-type"/>
<xsd:enumeration value="exception-type"/>
<xsd:enumeration value="wildcard"/>
<xsd:enumeration value="regex"/>
</xsd:restriction>
</xsd:simpleType>
</xsd:union>
</xsd:simpleType>
<xsd:simpleType name="standardExpressionEnrichers">
<xsd:restriction base="substitutableName">
<xsd:enumeration value="header"/>
<xsd:enumeration value="custom"/>
</xsd:restriction>
</xsd:simpleType>
<xsd:attributeGroup name="expressionAttributes">
<xsd:attribute name="evaluator" type="standardExpressionEvaluators" use="optional">
<xsd:annotation>
<xsd:documentation>
The expression evaluator to use. Expression evaluators must be registered with the ExpressionEvaluatorManager before they can be used. Using the custom evaluator allows you to define your own evaluator with the 'custom-evaluator' attribute. Note that some evaluators such as xpath, groovy, and bean are loaded from other Mule modules (XML and Scripting, respectively). These modules must be on your classpath before the evaluator can be used.
</xsd:documentation>
</xsd:annotation>
</xsd:attribute>
<xsd:attribute name="expression" type="xsd:string" use="required">
<xsd:annotation>
<xsd:documentation>
The expression to evaluate. The syntax of this attribute changes depending on the evaluator being used.
</xsd:documentation>
</xsd:annotation>
</xsd:attribute>
<xsd:attribute name="custom-evaluator" type="substitutableName" use="optional">
<xsd:annotation>
<xsd:documentation>
The name of the custom evaluator to use. This attribute is only used when the 'evaluator' attribute is set to "custom". You can plug in your own expression evaluators by registering them with the ExpressionEvaluatorManager.
</xsd:documentation>
</xsd:annotation>
</xsd:attribute>
</xsd:attributeGroup>
<xsd:attributeGroup name="optionalExpressionAttributes">
<xsd:attribute name="evaluator" type="standardExpressionEvaluators">
<xsd:annotation>
<xsd:documentation>
The expression evaluator to use. Expression evaluators must be registered with the ExpressionEvaluatorManager before they can be used. Using the custom evaluator allows you to define your own evaluator with the 'custom-evaluator' attribute. Note that some evaluators such as xpath, groovy, and bean are loaded from other Mule modules (XML and Scripting, respectively). These modules must be on your classpath before the evaluator can be used.
</xsd:documentation>
</xsd:annotation>
</xsd:attribute>
<xsd:attribute name="expression" type="xsd:string">
<xsd:annotation>
<xsd:documentation>
The expression to evaluate. The syntax of this attribute changes depending on the evaluator being used.
</xsd:documentation>
</xsd:annotation>
</xsd:attribute>
<xsd:attribute name="custom-evaluator" type="substitutableName">
<xsd:annotation>
<xsd:documentation>
The name of the custom evaluator to use. This attribute is only used when the 'evaluator' attribute is set to "custom". You can plug in your own expression evaluators by registering them with the ExpressionEvaluatorManager.
</xsd:documentation>
</xsd:annotation>
</xsd:attribute>
</xsd:attributeGroup>
<xsd:annotation>
<xsd:documentation>
Extracts values from a given source using regular expressions and uses that values to enrich the mule message.
</xsd:documentation>
</xsd:annotation>
</xsd:element>
<xsd:complexType name="valueExtractorTransformerType">
<xsd:complexContent>
<xsd:extension base="abstractTransformerType">
<xsd:sequence>
<xsd:element maxOccurs="unbounded" minOccurs="1" name="extract" type="extractValueExtractorTemplateType"/>
</xsd:sequence>
<xsd:attribute name="source" type="xsd:string" use="optional">
<xsd:annotation>
<xsd:documentation>
An evaluator expression used to extract the value that will be matched against each regular expression. If an expression is not specified then the payload of the message is used.
</xsd:documentation>
</xsd:annotation>
</xsd:attribute>
</xsd:extension>
</xsd:complexContent>
</xsd:complexType>
<xsd:complexType name="extractValueExtractorTemplateType">
<xsd:attributeGroup ref="valueExtractorTemplateAttributes"/>
</xsd:complexType>
<xsd:attributeGroup name="valueExtractorTemplateAttributes">
<xsd:attribute name="pattern" type="xsd:string">
<xsd:annotation>
<xsd:documentation>
A regular expression used to match against a source value. The regular expression should contain a capture group which value will be returned.
</xsd:documentation>
</xsd:annotation>
</xsd:attribute>
<xsd:attribute name="target" type="xsd:string" use="required">
<xsd:annotation>
<xsd:documentation>
The enricher expression used to enrich the current message with the result the processing of the regular expression.
</xsd:documentation>
</xsd:annotation>
</xsd:attribute>
<xsd:attribute default="true" name="failIfNoMatch" type="substitutableBoolean">
<xsd:annotation>
<xsd:documentation>
Determines if there should be an error in case the pattern is not matched by the source value.
</xsd:documentation>
</xsd:annotation>
</xsd:attribute>
<xsd:attribute name="defaultValue" type="xsd:string" use="optional">
<xsd:annotation>
<xsd:documentation>
The default value used to enrich the message when the source value does not match the pattern. Useful only when failIfNoMatch is false.
</xsd:documentation>
</xsd:annotation>
</xsd:attribute>
</xsd:attributeGroup>
<!--==============================================================-->
<!-- Shared elements -->
<!--==============================================================-->
<xsd:element name="queue-profile" substitutionGroup="abstract-queue-profile" type="queueProfileType">
<xsd:annotation>
<xsd:documentation>
Specifies the properties of an internal Mule queue. Internal queues are used to queue messages for each component managed by Mule.
</xsd:documentation>
</xsd:annotation>
</xsd:element>
<xsd:complexType name="queueProfileType">
<xsd:complexContent>
<xsd:extension base="abstractQueueProfileType">
<xsd:sequence>
<xsd:element minOccurs="0" ref="abstract-queue-store">
<xsd:annotation>
<xsd:documentation>
The queue store that stortes the queue's elements. If not specified, this will be the default-in-memory-queue-store.
</xsd:documentation>
</xsd:annotation>
</xsd:element>
</xsd:sequence>
<xsd:attribute name="maxOutstandingMessages" type="substitutableInt">
<xsd:annotation>
<xsd:documentation>
Defines the maximum number of messages that can be queued.
</xsd:documentation>
</xsd:annotation>
</xsd:attribute>
</xsd:extension>
</xsd:complexContent>
</xsd:complexType>
<xsd:element abstract="true" name="abstract-security-manager" type="abstractSecurityManagerType">
<xsd:annotation>
<xsd:documentation>
A security manager is a container for security providers. More than one security manager may be configured; each contains providers from a particular module and has that module type. This element is abstract - a security-related module or transport will provide a suitable implementation.
</xsd:documentation>
</xsd:annotation>
</xsd:element>
<xsd:complexType name="abstractSecurityManagerType">
<xsd:complexContent>
<xsd:extension base="annotatedType">
<xsd:annotation>
<xsd:documentation>
An empty holder that can be extended by modules that want to provide security managers. Typically it will contain elements called 'module:type-security-provider', which extend securityProviderType where "module" might be "spring-security" and "type" might de "delegate", for example. It can also contain encryption strategies, which should follow a similar scheme and extend encryptionStrategyType.
</xsd:documentation>
</xsd:annotation>
<xsd:attribute fixed="_muleSecurityManager" name="id"/>
<xsd:attribute fixed="_muleSecurityManager" name="name"/>
</xsd:extension>
</xsd:complexContent>
</xsd:complexType>
<xsd:element name="security-manager" substitutionGroup="abstract-security-manager" type="securityManagerType">
<xsd:annotation>
<xsd:documentation>
The default security manager.
</xsd:documentation>
</xsd:annotation>
</xsd:element>
<xsd:complexType name="securityManagerType">
<xsd:annotation>
<xsd:documentation>
The default security manager (type 'defaultSecurityManagerType') provides basic support for security functions. Other modules (JAAS, PGP, Spring Security) provide more advanced functionality.
</xsd:documentation>
</xsd:annotation>
<xsd:complexContent>
<xsd:extension base="abstractSecurityManagerType">
<xsd:sequence>
<xsd:element minOccurs="0" name="custom-security-provider" type="customSecurityProviderType">
<xsd:annotation>
<xsd:documentation>
A custom implementation of SecurityProvider.
</xsd:documentation>
</xsd:annotation>
</xsd:element>
<xsd:element minOccurs="0" name="custom-encryption-strategy" type="customEncryptionStrategyType">
<xsd:annotation>
<xsd:documentation>
A custom implementation of EncryptionStrategy.
</xsd:documentation>
</xsd:annotation>
</xsd:element>
<xsd:element minOccurs="0" name="secret-key-encryption-strategy" type="secretKeyEncryptionStrategyType">
<xsd:annotation>
<xsd:documentation>
Provides secret key-based encryption using JCE.
</xsd:documentation>
</xsd:annotation>
</xsd:element>
<xsd:element minOccurs="0" name="password-encryption-strategy" type="passwordEncryptionStrategyType">
<xsd:annotation>
<xsd:documentation>
Provides password-based encryption using JCE. Users must specify a password and optionally a salt and iteration count as well. The default algorithm is PBEWithMD5AndDES, but users can specify any valid algorithm supported by JCE.
</xsd:documentation>
</xsd:annotation>
</xsd:element>
</xsd:sequence>
</xsd:extension>
</xsd:complexContent>
</xsd:complexType>
<xsd:complexType name="securityProviderType">
<xsd:annotation>
<xsd:documentation>
A security provider is a source of specific security-related functionality.
</xsd:documentation>
</xsd:annotation>
<xsd:attribute name="name" type="substitutableName" use="required"/>
</xsd:complexType>
<xsd:complexType name="encryptionStrategyType">
<xsd:annotation>
<xsd:documentation>
An encryption strategy provides support for a specific encryption algorithm.
</xsd:documentation>
</xsd:annotation>
<xsd:attribute name="name" type="substitutableName" use="required"/>
</xsd:complexType>
<xsd:complexType name="customSecurityProviderType">
<xsd:complexContent>
<xsd:extension base="securityProviderType">
<xsd:sequence>
<xsd:element maxOccurs="unbounded" minOccurs="0" ref="spring:property">
<xsd:annotation>
<xsd:documentation>
Spring-style property element for custom configuration.
</xsd:documentation>
</xsd:annotation>
</xsd:element>
</xsd:sequence>
<xsd:attribute name="provider-ref" type="xsd:string" use="required">
<xsd:annotation>
<xsd:documentation>
The name of the security provider to use.
</xsd:documentation>
</xsd:annotation>
</xsd:attribute>
</xsd:extension>
</xsd:complexContent>
</xsd:complexType>
<xsd:complexType name="customEncryptionStrategyType">
<xsd:complexContent>
<xsd:extension base="encryptionStrategyType">
<xsd:sequence>
<xsd:element maxOccurs="unbounded" minOccurs="0" ref="spring:property"/>
</xsd:sequence>
<xsd:attribute name="strategy-ref" type="xsd:string" use="required">
<xsd:annotation>
<xsd:documentation>
A reference to the encryption strategy (which may be a Spring bean that implements the EncryptionStrategy interface).
</xsd:documentation>
</xsd:annotation>
</xsd:attribute>
</xsd:extension>
</xsd:complexContent>
</xsd:complexType>
<xsd:complexType name="passwordEncryptionStrategyType">
<xsd:complexContent>
<xsd:extension base="encryptionStrategyType">
<xsd:attribute name="password" type="xsd:string" use="required">
<xsd:annotation>
<xsd:documentation>
The password to use.
</xsd:documentation>
</xsd:annotation>
</xsd:attribute>
<xsd:attribute name="salt" type="xsd:string">
<xsd:annotation>
<xsd:documentation>
The salt to use (this helps prevent dictionary attacks).
</xsd:documentation>
</xsd:annotation>
</xsd:attribute>
<xsd:attribute name="iterationCount" type="substitutableInt">
<xsd:annotation>
<xsd:documentation>
The number of iterations to use.
</xsd:documentation>
</xsd:annotation>
</xsd:attribute>
</xsd:extension>
</xsd:complexContent>
</xsd:complexType>
<xsd:complexType name="secretKeyEncryptionStrategyType">
<xsd:complexContent>
<xsd:extension base="encryptionStrategyType">
<xsd:attribute name="key" type="xsd:string">
<xsd:annotation>
<xsd:documentation>
The key to use. This and the 'keyFactory-ref' attribute are mutually exclusive.
</xsd:documentation>
</xsd:annotation>
</xsd:attribute>
<xsd:attribute name="keyFactory-ref" type="xsd:string">
<xsd:annotation>
<xsd:documentation>
The name of the key factory to use. This should implement the ObjectFactory interface and return a byte array. This and the 'key' attribute are mutually exclusive.
</xsd:documentation>
</xsd:annotation>
</xsd:attribute>
</xsd:extension>
</xsd:complexContent>
</xsd:complexType>
<xsd:element name="threading-profile" substitutionGroup="abstract-service-threading-profile" type="threadingProfileType">
<xsd:annotation>
<xsd:documentation>
The threading profile to use for the service.
</xsd:documentation>
</xsd:annotation>
</xsd:element>
<!-- this is a general threading type used by various elements here -->
<xsd:complexType name="threadingProfileType">
<xsd:complexContent>
<!-- this is a hack that allows us to use this general threading profile as a component threading profile
without retyping everything
-->
<xsd:attribute name="maxThreadsActive" type="substitutableInt">
<xsd:annotation>
<xsd:documentation>
The maximum number of threads that will be used.
</xsd:documentation>
</xsd:annotation>
</xsd:attribute>
<xsd:attribute name="maxThreadsIdle" type="substitutableInt">
<xsd:annotation>
<xsd:documentation>
The maximum number of idle or inactive threads that can be in the pool before they are destroyed.
</xsd:documentation>
</xsd:annotation>
</xsd:attribute>
<xsd:attribute default="true" name="doThreading" type="substitutableBoolean">
<xsd:annotation>
<xsd:documentation>
Whether threading should be used (default is true).
</xsd:documentation>
</xsd:annotation>
</xsd:attribute>
<xsd:attributeGroup ref="commonThreadPoolAttributes"/>
</xsd:extension>
</xsd:complexContent>
</xsd:complexType>
<!--==============================================================-->
<!-- Exception strategies -->
<!--==============================================================-->
<xsd:annotation>
<xsd:documentation>
Provides default exception handling.
</xsd:documentation>
</xsd:annotation>
</xsd:element>
<xsd:annotation>
<xsd:documentation>
Exception strategy used to handle exceptions. It will commit any transaction as if the message was consumed successfully.
</xsd:documentation>
</xsd:annotation>
</xsd:element>
<xsd:annotation>
<xsd:documentation>
Exception strategy used to route to different exception strategies. It will execute the exception strategy which expression attribute matches against MuleMessage. In case there's no match, then default exception strategy will be exeucted.
</xsd:documentation>
</xsd:annotation>
</xsd:element>
<xsd:annotation>
<xsd:documentation>
Exception strategy used to rollback inbound message. It will rollback any transaction or not consume
inbound message unless a org.mule.api.exception.MessageRedeliveredException is thrown.
</xsd:documentation>
</xsd:annotation>
</xsd:element>
<xsd:element name="exception-strategy" substitutionGroup="abstract-exception-strategy" type="referenceExceptionStrategyType">
<xsd:annotation>
<xsd:documentation>
Exception strategy used to reference global exceptions within a flow or service.
</xsd:documentation>
</xsd:annotation>
</xsd:element>
<xsd:complexType name="catchExceptionStrategyType">
<xsd:complexContent>
<xsd:sequence>
<xsd:group maxOccurs="unbounded" minOccurs="0" ref="messageProcessorOrOutboundEndpoint">
<xsd:annotation>
<xsd:documentation>
Destination to which a MuleMessage with an ExceptionPayload will be sent; this could be any message processor or outbound endpoint.
</xsd:documentation>
</xsd:annotation>
</xsd:group>
</xsd:sequence>
</xsd:extension>
</xsd:complexContent>
</xsd:complexType>
<xsd:complexType name="choiceExceptionStrategyType">
<xsd:complexContent>
<xsd:extension base="exceptionStrategyType">
<xsd:sequence>
<xsd:element maxOccurs="unbounded" minOccurs="1" ref="abstract-exception-strategy"/>
</xsd:sequence>
<xsd:attribute name="name" type="substitutableName" use="optional">
<xsd:annotation>
<xsd:documentation>
Name of the exception strategy that will be used in ref attribute of 'exception-strategy' element
</xsd:documentation>
</xsd:annotation>
</xsd:attribute>
</xsd:extension>
</xsd:complexContent>
</xsd:complexType>
<xsd:complexType name="rollbackExceptionStrategyType">
<xsd:complexContent>
<xsd:sequence>
<xsd:group maxOccurs="unbounded" minOccurs="0" ref="messageProcessorOrOutboundEndpoint">
<xsd:annotation>
<xsd:documentation>
Destination to which the message will be sent; this could be an outbound endpoint, a router, or message processor.
</xsd:documentation>
</xsd:annotation>
</xsd:group>
<xsd:element minOccurs="0" name="on-redelivery-attempts-exceeded">
<xsd:complexType>
<xsd:complexContent>
<xsd:extension base="annotatedType">
<xsd:sequence>
<xsd:group maxOccurs="unbounded" minOccurs="0" ref="messageProcessorOrOutboundEndpoint">
<xsd:annotation>
<xsd:documentation>
Destination to which the message will be sent in case that max redelivery attempts configured is exceeded, this
could be any sequence of outbound endpoint, router, or message processor.
</xsd:documentation>
</xsd:annotation>
</xsd:group>
</xsd:sequence>
</xsd:extension>
</xsd:complexContent>
</xsd:complexType>
</xsd:element>
</xsd:sequence>
<xsd:attribute name="maxRedeliveryAttempts" type="substitutableInt">
<xsd:annotation>
<xsd:documentation>
Times a message will be redelivery until it's consider a poison message. Once maxRedeliveryAttempts is exceeded on-redelivery-attempts-exceeded child message processors will be executed.
</xsd:documentation>
</xsd:annotation>
</xsd:attribute>
</xsd:extension>
</xsd:complexContent>
</xsd:complexType>
<xsd:complexType name="serviceExceptionStrategyType">
<xsd:complexContent>
<xsd:extension base="abstractExceptionStrategyType">
<xsd:attribute default="false" name="stopMessageProcessing" type="substitutableBoolean" use="optional">
<xsd:annotation>
<xsd:documentation>
Stop the flow/service when an exception occurs. You will need to restart the flow/service manually after this (e.g, using JMX).
</xsd:documentation>
</xsd:annotation>
</xsd:attribute>
</xsd:extension>
</xsd:complexContent>
</xsd:complexType>
<xsd:annotation>
<xsd:documentation>
A user-defined exception strategy.
</xsd:documentation>
</xsd:annotation>
</xsd:element>
<xsd:complexType name="customExceptionStrategyType">
<xsd:complexContent>
<xsd:extension base="abstractExceptionStrategyType">
<xsd:sequence>
<xsd:element maxOccurs="unbounded" minOccurs="0" ref="spring:property">
<xsd:annotation>
<xsd:documentation>
Spring-style property element for custom configuration.
</xsd:documentation>
</xsd:annotation>
</xsd:element>
</xsd:sequence>
<xsd:attribute name="class" type="substitutableClass" use="required">
<xsd:annotation>
<xsd:documentation>
A class that implements the ExceptionListener interface. In addition, if an 'outbound-endpoint' element is specified, it is set as an "endpoint" bean property.
</xsd:documentation>
</xsd:annotation>
</xsd:attribute>
</xsd:extension>
</xsd:complexContent>
</xsd:complexType>
<!-- This is left in for backwards-compatibility only, remove for next major version. -->
<xsd:annotation>
<xsd:documentation>
Deprecated: Use default-exception-strategy instead.
</xsd:documentation>
</xsd:annotation>
</xsd:element>
<!-- Custom connector element -->
<xsd:element name="custom-connector" substitutionGroup="abstract-connector" type="customConnectorType">
<xsd:annotation>
<xsd:documentation>
A user-defined connector.
</xsd:documentation>
</xsd:annotation>
</xsd:element>
<xsd:complexType name="customConnectorType">
<xsd:complexContent>
<xsd:extension base="connectorType">
<!-- This is already on the standard connector (but probably shouldn't be...)
<xsd:sequence>
<xsd:element ref="spring:property" minOccurs="0" maxOccurs="unbounded">
<xsd:annotation>
<xsd:documentation>
Spring-style property element for custom configuration.
</xsd:documentation>
</xsd:annotation>
</xsd:element>
</xsd:sequence>
-->
<xsd:attribute name="class" type="substitutableClass" use="required">
<xsd:annotation>
<xsd:documentation>
A class that implements the Connector interface.
</xsd:documentation>
</xsd:annotation>
</xsd:attribute>
</xsd:extension>
</xsd:complexContent>
</xsd:complexType>
<!--==============================================================-->
<!-- Object stores -->
<!--==============================================================-->
<xsd:element abstract="true" name="abstract-object-store" type="abstractObjectStoreType">
<xsd:annotation>
<xsd:documentation>
A placeholder for an object store that can be used by routers to maintain state.
</xsd:documentation>
</xsd:annotation>
</xsd:element>
<xsd:complexType name="abstractObjectStoreType"/>
<xsd:element name="in-memory-store" substitutionGroup="abstract-object-store" type="abstractMonitoredObjectStoreType">
<xsd:annotation>
<xsd:documentation>
An optionally bounded in-memory store for message IDs with periodic expiry of old entries. The bounded size is a soft limit and is only enforced periodically by the expiry process. This means that the store may temporarily exceed its maximum size between expiry runs but will eventually shrink to its configured size.
</xsd:documentation>
</xsd:annotation>
</xsd:element>
<xsd:element name="simple-text-file-store" substitutionGroup="abstract-object-store" type="textFileObjectStoreType">
<xsd:annotation>
<xsd:documentation>
A simple object store that stores String objects by key to a text file. This store is only suitable for storing simple key value pair strings. This store is backed by an in-memory store and supports the ability to expire and apply TTL to objects in the store.
</xsd:documentation>
</xsd:annotation>
</xsd:element>
<xsd:complexType name="textFileObjectStoreType">
<xsd:complexContent>
<xsd:extension base="abstractMonitoredObjectStoreType">
<xsd:attribute name="directory" type="xsd:string">
<xsd:annotation>
<xsd:documentation>
The file location (directory) where the object store will be saved. If this value is not set, Mule defaults to using 'mule.working.dir/objectstore'.
</xsd:documentation>
</xsd:annotation>
</xsd:attribute>
</xsd:extension>
</xsd:complexContent>
</xsd:complexType>
<xsd:element name="managed-store" substitutionGroup="abstract-object-store" type="managedObjectStoreType">
<xsd:annotation>
<xsd:documentation>
Managed Object Store
</xsd:documentation>
</xsd:annotation>
</xsd:element>
<xsd:complexType name="managedObjectStoreType">
<xsd:complexContent>
<xsd:extension base="abstractObjectStoreType">
<xsd:attribute name="storeName" type="xsd:string" use="required">
<xsd:annotation>
<xsd:documentation>
The ID used to retrieve the ObjectStore from the ObjectStoreManager
</xsd:documentation>
</xsd:annotation>
</xsd:attribute>
<xsd:attribute name="persistent" type="xsd:boolean">
<xsd:annotation>
<xsd:documentation>
Defines if this store should be persistent or not
</xsd:documentation>
</xsd:annotation>
</xsd:attribute>
<xsd:attribute name="maxEntries" type="substitutableInt">
<xsd:annotation>
<xsd:documentation>
The maximum number of entries that this store keeps around. Specify
'-1' if the store is supposed to be "unbounded".
</xsd:documentation>
</xsd:annotation>
</xsd:attribute>
<xsd:attribute name="entryTTL" type="substitutableInt">
<xsd:annotation>
<xsd:documentation>
The time-to-live for each message ID, specified in milliseconds, or '-1'
for entries that should never expire. DO NOT combine this with an
unbounded store!
</xsd:documentation>
</xsd:annotation>
</xsd:attribute>
<xsd:attribute name="expirationInterval" type="substitutableInt">
<xsd:annotation>
<xsd:documentation>
The interval for periodic bounded size enforcement and entry
expiration, specified in milliseconds. Arbitrary positive values
between one second and several hours or days are possible, but
should be chosen carefully according to the expected message rate
to prevent OutOfMemory conditions.
</xsd:documentation>
</xsd:annotation>
</xsd:attribute>
</xsd:extension>
</xsd:complexContent>
</xsd:complexType>
<xsd:complexType name="abstractMonitoredObjectStoreType">
<xsd:complexContent>
<xsd:extension base="abstractObjectStoreType">
<xsd:attribute name="name" type="xsd:string">
<xsd:annotation>
<xsd:documentation>
An ID for this store that can be used for logging and identification purposes.
</xsd:documentation>
</xsd:annotation>
</xsd:attribute>
<xsd:attribute name="maxEntries" type="substitutableInt">
<xsd:annotation>
<xsd:documentation>
The maximum number of entries that this store keeps around. Specify '-1' if the store is supposed to be "unbounded".
</xsd:documentation>
</xsd:annotation>
</xsd:attribute>
<xsd:attribute name="entryTTL" type="substitutableInt">
<xsd:annotation>
<xsd:documentation>
The time-to-live for each message ID, specified in seconds, or '-1' for entries that should never expire. DO NOT combine this with an unbounded store!
</xsd:documentation>
</xsd:annotation>
</xsd:attribute>
<xsd:attribute name="expirationInterval" type="substitutableInt">
<xsd:annotation>
<xsd:documentation>
The interval for periodic bounded size enforcement and entry expiration, specified in seconds. Arbitrary positive values between one second and several hours or days are possible, but should be chosen carefully according to the expected message rate to prevent OutOfMemory conditions.
</xsd:documentation>
</xsd:annotation>
</xsd:attribute>
</xsd:extension>
</xsd:complexContent>
</xsd:complexType>
<xsd:element name="custom-object-store" substitutionGroup="abstract-object-store" type="customObjectStoreType">
<xsd:annotation>
<xsd:documentation>
A custom implementation of the ObjectStore interface.
</xsd:documentation>
</xsd:annotation>
</xsd:element>
<xsd:complexType name="customObjectStoreType">
<xsd:complexContent>
<xsd:extension base="abstractObjectStoreType">
<xsd:sequence>
<xsd:element maxOccurs="unbounded" minOccurs="0" ref="spring:property">
<xsd:annotation>
<xsd:documentation>
Spring-style property element for custom configuration of the ObjectStore.
</xsd:documentation>
</xsd:annotation>
</xsd:element>
</xsd:sequence>
<xsd:attribute name="class" type="substitutableClass" use="required">
<xsd:annotation>
<xsd:documentation>
An implementation of the ObjectStore interface.
</xsd:documentation>
</xsd:annotation>
</xsd:attribute>
</xsd:extension>
</xsd:complexContent>
</xsd:complexType>
<xsd:element name="spring-object-store" substitutionGroup="abstract-object-store" type="springObjectStoreType">
<xsd:annotation>
<xsd:documentation>
A Spring bean that implements the ObjectStore interface.
</xsd:documentation>
</xsd:annotation>
</xsd:element>
<xsd:complexType name="springObjectStoreType">
<xsd:complexContent>
<xsd:extension base="abstractObjectStoreType">
<xsd:attribute name="ref" type="xsd:string" use="required">
<xsd:annotation>
<xsd:documentation>
The name of the ObjectStore bean to use.
</xsd:documentation>
</xsd:annotation>
</xsd:attribute>
</xsd:extension>
</xsd:complexContent>
</xsd:complexType>
<!--==============================================================-->
<!-- Routing -->
<!--==============================================================-->
<!--==================================-->
<!-- Simple (1-1) Message Processors -->
<!--==================================-->
<xsd:annotation>
<xsd:documentation>
A placeholder for intercepting router elements.
</xsd:documentation>
</xsd:annotation>
</xsd:element>
<xsd:complexContent>
<xsd:extension base="abstractMessageProcessorType"/>
</xsd:complexContent>
</xsd:complexType>
<xsd:annotation>
<xsd:documentation>
A placeholder for intercepting router elements.
</xsd:documentation>
</xsd:annotation>
</xsd:element>
<xsd:complexContent>
<xsd:attribute name="name" type="substitutableName">
<xsd:annotation>
<xsd:documentation>
Identifies the processor so that other elements can reference it. Required if the processor is defined at the global level.
</xsd:documentation>
</xsd:annotation>
</xsd:attribute>
</xsd:extension>
</xsd:complexContent>
</xsd:complexType>
<xsd:annotation>
<xsd:documentation>
A message processor that uses a filter to determine whether to process an event.
</xsd:documentation>
</xsd:annotation>
</xsd:element>
<xsd:complexType name="messageFilterType">
<xsd:complexContent>
<xsd:sequence>
<xsd:element ref="abstract-filter">
<xsd:annotation>
<xsd:documentation>
Used to filter events.
</xsd:documentation>
</xsd:annotation>
</xsd:element>
</xsd:sequence>
<xsd:attribute name="onUnaccepted" type="xsd:string">
<xsd:annotation>
<xsd:documentation>
Events that are not accepted by the filter are sent to this (optional) named message processor.
</xsd:documentation>
</xsd:annotation>
</xsd:attribute>
<xsd:attribute name="throwOnUnaccepted" type="xsd:boolean">
<xsd:annotation>
<xsd:documentation>
Whether to throw an exception if a message is not accepted
</xsd:documentation>
</xsd:annotation>
</xsd:attribute>
</xsd:extension>
</xsd:complexContent>
</xsd:complexType>
<xsd:annotation>
<xsd:documentation>
Ensures that only unique messages are received by a service by checking the unique ID of the incoming message. Note that the ID used can be generated from the message using an expression defined in the 'idExpression' attribute. By default, the expression used is '#[message:id]', which means the underlying endpoint must support unique message IDs for this to work. Otherwise, a UniqueIdNotSupportedException is thrown.
</xsd:documentation>
</xsd:annotation>
</xsd:element>
<xsd:complexType name="idempotentMessageFilterType">
<xsd:complexContent>
<xsd:sequence>
<xsd:element maxOccurs="1" minOccurs="0" ref="abstract-object-store"/>
</xsd:sequence>
<xsd:attribute name="idExpression" type="xsd:string">
<xsd:annotation>
<xsd:documentation>
Defines one or more expressions to use when extracting the ID from the message. For example, it would be possible to combine to headers as the ID of the message to provide idempotency: '#[headers:foo,bar]'. Or, you could combine the message ID with a header: '#[message:id]-#[header:foo]'. If this property is not set, '#[message:id]' will be used by default.
</xsd:documentation>
</xsd:annotation>
</xsd:attribute>
<xsd:attribute name="valueExpression" type="xsd:string">
<xsd:annotation>
<xsd:documentation>
Defines one or more expressions to use when extracting the value from the message.
</xsd:documentation>
</xsd:annotation>
</xsd:attribute>
<xsd:attribute name="throwOnUnaccepted" type="substitutableBoolean"/>
<xsd:attribute name="storePrefix" type="substitutableName">
<xsd:annotation>
<xsd:documentation>
Defines the prefix of the object store names.
</xsd:documentation>
</xsd:annotation>
</xsd:attribute>
</xsd:extension>
</xsd:complexContent>
</xsd:complexType>
<xsd:element abstract="true" name="abstract-redelivery-policy" type="abstractRedeliveryPolicyType">
<xsd:annotation>
<xsd:documentation>
A placeholder for a redelivery policy. Redelivery policies determine what action to take when the same message
is redelivered repeatedly.
</xsd:documentation>
</xsd:annotation>
</xsd:element>
<xsd:complexType name="abstractRedeliveryPolicyType">
<xsd:complexContent>
<xsd:extension base="annotatedType">
<xsd:sequence>
<xsd:element minOccurs="0" name="dead-letter-queue" type="singleTarget">
<xsd:annotation>
<xsd:documentation>
Message processor to call if a message exceeds its redelivery count without being processed successfully
</xsd:documentation>
</xsd:annotation>
</xsd:element>
</xsd:sequence>
<xsd:attribute default="5" name="maxRedeliveryCount" type="substitutableInt">
<xsd:annotation>
<xsd:documentation>
The maximum number of times a message can be redelivered and processed unsuccessfully before triggering
process-failed-message
</xsd:documentation>
</xsd:annotation>
</xsd:attribute>
</xsd:extension>
</xsd:complexContent>
</xsd:complexType>
<xsd:annotation>
<xsd:documentation>
Defines a policy for processing the redelivery of the same message
</xsd:documentation>
</xsd:annotation>
</xsd:element>
<xsd:complexType name="singleTarget">
<xsd:complexContent>
<xsd:sequence>
<xsd:group maxOccurs="1" minOccurs="1" ref="messageProcessorOrOutboundEndpoint"/>
</xsd:sequence>
</xsd:extension>
</xsd:complexContent>
</xsd:complexType>
<xsd:complexType name="idempotentRedeliveryPolicyType">
<xsd:complexContent>
<xsd:extension base="abstractRedeliveryPolicyType">
<xsd:attribute default="true" name="useSecureHash" type="xsd:boolean">
<xsd:annotation>
<xsd:documentation>
Whether to use a secure hash algorithm to identify a redelivered message
</xsd:documentation>
</xsd:annotation>
</xsd:attribute>
<xsd:attribute name="messageDigestAlgorithm" type="xsd:string">
<xsd:annotation>
<xsd:documentation>
The secure hashing algorithm to use. If not set, the default is SHA-256.
</xsd:documentation>
</xsd:annotation>
</xsd:attribute>
<xsd:attribute name="idExpression" type="xsd:string">
<xsd:annotation>
<xsd:documentation>
Defines one or more expressions to use to determine when a message has been redelivered. For example,it would be possible to combine to headers as the unique ID of the message : '#[headers:foo,bar]'. Or, you could combine the message ID with a header: '#[message:id]-#[header:foo]'. This property may only be set if useSecureHash is false..
</xsd:documentation>
</xsd:annotation>
</xsd:attribute>
</xsd:extension>
</xsd:complexContent>
</xsd:complexType>
<xsd:annotation>
<xsd:documentation>
Ensures that only unique messages are received by a service by calculating the hash of the message itself using a message digest algorithm. This provides a value with an infinitesimally small chance of a collision. This can be used to filter message duplicates. Keep in mind that the hash is calculated over the entire byte array representing the message, so any leading or trailing spaces or extraneous bytes (like padding) can produce different hash values for the same semantic message content. Care should be taken to ensure that messages do not contain extraneous bytes. This class is useful when the message does not support unique identifiers.
</xsd:documentation>
</xsd:annotation>
<xsd:complexType>
<xsd:complexContent>
<xsd:extension base="idempotentMessageFilterType">
<xsd:attribute name="messageDigestAlgorithm" type="xsd:string">
<xsd:annotation>
<xsd:documentation>
The secure hashing algorithm to use. If not set, the default is SHA-256.
</xsd:documentation>
</xsd:annotation>
</xsd:attribute>
</xsd:extension>
</xsd:complexContent>
</xsd:complexType>
</xsd:element>
<xsd:element name="wire-tap" substitutionGroup="abstract-intercepting-message-processor">
<xsd:annotation>
<xsd:documentation>
The WireTap inbound router allows you to route certain messages to a different endpoint as well as to the component.
</xsd:documentation>
</xsd:annotation>
<xsd:complexType>
<xsd:complexContent>
<xsd:sequence>
<xsd:group maxOccurs="1" ref="messageProcessorOrOutboundEndpoint"/>
<xsd:element minOccurs="0" ref="abstract-filter"/>
</xsd:sequence>
</xsd:extension>
</xsd:complexContent>
</xsd:complexType>
</xsd:element>
<xsd:annotation>
<xsd:documentation>
Takes a payload which is a Collection of Collections and turns into a single List. For example, if the payload is a Collection
which contains a Collection with elements A and B and another Collection with elements C and D, this will turn them into
a single Collection with elements A, B, C and D.

This transformer will also work on MuleMessageCollections. In this case, it will take the individual Collection
payloads of each MuleMessage and merge them into a single Collection on a new MuleMessage.
</xsd:documentation>
</xsd:annotation>
<xsd:complexType>
<xsd:complexContent>
</xsd:complexContent>
</xsd:complexType>
</xsd:element>
<xsd:complexType name="baseAggregatorType">
<xsd:complexContent>
<xsd:sequence>
<xsd:element minOccurs="0" ref="abstract-message-info-mapping"/>
</xsd:sequence>
<xsd:attribute name="timeout" type="substitutableInt">
<xsd:annotation>
<xsd:documentation>
Defines a timeout in Milliseconds to wait for events to be aggregated. By default the router will throw an exeception if the router is waiting for a correlation group and times out before all group enties are received.
</xsd:documentation>
</xsd:annotation>
</xsd:attribute>
<xsd:attribute name="failOnTimeout" type="substitutableBoolean">
<xsd:annotation>
<xsd:documentation>
When false, incomplete aggregation groups will be forwarded to a component on timeout as a java.util.List. When true (default), a CorrelationTimeoutException is thrown and RoutingNotification.CORRELATION_TIMEOUT is fired. The component doesn't receive any messages in this case.
</xsd:documentation>
</xsd:annotation>
</xsd:attribute>
<xsd:attribute default="false" name="persistentStores" type="substitutableBoolean">
<xsd:annotation>
<xsd:documentation>
Defines if the object stores used are persistent or not.
</xsd:documentation>
</xsd:annotation>
</xsd:attribute>
<xsd:attribute name="storePrefix" type="substitutableName">
<xsd:annotation>
<xsd:documentation>
Defines the prefix of the object store names.
</xsd:documentation>
</xsd:annotation>
</xsd:attribute>
</xsd:extension>
</xsd:complexContent>
</xsd:complexType>
<xsd:element name="resequencer" substitutionGroup="abstract-intercepting-message-processor" type="baseAggregatorType">
<xsd:annotation>
<xsd:documentation>
Holds back a group of messages and resequences them using each message's correlation sequence property.
</xsd:documentation>
</xsd:annotation>
</xsd:element>
<xsd:annotation>
<xsd:documentation>
Configures a Collection Response Router. This will return a MuleMessageCollection message type that will contain all messages received for a each correlation group.
</xsd:documentation>
</xsd:annotation>
</xsd:element>
<xsd:annotation>
<xsd:documentation>
Combines two or more messages into a single message by matching messages with a given Correlation ID. Correlation IDs are set on messages when they are dispatched by certain outbound routers, such as the Recipient List and Message Splitter routers. These messages can be aggregated back together again using this router.
</xsd:documentation>
</xsd:annotation>
</xsd:element>
<xsd:element name="custom-aggregator" substitutionGroup="abstract-intercepting-message-processor">
<xsd:annotation>
<xsd:documentation>
Configures a custom message aggregator. Mule provides an abstract implementation that has a template method that performs the message aggregation. A common use of the aggregator router is to combine the results of multiple requests such as "ask this set of vendors for the best price of X".
</xsd:documentation>
</xsd:annotation>
<xsd:complexType>
<xsd:complexContent>
<xsd:extension base="baseAggregatorType">
<xsd:sequence>
<xsd:element maxOccurs="unbounded" minOccurs="0" ref="spring:property">
<xsd:annotation>
<xsd:documentation>
Spring-style property element for custom configuration.
</xsd:documentation>
</xsd:annotation>
</xsd:element>
</xsd:sequence>
<xsd:attribute name="class" type="substitutableClass" use="required">
<xsd:annotation>
<xsd:documentation>
Fully qualified class name of the custom correlation aggregator router to be used.
</xsd:documentation>
</xsd:annotation>
</xsd:attribute>
</xsd:extension>
</xsd:complexContent>
</xsd:complexType>
</xsd:element>
<xsd:complexType name="baseSplitterType">
<xsd:complexContent>
<xsd:sequence>
<xsd:element minOccurs="0" ref="abstract-message-info-mapping"/>
</xsd:sequence>
<xsd:attributeGroup ref="defaultCorrelationAttributes"/>
</xsd:extension>
</xsd:complexContent>
</xsd:complexType>
<xsd:element name="splitter" substitutionGroup="abstract-intercepting-message-processor">
<xsd:annotation>
<xsd:documentation>
The simple splitter splits incoming message into parts using the configured expression passing on each part in turn to the next message processor
</xsd:documentation>
</xsd:annotation>
<xsd:complexType>
<xsd:complexContent>
<xsd:extension base="baseSplitterType">
<xsd:attributeGroup ref="expressionAttributes"/>
</xsd:extension>
</xsd:complexContent>
</xsd:complexType>
</xsd:element>
<xsd:element name="collection-splitter" substitutionGroup="abstract-intercepting-message-processor">
<xsd:annotation>
<xsd:documentation>
The collection splitter accepts a collection of objects and splits the collection invoking the next message processor with each item in the collection in sequence.
</xsd:documentation>
</xsd:annotation>
<xsd:complexType>
<xsd:complexContent>
<xsd:extension base="baseSplitterType"/>
</xsd:complexContent>
</xsd:complexType>
</xsd:element>
<xsd:element name="map-splitter" substitutionGroup="abstract-intercepting-message-processor">
<xsd:annotation>
<xsd:documentation>
The map splitter accepts a map of objects and splits the collection invoking the next message processor with each item in the collection in sequence.
</xsd:documentation>
</xsd:annotation>
<xsd:complexType>
<xsd:complexContent>
<xsd:extension base="baseSplitterType"/>
</xsd:complexContent>
</xsd:complexType>
</xsd:element>
<xsd:element name="message-chunk-splitter" substitutionGroup="abstract-intercepting-message-processor">
<xsd:annotation>
<xsd:documentation>
The collection splitter accepts a collection of objects and splits the collection invoking the next message processor with each item in the collection in sequence.
</xsd:documentation>
</xsd:annotation>
<xsd:complexType>
<xsd:complexContent>
<xsd:extension base="baseSplitterType">
<xsd:attribute name="messageSize" type="substitutableInt" use="required">
<xsd:annotation>
<xsd:documentation>
The message chunk size (in bytes) that the current message will be split into. Note that this is mutually exclusive to the 'numberOfMessages' property.
</xsd:documentation>
</xsd:annotation>
</xsd:attribute>
</xsd:extension>
</xsd:complexContent>
</xsd:complexType>
</xsd:element>
<xsd:element name="custom-splitter" substitutionGroup="abstract-intercepting-message-processor">
<xsd:annotation>
<xsd:documentation>
Configures a custom message splitter. Mule provides an abstract implementation that has a template method that performs the message aggregation.
</xsd:documentation>
</xsd:annotation>
<xsd:complexType>
<xsd:complexContent>
<xsd:extension base="baseSplitterType">
<xsd:sequence>
<xsd:element maxOccurs="unbounded" minOccurs="0" ref="spring:property">
<xsd:annotation>
<xsd:documentation>
Spring-style property element for custom configuration.
</xsd:documentation>
</xsd:annotation>
</xsd:element>
</xsd:sequence>
<xsd:attribute name="class" type="substitutableClass" use="required">
<xsd:annotation>
<xsd:documentation>
Fully qualified class name of the custom correlation aggregator router to be used.
</xsd:documentation>
</xsd:annotation>
</xsd:attribute>
</xsd:extension>
</xsd:complexContent>
</xsd:complexType>
</xsd:element>
<!-- Conditional Message Processor Elements -->
<xsd:complexType abstract="true" name="abstractMessageProcessorFilterPairType"/>
<xsd:complexType name="whenMessageProcessorFilterPairType">
<xsd:complexContent>
<xsd:sequence>
<!-- if the first message processor is a filter, it determines
whether this when clause is chosen or not. This is only allowed when
no expression is specified
-->
<xsd:group maxOccurs="unbounded" minOccurs="1" ref="messageProcessorOrOutboundEndpoint"/>
</xsd:sequence>
<xsd:attribute name="evaluator" type="whenExpressionEvaluators" use="optional">
<xsd:annotation>
<xsd:documentation>
The expression evaluator to use. Expression evaluators must be registered with the ExpressionEvaluatorManager before they can be used. Using the custom evaluator allows you to define your own evaluator with the 'custom-evaluator' attribute. Note that some evaluators such as xpath, groovy, and bean are loaded from other Mule modules (XML and Scripting, respectively). These modules must be on your classpath before the evaluator can be used.
</xsd:documentation>
</xsd:annotation>
</xsd:attribute>
<xsd:attribute name="expression" type="xsd:string" use="optional">
<xsd:annotation>
<xsd:documentation>
The expression to evaluate. The syntax of this attribute changes depending on the evaluator being used.
</xsd:documentation>
</xsd:annotation>
</xsd:attribute>
<xsd:attribute name="custom-evaluator" type="substitutableName" use="optional">
<xsd:annotation>
<xsd:documentation>
The name of the custom evaluator to use. This attribute is only used when the 'evaluator' attribute is set to "custom". You can plug in your own expression evaluators by registering them with the ExpressionEvaluatorManager.
</xsd:documentation>
</xsd:annotation>
</xsd:attribute>
</xsd:extension>
</xsd:complexContent>
</xsd:complexType>
<xsd:complexContent>
<xsd:group maxOccurs="unbounded" minOccurs="1" ref="messageProcessorOrOutboundEndpoint"/>
</xsd:extension>
</xsd:complexContent>
</xsd:complexType>
<xsd:element name="foreach" substitutionGroup="abstract-intercepting-message-processor" type="foreachProcessorType"/>
<xsd:complexType name="foreachProcessorType">
<xsd:complexContent>
<xsd:sequence>
<xsd:group maxOccurs="unbounded" minOccurs="1" ref="messageProcessorOrOutboundEndpoint"/>
</xsd:sequence>
<xsd:attribute name="collection" type="xsd:string" use="optional">
<xsd:annotation>
<xsd:documentation>
An expression to that returns a java collection, object array, map or DOM nodes.
</xsd:documentation>
</xsd:annotation>
</xsd:attribute>
<xsd:attribute name="batchSize" type="xsd:integer" use="optional">
<xsd:annotation>
<xsd:documentation>
Partitions the collection in subcollections of the specified size.
</xsd:documentation>
</xsd:annotation>
</xsd:attribute>
<xsd:attribute default="rootMessage" name="rootMessageVariableName" type="xsd:string" use="optional">
<xsd:annotation>
<xsd:documentation>
Property name where the parent message is stored.
</xsd:documentation>
</xsd:annotation>
</xsd:attribute>
<xsd:attribute default="counter" name="counterVariableName" type="xsd:string" use="optional">
<xsd:annotation>
<xsd:documentation>
Property name used to store the number of message being iterated.
</xsd:documentation>
</xsd:annotation>
</xsd:attribute>
</xsd:extension>
</xsd:complexContent>
</xsd:complexType>
<!--==================================-->
<!-- Routing (1-n) Message Processors -->
<!--==================================-->
<xsd:element abstract="true" name="abstract-routing-message-processor" substitutionGroup="abstract-message-processor" type="abstractRoutingMessageProcessorType">
<xsd:annotation>
<xsd:documentation>
A placeholder for intercepting router elements.
</xsd:documentation>
</xsd:annotation>
</xsd:element>
<xsd:complexType name="abstractRoutingMessageProcessorType">
<xsd:complexContent>
<xsd:extension base="abstractMessageProcessorType"/>
</xsd:complexContent>
</xsd:complexType>
<xsd:complexContent>
<xsd:sequence>
<xsd:group maxOccurs="unbounded" minOccurs="1" ref="messageProcessorOrOutboundEndpoint"/>
</xsd:sequence>
</xsd:extension>
</xsd:complexContent>
</xsd:complexType>
<xsd:complexContent>
<xsd:sequence>
<xsd:element minOccurs="0" ref="abstract-message-info-mapping"/>
</xsd:sequence>
<xsd:attributeGroup ref="defaultCorrelationAttributes"/>
</xsd:extension>
</xsd:complexContent>
</xsd:complexType>
<xsd:element name="custom-router" substitutionGroup="abstract-routing-message-processor">
<xsd:complexType>
<xsd:complexContent>
<xsd:sequence>
<xsd:element maxOccurs="unbounded" minOccurs="0" ref="spring:property"/>
</xsd:sequence>
<xsd:attribute name="class" type="substitutableClass" use="required"/>
</xsd:extension>
</xsd:complexContent>
</xsd:complexType>
</xsd:element>
<xsd:complexType name="selectiveOutboundRouterType">
<xsd:complexContent>
<xsd:sequence>
<xsd:element maxOccurs="unbounded" minOccurs="1" name="when" type="whenMessageProcessorFilterPairType"/>
<xsd:element maxOccurs="1" minOccurs="0" name="otherwise" type="otherwiseMessageProcessorFilterPairType"/>
</xsd:sequence>
</xsd:extension>
</xsd:complexContent>
</xsd:complexType>
<xsd:element name="choice" substitutionGroup="abstract-routing-message-processor" type="selectiveOutboundRouterType">
<xsd:annotation>
<xsd:documentation>
Sends the message to the first endpoint whose condition has been satisfied. If no conditions were satisfied, sends to the configured default endpoint if configured, or throws an exception if not configured.
</xsd:documentation>
</xsd:annotation>
</xsd:element>
<xsd:annotation>
<xsd:documentation>
Sends the same message to multiple message processors or outbound endpoints.
</xsd:documentation>
</xsd:annotation>
</xsd:element>
<xsd:complexType name="processorWithAtLeastOneTargetType">
<xsd:complexContent>
<xsd:sequence>
<xsd:group maxOccurs="unbounded" minOccurs="1" ref="messageProcessorOrOutboundEndpoint"/>
</xsd:sequence>
</xsd:extension>
</xsd:complexContent>
</xsd:complexType>
<xsd:complexType name="processorWithExactlyOneTargetType">
<xsd:complexContent>
<xsd:sequence>
<xsd:group maxOccurs="1" minOccurs="1" ref="messageProcessorOrOutboundEndpoint"/>
</xsd:sequence>
</xsd:extension>
</xsd:complexContent>
</xsd:complexType>
<xsd:element name="first-successful" substitutionGroup="abstract-routing-message-processor">
<xsd:annotation>
<xsd:documentation>
Sends a message to a list of message processors until one processes it
successfully
</xsd:documentation>
</xsd:annotation>
<xsd:complexType>
<xsd:complexContent>
<xsd:extension base="processorWithAtLeastOneTargetType">
<xsd:attribute name="failureExpression" type="xsd:string">
<xsd:annotation>
<xsd:documentation>
Specifies an expression that when evaluated as determines if the processing of one a route was a failure or not.
</xsd:documentation>
</xsd:annotation>
</xsd:attribute>
</xsd:extension>
</xsd:complexContent>
</xsd:complexType>
</xsd:element>
<xsd:element name="until-successful" substitutionGroup="abstract-routing-message-processor">
<xsd:annotation>
<xsd:documentation>
Attempts to route a message to the message processor it contains in an asynchronous manner.
Routing is considered successful if no exception has been raised and, optionally, if the response matches an expression
</xsd:documentation>
</xsd:annotation>
<xsd:complexType>
<xsd:complexContent>
<xsd:extension base="processorWithExactlyOneTargetType">
<xsd:attribute name="objectStore-ref" type="xsd:string" use="required">
<xsd:annotation>
<xsd:documentation>
Reference to the org.mule.api.store.ListableObjectStore that will be used to store events pending (re)processing.
</xsd:documentation>
</xsd:annotation>
</xsd:attribute>
<xsd:attribute default="5" name="maxRetries" type="substitutableInt" use="optional">
<xsd:annotation>
<xsd:documentation>
Specifies the maximum number of processing retries that will be performed.
</xsd:documentation>
</xsd:annotation>
</xsd:attribute>
<xsd:attribute default="60" name="secondsBetweenRetries" type="substitutableInt" use="optional">
<xsd:annotation>
<xsd:documentation>
Specifies the minimum time interval between two process retries.
The actual time interval depends on the previous execution but should not exceed twice this number.
</xsd:documentation>
</xsd:annotation>
</xsd:attribute>
<xsd:attribute name="failureExpression" type="xsd:string" use="optional">
<xsd:annotation>
<xsd:documentation>
Specifies an expression that when evaluated determines if the processing of one a route was a failure or not.
If no expression is specified, only exceptions will be considered as processing failures.
</xsd:documentation>
</xsd:annotation>
</xsd:attribute>
<xsd:attribute name="ackExpression" type="xsd:string" use="optional">
<xsd:annotation>
<xsd:documentation>
Specifies an expression that when evaluated determines the synchronous response of until-successful.
</xsd:documentation>
</xsd:annotation>
</xsd:attribute>
<xsd:attribute name="deadLetterQueue-ref" type="xsd:string" use="optional">
<xsd:annotation>
<xsd:documentation>
The endpoint or message processor to which undeliverable messages are sent after all retries have been attempted.
</xsd:documentation>
</xsd:annotation>
</xsd:attribute>
</xsd:extension>
</xsd:complexContent>
</xsd:complexType>
</xsd:element>
<xsd:annotation>
<xsd:documentation>
Send each message received to the next message processor in the circular list of targets
</xsd:documentation>
</xsd:annotation>
</xsd:element>
<xsd:element name="recipient-list" substitutionGroup="abstract-routing-message-processor">
<xsd:annotation>
<xsd:documentation>
Sends the same message to multiple endpoints, over the same endpoint, or implements routing-slip behavior where the next destination for the message is determined from message properties or the payload. The recipients can be extracted from the message using an expression, or you can specify a static list of recipient endpoints. (As of version 2.1)
</xsd:documentation>
</xsd:annotation>
<xsd:complexType>
<xsd:complexContent>
<xsd:sequence>
<xsd:element minOccurs="0" ref="abstract-message-info-mapping"/>
</xsd:sequence>
<xsd:attributeGroup ref="defaultCorrelationAttributes"/>
<xsd:attributeGroup ref="expressionAttributes"/>
<!-- See MULE-5069 <xsd:attributeGroup ref="allExchangePatterns" />-->
</xsd:extension>
</xsd:complexContent>
</xsd:complexType>
</xsd:element>
<!--=======================-->
<!-- 2.x Inbound Routers -->
<!--=======================-->
<xsd:complexType name="filteredInboundRouterType">
<xsd:complexContent>
<xsd:extension base="abstractInboundRouterType">
<xsd:sequence>
<xsd:element minOccurs="0" ref="abstract-filter"/>
</xsd:sequence>
</xsd:extension>
</xsd:complexContent>
</xsd:complexType>
<xsd:element name="idempotent-receiver-router" substitutionGroup="abstract-inbound-router" type="idempotentReceiverType">
<xsd:annotation>
<xsd:documentation>
Ensures that only unique messages are received by a service by checking the unique ID of the incoming message. Note that the ID used can be generated from the message using an expression defined in the 'idExpression' attribute. By default, the expression used is '#[message:id]', which means the underlying endpoint must support unique message IDs for this to work. Otherwise, a UniqueIdNotSupportedException is thrown.
</xsd:documentation>
</xsd:annotation>
</xsd:element>
<xsd:annotation>
<xsd:documentation>
Ensures that only unique messages are received by a service by calculating the hash of the message itself using a message digest algorithm. This provides a value with an infinitesimally small chance of a collision. This can be used to filter message duplicates. Keep in mind that the hash is calculated over the entire byte array representing the message, so any leading or trailing spaces or extraneous bytes (like padding) can produce different hash values for the same semantic message content. Care should be taken to ensure that messages do not contain extraneous bytes. This class is useful when the message does not support unique identifiers.
</xsd:documentation>
</xsd:annotation>
</xsd:element>
<xsd:complexType name="idempotentReceiverType">
<xsd:complexContent>
<xsd:extension base="abstractInboundRouterType">
<xsd:sequence>
<xsd:element maxOccurs="1" minOccurs="0" ref="abstract-object-store"/>
</xsd:sequence>
<xsd:attribute name="idExpression" type="xsd:string">
<xsd:annotation>
<xsd:documentation>
Defines one or more expressions to use when extracting the ID from the message. For example, it would be possible to combine to headers as the ID of the message to provide idempotency: '#[headers:foo,bar]'. Or, you could combine the message ID with a header: '#[message:id]-#[header:foo]'. If this property is not set, '#[message:id]' will be used by default.
</xsd:documentation>
</xsd:annotation>
</xsd:attribute>
</xsd:extension>
</xsd:complexContent>
</xsd:complexType>
<xsd:complexType name="idempotentSecureHashReceiverType">
<xsd:complexContent>
<xsd:extension base="abstractInboundRouterType">
<xsd:sequence>
<xsd:element maxOccurs="1" minOccurs="0" ref="abstract-object-store"/>
</xsd:sequence>
<xsd:attribute name="messageDigestAlgorithm" type="xsd:string">
<xsd:annotation>
<xsd:documentation>
The secure hashing algorithm to use. If not set, the default is SHA-256.
</xsd:documentation>
</xsd:annotation>
</xsd:attribute>
</xsd:extension>
</xsd:complexContent>
</xsd:complexType>
<xsd:element name="wire-tap-router" substitutionGroup="abstract-inbound-router" type="wireTapRouterType">
<xsd:annotation>
<xsd:documentation>
The WireTap inbound router allows you to route certain messages to a different endpoint as well as to the component.
</xsd:documentation>
</xsd:annotation>
</xsd:element>
<xsd:complexType name="wireTapRouterType">
<xsd:complexContent>
<xsd:extension base="filteredInboundRouterType">
<xsd:sequence>
<xsd:element maxOccurs="1" minOccurs="1" ref="abstract-outbound-endpoint"/>
</xsd:sequence>
</xsd:extension>
</xsd:complexContent>
</xsd:complexType>
<xsd:element name="forwarding-router" substitutionGroup="abstract-inbound-router" type="abstractInboundRouterType">
<xsd:annotation>
<xsd:documentation>
Allows messages to be forwarded to the outbound routers without first being processed by a component.
</xsd:documentation>
</xsd:annotation>
</xsd:element>
<xsd:element name="selective-consumer-router" substitutionGroup="abstract-inbound-router" type="filteredInboundRouterType">
<xsd:annotation>
<xsd:documentation>
Applies one or more filters to the incoming message. If the filters match, the message is forwarded to the component. Otherwise, the message is forwarded to the catch-all strategy on the router. If no catch-all strategy is configured, the message is ignored and a warning is logged.
</xsd:documentation>
</xsd:annotation>
</xsd:element>
<xsd:annotation>
<xsd:documentation>
Holds back a group of messages and resequences them using each message's correlation sequence property.
</xsd:documentation>
</xsd:annotation>
</xsd:element>
<xsd:annotation>
<xsd:documentation>
Combines two or more messages into a single message by matching messages with a given Correlation ID. Correlation IDs are set on messages when they are dispatched by certain outbound routers, such as the Recipient List and Message Splitter routers. These messages can be aggregated back together again using this router.
</xsd:documentation>
</xsd:annotation>
</xsd:element>
<xsd:complexType name="messageChunkingAggregatorRouterType">
<xsd:complexContent>
<xsd:extension base="baseAggregatorRouterType"/>
</xsd:complexContent>
</xsd:complexType>
<xsd:annotation>
<xsd:documentation>
Configures a custom message aggregator. Mule provides an abstract implementation that has a template method that performs the message aggregation. A common use of the aggregator router is to combine the results of multiple requests such as "ask this set of vendors for the best price of X".
</xsd:documentation>
</xsd:annotation>
</xsd:element>
<xsd:complexType name="customCorrelationAggregatorRouterType">
<xsd:complexContent>
<xsd:sequence>
<xsd:element maxOccurs="unbounded" minOccurs="0" ref="spring:property">
<xsd:annotation>
<xsd:documentation>
Spring-style property element for custom configuration.
</xsd:documentation>
</xsd:annotation>
</xsd:element>
</xsd:sequence>
<xsd:attribute name="class" type="substitutableClass" use="required">
<xsd:annotation>
<xsd:documentation>
Fully qualified class name of the custom correlation aggregator router to be used.
</xsd:documentation>
</xsd:annotation>
</xsd:attribute>
</xsd:extension>
</xsd:complexContent>
</xsd:complexType>
<xsd:element name="collection-aggregator-router" substitutionGroup="abstract-inbound-router" type="baseAggregatorRouterType">
<xsd:annotation>
<xsd:documentation>
Configures a Collection Response Router. This will return a MuleMessageCollection message type that will contain all messages received for a each correlation group.
</xsd:documentation>
</xsd:annotation>
</xsd:element>
<xsd:element name="custom-inbound-router" substitutionGroup="abstract-inbound-router" type="customInboundRouterType">
<xsd:annotation>
<xsd:documentation>
Allows for custom inbound routers to be configured.
</xsd:documentation>
</xsd:annotation>
</xsd:element>
<xsd:complexType name="customInboundRouterType">
<xsd:complexContent>
<xsd:extension base="abstractInboundRouterType">
<xsd:sequence>
<xsd:element maxOccurs="unbounded" minOccurs="0" ref="spring:property">
<xsd:annotation>
<xsd:documentation>
Spring-style property elements so that custom configuration can be configured on the custom router.
</xsd:documentation>
</xsd:annotation>
</xsd:element>
</xsd:sequence>
<xsd:attribute name="class" type="substitutableClass" use="required">
<xsd:annotation>
<xsd:documentation>
An implementation of InboundRouter (fully qualified Java class name)
</xsd:documentation>
</xsd:annotation>
</xsd:attribute>
</xsd:extension>
</xsd:complexContent>
</xsd:complexType>
<xsd:complexType name="baseAggregatorRouterType">
<xsd:complexContent>
<xsd:extension base="abstractInboundRouterType">
<xsd:attribute name="timeout" type="substitutableInt">
<xsd:annotation>
<xsd:documentation>
Defines a timeout in Milliseconds to wait for events to be aggregated. By default the router will throw an exeception if the router is waiting for a correlation group and times out before all group enties are received.
</xsd:documentation>
</xsd:annotation>
</xsd:attribute>
<xsd:attribute name="failOnTimeout" type="substitutableBoolean">
<xsd:annotation>
<xsd:documentation>
When false, incomplete aggregation groups will be forwarded to a component on timeout as a java.util.List. When true (default), a CorrelationTimeoutException is thrown and RoutingNotification.CORRELATION_TIMEOUT is fired. The component doesn't receive any messages in this case.
</xsd:documentation>
</xsd:annotation>
</xsd:attribute>
</xsd:extension>
</xsd:complexContent>
</xsd:complexType>
<!-- ResponseRouters -->
<!-- Deprecated -->
<xsd:element name="single-async-reply-router" substitutionGroup="abstract-async-reply-router" type="asyncReplyRouterType">
<xsd:annotation>
<xsd:documentation>
Configures a Single Response Router. This will return the first message it receives on a reply endpoint and will discard the rest.
</xsd:documentation>
</xsd:annotation>
</xsd:element>
<!-- Deprecated -->
<xsd:annotation>
<xsd:documentation>
Configures a Collection Response Router. This will return a MuleMessageCollection message type that will contain all messages received for the current correlation.
</xsd:documentation>
</xsd:annotation>
</xsd:element>
<!-- Deprecated -->
<xsd:complexType name="asyncReplyRouterType">
<xsd:complexContent>
<xsd:extension base="abstractAsyncReplyRouterType">
<xsd:sequence>
<xsd:element maxOccurs="unbounded" minOccurs="0" ref="abstract-inbound-endpoint">
<xsd:annotation>
<xsd:documentation>
The endpoint used to receive the response(s) on.
</xsd:documentation>
</xsd:annotation>
</xsd:element>
</xsd:sequence>
</xsd:extension>
</xsd:complexContent>
</xsd:complexType>
<!-- Deprecated -->
<xsd:complexType name="customAsyncReplyRouterType">
<xsd:complexContent>
<xsd:extension base="asyncReplyRouterType">
<xsd:sequence>
<xsd:element maxOccurs="unbounded" minOccurs="0" ref="spring:property">
<xsd:annotation>
<xsd:documentation>
Spring-style property elements so that custom configuration can be configured on the custom router.
</xsd:documentation>
</xsd:annotation>
</xsd:element>
</xsd:sequence>
<xsd:attribute name="class" type="substitutableClass" use="required">
<xsd:annotation>
<xsd:documentation>
A fully qualified Java class name of the router to use. The router should either extend {{org.mule.routing.response.AbstractResponseRouter}} or {{org.mule.routing.response.AbstractResponseAggregator}}.
</xsd:documentation>
</xsd:annotation>
</xsd:attribute>
</xsd:extension>
</xsd:complexContent>
</xsd:complexType>
<!-- Outbound Router implementations -->
<!-- Outbound router element and attribute groups -->
<xsd:sequence>
<xsd:element minOccurs="0" name="reply-to" type="endpointRefType">
<xsd:annotation>
<xsd:documentation>
Defines where the message should be routed after the recipient of the message to which this service dispatches has finished with it.
</xsd:documentation>
</xsd:annotation>
</xsd:element>
<xsd:element minOccurs="0" ref="abstract-transaction">
<xsd:annotation>
<xsd:documentation>
Defines an overall transaction that will be used for all endpoints on this router. This is only useful when you want to define an outbound only transaction that will commit all of the transactions defined on the outbound endpoints for this router. Note that you must still define a transaction on each of the endpoints that should take part in the transaction. These transactions should always be configured to JOIN the existing transaction.
</xsd:documentation>
</xsd:annotation>
</xsd:element>
</xsd:sequence>
</xsd:group>
<xsd:sequence>
<xsd:element minOccurs="0" ref="abstract-filter">
<xsd:annotation>
<xsd:documentation>
Filters the messages to be processed by this router.
@Deprecated since 2.2. Configure the filter on the endpoint instead of the router.
</xsd:documentation>
</xsd:annotation>
</xsd:element>
<xsd:element maxOccurs="unbounded" minOccurs="0" ref="abstract-transformer">
<xsd:annotation>
<xsd:documentation>
Filters are applied before message transformations. A transformer can be configured here to transform messages before they are filtered.
</xsd:documentation>
</xsd:annotation>
</xsd:element>
</xsd:sequence>
</xsd:group>
<xsd:attributeGroup name="defaultCorrelationAttributes">
<xsd:attribute default="IF_NOT_SET" name="enableCorrelation">
<xsd:annotation>
<xsd:documentation>
Specifies whether Mule should give outgoing messages a correlation ID. The default behavior is to give messages a correlation ID only if they don't already have one, so that existing correlation IDs are maintained.
</xsd:documentation>
</xsd:annotation>
<xsd:simpleType>
<xsd:restriction base="xsd:NMTOKEN">
<xsd:enumeration value="ALWAYS"/>
<xsd:enumeration value="NEVER"/>
<xsd:enumeration value="IF_NOT_SET"/>
</xsd:restriction>
</xsd:simpleType>
</xsd:attribute>
</xsd:attributeGroup>
<xsd:attributeGroup name="defaultOutboundRouterAttributes">
<xsd:attributeGroup ref="defaultCorrelationAttributes"/>
<xsd:attribute name="transformer-refs" type="xsd:NMTOKENS">
<xsd:annotation>
<xsd:documentation>
A list of the transformers that will be applied to the message in order before it is delivered to the component.
</xsd:documentation>
</xsd:annotation>
</xsd:attribute>
</xsd:attributeGroup>
<xsd:attributeGroup name="defaultFilteredOutboundRouterAttributes">
<xsd:attributeGroup ref="defaultOutboundRouterAttributes"/>
<xsd:attribute default="true" name="useTemplates" type="substitutableBoolean">
<xsd:annotation>
<xsd:documentation>
Determines if placeholders with expressions can be used with the form [ ] in endpoint uri's.
</xsd:documentation>
</xsd:annotation>
</xsd:attribute>
</xsd:attributeGroup>
<!-- Default Outbound Router Types -->
<xsd:complexType name="outboundRouterType">
<xsd:complexContent>
<xsd:extension base="abstractOutboundRouterType">
<xsd:sequence>
<xsd:element ref="abstract-outbound-endpoint"/>
</xsd:sequence>
<xsd:attributeGroup ref="defaultCorrelationAttributes"/>
</xsd:extension>
</xsd:complexContent>
</xsd:complexType>
<xsd:complexType name="filteringOutboundRouterType">
<xsd:complexContent>
<xsd:extension base="abstractOutboundRouterType">
<xsd:sequence>
<xsd:element ref="abstract-outbound-endpoint"/>
</xsd:sequence>
<xsd:attributeGroup ref="defaultFilteredOutboundRouterAttributes"/>
</xsd:extension>
</xsd:complexContent>
</xsd:complexType>
<xsd:complexContent>
<xsd:extension base="abstractOutboundRouterType">
<xsd:sequence>
<xsd:element maxOccurs="unbounded" ref="abstract-outbound-endpoint"/>
</xsd:sequence>
<xsd:attributeGroup ref="defaultFilteredOutboundRouterAttributes"/>
</xsd:extension>
</xsd:complexContent>
</xsd:complexType>
<xsd:complexContent>
<xsd:extension base="abstractOutboundRouterType">
<xsd:sequence>
<xsd:element maxOccurs="1" ref="abstract-outbound-endpoint"/>
</xsd:sequence>
<xsd:attributeGroup ref="defaultFilteredOutboundRouterAttributes"/>
</xsd:extension>
</xsd:complexContent>
</xsd:complexType>
<!-- Concrete Outbound Routers -->
<xsd:element name="pass-through-router" substitutionGroup="abstract-outbound-router" type="outboundRouterType">
<xsd:annotation>
<xsd:documentation>
This router always matches and simply sends or dispatches message via the endpoint that is configured.
</xsd:documentation>
</xsd:annotation>
</xsd:element>
<!-- FilteringOutboundRouter only uses a single endpoint. For now this needs to support multiple endpoints for MessageBuilderComponent usage only. -->
<xsd:annotation>
<xsd:documentation>
Uses filters to determine whether the message matches a particular criteria and if so will route the message to the endpoint configured on the router.
</xsd:documentation>
</xsd:annotation>
</xsd:element>
<xsd:annotation>
<xsd:documentation>
Sends the message through multiple endpoints using the result of the first invocation as the input for the next.
</xsd:documentation>
</xsd:annotation>
</xsd:element>
<xsd:annotation>
<xsd:documentation>
Sends a message over an endpoint by selecting the first endpoint that can connect to the transport. Endpoints are listed statically in the router configuration.
</xsd:documentation>
</xsd:annotation>
</xsd:element>
<xsd:annotation>
<xsd:documentation>
Sends a message over an endpoint by selecting the first endpoint that can connect to the transport. Endpoints/recipients are extracted from the message using an expression.
</xsd:documentation>
</xsd:annotation>
</xsd:element>
<xsd:annotation>
<xsd:documentation>
Sends the same message over multiple endpoints.
</xsd:documentation>
</xsd:annotation>
</xsd:element>
<xsd:annotation>
<xsd:documentation>
Sends the same message sequentially over multiple endpoints. Stops the routing process if receives a null or an exception message as a partial response from a synchronous endpoint.
</xsd:documentation>
</xsd:annotation>
</xsd:element>
<xsd:element name="endpoint-selector-router" substitutionGroup="abstract-outbound-router" type="endpointSelectorRouterType">
<xsd:annotation>
<xsd:documentation>
Selects the outgoing endpoint based on an expression evaluator ("header:endpoint" by default). It will first try to match the endpoint by name and then by address. The endpoints to use can be set on the router itself or be global endpoint definitions.
</xsd:documentation>
</xsd:annotation>
</xsd:element>
<xsd:complexType name="endpointSelectorRouterType">
<xsd:complexContent>
<xsd:attributeGroup ref="expressionAttributes"/>
<xsd:attribute name="default" type="xsd:string" use="optional">
<xsd:annotation>
<xsd:documentation>
The name of the default endpoint to use if the expression returns null. This can be used as an 'else' condition to route messages that don't contain the expected routing information.
</xsd:documentation>
</xsd:annotation>
</xsd:attribute>
</xsd:extension>
</xsd:complexContent>
</xsd:complexType>
<!-- Splitter routers -->
<!-- Extends AbstractMessageSplitter-->
<xsd:complexType name="messageSplitterOutboundRouterType">
<xsd:complexContent>
</xsd:complexContent>
</xsd:complexType>
<!-- Extends AbstractRoundRobinMessageSplitter -->
<xsd:complexType name="roundRobinSplitterType">
<xsd:complexContent>
<xsd:extension base="messageSplitterOutboundRouterType">
<xsd:attribute name="deterministic" type="substitutableBoolean">
<xsd:annotation>
<xsd:documentation>
If 'disableRoundRobin' is false and this option is true (the default) then the first message part will be routed to the first endpoint, the second part to the second endpoint, etc, with the nth part going to the (n modulo number of endpoints) endpoint. If false then the messages will be distributed equally amongst all endpoints.
</xsd:documentation>
</xsd:annotation>
</xsd:attribute>
<xsd:attribute name="disableRoundRobin" type="substitutableBoolean">
<xsd:annotation>
<xsd:documentation>
If filters are being used on endpoints then round robin behaviour is probably not desirable. This flag switches round robin behaviour off, it is on by default.
</xsd:documentation>
</xsd:annotation>
</xsd:attribute>
<xsd:attribute name="failIfNoMatch" type="substitutableBoolean">
<xsd:annotation>
<xsd:documentation>
If 'disableRoundRobin' is true, there may be situations where the current split message does not match any endpoints. this flag controls whether an exception should be thrown when a match is not found.
</xsd:documentation>
</xsd:annotation>
</xsd:attribute>
</xsd:extension>
</xsd:complexContent>
</xsd:complexType>
<xsd:element name="list-message-splitter-router" substitutionGroup="abstract-outbound-router" type="roundRobinSplitterType">
<xsd:annotation>
<xsd:documentation>
The Filtering List Message Splitter accepts a list of objects that is split each object being routed to different endpoints.
</xsd:documentation>
</xsd:annotation>
</xsd:element>
<xsd:annotation>
<xsd:documentation>
Splits the message based on an expression. The expression must return one or more message parts in order to be effective.
</xsd:documentation>
</xsd:annotation>
</xsd:element>
<xsd:complexType name="expressionSplitterOutboundRouterType">
<xsd:complexContent>
<xsd:extension base="roundRobinSplitterType">
<xsd:attributeGroup ref="expressionAttributes"/>
</xsd:extension>
</xsd:complexContent>
</xsd:complexType>
<!-- Messgae chunking routers -->
<xsd:element name="message-chunking-router" substitutionGroup="abstract-outbound-router" type="chunkingRouterType">
<xsd:annotation>
<xsd:documentation>
Allows you to split a single message into a number of fixed-length messages that will all be routed to the same endpoint.
</xsd:documentation>
</xsd:annotation>
</xsd:element>
<xsd:complexType name="chunkingRouterType">
<xsd:complexContent>
<xsd:attribute name="messageSize" type="substitutableInt">
<xsd:annotation>
<xsd:documentation>
The message chunk size (in bytes) that the current message will be split into. Note that this is mutually exclusive to the 'numberOfMessages' property.
</xsd:documentation>
</xsd:annotation>
</xsd:attribute>
<xsd:attribute name="numberOfMessages" type="substitutableInt">
<xsd:annotation>
<xsd:documentation>
The number of message peices to break the current message into. This property is less useful than the 'message' size property since, usually messages are constricted by size. Note that this is mutually exclusive to the 'messageSize' property.
</xsd:documentation>
</xsd:annotation>
</xsd:attribute>
</xsd:extension>
</xsd:complexContent>
</xsd:complexType>
<!-- recipient List routers -->
<xsd:annotation>
<xsd:documentation>
Sends the same message to multiple endpoints over the same endpoint, or implements routing-slip behavior where the next destination for the message is determined from message properties or the payload. It uses a static list of recipient endpoints.
</xsd:documentation>
</xsd:annotation>
</xsd:element>
<xsd:complexType name="staticRecipientListRouterType">
<xsd:complexContent>
<xsd:extension base="abstractOutboundRouterType">
<xsd:sequence>
<xsd:element maxOccurs="1" minOccurs="0" name="recipients" type="listOrSetType">
<xsd:annotation>
<xsd:documentation>
Static list of recipients that the outgoing message is sent to. The default delimiter is ','.
</xsd:documentation>
</xsd:annotation>
</xsd:element>
</xsd:sequence>
<xsd:attributeGroup ref="defaultFilteredOutboundRouterAttributes"/>
<xsd:attribute name="recipientsProperty" type="xsd:string">
<xsd:annotation>
<xsd:documentation>
Defines a property name on the current message where a list of endpoint names (or URIs) can be obtained. This property can return a {{java.util.List}} of values or a delimited {{java.lang.String}}. If the 'recipientsProperty' returns a string then the 'recipientsDelimiter' property is used to split the string.
If the entries in the String or List define endpoint names, these will be looked up at runtime. If the entries define endpoint URIs these endpoints will be created at runtime.
</xsd:documentation>
</xsd:annotation>
</xsd:attribute>
<xsd:attribute name="recipientsDelimiter" type="xsd:string">
<xsd:annotation>
<xsd:documentation>
The delimiter to use when splitting a String list of recipients. the default is ','. This property is only used with the 'recipientsProperty'.
</xsd:documentation>
</xsd:annotation>
</xsd:attribute>
<xsd:attribute name="synchronous" type="xsd:boolean">
<xsd:annotation>
<xsd:documentation>
This flag controls whether the message will be sent to the recipients synchronously. Unlike other routers th recipient list router doesn't have pre-configured endpoints so the synchronicity of the endpoint cannot be honoured.
</xsd:documentation>
</xsd:annotation>
</xsd:attribute>
</xsd:extension>
</xsd:complexContent>
</xsd:complexType>
<xsd:annotation>
<xsd:documentation>
Sends the same message to multiple endpoints over the same endpoint, or implements routing-slip behavior where the next destination for the message is determined from message properties or the payload. The recipients can be extracted from the message using an expression, or you can specify a static list of recipient endpoints. (As of version 2.1)
</xsd:documentation>
</xsd:annotation>
</xsd:element>
<xsd:complexType name="expressionRecipientListRouterType">
<xsd:complexContent>
<xsd:extension base="abstractOutboundRouterType">
<xsd:sequence>
</xsd:sequence>
<xsd:attributeGroup ref="defaultFilteredOutboundRouterAttributes"/>
<xsd:attributeGroup ref="expressionAttributes"/>
<xsd:attribute name="synchronous" type="xsd:boolean">
<xsd:annotation>
<xsd:documentation>
This flag controls whether the message will be sent to the recipients synchronously. Unlike other routers th recipient list router doesn't have pre-configured endpoints so the synchronicity of the endpoint cannot be honoured.
</xsd:documentation>
</xsd:annotation>
</xsd:attribute>
</xsd:extension>
</xsd:complexContent>
</xsd:complexType>
<xsd:complexContent>
<xsd:extension base="expressionRecipientListRouterType">
<xsd:sequence>
<xsd:element maxOccurs="1" minOccurs="0" name="recipients" type="listOrSetType">
<xsd:annotation>
<xsd:documentation>
A static list of endpoint names or URIs that will be used as recipients of the current message. If the expression on this router returns a list of endpoint names, the endpoints here will be checked as well as any global endpoints.
</xsd:documentation>
</xsd:annotation>
</xsd:element>
</xsd:sequence>
</xsd:extension>
</xsd:complexContent>
</xsd:complexType>
<!-- custom router -->
<xsd:element name="custom-outbound-router" substitutionGroup="abstract-outbound-router" type="customOutboundRouterType">
<xsd:annotation>
<xsd:documentation>
Allows you to configure a custom outbound router by specifying the custom router class and by using Spring properties.
</xsd:documentation>
</xsd:annotation>
</xsd:element>
<xsd:complexType name="customOutboundRouterType">
<xsd:complexContent>
<xsd:extension base="abstractOutboundRouterType">
<xsd:sequence>
<xsd:element maxOccurs="unbounded" minOccurs="0" ref="abstract-outbound-endpoint"/>
<xsd:element maxOccurs="unbounded" minOccurs="0" ref="spring:property">
<xsd:annotation>
<xsd:documentation>
Spring-style property elements so that custom configuration can be configured on the
custom router.
</xsd:documentation>
</xsd:annotation>
</xsd:element>
</xsd:sequence>
<xsd:attributeGroup ref="defaultOutboundRouterAttributes"/>
<xsd:attribute name="class" type="substitutableClass" use="required">
<xsd:annotation>
<xsd:documentation>
An implementation of OutboundRouter (fully qualified Java class name)
</xsd:documentation>
</xsd:annotation>
</xsd:attribute>
</xsd:extension>
</xsd:complexContent>
</xsd:complexType>
<!-- Catch all strategy implementations -->
<xsd:annotation>
<xsd:documentation>
Does nothing with the message but simply logs (using the WARN log level) the fact that the message was not dispatched because no routing path was defined.
</xsd:documentation>
</xsd:annotation>
</xsd:element>
<xsd:complexType name="loggingCatchAllStrategyType">
<xsd:complexContent>
<xsd:extension base="abstractCatchAllStrategyType"/>
</xsd:complexContent>
</xsd:complexType>
<xsd:complexType name="customCatchAllStrategyType">
<xsd:complexContent>
<xsd:extension base="abstractCatchAllStrategyType">
<xsd:sequence>
<xsd:element maxOccurs="unbounded" minOccurs="0" ref="spring:property">
<xsd:annotation>
<xsd:documentation>
Spring-style property element for custom configuration.
</xsd:documentation>
</xsd:annotation>
</xsd:element>
</xsd:sequence>
<xsd:attribute name="class" type="substitutableClass" use="required">
<xsd:annotation>
<xsd:documentation>
Fully qualified class name of the custom catch-all strategy to be used.
</xsd:documentation>
</xsd:annotation>
</xsd:attribute>
</xsd:extension>
</xsd:complexContent>
</xsd:complexType>
<xsd:annotation>
<xsd:documentation>
Forwards the message to the specified endpoint if no outbound routers match.
</xsd:documentation>
</xsd:annotation>
</xsd:element>
<xsd:complexType name="forwardingCatchAllStrategyType">
<xsd:complexContent>
<xsd:extension base="abstractCatchAllStrategyType">
<xsd:sequence>
<xsd:element maxOccurs="unbounded" minOccurs="0" ref="abstract-outbound-endpoint"/>
</xsd:sequence>
</xsd:extension>
</xsd:complexContent>
</xsd:complexType>
<xsd:complexType name="customForwardingCatchAllStrategyType">
<xsd:complexContent>
<xsd:extension base="forwardingCatchAllStrategyType">
<xsd:sequence>
<xsd:element maxOccurs="unbounded" minOccurs="0" ref="spring:property">
<xsd:annotation>
<xsd:documentation>
Spring-style property element for custom configuration.
</xsd:documentation>
</xsd:annotation>
</xsd:element>
</xsd:sequence>
<xsd:attribute name="class" type="substitutableClass" use="required">
<xsd:annotation>
<xsd:documentation>
Fully qualified class name of the custom forwarding catch-all strategy to be used.
</xsd:documentation>
</xsd:annotation>
</xsd:attribute>
</xsd:extension>
</xsd:complexContent>
</xsd:complexType>
<!-- Message Info Mappers -->
<xsd:element abstract="true" name="abstract-message-info-mapping" type="abstractMessageInfoMappingType">
<xsd:annotation>
<xsd:documentation>
Maps the attributes of the current message to known message elements in Mule, namely Message ID and CorrrelationID.
</xsd:documentation>
</xsd:annotation>
</xsd:element>
<xsd:complexType name="abstractMessageInfoMappingType"/>
<xsd:annotation>
<xsd:documentation>
Allows expressions to be configured to extract the message information.
</xsd:documentation>
</xsd:annotation>
</xsd:element>
<xsd:complexType name="expressionMessageInfoMappingType">
<xsd:complexContent>
<xsd:extension base="abstractMessageInfoMappingType">
<xsd:attribute name="messageIdExpression" type="xsd:string" use="required"/>
<xsd:attribute name="correlationIdExpression" type="xsd:string" use="required"/>
</xsd:extension>
</xsd:complexContent>
</xsd:complexType>
<xsd:annotation>
<xsd:documentation>
Allows configuraton of a custom implementation of MessageInfoMapping.
</xsd:documentation>
</xsd:annotation>
</xsd:element>
<xsd:complexType name="customMessageInfoMappingType">
<xsd:complexContent>
<xsd:extension base="abstractMessageInfoMappingType">
<xsd:sequence>
<xsd:element maxOccurs="unbounded" minOccurs="0" ref="spring:property">
<xsd:annotation>
<xsd:documentation>
Spring-style property element for custom configuration.
</xsd:documentation>
</xsd:annotation>
</xsd:element>
</xsd:sequence>
<xsd:attribute name="class" type="substitutableClass" use="required">
<xsd:annotation>
<xsd:documentation>
An implementation of the MessageInfoMapping interface.
</xsd:documentation>
</xsd:annotation>
</xsd:attribute>
</xsd:extension>
</xsd:complexContent>
</xsd:complexType>
<!--==============================================================-->
<!-- Lifecycle Adapters -->
<!--==============================================================-->
<xsd:element abstract="true" name="abstract-lifecycle-adapter-factory" type="abstractLifecycleAdapterFactory"/>
<xsd:complexType name="abstractLifecycleAdapterFactory">
<xsd:annotation>
<xsd:documentation>
Allows a lifecycle adaptor factory to be implemented, which allows an alternative custom lifecycle adaptor to be used if required instead of the default implementation that propagates the Mule lifecycle to component implementations.
</xsd:documentation>
</xsd:annotation>
</xsd:complexType>
<xsd:complexType name="customLifecycleAdapterFactory">
<xsd:complexContent>
<xsd:extension base="abstractLifecycleAdapterFactory">
<xsd:sequence>
<xsd:element maxOccurs="unbounded" minOccurs="0" ref="spring:property">
<xsd:annotation>
<xsd:documentation>
Spring-style property element for custom configuration.
</xsd:documentation>
</xsd:annotation>
</xsd:element>
</xsd:sequence>
<xsd:attribute name="class" type="substitutableClass" use="required">
<xsd:annotation>
<xsd:documentation>
An implementation of the LifecycleAdapter interface.
</xsd:documentation>
</xsd:annotation>
</xsd:attribute>
</xsd:extension>
</xsd:complexContent>
</xsd:complexType>
<xsd:annotation>
<xsd:documentation/>
</xsd:annotation>
</xsd:element>
<!--==============================================================-->
<!-- Object Factories -->
<!--==============================================================-->
<xsd:element abstract="true" name="abstract-object-factory" type="abstractObjectFactoryType"/>
<xsd:complexType name="abstractObjectFactoryType">
<xsd:annotation>
<xsd:documentation>
An object factory is used to obtain object instances. The object factory is responsible for object creation and can implement different patterns, such a singleton or prototype, or lookup an instance from other object containers.
</xsd:documentation>
</xsd:annotation>
<xsd:sequence>
<xsd:group ref="propertiesGroup">
<xsd:annotation>
<xsd:documentation>
Properties to be set on the created object.
</xsd:documentation>
</xsd:annotation>
</xsd:group>
</xsd:sequence>
</xsd:complexType>
<xsd:complexType name="genericObjectFactoryType">
<xsd:sequence>
<xsd:element ref="abstract-object-factory"/>
</xsd:sequence>
</xsd:complexType>
<xsd:element name="spring-object" substitutionGroup="abstract-object-factory" type="springBeanLookupType"/>
<xsd:complexType name="springBeanLookupType">
<xsd:annotation>
<xsd:documentation>
Object factory used to obtain Spring bean instances. This object factory does not create any instances but rather looks them up from Spring.
</xsd:documentation>
</xsd:annotation>
<xsd:complexContent>
<xsd:extension base="abstractObjectFactoryType">
<xsd:attribute name="bean" type="substitutableName">
<xsd:annotation>
<xsd:documentation>Name of Spring bean to look up.</xsd:documentation>
</xsd:annotation>
</xsd:attribute>
</xsd:extension>
</xsd:complexContent>
</xsd:complexType>
<xsd:element name="singleton-object" substitutionGroup="abstract-object-factory" type="singletonObjectFactoryType"/>
<xsd:complexType name="singletonObjectFactoryType">
<xsd:annotation>
<xsd:documentation>
Object factory that creates and always returns a singleton object instance.
</xsd:documentation>
</xsd:annotation>
<xsd:complexContent>
<xsd:extension base="abstractObjectFactoryType">
<xsd:attribute name="class" type="substitutableClass">
<xsd:annotation>
<xsd:documentation>Class name</xsd:documentation>
</xsd:annotation>
</xsd:attribute>
</xsd:extension>
</xsd:complexContent>
</xsd:complexType>
<xsd:element name="prototype-object" substitutionGroup="abstract-object-factory" type="prototypeObjectFactoryType"/>
<xsd:complexType name="prototypeObjectFactoryType">
<xsd:annotation>
<xsd:documentation>
Object factory that creates and returns a new 'prototype' object instance every time it is called.
</xsd:documentation>
</xsd:annotation>
<xsd:complexContent>
<xsd:extension base="abstractObjectFactoryType">
<xsd:attribute name="class" type="substitutableClass">
<xsd:annotation>
<xsd:documentation>Class name</xsd:documentation>
</xsd:annotation>
</xsd:attribute>
</xsd:extension>
</xsd:complexContent>
</xsd:complexType>
<xsd:element abstract="true" name="abstract-pooling-profile" type="abstractPoolingProfileType"/>
<xsd:complexType name="abstractPoolingProfileType"/>
<xsd:element name="pooling-profile" substitutionGroup="abstract-pooling-profile" type="poolingProfileType"/>
<xsd:complexType name="poolingProfileType">
<xsd:annotation>
<xsd:documentation>
A pooling profile is used to configure the pooling behaviour of Mule components. Each component can have its own pooling profile.
</xsd:documentation>
</xsd:annotation>
<xsd:complexContent>
<xsd:extension base="abstractPoolingProfileType">
<xsd:attribute name="maxActive" type="xsd:string">
<xsd:annotation>
<xsd:documentation>
Controls the maximum number of Mule components that can be borrowed from a session at one time. When set to a negative value, there is no limit to the number of components that may be active at one time. When maxActive is exceeded, the pool is said to be exhausted.
</xsd:documentation>
</xsd:annotation>
</xsd:attribute>
<xsd:attribute name="maxIdle" type="xsd:string">
<xsd:annotation>
<xsd:documentation>
Controls the maximum number of Mule components that can sit idle in the pool at any time. When set to a negative value, there is no limit to the number of Mule components that may be idle at one time.
</xsd:documentation>
</xsd:annotation>
</xsd:attribute>
<xsd:attribute default="INITIALISE_ONE" name="initialisationPolicy">
<xsd:annotation>
<xsd:documentation>
Determines how components in a pool should be initialized. The possible values are: INITIALISE_NONE (will not load any components into the pool on startup), INITIALISE_ONE (will load one initial component into the pool on startup), or INITIALISE_ALL (will load all components in the pool on startup)
</xsd:documentation>
</xsd:annotation>
<xsd:simpleType>
<xsd:restriction base="xsd:NMTOKEN">
<xsd:enumeration value="INITIALISE_NONE"/>
<xsd:enumeration value="INITIALISE_ONE"/>
<xsd:enumeration value="INITIALISE_ALL"/>
</xsd:restriction>
</xsd:simpleType>
</xsd:attribute>
<xsd:attribute default="WHEN_EXHAUSTED_GROW" name="exhaustedAction">
<xsd:annotation>
<xsd:documentation>
Specifies the behavior of the Mule component pool when the pool is exhausted. Possible values are: "WHEN_EXHAUSTED_FAIL", which will throw a NoSuchElementException, "WHEN_EXHAUSTED_WAIT", which will block by invoking Object.wait(long) until a new or idle object is available, or WHEN_EXHAUSTED_GROW, which will create a new Mule instance and return it, essentially making maxActive meaningless. If a positive maxWait value is supplied, it will block for at most that many milliseconds, after which a NoSuchElementException will be thrown. If maxThreadWait is a negative value, it will block indefinitely.
</xsd:documentation>
</xsd:annotation>
<xsd:simpleType>
<xsd:restriction base="xsd:NMTOKEN">
<xsd:enumeration value="WHEN_EXHAUSTED_GROW"/>
<xsd:enumeration value="WHEN_EXHAUSTED_WAIT"/>
<xsd:enumeration value="WHEN_EXHAUSTED_FAIL"/>
</xsd:restriction>
</xsd:simpleType>
</xsd:attribute>
<xsd:attribute name="maxWait" type="xsd:string">
<xsd:annotation>
<xsd:documentation>
Specifies the number of milliseconds to wait for a pooled component to become available when the pool is exhausted and the exhaustedAction is set to WHEN_EXHAUSTED_WAIT.
</xsd:documentation>
</xsd:annotation>
</xsd:attribute>
<!-- <xsd:attribute name="factory" type="xsd:string" default="org.mule.config.pool.CommonsPoolFactory"/> -->
</xsd:extension>
</xsd:complexContent>
</xsd:complexType>
<!--==============================================================-->
<!-- Utils / Standard Types -->
<!--==============================================================-->
<!-- corresponds to TlsIndirectKeyStore, named as tls-client in transport namespace -->
<xsd:complexType name="tlsClientKeyStoreType">
<xsd:annotation>
<xsd:documentation>
Configure client key stores. TLS/SSL connections are made on behalf of an entity, which can be anonymous or identified by a certificate. This interface specifies how a keystore can be used to provide the certificates (and associated private keys) necessary for identification. This is also used as the trust store if no other trust store is specified and the explicitTrustStoreOnly parameter in the server trust store configuration is false. WARNING - due to restrictions in library implementations the values specified here typically apply to all connectors using this transport.
</xsd:documentation>
</xsd:annotation>
<xsd:attribute name="path" type="xsd:string">
<xsd:annotation>
<xsd:documentation>
The location (which will be resolved relative to the current classpath and file system, if possible) of the keystore that contains public certificates and private keys for identification.
</xsd:documentation>
</xsd:annotation>
</xsd:attribute>
<xsd:attribute name="storePassword" type="xsd:string">
<xsd:annotation>
<xsd:documentation>
The password used to protect the keystore.
</xsd:documentation>
</xsd:annotation>
</xsd:attribute>
<xsd:attribute name="class" type="keystoreType">
<xsd:annotation>
<xsd:documentation>
Deprecated. use "type" instead
</xsd:documentation>
</xsd:annotation>
</xsd:attribute>
<xsd:attribute name="type" type="keystoreType">
<xsd:annotation>
<xsd:documentation>
The type of keystore used.
</xsd:documentation>
</xsd:annotation>
</xsd:attribute>
</xsd:complexType>
<!-- corresponds to TlsDirectKeyStore, named as tls-key-store in transport namespace -->
<xsd:complexType name="tlsKeyStoreType">
<xsd:annotation>
<xsd:documentation>
Configures key stores. TLS/SSL connections are made on behalf of an entity, which can be anonymous or identified by a certificate. This interface specifies how a keystore can be used to provide the certificates (and associated private keys) necessary for identification.
</xsd:documentation>
</xsd:annotation>
<xsd:attribute name="path" type="xsd:string">
<xsd:annotation>
<xsd:documentation>
The location (which will be resolved relative to the current classpath and file system, if possible) of the keystore that contains public certificates and private keys for identification.
</xsd:documentation>
</xsd:annotation>
</xsd:attribute>
<xsd:attribute name="class" type="keystoreType">
<xsd:annotation>
<xsd:documentation>
Deprecated. use "type" instead
</xsd:documentation>
</xsd:annotation>
</xsd:attribute>
<xsd:attribute name="type" type="keystoreType">
<xsd:annotation>
<xsd:documentation>
The type of keystore used.
</xsd:documentation>
</xsd:annotation>
</xsd:attribute>
<xsd:attribute name="keyAlias" type="xsd:string" use="optional">
<xsd:annotation>
<xsd:documentation>
The alias of the key to use.
</xsd:documentation>
</xsd:annotation>
</xsd:attribute>
<xsd:attribute name="keyPassword" type="xsd:string">
<xsd:annotation>
<xsd:documentation>
The password used to protect the private key.
</xsd:documentation>
</xsd:annotation>
</xsd:attribute>
<xsd:attribute name="storePassword" type="xsd:string">
<xsd:annotation>
<xsd:documentation>
The password used to protect the keystore.
</xsd:documentation>
</xsd:annotation>
</xsd:attribute>
<xsd:attribute name="algorithm" type="xsd:string">
<xsd:annotation>
<xsd:documentation>
The algorithm used by the key store.
</xsd:documentation>
</xsd:annotation>
</xsd:attribute>
</xsd:complexType>
<!-- corresponds to TlsIndirectTrustStore, named as tls-trust-store in transport namespace -->
<xsd:complexType name="tlsTrustStoreType">
<xsd:annotation>
<xsd:documentation>
Configures a trust store. TLS/SSL connections are made to trusted systems. The public certificates of trusted systems are stored in a keystore (called a trust store) and used to verify that the connection made to a remote system is the expected identity.
</xsd:documentation>
</xsd:annotation>
<xsd:attribute name="path" type="xsd:string">
<xsd:annotation>
<xsd:documentation>
The location (which will be resolved relative to the current classpath and file system, if possible) of the keystore that contains public certificates of trusted servers.
</xsd:documentation>
</xsd:annotation>
</xsd:attribute>
<xsd:attribute name="storePassword" type="xsd:string">
<xsd:annotation>
<xsd:documentation>
The password used to protect the trust store.
</xsd:documentation>
</xsd:annotation>
</xsd:attribute>
</xsd:complexType>
<!-- corresponds to TlsDirectTrustStore, named as tls-server in transport namespace
note that this extends tlsTrustStoreType, so only one of the two is needed
-->
<xsd:complexType name="tlsServerTrustStoreType">
<xsd:annotation>
<xsd:documentation>
Configures a direct trust store. TLS/SSL connections are made to trusted systems. The public certificates of trusted systems are stored in a keystore (called a trust store) and used to verify that the connection made to a remote system is the expected identity.
</xsd:documentation>
</xsd:annotation>
<xsd:complexContent>
<xsd:extension base="tlsTrustStoreType">
<xsd:attribute name="class" type="keystoreType">
<xsd:annotation>
<xsd:documentation>
Deprecated. use "type" instead
</xsd:documentation>
</xsd:annotation>
</xsd:attribute>
<xsd:attribute name="type" type="keystoreType">
<xsd:annotation>
<xsd:documentation>
The type of keystore used.
</xsd:documentation>
</xsd:annotation>
</xsd:attribute>
<xsd:attribute name="algorithm" type="xsd:string">
<xsd:annotation>
<xsd:documentation>
The algorithm used by the trust store.
</xsd:documentation>
</xsd:annotation>
</xsd:attribute>
<!-- should be of type TrustManagerFactory -->
<xsd:attribute name="factory-ref" type="xsd:string">
<xsd:annotation>
<xsd:documentation>
Reference to a TrustManagerFactory configured as a Spring bean.
</xsd:documentation>
</xsd:annotation>
</xsd:attribute>
<xsd:attribute name="explicitOnly" type="substitutableBoolean">
<xsd:annotation>
<xsd:documentation>
Specifies whether the key store data should not be used when a trust store is otherwise undefined.
</xsd:documentation>
</xsd:annotation>
</xsd:attribute>
<xsd:annotation>
<xsd:documentation>
If a server socket is constructed directly, this attribute is used to determine whether client authentication is required. This does not apply to client connections.
</xsd:documentation>
</xsd:annotation>
</xsd:attribute>
</xsd:extension>
</xsd:complexContent>
</xsd:complexType>
<xsd:simpleType name="keystoreType">
<xsd:annotation>
<xsd:documentation>
A type that defines a Java keystore..
</xsd:documentation>
</xsd:annotation>
<xsd:union>
<xsd:simpleType>
<xsd:restriction base="xsd:string">
<xsd:enumeration value="jks">
<xsd:annotation>
<xsd:documentation>
The default Java KeyStore. If no keystore type is specified, "jks" will be used.
</xsd:documentation>
</xsd:annotation>
</xsd:enumeration>
<xsd:enumeration value="jceks">
<xsd:annotation>
<xsd:documentation>
Used by the Java Cryptography Extension
</xsd:documentation>
</xsd:annotation>
</xsd:enumeration>
<xsd:enumeration value="pkcs12">
<xsd:annotation>
<xsd:documentation>
A format commonly used to store private keys.
</xsd:documentation>
</xsd:annotation>
</xsd:enumeration>
</xsd:restriction>
</xsd:simpleType>
<xsd:simpleType>
<xsd:restriction base="xsd:string">
<xsd:annotation>
<xsd:documentation>
Any other keystore type.
</xsd:documentation>
</xsd:annotation>
</xsd:restriction>
</xsd:simpleType>
</xsd:union>
</xsd:simpleType>
<!-- corresponds to TlsProtocolHandler, named as tls-protocol-handler -->
<xsd:complexType name="tlsProtocolHandler">
<xsd:annotation>
<xsd:documentation>
Configures the global Java protocol handler. WARNING - Untested.
</xsd:documentation>
</xsd:annotation>
<xsd:attribute name="property" type="xsd:string">
<xsd:annotation>
<xsd:documentation>
Sets the java.protocol.handler.pkgs system property.
</xsd:documentation>
</xsd:annotation>
</xsd:attribute>
</xsd:complexType>
<xsd:simpleType name="propertyPlaceholderType">
<xsd:annotation>
<xsd:documentation>
A type that defines a Mule-style property placeholder.
</xsd:documentation>
</xsd:annotation>
<xsd:restriction base="xsd:string">
<xsd:pattern value="(\#\[[^\]]+\]|\$\{[^\}]+\})"/>
</xsd:restriction>
</xsd:simpleType>
<xsd:simpleType name="substitutableClass">
<xsd:annotation>
<xsd:documentation>
A custom xsd:NMTOKEN-like type that also allows for Ant-style property placeholders and a leading "[".
</xsd:documentation>
</xsd:annotation>
<xsd:union>
<xsd:simpleType>
<xsd:restriction base="propertyPlaceholderType"/>
</xsd:simpleType>
<xsd:simpleType>
<xsd:restriction base="xsd:string">
<xsd:pattern value="\[?[A-Za-z0-9_\.$]+"/>
</xsd:restriction>
</xsd:simpleType>
</xsd:union>
</xsd:simpleType>
<xsd:simpleType name="nonBlankString">
<xsd:annotation>
<xsd:documentation>
A custom xsd:string-like type that cannot be empty.
</xsd:documentation>
</xsd:annotation>
<xsd:union>
<xsd:simpleType>
<xsd:restriction base="xsd:string">
<xsd:pattern value=".*[^ ]+.*"/>
</xsd:restriction>
</xsd:simpleType>
</xsd:union>
</xsd:simpleType>
<xsd:simpleType name="substitutableName">
<xsd:annotation>
<xsd:documentation>
A custom xsd:NMTOKEN type that also allows for Ant-style property placeholders.
</xsd:documentation>
</xsd:annotation>
<xsd:union>
<xsd:simpleType>
<xsd:restriction base="propertyPlaceholderType"/>
</xsd:simpleType>
<xsd:simpleType>
<xsd:restriction base="xsd:NMTOKEN"/>
</xsd:simpleType>
</xsd:union>
</xsd:simpleType>
<xsd:simpleType name="substitutablePortNumber">
<xsd:annotation>
<xsd:documentation>
A custom xsd:int type that also allows for Ant-style property placeholders and restricts the int value to a valid port number.
</xsd:documentation>
</xsd:annotation>
<xsd:union>
<xsd:simpleType>
<xsd:restriction base="propertyPlaceholderType"/>
</xsd:simpleType>
<xsd:simpleType>
<xsd:restriction base="xsd:int">
<xsd:minInclusive value="0"/>
<xsd:maxInclusive value="65536"/>
</xsd:restriction>
</xsd:simpleType>
</xsd:union>
</xsd:simpleType>
<xsd:simpleType name="substitutableInt">
<xsd:annotation>
<xsd:documentation>
A custom xsd:int type that also allows for Ant-style property placeholders.
</xsd:documentation>
</xsd:annotation>
<xsd:union>
<xsd:simpleType>
<xsd:restriction base="propertyPlaceholderType"/>
</xsd:simpleType>
<xsd:simpleType>
<xsd:restriction base="xsd:int"/>
</xsd:simpleType>
</xsd:union>
</xsd:simpleType>
<xsd:simpleType name="substitutableLong">
<xsd:annotation>
<xsd:documentation>
A custom xsd:long type that also allows for Ant-style property placeholders.
</xsd:documentation>
</xsd:annotation>
<xsd:union>
<xsd:simpleType>
<xsd:restriction base="propertyPlaceholderType"/>
</xsd:simpleType>
<xsd:simpleType>
<xsd:restriction base="xsd:long"/>
</xsd:simpleType>
</xsd:union>
</xsd:simpleType>
<xsd:simpleType name="substitutableBoolean">
<xsd:annotation>
<xsd:documentation>
A custom xsd:boolean type that also allows for Ant-style property placeholders.
</xsd:documentation>
</xsd:annotation>
<xsd:union>
<xsd:simpleType>
<xsd:restriction base="propertyPlaceholderType"/>
</xsd:simpleType>
<xsd:simpleType>
<xsd:restriction base="xsd:boolean"/>
</xsd:simpleType>
</xsd:union>
</xsd:simpleType>
<!-- i found this a bit confusing, so here is some background...
this type is typically called from something like
<xsd:element name="properties" type="mapType/>
and the "properties" element generates a ChildMapDefinitionParser that
can "receive" the map entries generated by the embedded spring <entry..>
elements and which is then set via "setProperties" on the parent.
in other words, it's a map, and despite the name "properties" has
nothing to do with the spring <property ...> element.
spring elements like <entry...> are handled by
MuleHierarchicalBeanDefinitionParserDelegate which punts them to
the spring handler
-->
<xsd:element name="properties" type="mapType">
<xsd:annotation>
<xsd:documentation>
A map of Mule properties.
</xsd:documentation>
</xsd:annotation>
</xsd:element>
<xsd:complexType name="mapType">
<xsd:complexContent>
<xsd:extension base="spring:mapType"/>
</xsd:complexContent>
</xsd:complexType>
<xsd:group name="propertiesGroup">
<xsd:sequence>
<xsd:element maxOccurs="unbounded" minOccurs="0" name="property" type="keyValueType">
<xsd:annotation>
<xsd:documentation>
Sets a Mule property. This is a name/value pair that can be set on components, services, etc., and which provide a generic way of configuring the system. Typically, you shouldn't need to use a generic property like this, since almost all functionality is exposed via dedicated elements. However, it can be useful in configuring obscure or overlooked options and in configuring transports from the generic endpoint elements.
</xsd:documentation>
</xsd:annotation>
</xsd:element>
<xsd:element minOccurs="0" ref="properties"/>
</xsd:sequence>
</xsd:group>
<xsd:complexType name="listOrSetType">
<xsd:complexContent>
<xsd:extension base="spring:listOrSetType"/>
</xsd:complexContent>
</xsd:complexType>
<xsd:complexType name="referenceType">
<xsd:attribute name="ref" type="xsd:string"/>
</xsd:complexType>
<xsd:complexType name="keyType">
<xsd:attribute name="key" type="xsd:string"/>
</xsd:complexType>
<xsd:complexType name="nameType">
<xsd:attribute name="name" type="xsd:string"/>
</xsd:complexType>
<xsd:complexType name="valueType">
<xsd:attribute name="value" type="xsd:string"/>
<xsd:attribute name="value-ref" type="xsd:string"/>
</xsd:complexType>
<xsd:complexType name="keyValueType">
<xsd:complexContent>
<xsd:extension base="keyType">
<xsd:attribute name="value" type="xsd:string"/>
<xsd:attribute name="value-ref" type="xsd:string"/>
</xsd:extension>
</xsd:complexContent>
</xsd:complexType>
<xsd:complexType name="nameValueType">
<xsd:complexContent>
<xsd:extension base="nameType">
<xsd:attribute name="value" type="xsd:string"/>
<xsd:attribute name="value-ref" type="xsd:string"/>
</xsd:extension>
</xsd:complexContent>
</xsd:complexType>
<xsd:simpleType name="attributeType">
<xsd:restriction base="xsd:string"/>
</xsd:simpleType>
<!--==============================================================-->
<!-- Connector support -->
<!--==============================================================-->
<xsd:complexType name="connectorType">
<xsd:complexContent>
<xsd:extension base="abstractConnectorType">
<xsd:sequence>
<!-- for normal connectors, this is for emergency use only, but it is
critical for custom connector
-->
<xsd:element maxOccurs="unbounded" minOccurs="0" ref="spring:property"/>
<xsd:element minOccurs="0" name="receiver-threading-profile" type="threadingProfileType">
<xsd:annotation>
<xsd:documentation>
The threading profile to use when a connector receives messages.
</xsd:documentation>
</xsd:annotation>
</xsd:element>
<xsd:element minOccurs="0" name="dispatcher-threading-profile" type="threadingProfileType">
<xsd:annotation>
<xsd:documentation>
The threading profile to use when a connector dispatches messages.
</xsd:documentation>
</xsd:annotation>
</xsd:element>
<xsd:element minOccurs="0" ref="abstract-reconnection-strategy">
<xsd:annotation>
<xsd:documentation>
Reconnection strategy that defines how Mule should handle a connection failure.
</xsd:documentation>
</xsd:annotation>
</xsd:element>
<xsd:element minOccurs="0" name="service-overrides" type="serviceOverridesType">
<xsd:annotation>
<xsd:documentation>
Service overrides allow the connector to be further configured/customized by allowing parts of the transport implementation to be overridden, for example, the message receiver or dispatcher implementation, or the message adaptor that is used.
</xsd:documentation>
</xsd:annotation>
</xsd:element>
</xsd:sequence>
<xsd:attribute default="false" name="dynamicNotification" type="substitutableBoolean">
<xsd:annotation>
<xsd:documentation>
Enables dynamic notifications for notifications fired by this connector. This allows listeners to be registered dynamically at runtime via the MuleContext, and the configured notification can be changed. This overrides the default value defined in the 'configuration' element.
</xsd:documentation>
</xsd:annotation>
</xsd:attribute>
<xsd:attribute default="true" name="validateConnections" type="substitutableBoolean">
<xsd:annotation>
<xsd:documentation>
Causes Mule to validate connections before use. Note that this is only a configuration hint,
transport implementations may or may not make an extra effort to validate the connection. Default is true.
</xsd:documentation>
</xsd:annotation>
</xsd:attribute>
<xsd:attribute name="dispatcherPoolFactory-ref" type="xsd:string">
<xsd:annotation>
<xsd:documentation>
Allows Spring beans to be defined as a dispatcher pool factory
</xsd:documentation>
</xsd:annotation>
</xsd:attribute>
</xsd:extension>
</xsd:complexContent>
</xsd:complexType>
<xsd:complexType name="serviceOverridesType">
<xsd:attribute name="messageReceiver" type="xsd:string"/>
<xsd:attribute name="transactedMessageReceiver" type="xsd:string"/>
<xsd:attribute name="xaTransactedMessageReceiver" type="xsd:string"/>
<xsd:attribute name="dispatcherFactory" type="xsd:string"/>
<xsd:attribute name="inboundTransformer" type="xsd:string"/>
<xsd:attribute name="outboundTransformer" type="xsd:string"/>
<xsd:attribute name="responseTransformer" type="xsd:string"/>
<xsd:attribute name="endpointBuilder" type="xsd:string"/>
<xsd:attribute name="messageFactory" type="xsd:string"/>
<xsd:attribute name="serviceFinder" type="xsd:string"/>
<xsd:attribute name="sessionHandler" type="xsd:string"/>
<xsd:attribute name="inboundExchangePatterns" type="xsd:string"/>
<xsd:attribute name="outboundExchangePatterns" type="xsd:string"/>
<xsd:attribute name="defaultExchangePattern" type="xsd:string"/>
</xsd:complexType>
<xsd:complexType name="transactedConnectorType">
<xsd:complexContent>
<xsd:extension base="connectorType">
<xsd:annotation>
<xsd:documentation>
Whether to create multiple concurrent receivers for this connector. This property is used by transports that support transactions, specifically receivers that extend the TransactedPollingMessageReceiver, and provides better throughput.
</xsd:documentation>
</xsd:annotation>
</xsd:attribute>
<xsd:annotation>
<xsd:documentation>
If createMultipleTransactedReceivers is set to true, the number of concurrent receivers that will be launched.
</xsd:documentation>
</xsd:annotation>
</xsd:attribute>
</xsd:extension>
</xsd:complexContent>
</xsd:complexType>
<!--==============================================================-->
<!-- JNDI support -->
<!--==============================================================-->
<xsd:complexType name="jndiConnectorType">
<xsd:complexContent>
<xsd:extension base="connectorType">
<xsd:sequence>
<xsd:element maxOccurs="unbounded" minOccurs="0" name="jndi-provider-property" type="keyValueType">
<xsd:annotation>
<xsd:documentation>
Direct setting of a JNDI property.
</xsd:documentation>
</xsd:annotation>
</xsd:element>
<xsd:element minOccurs="0" name="jndi-provider-properties" type="mapType">
<xsd:annotation>
<xsd:documentation>
Direct setting of JNDI properties (allows access to the full Spring map entry).
</xsd:documentation>
</xsd:annotation>
</xsd:element>
</xsd:sequence>
<xsd:attribute name="jndiContext-ref" type="xsd:string">
<xsd:annotation>
<xsd:documentation>
Set the complete context directly, via a bean reference.
</xsd:documentation>
</xsd:annotation>
</xsd:attribute>
<xsd:attribute name="jndiInitialFactory" type="substitutableClass">
<xsd:annotation>
<xsd:documentation>
The initial context factory to use. The value of the property should be the fully qualified class name of the factory class that will create an initial context.
</xsd:documentation>
</xsd:annotation>
</xsd:attribute>
<xsd:attribute name="jndiProviderUrl" type="xsd:string">
<xsd:annotation>
<xsd:documentation>
The service provider to use. The value of the property should contain a URL string (such as "ldap://somehost:389").
</xsd:documentation>
</xsd:annotation>
</xsd:attribute>
<xsd:attribute name="jndiUrlPkgPrefixes" type="xsd:string">
<xsd:annotation>
<xsd:documentation>
The list of package prefixes to use when loading in URL context factories. The value of the property should be a colon-separated list of package prefixes for the class name of the factory class that will create a URL context factory.
</xsd:documentation>
</xsd:annotation>
</xsd:attribute>
</xsd:extension>
</xsd:complexContent>
</xsd:complexType>
<xsd:complexType mixed="true" name="dataReferenceType">
<xsd:attribute name="file" type="xsd:string"/>
<xsd:attribute name="ref" type="xsd:string"/>
<!--I don't like this flag, may be we could use content-type mappings... -->
<xsd:attribute name="binary" type="substitutableBoolean"/>
</xsd:complexType>
<xsd:attributeGroup name="mimeTypeAttributes">
<xsd:attribute name="mimeType" type="xsd:string">
<xsd:annotation>
<xsd:documentation>
The mime type, e.g. text/plain or application/json
</xsd:documentation>
</xsd:annotation>
</xsd:attribute>
</xsd:attributeGroup>
<!-- these cannot be references (unless we use qualified attribute names, which are ugly),
but serve as templates to cut+paste in individual transports

<xsd:attribute name="path" type="xsd:string">
<xsd:annotation>
<xsd:documentation>
A file location.
</xsd:documentation>
</xsd:annotation>
</xsd:attribute>

<xsd:attribute name="user" type="xsd:string">
<xsd:annotation>
<xsd:documentation>
A username.
</xsd:documentation>
</xsd:annotation>
</xsd:attribute>

<xsd:attribute name="password" type="xsd:string">
<xsd:annotation>
<xsd:documentation>
A password.
</xsd:documentation>
</xsd:annotation>
</xsd:attribute>

<xsd:attribute name="host" type="xsd:string">
<xsd:annotation>
<xsd:documentation>
An IP address (eg www.mulesoft.com, localhost, 127.0.0.1).
</xsd:documentation>
</xsd:annotation>
</xsd:attribute>

<xsd:attribute name="port" type="substitutablePortNumber">
<xsd:annotation>
<xsd:documentation>
A port number.
</xsd:documentation>
</xsd:annotation>
</xsd:attribute>

-->
<!--==============================================================-->
<!-- Cache -->
<!--==============================================================-->
<xsd:element abstract="true" name="abstract-caching-strategy" substitutionGroup="abstract-extension" type="abstractCachingStrategyType">
<xsd:annotation>
<xsd:documentation>
A placeholder for caching strategies elements.
</xsd:documentation>
</xsd:annotation>
</xsd:element>
<xsd:complexType name="abstractCachingStrategyType">
<xsd:complexContent>
<xsd:extension base="abstractExtensionType">
<xsd:attribute name="name" type="xsd:string" use="optional">
<xsd:annotation>
<xsd:documentation>
The name of the caching strategy.
</xsd:documentation>
</xsd:annotation>
</xsd:attribute>
</xsd:extension>
</xsd:complexContent>
</xsd:complexType>
</xsd:schema>

XML schema documentation generated with DocFlex/XML RE 1.8.5 using DocFlex/XML XSDDoc 2.5.0 template set. All content model diagrams generated by Altova XMLSpy via DocFlex/XML XMLSpy Integration.