All Classes and Interfaces
Class
Description
A specialization of
AbstractComplexModel which also implements HasConnectionProviderModels,
HasSourceModels and HasOperationModelsBase class for immutable implementations of a
ComponentModelBase class for immutable implementations of a
ComponentModelBase class for immutable implementations of a
DescribedObject EnrichableModel modelBase class for immutable implementations of
NamedObject introspection modelsBase class for immutable implementation of
ParameterizedModelBase class for immutable implementation of
HasStereotypeModelException to be thrown by operations which are trying to use an expired access token.
Defines an alias for a Java type.
Declares an array of
classes of an StereotypeDefinition, to communicate and declare which
StereotypeDefinition the nested component allows to be injected with.StereotypeDefinition for any generic config global element.Declares the annotated
ComponentModel's attributes MetadataType to the type represented by the JSON Schema.Declares the annotated
ComponentModel's attributes MetadataType to the type represented by the provided element
in the XSD Schema.Provides information about the request that is sent to the authorization url during an OAuth2 dance using the
Authorization-Code grant type.
This handler allows to configure the current context's authentication, used for encryption and inbound authentication, based on
a given
Authentication request.To be used on implementations of
ConnectionProvider, indicates that the provided connections will be authenticated
using Authorization-Code grant type of the OAuth2 specification.Implementation of which contains information about how to use the Authorization-Code grant type against
a particular OAuth provider
ConnectionProvider implementations which are also annotated with AuthorizationCode MUST have a field of
this type.Allows the customization of a
Source available and default BackPressureMode.Indicates which type of back pressure has the runtime applied on a give message.
Provides information about how the runtime applied back pressure on a certain
eventAdds a parameter for back pressure on message sources that apply
Describes the available back pressure strategies
Validates that the backPressureStrategy parameter is correctly formed on the sources that apply
Private
ModelProperty which describes the back pressure support of a given SourceModelDeclarationEnricher implementation that walks through all the BooleanType parameters and sets them as optional.A
Chain allows a given Operation to receive a chain of message processors to be executed as part
of the operation's execution.StereotypeDefinition for the chain of components defined through a DSL.Adds a
ClassLoaderModelProperty pointing to ExtensionLoadingContext.getExtensionClassLoader()Links an
EnrichableModel with a ClassLoader.Marks a field or parameter annotated with
Parameter as actually representing a class.To be used on implementations of
ConnectionProvider, indicates that the provided connections will be authenticated
using Client Credentials grant type of the OAuth2 specification.Implementation of
OAuthGrantType which contains information about how to use the Client Credentials grant type against
a particular OAuth providerConnectionProvider implementations which are also annotated with ClientCredentials MUST have a field of
this type.Indicates the
SourceClusterSupport that a Source should have when running in cluster mode.Adds a #
ExtensionConstants.PRIMARY_NODE_ONLY_PARAMETER_NAME parameter on all sources for which
SourceModel.runsOnPrimaryNodeOnly() is falseCompletableComponentExecutor<M extends org.mule.runtime.api.meta.model.ComponentModel>
A facade interface which hides the details of how an operation is actually executed.
Callback to notify the operation's result.
CompletableComponentExecutorFactory<T extends org.mule.runtime.api.meta.model.ComponentModel>
Creates
CompletableComponentExecutor instancesThis callback is how non blocking operations notify their outcome.
Represents a complex parameter that has a type and it's composed by other parameters.
Provides a way to access the functionality on internal model properties when declaring components on crafted extensions.
ComponentExecutor<T extends org.mule.runtime.api.meta.model.ComponentModel>
Deprecated.
since 1.3.0.
ComponentExecutorFactory<T extends org.mule.runtime.api.meta.model.ComponentModel>
Deprecated.
since 1.3.0.
Marks a Component's
ParameterModel as the Component ID.Marker annotation for a
ObjectFieldType that represents a componentId.Declarative API for configuring DataSense related resolvers at the declarer or declaration level with minimal exposure to the
implementation details.
Factory of
ComponentMetadataConfigurer.Factory of
ComponentMetadataConfigurer.Parameterizes a component executed or created through the
ExtensionsClientContract for components capable of providing sample data.
This interface allows the exposure of the
values associated to a parameter of a Component.Indicates that the annotated member should be injected with the currently active configuration instance.
Binds the annotated member with the
ParameterModel of the same name and
type that exists in the config associated to the
container of the annotated member.Marker annotation for a field that is a
ConfigOverride.Enriches component models that depends on a configuration adding the `config-ref` parameter to the model.
Container for the
Repeatable ConfigReference annotationUsed to express that a class should be used to describe a
org.mule.runtime.extension.api.introspection.Configuration
model.Creates instances of objects which are compliant with the model described by the owning
ConfigurationModel.Just like the
ConfigurationModel class provides introspection on a configuration's structure and parameters, this
concept provides an abstraction on an actual configuration instance which was declared and instantiated.ExtensionModelValidator which applies to ExtensionModels which contains ConfigurationModels and
OperationModels .This interface allows the exposure of the
Set of values associated to a Configuration's or Connection
Provider's parameter.A component responsible for providing instances which are realizations of a given
ConfigurationModel.Allows to reference a list of classes from which a
org.mule.runtime.extension.api.introspection.Configuration model is
to be inferred.Contains the state of the parameters of a given
ConfigurationInstance.Usage statistics about a
ConfigurationInstance.Represents a component which might be associated to a
ConfigurationInstanceIndicates that the annotated member should be injected with a currently active connection.
Enriches all the
ConnectionProviderDeclaration by adding language rules parameters.Creates instances of
ConnectionProvider for the generic Config and Connection types.ExtensionModelValidator which applies to ExtensionModels which contains ConnectionProviderModels
This validator makes sure that:
No parameter of any ConnectionProviderModel is defined as a configuration override
Validates that there's no name clashing among the extension's connection providers
StereotypeDefinition for any generic connection.A set of constants which represent the Anypoint model vocabulary terms which are relevant to the connectivity domain
Sets defaults and other configurations on content parameters so that they provider a consistent experience.
Validates that all content parameters are property configured.
Provides message correlation information.
Describes the possible placements credentials can have inside a HTTP request
Implementation of
ClassHandler for the cursor providersEnriches
declarers before they are actually turned into models.DO NOT USE THIS ANNOTATION.
This annotation is meant to be applied on fields of classes or on operation's arguments.
Default implementation of
ExtensionLoadingContext.Default implementation of
ExtensionsTypeLoaderFactoryDeclares the default
Type that will be instantiated for this ObjectFieldType if no instance is provided as a
value.Declares the default
Type that will be instantiated for this ParameterModel if no instance is provided as a
value.Default
ImportTypesStrategy implementation that fails if an extension could not be located in the current context.Default
OperationParameters implementation, works as a generic OperationParameters for every extension
operation.Builder pattern implementation for building a new
OperationParameters instance.Default
OperatorTranslator implementation, if no implementation is defined in a QueryTranslator this one is
going to be used.Default
ProblemsHandler.Adds a default stereotype on all components which don't define one
Indicated that the current annotated member is deprecated from the extension.
The direction to sort the items returned from a query.
Allows to specify a custom label for the element and/or field to be used in the UI.
A
TypeAnnotation that contains information about the name and summary that should be rendered in the UI for a
particular model.Pojo used to store a baseType when specified from
TypeDsl.Mule DSL constants.
Provides a declaration of how a
Component is represented in XML, containing all the required
information for the XML element creation and parsing.Implementation of the builder design pattern to create instances of
DslElementSyntaxCreates a
GeneratedResource instance from an ExtensionModel instance.Provides the
DslElementSyntax of any Component, Parameter or
Type within the context of the Extension model where the Component was declared.Utils class with helper methods for the
DslSyntaxResolverThis class works as a processor of
DsqlQuerys, conforming to the rules of the formal defined grammar.Represents a parsed DSQL query.
Adds an
ExpirationPolicy parameter to all configs which might be used in a dynamic wayCreates instances of
MetadataType which represent an ExpirationPolicy.Indicates that the annotated
Source supports emitting responses back to the client once a generated message is
processed (either correctly or incorrectly).Represents the queried entity in a DSQL query.
Provides useful static values for use in extensions declarers dealing with error types.
StereotypeDefinition for error-handler core componentsDetermines that an error thrown by an operation should be mapped to another.
A
DeclarationEnricher which adds a ExtensionConstants.ERROR_MAPPINGS_PARAMETER_NAME parameter to all operationsCreates instances of
MetadataType which represent an error mapping.Identifies a Mule Error Type to be declared by extensions and must be implemented by an
Enum.A component responsible for providing an idempotent
Set of ErrorTypeDefinition representing the list of errors
that a component can throw.Annotation for
Extension level to communicate and declare the ErrorTypeDefinitions that the whole extension
managesAllows to specify an example for a
EnrichableModel to be used in the UI.Allows the developer to provide generic logic to enrich exceptions, either via logging, sending notifications, etc.
Creates an instance of an
ExceptionHandlerA
ModelProperty which indicates that the enriched element should not be a part of any generated Connectivity Schema* A
TypeAnnotation used to enrich an ObjectType by specifying that the contained parameters have an exclusive
relation as it is specified in ExclusiveOptionalsThis validator makes sure that all
group models which contain exclusive parameters are correctly
defined.Allows to specify the
ExecutionType of the annotated component.ExecutionContext<M extends org.mule.runtime.api.meta.model.ComponentModel>
Provides context information about the execution of a modeled component
Sets the
ExecutionType on all operations which didn't explicitly set one.A specialization of the
ConfigurationProvider interface which adds the concept of expiration.A policy around when should a given instances be expired
Specifies classes and resources that an extension should expose beyond the default
ClassLoader isolation.Allows customizing how a
ParameterModel supports expressions.Generic contract for a DSQL expression.
Allows to reference a list of classes from which an Extension's functions for usage in the expression language are to be
inferred.
A
TypeAnnotation used to enrich a MetadataType by specifying a certain level of ExpressionSupport it
supports.Denotes that a given type can be extended by others.
Marks that the annotated type is of
Extensible kind, declaring that a given type can be extended by others in the
context of the ExtensionModel.This annotation defines a class that will export its functionality as a Mule module.
Extensions API constants
Utility methods for analyzing and decomposing
ExtensionDeclarer instances.Used for propagating state across all the components that take part into loading an
ExtensionModel.Extension point for customizable components which declare an extension.
Set of utility operations to handle
MetadataTypeA factory that can take an
ExtensionDeclarer and transform it into an actual ExtensionModel.Loader of an
ExtensionModel for a Mule plugin artifact from a set of attributes read by the MulePluginModel.Contract intended for the discovery of the available
ExtensionModelLoader.Parameterizes the loading of one specific
ExtensionModelBuilder for creating a new
ExtensionModelLoadingRequestUtility methods for analyzing and decomposing
ExtensionModel instancesValidates that a constructed model is legal, meaning it's consistent and doesn't violate any restriction.
Constants for the Extensions API OAuth support
An implementation of
ObjectHandler which allows the type to me enriched with custom type annotations of the Extensions
API.Provides utilities to lookup and load implementations of interfaces defined in
extensions-api through SPI.Enables the generation of XML Schema Definitions for extensions.
The
ExtensionsClient is a simple interface for executing extension operations programmatically.DeclarationEnricher implementation which enriches operationModels adding connectivity related
MuleErrors if the operations are considered as a connected ones.An implementation of
TypeHandlerManagerFactory which creates instances of TypeHandlerManager properly
configured to be used under the rules of the Extensions API.Factory class for instances of
ClassTypeLoader properly setup to introspect types following the rules of the Extensions
API.Navigates all the components of the extension and automatically declares all complex types.
Specifies that the annotated element depends on a library which is not packaged with the extension.
Container for the
Repeatable ExternalLib annotationRepresents a selected field in a query.
Declares an array of
classes of an NotificationActionProvider, to communicate and declare which
NotificationActionDefinitions a component could fire.A marker
TypeAnnotation meant to be applied on ObjectFieldType instances which
ObjectFieldType.getValue() points to an ObjectType.Allows to execute custom logic when the flow on which an operation is being executed finishes.
StereotypeDefinition for flow core componentsValidates rules specific to
FunctionModel.A resource that is generated in the context of an
ExtensionModel's build processCreates a
GeneratedResource instance from an ExtensionModel instance.Describes the possible placements a parameter can have inside a HTTP request
A
WalkingDeclarationEnricher.DeclarationEnricherWalkDelegate which assures that each component is visited only once, making it easy to handle the
fact that some components such as OperationDeclaration, SourceDeclaration,
ConnectionProviderDeclaration, etc, implement the flyweight pattern, which means that the same instance might be
present at different levels.A
DeclarationWalker which assures that each component is visited only once, making it easy to handle the fact that some
components such as OperationDeclaration, SourceDeclaration, ConnectionProviderDeclaration, etc,
implement the flyweight pattern, which means that the same instance might be present at different levels.Ignores a field or method inside a complex type.
A specialization of
IllegalModelDefinitionException which marks that a ConfigurationModel is invalidA specialization of
IllegalModelDefinitionException which marks that a ConnectionProvider is invalidA
RuntimeException thrown when the Extensions API (or a component of any of its implementations) has been used to
define an invalid model.A specialization of
IllegalModelDefinitionException which marks that a OperationModel is invalidA specialization of
IllegalModelDefinitionException which marks that a ParameterModel is invalidA specialization of
IllegalModelDefinitionException which marks that a SourceModel is invalidImmutable implementation of
ActingParameterModelImmutable implementation of
ConfigurationModelImmutable implementation of
ConnectionProviderModelImmutable concrete implementation of
OperationModelImmutable implementation of
DeprecationModelImmutable implementation of
ExclusiveParametersModelImmutable implementation of
ExtensionModelImmutable concrete implementation of
FunctionModelImmutable concrete implementation of
NestedChainModelImmutable concrete implementation of
NestedComponentModelImmutable concrete implementation of
NestedRouteModelDefault and immutable implementation of
NotificationModelImmutable concrete implementation of
OperationModelImmutable implementation of
OutputModelImmutable implementation of
ParameterGroupModelImmutable implementation of
ParameterModelImmutable implementation of
SourceCallbackModelImmutable implementation of
SourceModelImmutable implementation of
ValueA special kind of stereotype definition, to be automatically added to top level pojos and interfaces form an extension that do
not already have an associated stereotype.
Container for the
Repeatable Import annotationParameterize how the
DslSyntaxResolver would behave when dealing with imported types from other extensions.Utility builder for all the infrastructure parameters
A
ModelProperty meant to be applied on ParameterModel instances which represent an infrastructure parameterA
TypeAnnotation used as a marker for ObjectType instances, signaling that such type is an Infrastructure Type.Utilities for types considered of "Infrastructure".
Representation of an infrastructure type.
Representation of an actionable infrastructure type.
Declares the annotated
ParameterModel's MetadataType to the type represented by the provided JSON Schema.Declares the annotated
ParameterModel's MetadataType to the type represented by the provided element in the XSD
Schema.Deprecated.
since 1.3.0.
Interceptor<T extends org.mule.runtime.api.meta.model.ComponentModel>
Taps into different phases of the execution of an extension's operation allowing to take different actions depending on the
phase.
Deprecated.
since 1.3.0.
Utilities for parsing Extensions defined through the Java language.
A
Comparator for sorting objects of type ObjectFieldType based on its LayoutTypeAnnotation annotation.A
TypeAnnotation meant to be applied on ObjectFieldType instances and it contains information on how the field
should be rendered in the UI.A parameter type which allows to get values as they were provided in the DSL, preventing the runtime from resolving expressions
or applying any transformations.
TypeAnnotation indicating that the real type of the of the annotated type is a LiteralUse this annotation on operation methods and
Source classes which return either String or InputStream.Marks one of the parameters of an Operation or Source as the key for the metadata lookup.
A
ModelProperty for a of SourceModel and OperationModel parameters that indicates that its a
MetadataKeyId.Marks a field inside a POJO that represents a composed
MetadataKey as one of the parts of that composed
MetadataKey.A
ModelProperty for ParameterModel of SourceModel and OperationModel parameters that indicates
that the is a part of a MetadataKey.Provides instances of the
TypeKeysResolver, TypeKeysResolver, OutputTypeResolver and
QueryEntityResolver resolving types associated to a ComponentHelper methods for the
MetadataResolverFactoryAssociates the annotated Component to a
TypeKeysResolver, and an OutputTypeResolver that will be used to
resolve the Component's MetadataType dynamically
This annotation can be used at Operation or Extension level.Utility class for
ExtensionModelValidatorsStereotypeDefinition for any generic config global element.RuntimeException implementation to throw Exceptions that indicates explicitly the ErrorTypeDefinition
that is wanted to throw.ErrorTypeDefinition Enum which publish the available errors that the Mule Runtime provides to be extended from
an extension.Marker interface that identifies a given
StereotypeDefinition as a Mule stereotype.Deprecated.
since 4.5.0, use
MuleStereotypes insteadValidates names clashes in the model by comparing:
The
NamedObject.getName() value of all the ConfigurationModel, OperationModel and
ConnectionProviderModel
Makes sure that there no two ParameterModels with the same name but different types, for those which represent an
object
Makes sure that no ConfigurationModel, OperationModel or ConnectionProviderModel have parameters
with repeated name
Enriches constructs models with the synthetic "name" parameter.
ExtensionModelValidator which validates that the given names are valid.Extends
NameUtils with extensions oriented behaviorMarker
ModelProperty for modules to avoid propagating connectivity errors from operations.Marker, interface to indicate that the implementing component does not support connectivity testing.
Model property for indicating that the owning operation may not contain errorMappings.
Used to express that the annotated element should not support being used implicitly.
Model property that indicates that the enriched model should not be used in an implicit way
Marker
ModelProperty for XML modules to determine the ExtensionConstants.RECONNECTION_CONFIG_PARAMETER_NAME
element must not be added.Marker
ModelProperty meant to be applied on SourceModel instances.ModelProperty for indicating that the owning operation may not have a configuring streaming strategy, regardless of it
being a streaming operation.An
Exception to signal that an ExtensionModel has been referenced but the runtime has no knowledge of it.Identifies a notification action to be declared by extensions and must be implemented by an
Enum.A component responsible for providing an immutable
Set of NotificationActionDefinitions.Annotation for
Extension level to communicate and declare the NotificationActionDefinitions that the whole
extension emits.This component allows firing
ExtensionNotifications with both custom data and default one.Builder pattern implementation to build
NotificationModel instances.ModelProperty for indicating that the owning operation may not have a configuring transactionalAction.Indicates that a complex parameter that would have a wrapper element under normal conditions, doesn't have a wrapper element
when represented in the DSL.
Null
MetadataKey implementation that represents the absence of a keyNull implementation of
InputTypeResolver, AttributesTypeResolver and TypeKeysResolver, used to
represent the absence of any of them when required.Null implementation of
OutputTypeResolver used to represent the absence of output resolver in a Query annotated
operation.Indicates that the annotated parameter should never be assigned a
null value, even though such value is a valid
assignment on the mule DSL.A
TypeAnnotation meant to be applied on ObjectFieldType instances.This annotation is used to annotate fields on a
ConnectionProvider which supports OAuth.Looks for all the
ConnectionProviderDeclaration with the OAuthModelProperty and adds synthetic parameters that
allows configuring the proper grant typeBase contract for a Grant Type as defined in the OAuth2 specification.
Implementation of the visitor pattern for
OAuthGrantType implementationsA public
ModelProperty used to indicate that a ConnectionProvider supports a number of OAuth2 grant typesSimilar to
Parameter, but intended to be used exclusively on fields of a ConnectionProvider which supports
OAuth.A private
ModelProperty used on ParameterModel instances, indicating that such parameter should be used as an
OAuth parameter.An object which holds information about an OAuth authorization
StereotypeDefinition for a generic Object definitionImplementation of
ClassHandler for the ObjectStore interfaceAnnotation to be used in a field or parameter which value is a reference to a global object store element
StereotypeDefinition for a generic ObjectStore definitionConstants for the OAuth Client Service functionality.
Marks a parameter or parameter group as a value that has the capability of resolve
values for this one.Used to indicate that an annotated method in a
Source should be executed when the runtime applies back pressure on a
message generated by the owning source.Used to indicate that an annotated method should be executed when a generated event was processed by the owning flow but an
error was thrown.
StereotypeDefinition for on-error core componentsThis annotation can be used at Operation level or at
Extension level as a common handler for all the Operations, When
an exception occurs in an operation the Enricher Class declared in this annotation will be called immediately, passing to the
enrichException method the exception thrown by the operation. an Operation level enricher will override the OnException
level one.Used to indicate that an Source's method should be executed when a generated event is successfully processed by the owning
flow.
Used to indicate that an annotated method should be executed when a generated event was processed by the owning flow, doesn't
taking in account if the processing finished successfully or not.
Validates
parameters with rules specific to OperationModel.Parameterizes an operation execution performed through the
ExtensionsClientDeprecated.
since 1.5.0.
Allows to reference a list of classes from which an Extension's operations are to be inferred.
The type of joining actions that operations can take regarding transactions.
Provides the possibility to define an operators syntax for translating from the DSQL operators to the specific query language
ones.
Marks a
Parameter field a optional.Lists the possible strategies to determine the correlation id that should be sent on an outbound operation which supports
correlation.
Declares the annotated
ComponentModel's output MetadataType to the type represented by the JSON Schema.Associates the annotated Component to an
OutputTypeResolver that will be used to resolve the Component's return
type dynamicallyDeclares the annotated
ComponentModel's output MetadataType to the type represented by the provided element in
the XSD Schema.A marker
ModelProperty to signal that the owning OperationModel is paged.This interface provides functionality for consuming a data feed in pages.
Marks a field inside a mule extension as being a parameter that the user can set.
Allows setting directives regarding syntax and semantics of the generated XML DSL.
Contains directives regarding syntax and semantics of the generated XML DSL
Enhances the declaration of the
ParameterDslConfiguration taking into account the type of the parameter as well as the
context in which the type is being used.Allows to define a group of parameters which share some kind of special relationship and thus makes sense for them to belong to
the same group.
A contract for obtaining the parameters that were configured into a
Source instance without depending on its actual
implementation class.Parameterizes a generic entity executed or created through the
ExtensionsClientDeclarationEnricher which walks through all the ParameterDeclaration of the entire extension and populates them
with the correspondent order.A
Comparator for sorting objects of type ParameterModelValidates that all
parameters provided by the configurations,
connection providers and operations from the extension complies with:
If the parameter is a ArrayType the name should be plural
The metadataType must be provided
If required, cannot provide a default value
The Class of the parameter must be valid too, that implies that the class shouldn't contain any field with a
reserved name.A parameter type that gives the capability of:
Get the configured expression: With
ParameterResolver.getExpression() returns the possible expression used to resolve the
parameter value
Differ the resolution: Using ParameterResolver.resolve() resolves the parameter value of type ParameterResolver
TypeAnnotation indicating that the real type of the of the annotated type is a ParameterResolverMarks a
Parameter as one that needs masking when it is populated from the UI.Marks a field or parameter annotated with
Parameter as a path to a file or directory.Defines the particular place of a
Parameter field in the extension configuration window.A grant type that represent a Platform Managed OAuth connections.
Contains context associated to each polling execution, and allows to dispatch items for execution through the
PollContext.accept(Consumer) method.An item obtained through a poll
The possible outcomes of submiting an item for processing through the
PollContext.accept(Consumer) methodA Special kind of
Source which automatically handles polling, idempotency and watermarking.Creates instances of
MetadataType which represent a PoolingProfile.Pojo used to store annotations which value has the format prefix:element.
Specifies packages that an extension should expose beyond the default
ClassLoader isolation.A problem found while validating a model or a component of it
Handler for the
problems generated when loading an extension.Collects
problems found while validating an ExtensionModel.StereotypeDefinition for any generic processor that can be executed by mule runtime.A
ModelProperty which indicates that the enriched model relates to a QName which is not the one the extension
belongs to.A
TypeAnnotation which indicates that the enriched type relates to a QName which is not the one the extension
belongs to.This annotation is meant to be applied to support easy query building by using DataSense Query Language, DSQL.
Builder interface to create basic query objects.
This is a translator interface for go over a DSQL
Query structure and easily translate it to a native one.A component which has its own way of reconnecting.
Callback used to notify the runtime about the outcome of a reconnection attempt.
A
DeclarationEnricher which adds the following to all SourceDeclaration:
A reconnection strategy parameter
Creates instances of
MetadataType which represent a reconnection strategyA
DeclarationEnricher which adds a redelivery policy parameter to all sourcesCreates instances of
MetadataType which represent a redelivery policyThis annotation is meant to be applied on fields of classes which are serving as top level elements which can be referenced by
name, such as configs or global objects.
Marker annotation which indicates that the annotated parameter is required for Metadata, this indicates that any other not
annotated parameter won't be considered as part of the metadata resolution, so if the value changes the metadata resolution
won't be triggered for those connectors
ModelProperty to be used on Configurations or Connection Providers which indicates which parameters of these impact on
the metadata resolution.Defines if the extension requires an enterprise license to run.
Defines if the extension license requires a custom entitlement.
Class which describes an Extension Metadata Resolver.
A component capable of dynamically generating resources to support an
ExtensionModel.Represents the result of a component's execution.
Builds instances of
ResultA
Route allows a given Operation to receive a chain of message processors along with a set of
parameters, to be executed as part of the operation's execution.Deprecated.
since 1.7.0.
Provider of an
ExtensionModel of a Mule Runtime Component.Utlils to discover the
ExtensionModel using the RuntimeExtensionModelProvider.Implementation of
ClassHandler for the SchedulingStrategy interfaceCreates an instance of an
ExceptionHandlerFactory object for instances of either
Source or Source.Helper class to assist in dealing with semantic terms.
A public
TypeAnnotation that holds the semantic terms associated to annotated type.StereotypeDefinition for serializer componentsModelProperty to be used on any EnrichableModel that has been added to an
ExtensionModel in a certain MuleVersion and it is not
desired to add it to versions of the extension model generated for older runtimes.ImportTypesStrategy implementation that permits the DslSyntaxResolver to work without any imported type.Base class to write message sources compliant with a given
SourceModel.A callback to allow
Source implementations to communicate generated messages back to the runtime so that they can be
processed.A context interface to correlate a message generated by a
Source to a particular stateParameterizes a success/error callback from a message source
Describes the operation modes that a
Source can have when running in cluster mode.Private
ModelProperty which describes the cluster support of a given SourceModelCallback used by
sources in order tell the runtime that they will process the flow's response in an asynchronous
manner (from now on, async sources).Deprecated.
since 1.4.0.
Offers management and lifecycle control over a message source created through the
ExtensionsClient.Parameterizes a source created through the
ExtensionsClientA class that represents the result of processing a message from a
Source through a flow, this reports whether the
result of the processing was successful or terminated with errors.Callback used by
ExtensionsClient to notify of new results produced by a source created through the
ExtensionsClient.createSource(String, String, Consumer, Consumer) method.StereotypeDefinition for any generic source that can be executed by mule runtime.The type of beginning actions that sources can take regarding transactions.
Annotation for
Sources, Operations, Configuration and
Connections level to communicate and declare the StereotypeDefinitions that
characterize the annotated componentsA widely held but fixed and oversimplified image or idea of the owning model.
A public
TypeAnnotation intended to be used on ObjectFieldType types in order to communicate an associated
StereotypeModelIntended to be used on operation methods and implementations of
Source, this annotation indicates that such component
supports streaming.Adds infrastructure parameters to sources and operations which returns
InputStream objects.This class provides helper methods to deal with repeatable streaming resources which are contained into structures of arbitrary
complexity.
Creates instances of
MetadataType which represent a streaming strategy typeStereotypeDefinition for sub-flow core componentsPojo used to store a substitutionGroup when specified from
TypeDsl.Container for the
Repeatable SubTypeMapping annotationExtensionModelValidator which applies to ExtensionModels.Allows to specify a summary for a
EnrichableModel to be used in the UI.ModelProperty to be used on any EnrichableModel that it's added to to a
ExtensionModel by the Mule's Sdk.Marker
ModelProperty for ParameterModels that indicates that the enriched parameter is considered as a Target
type.A
DeclarationEnricher which adds a ExtensionConstants.TARGET_PARAMETER_NAME parameter to all non void
operationsMarks a
Parameter field as one that supports a multi line string input both in the editor (when it is populated from
the UI) and in the DSL.Declares an array of
classes of an ErrorTypeProvider, to communicate and declare which
ErrorTypeDefinition the operation could throw.Base contract for a component which can participate in a transaction
Marker
ModelProperty indicating that the enriched ParameterModel is the parameter considered to inject the
value of the Transactional Action.Connections which support transaction must implement this interface in order to start or join a current transaction.
DeclarationEnricher which enrich transactional component models adding required transactional
parameters to the correspondent model.ExtensionModelValidator implementation in charge of validate the set of "Transactional Parameters" for
OperationModel and SourceModelMarker
ModelProperty to indicate that the enriched element is a TransactionTypeAllows to manipulate the transaction that was started and bound to an specific
SourceCallbackContextAllows setting directives regarding syntax and semantics of the generated XML DSL.
TypeAnnotation storing information defined by TypsDsl annotationsTypeAnnotation indicating that the real type of the of the annotated type is a TypedValueAssociates the annotated Parameter to an
InputTypeResolver that will be used to resolve the Parameter's
MetadataType dynamicallyA
ModelProperty for a of ComponentModel that contains all the information regarding which dynamic
TypeResolvers are used by this component.Utility class for handling semantic terms declared at a type level.
Utility class to handle Java types and their relationship with the
MetadataType modelStereotype annotation to mark that one or more operations are validators.
Makes sure that operations with the
VALIDATOR stereotype comply with its restrictions, as defined in ValidatorStereotypeDefinition for any validator component.Represents a value for a query field comparison.
An implementation of the builder design pattern to create a new
ValueBuilder instance.Marks a field inside a POJO that represents a composed
Value as one of the parts of that composed Value.Provider of
values.Exception to indicate than an error occurred resolving valuesThis callback is how Routers notify the end of its execution when no result is produced.
Optimization for
enrichers which would normally use a DeclarationEnricher to implement
their logic, a pattern we found to be quite common.A delegate containing the enrichment logic of a
WalkingDeclarationEnricher.Specialization of
TransactionalConnection for connections which can participate of XA transactionsAllows the customization of the schema attributes.
Constants related with XML based DSLs.
Default implementation of a
DslSyntaxResolver based on XML.Marker
ModelProperty to indicate if the current ExtensionModel containing it should be expanded in the Mule
application.Utils class for parsing and generation of Xml related values of an
extension.