Overview | Package | Class | Use | Tree | Deprecated | Index | Help
PREV NEXT | FRAMES NO FRAMES

## Uses of Package
org.mule.api.lifecycle

Packages that use org.mule.api.lifecycle
org.mule | The Mule implementation of the Universal Message Objects(tm) API specification.
org.mule.agent | Admin components and Agents used to control and Monitor Mule
org.mule.api | The Universal Message Object(tm) API provides a way for components to interact without needing to know about the protocol or delivery mechanisms of information passed between them
org.mule.api.agent |
org.mule.api.component |
org.mule.api.construct |
org.mule.api.context | Mule Context APIs, including the MuleContext, agent and server event interfaces
org.mule.api.endpoint | Endpoint interfaces.
org.mule.api.lifecycle | Lifecycle interfaces for all Components.
org.mule.api.model | Contains the interfaces for the Model and supporting objects such as the CompoenntResolver, EntryPointResolver, etc.
org.mule.api.object |
org.mule.api.processor |
org.mule.api.registry |
org.mule.api.routing | Interfaces that define inbound and outbound routing API.
org.mule.api.security | Security API for authentication and authorisation.
org.mule.api.security.tls | This package contains classes to support TLS/SSL configuration and socket creation.
org.mule.api.service |
org.mule.api.transformer | Contains the interfaces for transformers and exceptions for the Transformer API.
org.mule.api.transport | Contains the interfaces that comprise a provider implementation.
org.mule.client |
org.mule.component |
org.mule.component.simple | A collection of simple mule components that can be useful to simplify configuration while testing.
org.mule.config | Providers Mule Xml configuration support and general configuration classes.
org.mule.config.bootstrap |
org.mule.config.builders |
org.mule.config.dsl.routers |
org.mule.config.expression |
org.mule.config.spring | Support claases for Load Mule from Spring.
org.mule.config.spring.factories |
org.mule.config.spring.util |
org.mule.config.support |
org.mule.config.transformer |
org.mule.construct |
org.mule.construct.builder |
org.mule.context |
org.mule.context.notification | Internal server notification types fired via the MuleManager.
org.mule.endpoint | Implemtation of Mule endpoint uris.
org.mule.endpoint.dynamic |
org.mule.enricher |
org.mule.example.bookstore |
org.mule.example.bookstore.transformers |
org.mule.example.errorhandler |
org.mule.example.geomail.components |
org.mule.example.geomail.transformers |
org.mule.example.hello |
org.mule.example.loanbroker.routers |
org.mule.example.loanbroker.transformers |
org.mule.example.notifications |
org.mule.example.scripting |
org.mule.exception |
org.mule.expression.transformers |
org.mule.impl.model.resolvers |
org.mule.interceptor |
org.mule.lifecycle |
org.mule.lifecycle.phases |
org.mule.lifecycle.processor |
org.mule.model |
org.mule.model.seda |
org.mule.module.acegi |
org.mule.module.atom |
org.mule.module.atom.endpoint |
org.mule.module.atom.transformers |
org.mule.module.bpm |
org.mule.module.client | Simple interface for Mule clients to send and receive events from local or remote Mule Servers.
org.mule.module.client.remoting |
org.mule.module.cxf |
org.mule.module.cxf.builder |
org.mule.module.cxf.component |
org.mule.module.cxf.config |
org.mule.module.cxf.endpoint |
org.mule.module.guice |
org.mule.module.ibeans.config |
org.mule.module.ibeans.spi.support |
org.mule.module.jaas |
org.mule.module.jaas.filters |
org.mule.module.jbpm |
org.mule.module.jca | A Resource Adapter implementation that allows a Mule instance to be deployed to a J2ee application server and exposes Mule services via the JCA connector architecture.
org.mule.module.jersey |
org.mule.module.json.transformers | Transfromers for converting from JavaBeans and collections to JSON and back again.
org.mule.module.management.agent | Management agents including agents for Jdmk, MX4J, and Log4J
org.mule.module.management.mbean | Jmx Management beans for mule components, the model and the Mule server.
org.mule.module.ognl.expression |
org.mule.module.pgp |
org.mule.module.pgp.filters |
org.mule.module.rss.endpoint |
org.mule.module.rss.transformers |
org.mule.module.scripting.component | Base classes for script based components such as BeanShell or Groovy.
org.mule.module.scripting.expression |
org.mule.module.scripting.transformer |
org.mule.module.spring.events | A Spring EventMulticaster that allows any Spring bean to send and receive mule events through the ApplicationContext and event listeners.
org.mule.module.spring.remoting |
org.mule.module.spring.security |
org.mule.module.spring.security.filters.http |
org.mule.module.sxc |
org.mule.module.ws.config.spring.factories |
org.mule.module.ws.construct |
org.mule.module.xml.expression |
org.mule.module.xml.filters | Filters that apply specifically to xml using xml querying mechanisms.
org.mule.module.xml.routing |
org.mule.module.xml.transformer | Xml and Xslt Transformer implementations.
org.mule.module.xml.transformer.jaxb |
org.mule.module.xml.util |
org.mule.object |
org.mule.processor |
org.mule.processor.chain |
org.mule.registry |
org.mule.retry |
org.mule.routing | Defines the core routing patterns supported by mule.
org.mule.routing.outbound | Outbound router implementation as described in the Enterprise Integration Patterns book.
org.mule.routing.requestreply |
org.mule.security | Core security implementation including the mule security manager and encryption types
org.mule.security.filters | Core sercurity filter types.
org.mule.service |
org.mule.source |
org.mule.tck.functional | Helper classes and interfaces used by Mule fnctional tests.
org.mule.tck.security |
org.mule.tck.testmodels.services |
org.mule.tck.transformer |
org.mule.transaction.lookup |
org.mule.transformer | Provides the default transformer base implementations for Mule including compression and encryption support.
org.mule.transformer.codec | Transformers for Base64, UC and UU encoding/decoding.
org.mule.transformer.compression | Transformers for compressing and uncompressing message payloads.
org.mule.transformer.encryption | Transformers for encrypting and decrypting message payloads.
org.mule.transformer.simple | Basic transformer implementations.
org.mule.transport | Contains Abstract classes providing common functionality for all Mule providers.
org.mule.transport.ajax |
org.mule.transport.ajax.container | A AJAX transport allows Mule applications to send a receive events to the web browser.
org.mule.transport.ajax.embedded | A AJAX transport allows Mule applications to send a receive events to the web browser.
org.mule.transport.ejb |
org.mule.transport.email | Provides pop3, smtp and imap connectivity for Mule.
org.mule.transport.email.transformers | Contains transformers to convert to and from the java.mail.Message type.
org.mule.transport.file | Provides file transport in the form of a directory listeners and file dispatchers.
org.mule.transport.file.transformers | Transformers for converting to and from the FileMessage type.
org.mule.transport.ftp |
org.mule.transport.http | Provides http transport including proxy support.
org.mule.transport.http.components |
org.mule.transport.http.transformers |
org.mule.transport.ibean |
org.mule.transport.jdbc | Provides jdbc transport.
org.mule.transport.jms | Provides Jms transport connectivity with support for all Jms features.
org.mule.transport.jms.activemq | Provides Jms connectivity with ActiveMQ-specific workarounds and improvements.
org.mule.transport.jms.mulemq |
org.mule.transport.jms.transformers | Contains transformers to convert to and from different javax.jms.Message types
org.mule.transport.jms.weblogic | Provides Jms connectivity with Weblogic-specific workarounds and improvements.
org.mule.transport.jms.websphere | Provides Jms connectivity with Websphere-specific workarounds and improvements.
org.mule.transport.jnp |
org.mule.transport.multicast | IP multicast connectivity for Mule.
org.mule.transport.polling |
org.mule.transport.quartz |
org.mule.transport.quartz.jobs |
org.mule.transport.rmi |
org.mule.transport.servlet |
org.mule.transport.servlet.jetty |
org.mule.transport.servlet.transformers |
org.mule.transport.soap.axis | Provides an Axis soap transport for Mule.
org.mule.transport.soap.axis.wsdl |
org.mule.transport.ssl | Provides tcp connectivity over Ssl for Mule.
org.mule.transport.stdio |
org.mule.transport.tcp | Provides tcp connectivity for Mule.
org.mule.transport.udp | Provides Udp connectivity for Mule.
org.mule.transport.vm | A connector implementation allowing events to be passed between Mule sessions via in-memory queues.
org.mule.transport.xmpp |
org.mule.transport.xmpp.transformers |
org.mule.util.monitor | Various resource monitor implementations.
org.mule.util.pool |
org.mule.util.queue | A resource manager that allow access to transactional queues with optional persistence.
org.mule.util.store |
org.mule.work | A javax.resource.spi.WorkManager implementation.

Classes in org.mule.api.lifecycle used by org.mule
Disposable `Disposable` is a lifecycle interface that gets called at the dispose lifecycle stage of the implementing service as the service is being destroyed.
Initialisable `Initialisable` is a lifecycle interface that gets called at the initialise lifecycle stage of the implementing service.
InitialisationException `InitialisationException` is thrown by the initialise method defined in the `org.mule.api.lifecycle.Initialisable` interface.
Lifecycle `DefaultLifecyclePhase` adds lifecycle methods `start`, `stop` and `dispose`.
LifecycleManager The LifecycleManager is responsible for managing the different lifecycle phases of the server and managing the transitions between lifecycle phases.
Startable `Startable` provides an object with a `Startable.start()` method which gets called when the Mule instance gets started.
Stoppable `Stoppable` is a lifecycle interfaqce that introduces a `Stoppable.stop()` method to an object.

Classes in org.mule.api.lifecycle used by org.mule.agent
Disposable `Disposable` is a lifecycle interface that gets called at the dispose lifecycle stage of the implementing service as the service is being destroyed.
Initialisable `Initialisable` is a lifecycle interface that gets called at the initialise lifecycle stage of the implementing service.
InitialisationException `InitialisationException` is thrown by the initialise method defined in the `org.mule.api.lifecycle.Initialisable` interface.
Lifecycle `DefaultLifecyclePhase` adds lifecycle methods `start`, `stop` and `dispose`.
Startable `Startable` provides an object with a `Startable.start()` method which gets called when the Mule instance gets started.
Stoppable `Stoppable` is a lifecycle interfaqce that introduces a `Stoppable.stop()` method to an object.

Classes in org.mule.api.lifecycle used by org.mule.api
Disposable `Disposable` is a lifecycle interface that gets called at the dispose lifecycle stage of the implementing service as the service is being destroyed.
Initialisable `Initialisable` is a lifecycle interface that gets called at the initialise lifecycle stage of the implementing service.
InitialisationException `InitialisationException` is thrown by the initialise method defined in the `org.mule.api.lifecycle.Initialisable` interface.
Lifecycle `DefaultLifecyclePhase` adds lifecycle methods `start`, `stop` and `dispose`.
LifecycleManager The LifecycleManager is responsible for managing the different lifecycle phases of the server and managing the transitions between lifecycle phases.
Startable `Startable` provides an object with a `Startable.start()` method which gets called when the Mule instance gets started.
Stoppable `Stoppable` is a lifecycle interfaqce that introduces a `Stoppable.stop()` method to an object.

Classes in org.mule.api.lifecycle used by org.mule.api.agent
Disposable `Disposable` is a lifecycle interface that gets called at the dispose lifecycle stage of the implementing service as the service is being destroyed.
Initialisable `Initialisable` is a lifecycle interface that gets called at the initialise lifecycle stage of the implementing service.
Lifecycle `DefaultLifecyclePhase` adds lifecycle methods `start`, `stop` and `dispose`.
Startable `Startable` provides an object with a `Startable.start()` method which gets called when the Mule instance gets started.
Stoppable `Stoppable` is a lifecycle interfaqce that introduces a `Stoppable.stop()` method to an object.

Classes in org.mule.api.lifecycle used by org.mule.api.component
Disposable `Disposable` is a lifecycle interface that gets called at the dispose lifecycle stage of the implementing service as the service is being destroyed.
Initialisable `Initialisable` is a lifecycle interface that gets called at the initialise lifecycle stage of the implementing service.
Lifecycle `DefaultLifecyclePhase` adds lifecycle methods `start`, `stop` and `dispose`.
Startable `Startable` provides an object with a `Startable.start()` method which gets called when the Mule instance gets started.
Stoppable `Stoppable` is a lifecycle interfaqce that introduces a `Stoppable.stop()` method to an object.

Classes in org.mule.api.lifecycle used by org.mule.api.construct
LifecycleStateEnabled Objects that have an associated lifecycle manager such as `Service` or `Connector` should implement this interface so that the registry lifecycle manager can introspect the lifecycle state of an object.

Classes in org.mule.api.lifecycle used by org.mule.api.context
Disposable `Disposable` is a lifecycle interface that gets called at the dispose lifecycle stage of the implementing service as the service is being destroyed.
InitialisationException `InitialisationException` is thrown by the initialise method defined in the `org.mule.api.lifecycle.Initialisable` interface.
LifecycleManager The LifecycleManager is responsible for managing the different lifecycle phases of the server and managing the transitions between lifecycle phases.
Startable `Startable` provides an object with a `Startable.start()` method which gets called when the Mule instance gets started.

Classes in org.mule.api.lifecycle used by org.mule.api.endpoint
Initialisable `Initialisable` is a lifecycle interface that gets called at the initialise lifecycle stage of the implementing service.
InitialisationException `InitialisationException` is thrown by the initialise method defined in the `org.mule.api.lifecycle.Initialisable` interface.
Startable `Startable` provides an object with a `Startable.start()` method which gets called when the Mule instance gets started.
Stoppable `Stoppable` is a lifecycle interfaqce that introduces a `Stoppable.stop()` method to an object.

Classes in org.mule.api.lifecycle used by org.mule.api.lifecycle
Disposable `Disposable` is a lifecycle interface that gets called at the dispose lifecycle stage of the implementing service as the service is being destroyed.
EventListener `EventListener` is a marker interface that is implemented by objects wishing to receive Mule events in managed environments, such as an EJB container.
Initialisable `Initialisable` is a lifecycle interface that gets called at the initialise lifecycle stage of the implementing service.
InitialisationException `InitialisationException` is thrown by the initialise method defined in the `org.mule.api.lifecycle.Initialisable` interface.
LifecycleException `LifecycleException` TODO
LifecycleState A safe facade for lifecycle manager that objects can use to monitor its own state
Startable `Startable` provides an object with a `Startable.start()` method which gets called when the Mule instance gets started.
Stoppable `Stoppable` is a lifecycle interfaqce that introduces a `Stoppable.stop()` method to an object.

Classes in org.mule.api.lifecycle used by org.mule.api.model
Disposable `Disposable` is a lifecycle interface that gets called at the dispose lifecycle stage of the implementing service as the service is being destroyed.
Initialisable `Initialisable` is a lifecycle interface that gets called at the initialise lifecycle stage of the implementing service.
Lifecycle `DefaultLifecyclePhase` adds lifecycle methods `start`, `stop` and `dispose`.
LifecycleStateEnabled Objects that have an associated lifecycle manager such as `Service` or `Connector` should implement this interface so that the registry lifecycle manager can introspect the lifecycle state of an object.
Startable `Startable` provides an object with a `Startable.start()` method which gets called when the Mule instance gets started.
Stoppable `Stoppable` is a lifecycle interfaqce that introduces a `Stoppable.stop()` method to an object.

Classes in org.mule.api.lifecycle used by org.mule.api.object
Disposable `Disposable` is a lifecycle interface that gets called at the dispose lifecycle stage of the implementing service as the service is being destroyed.
Initialisable `Initialisable` is a lifecycle interface that gets called at the initialise lifecycle stage of the implementing service.
InitialisationCallback `InitialisationCallback` is used to provide customised initialiation for more complex components.

Classes in org.mule.api.lifecycle used by org.mule.api.processor
Initialisable `Initialisable` is a lifecycle interface that gets called at the initialise lifecycle stage of the implementing service.
InitialisationException `InitialisationException` is thrown by the initialise method defined in the `org.mule.api.lifecycle.Initialisable` interface.

Classes in org.mule.api.lifecycle used by org.mule.api.registry
Disposable `Disposable` is a lifecycle interface that gets called at the dispose lifecycle stage of the implementing service as the service is being destroyed.
Initialisable `Initialisable` is a lifecycle interface that gets called at the initialise lifecycle stage of the implementing service.
LifecycleException `LifecycleException` TODO

Classes in org.mule.api.lifecycle used by org.mule.api.routing
Disposable `Disposable` is a lifecycle interface that gets called at the dispose lifecycle stage of the implementing service as the service is being destroyed.
Initialisable `Initialisable` is a lifecycle interface that gets called at the initialise lifecycle stage of the implementing service.
Lifecycle `DefaultLifecyclePhase` adds lifecycle methods `start`, `stop` and `dispose`.
Startable `Startable` provides an object with a `Startable.start()` method which gets called when the Mule instance gets started.
Stoppable `Stoppable` is a lifecycle interfaqce that introduces a `Stoppable.stop()` method to an object.

Classes in org.mule.api.lifecycle used by org.mule.api.security
Initialisable `Initialisable` is a lifecycle interface that gets called at the initialise lifecycle stage of the implementing service.
InitialisationException `InitialisationException` is thrown by the initialise method defined in the `org.mule.api.lifecycle.Initialisable` interface.

Classes in org.mule.api.lifecycle used by org.mule.api.security.tls
CreateException `CreateException` is thrown when creating an object inside Mule wasn't possible due to inconsistent internal state or wrong input.

Classes in org.mule.api.lifecycle used by org.mule.api.service
Disposable `Disposable` is a lifecycle interface that gets called at the dispose lifecycle stage of the implementing service as the service is being destroyed.
Initialisable `Initialisable` is a lifecycle interface that gets called at the initialise lifecycle stage of the implementing service.
Lifecycle `DefaultLifecyclePhase` adds lifecycle methods `start`, `stop` and `dispose`.
LifecycleManager The LifecycleManager is responsible for managing the different lifecycle phases of the server and managing the transitions between lifecycle phases.
LifecycleStateEnabled Objects that have an associated lifecycle manager such as `Service` or `Connector` should implement this interface so that the registry lifecycle manager can introspect the lifecycle state of an object.
Startable `Startable` provides an object with a `Startable.start()` method which gets called when the Mule instance gets started.
Stoppable `Stoppable` is a lifecycle interfaqce that introduces a `Stoppable.stop()` method to an object.

Classes in org.mule.api.lifecycle used by org.mule.api.transformer
Disposable `Disposable` is a lifecycle interface that gets called at the dispose lifecycle stage of the implementing service as the service is being destroyed.
Initialisable `Initialisable` is a lifecycle interface that gets called at the initialise lifecycle stage of the implementing service.

Classes in org.mule.api.lifecycle used by org.mule.api.transport
CreateException `CreateException` is thrown when creating an object inside Mule wasn't possible due to inconsistent internal state or wrong input.
Disposable `Disposable` is a lifecycle interface that gets called at the dispose lifecycle stage of the implementing service as the service is being destroyed.
Initialisable `Initialisable` is a lifecycle interface that gets called at the initialise lifecycle stage of the implementing service.
Lifecycle `DefaultLifecyclePhase` adds lifecycle methods `start`, `stop` and `dispose`.
LifecycleStateEnabled Objects that have an associated lifecycle manager such as `Service` or `Connector` should implement this interface so that the registry lifecycle manager can introspect the lifecycle state of an object.
Startable `Startable` provides an object with a `Startable.start()` method which gets called when the Mule instance gets started.
Stoppable `Stoppable` is a lifecycle interfaqce that introduces a `Stoppable.stop()` method to an object.

Classes in org.mule.api.lifecycle used by org.mule.client
LifecycleState A safe facade for lifecycle manager that objects can use to monitor its own state
LifecycleStateEnabled Objects that have an associated lifecycle manager such as `Service` or `Connector` should implement this interface so that the registry lifecycle manager can introspect the lifecycle state of an object.

Classes in org.mule.api.lifecycle used by org.mule.component
Callable `Callable` is used to provide a Service with an interface that supports event calls.
Disposable `Disposable` is a lifecycle interface that gets called at the dispose lifecycle stage of the implementing service as the service is being destroyed.
Initialisable `Initialisable` is a lifecycle interface that gets called at the initialise lifecycle stage of the implementing service.
InitialisationCallback `InitialisationCallback` is used to provide customised initialiation for more complex components.
InitialisationException `InitialisationException` is thrown by the initialise method defined in the `org.mule.api.lifecycle.Initialisable` interface.
Lifecycle `DefaultLifecyclePhase` adds lifecycle methods `start`, `stop` and `dispose`.
Startable `Startable` provides an object with a `Startable.start()` method which gets called when the Mule instance gets started.
Stoppable `Stoppable` is a lifecycle interfaqce that introduces a `Stoppable.stop()` method to an object.

Classes in org.mule.api.lifecycle used by org.mule.component.simple
Callable `Callable` is used to provide a Service with an interface that supports event calls.
Disposable `Disposable` is a lifecycle interface that gets called at the dispose lifecycle stage of the implementing service as the service is being destroyed.
EventListener `EventListener` is a marker interface that is implemented by objects wishing to receive Mule events in managed environments, such as an EJB container.
Initialisable `Initialisable` is a lifecycle interface that gets called at the initialise lifecycle stage of the implementing service.
InitialisationException `InitialisationException` is thrown by the initialise method defined in the `org.mule.api.lifecycle.Initialisable` interface.
Lifecycle `DefaultLifecyclePhase` adds lifecycle methods `start`, `stop` and `dispose`.
Startable `Startable` provides an object with a `Startable.start()` method which gets called when the Mule instance gets started.
Stoppable `Stoppable` is a lifecycle interfaqce that introduces a `Stoppable.stop()` method to an object.

Classes in org.mule.api.lifecycle used by org.mule.config
FatalException `FatalException` can be thrown during initialisation or during execution to indicate that something fatal has occurred and the MuleManager must shutdown.
InitialisationException `InitialisationException` is thrown by the initialise method defined in the `org.mule.api.lifecycle.Initialisable` interface.

Classes in org.mule.api.lifecycle used by org.mule.config.bootstrap
Initialisable `Initialisable` is a lifecycle interface that gets called at the initialise lifecycle stage of the implementing service.
InitialisationException `InitialisationException` is thrown by the initialise method defined in the `org.mule.api.lifecycle.Initialisable` interface.

Classes in org.mule.api.lifecycle used by org.mule.config.builders
InitialisationException `InitialisationException` is thrown by the initialise method defined in the `org.mule.api.lifecycle.Initialisable` interface.
LifecycleManager The LifecycleManager is responsible for managing the different lifecycle phases of the server and managing the transitions between lifecycle phases.

Classes in org.mule.api.lifecycle used by org.mule.config.dsl.routers
Disposable `Disposable` is a lifecycle interface that gets called at the dispose lifecycle stage of the implementing service as the service is being destroyed.
Initialisable `Initialisable` is a lifecycle interface that gets called at the initialise lifecycle stage of the implementing service.
Lifecycle `DefaultLifecyclePhase` adds lifecycle methods `start`, `stop` and `dispose`.
Startable `Startable` provides an object with a `Startable.start()` method which gets called when the Mule instance gets started.
Stoppable `Stoppable` is a lifecycle interfaqce that introduces a `Stoppable.stop()` method to an object.

Classes in org.mule.api.lifecycle used by org.mule.config.expression
InitialisationException `InitialisationException` is thrown by the initialise method defined in the `org.mule.api.lifecycle.Initialisable` interface.

Classes in org.mule.api.lifecycle used by org.mule.config.spring
Disposable `Disposable` is a lifecycle interface that gets called at the dispose lifecycle stage of the implementing service as the service is being destroyed.
Initialisable `Initialisable` is a lifecycle interface that gets called at the initialise lifecycle stage of the implementing service.
InitialisationException `InitialisationException` is thrown by the initialise method defined in the `org.mule.api.lifecycle.Initialisable` interface.
LifecycleManager The LifecycleManager is responsible for managing the different lifecycle phases of the server and managing the transitions between lifecycle phases.

Classes in org.mule.api.lifecycle used by org.mule.config.spring.factories
Initialisable `Initialisable` is a lifecycle interface that gets called at the initialise lifecycle stage of the implementing service.
InitialisationException `InitialisationException` is thrown by the initialise method defined in the `org.mule.api.lifecycle.Initialisable` interface.

Classes in org.mule.api.lifecycle used by org.mule.config.spring.util
Disposable `Disposable` is a lifecycle interface that gets called at the dispose lifecycle stage of the implementing service as the service is being destroyed.
Initialisable `Initialisable` is a lifecycle interface that gets called at the initialise lifecycle stage of the implementing service.
InitialisationException `InitialisationException` is thrown by the initialise method defined in the `org.mule.api.lifecycle.Initialisable` interface.

Classes in org.mule.api.lifecycle used by org.mule.config.support
Disposable `Disposable` is a lifecycle interface that gets called at the dispose lifecycle stage of the implementing service as the service is being destroyed.
Initialisable `Initialisable` is a lifecycle interface that gets called at the initialise lifecycle stage of the implementing service.
Lifecycle `DefaultLifecyclePhase` adds lifecycle methods `start`, `stop` and `dispose`.
LifecycleStateEnabled Objects that have an associated lifecycle manager such as `Service` or `Connector` should implement this interface so that the registry lifecycle manager can introspect the lifecycle state of an object.
Startable `Startable` provides an object with a `Startable.start()` method which gets called when the Mule instance gets started.
Stoppable `Stoppable` is a lifecycle interfaqce that introduces a `Stoppable.stop()` method to an object.

Classes in org.mule.api.lifecycle used by org.mule.config.transformer
Disposable `Disposable` is a lifecycle interface that gets called at the dispose lifecycle stage of the implementing service as the service is being destroyed.
Initialisable `Initialisable` is a lifecycle interface that gets called at the initialise lifecycle stage of the implementing service.
InitialisationException `InitialisationException` is thrown by the initialise method defined in the `org.mule.api.lifecycle.Initialisable` interface.

Classes in org.mule.api.lifecycle used by org.mule.construct
Disposable `Disposable` is a lifecycle interface that gets called at the dispose lifecycle stage of the implementing service as the service is being destroyed.
Initialisable `Initialisable` is a lifecycle interface that gets called at the initialise lifecycle stage of the implementing service.
InitialisationException `InitialisationException` is thrown by the initialise method defined in the `org.mule.api.lifecycle.Initialisable` interface.
Lifecycle `DefaultLifecyclePhase` adds lifecycle methods `start`, `stop` and `dispose`.
LifecycleCallback This callback is used to execute lifecycle behaviour for an object being managed by a `LifecycleManager` The callback is used so that transitions can be managed consistently outside of an object
LifecycleManager The LifecycleManager is responsible for managing the different lifecycle phases of the server and managing the transitions between lifecycle phases.
LifecycleState A safe facade for lifecycle manager that objects can use to monitor its own state
LifecycleStateEnabled Objects that have an associated lifecycle manager such as `Service` or `Connector` should implement this interface so that the registry lifecycle manager can introspect the lifecycle state of an object.
Startable `Startable` provides an object with a `Startable.start()` method which gets called when the Mule instance gets started.
Stoppable `Stoppable` is a lifecycle interfaqce that introduces a `Stoppable.stop()` method to an object.

Classes in org.mule.api.lifecycle used by org.mule.construct.builder
Callable `Callable` is used to provide a Service with an interface that supports event calls.

Classes in org.mule.api.lifecycle used by org.mule.context
InitialisationException `InitialisationException` is thrown by the initialise method defined in the `org.mule.api.lifecycle.Initialisable` interface.
LifecycleManager The LifecycleManager is responsible for managing the different lifecycle phases of the server and managing the transitions between lifecycle phases.

Classes in org.mule.api.lifecycle used by org.mule.context.notification
Disposable `Disposable` is a lifecycle interface that gets called at the dispose lifecycle stage of the implementing service as the service is being destroyed.
LifecycleException `LifecycleException` TODO

Classes in org.mule.api.lifecycle used by org.mule.endpoint
Disposable `Disposable` is a lifecycle interface that gets called at the dispose lifecycle stage of the implementing service as the service is being destroyed.
Initialisable `Initialisable` is a lifecycle interface that gets called at the initialise lifecycle stage of the implementing service.
InitialisationException `InitialisationException` is thrown by the initialise method defined in the `org.mule.api.lifecycle.Initialisable` interface.
Startable `Startable` provides an object with a `Startable.start()` method which gets called when the Mule instance gets started.
Stoppable `Stoppable` is a lifecycle interfaqce that introduces a `Stoppable.stop()` method to an object.

Classes in org.mule.api.lifecycle used by org.mule.endpoint.dynamic
Disposable `Disposable` is a lifecycle interface that gets called at the dispose lifecycle stage of the implementing service as the service is being destroyed.
Initialisable `Initialisable` is a lifecycle interface that gets called at the initialise lifecycle stage of the implementing service.
InitialisationException `InitialisationException` is thrown by the initialise method defined in the `org.mule.api.lifecycle.Initialisable` interface.
Lifecycle `DefaultLifecyclePhase` adds lifecycle methods `start`, `stop` and `dispose`.
LifecycleStateEnabled Objects that have an associated lifecycle manager such as `Service` or `Connector` should implement this interface so that the registry lifecycle manager can introspect the lifecycle state of an object.
Startable `Startable` provides an object with a `Startable.start()` method which gets called when the Mule instance gets started.
Stoppable `Stoppable` is a lifecycle interfaqce that introduces a `Stoppable.stop()` method to an object.

Classes in org.mule.api.lifecycle used by org.mule.enricher
Disposable `Disposable` is a lifecycle interface that gets called at the dispose lifecycle stage of the implementing service as the service is being destroyed.
Initialisable `Initialisable` is a lifecycle interface that gets called at the initialise lifecycle stage of the implementing service.
Lifecycle `DefaultLifecyclePhase` adds lifecycle methods `start`, `stop` and `dispose`.
Startable `Startable` provides an object with a `Startable.start()` method which gets called when the Mule instance gets started.
Stoppable `Stoppable` is a lifecycle interfaqce that introduces a `Stoppable.stop()` method to an object.

Classes in org.mule.api.lifecycle used by org.mule.example.bookstore
Initialisable `Initialisable` is a lifecycle interface that gets called at the initialise lifecycle stage of the implementing service.
InitialisationException `InitialisationException` is thrown by the initialise method defined in the `org.mule.api.lifecycle.Initialisable` interface.

Classes in org.mule.api.lifecycle used by org.mule.example.bookstore.transformers
Disposable `Disposable` is a lifecycle interface that gets called at the dispose lifecycle stage of the implementing service as the service is being destroyed.
Initialisable `Initialisable` is a lifecycle interface that gets called at the initialise lifecycle stage of the implementing service.

Classes in org.mule.api.lifecycle used by org.mule.example.errorhandler
Callable `Callable` is used to provide a Service with an interface that supports event calls.
Disposable `Disposable` is a lifecycle interface that gets called at the dispose lifecycle stage of the implementing service as the service is being destroyed.
EventListener `EventListener` is a marker interface that is implemented by objects wishing to receive Mule events in managed environments, such as an EJB container.
Initialisable `Initialisable` is a lifecycle interface that gets called at the initialise lifecycle stage of the implementing service.

Classes in org.mule.api.lifecycle used by org.mule.example.geomail.components
Callable `Callable` is used to provide a Service with an interface that supports event calls.
EventListener `EventListener` is a marker interface that is implemented by objects wishing to receive Mule events in managed environments, such as an EJB container.

Classes in org.mule.api.lifecycle used by org.mule.example.geomail.transformers
Disposable `Disposable` is a lifecycle interface that gets called at the dispose lifecycle stage of the implementing service as the service is being destroyed.
Initialisable `Initialisable` is a lifecycle interface that gets called at the initialise lifecycle stage of the implementing service.

Classes in org.mule.api.lifecycle used by org.mule.example.hello
Disposable `Disposable` is a lifecycle interface that gets called at the dispose lifecycle stage of the implementing service as the service is being destroyed.
Initialisable `Initialisable` is a lifecycle interface that gets called at the initialise lifecycle stage of the implementing service.

Classes in org.mule.api.lifecycle used by org.mule.example.loanbroker.routers
Initialisable `Initialisable` is a lifecycle interface that gets called at the initialise lifecycle stage of the implementing service.

Classes in org.mule.api.lifecycle used by org.mule.example.loanbroker.transformers
Disposable `Disposable` is a lifecycle interface that gets called at the dispose lifecycle stage of the implementing service as the service is being destroyed.
Initialisable `Initialisable` is a lifecycle interface that gets called at the initialise lifecycle stage of the implementing service.

Classes in org.mule.api.lifecycle used by org.mule.example.notifications
Disposable `Disposable` is a lifecycle interface that gets called at the dispose lifecycle stage of the implementing service as the service is being destroyed.
Initialisable `Initialisable` is a lifecycle interface that gets called at the initialise lifecycle stage of the implementing service.
InitialisationException `InitialisationException` is thrown by the initialise method defined in the `org.mule.api.lifecycle.Initialisable` interface.
Lifecycle `DefaultLifecyclePhase` adds lifecycle methods `start`, `stop` and `dispose`.
Startable `Startable` provides an object with a `Startable.start()` method which gets called when the Mule instance gets started.
Stoppable `Stoppable` is a lifecycle interfaqce that introduces a `Stoppable.stop()` method to an object.

Classes in org.mule.api.lifecycle used by org.mule.example.scripting
Callable `Callable` is used to provide a Service with an interface that supports event calls.
Disposable `Disposable` is a lifecycle interface that gets called at the dispose lifecycle stage of the implementing service as the service is being destroyed.
EventListener `EventListener` is a marker interface that is implemented by objects wishing to receive Mule events in managed environments, such as an EJB container.
Initialisable `Initialisable` is a lifecycle interface that gets called at the initialise lifecycle stage of the implementing service.

Classes in org.mule.api.lifecycle used by org.mule.exception
Disposable `Disposable` is a lifecycle interface that gets called at the dispose lifecycle stage of the implementing service as the service is being destroyed.
Initialisable `Initialisable` is a lifecycle interface that gets called at the initialise lifecycle stage of the implementing service.
InitialisationException `InitialisationException` is thrown by the initialise method defined in the `org.mule.api.lifecycle.Initialisable` interface.
Lifecycle `DefaultLifecyclePhase` adds lifecycle methods `start`, `stop` and `dispose`.
Startable `Startable` provides an object with a `Startable.start()` method which gets called when the Mule instance gets started.
Stoppable `Stoppable` is a lifecycle interfaqce that introduces a `Stoppable.stop()` method to an object.

Classes in org.mule.api.lifecycle used by org.mule.expression.transformers
Disposable `Disposable` is a lifecycle interface that gets called at the dispose lifecycle stage of the implementing service as the service is being destroyed.
Initialisable `Initialisable` is a lifecycle interface that gets called at the initialise lifecycle stage of the implementing service.
InitialisationException `InitialisationException` is thrown by the initialise method defined in the `org.mule.api.lifecycle.Initialisable` interface.

Classes in org.mule.api.lifecycle used by org.mule.impl.model.resolvers
InitialisationException `InitialisationException` is thrown by the initialise method defined in the `org.mule.api.lifecycle.Initialisable` interface.

Classes in org.mule.api.lifecycle used by org.mule.interceptor
Disposable `Disposable` is a lifecycle interface that gets called at the dispose lifecycle stage of the implementing service as the service is being destroyed.
Initialisable `Initialisable` is a lifecycle interface that gets called at the initialise lifecycle stage of the implementing service.
InitialisationException `InitialisationException` is thrown by the initialise method defined in the `org.mule.api.lifecycle.Initialisable` interface.

Classes in org.mule.api.lifecycle used by org.mule.lifecycle
LifecycleCallback This callback is used to execute lifecycle behaviour for an object being managed by a `LifecycleManager` The callback is used so that transitions can be managed consistently outside of an object
LifecycleException `LifecycleException` TODO
LifecycleManager The LifecycleManager is responsible for managing the different lifecycle phases of the server and managing the transitions between lifecycle phases.
LifecyclePhase Encapsulates the notion of a lifecycle phase i.e.
LifecycleState A safe facade for lifecycle manager that objects can use to monitor its own state
RegistryLifecycleHelpers This interface defines additional Registry Lifecycle methods to enable extenral objects to have there lifecycle managed by the registry.

Classes in org.mule.api.lifecycle used by org.mule.lifecycle.phases
LifecycleException `LifecycleException` TODO
LifecyclePhase Encapsulates the notion of a lifecycle phase i.e.

Classes in org.mule.api.lifecycle used by org.mule.lifecycle.processor
LifecycleException `LifecycleException` TODO
LifecycleState A safe facade for lifecycle manager that objects can use to monitor its own state
Startable `Startable` provides an object with a `Startable.start()` method which gets called when the Mule instance gets started.

Classes in org.mule.api.lifecycle used by org.mule.model
Disposable `Disposable` is a lifecycle interface that gets called at the dispose lifecycle stage of the implementing service as the service is being destroyed.
Initialisable `Initialisable` is a lifecycle interface that gets called at the initialise lifecycle stage of the implementing service.
InitialisationException `InitialisationException` is thrown by the initialise method defined in the `org.mule.api.lifecycle.Initialisable` interface.
Lifecycle `DefaultLifecyclePhase` adds lifecycle methods `start`, `stop` and `dispose`.
LifecycleCallback This callback is used to execute lifecycle behaviour for an object being managed by a `LifecycleManager` The callback is used so that transitions can be managed consistently outside of an object
LifecycleManager The LifecycleManager is responsible for managing the different lifecycle phases of the server and managing the transitions between lifecycle phases.
LifecycleState A safe facade for lifecycle manager that objects can use to monitor its own state
LifecycleStateEnabled Objects that have an associated lifecycle manager such as `Service` or `Connector` should implement this interface so that the registry lifecycle manager can introspect the lifecycle state of an object.
Startable `Startable` provides an object with a `Startable.start()` method which gets called when the Mule instance gets started.
Stoppable `Stoppable` is a lifecycle interfaqce that introduces a `Stoppable.stop()` method to an object.

Classes in org.mule.api.lifecycle used by org.mule.model.seda
Disposable `Disposable` is a lifecycle interface that gets called at the dispose lifecycle stage of the implementing service as the service is being destroyed.
Initialisable `Initialisable` is a lifecycle interface that gets called at the initialise lifecycle stage of the implementing service.
InitialisationException `InitialisationException` is thrown by the initialise method defined in the `org.mule.api.lifecycle.Initialisable` interface.
Lifecycle `DefaultLifecyclePhase` adds lifecycle methods `start`, `stop` and `dispose`.
LifecycleStateEnabled Objects that have an associated lifecycle manager such as `Service` or `Connector` should implement this interface so that the registry lifecycle manager can introspect the lifecycle state of an object.
Startable `Startable` provides an object with a `Startable.start()` method which gets called when the Mule instance gets started.
Stoppable `Stoppable` is a lifecycle interfaqce that introduces a `Stoppable.stop()` method to an object.

Classes in org.mule.api.lifecycle used by org.mule.module.acegi
Initialisable `Initialisable` is a lifecycle interface that gets called at the initialise lifecycle stage of the implementing service.
InitialisationException `InitialisationException` is thrown by the initialise method defined in the `org.mule.api.lifecycle.Initialisable` interface.

Classes in org.mule.api.lifecycle used by org.mule.module.atom
Callable `Callable` is used to provide a Service with an interface that supports event calls.
Disposable `Disposable` is a lifecycle interface that gets called at the dispose lifecycle stage of the implementing service as the service is being destroyed.
EventListener `EventListener` is a marker interface that is implemented by objects wishing to receive Mule events in managed environments, such as an EJB container.
Initialisable `Initialisable` is a lifecycle interface that gets called at the initialise lifecycle stage of the implementing service.
Lifecycle `DefaultLifecyclePhase` adds lifecycle methods `start`, `stop` and `dispose`.
Startable `Startable` provides an object with a `Startable.start()` method which gets called when the Mule instance gets started.
Stoppable `Stoppable` is a lifecycle interfaqce that introduces a `Stoppable.stop()` method to an object.

Classes in org.mule.api.lifecycle used by org.mule.module.atom.endpoint
Disposable `Disposable` is a lifecycle interface that gets called at the dispose lifecycle stage of the implementing service as the service is being destroyed.
InitialisationException `InitialisationException` is thrown by the initialise method defined in the `org.mule.api.lifecycle.Initialisable` interface.
Startable `Startable` provides an object with a `Startable.start()` method which gets called when the Mule instance gets started.
Stoppable `Stoppable` is a lifecycle interfaqce that introduces a `Stoppable.stop()` method to an object.

Classes in org.mule.api.lifecycle used by org.mule.module.atom.transformers
Disposable `Disposable` is a lifecycle interface that gets called at the dispose lifecycle stage of the implementing service as the service is being destroyed.
Initialisable `Initialisable` is a lifecycle interface that gets called at the initialise lifecycle stage of the implementing service.

Classes in org.mule.api.lifecycle used by org.mule.module.bpm
Disposable `Disposable` is a lifecycle interface that gets called at the dispose lifecycle stage of the implementing service as the service is being destroyed.
Initialisable `Initialisable` is a lifecycle interface that gets called at the initialise lifecycle stage of the implementing service.
InitialisationException `InitialisationException` is thrown by the initialise method defined in the `org.mule.api.lifecycle.Initialisable` interface.
Lifecycle `DefaultLifecyclePhase` adds lifecycle methods `start`, `stop` and `dispose`.
Startable `Startable` provides an object with a `Startable.start()` method which gets called when the Mule instance gets started.
Stoppable `Stoppable` is a lifecycle interfaqce that introduces a `Stoppable.stop()` method to an object.

Classes in org.mule.api.lifecycle used by org.mule.module.client
Disposable `Disposable` is a lifecycle interface that gets called at the dispose lifecycle stage of the implementing service as the service is being destroyed.
Initialisable `Initialisable` is a lifecycle interface that gets called at the initialise lifecycle stage of the implementing service.
InitialisationException `InitialisationException` is thrown by the initialise method defined in the `org.mule.api.lifecycle.Initialisable` interface.

Classes in org.mule.api.lifecycle used by org.mule.module.client.remoting
Callable `Callable` is used to provide a Service with an interface that supports event calls.
Disposable `Disposable` is a lifecycle interface that gets called at the dispose lifecycle stage of the implementing service as the service is being destroyed.
EventListener `EventListener` is a marker interface that is implemented by objects wishing to receive Mule events in managed environments, such as an EJB container.
Initialisable `Initialisable` is a lifecycle interface that gets called at the initialise lifecycle stage of the implementing service.
InitialisationException `InitialisationException` is thrown by the initialise method defined in the `org.mule.api.lifecycle.Initialisable` interface.
Lifecycle `DefaultLifecyclePhase` adds lifecycle methods `start`, `stop` and `dispose`.
Startable `Startable` provides an object with a `Startable.start()` method which gets called when the Mule instance gets started.
Stoppable `Stoppable` is a lifecycle interfaqce that introduces a `Stoppable.stop()` method to an object.

Classes in org.mule.api.lifecycle used by org.mule.module.cxf
Callable `Callable` is used to provide a Service with an interface that supports event calls.
Disposable `Disposable` is a lifecycle interface that gets called at the dispose lifecycle stage of the implementing service as the service is being destroyed.
EventListener `EventListener` is a marker interface that is implemented by objects wishing to receive Mule events in managed environments, such as an EJB container.
Initialisable `Initialisable` is a lifecycle interface that gets called at the initialise lifecycle stage of the implementing service.
InitialisationException `InitialisationException` is thrown by the initialise method defined in the `org.mule.api.lifecycle.Initialisable` interface.
Lifecycle `DefaultLifecyclePhase` adds lifecycle methods `start`, `stop` and `dispose`.
Startable `Startable` provides an object with a `Startable.start()` method which gets called when the Mule instance gets started.
Stoppable `Stoppable` is a lifecycle interfaqce that introduces a `Stoppable.stop()` method to an object.

Classes in org.mule.api.lifecycle used by org.mule.module.cxf.builder
CreateException `CreateException` is thrown when creating an object inside Mule wasn't possible due to inconsistent internal state or wrong input.

Classes in org.mule.api.lifecycle used by org.mule.module.cxf.component
Disposable `Disposable` is a lifecycle interface that gets called at the dispose lifecycle stage of the implementing service as the service is being destroyed.
Initialisable `Initialisable` is a lifecycle interface that gets called at the initialise lifecycle stage of the implementing service.
InitialisationException `InitialisationException` is thrown by the initialise method defined in the `org.mule.api.lifecycle.Initialisable` interface.
Lifecycle `DefaultLifecyclePhase` adds lifecycle methods `start`, `stop` and `dispose`.
Startable `Startable` provides an object with a `Startable.start()` method which gets called when the Mule instance gets started.
Stoppable `Stoppable` is a lifecycle interfaqce that introduces a `Stoppable.stop()` method to an object.

Classes in org.mule.api.lifecycle used by org.mule.module.cxf.config
Disposable `Disposable` is a lifecycle interface that gets called at the dispose lifecycle stage of the implementing service as the service is being destroyed.
Initialisable `Initialisable` is a lifecycle interface that gets called at the initialise lifecycle stage of the implementing service.
InitialisationException `InitialisationException` is thrown by the initialise method defined in the `org.mule.api.lifecycle.Initialisable` interface.
Lifecycle `DefaultLifecyclePhase` adds lifecycle methods `start`, `stop` and `dispose`.
Startable `Startable` provides an object with a `Startable.start()` method which gets called when the Mule instance gets started.
Stoppable `Stoppable` is a lifecycle interfaqce that introduces a `Stoppable.stop()` method to an object.

Classes in org.mule.api.lifecycle used by org.mule.module.cxf.endpoint
InitialisationException `InitialisationException` is thrown by the initialise method defined in the `org.mule.api.lifecycle.Initialisable` interface.

Classes in org.mule.api.lifecycle used by org.mule.module.guice
Disposable `Disposable` is a lifecycle interface that gets called at the dispose lifecycle stage of the implementing service as the service is being destroyed.
Initialisable `Initialisable` is a lifecycle interface that gets called at the initialise lifecycle stage of the implementing service.
InitialisationException `InitialisationException` is thrown by the initialise method defined in the `org.mule.api.lifecycle.Initialisable` interface.

Classes in org.mule.api.lifecycle used by org.mule.module.ibeans.config
Disposable `Disposable` is a lifecycle interface that gets called at the dispose lifecycle stage of the implementing service as the service is being destroyed.
Initialisable `Initialisable` is a lifecycle interface that gets called at the initialise lifecycle stage of the implementing service.
Lifecycle `DefaultLifecyclePhase` adds lifecycle methods `start`, `stop` and `dispose`.
LifecycleStateEnabled Objects that have an associated lifecycle manager such as `Service` or `Connector` should implement this interface so that the registry lifecycle manager can introspect the lifecycle state of an object.
Startable `Startable` provides an object with a `Startable.start()` method which gets called when the Mule instance gets started.
Stoppable `Stoppable` is a lifecycle interfaqce that introduces a `Stoppable.stop()` method to an object.

Classes in org.mule.api.lifecycle used by org.mule.module.ibeans.spi.support
Disposable `Disposable` is a lifecycle interface that gets called at the dispose lifecycle stage of the implementing service as the service is being destroyed.
Startable `Startable` provides an object with a `Startable.start()` method which gets called when the Mule instance gets started.
Stoppable `Stoppable` is a lifecycle interfaqce that introduces a `Stoppable.stop()` method to an object.

Classes in org.mule.api.lifecycle used by org.mule.module.jaas
Initialisable `Initialisable` is a lifecycle interface that gets called at the initialise lifecycle stage of the implementing service.
InitialisationException `InitialisationException` is thrown by the initialise method defined in the `org.mule.api.lifecycle.Initialisable` interface.

Classes in org.mule.api.lifecycle used by org.mule.module.jaas.filters
Initialisable `Initialisable` is a lifecycle interface that gets called at the initialise lifecycle stage of the implementing service.
InitialisationException `InitialisationException` is thrown by the initialise method defined in the `org.mule.api.lifecycle.Initialisable` interface.

Classes in org.mule.api.lifecycle used by org.mule.module.jbpm
Disposable `Disposable` is a lifecycle interface that gets called at the dispose lifecycle stage of the implementing service as the service is being destroyed.
Initialisable `Initialisable` is a lifecycle interface that gets called at the initialise lifecycle stage of the implementing service.

Classes in org.mule.api.lifecycle used by org.mule.module.jca
Disposable `Disposable` is a lifecycle interface that gets called at the dispose lifecycle stage of the implementing service as the service is being destroyed.
Initialisable `Initialisable` is a lifecycle interface that gets called at the initialise lifecycle stage of the implementing service.
InitialisationException `InitialisationException` is thrown by the initialise method defined in the `org.mule.api.lifecycle.Initialisable` interface.
Lifecycle `DefaultLifecyclePhase` adds lifecycle methods `start`, `stop` and `dispose`.
LifecycleStateEnabled Objects that have an associated lifecycle manager such as `Service` or `Connector` should implement this interface so that the registry lifecycle manager can introspect the lifecycle state of an object.
Startable `Startable` provides an object with a `Startable.start()` method which gets called when the Mule instance gets started.
Stoppable `Stoppable` is a lifecycle interfaqce that introduces a `Stoppable.stop()` method to an object.

Classes in org.mule.api.lifecycle used by org.mule.module.jersey
Disposable `Disposable` is a lifecycle interface that gets called at the dispose lifecycle stage of the implementing service as the service is being destroyed.
Initialisable `Initialisable` is a lifecycle interface that gets called at the initialise lifecycle stage of the implementing service.
InitialisationException `InitialisationException` is thrown by the initialise method defined in the `org.mule.api.lifecycle.Initialisable` interface.
Lifecycle `DefaultLifecyclePhase` adds lifecycle methods `start`, `stop` and `dispose`.
Startable `Startable` provides an object with a `Startable.start()` method which gets called when the Mule instance gets started.
Stoppable `Stoppable` is a lifecycle interfaqce that introduces a `Stoppable.stop()` method to an object.

Classes in org.mule.api.lifecycle used by org.mule.module.json.transformers
Disposable `Disposable` is a lifecycle interface that gets called at the dispose lifecycle stage of the implementing service as the service is being destroyed.
Initialisable `Initialisable` is a lifecycle interface that gets called at the initialise lifecycle stage of the implementing service.
InitialisationException `InitialisationException` is thrown by the initialise method defined in the `org.mule.api.lifecycle.Initialisable` interface.

Classes in org.mule.api.lifecycle used by org.mule.module.management.agent
Disposable `Disposable` is a lifecycle interface that gets called at the dispose lifecycle stage of the implementing service as the service is being destroyed.
Initialisable `Initialisable` is a lifecycle interface that gets called at the initialise lifecycle stage of the implementing service.
InitialisationException `InitialisationException` is thrown by the initialise method defined in the `org.mule.api.lifecycle.Initialisable` interface.
Lifecycle `DefaultLifecyclePhase` adds lifecycle methods `start`, `stop` and `dispose`.
Startable `Startable` provides an object with a `Startable.start()` method which gets called when the Mule instance gets started.
Stoppable `Stoppable` is a lifecycle interfaqce that introduces a `Stoppable.stop()` method to an object.

Classes in org.mule.api.lifecycle used by org.mule.module.management.mbean
Initialisable `Initialisable` is a lifecycle interface that gets called at the initialise lifecycle stage of the implementing service.
InitialisationException `InitialisationException` is thrown by the initialise method defined in the `org.mule.api.lifecycle.Initialisable` interface.
Startable `Startable` provides an object with a `Startable.start()` method which gets called when the Mule instance gets started.
Stoppable `Stoppable` is a lifecycle interfaqce that introduces a `Stoppable.stop()` method to an object.

Classes in org.mule.api.lifecycle used by org.mule.module.ognl.expression
Disposable `Disposable` is a lifecycle interface that gets called at the dispose lifecycle stage of the implementing service as the service is being destroyed.

Classes in org.mule.api.lifecycle used by org.mule.module.pgp
Initialisable `Initialisable` is a lifecycle interface that gets called at the initialise lifecycle stage of the implementing service.
InitialisationException `InitialisationException` is thrown by the initialise method defined in the `org.mule.api.lifecycle.Initialisable` interface.

Classes in org.mule.api.lifecycle used by org.mule.module.pgp.filters
Initialisable `Initialisable` is a lifecycle interface that gets called at the initialise lifecycle stage of the implementing service.
InitialisationException `InitialisationException` is thrown by the initialise method defined in the `org.mule.api.lifecycle.Initialisable` interface.

Classes in org.mule.api.lifecycle used by org.mule.module.rss.endpoint
Disposable `Disposable` is a lifecycle interface that gets called at the dispose lifecycle stage of the implementing service as the service is being destroyed.
InitialisationException `InitialisationException` is thrown by the initialise method defined in the `org.mule.api.lifecycle.Initialisable` interface.
Startable `Startable` provides an object with a `Startable.start()` method which gets called when the Mule instance gets started.
Stoppable `Stoppable` is a lifecycle interfaqce that introduces a `Stoppable.stop()` method to an object.

Classes in org.mule.api.lifecycle used by org.mule.module.rss.transformers
Disposable `Disposable` is a lifecycle interface that gets called at the dispose lifecycle stage of the implementing service as the service is being destroyed.
Initialisable `Initialisable` is a lifecycle interface that gets called at the initialise lifecycle stage of the implementing service.

Classes in org.mule.api.lifecycle used by org.mule.module.scripting.component
Callable `Callable` is used to provide a Service with an interface that supports event calls.
Disposable `Disposable` is a lifecycle interface that gets called at the dispose lifecycle stage of the implementing service as the service is being destroyed.
EventListener `EventListener` is a marker interface that is implemented by objects wishing to receive Mule events in managed environments, such as an EJB container.
Initialisable `Initialisable` is a lifecycle interface that gets called at the initialise lifecycle stage of the implementing service.
InitialisationException `InitialisationException` is thrown by the initialise method defined in the `org.mule.api.lifecycle.Initialisable` interface.
Lifecycle `DefaultLifecyclePhase` adds lifecycle methods `start`, `stop` and `dispose`.
Startable `Startable` provides an object with a `Startable.start()` method which gets called when the Mule instance gets started.
Stoppable `Stoppable` is a lifecycle interfaqce that introduces a `Stoppable.stop()` method to an object.

Classes in org.mule.api.lifecycle used by org.mule.module.scripting.expression
Disposable `Disposable` is a lifecycle interface that gets called at the dispose lifecycle stage of the implementing service as the service is being destroyed.

Classes in org.mule.api.lifecycle used by org.mule.module.scripting.transformer
Disposable `Disposable` is a lifecycle interface that gets called at the dispose lifecycle stage of the implementing service as the service is being destroyed.
Initialisable `Initialisable` is a lifecycle interface that gets called at the initialise lifecycle stage of the implementing service.

Classes in org.mule.api.lifecycle used by org.mule.module.spring.events
Callable `Callable` is used to provide a Service with an interface that supports event calls.
EventListener `EventListener` is a marker interface that is implemented by objects wishing to receive Mule events in managed environments, such as an EJB container.
Initialisable `Initialisable` is a lifecycle interface that gets called at the initialise lifecycle stage of the implementing service.
InitialisationException `InitialisationException` is thrown by the initialise method defined in the `org.mule.api.lifecycle.Initialisable` interface.

Classes in org.mule.api.lifecycle used by org.mule.module.spring.remoting
Callable `Callable` is used to provide a Service with an interface that supports event calls.
Disposable `Disposable` is a lifecycle interface that gets called at the dispose lifecycle stage of the implementing service as the service is being destroyed.
EventListener `EventListener` is a marker interface that is implemented by objects wishing to receive Mule events in managed environments, such as an EJB container.
Initialisable `Initialisable` is a lifecycle interface that gets called at the initialise lifecycle stage of the implementing service.
InitialisationException `InitialisationException` is thrown by the initialise method defined in the `org.mule.api.lifecycle.Initialisable` interface.

Classes in org.mule.api.lifecycle used by org.mule.module.spring.security
Initialisable `Initialisable` is a lifecycle interface that gets called at the initialise lifecycle stage of the implementing service.
InitialisationException `InitialisationException` is thrown by the initialise method defined in the `org.mule.api.lifecycle.Initialisable` interface.

Classes in org.mule.api.lifecycle used by org.mule.module.spring.security.filters.http
Initialisable `Initialisable` is a lifecycle interface that gets called at the initialise lifecycle stage of the implementing service.
InitialisationException `InitialisationException` is thrown by the initialise method defined in the `org.mule.api.lifecycle.Initialisable` interface.

Classes in org.mule.api.lifecycle used by org.mule.module.sxc
Disposable `Disposable` is a lifecycle interface that gets called at the dispose lifecycle stage of the implementing service as the service is being destroyed.
Initialisable `Initialisable` is a lifecycle interface that gets called at the initialise lifecycle stage of the implementing service.
Lifecycle `DefaultLifecyclePhase` adds lifecycle methods `start`, `stop` and `dispose`.
Startable `Startable` provides an object with a `Startable.start()` method which gets called when the Mule instance gets started.
Stoppable `Stoppable` is a lifecycle interfaqce that introduces a `Stoppable.stop()` method to an object.

Classes in org.mule.api.lifecycle used by org.mule.module.ws.config.spring.factories
Initialisable `Initialisable` is a lifecycle interface that gets called at the initialise lifecycle stage of the implementing service.

Classes in org.mule.api.lifecycle used by org.mule.module.ws.construct
Disposable `Disposable` is a lifecycle interface that gets called at the dispose lifecycle stage of the implementing service as the service is being destroyed.
Initialisable `Initialisable` is a lifecycle interface that gets called at the initialise lifecycle stage of the implementing service.
Lifecycle `DefaultLifecyclePhase` adds lifecycle methods `start`, `stop` and `dispose`.
LifecycleStateEnabled Objects that have an associated lifecycle manager such as `Service` or `Connector` should implement this interface so that the registry lifecycle manager can introspect the lifecycle state of an object.
Startable `Startable` provides an object with a `Startable.start()` method which gets called when the Mule instance gets started.
Stoppable `Stoppable` is a lifecycle interfaqce that introduces a `Stoppable.stop()` method to an object.

Classes in org.mule.api.lifecycle used by org.mule.module.xml.expression
Disposable `Disposable` is a lifecycle interface that gets called at the dispose lifecycle stage of the implementing service as the service is being destroyed.
Initialisable `Initialisable` is a lifecycle interface that gets called at the initialise lifecycle stage of the implementing service.
InitialisationException `InitialisationException` is thrown by the initialise method defined in the `org.mule.api.lifecycle.Initialisable` interface.

Classes in org.mule.api.lifecycle used by org.mule.module.xml.filters
Initialisable `Initialisable` is a lifecycle interface that gets called at the initialise lifecycle stage of the implementing service.
InitialisationException `InitialisationException` is thrown by the initialise method defined in the `org.mule.api.lifecycle.Initialisable` interface.

Classes in org.mule.api.lifecycle used by org.mule.module.xml.routing
Disposable `Disposable` is a lifecycle interface that gets called at the dispose lifecycle stage of the implementing service as the service is being destroyed.
Initialisable `Initialisable` is a lifecycle interface that gets called at the initialise lifecycle stage of the implementing service.
InitialisationException `InitialisationException` is thrown by the initialise method defined in the `org.mule.api.lifecycle.Initialisable` interface.
Lifecycle `DefaultLifecyclePhase` adds lifecycle methods `start`, `stop` and `dispose`.
Startable `Startable` provides an object with a `Startable.start()` method which gets called when the Mule instance gets started.
Stoppable `Stoppable` is a lifecycle interfaqce that introduces a `Stoppable.stop()` method to an object.

Classes in org.mule.api.lifecycle used by org.mule.module.xml.transformer
Disposable `Disposable` is a lifecycle interface that gets called at the dispose lifecycle stage of the implementing service as the service is being destroyed.
Initialisable `Initialisable` is a lifecycle interface that gets called at the initialise lifecycle stage of the implementing service.
InitialisationException `InitialisationException` is thrown by the initialise method defined in the `org.mule.api.lifecycle.Initialisable` interface.

Classes in org.mule.api.lifecycle used by org.mule.module.xml.transformer.jaxb
Disposable `Disposable` is a lifecycle interface that gets called at the dispose lifecycle stage of the implementing service as the service is being destroyed.
Initialisable `Initialisable` is a lifecycle interface that gets called at the initialise lifecycle stage of the implementing service.
InitialisationException `InitialisationException` is thrown by the initialise method defined in the `org.mule.api.lifecycle.Initialisable` interface.

Classes in org.mule.api.lifecycle used by org.mule.module.xml.util
Initialisable `Initialisable` is a lifecycle interface that gets called at the initialise lifecycle stage of the implementing service.
InitialisationException `InitialisationException` is thrown by the initialise method defined in the `org.mule.api.lifecycle.Initialisable` interface.

Classes in org.mule.api.lifecycle used by org.mule.object
Disposable `Disposable` is a lifecycle interface that gets called at the dispose lifecycle stage of the implementing service as the service is being destroyed.
Initialisable `Initialisable` is a lifecycle interface that gets called at the initialise lifecycle stage of the implementing service.
InitialisationCallback `InitialisationCallback` is used to provide customised initialiation for more complex components.
InitialisationException `InitialisationException` is thrown by the initialise method defined in the `org.mule.api.lifecycle.Initialisable` interface.

Classes in org.mule.api.lifecycle used by org.mule.processor
Disposable `Disposable` is a lifecycle interface that gets called at the dispose lifecycle stage of the implementing service as the service is being destroyed.
Initialisable `Initialisable` is a lifecycle interface that gets called at the initialise lifecycle stage of the implementing service.
InitialisationException `InitialisationException` is thrown by the initialise method defined in the `org.mule.api.lifecycle.Initialisable` interface.
Lifecycle `DefaultLifecyclePhase` adds lifecycle methods `start`, `stop` and `dispose`.
LifecycleState A safe facade for lifecycle manager that objects can use to monitor its own state
Startable `Startable` provides an object with a `Startable.start()` method which gets called when the Mule instance gets started.
Stoppable `Stoppable` is a lifecycle interfaqce that introduces a `Stoppable.stop()` method to an object.

Classes in org.mule.api.lifecycle used by org.mule.processor.chain
Disposable `Disposable` is a lifecycle interface that gets called at the dispose lifecycle stage of the implementing service as the service is being destroyed.
Initialisable `Initialisable` is a lifecycle interface that gets called at the initialise lifecycle stage of the implementing service.
InitialisationException `InitialisationException` is thrown by the initialise method defined in the `org.mule.api.lifecycle.Initialisable` interface.
Lifecycle `DefaultLifecyclePhase` adds lifecycle methods `start`, `stop` and `dispose`.
Startable `Startable` provides an object with a `Startable.start()` method which gets called when the Mule instance gets started.
Stoppable `Stoppable` is a lifecycle interfaqce that introduces a `Stoppable.stop()` method to an object.

Classes in org.mule.api.lifecycle used by org.mule.registry
Disposable `Disposable` is a lifecycle interface that gets called at the dispose lifecycle stage of the implementing service as the service is being destroyed.
Initialisable `Initialisable` is a lifecycle interface that gets called at the initialise lifecycle stage of the implementing service.
InitialisationException `InitialisationException` is thrown by the initialise method defined in the `org.mule.api.lifecycle.Initialisable` interface.
LifecycleException `LifecycleException` TODO
LifecycleState A safe facade for lifecycle manager that objects can use to monitor its own state

Classes in org.mule.api.lifecycle used by org.mule.retry
FatalException `FatalException` can be thrown during initialisation or during execution to indicate that something fatal has occurred and the MuleManager must shutdown.
LifecycleException `LifecycleException` TODO

Classes in org.mule.api.lifecycle used by org.mule.routing
Disposable `Disposable` is a lifecycle interface that gets called at the dispose lifecycle stage of the implementing service as the service is being destroyed.
Initialisable `Initialisable` is a lifecycle interface that gets called at the initialise lifecycle stage of the implementing service.
InitialisationException `InitialisationException` is thrown by the initialise method defined in the `org.mule.api.lifecycle.Initialisable` interface.
Lifecycle `DefaultLifecyclePhase` adds lifecycle methods `start`, `stop` and `dispose`.
Startable `Startable` provides an object with a `Startable.start()` method which gets called when the Mule instance gets started.
Stoppable `Stoppable` is a lifecycle interfaqce that introduces a `Stoppable.stop()` method to an object.

Classes in org.mule.api.lifecycle used by org.mule.routing.outbound
Disposable `Disposable` is a lifecycle interface that gets called at the dispose lifecycle stage of the implementing service as the service is being destroyed.
Initialisable `Initialisable` is a lifecycle interface that gets called at the initialise lifecycle stage of the implementing service.
InitialisationException `InitialisationException` is thrown by the initialise method defined in the `org.mule.api.lifecycle.Initialisable` interface.
Lifecycle `DefaultLifecyclePhase` adds lifecycle methods `start`, `stop` and `dispose`.
Startable `Startable` provides an object with a `Startable.start()` method which gets called when the Mule instance gets started.
Stoppable `Stoppable` is a lifecycle interfaqce that introduces a `Stoppable.stop()` method to an object.

Classes in org.mule.api.lifecycle used by org.mule.routing.requestreply
Startable `Startable` provides an object with a `Startable.start()` method which gets called when the Mule instance gets started.
Stoppable `Stoppable` is a lifecycle interfaqce that introduces a `Stoppable.stop()` method to an object.

Classes in org.mule.api.lifecycle used by org.mule.security
Initialisable `Initialisable` is a lifecycle interface that gets called at the initialise lifecycle stage of the implementing service.
InitialisationException `InitialisationException` is thrown by the initialise method defined in the `org.mule.api.lifecycle.Initialisable` interface.

Classes in org.mule.api.lifecycle used by org.mule.security.filters
Initialisable `Initialisable` is a lifecycle interface that gets called at the initialise lifecycle stage of the implementing service.
InitialisationException `InitialisationException` is thrown by the initialise method defined in the `org.mule.api.lifecycle.Initialisable` interface.

Classes in org.mule.api.lifecycle used by org.mule.service
Disposable `Disposable` is a lifecycle interface that gets called at the dispose lifecycle stage of the implementing service as the service is being destroyed.
Initialisable `Initialisable` is a lifecycle interface that gets called at the initialise lifecycle stage of the implementing service.
InitialisationException `InitialisationException` is thrown by the initialise method defined in the `org.mule.api.lifecycle.Initialisable` interface.
Lifecycle `DefaultLifecyclePhase` adds lifecycle methods `start`, `stop` and `dispose`.
LifecycleCallback This callback is used to execute lifecycle behaviour for an object being managed by a `LifecycleManager` The callback is used so that transitions can be managed consistently outside of an object
LifecycleManager The LifecycleManager is responsible for managing the different lifecycle phases of the server and managing the transitions between lifecycle phases.
LifecyclePhase Encapsulates the notion of a lifecycle phase i.e.
LifecycleState A safe facade for lifecycle manager that objects can use to monitor its own state
LifecycleStateEnabled Objects that have an associated lifecycle manager such as `Service` or `Connector` should implement this interface so that the registry lifecycle manager can introspect the lifecycle state of an object.
Startable `Startable` provides an object with a `Startable.start()` method which gets called when the Mule instance gets started.
Stoppable `Stoppable` is a lifecycle interfaqce that introduces a `Stoppable.stop()` method to an object.

Classes in org.mule.api.lifecycle used by org.mule.source
Disposable `Disposable` is a lifecycle interface that gets called at the dispose lifecycle stage of the implementing service as the service is being destroyed.
Initialisable `Initialisable` is a lifecycle interface that gets called at the initialise lifecycle stage of the implementing service.
InitialisationException `InitialisationException` is thrown by the initialise method defined in the `org.mule.api.lifecycle.Initialisable` interface.
Lifecycle `DefaultLifecyclePhase` adds lifecycle methods `start`, `stop` and `dispose`.
Startable `Startable` provides an object with a `Startable.start()` method which gets called when the Mule instance gets started.
Stoppable `Stoppable` is a lifecycle interfaqce that introduces a `Stoppable.stop()` method to an object.

Classes in org.mule.api.lifecycle used by org.mule.tck.functional
Callable `Callable` is used to provide a Service with an interface that supports event calls.
Disposable `Disposable` is a lifecycle interface that gets called at the dispose lifecycle stage of the implementing service as the service is being destroyed.
EventListener `EventListener` is a marker interface that is implemented by objects wishing to receive Mule events in managed environments, such as an EJB container.
Initialisable `Initialisable` is a lifecycle interface that gets called at the initialise lifecycle stage of the implementing service.
InitialisationException `InitialisationException` is thrown by the initialise method defined in the `org.mule.api.lifecycle.Initialisable` interface.
Lifecycle `DefaultLifecyclePhase` adds lifecycle methods `start`, `stop` and `dispose`.
Startable `Startable` provides an object with a `Startable.start()` method which gets called when the Mule instance gets started.
Stoppable `Stoppable` is a lifecycle interfaqce that introduces a `Stoppable.stop()` method to an object.

Classes in org.mule.api.lifecycle used by org.mule.tck.security
Callable `Callable` is used to provide a Service with an interface that supports event calls.
EventListener `EventListener` is a marker interface that is implemented by objects wishing to receive Mule events in managed environments, such as an EJB container.
Initialisable `Initialisable` is a lifecycle interface that gets called at the initialise lifecycle stage of the implementing service.
InitialisationException `InitialisationException` is thrown by the initialise method defined in the `org.mule.api.lifecycle.Initialisable` interface.

Classes in org.mule.api.lifecycle used by org.mule.tck.testmodels.services
Callable `Callable` is used to provide a Service with an interface that supports event calls.
Disposable `Disposable` is a lifecycle interface that gets called at the dispose lifecycle stage of the implementing service as the service is being destroyed.
EventListener `EventListener` is a marker interface that is implemented by objects wishing to receive Mule events in managed environments, such as an EJB container.
Initialisable `Initialisable` is a lifecycle interface that gets called at the initialise lifecycle stage of the implementing service.

Classes in org.mule.api.lifecycle used by org.mule.tck.transformer
Disposable `Disposable` is a lifecycle interface that gets called at the dispose lifecycle stage of the implementing service as the service is being destroyed.
Initialisable `Initialisable` is a lifecycle interface that gets called at the initialise lifecycle stage of the implementing service.

Classes in org.mule.api.lifecycle used by org.mule.transaction.lookup
Initialisable `Initialisable` is a lifecycle interface that gets called at the initialise lifecycle stage of the implementing service.
InitialisationException `InitialisationException` is thrown by the initialise method defined in the `org.mule.api.lifecycle.Initialisable` interface.

Classes in org.mule.api.lifecycle used by org.mule.transformer
Disposable `Disposable` is a lifecycle interface that gets called at the dispose lifecycle stage of the implementing service as the service is being destroyed.
Initialisable `Initialisable` is a lifecycle interface that gets called at the initialise lifecycle stage of the implementing service.
InitialisationException `InitialisationException` is thrown by the initialise method defined in the `org.mule.api.lifecycle.Initialisable` interface.

Classes in org.mule.api.lifecycle used by org.mule.transformer.codec
Disposable `Disposable` is a lifecycle interface that gets called at the dispose lifecycle stage of the implementing service as the service is being destroyed.
Initialisable `Initialisable` is a lifecycle interface that gets called at the initialise lifecycle stage of the implementing service.

Classes in org.mule.api.lifecycle used by org.mule.transformer.compression
Disposable `Disposable` is a lifecycle interface that gets called at the dispose lifecycle stage of the implementing service as the service is being destroyed.
Initialisable `Initialisable` is a lifecycle interface that gets called at the initialise lifecycle stage of the implementing service.

Classes in org.mule.api.lifecycle used by org.mule.transformer.encryption
Disposable `Disposable` is a lifecycle interface that gets called at the dispose lifecycle stage of the implementing service as the service is being destroyed.
Initialisable `Initialisable` is a lifecycle interface that gets called at the initialise lifecycle stage of the implementing service.
InitialisationException `InitialisationException` is thrown by the initialise method defined in the `org.mule.api.lifecycle.Initialisable` interface.

Classes in org.mule.api.lifecycle used by org.mule.transformer.simple
Disposable `Disposable` is a lifecycle interface that gets called at the dispose lifecycle stage of the implementing service as the service is being destroyed.
Initialisable `Initialisable` is a lifecycle interface that gets called at the initialise lifecycle stage of the implementing service.
InitialisationException `InitialisationException` is thrown by the initialise method defined in the `org.mule.api.lifecycle.Initialisable` interface.

Classes in org.mule.api.lifecycle used by org.mule.transport
CreateException `CreateException` is thrown when creating an object inside Mule wasn't possible due to inconsistent internal state or wrong input.
Disposable `Disposable` is a lifecycle interface that gets called at the dispose lifecycle stage of the implementing service as the service is being destroyed.
Initialisable `Initialisable` is a lifecycle interface that gets called at the initialise lifecycle stage of the implementing service.
InitialisationException `InitialisationException` is thrown by the initialise method defined in the `org.mule.api.lifecycle.Initialisable` interface.
Lifecycle `DefaultLifecyclePhase` adds lifecycle methods `start`, `stop` and `dispose`.
LifecycleCallback This callback is used to execute lifecycle behaviour for an object being managed by a `LifecycleManager` The callback is used so that transitions can be managed consistently outside of an object
LifecycleException `LifecycleException` TODO
LifecycleManager The LifecycleManager is responsible for managing the different lifecycle phases of the server and managing the transitions between lifecycle phases.
LifecycleState A safe facade for lifecycle manager that objects can use to monitor its own state
LifecycleStateEnabled Objects that have an associated lifecycle manager such as `Service` or `Connector` should implement this interface so that the registry lifecycle manager can introspect the lifecycle state of an object.
Startable `Startable` provides an object with a `Startable.start()` method which gets called when the Mule instance gets started.
Stoppable `Stoppable` is a lifecycle interfaqce that introduces a `Stoppable.stop()` method to an object.

Classes in org.mule.api.lifecycle used by org.mule.transport.ajax
CreateException `CreateException` is thrown when creating an object inside Mule wasn't possible due to inconsistent internal state or wrong input.
Disposable `Disposable` is a lifecycle interface that gets called at the dispose lifecycle stage of the implementing service as the service is being destroyed.
Initialisable `Initialisable` is a lifecycle interface that gets called at the initialise lifecycle stage of the implementing service.
InitialisationException `InitialisationException` is thrown by the initialise method defined in the `org.mule.api.lifecycle.Initialisable` interface.
Lifecycle `DefaultLifecyclePhase` adds lifecycle methods `start`, `stop` and `dispose`.
LifecycleStateEnabled Objects that have an associated lifecycle manager such as `Service` or `Connector` should implement this interface so that the registry lifecycle manager can introspect the lifecycle state of an object.
Startable `Startable` provides an object with a `Startable.start()` method which gets called when the Mule instance gets started.
Stoppable `Stoppable` is a lifecycle interfaqce that introduces a `Stoppable.stop()` method to an object.

Classes in org.mule.api.lifecycle used by org.mule.transport.ajax.container
Disposable `Disposable` is a lifecycle interface that gets called at the dispose lifecycle stage of the implementing service as the service is being destroyed.
Initialisable `Initialisable` is a lifecycle interface that gets called at the initialise lifecycle stage of the implementing service.
Lifecycle `DefaultLifecyclePhase` adds lifecycle methods `start`, `stop` and `dispose`.
LifecycleStateEnabled Objects that have an associated lifecycle manager such as `Service` or `Connector` should implement this interface so that the registry lifecycle manager can introspect the lifecycle state of an object.
Startable `Startable` provides an object with a `Startable.start()` method which gets called when the Mule instance gets started.
Stoppable `Stoppable` is a lifecycle interfaqce that introduces a `Stoppable.stop()` method to an object.

Classes in org.mule.api.lifecycle used by org.mule.transport.ajax.embedded
Disposable `Disposable` is a lifecycle interface that gets called at the dispose lifecycle stage of the implementing service as the service is being destroyed.
Initialisable `Initialisable` is a lifecycle interface that gets called at the initialise lifecycle stage of the implementing service.
InitialisationException `InitialisationException` is thrown by the initialise method defined in the `org.mule.api.lifecycle.Initialisable` interface.
Lifecycle `DefaultLifecyclePhase` adds lifecycle methods `start`, `stop` and `dispose`.
LifecycleStateEnabled Objects that have an associated lifecycle manager such as `Service` or `Connector` should implement this interface so that the registry lifecycle manager can introspect the lifecycle state of an object.
Startable `Startable` provides an object with a `Startable.start()` method which gets called when the Mule instance gets started.
Stoppable `Stoppable` is a lifecycle interfaqce that introduces a `Stoppable.stop()` method to an object.

Classes in org.mule.api.lifecycle used by org.mule.transport.ejb
CreateException `CreateException` is thrown when creating an object inside Mule wasn't possible due to inconsistent internal state or wrong input.
Disposable `Disposable` is a lifecycle interface that gets called at the dispose lifecycle stage of the implementing service as the service is being destroyed.
Initialisable `Initialisable` is a lifecycle interface that gets called at the initialise lifecycle stage of the implementing service.
Lifecycle `DefaultLifecyclePhase` adds lifecycle methods `start`, `stop` and `dispose`.
LifecycleStateEnabled Objects that have an associated lifecycle manager such as `Service` or `Connector` should implement this interface so that the registry lifecycle manager can introspect the lifecycle state of an object.
Startable `Startable` provides an object with a `Startable.start()` method which gets called when the Mule instance gets started.
Stoppable `Stoppable` is a lifecycle interfaqce that introduces a `Stoppable.stop()` method to an object.

Classes in org.mule.api.lifecycle used by org.mule.transport.email
CreateException `CreateException` is thrown when creating an object inside Mule wasn't possible due to inconsistent internal state or wrong input.
Disposable `Disposable` is a lifecycle interface that gets called at the dispose lifecycle stage of the implementing service as the service is being destroyed.
Initialisable `Initialisable` is a lifecycle interface that gets called at the initialise lifecycle stage of the implementing service.
InitialisationException `InitialisationException` is thrown by the initialise method defined in the `org.mule.api.lifecycle.Initialisable` interface.
Lifecycle `DefaultLifecyclePhase` adds lifecycle methods `start`, `stop` and `dispose`.
LifecycleStateEnabled Objects that have an associated lifecycle manager such as `Service` or `Connector` should implement this interface so that the registry lifecycle manager can introspect the lifecycle state of an object.
Startable `Startable` provides an object with a `Startable.start()` method which gets called when the Mule instance gets started.
Stoppable `Stoppable` is a lifecycle interfaqce that introduces a `Stoppable.stop()` method to an object.

Classes in org.mule.api.lifecycle used by org.mule.transport.email.transformers
Disposable `Disposable` is a lifecycle interface that gets called at the dispose lifecycle stage of the implementing service as the service is being destroyed.
Initialisable `Initialisable` is a lifecycle interface that gets called at the initialise lifecycle stage of the implementing service.

Classes in org.mule.api.lifecycle used by org.mule.transport.file
CreateException `CreateException` is thrown when creating an object inside Mule wasn't possible due to inconsistent internal state or wrong input.
Disposable `Disposable` is a lifecycle interface that gets called at the dispose lifecycle stage of the implementing service as the service is being destroyed.
Initialisable `Initialisable` is a lifecycle interface that gets called at the initialise lifecycle stage of the implementing service.
InitialisationException `InitialisationException` is thrown by the initialise method defined in the `org.mule.api.lifecycle.Initialisable` interface.
Lifecycle `DefaultLifecyclePhase` adds lifecycle methods `start`, `stop` and `dispose`.
LifecycleStateEnabled Objects that have an associated lifecycle manager such as `Service` or `Connector` should implement this interface so that the registry lifecycle manager can introspect the lifecycle state of an object.
Startable `Startable` provides an object with a `Startable.start()` method which gets called when the Mule instance gets started.
Stoppable `Stoppable` is a lifecycle interfaqce that introduces a `Stoppable.stop()` method to an object.

Classes in org.mule.api.lifecycle used by org.mule.transport.file.transformers
Disposable `Disposable` is a lifecycle interface that gets called at the dispose lifecycle stage of the implementing service as the service is being destroyed.
Initialisable `Initialisable` is a lifecycle interface that gets called at the initialise lifecycle stage of the implementing service.

Classes in org.mule.api.lifecycle used by org.mule.transport.ftp
CreateException `CreateException` is thrown when creating an object inside Mule wasn't possible due to inconsistent internal state or wrong input.
Disposable `Disposable` is a lifecycle interface that gets called at the dispose lifecycle stage of the implementing service as the service is being destroyed.
Initialisable `Initialisable` is a lifecycle interface that gets called at the initialise lifecycle stage of the implementing service.
InitialisationException `InitialisationException` is thrown by the initialise method defined in the `org.mule.api.lifecycle.Initialisable` interface.
Lifecycle `DefaultLifecyclePhase` adds lifecycle methods `start`, `stop` and `dispose`.
LifecycleStateEnabled Objects that have an associated lifecycle manager such as `Service` or `Connector` should implement this interface so that the registry lifecycle manager can introspect the lifecycle state of an object.
Startable `Startable` provides an object with a `Startable.start()` method which gets called when the Mule instance gets started.
Stoppable `Stoppable` is a lifecycle interfaqce that introduces a `Stoppable.stop()` method to an object.

Classes in org.mule.api.lifecycle used by org.mule.transport.http
CreateException `CreateException` is thrown when creating an object inside Mule wasn't possible due to inconsistent internal state or wrong input.
Disposable `Disposable` is a lifecycle interface that gets called at the dispose lifecycle stage of the implementing service as the service is being destroyed.
Initialisable `Initialisable` is a lifecycle interface that gets called at the initialise lifecycle stage of the implementing service.
InitialisationException `InitialisationException` is thrown by the initialise method defined in the `org.mule.api.lifecycle.Initialisable` interface.
Lifecycle `DefaultLifecyclePhase` adds lifecycle methods `start`, `stop` and `dispose`.
LifecycleStateEnabled Objects that have an associated lifecycle manager such as `Service` or `Connector` should implement this interface so that the registry lifecycle manager can introspect the lifecycle state of an object.
Startable `Startable` provides an object with a `Startable.start()` method which gets called when the Mule instance gets started.
Stoppable `Stoppable` is a lifecycle interfaqce that introduces a `Stoppable.stop()` method to an object.

Classes in org.mule.api.lifecycle used by org.mule.transport.http.components
Disposable `Disposable` is a lifecycle interface that gets called at the dispose lifecycle stage of the implementing service as the service is being destroyed.
Initialisable `Initialisable` is a lifecycle interface that gets called at the initialise lifecycle stage of the implementing service.
InitialisationException `InitialisationException` is thrown by the initialise method defined in the `org.mule.api.lifecycle.Initialisable` interface.
Lifecycle `DefaultLifecyclePhase` adds lifecycle methods `start`, `stop` and `dispose`.
Startable `Startable` provides an object with a `Startable.start()` method which gets called when the Mule instance gets started.
Stoppable `Stoppable` is a lifecycle interfaqce that introduces a `Stoppable.stop()` method to an object.

Classes in org.mule.api.lifecycle used by org.mule.transport.http.transformers
Disposable `Disposable` is a lifecycle interface that gets called at the dispose lifecycle stage of the implementing service as the service is being destroyed.
Initialisable `Initialisable` is a lifecycle interface that gets called at the initialise lifecycle stage of the implementing service.
InitialisationException `InitialisationException` is thrown by the initialise method defined in the `org.mule.api.lifecycle.Initialisable` interface.

Classes in org.mule.api.lifecycle used by org.mule.transport.ibean
Disposable `Disposable` is a lifecycle interface that gets called at the dispose lifecycle stage of the implementing service as the service is being destroyed.
Initialisable `Initialisable` is a lifecycle interface that gets called at the initialise lifecycle stage of the implementing service.
InitialisationException `InitialisationException` is thrown by the initialise method defined in the `org.mule.api.lifecycle.Initialisable` interface.
Lifecycle `DefaultLifecyclePhase` adds lifecycle methods `start`, `stop` and `dispose`.
LifecycleStateEnabled Objects that have an associated lifecycle manager such as `Service` or `Connector` should implement this interface so that the registry lifecycle manager can introspect the lifecycle state of an object.
Startable `Startable` provides an object with a `Startable.start()` method which gets called when the Mule instance gets started.
Stoppable `Stoppable` is a lifecycle interfaqce that introduces a `Stoppable.stop()` method to an object.

Classes in org.mule.api.lifecycle used by org.mule.transport.jdbc
CreateException `CreateException` is thrown when creating an object inside Mule wasn't possible due to inconsistent internal state or wrong input.
Disposable `Disposable` is a lifecycle interface that gets called at the dispose lifecycle stage of the implementing service as the service is being destroyed.
Initialisable `Initialisable` is a lifecycle interface that gets called at the initialise lifecycle stage of the implementing service.
InitialisationException `InitialisationException` is thrown by the initialise method defined in the `org.mule.api.lifecycle.Initialisable` interface.
Lifecycle `DefaultLifecyclePhase` adds lifecycle methods `start`, `stop` and `dispose`.
LifecycleStateEnabled Objects that have an associated lifecycle manager such as `Service` or `Connector` should implement this interface so that the registry lifecycle manager can introspect the lifecycle state of an object.
Startable `Startable` provides an object with a `Startable.start()` method which gets called when the Mule instance gets started.
Stoppable `Stoppable` is a lifecycle interfaqce that introduces a `Stoppable.stop()` method to an object.

Classes in org.mule.api.lifecycle used by org.mule.transport.jms
CreateException `CreateException` is thrown when creating an object inside Mule wasn't possible due to inconsistent internal state or wrong input.
Disposable `Disposable` is a lifecycle interface that gets called at the dispose lifecycle stage of the implementing service as the service is being destroyed.
Initialisable `Initialisable` is a lifecycle interface that gets called at the initialise lifecycle stage of the implementing service.
InitialisationException `InitialisationException` is thrown by the initialise method defined in the `org.mule.api.lifecycle.Initialisable` interface.
Lifecycle `DefaultLifecyclePhase` adds lifecycle methods `start`, `stop` and `dispose`.
LifecycleStateEnabled Objects that have an associated lifecycle manager such as `Service` or `Connector` should implement this interface so that the registry lifecycle manager can introspect the lifecycle state of an object.
Startable `Startable` provides an object with a `Startable.start()` method which gets called when the Mule instance gets started.
Stoppable `Stoppable` is a lifecycle interfaqce that introduces a `Stoppable.stop()` method to an object.

Classes in org.mule.api.lifecycle used by org.mule.transport.jms.activemq
Disposable `Disposable` is a lifecycle interface that gets called at the dispose lifecycle stage of the implementing service as the service is being destroyed.
Initialisable `Initialisable` is a lifecycle interface that gets called at the initialise lifecycle stage of the implementing service.
Lifecycle `DefaultLifecyclePhase` adds lifecycle methods `start`, `stop` and `dispose`.
LifecycleStateEnabled Objects that have an associated lifecycle manager such as `Service` or `Connector` should implement this interface so that the registry lifecycle manager can introspect the lifecycle state of an object.
Startable `Startable` provides an object with a `Startable.start()` method which gets called when the Mule instance gets started.
Stoppable `Stoppable` is a lifecycle interfaqce that introduces a `Stoppable.stop()` method to an object.

Classes in org.mule.api.lifecycle used by org.mule.transport.jms.mulemq
Disposable `Disposable` is a lifecycle interface that gets called at the dispose lifecycle stage of the implementing service as the service is being destroyed.
Initialisable `Initialisable` is a lifecycle interface that gets called at the initialise lifecycle stage of the implementing service.
InitialisationException `InitialisationException` is thrown by the initialise method defined in the `org.mule.api.lifecycle.Initialisable` interface.
Lifecycle `DefaultLifecyclePhase` adds lifecycle methods `start`, `stop` and `dispose`.
LifecycleStateEnabled Objects that have an associated lifecycle manager such as `Service` or `Connector` should implement this interface so that the registry lifecycle manager can introspect the lifecycle state of an object.
Startable `Startable` provides an object with a `Startable.start()` method which gets called when the Mule instance gets started.
Stoppable `Stoppable` is a lifecycle interfaqce that introduces a `Stoppable.stop()` method to an object.

Classes in org.mule.api.lifecycle used by org.mule.transport.jms.transformers
Disposable `Disposable` is a lifecycle interface that gets called at the dispose lifecycle stage of the implementing service as the service is being destroyed.
Initialisable `Initialisable` is a lifecycle interface that gets called at the initialise lifecycle stage of the implementing service.

Classes in org.mule.api.lifecycle used by org.mule.transport.jms.weblogic
Disposable `Disposable` is a lifecycle interface that gets called at the dispose lifecycle stage of the implementing service as the service is being destroyed.
Initialisable `Initialisable` is a lifecycle interface that gets called at the initialise lifecycle stage of the implementing service.
Lifecycle `DefaultLifecyclePhase` adds lifecycle methods `start`, `stop` and `dispose`.
LifecycleStateEnabled Objects that have an associated lifecycle manager such as `Service` or `Connector` should implement this interface so that the registry lifecycle manager can introspect the lifecycle state of an object.
Startable `Startable` provides an object with a `Startable.start()` method which gets called when the Mule instance gets started.
Stoppable `Stoppable` is a lifecycle interfaqce that introduces a `Stoppable.stop()` method to an object.

Classes in org.mule.api.lifecycle used by org.mule.transport.jms.websphere
CreateException `CreateException` is thrown when creating an object inside Mule wasn't possible due to inconsistent internal state or wrong input.
Disposable `Disposable` is a lifecycle interface that gets called at the dispose lifecycle stage of the implementing service as the service is being destroyed.
Initialisable `Initialisable` is a lifecycle interface that gets called at the initialise lifecycle stage of the implementing service.
InitialisationException `InitialisationException` is thrown by the initialise method defined in the `org.mule.api.lifecycle.Initialisable` interface.
Lifecycle `DefaultLifecyclePhase` adds lifecycle methods `start`, `stop` and `dispose`.
LifecycleStateEnabled Objects that have an associated lifecycle manager such as `Service` or `Connector` should implement this interface so that the registry lifecycle manager can introspect the lifecycle state of an object.
Startable `Startable` provides an object with a `Startable.start()` method which gets called when the Mule instance gets started.
Stoppable `Stoppable` is a lifecycle interfaqce that introduces a `Stoppable.stop()` method to an object.

Classes in org.mule.api.lifecycle used by org.mule.transport.jnp
Disposable `Disposable` is a lifecycle interface that gets called at the dispose lifecycle stage of the implementing service as the service is being destroyed.
Initialisable `Initialisable` is a lifecycle interface that gets called at the initialise lifecycle stage of the implementing service.
Lifecycle `DefaultLifecyclePhase` adds lifecycle methods `start`, `stop` and `dispose`.
LifecycleStateEnabled Objects that have an associated lifecycle manager such as `Service` or `Connector` should implement this interface so that the registry lifecycle manager can introspect the lifecycle state of an object.
Startable `Startable` provides an object with a `Startable.start()` method which gets called when the Mule instance gets started.
Stoppable `Stoppable` is a lifecycle interfaqce that introduces a `Stoppable.stop()` method to an object.

Classes in org.mule.api.lifecycle used by org.mule.transport.multicast
CreateException `CreateException` is thrown when creating an object inside Mule wasn't possible due to inconsistent internal state or wrong input.
Disposable `Disposable` is a lifecycle interface that gets called at the dispose lifecycle stage of the implementing service as the service is being destroyed.
Initialisable `Initialisable` is a lifecycle interface that gets called at the initialise lifecycle stage of the implementing service.
InitialisationException `InitialisationException` is thrown by the initialise method defined in the `org.mule.api.lifecycle.Initialisable` interface.
Lifecycle `DefaultLifecyclePhase` adds lifecycle methods `start`, `stop` and `dispose`.
LifecycleStateEnabled Objects that have an associated lifecycle manager such as `Service` or `Connector` should implement this interface so that the registry lifecycle manager can introspect the lifecycle state of an object.
Startable `Startable` provides an object with a `Startable.start()` method which gets called when the Mule instance gets started.
Stoppable `Stoppable` is a lifecycle interfaqce that introduces a `Stoppable.stop()` method to an object.

Classes in org.mule.api.lifecycle used by org.mule.transport.polling
CreateException `CreateException` is thrown when creating an object inside Mule wasn't possible due to inconsistent internal state or wrong input.
Disposable `Disposable` is a lifecycle interface that gets called at the dispose lifecycle stage of the implementing service as the service is being destroyed.
Initialisable `Initialisable` is a lifecycle interface that gets called at the initialise lifecycle stage of the implementing service.
InitialisationException `InitialisationException` is thrown by the initialise method defined in the `org.mule.api.lifecycle.Initialisable` interface.
Lifecycle `DefaultLifecyclePhase` adds lifecycle methods `start`, `stop` and `dispose`.
LifecycleStateEnabled Objects that have an associated lifecycle manager such as `Service` or `Connector` should implement this interface so that the registry lifecycle manager can introspect the lifecycle state of an object.
Startable `Startable` provides an object with a `Startable.start()` method which gets called when the Mule instance gets started.
Stoppable `Stoppable` is a lifecycle interfaqce that introduces a `Stoppable.stop()` method to an object.

Classes in org.mule.api.lifecycle used by org.mule.transport.quartz
CreateException `CreateException` is thrown when creating an object inside Mule wasn't possible due to inconsistent internal state or wrong input.
Disposable `Disposable` is a lifecycle interface that gets called at the dispose lifecycle stage of the implementing service as the service is being destroyed.
Initialisable `Initialisable` is a lifecycle interface that gets called at the initialise lifecycle stage of the implementing service.
InitialisationException `InitialisationException` is thrown by the initialise method defined in the `org.mule.api.lifecycle.Initialisable` interface.
Lifecycle `DefaultLifecyclePhase` adds lifecycle methods `start`, `stop` and `dispose`.
LifecycleStateEnabled Objects that have an associated lifecycle manager such as `Service` or `Connector` should implement this interface so that the registry lifecycle manager can introspect the lifecycle state of an object.
Startable `Startable` provides an object with a `Startable.start()` method which gets called when the Mule instance gets started.
Stoppable `Stoppable` is a lifecycle interfaqce that introduces a `Stoppable.stop()` method to an object.

Classes in org.mule.api.lifecycle used by org.mule.transport.quartz.jobs
Disposable `Disposable` is a lifecycle interface that gets called at the dispose lifecycle stage of the implementing service as the service is being destroyed.
Initialisable `Initialisable` is a lifecycle interface that gets called at the initialise lifecycle stage of the implementing service.
InitialisationException `InitialisationException` is thrown by the initialise method defined in the `org.mule.api.lifecycle.Initialisable` interface.
Lifecycle `DefaultLifecyclePhase` adds lifecycle methods `start`, `stop` and `dispose`.
Startable `Startable` provides an object with a `Startable.start()` method which gets called when the Mule instance gets started.
Stoppable `Stoppable` is a lifecycle interfaqce that introduces a `Stoppable.stop()` method to an object.

Classes in org.mule.api.lifecycle used by org.mule.transport.rmi
CreateException `CreateException` is thrown when creating an object inside Mule wasn't possible due to inconsistent internal state or wrong input.
Disposable `Disposable` is a lifecycle interface that gets called at the dispose lifecycle stage of the implementing service as the service is being destroyed.
Initialisable `Initialisable` is a lifecycle interface that gets called at the initialise lifecycle stage of the implementing service.
InitialisationException `InitialisationException` is thrown by the initialise method defined in the `org.mule.api.lifecycle.Initialisable` interface.
Lifecycle `DefaultLifecyclePhase` adds lifecycle methods `start`, `stop` and `dispose`.
LifecycleStateEnabled Objects that have an associated lifecycle manager such as `Service` or `Connector` should implement this interface so that the registry lifecycle manager can introspect the lifecycle state of an object.
Startable `Startable` provides an object with a `Startable.start()` method which gets called when the Mule instance gets started.
Stoppable `Stoppable` is a lifecycle interfaqce that introduces a `Stoppable.stop()` method to an object.

Classes in org.mule.api.lifecycle used by org.mule.transport.servlet
CreateException `CreateException` is thrown when creating an object inside Mule wasn't possible due to inconsistent internal state or wrong input.
Disposable `Disposable` is a lifecycle interface that gets called at the dispose lifecycle stage of the implementing service as the service is being destroyed.
Initialisable `Initialisable` is a lifecycle interface that gets called at the initialise lifecycle stage of the implementing service.
InitialisationException `InitialisationException` is thrown by the initialise method defined in the `org.mule.api.lifecycle.Initialisable` interface.
Lifecycle `DefaultLifecyclePhase` adds lifecycle methods `start`, `stop` and `dispose`.
LifecycleStateEnabled Objects that have an associated lifecycle manager such as `Service` or `Connector` should implement this interface so that the registry lifecycle manager can introspect the lifecycle state of an object.
Startable `Startable` provides an object with a `Startable.start()` method which gets called when the Mule instance gets started.
Stoppable `Stoppable` is a lifecycle interfaqce that introduces a `Stoppable.stop()` method to an object.

Classes in org.mule.api.lifecycle used by org.mule.transport.servlet.jetty
CreateException `CreateException` is thrown when creating an object inside Mule wasn't possible due to inconsistent internal state or wrong input.
Disposable `Disposable` is a lifecycle interface that gets called at the dispose lifecycle stage of the implementing service as the service is being destroyed.
Initialisable `Initialisable` is a lifecycle interface that gets called at the initialise lifecycle stage of the implementing service.
InitialisationException `InitialisationException` is thrown by the initialise method defined in the `org.mule.api.lifecycle.Initialisable` interface.
Lifecycle `DefaultLifecyclePhase` adds lifecycle methods `start`, `stop` and `dispose`.
LifecycleStateEnabled Objects that have an associated lifecycle manager such as `Service` or `Connector` should implement this interface so that the registry lifecycle manager can introspect the lifecycle state of an object.
Startable `Startable` provides an object with a `Startable.start()` method which gets called when the Mule instance gets started.
Stoppable `Stoppable` is a lifecycle interfaqce that introduces a `Stoppable.stop()` method to an object.

Classes in org.mule.api.lifecycle used by org.mule.transport.servlet.transformers
Disposable `Disposable` is a lifecycle interface that gets called at the dispose lifecycle stage of the implementing service as the service is being destroyed.
Initialisable `Initialisable` is a lifecycle interface that gets called at the initialise lifecycle stage of the implementing service.

Classes in org.mule.api.lifecycle used by org.mule.transport.soap.axis
Callable `Callable` is used to provide a Service with an interface that supports event calls.
CreateException `CreateException` is thrown when creating an object inside Mule wasn't possible due to inconsistent internal state or wrong input.
Disposable `Disposable` is a lifecycle interface that gets called at the dispose lifecycle stage of the implementing service as the service is being destroyed.
EventListener `EventListener` is a marker interface that is implemented by objects wishing to receive Mule events in managed environments, such as an EJB container.
Initialisable `Initialisable` is a lifecycle interface that gets called at the initialise lifecycle stage of the implementing service.
InitialisationCallback `InitialisationCallback` is used to provide customised initialiation for more complex components.
InitialisationException `InitialisationException` is thrown by the initialise method defined in the `org.mule.api.lifecycle.Initialisable` interface.
Lifecycle `DefaultLifecyclePhase` adds lifecycle methods `start`, `stop` and `dispose`.
LifecycleStateEnabled Objects that have an associated lifecycle manager such as `Service` or `Connector` should implement this interface so that the registry lifecycle manager can introspect the lifecycle state of an object.
Startable `Startable` provides an object with a `Startable.start()` method which gets called when the Mule instance gets started.
Stoppable `Stoppable` is a lifecycle interfaqce that introduces a `Stoppable.stop()` method to an object.

Classes in org.mule.api.lifecycle used by org.mule.transport.soap.axis.wsdl
Disposable `Disposable` is a lifecycle interface that gets called at the dispose lifecycle stage of the implementing service as the service is being destroyed.
Initialisable `Initialisable` is a lifecycle interface that gets called at the initialise lifecycle stage of the implementing service.
Lifecycle `DefaultLifecyclePhase` adds lifecycle methods `start`, `stop` and `dispose`.
LifecycleStateEnabled Objects that have an associated lifecycle manager such as `Service` or `Connector` should implement this interface so that the registry lifecycle manager can introspect the lifecycle state of an object.
Startable `Startable` provides an object with a `Startable.start()` method which gets called when the Mule instance gets started.
Stoppable `Stoppable` is a lifecycle interfaqce that introduces a `Stoppable.stop()` method to an object.

Classes in org.mule.api.lifecycle used by org.mule.transport.ssl
CreateException `CreateException` is thrown when creating an object inside Mule wasn't possible due to inconsistent internal state or wrong input.
Disposable `Disposable` is a lifecycle interface that gets called at the dispose lifecycle stage of the implementing service as the service is being destroyed.
Initialisable `Initialisable` is a lifecycle interface that gets called at the initialise lifecycle stage of the implementing service.
InitialisationException `InitialisationException` is thrown by the initialise method defined in the `org.mule.api.lifecycle.Initialisable` interface.
Lifecycle `DefaultLifecyclePhase` adds lifecycle methods `start`, `stop` and `dispose`.
LifecycleStateEnabled Objects that have an associated lifecycle manager such as `Service` or `Connector` should implement this interface so that the registry lifecycle manager can introspect the lifecycle state of an object.
Startable `Startable` provides an object with a `Startable.start()` method which gets called when the Mule instance gets started.
Stoppable `Stoppable` is a lifecycle interfaqce that introduces a `Stoppable.stop()` method to an object.

Classes in org.mule.api.lifecycle used by org.mule.transport.stdio
CreateException `CreateException` is thrown when creating an object inside Mule wasn't possible due to inconsistent internal state or wrong input.
Disposable `Disposable` is a lifecycle interface that gets called at the dispose lifecycle stage of the implementing service as the service is being destroyed.
Initialisable `Initialisable` is a lifecycle interface that gets called at the initialise lifecycle stage of the implementing service.
InitialisationException `InitialisationException` is thrown by the initialise method defined in the `org.mule.api.lifecycle.Initialisable` interface.
Lifecycle `DefaultLifecyclePhase` adds lifecycle methods `start`, `stop` and `dispose`.
LifecycleStateEnabled Objects that have an associated lifecycle manager such as `Service` or `Connector` should implement this interface so that the registry lifecycle manager can introspect the lifecycle state of an object.
Startable `Startable` provides an object with a `Startable.start()` method which gets called when the Mule instance gets started.
Stoppable `Stoppable` is a lifecycle interfaqce that introduces a `Stoppable.stop()` method to an object.

Classes in org.mule.api.lifecycle used by org.mule.transport.tcp
CreateException `CreateException` is thrown when creating an object inside Mule wasn't possible due to inconsistent internal state or wrong input.
Disposable `Disposable` is a lifecycle interface that gets called at the dispose lifecycle stage of the implementing service as the service is being destroyed.
Initialisable `Initialisable` is a lifecycle interface that gets called at the initialise lifecycle stage of the implementing service.
InitialisationException `InitialisationException` is thrown by the initialise method defined in the `org.mule.api.lifecycle.Initialisable` interface.
Lifecycle `DefaultLifecyclePhase` adds lifecycle methods `start`, `stop` and `dispose`.
LifecycleStateEnabled Objects that have an associated lifecycle manager such as `Service` or `Connector` should implement this interface so that the registry lifecycle manager can introspect the lifecycle state of an object.
Startable `Startable` provides an object with a `Startable.start()` method which gets called when the Mule instance gets started.
Stoppable `Stoppable` is a lifecycle interfaqce that introduces a `Stoppable.stop()` method to an object.

Classes in org.mule.api.lifecycle used by org.mule.transport.udp
CreateException `CreateException` is thrown when creating an object inside Mule wasn't possible due to inconsistent internal state or wrong input.
Disposable `Disposable` is a lifecycle interface that gets called at the dispose lifecycle stage of the implementing service as the service is being destroyed.
Initialisable `Initialisable` is a lifecycle interface that gets called at the initialise lifecycle stage of the implementing service.
InitialisationException `InitialisationException` is thrown by the initialise method defined in the `org.mule.api.lifecycle.Initialisable` interface.
Lifecycle `DefaultLifecyclePhase` adds lifecycle methods `start`, `stop` and `dispose`.
LifecycleStateEnabled Objects that have an associated lifecycle manager such as `Service` or `Connector` should implement this interface so that the registry lifecycle manager can introspect the lifecycle state of an object.
Startable `Startable` provides an object with a `Startable.start()` method which gets called when the Mule instance gets started.
Stoppable `Stoppable` is a lifecycle interfaqce that introduces a `Stoppable.stop()` method to an object.

Classes in org.mule.api.lifecycle used by org.mule.transport.vm
CreateException `CreateException` is thrown when creating an object inside Mule wasn't possible due to inconsistent internal state or wrong input.
Disposable `Disposable` is a lifecycle interface that gets called at the dispose lifecycle stage of the implementing service as the service is being destroyed.
Initialisable `Initialisable` is a lifecycle interface that gets called at the initialise lifecycle stage of the implementing service.
InitialisationException `InitialisationException` is thrown by the initialise method defined in the `org.mule.api.lifecycle.Initialisable` interface.
Lifecycle `DefaultLifecyclePhase` adds lifecycle methods `start`, `stop` and `dispose`.
LifecycleStateEnabled Objects that have an associated lifecycle manager such as `Service` or `Connector` should implement this interface so that the registry lifecycle manager can introspect the lifecycle state of an object.
Startable `Startable` provides an object with a `Startable.start()` method which gets called when the Mule instance gets started.
Stoppable `Stoppable` is a lifecycle interfaqce that introduces a `Stoppable.stop()` method to an object.

Classes in org.mule.api.lifecycle used by org.mule.transport.xmpp
CreateException `CreateException` is thrown when creating an object inside Mule wasn't possible due to inconsistent internal state or wrong input.
Disposable `Disposable` is a lifecycle interface that gets called at the dispose lifecycle stage of the implementing service as the service is being destroyed.
Initialisable `Initialisable` is a lifecycle interface that gets called at the initialise lifecycle stage of the implementing service.
InitialisationException `InitialisationException` is thrown by the initialise method defined in the `org.mule.api.lifecycle.Initialisable` interface.
Lifecycle `DefaultLifecyclePhase` adds lifecycle methods `start`, `stop` and `dispose`.
LifecycleStateEnabled Objects that have an associated lifecycle manager such as `Service` or `Connector` should implement this interface so that the registry lifecycle manager can introspect the lifecycle state of an object.
Startable `Startable` provides an object with a `Startable.start()` method which gets called when the Mule instance gets started.
Stoppable `Stoppable` is a lifecycle interfaqce that introduces a `Stoppable.stop()` method to an object.

Classes in org.mule.api.lifecycle used by org.mule.transport.xmpp.transformers
Disposable `Disposable` is a lifecycle interface that gets called at the dispose lifecycle stage of the implementing service as the service is being destroyed.
Initialisable `Initialisable` is a lifecycle interface that gets called at the initialise lifecycle stage of the implementing service.

Classes in org.mule.api.lifecycle used by org.mule.util.monitor
Disposable `Disposable` is a lifecycle interface that gets called at the dispose lifecycle stage of the implementing service as the service is being destroyed.

Classes in org.mule.api.lifecycle used by org.mule.util.pool
Disposable `Disposable` is a lifecycle interface that gets called at the dispose lifecycle stage of the implementing service as the service is being destroyed.
Initialisable `Initialisable` is a lifecycle interface that gets called at the initialise lifecycle stage of the implementing service.
InitialisationException `InitialisationException` is thrown by the initialise method defined in the `org.mule.api.lifecycle.Initialisable` interface.
Startable `Startable` provides an object with a `Startable.start()` method which gets called when the Mule instance gets started.
Stoppable `Stoppable` is a lifecycle interfaqce that introduces a `Stoppable.stop()` method to an object.

Classes in org.mule.api.lifecycle used by org.mule.util.queue
Startable `Startable` provides an object with a `Startable.start()` method which gets called when the Mule instance gets started.
Stoppable `Stoppable` is a lifecycle interfaqce that introduces a `Stoppable.stop()` method to an object.

Classes in org.mule.api.lifecycle used by org.mule.util.store
Disposable `Disposable` is a lifecycle interface that gets called at the dispose lifecycle stage of the implementing service as the service is being destroyed.
Initialisable `Initialisable` is a lifecycle interface that gets called at the initialise lifecycle stage of the implementing service.
InitialisationException `InitialisationException` is thrown by the initialise method defined in the `org.mule.api.lifecycle.Initialisable` interface.

Classes in org.mule.api.lifecycle used by org.mule.work
Disposable `Disposable` is a lifecycle interface that gets called at the dispose lifecycle stage of the implementing service as the service is being destroyed.
Startable `Startable` provides an object with a `Startable.start()` method which gets called when the Mule instance gets started.

Overview | Package | Class | Use | Tree | Deprecated | Index | Help
PREV NEXT | FRAMES NO FRAMES

Copyright © 2003-2010 MuleSoft, Inc.. All Rights Reserved.