io.smallrye.reactive.messaging.i18n

Interface ProviderExceptions

All Known Implementing Classes:

ProviderExceptions_$bundle

@MessageBundle(projectCode="SRMSG",
               length=5)
public interface ProviderExceptions

Field Summary

Fields

Modifier and Type	Field and Description
static ProviderExceptions	ex

Method Summary

Modifier and Type	Method and Description
IllegalArgumentException	configNotOfType(Class<?> type)
NoSuchElementException	converterReturnedNull(org.eclipse.microprofile.config.spi.Converter<?> converter, String value)
javax.enterprise.inject.spi.DefinitionException	definitionAutoAckNotSupported(String annotation, String methodAsString)
javax.enterprise.inject.spi.DefinitionException	definitionBlockingOnlyIndividual(String methodAsString)
javax.enterprise.inject.spi.DefinitionException	definitionBlockingOnlyIndividualParam(String methodAsString)
javax.enterprise.inject.spi.DefinitionException	definitionBroadcastOnlyOutgoing(String annotation, String methodAsString)
javax.enterprise.inject.spi.DefinitionException	definitionCompletionStageOfVoid(String methodAsString)
javax.enterprise.inject.spi.DefinitionException	definitionExceptionUnsupported(String annotation, String methodAsString)
javax.enterprise.inject.spi.DefinitionException	definitionExpectedConsumedParam(String annotation, String methodAsString, String returnClass)
javax.enterprise.inject.spi.DefinitionException	definitionExpectedReturnedParam(String annotation, String methodAsString, String returnClass)
javax.enterprise.inject.spi.DefinitionException	definitionExpectedTwoParams(String annotation, String methodAsString)
javax.enterprise.inject.spi.DefinitionException	definitionManualAckNotSupported(String annotation, String methodAsString)
javax.enterprise.inject.spi.DefinitionException	definitionMergeOnlyIncoming(String annotation, String methodAsString)
javax.enterprise.inject.spi.DefinitionException	definitionMustDeclareParam(String annotation, String methodAsString, String returnClass)
javax.enterprise.inject.spi.DefinitionException	definitionMustNotHaveParams(String annotation, String methodAsString)
javax.enterprise.inject.spi.DefinitionException	definitionNoParametersExpected(String annotation, String methodAsString)
javax.enterprise.inject.spi.DefinitionException	definitionNoParamOnSubscriber(String annotation, String methodAsString)
javax.enterprise.inject.spi.DefinitionException	definitionNotVoid(String annotation, String methodAsString)
javax.enterprise.inject.spi.DefinitionException	definitionOnParam(String annotation, String methodAsString, String returnType)
javax.enterprise.inject.spi.DefinitionException	definitionProduceConsume(String annotation, String methodAsString)
javax.enterprise.inject.spi.DefinitionException	definitionReturnVoid(String methodAsString, String returnType)
javax.enterprise.inject.spi.DefinitionException	definitionSubscriberTypeParam(String annotation, String methodAsString)
javax.enterprise.inject.spi.DefinitionException	definitionUnsupportedSignature(String annotation, String methodAsString)
javax.enterprise.inject.spi.DeploymentException	deploymentInvalidConfiguration(Set<String> sources)
javax.enterprise.inject.spi.DefinitionException	emitterWithoutChannelAnnotation(javax.enterprise.inject.spi.InjectionPoint injectionPoint)
IllegalArgumentException	illegalArgumentChannelConnectorConfiguration(String name)
IllegalArgumentException	illegalArgumentForAnnotationNonEmpty(String annotation, String annotationTarget)
IllegalArgumentException	illegalArgumentForAnnotationNullOrBlank(String annotation, String annotationTarget)
IllegalArgumentException	illegalArgumentForBackPressure(OnOverflow.Strategy overFlowStrategy)
IllegalArgumentException	illegalArgumentForDefaultBuffer()
IllegalArgumentException	illegalArgumentForException(String val)
IllegalArgumentException	illegalArgumentForFailedWorker()
IllegalArgumentException	illegalArgumentForGenericParameterType(Method method, int length, int index)
IllegalArgumentException	illegalArgumentForInitialize(String methodAsString)
IllegalArgumentException	illegalArgumentForNullValue()
IllegalArgumentException	illegalArgumentForProcessorShape(Shape shape)
IllegalArgumentException	illegalArgumentForPublisherShape(Shape shape)
IllegalArgumentException	illegalArgumentForSubscriberShape(Shape shape)
IllegalArgumentException	illegalArgumentForUnexpectedConsumption(MediatorConfiguration.Consumption consumption)
IllegalArgumentException	illegalArgumentForUnexpectedProduction(MediatorConfiguration.Production production)
IllegalArgumentException	illegalArgumentForUnsupportedShape(Shape shape, String methodAsString)
IllegalArgumentException	illegalArgumentForValidateProcessor(String methodAsString)
IllegalArgumentException	illegalArgumentForWorkerConfigKey(String annotation, String annotationTarget, String workerConfigKey)
IllegalArgumentException	illegalArgumentInvalidChannelConfiguration(String name)
IllegalArgumentException	illegalArgumentMissingAssignment(Type type)
IllegalArgumentException	illegalArgumentTypeToString(String typeName)
IllegalArgumentException	illegalArgumentUnknownConnector(String name)
IllegalArgumentException	illegalBlockingSignature(String methodAsString)
IllegalStateException	illegalStateExceptionForSubscriberOrSubscriberBuilder(String resultClassName)
IllegalStateException	illegalStateExceptionForValidate(Shape shape)
IllegalStateException	illegalStateForCancelledSubscriber(String name)
IllegalStateException	illegalStateForDownstreamCancel()
IllegalStateException	illegalStateForEmitterWhileEmitting(Throwable throwable)
IllegalStateException	illegalStateForNoSubscriber(String name)
IllegalStateException	illegalStateForNotSupported(String value)
IllegalStateException	illegalStateForStream(String name, Set<String> valid)
IllegalStateException	illegalStateForValidateProcessor(String methodAsString)
IllegalStateException	illegalStateInsufficientDownstreamRequests()
IllegalStateException	illegalStateRetrieveConfig()
IllegalStateException	illegalStateUnexpectedGenericInterface(Type type)
IllegalStateException	illegalStateUnhandledType(Type type)
javax.enterprise.inject.spi.DefinitionException	incomingNotFoundForEmitter(String name)
IllegalStateException	incomingNotFoundForEmitter(Throwable throwable)
javax.enterprise.inject.spi.DefinitionException	invalidEmitterOfMessage(javax.enterprise.inject.spi.InjectionPoint ip)
javax.enterprise.inject.spi.DefinitionException	invalidRawEmitter(javax.enterprise.inject.spi.InjectionPoint ip)
IllegalArgumentException	nameMustBeSet()
NoSuchElementException	noConverterForType(Class<?> propertyType)
NoSuchElementException	noSuchElementForAttribute(String propertyName, String name, String channelKey, String connectorKey)
NullPointerException	nullPointerOnInvokeBlocking(String methodAsString)
ProcessingException	processingException(String methodAsString, Throwable cause)
RuntimeException	runtimeForFailedWorker(String workerName)
javax.enterprise.inject.spi.DefinitionException	unsupportedSynchronousSignature(String methodAsString)
IllegalArgumentException	validateIsTrue(String value)
IllegalArgumentException	validationForContainsNull(String name)
IllegalArgumentException	validationForNotEmpty(String name)
IllegalArgumentException	validationForNotNull(String name)
WeavingException	weavingForIncoming(List<String> incoming, Throwable cause)

Field Detail

ex

static final ProviderExceptions ex

Method Detail

processingException

@Message(id=0,
         value="%s")
ProcessingException processingException(String methodAsString,
                                                                            @Cause
                                                                            Throwable cause)

illegalArgumentForGenericParameterType

@Message(id=1,
         value="Method %s only has %d so parameter with index %d cannot be retrieved")
IllegalArgumentException illegalArgumentForGenericParameterType(Method method,
                                                                                                                                                                      int length,
                                                                                                                                                                      int index)

illegalArgumentForAnnotationNullOrBlank

@Message(id=2,
         value="Invalid method annotated with %s: %s - value is blank or null")
IllegalArgumentException illegalArgumentForAnnotationNullOrBlank(String annotation,
                                                                                                                                                                String annotationTarget)

illegalStateExceptionForValidate

@Message(id=3,
         value="Unknown shape: %s")
IllegalStateException illegalStateExceptionForValidate(Shape shape)

illegalArgumentForValidateProcessor

@Message(id=4,
         value="Invalid method annotated with @Outgoing and @Incoming %s - one parameter expected")
IllegalArgumentException illegalArgumentForValidateProcessor(String methodAsString)

illegalStateForValidateProcessor

@Message(id=5,
         value="Unsupported acknowledgement policy - POST_PROCESSING not supported when producing messages for %s")
IllegalStateException illegalStateForValidateProcessor(String methodAsString)

definitionExceptionUnsupported

@Message(id=6,
         value="Invalid method annotated with %s: %s - The @Acknowledgment annotation is only supported for method annotated with @Incoming")
javax.enterprise.inject.spi.DefinitionException definitionExceptionUnsupported(String annotation,
                                                                                                                                                                                                                                            String methodAsString)

illegalArgumentForUnsupportedShape

@Message(id=7,
         value="Unsupported shape %s for method %s")
IllegalArgumentException illegalArgumentForUnsupportedShape(Shape shape,
                                                                                                                                String methodAsString)

illegalArgumentForProcessorShape

@Message(id=8,
         value="Expected a Processor shape, received a %s")
IllegalArgumentException illegalArgumentForProcessorShape(Shape shape)

illegalArgumentForInitialize

@Message(id=9,
         value="Invalid Processor - unsupported signature for %s")
IllegalArgumentException illegalArgumentForInitialize(String methodAsString)

illegalArgumentForUnexpectedProduction

@Message(id=10,
         value="Unexpected production type: %s")
IllegalArgumentException illegalArgumentForUnexpectedProduction(MediatorConfiguration.Production production)

illegalArgumentForPublisherShape

@Message(id=11,
         value="Expected a Publisher shape, received a %s")
IllegalArgumentException illegalArgumentForPublisherShape(Shape shape)

illegalArgumentForUnexpectedConsumption

@Message(id=12,
         value="Unexpected consumption type: %s")
IllegalArgumentException illegalArgumentForUnexpectedConsumption(MediatorConfiguration.Consumption consumption)

illegalArgumentForSubscriberShape

@Message(id=13,
         value="Expected a Subscriber shape, received a %s")
IllegalArgumentException illegalArgumentForSubscriberShape(Shape shape)

weavingForIncoming

@Message(id=14,
         value="%s")
WeavingException weavingForIncoming(List<String> incoming,
                                                                         @Cause
                                                                         Throwable cause)

illegalStateExceptionForSubscriberOrSubscriberBuilder

@Message(id=15,
         value="Invalid return type: %s - expected a Subscriber or a SubscriberBuilder")
IllegalStateException illegalStateExceptionForSubscriberOrSubscriberBuilder(String resultClassName)

runtimeForFailedWorker

@Message(id=16,
         value="Failed to create Worker for %s")
RuntimeException runtimeForFailedWorker(String workerName)

illegalArgumentForFailedWorker

@Message(id=17,
         value="@Blocking referred to invalid worker name.")
IllegalArgumentException illegalArgumentForFailedWorker()

illegalStateForStream

@Message(id=18,
         value="Unable to find a stream with the name %s, available streams are: %s")
IllegalStateException illegalStateForStream(String name,
                                                                                                                                                  Set<String> valid)

incomingNotFoundForEmitter

@Message(id=19,
         value="Unable to connect an emitter with the channel `%s`")
javax.enterprise.inject.spi.DefinitionException incomingNotFoundForEmitter(String name)

emitterWithoutChannelAnnotation

@Message(id=20,
         value="Missing @Channel qualifier for + `%s`")
javax.enterprise.inject.spi.DefinitionException emitterWithoutChannelAnnotation(javax.enterprise.inject.spi.InjectionPoint injectionPoint)

illegalArgumentForDefaultBuffer

@Message(id=21,
         value="The default buffer size must be strictly positive")
IllegalArgumentException illegalArgumentForDefaultBuffer()

illegalArgumentForBackPressure

@Message(id=22,
         value="Invalid back-pressure strategy: %s")
IllegalArgumentException illegalArgumentForBackPressure(OnOverflow.Strategy overFlowStrategy)

illegalArgumentForNullValue

@Message(id=23,
         value="`null` is not a valid value")
IllegalArgumentException illegalArgumentForNullValue()

incomingNotFoundForEmitter

@Message(id=24,
         value="The emitter encountered a failure")
IllegalStateException incomingNotFoundForEmitter(@Cause
                                                                                                                     Throwable throwable)

illegalStateForDownstreamCancel

@Message(id=25,
         value="The downstream has cancelled the consumption")
IllegalStateException illegalStateForDownstreamCancel()

illegalStateForEmitterWhileEmitting

@Message(id=26,
         value="The emitter encountered a failure while emitting")
IllegalStateException illegalStateForEmitterWhileEmitting(@Cause
                                                                                                                                             Throwable throwable)

illegalStateForNoSubscriber

@Message(id=27,
         value="No subscriber found for the channel %s")
IllegalStateException illegalStateForNoSubscriber(String name)

illegalStateForCancelledSubscriber

@Message(id=28,
         value="The subscription to %s has been cancelled")
IllegalStateException illegalStateForCancelledSubscriber(String name)

illegalArgumentForException

@Message(id=29,
         value="`%s` is not a valid exception")
IllegalArgumentException illegalArgumentForException(String val)

illegalStateInsufficientDownstreamRequests

@Message(id=34,
         value="Insufficient downstream requests to emit item")
IllegalStateException illegalStateInsufficientDownstreamRequests()

illegalStateUnhandledType

@Message(id=35,
         value="found an unhandled type: %s")
IllegalStateException illegalStateUnhandledType(Type type)

illegalArgumentMissingAssignment

@Message(id=36,
         value="missing assignment type for type variable %s")
IllegalArgumentException illegalArgumentMissingAssignment(Type type)

illegalStateUnexpectedGenericInterface

@Message(id=37,
         value="Unexpected generic interface type found: %s")
IllegalStateException illegalStateUnexpectedGenericInterface(Type type)

illegalArgumentTypeToString

@Message(id=38,
         value="%s")
IllegalArgumentException illegalArgumentTypeToString(String typeName)

nameMustBeSet

@Message(id=39,
         value="`name` must be set")
IllegalArgumentException nameMustBeSet()

validationForNotNull

@Message(id=40,
         value="%s must not be `null`")
IllegalArgumentException validationForNotNull(String name)

validationForNotEmpty

@Message(id=41,
         value="%s must not be `empty`")
IllegalArgumentException validationForNotEmpty(String name)

validationForContainsNull

@Message(id=42,
         value="%s must not contain a `null` element")
IllegalArgumentException validationForContainsNull(String name)

validateIsTrue

@Message(id=43,
         value="%s")
IllegalArgumentException validateIsTrue(String value)

illegalArgumentInvalidChannelConfiguration

@Message(id=44,
         value="Invalid channel configuration -  the `channel-name` attribute cannot be used in configuration (channel `%s`)")
IllegalArgumentException illegalArgumentInvalidChannelConfiguration(String name)

noSuchElementForAttribute

@Message(id=45,
         value="Cannot find attribute `%s` for channel `%s`. Has been tried: % and %s")
NoSuchElementException noSuchElementForAttribute(String propertyName,
                                                                                                                                                         String name,
                                                                                                                                                         String channelKey,
                                                                                                                                                         String connectorKey)

illegalArgumentForAnnotationNonEmpty

@Message(id=46,
         value="%ss must contain a non-empty array of %s")
IllegalArgumentException illegalArgumentForAnnotationNonEmpty(String annotation,
                                                                                                                                         String annotationTarget)

definitionNoParamOnSubscriber

@Message(id=47,
         value="Invalid method annotated with %s: %s - when returning a Subscriber or a SubscriberBuilder, no parameters are expected")
javax.enterprise.inject.spi.DefinitionException definitionNoParamOnSubscriber(String annotation,
                                                                                                                                                                                                                                      String methodAsString)

definitionSubscriberTypeParam

@Message(id=48,
         value="Invalid method annotated with %s: %s - the returned Subscriber must declare a type parameter")
javax.enterprise.inject.spi.DefinitionException definitionSubscriberTypeParam(String annotation,
                                                                                                                                                                                                             String methodAsString)

definitionOnParam

@Message(id=49,
         value="Invalid method annotated with %s: %s - when returning a %s, one parameter is expected")
javax.enterprise.inject.spi.DefinitionException definitionOnParam(String annotation,
                                                                                                                                                                                          String methodAsString,
                                                                                                                                                                                          String returnType)

definitionUnsupportedSignature

@Message(id=50,
         value="Invalid method annotated with %s: %s - Unsupported signature")
javax.enterprise.inject.spi.DefinitionException definitionUnsupportedSignature(String annotation,
                                                                                                                                                                              String methodAsString)

unsupportedSynchronousSignature

@Message(id=51,
         value="Invalid method annotated with @Incoming: %s - The signature is not supported. The method consumes a `Message`, so the returned type must be `CompletionStage<Void>` or `Uni<Void>`.")
javax.enterprise.inject.spi.DefinitionException unsupportedSynchronousSignature(String methodAsString)

definitionNotVoid

@Message(id=52,
         value="Invalid method annotated with %s: %s - the method must not be `void`")
javax.enterprise.inject.spi.DefinitionException definitionNotVoid(String annotation,
                                                                                                                                                                         String methodAsString)

definitionNoParametersExpected

@Message(id=53,
         value="Invalid method annotated with %s: %s - no parameters expected")
javax.enterprise.inject.spi.DefinitionException definitionNoParametersExpected(String annotation,
                                                                                                                                                                               String methodAsString)

definitionMustDeclareParam

@Message(id=54,
         value="Invalid method annotated with %s: %s - the returned %s must declare a type parameter")
javax.enterprise.inject.spi.DefinitionException definitionMustDeclareParam(String annotation,
                                                                                                                                                                                                  String methodAsString,
                                                                                                                                                                                                  String returnClass)

definitionMustNotHaveParams

@Message(id=55,
         value="Invalid method annotated with %s: %s - the method must not have parameters")
javax.enterprise.inject.spi.DefinitionException definitionMustNotHaveParams(String annotation,
                                                                                                                                                                                         String methodAsString)

definitionExpectedTwoParams

@Message(id=56,
         value="Invalid method annotated with %s: %s - Expected 2 type parameters for the returned Processor")
javax.enterprise.inject.spi.DefinitionException definitionExpectedTwoParams(String annotation,
                                                                                                                                                                                                           String methodAsString)

definitionExpectedReturnedParam

@Message(id=57,
         value="Invalid method annotated with %s: %s - Expected a type parameter in the returned %s")
javax.enterprise.inject.spi.DefinitionException definitionExpectedReturnedParam(String annotation,
                                                                                                                                                                                                      String methodAsString,
                                                                                                                                                                                                      String returnClass)

definitionExpectedConsumedParam

@Message(id=58,
         value="Invalid method annotated with %s: %s - Expected a type parameter for the consumed  %s")
javax.enterprise.inject.spi.DefinitionException definitionExpectedConsumedParam(String annotation,
                                                                                                                                                                                                        String methodAsString,
                                                                                                                                                                                                        String returnClass)

definitionAutoAckNotSupported

@Message(id=59,
         value="Invalid method annotated with %s: %s - Automatic post-processing acknowledgment is not supported.")
javax.enterprise.inject.spi.DefinitionException definitionAutoAckNotSupported(String annotation,
                                                                                                                                                                                                                  String methodAsString)

definitionManualAckNotSupported

@Message(id=60,
         value="Invalid method annotated with %s: %s - Consuming a stream of payload is not supported with MANUAL acknowledgment. Use a Publisher<Message<I>> or PublisherBuilder<Message<I>> instead.")
javax.enterprise.inject.spi.DefinitionException definitionManualAckNotSupported(String annotation,
                                                                                                                                                                                                                                                                                                         String methodAsString)

definitionProduceConsume

@Message(id=61,
         value="Invalid method annotated with %s: %s - If the method produces a PublisherBuilder, it needs to consume a PublisherBuilder.")
javax.enterprise.inject.spi.DefinitionException definitionProduceConsume(String annotation,
                                                                                                                                                                                                                                     String methodAsString)

definitionMergeOnlyIncoming

@Message(id=62,
         value="Invalid method annotated with %s: %s - The @Merge annotation is only supported for method annotated with @Incoming")
javax.enterprise.inject.spi.DefinitionException definitionMergeOnlyIncoming(String annotation,
                                                                                                                                                                                                                                 String methodAsString)

definitionBroadcastOnlyOutgoing

@Message(id=63,
         value="Invalid method annotated with %s: %s - The @Broadcast annotation is only supported for method annotated with @Outgoing")
javax.enterprise.inject.spi.DefinitionException definitionBroadcastOnlyOutgoing(String annotation,
                                                                                                                                                                                                                                         String methodAsString)

definitionBlockingOnlyIndividual

@Message(id=64,
         value="Invalid method annotated with @Blocking: %s - The @Blocking annotation is only supported for methods returning `void` (@Incoming only), a `Message` or a payload")
javax.enterprise.inject.spi.DefinitionException definitionBlockingOnlyIndividual(String methodAsString)

definitionBlockingOnlyIndividualParam

@Message(id=65,
         value="Invalid method annotated with @Blocking: %s - The @Blocking annotation is only supported for methods consuming an individual Message or payload like `consume(String s)` or `consume(Message<String> s)")
javax.enterprise.inject.spi.DefinitionException definitionBlockingOnlyIndividualParam(String methodAsString)

illegalBlockingSignature

@Message(id=66,
         value="Invalid method annotated with @Blocking: %s - no @Incoming or @Outgoing present")
IllegalArgumentException illegalBlockingSignature(String methodAsString)

illegalArgumentForWorkerConfigKey

@Message(id=67,
         value="Invalid method annotated with %s: %s - %s was not defined")
IllegalArgumentException illegalArgumentForWorkerConfigKey(String annotation,
                                                                                                                                                       String annotationTarget,
                                                                                                                                                       String workerConfigKey)

nullPointerOnInvokeBlocking

@Message(id=68,
         value="The operation %s has returned null")
NullPointerException nullPointerOnInvokeBlocking(String methodAsString)

illegalStateForNotSupported

@Message(id=69,
         value="%s not supported")
IllegalStateException illegalStateForNotSupported(String value)

illegalArgumentChannelConnectorConfiguration

@Message(id=71,
         value="Invalid channel configuration -  the `connector` attribute must be set for channel `%s`")
IllegalArgumentException illegalArgumentChannelConnectorConfiguration(String name)

illegalArgumentUnknownConnector

@Message(id=72,
         value="Unknown connector for `%s`.")
IllegalArgumentException illegalArgumentUnknownConnector(String name)

deploymentInvalidConfiguration

@Message(id=73,
         value="Invalid configuration, the following channel names cannot be used for both incoming and outgoing: %s")
javax.enterprise.inject.spi.DeploymentException deploymentInvalidConfiguration(Set<String> sources)

illegalStateRetrieveConfig

@Message(id=74,
         value="Unable to retrieve the config")
IllegalStateException illegalStateRetrieveConfig()

invalidEmitterOfMessage

@Message(id=75,
         value="Invalid Emitter injection found for `%s`. Injecting an `Emitter<Message<T>>` is invalid. You can use an `Emitter<T>` to send instances of `T` and `Message<T>`.")
javax.enterprise.inject.spi.DefinitionException invalidEmitterOfMessage(javax.enterprise.inject.spi.InjectionPoint ip)

invalidRawEmitter

@Message(id=76,
         value="Invalid Emitter injection found for  `%s`. The Emitter expected to be parameterized with the emitted type, such as Emitter<String>.")
javax.enterprise.inject.spi.DefinitionException invalidRawEmitter(javax.enterprise.inject.spi.InjectionPoint ip)

noConverterForType

@Message(id=77,
         value="No converter for type `%s`")
NoSuchElementException noConverterForType(Class<?> propertyType)

converterReturnedNull

@Message(id=78,
         value="Converter `%s` returned null for value `%s`")
NoSuchElementException converterReturnedNull(org.eclipse.microprofile.config.spi.Converter<?> converter,
                                                                                                                           String value)

configNotOfType

@Message(id=79,
         value="The config is not of type `%s`")
IllegalArgumentException configNotOfType(Class<?> type)

definitionCompletionStageOfVoid

@Message(id=80,
         value="Invalid method annotated with @Incoming: %s - when returning a CompletionStage, you must return a CompletionStage<Void>")
javax.enterprise.inject.spi.DefinitionException definitionCompletionStageOfVoid(String methodAsString)

definitionReturnVoid

@Message(id=81,
         value="Invalid method annotated with @Incoming: %s. The signature is not supported as the produced result would be ignored. The method must return `void`, found %s.")
javax.enterprise.inject.spi.DefinitionException definitionReturnVoid(String methodAsString,
                                                                                                                                                                                                                                                                     String returnType)