Uses of Package org.mule.api.lifecycle (Mule ESB 3.3.0 API)

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.el
org.mule.el.mvel
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.cep
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
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.atom
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.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.sxc
org.mule.module.ws.config.spring.factories
org.mule.module.ws.construct
org.mule.module.xml.el
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.correlation
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.service.processor
org.mule.source
org.mule.tck.functional	Helper classes and interfaces used by Mule fnctional tests.
org.mule.tck.property
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.config.spring.factories
org.mule.transport.http.construct
org.mule.transport.http.filters
org.mule.transport.http.servlet
org.mule.transport.http.transformers
org.mule.transport.jdbc	Provides jdbc transport.
org.mule.transport.jdbc.store
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.jndi
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.sftp
org.mule.transport.sftp.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`.
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.
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.
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.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
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.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.el
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.el.mvel
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.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.cep
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.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.
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.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
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.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
InitialisationException `InitialisationException` is thrown by the initialise method defined in the `org.mule.api.lifecycle.Initialisable` interface.
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.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.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.
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.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.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.el
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.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`.
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.
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.correlation
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
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.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.service.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.
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.property
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.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.
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.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
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.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.transport.http.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.transport.http.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.transport.http.servlet
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.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.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.jdbc.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.

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.jndi
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.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.sftp
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.sftp.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

Uses of Packageorg.mule.api.lifecycle

Uses of Package
org.mule.api.lifecycle