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>>.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.Builder for annotations of given type.
Supports instantiating
AnnotationBuilder.An annotation instance, typically obtained from an
AnnotationTarget.
Supports inline instantiation of annotation type instances.
The value of an annotation member.
The kind of the annotation member value.
An annotation target is anything that can be annotated.
The built-in qualifier type.
Supports inline instantiation of the
Any qualifier.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.
An array type is created from a component type.
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.BeanContainer is a superclass of BeanManager containing capabilities that are portable across
all CDI environments.Beans are:
managed beans
beans defined by producer methods
beans defined by producer fields
synthetic beans
Managed beans are also known as class-based beans, while beans defined by producer methods
and producer fields are together also known as producer-based beans.
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.
Build compatible extensions are service providers for this interface, as defined in
ServiceLoader.Service provider interface for various services needed by
BuildCompatibleExtension implementations.An internal helper to resolve
BuildServices implementations.
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.
Provides access to the current container.
Interface implemented by a CDI provider to provide access to the current container
Allows adding annotations to and removing annotations from a class.
A class.
A class type, including interface types, enum types, annotation types and record types.
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).Client request filter context.
An extension interface implemented by client request filters.
Client response filter context.
An extension interface implemented by client response filters.
A request processing callback that receives request processing completion events.
Reactive invoker based
CompletionStage.Represents a client or server-side configurable context in JAX-RS.
A configuration state associated with a
configurable JAX-RS context.Asynchronous request processing lifecycle callback that receives connection related
asynchronous
response lifecycle events.Indicates the run-time context in which an annotated JAX-RS provider is applicable.
Defines the media types that the methods of a resource class or
MessageBodyReader can accept.Container request filter context.
An extension interface implemented by container request filters.
Container response filter context.
An extension interface implemented by container response filters.
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.
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.Represents the value of a HTTP cookie, transferred in a request.
JAX-RS abstract
Cookie builder class.JAX-RS
Cookie builder class.Binds the value of a HTTP cookie to a resource method parameter, resource class field, or resource class bean
property.
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.Allows adding annotations to and removing annotations from a declaration.
A declaration is an element of a program source code.
The declaration kind: package, class, method, parameter, field, record component.
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.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.1st phase of build compatible extension execution.
Disposer methods may exist for producer-based beans.
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.2nd phase of build compatible extension execution.
Encapsulates message entity including the associated variant information.
A
EntityPart is one part of a multipart entity.Builder for
EntityPart instances.An abstraction for the value of a HTTP Entity Tag, used as the value of an ETag response header.
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.
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.
Service interface implemented by extensions.
A feature extension contract.
A configurable context passed to
Feature and DynamicFeature instances by JAX-RS
runtime during the phase of their configuration.Allows adding annotations to and removing annotations from a field.
A field, declared in some class.
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.
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.
Indicates that the annotated method responds to HTTP HEAD requests.
Binds the value(s) of a HTTP header to a resource method parameter, resource class field, or resource class bean
property.
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.
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.An injection point defined on some bean.
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.
This interface represents a contextual reference handle.
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.
Context shared by message body interceptors that can be used to wrap calls to
MessageBodyReader.readFrom(java.lang.Class<T>, java.lang.reflect.Type, java.lang.annotation.Annotation[], jakarta.ws.rs.core.MediaType, jakarta.ws.rs.core.MultivaluedMap<java.lang.String, java.lang.String>, java.io.InputStream) and MessageBodyWriter.writeTo(T, java.lang.Class<?>, java.lang.reflect.Type, java.lang.annotation.Annotation[], jakarta.ws.rs.core.MediaType, jakarta.ws.rs.core.MultivaluedMap<java.lang.String, java.lang.Object>, java.io.OutputStream).Interceptors are managed beans annotated
@Interceptor.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.
An invoker allows indirect invocation of its target method on an instance of its target
bean.
Builder of
Invokers.Factory for
InvokerBuilders.Opaque token that stands in for an invoker registered using
InvokerFactory.createInvoker(BeanInfo, MethodInfo)
and InvokerBuilder.build().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.
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.
Subtype is tightly bound to the
JsonbTypeInfo.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.
Configuration annotation of the type information handling.
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.This class contains the Json properties and values.
Contains the different values allowed for
JsonConfig.KEY_STRATEGY.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.
Factory to create
JsonReader instances.An immutable JSON string value.
JsonValue represents an immutable JSON value.Indicates the type of a
JsonValue object.Factory to create
JsonWriter instances.
Class representing hypermedia links.
Builder class for hypermedia links.
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.
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.
Allows logging and producing errors during build compatible extension
execution.
Allows registering custom CDI meta-annotations: qualifiers, interceptor bindings,
stereotypes, and scopes.
Allows adding annotations to and removing annotations from a method.
A method or a constructor, declared in some class.
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.Used to create a new HTTP cookie, transferred in a response.
JAX-RS abstract
NewCookie builder class.JAX-RS
NewCookie builder class.The available values for the
SameSite cookie attribute.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.
The annotated element must not be null.
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.The annotated element could be null under some circumstances.
Indicates that a checked exception was thrown by an observer method during event notification.
Observers are:
observer methods
synthetic observers
Observer methods directly correspond to a method declaration in program source code.
Represents an observer method of an enabled
bean.
An
ObserverMethodConfigurator can configure an ObserverMethod.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.
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.A package, possibly annotated in
package-info.java.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.Allows adding annotations to and removing annotations from a method parameter.
A method parameter or a constructor parameter, declared in some method
or constructor.
A parameterized type.
A
String-keyed parameter map.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.
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.
Represents a URI path segment and any associated matrix parameters.
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.Primitive types are:
boolean
byte
short
int
long
float
double
char
The primitive type kind: boolean, byte, short, int, long, float, double, char
A collection of built-in priority constants for the JAX-RS components that are supposed to be ordered based on their
jakarta.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 any program elements
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 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 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.
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 Java class or interface added by
BeforeBeanDiscovery.addAnnotatedType(AnnotatedType, String) or
AfterTypeDiscovery.addAnnotatedType(AnnotatedType, String)
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.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.
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.
Interface for message body reader interceptors that wrap around calls to
MessageBodyReader.readFrom(java.lang.Class<T>, java.lang.reflect.Type, java.lang.annotation.Annotation[], jakarta.ws.rs.core.MediaType, jakarta.ws.rs.core.MultivaluedMap<java.lang.String, java.lang.String>, java.io.InputStream).Context class used by
ReaderInterceptor to intercept calls to (@link
jakarta.ws.rs.ext.MessageBodyReader#readFrom}.
Distinguishes conditional observer methods from observer methods which are
always notified.
A record component, declared in some record.
A runtime application exception indicating a request redirection (HTTP
3xx status codes).3rd phase of build compatible extension execution.
An injectable helper for request processing, all methods throw an
IllegalStateException if called outside the
scope of a request (e.g.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
HTTP/1.1 documentation for the complete
list.
An enumeration representing the class of status code.
Base interface for statuses used in responses.
JAX-RS client-side runtime processing exception thrown to indicate that response processing has failed (e.g.
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.Allows adding additional classes to the set of types discovered during type discovery.
Identifies scope annotations.
A scope of a bean.
Bootstrap class used to startup a JAX-RS application in Java SE environments.
Provides information needed by the JAX-RS implementation for bootstrapping an application.
Builder for bootstrap
SeBootstrap.Configuration.Secure socket client authentication policy
Handle of the running application instance.
Result of stopping the application instance.
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.
Provides JSONB internals for custom serializers.
A base runtime application exception indicating a server error (HTTP
5xx status codes).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.Identifies a type that the injector only instantiates once.
Supports inline instantiation of the
Singleton annotation.If a build compatible extension is annotated
@SkipIfPortableExtensionPresent, it is ignored when the CDI container
can execute portable extensions and determines that a portable extension
of given class is present.
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.
Specifies that an annotation type is a stereotype.
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.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.
4th phase of build compatible extension execution.
Builder for synthetic beans.
Creation function for a synthetic bean defined by
SyntheticBeanBuilder.Destruction function for a synthetic bean defined by
SyntheticBeanBuilder.Allows registering synthetic beans and observers.
The event notification function for a synthetic observer defined by
SyntheticObserverBuilder.Builder for synthetic observers.
Asynchronous response suspend time-out handler.
Distinguishes the various kinds of transactional observer methods from regular
observer methods which are notified immediately.
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.A type is used in a program source code, but does not have to be declared anywhere.
The type kind: void, primitive, class, array, parameterized type, type variable, wildcard type
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.
Factory for types.
Type variables represent type parameters declared on generic classes or methods.
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.
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.
5th phase of build compatible extension execution.
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.The
void pseudo-type.Runtime exception for applications.
A resource target identified by the resource URI.
A wildcard type.
WithAnnotations may be applied to any portable extension observer method with an event parameter type of
ProcessAnnotatedType to filter the events delivered.Interface for message body writer interceptors that wrap around calls to
MessageBodyWriter.writeTo(T, java.lang.Class<?>, java.lang.reflect.Type, java.lang.annotation.Annotation[], jakarta.ws.rs.core.MediaType, jakarta.ws.rs.core.MultivaluedMap<java.lang.String, java.lang.Object>, java.io.OutputStream).