All Classes and Interfaces

Class
Description
Abstract skeleton implementation of a MultivaluedMap that is backed by a [key, multi-value] store represented as a Map<K, List<V>>.
Configure the acknowledgement policy for the given @Incoming.
 
The container provides a built in interceptor that may be used to annotate classes and methods to indicate that a request context should be activated when this method is invoked.
The event type of the second event fired by the container when it has fully completed the bean discovery process, validated that there are no definition errors relating to the discovered beans, and registered Bean and ObserverMethod objects for the discovered beans, but before detecting deployment problems.
The event type of the third event fired by the container after it has validated that there are no deployment problems and before creating contexts or processing requests.
This event type is thrown by the container after type discovery is complete.
Provides an operation for obtaining and destroying contextual instances with a particular scope of any contextual type.
Specifies that a bean is an alternative.
Supports inline instantiation of the Alternative annotation.
Indicates that multiple beans match a certain combination of required type and required qualifiers and are eligible for injection into a certain class.
Represents a Java program element that can be annotated.
Represents a callable member of a Java type.
Represents a constructor of a Java class.
This interface is part of the AnnotatedTypeConfigurator SPI and helps defining an AnnotatedConstructor
Represents a field of a Java class.
This interface is part of the AnnotatedTypeConfigurator SPI and helps defining an AnnotatedField
Represents a member of a Java type.
Represents a method of a Java type.
This interface is part of the AnnotatedTypeConfigurator SPI and helps defining an AnnotatedMethod
Represents a parameter of a method or constructor.
This interface is part of the AnnotatedTypeConfigurator SPI and helps defining an AnnotatedParameter
Represents a Java class or interface.
This API is a helper to configure a new AnnotatedType instance.
Supports inline instantiation of annotation type instances.
The built-in qualifier type.
Supports inline instantiation of the Any qualifier.
The APIResponse annotation corresponds to the OpenAPI Response model object which describes a single response from an API Operation, including design-time, static links to operations based on the response.
This interface represents a single response from an API Operation, including design-time, static links to operations based on the response.
The ApiResponses annotation is a container for @ApiResponse annotations.
This interface represents the container for the expected responses of an operation.
The APIResponseSchema annotation corresponds to an individual schema in the OpenAPI Response model object which describes a single response from an API Operation.
Defines the components of a JAX-RS application and supplies additional meta-data.
Identifies the application path that serves as the base URI for all resource URIs provided by Path.
Specifies that a bean is application scoped.
Supports inline instantiation of the ApplicationScoped annotation.
Designates an interceptor method that receives a callback when the target class constructor is invoked.
Defines an interceptor method that interposes on business methods.
Defines an interceptor method that interposes on timeout methods.
Wrap the execution and invoke it asynchronously.
Implementations of this interface can intercept asynchronous method invocations.
This is a provider interface intended for intercepting asynchronous method invocations.
Uniform interface for asynchronous invocation of HTTP methods.
An injectable JAX-RS asynchronous response that provides means for asynchronous server side response processing.
A runtime exception indicating a bad client request.
Represents an enabled bean.
The BeanAttributes interface exposes the basic attributes of a bean.
This API is an helper to configure a new BeanAttributes instance.
This API is an helper to configure a new Bean instance.
Allows a portable extension to interact directly with the container.
The annotation that may be used to inject custom JAX-RS "parameter aggregator" value object into a resource class field, property or resource method parameter.
This event type is thrown by the container before the bean discovery process begins.
An event with this qualifier is fired when a context is about to be destroyed, i.e.
Supports inline instantiation of the BeforeDestroyed qualifier.
The type of the final event the container fires after it has finished processing requests and destroyed all contexts.
Specifies predefined binary data handling strategies.
Define bulkhead policy to limit the number of the concurrent calls to an instance.
The exception should be thrown when Bulkhead implementation throws an exception, e.g.
Indicates that the container has rejected a request because a concurrent request is associated with the same conversation context.
An abstraction for the value of a HTTP Cache-Control response header.
This object represents a callback URL that will be invoked.
Callback
Describes a single API callback operation.
This object represents an array of Callback URLs that can be invoked.
Provides access to the current container.
Interface implemented by a CDI provider to provide access to the current container
Defines a circuit breaker policy to an individual method or a class.
The exception should be thrown when circuit breaker is open.
Annotation used to signify an injection point for a ClaimValue from a JsonWebToken
Annotation literal for Claim
This enum represents the standardized claims that the MP-JWT specification allows for in terms of interoperability.
A representation of a claim in a JsonWebToken
Client is the main entry point to the fluent API used to build and execute client requests in order to consume responses returned.
Main entry point to the client API used to bootstrap Client instances.
A base runtime application exception indicating a client request error (HTTP 4xx status codes).
Used to specify an HTTP parameter that should be sent with the outbound request.
Used to specify HTTP parameters that should be sent with the outbound request.
This interface is intended for generating or propagating HTTP headers.
Client request filter context.
An extension interface implemented by client request filters.
Client response filter context.
An extension interface implemented by client response filters.
This class registers tracing components into ClientBuilder.
Implementation of this interface will be used to configure ClientBuilder when ClientTracingRegistrar.configure(ClientBuilder) is called.
A request processing callback that receives request processing completion events.
A builder for a closed reactive streams graph.
Reactive invoker based CompletionStage.
A subscriber that redeems a completion stage when it completes.
Describes the Components object that holds various reusable objects for different aspects of the OpenAPI Specification (OAS).
Components
An annotation for marking a method, constructor, or class as concurrent gauged.
A concurrent gauge is a gauge that measures parallel invocations of a method.
Resolves the property value by searching through all configured ConfigSources.
A builder for manually creating a configuration instance.
Retrieve a number of related configuration properties with the specified prefix into a property class.
Support inline instantiation of the ConfigProperties qualifier.
Binds the injection point with a configured value.
This is the central class to access a Config.
The service provider for implementations of the MicroProfile Configuration specification.
A configuration source which provides configuration values from a specific place.
A provider for configuration source instances.
Represents a client or server-side configurable context in JAX-RS.
A configuration state associated with a configurable JAX-RS context.
The ConfigValue holds additional information after the lookup of a configuration property and is itself immutable.
Operators for connecting different graphs together.
Asynchronous request processing lifecycle callback that receives connection related asynchronous response lifecycle events.
Qualifier used on connector implementations to indicate the associated underlying transport.
Supports inline instantiation of the Connector qualifier.
Indicates the run-time context in which an annotated JAX-RS provider is applicable.
Marker interface for OpenAPI model objects that can be constructed by the OASFactory.
Defines the media types that the methods of a resource class or MessageBodyReader can accept.
Operators for completing a stream.
Contact information for the exposed API.
This interface represents the Contact information for the exposed API.
Container request filter context.
An extension interface implemented by container request filters.
Container response filter context.
An extension interface implemented by container response filters.
This object provides schema and examples for a particular media type.
Content
Provides an operation for obtaining contextual instances with a particular scope of any contextual type.
This annotation is used to inject information into a class field, bean property or method parameter.
Indicates a problem relating to context management.
Use this class to configure instances of ContextManager.
ContextManagerExtension instances receive notification upon creation of each ContextManager.
A provider implementation supplied by the container, which creates and caches instances of ContextManager per class loader, which in turn create new instances of ManagedExecutor.Builder and ThreadContext.Builder.
This class gives the container that registered a ContextManagerProvider exclusive control over unregistering it.
Indicates that a context is not active.
Contract for a provider that supplies context information to resource classes and other providers.
Defines operations to create and destroy contextual instances of a certain type.
Allows the application to manage the conversation context by marking the current conversation as transient or long-running, specifying a conversation identifier, or setting the conversation timeout.
Specifies that a bean is conversation scoped.
Supports inline instantiation of the ConversationScoped annotation.
A mechanism for converting configured values from String to any Java type.
Represents the value of a HTTP cookie, transferred in a request.
Binds the value of a HTTP cookie to a resource method parameter, resource class field, or resource class bean property.
An annotation for marking a method, constructor, or class as counted.
An incrementing counter metric.
An interface for metric types which have counts.
Provides operations that are used by the Contextual implementation during instance creation and destruction.
Indicates that a checked exception was thrown during creation of a bean.
Annotation used to define a container DataSource to be registered with JNDI.
Declares one or more DataSourceDefinition annotations.
Used by application to declare security roles.
A decorator may inject metadata about the bean it is decorating
Specifies that a class is a decorator.
Represents an enabled decorator.
The default qualifier type.
Supports inline instantiation of the Default qualifier.
This class propagates JAX-RS headers whose names are specified using the MicroProfile Config property, org.eclipse.microprofile.rest.client.propagateHeaders.
The default implementation of Metadata
Defines the default value of request meta-data that is bound using one of the following annotations: PathParam, QueryParam, MatrixParam, CookieParam, FormParam, or HeaderParam.
Thrown when a definition error occurs.
Identifies the delegate injection point of a decorator.
Indicates that the annotated method responds to HTTP DELETE requests.
Specifies that no security roles are allowed to invoke the specified method(s).
Specifies that a bean belongs to the dependent pseudo-scope.
Supports inline instantiation of the Dependent annotation.
Thrown when a deployment problem occurs.
Provides JSONB Mapper functionality on top of JSONP parser.
An event with this qualifier is fired when a context is destroyed, i.e.
Supports inline instantiation of the Destroyed qualifier.
Discriminator
This object maps payload values to a particular Schema.
Identifies the disposed parameter of a disposer method.
A JAX-RS meta-provider for dynamic registration of post-matching providers during a JAX-RS application setup at deployment time.
Disables automatic decoding of parameter values bound using QueryParam, PathParam, FormParam or MatrixParam.
Single encoding definition to be applied to single Schema Object
Encoding
 
Encapsulates message entity including the associated variant information.
An abstraction for the value of a HTTP Entity Tag, used as the value of an ETag response header.
Operators for handling errors in streams.
Allows the application to fire events of a particular type.
Represents a context of a fired event.
Provides access to metadata about an observed event payload.
Example
This object illustrates an example of a particular content
Contract for a provider that maps Java exceptions to Response.
Used to exclude class-level interceptors for the lifecycle callback method, business method, timeout method, or constructor to which it is applied.
Used to exclude default interceptors for a target class or for a lifecycle callback method, business method, timeout method, or constructor of a target class.
The execution context for the method being executed.
Enumeration used to define the value of Explode property.
The base interface for OpenAPI model objects that can contain extensions.
Service interface implemented by extensions.
A named extension that should be added to the OpenAPI definition.
This object represents an array of extensions that can be added to the element.
This annotation allows referencing an external resource for extended documentation.
ExternalDocumentation
The fallback annotation to define the fallback handler class so that a failure can be handled properly.
Create a default class so the value is not required to be set all the time.
The handler instance used by the container to service a fallback invocation is a non-contextual instance created using the CDI SPI.
The exception should be thrown when the definition of any Fault Tolerance annotations is invalid.
The exception should be thrown when the maximum retries is reached or overall retry duration is reached, circuit breaker is open, timeout occurred.
A feature extension contract.
A configurable context passed to Feature and DynamicFeature instances by JAX-RS runtime during the phase of their configuration.
Operations for transforming a stream.
A runtime exception indicating that an access to a resource requested by a client has been forbidden by the server.
Represents the the HTML form data request entity encoded using the "application/x-www-form-urlencoded" content type.
Binds the value(s) of a form parameter contained within a request entity body to a resource method parameter.
An annotation for marking a method or field as a gauge.
A gauge metric is an instantaneous reading of a particular value.
The Generated annotation is used to mark source code that has been generated.
Represents a message entity of a generic type T.
Represents a generic message entity type T.
Indicates that the annotated method responds to HTTP GET requests.
A graph.
Indicates that the annotated method responds to HTTP HEAD requests.
Describes a single header object
Header
Controls the style of serialization.
Binds the value(s) of a HTTP header to a resource method parameter, resource class field, or resource class bean property.
The health check procedure interface.
The response to a health check invocation.
 
A builder to construct a health check procedure response.
Reserved for implementors as means to supply their own HealthCheckResponseBuilder.
A metric which calculates the distribution of a value.
An injectable interface that provides access to HTTP header information.
Associates the name of a HTTP method with an annotation.
Indicates that a producer method returned a null value or a producer field contained a null value, and the scope of the producer method or field was not Dependent.
Inbound Server-sent event.
Used to signify a subscriber to incoming messages.
SPI used to implement a connector managing a source of messages for a specific transport.
This annotation provides metadata about the API, and maps to the Info object in OpenAPI Specification 3.
This interface represents all the metadata about the API.
An event with this qualifier is fired when a context is initialized, i.e.
Supports inline instantiation of the Initialized qualifier.
Identifies injectable constructors, methods, and fields.
Indicates a problem relating to dependency injection.
Provides access to metadata about an injection point.
This API is an helper to configure an existing InjectionPoint instance.
Provides operations for performing dependency injection and lifecycle callbacks on an instance of a type.
An InjectionTargetFactory can create an InjectionTarget for a given bean.
Supports inline instantiation of the Inject annotation.
Allows the application to dynamically obtain instances of beans with a specified combination of required type and qualifiers.
An interceptor may inject metadata about the bean it is intercepting.
InterceptionFactory allows to create a wrapper instance whose method invocations are intercepted by method interceptors and forwarded to a provided instance.
Identifies the kind of lifecycle callback, EJB timeout method or business method interception.
Represents an enabled interceptor.
Specifies that a class is an interceptor.
Priorities that define the order in which interceptors are invoked.
Specifies that an annotation type is an interceptor binding type.
Declares an ordered list of interceptors for a target class, or for a method or a constructor of a target class.
A runtime exception indicating an internal server error.
A client request invocation.
A client request invocation builder.
Callback that can be implemented to receive the asynchronous processing events from the invocation processing.
Exposes contextual information about the intercepted invocation and operations that enable interceptor methods to control the behavior of the invocation chain.
Factory class for creating JSON processing objects.
JsonArray represents an immutable JSON array (an ordered sequence of zero or more values).
A builder for creating JsonArray models from scratch, and for modifying a existing JsonArray.
Jsonb provides an abstraction over the JSON Binding framework operations:
Allows to define custom mapping for given java type.
Marks any relevant JSON Binding annotations.
JsonbBuilder class provides the client's entry point to the JSON Binding API.
Supported Properties
This annotation identifies the custom constructor or factory method to use when creating an instance of the associated class.
Annotation provides way how to set custom date format to field or JavaBean property.
Interface representing a custom deserializer for a given type.
Root class for all JSON Binding exceptions.
Specifies how fields having null values are serialized into JSON.
Annotation provides way how to set custom number format to field or JavaBean property.
Allows customization of field (or JavaBean property) name.This name is used either in serialization or in deserialization.
Specifies order in which properties are serialized.
Service provider for JSON Binding implementations.
Interface representing a custom serializer for given type.
Prevents mapping of a Java Bean property, field or type to JSON representation.
Annotation provides way how to set custom JsonbAdapter to field or JavaBean property.
Annotation provides way how to set custom JsonbDeserializer to field or JavaBean property.
Annotation provides way how to set custom JsonbSerializer to field or JavaBean property.
Factory to create JsonObjectBuilder and JsonArrayBuilder instances.
Annotation provides way how to customize visibility strategy of the JSON Binding.
This class contains some implementations of java.util.stream.Collector for accumulating JsonValues into JsonArray and JsonObject.
JsonException indicates that some exception happened during JSON processing.
JsonGenerationException indicates an incorrect JSON is being generated.
Writes JSON data to an output source in a streaming way.
Factory to create JsonGenerator instances.
Provides the location information of a JSON event in an input source.
This interface represents an implementation of a JSON Merge Patch as defined by RFC 7396.
An immutable JSON number value.
JsonObject class represents an immutable JSON object value (an unordered collection of zero or more name/value pairs).
A builder for creating JsonObject models from scratch.
Provides forward, read-only access to JSON data in a streaming way.
An event from JsonParser.
Factory for creating JsonParser instances.
JsonParsingException is used when an incorrect JSON is being parsed.
This interface represents an immutable implementation of a JSON Patch as defined by RFC 6902.
This enum represents the list of valid JSON Patch operations as defined by RFC 6902.
A builder for constructing a JSON Patch as defined by RFC 6902 by adding JSON Patch operations incrementally.
This interface represents an immutable implementation of a JSON Pointer as defined by RFC 6901.
Service provider for JSON processing objects.
Reads a JSON object or an array structure from an input source.
Factory to create JsonReader instances.
An immutable JSON string value.
Super type for the two structured types in JSON (objects and arrays).
JsonValue represents an immutable JSON value.
Indicates the type of a JsonValue object.
A read-only interface for the the claims required by Eclipse MicroProfile conforming tokens.
Writes a JSON object or array structure to an output source.
Factory to create JsonWriter instances.
License information for the exposed API.
This interface represents the License information for the exposed API.
Class representing hypermedia links.
The Link object represents a possible design-time link for a response.
Link
Builder class for hypermedia links.
An implementation of JAXB XmlAdapter that maps the JAX-RS Link type to a value that can be marshalled and unmarshalled by JAXB.
Value type for Link that can be marshalled and unmarshalled by JAXB.
Represents a parameter to pass to an operation as specified with operationId or identified via operationRef.
This qualifier is used to define a liveness Health Check procedure
Support inline instantiation of the Liveness qualifier.
A security annotation describing the authentication method and the associated realm name that should be used for this application.
The ManagedBean annotation marks a POJO (Plain Old Java Object) as a ManagedBean.
A container-managed executor service that creates instances of CompletableFuture, which it backs as the default asynchronous execution facility, both for the CompletableFuture itself as well as all dependent stages created from it, as well as all dependent stages created from those, and so on.
Builder for ManagedExecutor instances.
Binds the value(s) of a URI matrix parameter to a resource method parameter, resource class field, or resource class bean property.
An abstraction for a media type.
MediaType
A message envelope.
Contract for a provider that supports the conversion of a stream to a Java type.
Contract for a provider that supports the conversion of a Java type to a stream.
Bean holding the metadata of one single metric.
The Metadata builder.
A meter metric which measures mean throughput and one-, five-, and fifteen-minute exponentially-weighted moving average throughputs.
An annotation for marking a method, constructor, or class as metered.
An object which maintains mean and exponentially-weighted rate.
An annotation requesting that a metric be injected or registered.
A tag interface to indicate that a class is a metric.
A filter used to determine whether or not a metric should be reported, among other things.
A unique identifier for Metric and Metadata that are registered in the MetricRegistry The MetricID contains: Name: (Required) The name of the metric.
The registry that stores metrics and their metadata.
An enumeration representing the scopes of the MetricRegistry
An enumeration representing the different types of metrics.
Standard units constants for metric's Metadata.
The built-in stereotype intended for use with beans that define the model layer of an MVC web application architecture such as JSF.
A hash table based implementation of MultivaluedMap interface.
A map of key-values pairs.
Meta-annotation used to create name binding annotations for filters and interceptors.
String-based qualifier.
Supports inline instantiation of the Named qualifier.
Constants for the names of the MP-config properties that MP-JWT implementations must support externalization of to ensure portable setup of MP-JWT implementations.
The New qualifier was deprecated in CDI 1.1.
Supports inline instantiation of the New qualifier.
Used to create a new HTTP cookie, transferred in a response.
An I/O exception thrown by MessageBodyReader implementations when reading a zero-length message content to indicate that the message body reader is not able to produce an instance representing an zero-length message content.
Excludes a member of an annotation type (such as a qualifier type or interceptor binding type) from consideration when the container compares two annotation instances.
Supports inline instantiation of the Nonbinding annotation.
Indicates that the conversation context could not be restored.
Specifies that an annotation type is a normal scope type.
A runtime exception indicating that a client request is not acceptable by the server.
A runtime exception indicating a client requesting a resource method that is not allowed.
A runtime exception indicating request authorization failure caused by one of the following scenarios: a client did not send the required authorization credentials to access the requested resource, i.e.
A runtime exception indicating a resource requested by a client was not found on the server.
Notification options are used to configure observer notification.
Notification options builder.
A runtime exception indicating that the client request entity media type is not supported.
Configurable properties in MicroProfile OpenAPI
This class allows application developers to build new OpenAPI model elements.
This class is not intended to be used by end-users.
This interface allows application developers to filter different parts of the OpenAPI model tree.
This interface allows application developers to programmatically contribute an OpenAPI model tree.
Configuration details for a supported OAuth Flow.
Configuration details for a supportde OAuthFlow
Allows configuration of the supported OAuth Flows.
Configuration of the supported OAuthFlows
Represents an OAuth scope.
Indicates that a checked exception was thrown by an observer method during event notification.
Represents an observer method of an enabled bean.
Represents an operation that accepts a context of a fired event.
Identifies the event parameter of an observer method.
Identifies the event parameter of an asynchronous observer method.
OpenAPI
OpenAPI
Describes a single API operation on a path.
Operation
Indicates that the annotated method responds to HTTP OPTIONS requests.
Representation of a single outbound Server-sent event.
A builder class used for creating OutboundSseEvent instances.
Used to signify a publisher of outgoing messages.
SPI used to implement a connector managing a sink of messages for a specific transport.
Defines a contract for a delegate responsible for converting between a String form of a message parameter value and the corresponding custom Java type T.
Mandates that a conversion of any default value delegated to a parameter converter annotated with @Lazy annotation SHOULD occur only once the value is actually required (e.g.
Contract for a provider of ParamConverter instances.
Describes a single operation parameter
Parameter
The values allowed for the in field.
The values allowed for the style field.
 
This object encapsulates input parameters
 
Indicates that a custom implementation of Bean or Contextual is passivation capable.
Indicates that the annotated method responds to HTTP PATCH requests.
Identifies the URI path that a resource class or class method will serve requests for.
PathItem
All of the possible types of HTTP operations for this path
Binds the value of a URI template parameter or a path segment containing the template parameter to a resource method parameter, resource class field, or resource class bean property.
Paths
Represents a URI path segment and any associated matrix parameters.
Operations for peeking at elements and signals in the stream, without impacting the stream itself.
Specifies that all security roles are allowed to invoke the specified method(s) — i.e., that the specified method(s) are "unchecked".
Indicates that the annotated method responds to HTTP POST requests.
The PostConstruct annotation is used on a method that needs to be executed after dependency injection is done to perform any initialization.
The PreDestroy annotation is used on a method as a callback notification to signal that the instance is in the process of being removed by the container.
Global binding annotation that can be applied to a container request filter to indicate that such filter should be applied globally on all resources in the application before the actual resource matching occurs.
A collection of built-in priority constants for the JAX-RS components that are supposed to be ordered based on their javax.annotation.Priority class-level annotation value when used or applied by JAX-RS runtime.
This interface allows some SPI implementation to change their priority programmatically.
The Priority annotation can be applied to classes or parameters to indicate in what order they should be used.
The container fires an event of this type for each Java class or interface it discovers in a bean archive, before it reads the declared annotations.
The container fires an event of this type for each enabled bean, interceptor or decorator deployed in a bean archive, before registering the Bean object.
The container fires an event of this type for each enabled bean, interceptor or decorator deployed in a bean archive before registering the Bean object.
A base JAX-RS runtime processing exception.
The container fires an event of this type for every injection point of every Java EE component class supporting injection that may be instantiated by the container at runtime, including every managed bean declared using javax.annotation.ManagedBean, EJB session or message-driven bean, enabled bean, enabled interceptor or enabled decorator.
The container fires an event of this type for every Java EE component class supporting injection that may be instantiated by the container at runtime, including every managed bean declared using javax.annotation.ManagedBean, EJB session or message-driven bean, enabled bean, enabled interceptor or enabled decorator.
The container fires an event of this type for each enabled managed bean, before registering the Bean object.
The container fires an event of this type for each observer method of each enabled bean, before registering the ObserverMethod object.
A builder for a Processor.
The container fires an event of this type for each producer method or field of each enabled bean, including resources.
The container fires an event of this type for each enabled producer field, before registering the Bean object.
The container fires an event of this type for each enabled producer method, before registering the Bean object.
The container fires an event of this type for each enabled session bean, before registering the Bean object.
The container fires an event of this type for each custom bean implementation added through AfterBeanDiscovery.addBean() or AfterBeanDiscovery.addBean(Bean), before registering the Bean object.
The container fires an event of this type for each custom implementation of ObserverMethod added through AfterBeanDiscovery.addObserverMethod(ObserverMethod) or AfterBeanDiscovery.addObserverMethod(), before registering the ObserverMethod object.
Provides a generic operation for producing an instance of a type.
A ProducerConfigurator can configure a Producer.
An ProducerFactory can create an Producer for a given bean.
Identifies a producer method or field.
Defines the media type(s) that the methods of a resource class or MessageBodyWriter can produce.
A stream that completes with a single result.
Allows to define custom property naming strategy.
Specifies predefined property order strategies.
Provides mechanism how to define customized property visibility strategy.
Provides instances of T.
Marks an implementation of an extension interface that should be discoverable by JAX-RS runtime during a provider scanning phase.
An injectable interface providing runtime lookup of provider instances.
A builder for a Publisher.
Indicates that the annotated method responds to HTTP PUT requests.
Identifies qualifier annotations.
Supports inline instantiation of the Qualifier annotation.
Binds the value(s) of a HTTP query parameter to a resource method parameter, resource class field, or resource class bean property.
A QueryParamStyle enum is used to specify how multiple values are handled when constructing the query portion of the URI.
Primary entry point into the Reactive Streams utility API.
An engine for turning reactive streams graphs into Reactive Streams publishers/subscribers.
Factory interface for providing the implementation of the static factory methods in ReactiveStreams.
This class is not intended to be used by end-users but for portable container integration purpose only.
Context class used by ReaderInterceptor to intercept calls to (@link javax.ws.rs.ext.MessageBodyReader#readFrom}.
This qualifier is used to define a readiness Health Check procedure
Support inline instantiation of the Readiness qualifier.
Distinguishes conditional observer methods from observer methods which are always notified.
A runtime application exception indicating a request redirection (HTTP 3xx status codes).
Base interface for OpenAPI model objects that can make reference to other objects.
Used to specify that a ClientHeadersFactory should be used to generate or propagate HTTP headers on the outbound request.
When annotation is placed at the interface level of a REST API definition, the providers listed will be registered upon proxying.
When annotation is placed at the interface level of a REST API definition, the providers listed will be registered upon proxying.
A marker annotation to register a rest client at runtime.
Qualifies the type of Metric Registry to inject.
An injectable helper for request processing, all methods throw an IllegalStateException if called outside the scope of a request (e.g.
Describes a single request body.
This interface represents the request body of an operation in which body parameters can be specified.
Provides a reference to a class that (after introspection) describes the schema for a single request body.
The CDI container provides a built in instance of RequestContextController that is dependent scoped for the purposes of activating and deactivating.
Specifies that a bean is request scoped.
Supports inline instantiation of the RequestScoped annotation.
Indicates a problem relating to typesafe resolution.
The Resource annotation marks a resource that is needed by the application.
The two possible authentication types for a resource.
The resource context provides access to instances of resource classes.
An injectable class to access the resource class and resource method matched by the current request.
This class is used to allow multiple resources declarations.
Defines the contract between a returned instance and the runtime when an application needs to provide meta-data to the runtime.
A class used to build Response instances that contain metadata instead of or in addition to an entity.
Commonly used status codes defined by HTTP, see {@link <a href="http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10">HTTP/1.1 documentation} for the complete list.
An enumeration representing the class of status code.
Base interface for statuses used in responses.
Converts an JAX-RS Response object into an Exception.
JAX-RS client-side runtime processing exception thrown to indicate that response processing has failed (e.g.
Use the RestClient qualifier on an injection to point to indicate that this injection point is meant to use an instance of a Type-Safe Rest Client.
 
This is the main entry point for creating a Type Safe Rest Client.
Implementations of this interface will be notified when new RestClientBuilder instances are being constructed.
Resolver for a RestClientBuilder implementation.
This exception is thrown when the MicroProfile Rest Client implementation attempts to build a client using an invalid interface.
Implementations of this interface will be notified when new Rest Client instances are being constructed.
The retry annotation to define the number of retries.
Specifies the list of security roles permitted to access method(s) in an application.
Defines the identity of the application during execution.
Implementations of JAX-RS provide a concrete subclass of RuntimeDelegate and various JAX-RS API methods defer to methods of RuntimeDelegate for their functionality.
Defines the contract for a delegate that is responsible for converting between the String form of a HTTP header and the corresponding JAX-RS type T.
Enumeration of JAX-RS runtime types.
Uniform interface for reactive invocation of HTTP methods.
RxInvoker provider.
An object which samples values.
The Schema Object allows the definition of input and output data types.
The Schema Object allows the definition of input and output data types.
The values allowed for the in field.
The SchemaProperty Object allows the definition of input and output data types nested within the properties attribute of a Schema annotation.
 
Identifies scope annotations.
Provides access to the current container in Java SE.
A CDI container initializer for Java SE.
An injectable interface that provides access to security related information.
Specifies a security requirement for an operation.
SecurityRequirement
This object represents an array of security requirements that can be specified for the operation or at definition level.
This object represents a map of security requirements that can be specified for the operation or at definition level.
Defines a security scheme that can be used by the operations.
SecurityScheme
In is a REQUIRED property that specifies the location of the API key.
Type is a REQUIRED property that specifies the type of SecurityScheme instance.
 
This object represents an array of SecurityScheme annotations that can be specified at the definition level.
 
Provides JSONB internals for custom serializers.
This annotation represents a Server used in an operation or used by all operations in an OpenAPI document.
An object representing a server.
A base runtime application exception indicating a server error (HTTP 5xx status codes).
The Servers annotation is a container for @Server annotations.
An object representing a Server Variable for server URL template substitution.
An object representing a Server Variable for server URL template substitution.
A runtime exception indicating that the requested resource cannot be served.
Identifies the kind of EJB session bean.
Specifies that a bean is session scoped.
Supports inline instantiation of the SessionScoped annotation.
A simple timer metric which tracks elapsed time durations and count.
A timing context.
An annotation for marking a method, constructor, or class as simply timed.
Identifies a type that the injector only instantiates once.
Supports inline instantiation of the Singleton annotation.
A statistical snapshot of a Snapshot.
Indicates that a bean directly specializes another bean.
Supports inline instantiation of the Specializes annotation.
Server-side entry point for creating OutboundSseEvent and SseBroadcaster.
Server-Sent events broadcasting facility.
Base Server Sent Event definition.
Outbound Server-Sent Events stream.
Client for reading and processing incoming Server-Sent Events.
JAX-RS SseEventSource builder class.
A stage of a Reactive Streams graph.
A cancelling stage.
A collect stage.
Concatenate the given graphs together.
A stage that couples a wrapped subscriber graph to a wrapped publisher graph.
A stage returning a stream consisting of the distinct elements (according to Object.equals(Object)) of this stream.
A drop while stage.
A failed publisher.
A filter stage.
A subscriber stage that emits the first element encountered.
A flat map stage.
A flat map stage that emits and flattens CompletionStage.
A flat map stage that emits and fattens Iterable.
A publisher representation of a CompletionStage.
A publisher representation of a CompletionStage.
A limit stage.
A map stage.
A publisher of zero to many values.
A stage returning a stream containing all the elements from this stream, additionally performing the provided action when this stream completes.
A stage returning a stream containing all the elements from this stream, additionally performing the provided action if this stream conveys an error.
A stage to handle errors from upstream.
A stage to handle errors from upstream.
A stage returning a stream containing all the elements from this stream, additionally performing the provided action if this stream terminates with an error, completes, or is cancelled by downstream.
A stage returning a stream containing all the elements from this stream, additionally performing the provided action on each element.
A processor stage.
A publisher stage.
A skip stage.
A subscriber.
A take while stage.
This qualifier is used to define a Startup Health Check procedure mapped to the Startup Kubernetes probes.
Support inline instantiation of the Startup qualifier.
Specifies that an annotation type is a stereotype.
A type that may be used as a resource method return value or as the entity in a Response when the application wishes to stream the output.
A builder for a Subscriber and its result.
A subscriber and completion stage pair.
Inject a suspended AsyncResponse into a parameter of an invoked JAX-RS resource or sub-resource method.
Uniform interface for synchronous invocation of HTTP methods.
Tag represents a singular metric tag key and value pair.
This object represents a tag.
Tag
The Tags annotation is a container for @Tag annotations.
This interface offers various methods for capturing the context of the current thread and applying it to various interfaces that are commonly used with completion stages and executor services.
Builder for ThreadContext instances.
Represents context that is applied to a particular thread, along with any state that is associated with it or that is necessary for restoring the previous context afterward.
Third party providers of thread context implement this interface to enable the provided type of context to participate in thread context capture and propagation when the ManagedExecutor and ThreadContext are used to create and contextualize dependent actions and tasks.
An immutable snapshot of a particular type of thread context.
An annotation for marking a method, constructor, or class as timed.
The annotation to define a method execution timeout.
The exception should be thrown when timeout is reached.
Asynchronous response suspend time-out handler.
A timer metric which aggregates timing durations and provides duration statistics, plus throughput statistics via Meter.
A timing context.
All instances of PublisherBuilder, ProcessorBuilder, SubscriberBuilder and CompletionRunner must implement this, to ensure that the builder can be turned into a graph by other implementations of the API.
This annotation allows fine-tuned control over which classes and methods create OpenTracing spans.
Distinguishes the various kinds of transactional observer methods from regular observer methods which are notified immediately.
Operations for transforming a stream.
If a parameter annotated with @TransientReference resolves to a dependent scoped bean, then the bean will be destroyed after the invocation completes.
Supports inline instantiation of the TransientReference annotation.
Restricts the bean types of a bean.
Supports inline instantiation of the Typed annotation.
Supports inline instantiation of objects that represent parameterized types with actual type parameters.
Helper class for injecting and calling lifecycle callbacks unmanaged instances for use by framework and library integrators.
Represents a non-contextual instance.
Indicates that a contextual reference for a bean with a normal scope and a certain bean type cannot be obtained because the bean type cannot be proxied by the container.
Indicates that no bean matches a certain combination of required type and required qualifiers and is eligible for injection into a certain class.
Exception thrown when a reactive streams engine doesn't support a stage that is passed to it.
URI template-aware utility class for building URIs from their components.
A runtime exception thrown by UriBuilder.build(Object...) methods when a URI cannot be constructed based on the current state of the builder.
An injectable interface that provides access to application and request URI information.
Abstraction for a resource representation variant.
A builder for a list of representation variants.
Veto the processing of the class.
Supports inline instantiation of the Vetoed annotation.
Runtime exception for applications.
A resource target identified by the resource URI.
WithAnnotations may be applied to any portable extension observer method with an event parameter type of ProcessAnnotatedType to filter the events delivered.
A metadata object that allows for more fine-tuned XML model definitions.