All Classes

Class	Description
AfterPropertiesConfigured	To perform optional initialization on an element after its properties has been configured.
AggregationRepository	Access to a repository to store aggregated exchanges to support pluggable implementations.
AggregationStrategy	A strategy for aggregating two exchanges together into a single exchange.
AliasedX509ExtendedKeyManager	KeyManager to select a key with desired alias while delegating processing to specified KeyManager Can be used both with server and client sockets
AlreadyStoppedException	Exception thrown in situations when a Service has already been stopped.
AnnotationBasedProcessorFactory	Factory to create Processor for annotation based EIPs.
AnnotationScanTypeConverters	A TypeConverter which is capable of annotation scanning for Converter classes and add these as type converters.
ApiEndpoint	Marks the Endpoint as an endpoint from an API based component.
ApiMethod	Represents an API method as part of a parent API.
ApiParam	Used for annotating a UriParam parameter that its for use by API based endpoints.
ApiParams	Used to annotate a nested configuration parameter type (such as a nested Configuration object) which can then be used on a API based component, endpoint.
AsEndpointUri	Indicates that the Camel string/expression should be used as an endpoint uri.
AsPredicate	Indicates that the Camel language/expression should be used as predicate.
AsyncCallback	The callback interface for an AsyncProcessor so that it can notify you when an Exchange is done.
AsyncEndpoint	Marks the Endpoint as support asynchronous non-blocking routing in its consumer and producer.
AsyncProcessor	An asynchronous processor which can process an Exchange in an asynchronous fashion and signal completion by invoking the AsyncCallback.
AsyncProcessorAwaitManager	A manager to handle async routing engine, when Exchanges are being handed over from one thread to another, while the callee thread is blocked waiting for the other threads to complete, before it can continue.
AsyncProcessorAwaitManager.AwaitThread	Information about the thread and exchange that are inflight.
AsyncProcessorAwaitManager.Statistics	Utilization statistics of the this manager.
AsyncProducer	Asynchronous producer
AuthorizationPolicy	A marker for defining the policy to be used for applying authorization to routes.
AutowiredLifecycleStrategy	Marker interface for LifecycleStrategy that are used for auto-wiring components, data formats and languages.
BaseService	A useful base class which ensures that a service is only initialized once and provides some helper methods for enquiring of its status.
BaseSSLContextParameters	Represents configuration options that can be applied in the client-side or server-side context depending on what they are applied to.
BaseSSLContextParameters.SSLContextDecorator	Makes a decorated SSLContext appear as a normal SSLContext.
BaseSSLContextParameters.SSLContextSpiDecorator	Class needed to provide decoration of an existing SSLContext.
BaseSSLContextParameters.SSLServerSocketFactoryDecorator	A decorator that enables the application of configuration options to be applied to created sockets even after this factory has been created and turned over to client code.
BaseSSLContextParameters.SSLSocketFactoryDecorator	A decorator that enables the application of configuration options to be applied to created sockets even after this factory has been created and turned over to client code.
BatchConsumer	A consumer of a batch of message exchanges from an Endpoint
BeanConfigInject	Used to indicate an injection point of a configuration bean (obtained from the Registry, or a new instance is created) into a POJO.
BeanInject	Used to indicate an injection point of a bean obtained from the Registry, into a POJO.
BeanIntrospection	Used for introspecting beans properties via Java reflection; such as extracting current property values, or updating one or more properties etc.
BeanIntrospection.ClassInfo	Structure of an introspected class.
BeanIntrospection.MethodInfo	Structure of an introspected method.
BeanProcessorFactory	Factory for creating a Processor that can invoke a method on a bean and supporting using Camel bean parameter bindings.
BeanProxyFactory	A factory for creating a Proxy for a bean.
BeanRepository	Represents a bean repository used to lookup components by name and type.
BeanScope
BinaryPredicate	A predicate which evaluates a binary expression.
BindToRegistry	Used for binding a bean to the registry.
Body	Marks a parameter as being the body of an inbound Message
BootstrapCloseable	A marker interface for a service, or other kind of process that is only used during bootstrapping Camel.
Breakpoint	Breakpoint are used by the Debugger API.
Breakpoint.State	State of the breakpoint as either active or suspended.
BrowsableEndpoint	An optional interface an Endpoint may choose to implement which allows it to expose a way of browsing the exchanges available.
Builder<T>
BulkTypeConverters	Bulk type converters that often comes out of the box with Apache Camel.
CamelAuthorizationException	An exception thrown for either authentication or authorization errors occurring in a Camel exchange.
CamelBeanPostProcessor	Bean post processor.
CamelClusterEventListener	Marker interface for cluster events
CamelClusterEventListener.Leadership
CamelClusterEventListener.Membership
CamelClusterMember
CamelClusterService
CamelClusterService.Selector
CamelClusterView	Represents the View of the cluster at some given period of time.
CamelContext	Interface used to represent the CamelContext used to configure routes and the policies to use during message exchanges between endpoints.
CamelContextAware	An interface to represent an object which wishes to be injected with the CamelContext
CamelContextCustomizer	To apply custom configurations to CamelContext instances.
CamelContextLifecycle	Lifecycle API for CamelContext.
CamelContextNameStrategy	Strategy for assigning name to a CamelContext.
CamelContextTracker	A CamelContext creation and destruction tracker.
CamelContextTracker.Filter
CamelEvent	This interface is implemented by all events.
CamelEvent.CamelContextEvent
CamelEvent.CamelContextInitializedEvent
CamelEvent.CamelContextInitializingEvent
CamelEvent.CamelContextResumedEvent
CamelEvent.CamelContextResumeFailureEvent
CamelEvent.CamelContextResumingEvent
CamelEvent.CamelContextRoutesStartedEvent
CamelEvent.CamelContextRoutesStartingEvent
CamelEvent.CamelContextRoutesStoppedEvent
CamelEvent.CamelContextRoutesStoppingEvent
CamelEvent.CamelContextStartedEvent
CamelEvent.CamelContextStartingEvent
CamelEvent.CamelContextStartupFailureEvent
CamelEvent.CamelContextStopFailureEvent
CamelEvent.CamelContextStoppedEvent
CamelEvent.CamelContextStoppingEvent
CamelEvent.CamelContextSuspendedEvent
CamelEvent.CamelContextSuspendingEvent
CamelEvent.ExchangeCompletedEvent
CamelEvent.ExchangeCreatedEvent
CamelEvent.ExchangeEvent
CamelEvent.ExchangeFailedEvent
CamelEvent.ExchangeFailureEvent
CamelEvent.ExchangeFailureHandledEvent
CamelEvent.ExchangeFailureHandlingEvent
CamelEvent.ExchangeRedeliveryEvent
CamelEvent.ExchangeSendingEvent
CamelEvent.ExchangeSentEvent
CamelEvent.FailureEvent	This interface is implemented by all events that contain an exception and is used to retrieve the exception in a universal way.
CamelEvent.RouteAddedEvent
CamelEvent.RouteEvent
CamelEvent.RouteRemovedEvent
CamelEvent.RouteStartedEvent
CamelEvent.RouteStartingEvent
CamelEvent.RouteStoppedEvent
CamelEvent.RouteStoppingEvent
CamelEvent.ServiceEvent
CamelEvent.ServiceStartupFailureEvent
CamelEvent.ServiceStopFailureEvent
CamelEvent.StepCompletedEvent
CamelEvent.StepEvent
CamelEvent.StepFailedEvent
CamelEvent.StepStartedEvent
CamelEvent.Type
CamelException	Base class for all Camel checked exceptions typically thrown by a Processor
CamelExchangeException	An exception caused by a specific message Exchange
CamelExecutionException	Exception occurred during execution/processing of an Exchange.
CamelInternalProcessorAdvice<T>	An advice (before and after) to execute cross cutting functionality in the Camel routing engine.
CamelLogger	A logger which logs to a slf4j Logger.
CamelPreemptiveClusterService	A CamelPreemptiveClusterService is a CamelClusterService that manages CamelPreemptiveClusterViews.
CamelPreemptiveClusterView	A CamelPreemptiveClusterView is a CamelClusterView that can be externally disabled by another controller.
CamelUnitOfWorkException	A UnitOfWork failed with a number of caused exceptions.
CatalogCamelContext	Catalog level interface for the CamelContext
Category	This enum set various categories options into the UriEndpoint.
Channel	Channel acts as a channel between Processors in the route graph.
CipherSuitesParameters	Represents a list of TLS/SSL cipher suite names.
CircuitBreakerConstants
ClaimCheckRepository	Access to a repository of keys to implement the Claim Check pattern.
ClassResolver	A class resolver for loading classes in a loosly coupled manner to cater for different platforms such as standalone, web container, j2ee container and OSGi platforms.
ClientAuthentication	Represents the options for the client authentication settings of a server socket.
CloudServiceFactory
Component	A component is a factory of Endpoint objects.
Component
ComponentAware	An interface to represent an object which wishes to be injected with a Component.
ComponentCustomizer	To apply custom configurations to Component instances.
ComponentCustomizer.Builder<T extends Component>	A fluent builder to create a ComponentCustomizer instance.
ComponentCustomizer.Policy	Used as additional filer mechanism to control if customizers need to be applied or not.
ComponentExtension	Marker interface for component extensions.
ComponentNameResolver	Discovers which components are available on the classpath.
ComponentResolver	Represents a resolver of components from a URI to be able to auto-load them using some discovery mechanism like org.apache.camel.impl.DefaultComponentResolver
ComponentVerifierExtension	Defines the interface used for validating component/endpoint parameters.
ComponentVerifierExtension.Result	The result of a verification
ComponentVerifierExtension.Result.Status	Status of the verification
ComponentVerifierExtension.Scope	The scope defines how the parameters should be verified.
ComponentVerifierExtension.VerificationError	This interface represents a detailed error in case when the verification fails.
ComponentVerifierExtension.VerificationError.Attribute	Interface defining an attribute which is a key for the detailed error messages.
ComponentVerifierExtension.VerificationError.Code	Interface defining an error code.
ComponentVerifierExtension.VerificationError.ExceptionAttribute	Attributes for details about an exception that was raised
ComponentVerifierExtension.VerificationError.GroupAttribute	Group related details
ComponentVerifierExtension.VerificationError.HttpAttribute	HTTP related error details
ComponentVerifierExtension.VerificationError.StandardCode	Standard set of error codes
Condition	A condition to define when a given Exchange matches when is being routed.
ConfigurationPropertiesValidationResult	Details result of validating configuration properties (eg application.properties for camel-main).
Configurer	An annotation used to mark classes to indicate code capable of configuring its options via a getter/setters that can be called via Camels PropertyConfigurer.
ConfigurerResolver	A pluggable strategy for resolving different configurers in a loosely coupled manner
ConfigurerStrategy	Strategy for configurers.
ConstantProvider
Consume	Subscribes a method to an Endpoint either via its URI or via the name of the endpoint reference which is then resolved in a registry such as the Spring Application Context.
Consumer	A consumer of message exchanges from an Endpoint.
ConsumerCache	Cache containing created PollingConsumer.
ConsumerTemplate	Template for working with Camel and consuming Message instances in an Exchange from an Endpoint.
Contract	A Contract which represents the input type and/or output type of the Endpoint or Processor.
Converter	An annotation used to mark classes and methods to indicate code capable of converting from a type to another type which are then auto-discovered using the Type Conversion Support
Dataformat
DataFormat	Represents a data format used to marshal objects to and from streams such as Java Serialization or using JAXB2 to encode/decode objects using XML or using SOAP encoding.
DataFormatContentTypeHeader	Special accessor for a DataFormat
DataFormatCustomizer	To apply custom configurations to DataFormat instances.
DataFormatCustomizer.Builder<T extends DataFormat>	A fluent builder to create a DataFormatCustomizer instance.
DataFormatCustomizer.Policy	Used as additional filer mechanism to control if customizers need to be applied or not.
DataFormatFactory	A factory to create DataFormat.
DataFormatName	The name of the DataFormat which allows to know which kind of data format the implementation is.
DataFormatResolver	Represents a resolver of data formats.
DataType	Represents the data type URN which is used for message data type contract.
DataTypeAware	Allows Message to store a DataType which represents the data type of the Message.
Debugger	A debugger which allows tooling to attach breakpoints which is is being invoked when Exchanges is being routed.
DeferredContextBinding	Used to indicate that if the target type is CamelContextAware, the context does not need to be mandatory injected during bean post processing but can be injected later on as example during Camel Context configuration.
DeferServiceFactory	Factory to create services such as Producers and defer starting the created service, until CamelContext has been started.
DelegateEndpoint	An interface to represent an Endpoint which are delegated.
DelegateProcessor	Interface to be used for processors that delegate to the real processor
DiscoverableService
DslProperty	Internal annotation used to include fields otherwise excluded because annotate with XmlTransient.
DynamicRouter	Indicates that this method is to be used as a Dynamic Router routing the incoming message through a series of processing steps.
EagerClassloaded	Marks this class to be eager loaded by the JDK classloader so the class is already loaded when Camel is started.
Endpoint	An endpoint implements the Message Endpoint pattern and represents an endpoint that can send and receive message exchanges
EndpointAware	An interface to represent an object such as a Processor that uses an Endpoint
EndpointConsumerResolver	An interface to represent an object that can be resolved as a consumer Endpoint
EndpointInject	Used to indicate an injection point of an Endpoint, Producer or ProducerTemplate into a POJO.
EndpointProducerResolver	An interface to represent an object that can be resolved as a producer Endpoint
EndpointRegistry<K>	Registry to cache endpoints in memory.
EndpointStrategy	Endpoint strategy with callback invoked when an Endpoint is about to be registered to the endpoint registry in CamelContext.
EndpointUriFactory	Factory to create Endpoint URI string from a Map of parameters.
EndpointUtilizationStatistics	Various statistics about endpoint utilization, such as from EIP patterns that uses dynamic endpoints.
EndpointValidationResult	Details result of validating endpoint uri.
ErrorHandler	An interface used to represent an error handler
ErrorHandlerAware	An interface for Processor aware of its ErrorHandler which are wrapped via the Channel during route initialization, or specially used by RecipientList EIP annotation.
ErrorHandlerFactory	Factory for creating ErrorHandlers.
ErrorHandlerRedeliveryCustomizer	Customizer for ErrorHandler which supports redeliveries.
EventFactory	Factory to create events that are emitted when such an event occur.
EventNotifier	Notifier to send events.
ExceptionHandler	A Strategy pattern for handling exceptions; particularly in asynchronous processes such as consumers.
Exchange	An Exchange is the message container holding the information during the entire routing of a Message received by a Consumer.
ExchangeConstantProvider	Generated by camel build tools - do NOT edit this file!
ExchangeException	Marks a parameter as being the exception set on an exchange
ExchangeFactory	Factory used by Consumer to create Camel Exchange holding the incoming message received by the consumer.
ExchangeFactoryManager	Manages ExchangeFactory.
ExchangeFormatter	A plugin used to turn an Exchange into a String representation usually to be used for logging or tracing purposes.
ExchangePattern	Represents the kind of message exchange pattern
ExchangeProperties	Marks a parameter as being an injection point of the exchange properties of an Exchange
ExchangeProperty	Marks a parameter as being an injection point of a property of an Exchange
ExchangePropertyKey	An enum of common and known keys for exchange properties used by camel-core.
ExchangeTimedOutException	An exception thrown if an InOut exchange times out receiving the OUT message
ExecutorServiceAware	Is used for easy configuration of ExecutorService.
ExecutorServiceManager	Strategy to create thread pools.
ExpectedBodyTypeException	Thrown if the body could not be converted to the required type
Experimental	An experimental user-facing API.
Expression	An expression provides a plugin strategy for evaluating expressions on a message exchange.
ExpressionEvaluationException	An exception thrown if evaluation of the expression failed.
ExpressionFactory	A factory for creating Expression
ExpressionFactoryAware	When an instance is aware of ExpressionFactory.
ExpressionIllegalSyntaxException	An exception thrown if the expression contains illegal syntax.
ExpressionResultTypeAware	Represents an Expression or Predicate that supports a result type.
ExtendedCamelContext	Extended CamelContext which contains the methods and APIs that are not primary intended for Camel end users but for SPI, custom components, or more advanced used-cases with Camel.
ExtendedExchange	Extended Exchange which contains the methods and APIs that are not intended for Camel end users but used internally by Camel for optimization purposes, SPI, custom components, or more advanced used-cases with Camel.
ExtendedPropertyConfigurerGetter	A marker interface to identify the object as being a configurer which can provide details about the options the configurer supports.
ExtendedStartupListener	Extended StartupListener that is invoked when the CamelContext is fully started.
FactoryFinder	Finder to find factories from the resource classpath, usually META-INF/services/org/apache/camel/.
FactoryFinderResolver	Represents a resolver for FactoryFinder
FailedToCreateConsumerException	Thrown if Camel failed to create a consumer for a given endpoint.
FailedToCreateProducerException	Thrown if Camel failed to create a producer for a given endpoint.
FailedToCreateRouteException	Exception when failing to create a Route.
FailedToCreateRouteFromTemplateException	Exception when failing to create a Route from a RouteTemplateDefinition.
FailedToStartComponentException	Exception when failing to start a Component.
FailedToStartRouteException	Exception when failing to start a Route.
FallbackConverter	Deprecated. use @Converter(fallback = true) instead
FilterParameters	Represents a set of regular expression based filter patterns for including and excluding content of some type.
FilterParameters.Patterns	An immutable collection of compiled includes and excludes filter Patterns.
FluentProducerTemplate	Template for working with Camel and sending Message instances in an Exchange to an Endpoint using a fluent build style.
GeneratedPropertyConfigurer	A auto generated PropertyConfigurer for fast configuration of Camel components & endpoints.
GlobalEndpointConfiguration	Global endpoint configurations which can be set as defaults when Camel creates new Endpoints.
GlobalSSLContextParametersSupplier	A global Supplier of SSLContextParameters to be used in Camel registry.
GroupAware	To allow objects to be injected with an group.
Handler	Marks a method on a POJO as being the preferred method to invoke when Camel looks for methods to invoke using the BeanEndpoint.
HasCamelContext	A simple marker interface for an object which holds a CamelContext.
HasGroup	A simple marker interface for an object which has belongs to a group Group which is useful for group related operation such as clustering, JMX style API
HasId	A simple marker interface for an object which has a unique ID which is useful for referring to objects in REST or JMX style APIs
Header	Marks a parameter as being a header on an inbound Message
HeaderFilterStrategy	Interface to allow plug-able implementation to filter header to and from Camel message.
HeaderFilterStrategy.Direction	The direction is either IN or OUT.
HeaderFilterStrategyAware	An interface to represent an object which can make use of injected HeaderFilterStrategy.
Headers	Marks a parameter as being an injection point of the headers of an inbound Message
HeadersMapFactory	Factory to create the Map implementation to use for storing headers on Message.
HealthCheck	Health check
HealthCheck.Result	Response to an health check invocation.
HealthCheck.State
HealthCheckConfiguration	Configuration for HealthCheck.
HealthCheckConfiguration.Builder
HealthCheckFilter	Health check filter definition.
HealthCheckHelper	Helper for invoking HealthCheck's.
HealthCheckRegistry	A registry for health checks.
HealthCheckRepository	A repository for health checks.
HealthCheckResultBuilder	A builder helper to create a HealthCheck result.
IdAware	To allow objects to be injected with an id, such as EIP Processors which has been defined from Camel routes.
IdempotentRepository	Access to a repository of Message IDs to implement the Idempotent Consumer pattern.
InflightRepository	A repository which tracks in flight Exchanges.
InflightRepository.InflightExchange	Information about the inflight exchange.
Injector	A pluggable strategy for creating and possibly dependency injecting objects which could be implemented using straight forward reflection or using Spring or CDI to perform dependency injection.
InOnly	Marks methods as being ExchangePattern.InOnly for one way asynchronous invocation when using Bean Integration to overload the default value which is ExchangePattern.InOut for request/reply if no annotations are used.
InOut	Marks a method as being ExchangePattern.InOut when a class or interface has been annotated with InOnly when using Bean Integration.
InterceptEndpointFactory	A factory to create Endpoint which are intercepted.
InterceptSendToEndpoint	This is an endpoint when sending to it, is intercepted and is routed in a detour, with the following flow: before, send to original endpoint (can be skipped), after (optional).
InterceptStrategy	The purpose of this interface is to allow an implementation to wrap processors in a route with interceptors.
InternalProcessor	Internal Processor that Camel routing engine used during routing for cross cutting functionality such as: Execute UnitOfWork Keeping track which route currently is being routed Execute RoutePolicy Gather JMX performance statics Tracing Debugging Message History Stream Caching Transformer ...
InternalProcessorFactory	A factory used internally by Camel to create Processor and other internal building blocks.
InvalidPayloadException	Is thrown if the payload from the exchange could not be retrieved because of being null, wrong class type etc.
InvalidPayloadRuntimeException	Runtime version of the InvalidPayloadException.
InvalidPropertyException	An exception caused when an invalid property name is used on an object
InvokeOnHeader	Marks a method as being invoked for a specific header value.
InvokeOnHeaderStrategy	Pluggable strategy for invoking InvokeOnHeader.
IsSingleton	Used for defining if a given class is singleton or not.
JdkService
JSonSchemaResolver	Pluggable resolver to load JSON schema files for components, data formats, languages etc.
JsseParameters	Base class that provides optional integration with core Camel capabilities.
KeyManagersParameters	A representation of configuration options for creating and loading KeyManager instance(s).
KeyStoreParameters	A representation of configuration options for creating and loading a KeyStore instance.
Language
Language	Represents a language to be used for Expression or Predicate instances
LanguageCustomizer	To apply custom configurations to Language instances.
LanguageCustomizer.Builder<T extends Language>	A fluent builder to create a LanguageCustomizer instance.
LanguageCustomizer.Policy	Used as additional filer mechanism to control if customizers need to be applied or not.
LanguageResolver	A pluggable strategy for resolving different languages in a loosely coupled manner
LanguageValidationResult	Validation result of parsing a language expression or predicate
LifecycleStrategy	Strategy for lifecycle notifications.
LoadablePropertiesSource	A source for properties that can be loaded all at once during initialization, such as loading .properties files.
LoadPropertiesException	Represents a failure to open a Properties file at a given URL
LocalBeanRepositoryAware	Allows a BeanRepository to temporary have a local repository take precedence, such as when creating route templates to give more flexibility.
LoggingLevel	Used to configure the logging levels
LogListener	An event listener SPI for logging.
ManagementAgent	Camel JMX service agent
ManagementInterceptStrategy
ManagementInterceptStrategy.InstrumentationProcessor<T>
ManagementMBeanAssembler	An assembler to assemble a RequiredModelMBean which can be used to register the object in JMX.
ManagementNameStrategy	Strategy for assigning the name part of the ObjectName for a managed CamelContext.
ManagementObjectNameStrategy	Strategy for computing ObjectName names for the various beans that Camel register for management.
ManagementObjectStrategy	Strategy for creating the managed object for the various beans Camel register for management.
ManagementStatisticsLevel	Level of granularity for performance statistics enabled
ManagementStrategy	Strategy for management.
ManagementStrategyFactory	Service Factory for ManagementStrategy
MaskingFormatter	A plugin used to mask a log String, for example security information like password or passphrase.
Message	Implements the Message pattern and represents an inbound or outbound message as part of an Exchange.
MessageHistory	Represents the history of a Camel Message how it was routed by the Camel routing engine.
MessageHistoryFactory	A factory to create MessageHistory instances.
Metadata	Meta data for EIPs, components, data formats and other Camel concepts
MetaDataExtension
MetaDataExtension.MetaData
MockSendToEndpointStrategyFactory	Factory for intercepting sending to endpoint pattern and sending to mock component.
ModelJAXBContextFactory	Factory to abstract the creation of the Model's javax.xml.bind.JAXBContext.
ModelReifierFactory	Factory that uses reifiers to build an entity from a given model.
ModelToXMLDumper	SPI for dumping model definitions into XML representation.
MultipleConsumersSupport	Endpoint can optionally implement this interface to indicate whether or not it supports multiple consumers.
NamedNode	Represents a node in the routes which is identified by an id.
NamedRoute	Represents a node in the routes which is identified as a route.
NamespaceAware	Represents an object which is aware of the namespaces in which its used such as XPath and XQuery type expressions so that the current namespace context can be injected
Navigate<T>	Implementations support navigating a graph where you can traverse forward and each next returns a List of outputs of type T that can contain 0..n nodes.
NodeIdFactory	Factory to generate unique ids for model nodes.
NoFactoryAvailableException	Thrown if no factory resource is available for the given URI
NonManagedService	A marker to indicate the Service should not be registered in JMX for management.
NormalizedEndpointUri	An Uri which has been normalized.
NoSuchBeanException	A runtime exception if a given bean could not be found in the Registry
NoSuchEndpointException	A runtime exception thrown if a routing processor such as a recipient list is unable to resolve an Endpoint from a URI.
NoSuchHeaderException	An exception caused when a mandatory header is not available on a message Exchange
NoSuchLanguageException	A runtime exception thrown if an attempt is made to resolve an unknown language definition.
NoSuchPropertyException	An exception caused when a mandatory property is not available on a message Exchange
NotifyBuilderMatcher	Allows to be used in combination with NotifyBuilder as external predicate implementations to compute if the exchange matches.
NoTypeConversionAvailableException	An exception thrown if a value could not be converted to the required type
OnCamelContextEvent	Marker interface used to make it easy to discover CamelContext related event handlers from the registry.
OnCamelContextInitialized	Notification on an initialized a CamelContext.
OnCamelContextInitializing	Notification on initializing a CamelContext.
OnCamelContextStart	Notification on starting a CamelContext.
OnCamelContextStarted	Notification on a started CamelContext.
OnCamelContextStarting	Notification on starting a CamelContext.
OnCamelContextStop	Notification on stopping a CamelContext.
OnCamelContextStopped	Notification on a stopped CamelContext.
OnCamelContextStopping	Notification on stopping a CamelContext.
OptimisticLockingAggregationRepository	A specialized AggregationRepository which also supports optimistic locking.
OptimisticLockingAggregationRepository.OptimisticLockingException	Exception used by an AggregationRepository to indicate that an optimistic update error has occurred and that the operation should be retried by the caller.
Ordered	Interface to be implemented by objects that should be orderable, such as with a Collection.
PackageScanClassResolver	A resolver that can find classes based on package scanning.
PackageScanFilter	Filter that can be used with the PackageScanClassResolver resolver.
PackageScanResourceResolver	A resolver that can find resources based on package scanning.
Pattern	Marks a method as having a specific kind of ExchangePattern for use with Bean Integration to overload the default value which is ExchangePattern.InOut for request/reply if no annotations are used.
Policy	A strategy capable of applying interceptors to a processor.
PollingConsumer	Represents a Polling Consumer where the caller polls for messages when it is ready.
PollingConsumerPollingStrategy	Strategy that allows Consumers to influence the PollingConsumer.
PollingConsumerPollStrategy	Strategy for a PollingConsumer when polling an Endpoint.
PooledExchange	Pooled Exchange which contains the methods and APIs that are not intended for Camel end users but used internally by Camel for optimizing memory footprint by reusing exchanges created by Consumers via ExchangeFactory.
PooledExchange.OnDoneTask	Task to execute when the exchange is done.
PooledObjectFactory<T>	Factory for pooled objects or tasks.
PooledObjectFactory.Statistics	Utilization statistics of the this factory.
Predicate	Evaluates a binary predicate on the message exchange.
PredicateFactory	A factory for creating Predicate
PredicateFactoryAware	When an instance is aware of PredicateFactory.
Processor	A processor is used to implement the Event Driven Consumer and Message Translator patterns and to process message exchanges.
ProcessorExchangeFactory	Factory used by Processor (EIPs) when they create copies of the processed Exchange.
ProcessorFactory	A factory to create Processor based on the definition.
Produce	Marks a field or property as being a producer to an Endpoint either via its URI or via the name of the endpoint reference which is then resolved in a registry such as the Spring Application Context.
Producer	Provides a channel on which clients can create and invoke message exchanges on an Endpoint.
ProducerCache	Cache containing created Producer.
ProducerCache.AsyncProducerCallback	Callback for sending a exchange message to a endpoint using an AsyncProcessor capable producer.
ProducerTemplate	Template for working with Camel and sending Message instances in an Exchange to an Endpoint.
PropertiesComponent	Component for property placeholders and loading properties from sources (such as .properties file from classpath or file system)
PropertiesFunction	A function that is applied instead of looking up a property placeholder.
PropertiesSource	A source for properties.
PropertyBindingException	Error binding property to a bean.
PropertyConfigurer	A marker interface to identify the object as being configurable via a configurer class.
PropertyConfigurerAware	An interface to represent an object which is capable of configuring via PropertyConfigurer.
PropertyConfigurerGetter	A marker interface to identify the object as being a configurer which can provide details about the options the configurer supports.
PropertyInject	Used to indicate an injection point of a property placeholder into a POJO.
ProxyInstantiationException	Exception indicating a failure while trying to create a proxy of a given type and on a given endpoint
ReactiveExecutor	SPI to plugin different reactive engines in the Camel routing engine.
RecipientList	Indicates that this method is to be used as a Dynamic Recipient List routing the incoming message to one or more endpoints.
RecoverableAggregationRepository	A specialized AggregationRepository which also supports recovery.
Registry	Represents a BeanRepository which may also be capable of binding beans to its repository.
ReifierStrategy	Strategy for reifiers.
ResolveEndpointFailedException	A runtime exception thrown if an Endpoint cannot be resolved via URI
Resource	Describe a resource, such as a file or class path resource.
ResourceLoader	SPI for loading resources.
ResourceResolver
ResourceResolver	SPI for loading resources.
RestApiConsumerFactory	Allows SPI to plugin a RestApiConsumerFactory that creates the Camel Consumer responsible for handling incoming HTTP GET requests from clients that request to access the REST API documentation.
RestApiProcessorFactory	Allows SPI to plugin a RestApiProcessorFactory that creates the Camel Processor responsible for servicing and generating the REST API documentation.
RestBindingJaxbDataFormatFactory	SPI for setting up XML data format (JAXB) for rest-dsl.
RestConfiguration	Configuration use by RestConsumerFactory and RestApiConsumerFactory for Camel components to support the Camel rest DSL.
RestConfiguration.RestBindingMode
RestConfiguration.RestHostNameResolver
RestConsumerFactory	Allows SPI to plugin a RestConsumerFactory that creates the Camel Consumer responsible for handling incoming HTTP requests from clients that request to access REST services which has been created using the rest-dsl.
RestProducerFactory	Allows SPI to plugin a RestProducerFactory that creates the Camel Producer responsible for performing HTTP requests to call a remote REST service.
RestRegistry	A registry of all REST services running within the CamelContext which have been defined and created using the Rest DSL.
RestRegistry.RestService	Details about the REST service
RestRegistryFactory	A factory for RestRegistry.
RollbackExchangeException	Exception used for forcing an Exchange to be rolled back.
Route	A Route defines the processing used on an inbound message exchange from a specific Endpoint within a CamelContext.
RouteAware	An interface to represent an object which wishes to be injected with a Route such as Consumer which is the consumer for a route.
RouteController	Controller for managing the lifecycle of all the Route's.
RouteError
RouteError.Phase
RouteFactory	A factory to create Route
RouteIdAware	To allow objects to be injected with the route id
RoutePolicy	Policy for a Route which allows controlling the route at runtime.
RoutePolicyFactory	A factory to create RoutePolicy and assign to routes automatic.
RoutesBuilder	A routes builder is capable of building routes using the builder and model classes.
RoutesBuilderLoader	SPI for loading RoutesBuilder from a Resource.
RoutesLoader
RoutesLoader	SPI for loading RoutesBuilder from a list of Resource.
RouteStartupOrder	Information about a route to be started where we want to control the order in which they are started by CamelContext.
RouteTemplateContext	The context used during creating a Route from a route template.
RouteTemplateContext.BeanSupplier<T>	Used for template beans to supply the local bean the route template should use when creating route(s).
RouteTemplateLoaderListener	Listener when route templates is loaded from a Resource.
RouteTemplateParameterSource	Source for parameters used when creating routes from route templates.
RoutingSlip	Indicates that this method is to be used as a Routing Slip routing the incoming message through a series of processing steps.
RuntimeCamelCatalog	Runtime catalog which limited API needed by components that supports ComponentVerifierExtension.
RuntimeCamelException	Base class for all Camel unchecked exceptions.
RuntimeConfiguration	Various runtime configuration options used by CamelContext and Route for cross cutting functions such as tracing, delayer, stream cache and the like.
RuntimeEndpointRegistry	A registry which listen for runtime usage of Endpoint during routing in Camel.
RuntimeEndpointRegistry.Statistic	Statistics gathered about the endpoint.
RuntimeExchangeException	A runtime exception caused by a specific message Exchange
RuntimeExpressionException	Thrown if an expression evaluation fails
RuntimeTransformException	Thrown if a message transformation fails
SafeCopyProperty	An interface that allows safe copy (deep clone) of property value object when creating copy of Exchange objects.
ScheduledPollConsumerScheduler	A pluggable scheduler for org.apache.camel.support.ScheduledPollConsumer consumers.
ScriptingLanguage	Represents a Language which is a general purpose scripting languages such as groovy, joor and others.
SecureRandomParameters
SecureSocketProtocolsParameters	Represents a list of TLS/SSL cipher suite names.
SendDynamic
SendDynamicAware	Used for components that can optimise the usage of org.apache.camel.processor.SendDynamicProcessor (toD) to reuse a static Endpoint and Producer that supports using headers to provide the dynamic parts.
SendDynamicAware.DynamicAwareEntry	An entry of detailed information from the recipient uri, which allows the SendDynamicAware implementation to prepare pre- and post- processor and the static uri to be used for the optimised dynamic to.
Service	Represents the core lifecycle API for services which can be initialized, started and stopped
ServiceCallConstants
ServiceChooser	Allows SPIs to implement custom Service Chooser.
ServiceChooserAware	An interface to represent an object which wishes to be injected with a ServiceChooser
ServiceChooserFactory	A factory to create ServiceChooser
ServiceDefinition	Represents a Service.
ServiceDiscovery	Allows SPIs to implement custom Service Discovery.
ServiceDiscoveryAware	An interface to represent an object which wishes to be injected with a ServiceDiscovery
ServiceDiscoveryFactory	A factory to create ServiceDiscovery
ServiceExpressionFactory	A factory to create Expression
ServiceFactory<T>
ServiceFactory
ServiceFilter	Allows SPIs to implement custom Service Filter.
ServiceFilterAware	An interface to represent an object which wishes to be injected with a ServiceFilter
ServiceFilterFactory	A factory to create ServiceFilter
ServiceHealth
ServiceHelper	A collection of helper methods for working with Service objects.
ServiceLoadBalancer	Represents a Load Balancer.
ServiceLoadBalancerFactory	A factory to create LoadBalancer
ServiceLoadBalancerFunction<T>	Represents a load balancer function to be executed by the LoadBalancer.
ServiceRegistry
ServiceRegistry.Selector	A selector used to pick up a service among a list.
ServiceStatus	Represents the status of a Service instance
ServiceSupport	A useful base class which ensures that a service is only initialized once and provides some helper methods for enquiring of its status.
SharedInternalProcessor	A Shared (thread safe) internal Processor that Camel routing engine used during routing for cross cutting functionality such as: Execute UnitOfWork Keeping track which route currently is being routed Execute RoutePolicy Gather JMX performance statics Tracing Debugging Message History Stream Caching Transformer ...
ShutdownableService	A Service which is capable of being shut down.
ShutdownAware	Allows Consumer to fine grained control on shutdown which mostly have to cater for in-memory based components.
ShutdownPrepared	Allows a Service to prepare for shutdown.
ShutdownRoute	Represents the options available when shutting down routes.
ShutdownRunningTask	Represents the kind of options for what to do with the current task when shutting down.
ShutdownStrategy	Pluggable shutdown strategy executed during shutdown of Camel and the active routes.
SimpleExecutorService	Marker interface to signal that a ExecutorService is simple and tasks are either only submitted via ExecutorService.submit(Runnable) or executed via Executor.execute(Runnable) methods.
SSLContextClientParameters	Configuration model for client side JSSE options.
SSLContextParameters	Represents SSLContext configuration options used in instantiating an SSLContext instance.
SSLContextParametersAware	Indicates that an object is able to use the global SSLContextParameters if configured.
SSLContextServerParameters
StartupListener	Allows objects to be notified when CamelContext has almost done all work when starting.
StartupStep	Recording state of steps during startup to capture execution time, and being able to emit events to diagnostic tools such as Java Flight Recorder.
StartupStepRecorder	To record StartupStep during startup to allow to capture diagnostic information to help troubleshoot Camel applications via various tooling such as Java Flight Recorder.
StartupSummaryLevel	Controls the level of information logged during startup (and shutdown) of CamelContext.
StatefulService	A Service which has all the lifecycle events and offers details about its current state.
StateRepository<K,V>	This StateRepository holds a set of key/value pairs for defining a particular state of a component.
StaticExpression	Marked if the Expression or Predicate is based from a constant value (ie is static).
StaticService	Marker for indicating the Service is a static service (only one instance per CamelContext).
StreamCache	Tagging interface to indicate that a type is capable of caching the underlying data stream.
StreamCacheException
StreamCachingStrategy	Strategy for using stream caching.
StreamCachingStrategy.SpoolRule	Rule for determine if stream caching should be spooled to disk or kept in-memory.
StreamCachingStrategy.SpoolUsedHeapMemoryLimit	Used for selecting if the memory limit is committed or maximum heap memory setting.
StreamCachingStrategy.Statistics	Utilization statistics of stream caching.
SuggestionStrategy	Strategy to provide suggestions for unknown endpoint options
SupervisingRouteController	A supervising capable RouteController that delays the startup of the routes after the camel context startup and takes control of starting the routes in a safe manner.
Suspendable	Marker interface to indicate a custom component has custom implementation for suspending the SuspendableService service.
SuspendableService	A Service which is also capable of suspending and resuming.
Synchronization	Provides a hook for custom Processor or Component instances to respond to completed or failed processing of an Exchange rather like Spring's TransactionSynchronization
SynchronizationRouteAware	An extended Synchronization which is route aware.
SynchronizationVetoable	A vetoable Synchronization.
ThreadPoolFactory	Creates ExecutorService and ScheduledExecutorService objects that work with a thread pool for a given ThreadPoolProfile and ThreadFactory.
ThreadPoolProfile	A profile which defines thread pool settings.
TimeoutMap<K,V>	Represents a map of values which timeout after a period of inactivity.
TimeoutMap.Listener<K,V>
TimeoutMap.Listener.Type
TimerListener	Listener for receiving timer events.
Traceable	Traceable processors allowing easier tracing using constructed labels to help identify the processor and where it's defined in the route model.
Tracer	SPI for tracing messages.
TransactedPolicy	A marker for defining the policy to be used for applying transaction to routes.
Transformer	Transformer performs message transformation according to the declared data type.
TransformerRegistry<K>	Registry to cache transformers in memory.
TrustManagersParameters
TypeConversionException	Exception when failing during type conversion.
TypeConverter	A pluggable strategy to be able to convert objects to different types such as to and from String, InputStream/OutputStream, Reader/Writer, Document, byte[], ByteBuffer etc
TypeConverterExists	What to do if attempting to add a duplicate type converter
TypeConverterExistsException	Exception when failing to add type converters due there is already an existing type converter.
TypeConverterLoader	A pluggable strategy to load type converters into a TypeConverterRegistry from some kind of mechanism.
TypeConverterLoaderException	Exception when failing to load type converters.
TypeConverterRegistry	Registry for type converters.
TypeConverterRegistry.Statistics	Utilization statistics of the this registry.
TypeConverters	A tagging interface to mark this class implements type converters using the Converter annotations.
UnitOfWork	An object representing the unit of work processing an Exchange which allows the use of Synchronization hooks.
UnitOfWorkFactory	Factory to create UnitOfWork.
UriEndpoint	Represents an annotated Camel Endpoint which can have its properties (and the properties on its consumer) injected from the Camel URI path and its query parameters
UriFactoryResolver	A pluggable strategy for resolving different URI factories in a loosely coupled manner.
UriParam	Represents an injection point of a Camel Uri parameter value on an Endpoint or Consumer, usually configured via a URI style query parameter in a URI
UriParams	Used to annotate a nested configuration parameter type (such as a nested Configuration object) which can then be used on a Component, Endpoint and/or Consumer and then be configured via Camel URI query arguments.
UriPath	Represents an injection point of a Camel Uri path value (the remaining part of a Camel URI without any query arguments)
UuidGenerator	Generator to generate UUID strings.
ValidationException	The base class for any validation exception, such as org.apache.camel.processor.validation.SchemaValidationException so that it is easy to treat all validation errors in a similar way irrespective of the particular validation technology used.
Validator	Validator performs message content validation according to the declared data type.
ValidatorRegistry<K>	Registry to cache validators in memory.
ValueHolder<V>	Holder object for a given value.
VetoCamelContextStartException	An exception to veto starting CamelContext.
WaitForTaskToComplete	Represent the kinds of options for wait for tasks to complete.
WrapAwareProcessor	An interface to represent an object which wraps a Processor.
WrappedFile<T>	Wraps a file.
XMLRoutesDefinitionLoader	Deprecated. use RoutesLoader
YamlIn
YamlOut
YamlProperty
YamlType