All Classes

Class	Description
AbortedException	Exception indicating that the result of a task cannot be retrieved because the task failed to run for some reason other than being cancelled.
AbortProcessingException	An exception that may be thrown by event listeners to terminate the processing of the current event.
AbstractBatchlet	The AbstractBatchlet provides default implementations of less commonly implemented methods.
AbstractCheckpointAlgorithm	The AbstractCheckpointAlgorithm provides default implementations of less commonly implemented methods.
AbstractChunkListener	The AbstractChunkListener provides default implementations of less commonly implemented methods.
AbstractClearableCredential	AbstractClearableCredential contains behavior common to Credential implementations that can be meaningfully cleared.
AbstractItemProcessListener	The AbstractItemProcessListener provides default implementations of less commonly implemented methods.
AbstractItemReader	The AbstractItemReader provides default implementations of less commonly implemented methods.
AbstractItemReadListener	The AbstractItemReadListener provides default implementations of less commonly implemented methods.
AbstractItemWriteListener	The AbstractItemWriteListener provides default implementations of less commonly implemented methods.
AbstractItemWriter	The AbstractItemWriter provides default implementations of not commonly implemented methods.
AbstractJobListener	The AbstractJobListener provides default implementations of less commonly implemented methods.
AbstractMarshallerImpl	Partial default Marshaller implementation.
AbstractMultivaluedMap<K,V>	Abstract skeleton implementation of a MultivaluedMap that is backed by a [key, multi-value] store represented as a Map<K, List<V>>.
AbstractPartitionAnalyzer	The AbstractPartitionAnalyzer provides default implementations of less commonly implemented methods.
AbstractPartitionReducer	The AbstractBatchlet provides default implementations of less commonly implemented methods.
AbstractQuery<T>	The AbstractQuery interface defines functionality that is common to both top-level queries and subqueries.
AbstractStepListener	The AbstractStepListener provides default implementations of less commonly implemented methods.
AbstractUnmarshallerImpl	Partial default Unmarshaller implementation.
Access	Used to specify an access type to be applied to an entity class, mapped superclass, or embeddable class, or to a specific attribute of such a class.
AccessLocalException	An AccessLocalException is thrown to indicate that the caller does not have permission to call the method.
AccessTimeout	Specifies the amount of time in a given time unit that a concurrent access attempt should block before timing out.
AccessToken	The Access Token is used by an application to access protected resources.
AccessToken.Type
AccessType	Used with the Access annotation to specify an access type to be applied to an entity class, mapped superclass, or embeddable class, or to a specific attribute of such a class.
Action	The Action annotation allows explicit association of a WS-Addressing Action message addressing property with input, output, and fault messages of the mapped WSDL operation.
ActionEvent	An ActionEvent represents the activation of a user interface component (such as a UICommand).
ActionListener	A listener interface for receiving ActionEvents.
ActionListenerWrapper	Provides a simple implementation of ActionListener that can be subclassed by developers wishing to provide specialized behavior to an existing ActionListener instance.
ActionSource	ActionSource is an interface that may be implemented by any concrete UIComponent that wishes to be a source of ActionEvents, including the ability to invoke application actions via the default ActionListener mechanism.
ActionSource2	ActionSource2 extends ActionSource and provides a JavaBeans "action" property.
ActionSource2AttachedObjectHandler	A VDL handler that exposes ActionListener to a page author.
ActionSource2AttachedObjectTarget	A marker interface for VDL tags that represent <composite:actionSource/> for use by the composite component page author.
ActivateRequestContext	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.
Activation	Designates a JavaBean as an ActivationSpec.
ActivationConfigProperty	Used to provide information to the deployer about the configuration of a message driven bean in its operational environment.
ActivationDataFlavor	The ActivationDataFlavor class is similar to the JDK's java.awt.datatransfer.DataFlavor class.
ActivationSpec	This interface serves as a marker.
Address	This abstract class models the addresses in a message.
AddressException	The exception thrown when a wrongly formatted address is encountered.
Addressing	This annotation represents the use of WS-Addressing with either the SOAP 1.1/HTTP or SOAP 1.2/HTTP binding.
AddressingFeature	AddressingFeature represents the use of WS-Addressing with either the SOAP 1.1/HTTP or SOAP 1.2/HTTP binding.
AddressingFeature.Responses	If addressing is enabled, this property determines if endpoint requires the use of only anonymous responses, or only non-anonymous responses, or all.
AddressStringTerm	This abstract class implements string comparisons for Message addresses.
AddressTerm	This class implements Message Address comparisons.
AdministeredObject	Designates a JavaBean as an administered object.Administered objects are specific to a messaging style or message provider.
AdministeredObjectDefinition	Annotation used to define a Connector administered object to be registered in JNDI.
AdministeredObjectDefinitions	Declares one or more AdministeredObjectDefinition annotations.
AfterBeanDiscovery	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.
AfterBegin	Designate a stateful session bean method to receive the after begin session synchronization callback.
AfterCompletion	Designate a stateful session bean method to receive the after completion session synchronization callback.
AfterDeploymentValidation	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.
AfterTypeDiscovery	This event type is thrown by the container after type discovery is complete.
AjaxBehavior	An instance of this class is added as a ClientBehavior to a component using the ClientBehaviorHolder.addClientBehavior(java.lang.String, jakarta.faces.component.behavior.ClientBehavior) contract that components implement.
AjaxBehaviorEvent	AjaxBehaviorEvent represents the component behavior specific to Ajax).
AjaxBehaviorListener	By implementing this class, an object indicates that it is a listener for one or more kinds of BehaviorEvents.
AlterableContext	Provides an operation for obtaining and destroying contextual instances with a particular scope of any contextual type.
Alternative	Specifies that a bean is an alternative.
Alternative.Literal	Supports inline instantiation of the Alternative annotation.
AmbiguousResolutionException	Indicates that multiple beans match a certain combination of required type and required qualifiers and are eligible for injection into a certain class.
AndTerm	This class implements the logical AND operator on individual SearchTerms.
Annotated	Represents a Java program element that can be annotated.
AnnotatedCallable<X>	Represents a callable member of a Java type.
AnnotatedConstructor<X>	Represents a constructor of a Java class.
AnnotatedConstructorConfigurator<T>	This interface is part of the AnnotatedTypeConfigurator SPI and helps defining an AnnotatedConstructor
AnnotatedField<X>	Represents a field of a Java class.
AnnotatedFieldConfigurator<T>	This interface is part of the AnnotatedTypeConfigurator SPI and helps defining an AnnotatedField
AnnotatedMember<X>	Represents a member of a Java type.
AnnotatedMethod<X>	Represents a method of a Java type.
AnnotatedMethodConfigurator<T>	This interface is part of the AnnotatedTypeConfigurator SPI and helps defining an AnnotatedMethod
AnnotatedParameter<X>	Represents a parameter of a method or constructor.
AnnotatedParameterConfigurator<T>	This interface is part of the AnnotatedTypeConfigurator SPI and helps defining an AnnotatedParameter
AnnotatedType<X>	Represents a Java class or interface.
AnnotatedTypeConfigurator<T>	This API is a helper to configure a new AnnotatedType instance.
AnnotationBuilder	Builder for annotations of given type.
AnnotationBuilderFactory	Supports instantiating AnnotationBuilder.
AnnotationInfo	An annotation instance, typically obtained from an AnnotationTarget.
AnnotationLiteral<T extends Annotation>	Supports inline instantiation of annotation type instances.
AnnotationMember	The value of an annotation member.
AnnotationMember.Kind	The kind of the annotation member value.
AnnotationTarget	An annotation target is anything that can be annotated.
Any	The built-in qualifier type.
Any.Literal	Supports inline instantiation of the Any qualifier.
Application	Application represents a per-web-application singleton object where applications based on Jakarta Faces (or implementations wishing to provide extended functionality) can register application-wide singletons that provide functionality required by Jakarta Faces.
Application	Defines the components of a JAX-RS application and supplies additional meta-data.
ApplicationConfigurationPopulator	This class defines a java.util.ServiceLoader service which enables programmatic configuration of the Jakarta Server Faces runtime using the existing Application Configuration Resources schema.
ApplicationException	Applied to an exception to denote that it is an application exception and should be reported to the client directly (i.e., unwrapped).
ApplicationFactory	ApplicationFactory is a factory object that creates (if needed) and returns Application instances.
ApplicationMap	The presence of this annotation (along with @Inject) on a field of type Map<String, Object> causes the map returned from ExternalContext.getApplicationMap() to be injected as the value of that field.
ApplicationMap.Literal	Supports inline instantiation of the ApplicationMap qualifier.
ApplicationPath	Identifies the application path that serves as the base URI for all resource URIs provided by Path.
ApplicationScoped	Specifies that a bean is application scoped.
ApplicationScoped.Literal	Supports inline instantiation of the ApplicationScoped annotation.
ApplicationServerInternalException	An ApplicationServerInternalException is thrown by an application server to indicate error conditions specific to an application server.
ApplicationWrapper	Provides a simple implementation of Application that can be subclassed by developers wishing to provide specialized behavior to an existing Application instance.
AroundConstruct	Designates an interceptor method that receives a callback when the target class constructor is invoked.
AroundInvoke	Defines an interceptor method that interposes on business methods.
AroundTimeout	Defines an interceptor method that interposes on timeout methods.
ArrayDataModel<E>	ArrayDataModel is a convenience implementation of DataModel that wraps an array of Java objects.
ArrayELResolver	Defines property resolution behavior on arrays.
ArrayType	An array type is created from a component type.
AssertFalse	The annotated element must be false.
AssertFalse.List	Defines several AssertFalse annotations on the same element.
AssertTrue	The annotated element must be true.
AssertTrue.List	Defines several AssertTrue annotations on the same element.
AssociationOverride	Used to override a mapping for an entity relationship.
AssociationOverrides	Used to override mappings of multiple relationship properties or fields.
AsyncContext	Class representing the execution context for an asynchronous operation that was initiated on a ServletRequest.
AsyncEvent	Event that gets fired when the asynchronous operation initiated on a ServletRequest (via a call to ServletRequest.startAsync() or ServletRequest.startAsync(ServletRequest, ServletResponse)) has completed, timed out, or produced an error.
AsyncHandler<T>	The AsyncHandler interface is implemented by clients that wish to receive callback notification of the completion of service endpoint operations invoked asynchronously.
Asynchronous	Used to mark a session bean method as an asynchronous method or to designate all business methods of a session bean class as asynchronous.
Asynchronous	Annotates a CDI managed bean method to run asynchronously.
Asynchronous.Result	Mechanism by which the Jakarta EE Product Provider makes available to the asynchronous method implementation the same CompletableFuture instance that the Jakarta EE Product Provider supplies to the caller of the asynchronous method.
AsyncInvoker	Uniform interface for asynchronous invocation of HTTP methods.
AsyncListener	Listener that will be notified in the event that an asynchronous operation initiated on a ServletRequest to which the listener had been added has completed, timed out, or resulted in an error.
AsyncResponse	An injectable JAX-RS asynchronous response that provides means for asynchronous server side response processing.
AsyncResult<V>	Wraps the result of an asynchronous method call as a Future object, preserving compatability with the business interface signature.
AttachedObjectHandler	The abstract base interface for a handler representing an attached object in a VDL page.
AttachedObjectTarget	Within the declaration of a composite component, an AttachedObjectTarget allows the composite component author to expose the semantics of an inner component to the page author without exposing the rendering or implementation details of the inner component.
AttachmentMarshaller	Enable Jakarta XML Binding marshalling to optimize storage of binary data.
AttachmentPart	A single attachment to a SOAPMessage object.
AttachmentUnmarshaller	Enables Jakarta XML Binding unmarshalling of a root document containing optimized binary data formats.
Attribute<X,Y>	Represents an attribute of a Java type.
Attribute.PersistentAttributeType
AttributeConverter<X,Y>	A class that implements this interface can be used to convert entity attribute state into database column representation and back again.
AttributeHandler	An interface that allows other code to identify FaceletHandlers that correspond to component attributes.
AttributeNode<T>	Represents an attribute node of an entity graph.
AttributeOverride	Used to override the mapping of a Basic (whether explicit or default) property or field or Id property or field.
AttributeOverrides	Used to override mappings of multiple properties or fields.
AuthConfig	This interface defines the common functionality implemented by Authentication context configuration objects.
AuthConfigFactory	This class is used to obtain AuthConfigProvider objects that can be used to obtain authentication context configuration objects, that is, ClientAuthConfig and ServerAuthConfig objects.
AuthConfigFactory.RegistrationContext	Represents the layer identifier, application context identifier, and description components of an AuthConfigProvider registration at the factory.
AuthConfigProvider	This interface is implemented by objects that can be used to obtain authentication context configuration objects, that is, ClientAuthConfig or ServerAuthConfig objects.
AuthenticationException	A generic authentication exception.
AuthenticationFailedException	This exception is thrown when the connect method on a Store or Transport object fails due to an authentication failure (e.g., bad user name or password).
AuthenticationMechanism
AuthenticationMechanism.CredentialInterface	An enumerated type that represents the various interfaces that a resource adapter may support for the representation of the credentials.
AuthenticationParameters	Parameters that are provided along with an authentication request.
AuthenticationStatus	The AuthenticationStatus is used as a return value by primarily the HttpAuthenticationMechanism to indicate the result (status) of the authentication process.
Authenticator	The class Authenticator represents an object that knows how to obtain authentication for a network connection.
AuthException	A generic authentication exception.
AuthStatus	The AuthStatus class is used to represent return values from Authentication modules and Authentication Contexts.
AutoApplySession	The AutoApplySession annotation provides an application the ability to declaratively designate that an authentication mechanism uses the jakarta.servlet.http.registerSession and auto applies this for every request.
AutoApplySession.Literal	Supports inline instantiation of the AutoApplySession annotation.
BadRequestException	A runtime exception indicating a bad client request.
Basic	The simplest type of mapping to a database column.
BasicAuthenticationCredential	BasicAuthenticationCredential extends UsernamePasswordCredential to represent credentials used by HTTP Basic Authentication.
BasicAuthenticationMechanismDefinition	Annotation used to define a container authentication mechanism that implements the HTTP basic access authentication protocol as defined by the Servlet spec (13.6.1) and make that implementation available as an enabled CDI bean.
BasicType<X>	Instances of the type BasicType represent basic types (including temporal and enumerated types).
Batchlet	A batchlet is type of batch step that can be used for any type of background processing that does not explicitly call for a chunk oriented approach.
BatchProperty	Annotation used by batch artifacts and CDI Beans to declare a field or other element which is injectable via a JSL-defined value (possibly leveraging Job XML substitutions).
BatchRuntime	BatchRuntime represents the Jakarta Batch Runtime.
BatchRuntimeException	This is the common base class for all of the RuntimeException(s) thrown by the JobOperator API methods to its callers.
BatchStatus	BatchStatus enum defines the batch status values possible for a job.
Bean<T>	Represents an enabled bean.
BeanAttributes<T>	The BeanAttributes interface exposes the basic attributes of a bean.
BeanAttributesConfigurator<T>	This API is an helper to configure a new BeanAttributes instance.
BeanConfigurator<T>	This API is an helper to configure a new Bean instance.
BeanContainer	BeanContainer is a superclass of BeanManager containing capabilities that are portable across all CDI environments.
BeanDescriptor	Describes a constrained Java Bean and the constraints associated to it.
BeanELResolver	Defines property resolution behavior on objects using the JavaBeans component architecture.
BeanInfo	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.
BeanManager	Allows a portable extension to interact directly with the container.
BeanNameELResolver	An ELResolver for resolving user or container managed beans.
BeanNameResolver	Resolves a bean by its known name.
BeanParam	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.
BeanValidator	A Validator that delegates validation of the bean property to the Bean Validation API.
BeforeBeanDiscovery	This event type is thrown by the container before the bean discovery process begins.
BeforeCompletion	Designate a stateful session bean method to receive the before completion session synchronization callback.
BeforeDestroyed	An event with this qualifier is fired when a context is about to be destroyed, i.e.
BeforeDestroyed.Literal	Supports inline instantiation of the BeforeDestroyed qualifier.
BeforeShutdown	The type of the final event the container fires after it has finished processing requests and destroyed all contexts.
Behavior	The Behavior interface is the root API of the component behavior model.
BehaviorBase	BehaviorBase is a convenience base class that provides a default implementation of the Behavior contract.
BehaviorConfig	Convey the id of a behavior declared in a view.
BehaviorEvent	BehaviorEvent is the event that can be generated from component Behavior.
BehaviorHandler	The FaceletHandler that corresponds to attached objects that represent an instance of ClientBehavior that must be added to the parent component, which must implement ClientBehaviorHolder, with a call to ClientBehaviorHolder.addClientBehavior(java.lang.String, jakarta.faces.component.behavior.ClientBehavior).
BehaviorHolderAttachedObjectHandler	Represent an attached object that is a BehaviorHolder in a VDL page.
BehaviorHolderAttachedObjectTarget	Represent a BehaviorHolder attached object target in a VDL page.
BehaviorListener	A generic base interface for event listeners for various types of BehaviorEvents.
BigDecimalConverter	Converter implementation for java.math.BigDecimal values.
BigIntegerConverter	Converter implementation for java.math.BigInteger values.
BinaryDataStrategy	Specifies predefined binary data handling strategies.
Bindable<T>	Instances of the type Bindable represent object or attribute types that can be bound into a Path.
Bindable.BindableType
Binder<XmlNode>	Enable synchronization between XML infoset nodes and Jakarta XML Binding objects representing same XML document.
Binding	The Binding interface is the base interface for Jakarta XML Web Services protocol bindings.
BindingProvider	The BindingProvider interface provides access to the protocol binding and associated context objects for request and response message processing.
BindingType	The BindingType annotation is used to specify the binding to use for a web service endpoint implementation class.
BodyContent	An encapsulation of the evaluation of the body of an action so it is available to a tag handler.
BodyPart	This class models a Part that is contained within a Multipart.
BodyTag	The BodyTag interface extends IterationTag by defining additional methods that let a tag handler manipulate the content of evaluating its body.
BodyTagSupport	A base class for defining tag handlers implementing BodyTag.
BodyTerm	This class implements searches on a message body.
BooleanConverter	Converter implementation for java.lang.Boolean (and boolean primitive) values.
BootstrapConfiguration	Represents the user specified default configuration in META-INF/validation.xml.
BootstrapContext	This provides a mechanism to pass a bootstrap context to a resource adapter instance when it is bootstrapped.
BootstrapState	Defines the state used to bootstrap the Configuration.
BuildCompatibleExtension	Build compatible extensions are service providers for this interface, as defined in ServiceLoader.
BuildServices	Service provider interface for various services needed by BuildCompatibleExtension implementations.
BusyConversationException	Indicates that the container has rejected a request because a concurrent request is associated with the same conversation context.
ByteArrayDataSource	A DataSource backed by a byte array.
ByteConverter	Converter implementation for java.lang.Byte (and byte primitive) values.
BytesMessage	A BytesMessage object is used to send a message containing a stream of uninterpreted bytes.
Cache	Interface used to interact with the second-level cache.
Cacheable	Specifies whether an entity should be cached if caching is enabled when the value of the persistence.xml caching element is ENABLE_SELECTIVE or DISABLE_SELECTIVE.
CacheControl	An abstraction for the value of a HTTP Cache-Control response header.
CacheRetrieveMode	Used as the value of the jakarta.persistence.cache.retrieveMode property to specify the behavior when data is retrieved by the find methods and by queries.
CacheStoreMode	Used as the value of the jakarta.persistence.cache.storeMode property to specify the behavior when data is read from the database and when data is committed into the database.
CallerOnlyCredential	CallerOnlyCredential represents a credential that only contains a caller name and no secret of any kind.
CallerPrincipal	Principal that represents the caller principal associated with the invocation being processed by the container (e.g.
CallerPrincipalCallback	Callback for setting the container's caller (or remote user) principal.
CascadableDescriptor	Represents a cascadable element.
CascadeType	Defines the set of cascadable operations that are propagated to the associated entity.
CDI<T>	Provides access to the current container.
CDIProvider	Interface implemented by a CDI provider to provide access to the current container
CertStoreCallback	Callback for CertStore.
CharacterConverter	Converter implementation for java.lang.Character (and char primitive) values.
CheckpointAlgorithm	CheckpointAlgorithm provides a custom checkpoint policy for chunk steps.
ChunkListener	ChunkListener intercepts chunk processing.
Claims
ClaimsDefinition	ClaimsDefinition annotation defines claims mapping in openid connect client configuration.
ClassConfig	Allows adding annotations to and removing annotations from a class.
ClassInfo	A class.
ClassTransformer	A persistence provider supplies an instance of this interface to the PersistenceUnitInfo.addTransformer method.
ClassType	A class type, including interface types, enum types, annotation types and record types.
Client	Client is the main entry point to the fluent API used to build and execute client requests in order to consume responses returned.
ClientAuth	An implementation of this interface is used to secure service request messages, and validate received service response messages.
ClientAuthConfig	This interface encapsulates the configuration of ClientAuthContext objects for a message layer and application context (for example, the messaging context of a specific application, or set of applications).
ClientAuthContext	This ClientAuthContext class encapsulates ClientAuthModules that are used to secure service requests made by a client, and to validate any responses received to those requests.
ClientAuthModule	A ClientAuthModule secures request messages, and validates received response messages.
ClientBehavior	ClientBehavior is the base contract for Behaviors that attach script content to client-side events exposed by ClientBehaviorHolder components.
ClientBehaviorBase	ClientBehaviorBase is a convenience base class that implements the default concrete behavior of all methods defined by ClientBehavior.
ClientBehaviorContext	ClientBehaviorContext provides context information that may be useful to ClientBehavior.getScript(jakarta.faces.component.behavior.ClientBehaviorContext) implementations.
ClientBehaviorContext.Parameter	Parameter instances represent name/value pairs that "submitting" ClientBehavior implementations should include when posting back into the Faces lifecycle.
ClientBehaviorHint	An enum that specifies hints that describes the behavior of ClientBehavior implementations.
ClientBehaviorHolder	The ClientBehaviorHolder interface may be implemented by any concrete UIComponent that wishes to support client behaviors as defined by ClientBehavior.
ClientBehaviorRenderer	A ClientBehaviorRenderer produces the client-side script that implements a ClientBehavior's client-side logic.
ClientBuilder	Main entry point to the client API used to bootstrap Client instances.
ClientEndpoint	The ClientEndpoint annotation a class level annotation is used to denote that a POJO is a web socket client and can be deployed as such.
ClientEndpointConfig	The ClientEndpointConfig is a special kind of endpoint configuration object that contains web socket configuration information specific only to client endpoints.
ClientEndpointConfig.Builder	The ClientEndpointConfig.Builder is a class used for creating ClientEndpointConfig objects for the purposes of deploying a client endpoint.
ClientEndpointConfig.Configurator	The Configurator class may be extended by developers who want to provide custom configuration algorithms, such as intercepting the opening handshake, or providing arbitrary methods and algorithms that can be accessed from each endpoint instance configured with this configurator.
ClientErrorException	A base runtime application exception indicating a client request error (HTTP 4xx status codes).
ClientRequestContext	Client request filter context.
ClientRequestFilter	An extension interface implemented by client request filters.
ClientResponseContext	Client response filter context.
ClientResponseFilter	An extension interface implemented by client response filters.
ClientWindow	This class represents a client window, which may be a browser tab, browser window, browser pop-up, portlet, or anything else that can display a UIComponent hierarchy rooted at a UIViewRoot.
ClientWindowFactory	Create ClientWindow instances based on the incoming request.
ClientWindowScoped	ClientWindowScoped is a CDI scope that causes the runtime to consider classes with this annotation to be in the scope of the current ClientWindow.
ClientWindowWrapper	Wrapper for ClientWindow
ClockProvider	Contract for obtaining the Clock used as the reference for now when validating the @Future and @Past constraints.
CloseReason	A class encapsulating the reason why a web socket has been closed, or why it is being asked to close.
CloseReason.CloseCode	A marker interface for the close codes.
CloseReason.CloseCodes	An Enumeration of status codes for a web socket close that are defined in the specification.
CollapsedStringAdapter	Built-in XmlAdapter to handle xs:token and its derived types.
CollectionAttribute<X,E>	Instances of the type CollectionAttribute represent persistent java.util.Collection-valued attributes.
CollectionDataModel<E>	CollectionDataModel is a convenience implementation of DataModel that wraps an Collection of Java objects.
CollectionJoin<Z,E>	The CollectionJoin interface is the type of the result of joining to a collection over an association or element collection that has been specified as a java.util.Collection.
CollectionTable	Specifies the table that is used for the mapping of collections of basic or embeddable types.
Column	Specifies the mapped column for a persistent property or field.
ColumnResult	Used in conjunction with the SqlResultSetMapping annotation or ConstructorResult annotation to map a column of the SELECT list of a SQL query.
CommandInfo	The CommandInfo class is used by CommandMap implementations to describe the results of command requests.
CommandMap	The CommandMap class provides an interface to a registry of command objects available in the system.
CommandObject	JavaBeans components that are Jakarta Activation aware implement this interface to find out which command verb they're being asked to perform, and to obtain the DataHandler representing the data they should operate on.
CommException	This indicates errors related to failed or interrupted communication with an EIS instance.
CommonAbstractCriteria	The CommonAbstractCriteria interface defines functionality that is common to both top-level criteria queries and subqueries as well as to update and delete criteria operations.
ComparisonTerm	This class models the comparison operator.
CompletionCallback	A request processing callback that receives request processing completion events.
CompletionListener	A CompletionListener is implemented by the application and may be specified when a message is sent asynchronously.
CompletionStageRxInvoker	Reactive invoker based CompletionStage.
ComponentConfig	Passed to the constructor of ComponentHandler.
ComponentHandler	Public base class for markup element instances that map to UIComponent instances in the view.
ComponentNotFoundException	Typed FacesException for the SearchExpressionHandler, if a component can't be resolved.
ComponentSystemEvent	ComponentSystemEvent is the base class for SystemEvents that are specific to a UIComponent instance.
ComponentSystemEventListener	Implementors of this class do not need an isListenerForSource() method because they are only installed on specific component instances, therefore the isListenerForSource() method is implicit.
CompositeComponentExpressionHolder	This interface must be implemented by the Map returned by the composite component ELResolver, described in section 5.4.3.1 "faces.CompositeComponentAttributesELResolver" of the Jakarta Faces Specification Document, when evaluating #{cc.attrs} expressions.
CompositeELResolver	Maintains an ordered composite list of child ELResolvers.
CompositeFaceletHandler	A FaceletHandler that is derived of 1 or more, inner FaceletHandlers.
CompoundSelection<X>	The CompoundSelection interface defines a compound selection item (tuple, array, or result of constructor).
ConcurrencyManagement	Declares a singleton session bean's concurrency management type.
ConcurrencyManagementType	Used to specify the value of the ConcurrencyManagement annotation for a singleton session bean.
ConcurrentAccessException	A ConcurrentAccessException indicates that the client has attempted an invocation on a stateful session bean or singleton bean while another invocation is in progress and such concurrent access is not allowed.
ConcurrentAccessTimeoutException	This exception indicates that an attempt to concurrently access a stateful session or singleton bean method resulted in a timeout.
ConditionalTagSupport	Abstract class that facilitates implementation of conditional actions where the boolean result is exposed as a JSP scoped variable.
Config	Class supporting access to configuration settings.
ConfigProperty	Designates a JavaBean property as a configuration property
Configurable<C extends Configurable>	Represents a client or server-side configurable context in JAX-RS.
ConfigurableNavigationHandler	ConfigurableNavigationHandler extends the contract of NavigationHandler to allow runtime inspection of the NavigationCases that make up the rule-base for navigation.
ConfigurableNavigationHandlerWrapper	Provides a simple implementation of ConfigurableNavigationHandler that can be subclassed by developers wishing to provide specialized behavior to an existing ConfigurableNavigationHandler instance.
Configuration<T extends Configuration<T>>	Receives configuration information, selects the appropriate Jakarta Bean Validation provider and builds the appropriate ValidatorFactory.
Configuration	A configuration state associated with a configurable JAX-RS context.
ConfigurationState	Contract between a Configuration and a ValidationProvider to create a ValidatorFactory.
Connection	A Connection object is a client's active connection to its Jakarta Messaging provider.
Connection	A Connection represents an application-level handle that is used by a client to access the underlying physical connection.
ConnectionAdapter	The adapter which receives connection events.
ConnectionCallback	Asynchronous request processing lifecycle callback that receives connection related asynchronous response lifecycle events.
ConnectionConsumer	For application servers, Connection objects provide a special facility for creating a ConnectionConsumer (optional).
ConnectionDefinition	Defines a set of connection interfaces and classes pertaining to a particular connection type.
ConnectionDefinitions	Defines a set of connection definitions that the JavaBean, that has been annotated with this annotation, is a part of.
ConnectionEvent	This class models Connection events.
ConnectionEvent	The ConnectionEvent class provides information about the source of a connection related event.A ConnectionEvent instance contains the following information: Type of the connection event ManagedConnection instance that generated the connection event.
ConnectionEventListener	The ConnectionEventListener interface provides an event callback mechanism to enable an application server to receive notifications from a ManagedConnection instance.
ConnectionFactory	A ConnectionFactory object encapsulates a set of connection configuration parameters that has been defined by an administrator.
ConnectionFactory	ConnectionFactory provides an interface for getting connection to an EIS instance.
ConnectionFactoryDefinition	Annotation used to define a Connector Connection Factory resource to be registered in JNDI.
ConnectionFactoryDefinitions	Declares one or more ConnectionFactoryDefinition annotations.
ConnectionListener	This is the Listener interface for Connection events.
ConnectionManager	ConnectionManager interface provides a hook for the resource adapter to pass a connection request to the application server.
ConnectionMetaData	A ConnectionMetaData object provides information describing the Connection object.
ConnectionMetaData	The interface ConnectionMetaData provides information about an EIS instance connected through a Connection instance.
ConnectionRequestInfo	The ConnectionRequestInfo interface enables a resource adapter to pass its own request specific data structure across the connection request flow.
ConnectionSpec	ConnectionSpec is used by an application component to pass connection request-specific properties to the ConnectionFactory.
Connector	The Connector annotation is a component-defining annotation and it can be used by the resource adapter developer to specify that the JavaBean is a resource adapter JavaBean.
ConstrainedTo	Indicates the run-time context in which an annotated JAX-RS provider is applicable.
Constraint	Marks an annotation as being a Jakarta Bean Validation constraint.
ConstraintDeclarationException	Exception raised if a constraint declaration is not legal.
ConstraintDefinitionException	Exception raised if a constraint definition is not legal.
ConstraintDescriptor<T extends Annotation>	Describes a single constraint and its composing constraints.
ConstraintMode	Used to control the application of a constraint.
ConstraintTarget	Defines the constraint target.
ConstraintValidator<A extends Annotation,T>	Defines the logic to validate a given constraint A for a given object type T.
ConstraintValidatorContext	Provides contextual data and operation when applying a given constraint validator.
ConstraintValidatorContext.ConstraintViolationBuilder	ConstraintViolation builder allowing to optionally associate the violation report to a sub path.
ConstraintValidatorContext.ConstraintViolationBuilder.ContainerElementNodeBuilderCustomizableContext	Represents a container element node whose context is configurable (i.e.
ConstraintValidatorContext.ConstraintViolationBuilder.ContainerElementNodeBuilderDefinedContext	Represents a container element node whose context is known (i.e.
ConstraintValidatorContext.ConstraintViolationBuilder.ContainerElementNodeContextBuilder	Represents refinement choices for a container element node.
ConstraintValidatorContext.ConstraintViolationBuilder.LeafNodeBuilderCustomizableContext	Represents a node whose context is configurable (i.e.
ConstraintValidatorContext.ConstraintViolationBuilder.LeafNodeBuilderDefinedContext	Represents a node whose context is known (i.e.
ConstraintValidatorContext.ConstraintViolationBuilder.LeafNodeContextBuilder	Represents refinement choices for a node which is in an iterable, e.g.
ConstraintValidatorContext.ConstraintViolationBuilder.NodeBuilderCustomizableContext	Represents a node whose context is configurable (i.e.
ConstraintValidatorContext.ConstraintViolationBuilder.NodeBuilderDefinedContext	Represents a node whose context is known (i.e.
ConstraintValidatorContext.ConstraintViolationBuilder.NodeContextBuilder	Represents refinement choices for a node which is in an iterable, e.g.
ConstraintValidatorFactory	Instantiates a ConstraintValidator instance based off its class.
ConstraintViolation<T>	Describes a constraint violation.
ConstraintViolationException	Reports the result of constraint violations.
ConstructorDescriptor	Describes a validated constructor.
ConstructorResult	Used in conjunction with the SqlResultSetMapping annotation to map the SELECT clause of a SQL query to a constructor.
Consumes	Defines the media types that the methods of a resource class or MessageBodyReader can accept.
ContainerDescriptor	Represents an element that might be a container, thus allowing container element constraints.
ContainerElementTypeDescriptor	Describes a validated container element type, e.g.
ContainerProvider	Provider class that allows the developer to get a reference to the implementation of the WebSocketContainer.
ContainerRequestContext	Container request filter context.
ContainerRequestFilter	An extension interface implemented by container request filters.
ContainerResponseContext	Container response filter context.
ContainerResponseFilter	An extension interface implemented by container response filters.
ContentDisposition	This class represents a MIME ContentDisposition value.
ContentType	This class represents a MIME Content-Type value.
Context	Provides an operation for obtaining contextual instances with a particular scope of any contextual type.
Context	This annotation is used to inject information into a class field, bean property or method parameter.
ContextCallback	A simple callback interace that enables taking action on a specific UIComponent (either facet or child) in the view while preserving any contextual state for that component instance in the view.
ContextException	Indicates a problem relating to context management.
ContextNotActiveException	Indicates that a context is not active.
ContextResolver<T>	Contract for a provider that supplies context information to resource classes and other providers.
ContextService	The ContextService provides methods for creating dynamic proxy objects (as defined by java.lang.reflect.Proxy).
ContextServiceDefinition	Defines a ContextService to be registered in JNDI by the container under the JNDI name that is specified in the ContextServiceDefinition.name() attribute.
ContextServiceDefinition.List	Enables multiple ContextServiceDefinition annotations on the same type.
Contextual<T>	Defines operations to create and destroy contextual instances of a certain type.
Conversation	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.
ConversationScoped	Specifies that a bean is conversation scoped.
ConversationScoped.Literal	Supports inline instantiation of the ConversationScoped annotation.
Convert	Specifies the conversion of a Basic field or property.
Converter<T>	Converter is an interface describing a Java class that can perform Object-to-String and String-to-Object conversions between model data objects and a String representation of those objects that is suitable for rendering.
Converter	Specifies that the annotated class is a converter and defines its scope.
ConverterConfig	A Facelet version of the Jakarta Server Pages ConverterTag.
ConverterException	ConverterException is an exception thrown by the getAsObject() or getAsText() method of a Converter, to indicate that the requested conversion cannot be performed.
ConverterHandler	Handles setting a Converter instance on a ValueHolder parent.
ConvertGroup	Converts group from to group to during cascading.
ConvertGroup.List	Defines several ConvertGroup annotations on the same element.
Converts	Used to group Convert annotations.
Cookie	Creates a cookie, a small amount of information sent by a servlet to a Web browser, saved by the browser, and later sent back to the server.
Cookie	Represents the value of a HTTP cookie, transferred in a request.
Cookie.AbstractCookieBuilder<T extends Cookie.AbstractCookieBuilder<T>>	JAX-RS abstract Cookie builder class.
Cookie.Builder	JAX-RS Cookie builder class.
CookieParam	Binds the value of a HTTP cookie to a resource method parameter, resource class field, or resource class bean property.
CreateException	The CreateException exception must be included in the throws clauses of all create methods defined in an enterprise bean's home or local home interface.
CreationalContext<T>	Provides operations that are used by the Contextual implementation during instance creation and destruction.
CreationException	Indicates that a checked exception was thrown during creation of a bean.
Credential	Credential represents the credential the caller will use to authenticate.
CredentialValidationResult	CredentialValidationResult is the result from an attempt to validate an instance of Credential.
CredentialValidationResult.Status
CriteriaBuilder	Used to construct criteria queries, compound selections, expressions, predicates, orderings.
CriteriaBuilder.Case<R>	Interface used to build general case expressions.
CriteriaBuilder.Coalesce<T>	Interface used to build coalesce expressions.
CriteriaBuilder.In<T>	Interface used to build in predicates.
CriteriaBuilder.SimpleCase<C,R>	Interface used to build simple case expressions.
CriteriaBuilder.Trimspec	Used to specify how strings are trimmed.
CriteriaDelete<T>	The CriteriaDelete interface defines functionality for performing bulk delete operations using the Criteria API
CriteriaQuery<T>	The CriteriaQuery interface defines functionality that is specific to top-level queries.
CriteriaUpdate<T>	The CriteriaUpdate interface defines functionality for performing bulk update operations using the Criteria API.
CronTrigger	Cron-based Trigger implementation, which supports 5 or 6 fields delimited by a single space character, plus a ZoneId.
CrossParameterDescriptor	Describes an element holding cross-parameter constraints of a method or constructor
CustomFormAuthenticationMechanismDefinition	Annotation used to define a container authentication mechanism that implements authentication resembling Servlet FORM authentication (Servlet spec 13.6.3).
DatabaseIdentityStoreDefinition	Annotation used to define a container-provided IdentityStore that stores caller credentials and identity attributes in a relational database, and make that implementation available as an enabled CDI bean.
DataBindingException	Exception that represents a failure in a Jakarta XML Binding operation.
DataContentHandler	The DataContentHandler interface is implemented by objects that can be used to extend the capabilities of the DataHandler's implementation of the Transferable interface.
DataContentHandlerFactory	This interface defines a factory for DataContentHandlers.
DataHandler	The DataHandler class provides a consistent interface to data available in many different sources and formats.
DataModel<E>	DataModel is an abstraction around arbitrary data binding technologies that can be used to adapt a variety of data sources for use by Jakarta Faces components that support per-row processing for their child components (such as UIData.
DataModelEvent	DataModelEvent represents an event of interest to registered listeners that occurred on the specified DataModel.
DataModelListener	DataModelListener represents an event listener that wishes to be notified of DataModelEvents occurring on a particular DataModel instance.
DataSource	The DataSource interface provides Jakarta Activation with an abstraction of an arbitrary collection of data.
DataSourceDefinition	Annotation used to define a container DataSource to be registered with JNDI.
DataSourceDefinitions	Declares one or more DataSourceDefinition annotations.
DatatypeConverter	The javaType binding declaration can be used to customize the binding of an XML schema datatype to a Java datatype.
DatatypeConverterInterface	The DatatypeConverterInterface is for Jakarta XML Binding provider use only.
DateTerm	This class implements comparisons for Dates
DateTimeConverter	Converter implementation for java.util.Date values.
Decider	A Decider receives control as part of a decision element in a job.
DecimalMax	The annotated element must be a number whose value must be lower or equal to the specified maximum.
DecimalMax.List	Defines several DecimalMax annotations on the same element.
DecimalMin	The annotated element must be a number whose value must be higher or equal to the specified minimum.
DecimalMin.List	Defines several DecimalMin annotations on the same element.
DeclarationConfig	Allows adding annotations to and removing annotations from a declaration.
DeclarationInfo	A declaration is an element of a program source code.
DeclarationInfo.Kind
DeclareRoles	Used by application to declare security roles.
DecodeException	A general exception that occurs when trying to decode a custom object from a text or binary message.
Decoder	The Decoder interface holds member interfaces that define how a developer can provide the web socket container a way web socket messages into developer defined custom objects.
Decoder.Binary<T>	This interface defines how a custom object (of type T) is decoded from a web socket message in the form of a byte buffer.
Decoder.BinaryStream<T>	This interface defines how a custom object is decoded from a web socket message in the form of a binary stream.
Decoder.Text<T>	This interface defines how a custom object is decoded from a web socket message in the form of a string.
Decoder.TextStream<T>	This interface defines how a custom object of type T is decoded from a web socket message in the form of a character stream.
Decorated	A decorator may inject metadata about the bean it is decorating
Decorator	Specifies that a class is a decorator.
Decorator<T>	Represents an enabled decorator.
Default	The default qualifier type.
Default	Default Jakarta Bean Validation group.
Default.Literal	Supports inline instantiation of the Default qualifier.
DefaultValidationEventHandler	JAXB 1.0 only default validation event handler.
DefaultValue	Defines the default value of request meta-data that is bound using one of the following annotations: PathParam, QueryParam, MatrixParam, CookieParam, FormParam, or HeaderParam.
DefinitionException	Thrown when a definition error occurs.
Delegate	Identifies the delegate injection point of a decorator.
DelegatingMetaTagHandler	Enable the Jakarta Faces implementation to provide the appropriate behavior for the kind of MetaTagHandler subclass for each kind of element in the view, while providing a base-class from which those wanting to make a Java language custom tag handler can inherit.
DELETE	Indicates that the annotated method responds to HTTP DELETE requests.
DeliveryMode	The delivery modes supported by the Jakarta Messaging API are PERSISTENT and NON_PERSISTENT.
DenyAll	Specifies that no security roles are allowed to invoke the specified method(s).
Dependent	Specifies that a bean belongs to the dependent pseudo-scope.
Dependent.Literal	Supports inline instantiation of the Dependent annotation.
DependsOn	Used to express an initialization dependency between singleton components.
DeploymentException	Thrown when a deployment problem occurs.
DeploymentException	Checked exception indicating some kind of failure either to publish an endpoint on its server, or a failure to connect a client to its server.
DeserializationContext	Provides JSONB Mapper functionality on top of JSONP parser.
Destination	A Destination object encapsulates a provider-specific address.
Destroyed	An event with this qualifier is fired when a context is destroyed, i.e.
Destroyed.Literal	Supports inline instantiation of the Destroyed qualifier.
Detail	A container for DetailEntry objects.
DetailEntry	The content for a Detail object, giving details for a SOAPFault object.
Digits	The annotated element must be a number within accepted range.
Digits.List	Defines several Digits annotations on the same element.
Discovery	1st phase of build compatible extension execution.
DiscriminatorColumn	Specifies the discriminator column for the SINGLE_TABLE and JOINED Inheritance mapping strategies.
DiscriminatorType	Defines supported types of the discriminator column.
DiscriminatorValue	Specifies the value of the discriminator column for entities of the given type.
Dispatch<T>	The Dispatch interface provides support for the dynamic invocation of a service endpoint operations.
DispatcherType	Enumeration of filter dispatcher types.
DisplayType	Display specifies how the Authorization Server displays the authentication and consent user interface pages to the End-User.
DisposerInfo	Disposer methods may exist for producer-based beans.
Disposes	Identifies the disposed parameter of a disposer method.
DissociatableManagedConnection	This is a mix-in interface that may be optionally implemented by a ManagedConnection implementation.
DistributableWork	This models a Work instance that would be distributed by a DistributableWorkManager for execution in a remote DistributableWorkManager
DistributableWorkManager	This interface models a WorkManager that supports distributed execution of Work instances.
Doctype	Doctype is an interface that must be implemented by any UIComponent that represents a document type declaration.
DomHandler<ElementT,ResultT extends Result>	Converts an element (and its descendants) from/to DOM (or similar) representation.
DoubleConverter	Converter implementation for java.lang.Double (and double primitive) values.
DoubleRangeValidator	DoubleRangeValidator is a Validator that checks the value of the corresponding component against specified minimum and maximum values.
DuplicateKeyException	The DuplicateKeyException exception is thrown if an entity EJB object or enterprise bean local object cannot be created because an object with the same key already exists.
DynamicAttributes	For a tag to declare that it accepts dynamic attributes, it must implement this interface.
DynamicFeature	A JAX-RS meta-provider for dynamic registration of post-matching providers during a JAX-RS application setup at deployment time.
EditableValueHolder	EditableValueHolder is an extension of ValueHolder that describes additional features supported by editable components, including ValueChangeEvents and Validators.
EditableValueHolderAttachedObjectHandler	A VDL handler that exposes Validator or ValueChangeListener to a page author.
EditableValueHolderAttachedObjectTarget	A marker interface for VDL tags that represent <composite:editableValueHolder/> for use by the composite component page author.
EISSystemException	An EISSystemException is used to indicate any EIS specific system-level error conditions.
EJB	Indicates a dependency on the local, no-interface, or remote view of an Enterprise Bean.
EJBAccessException	This exception indicates that client access to a business method was denied.
EJBContainer	Used to execute an enterprise bean application in an embeddable container.
EJBContainerProvider	The EJBContainerProvider SPI is used by the embeddable container bootstrap class to initialize a suitable embeddable container.
EJBContext	The EJBContext interface provides an instance with access to the container-provided runtime context of an enterprise bean instance.
EJBException	The EJBException is thrown to report that the invoked business method or callback method could not be completed because of an unexpected error (e.g.
EJBHome	The EJBHome interface must be extended by all enterprise beans' remote home interfaces.
EJBLocalHome	The EJBLocalHome interface must be extended by all enterprise beans' local home interfaces.
EJBLocalObject	The EJBLocalObject interface must be extended by all enterprise beans' local interfaces.
EJBMetaData	The EJBMetaData interface allows a client to obtain the enterprise bean's meta-data information.
EJBMethodPermission	Class for Jakarta Enterprise Beans method permissions.
EJBObject	The EJBObject interface is extended by all enterprise beans' remote interfaces.
EJBRoleRefPermission	Class for Jakarta Enterprise Beans isCallerInRole (String reference) permissions.
EJBs	Declares multiple EJB annotations.
EJBTransactionRequiredException	This exception indicates that a request carried a null transaction context, but the target object requires an active transaction.
EJBTransactionRolledbackException	This exception is thrown to a caller of bean business method to indicate that the transaction associated with processing of the request has been rolled back, or marked to roll back.
ELClass	A runtime representation of a Class in the Jakarta Expression Language expressions.
ELContext	Context information for expression parsing and evaluation.
ELContextEvent	An event which indicates that an ELContext has been created.
ELContextListener	The listener interface for receiving notification when an ELContext is created.
Element	This is an element marker interface.
ElementCollection	Specifies a collection of instances of a basic type or embeddable class.
ElementDescriptor	Describes a validated element (class, property, method etc.).
ElementDescriptor.ConstraintFinder	Declares restrictions on retrieved constraints.
ElementKind	Enum of possible kinds of elements encountered in Jakarta Bean Validation.
ELException	Represents any of the exception conditions that can arise during expression evaluation.
ELException	Deprecated. As of JSP 2.1, replaced by ELException
ELManager	Manages Jakarta Expression Language parsing and evaluation environment.
ELParseException	Deprecated. As of JSP 2.1, replaced by ELException
ELProcessor	Provides an API for using Jakarta Expression Language in a stand-alone environment.
ELResolver	Enables customization of variable, property, method call, and type conversion resolution behavior for Jakarta Expression Language expression evaluation.
Email	The string has to be a well-formed email address.
Email.List	Defines several @Email constraints on the same element.
Embeddable	Specifies a class whose instances are stored as an intrinsic part of an owning entity and share the identity of the entity.
EmbeddableType<X>	Instances of the type EmbeddableType represent embeddable types.
Embedded	Specifies a persistent field or property of an entity whose value is an instance of an embeddable class.
EmbeddedId	Applied to a persistent field or property of an entity class or mapped superclass to denote a composite primary key that is an embeddable class.
Encoded	Disables automatic decoding of parameter values bound using QueryParam, PathParam, FormParam or MatrixParam.
EncodeException	A general exception that occurs when trying to encode a custom object to a string or binary message.
Encoder	The Encoder interface defines how developers can provide a way to convert their custom objects into web socket messages.
Encoder.Binary<T>	This interface defines how to provide a way to convert a custom object into a binary message.
Encoder.BinaryStream<T>	This interface may be implemented by encoding algorithms that want to write the encoded object to a binary stream.
Encoder.Text<T>	This interface defines how to provide a way to convert a custom object into a text message.
Encoder.TextStream<T>	This interface may be implemented by encoding algorithms that want to write the encoded object to a character stream.
EncodingAware	A DataSource that also implements EncodingAware may specify the Content-Transfer-Encoding to use for its data.
Endpoint	The Web Socket Endpoint represents an object that can handle websocket conversations.
Endpoint	A Web service endpoint.
EndpointConfig	The endpoint configuration contains all the information needed during the handshake process for this end point.
EndpointContext	EndpointContext allows multiple endpoints in an application to share any information.
EndpointReference	This class represents an WS-Addressing EndpointReference which is a remote reference to a web service endpoint.
Enhancement	2nd phase of build compatible extension execution.
EnterpriseBean	The EnterpriseBean interface is a common superinterface for the SessionBean, EntityBean and MessageDrivenBean interfaces.
Entity	Specifies that the class is an entity.
Entity<T>	Encapsulates message entity including the associated variant information.
EntityBean	The EntityBean interface is implemented by every entity bean class.
EntityContext	The EntityContext interface provides an instance with access to the container-provided runtime context of an entity bean instance.
EntityExistsException	Thrown by the persistence provider when EntityManager.persist(Object) is called and the entity already exists.
EntityGraph<T>	This type represents the root of an entity graph that will be used as a template to define the attribute nodes and boundaries of a graph of entities and entity relationships.
EntityListeners	Specifies the callback listener classes to be used for an entity or mapped superclass.
EntityManager	Interface used to interact with the persistence context.
EntityManagerFactory	Interface used to interact with the entity manager factory for the persistence unit.
EntityNotFoundException	Thrown by the persistence provider when an entity reference obtained by EntityManager.getReference is accessed but the entity does not exist.
EntityPart	A EntityPart is one part of a multipart entity.
EntityPart.Builder	Builder for EntityPart instances.
EntityResult	Used in conjunction with the SqlResultSetMapping annotation to map the SELECT clause of a SQL query to an entity result.
EntityTag	An abstraction for the value of a HTTP Entity Tag, used as the value of an ETag response header.
EntityTransaction	Interface used to control transactions on resource-local entity managers.
EntityType<X>	Instances of the type EntityType represent entity types.
EnumConverter	Converter implementation for java.lang.Enum (and enum primitive) values.
Enumerated	Specifies that a persistent property or field should be persisted as a enumerated type.
EnumType	Defines mapping for enumerated types.
ErrorData	Contains information about an error, for error pages.
EvaluationListener	The listener interface for receiving notification when a Jakarta Expression Language expression is evaluated.
Event<T>	Allows the application to fire events of a particular type.
EventContext<T>	Represents a context of a fired event.
EventMetadata	Provides access to metadata about an observed event payload.
ExceptionHandler	ExceptionHandler is the central point for handling unexpected Exceptions that are thrown during the Faces lifecycle.
ExceptionHandlerFactory	ExceptionHandlerFactory is a factory object that creates (if needed) and returns a new ExceptionHandler instance.
ExceptionHandlerWrapper	Provides a simple implementation of ExceptionHandler that can be subclassed by developers wishing to provide specialized behavior to an existing ExceptionHandler instance.
ExceptionListener	If a Jakarta Messaging provider detects a serious problem with a Connection object, it informs the Connection object's ExceptionListener, if one has been registered.
ExceptionMapper<E extends Throwable>	Contract for a provider that maps Java exceptions to Response.
ExceptionQueuedEvent	The system event facility will create an instance of this class whenever Application.publishEvent(jakarta.faces.context.FacesContext, java.lang.Class<? extends jakarta.faces.event.SystemEvent>, java.lang.Object) is called with ExceptionQueuedEvent.class as systemEventClass argument.
ExceptionQueuedEventContext	This helper class provides context to the ExceptionQueuedEvent regarding the state of the system at the point in time when the ExceptionQueuedEvent occurs and links the ExceptionQueuedEvent to the ExceptionHandler by virtue of implementing SystemEventListener.
ExcludeClassInterceptors	Used to exclude class-level interceptors for the lifecycle callback method, business method, timeout method, or constructor to which it is applied.
ExcludeDefaultInterceptors	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.
ExcludeDefaultListeners	Specifies that the invocation of default listeners is to be excluded for the entity class (or mapped superclass) and its subclasses.
ExcludeSuperclassListeners	Specifies that the invocation of superclass listeners is to be excluded for the entity class (or mapped superclass) and its subclasses.
ExecutableDescriptor	Provides the common functionality of MethodDescriptor and ConstructorDescriptor.
ExecutableType	Defines the types of executables targeted by an operation.
ExecutableValidator	Validates parameters and return values of methods and constructors.
ExecutionContext	This class models an execution context (transaction, security, etc) with which the Work instance must be executed.
Expression	Base class for the expression subclasses ValueExpression and MethodExpression, implementing characteristics common to both.
Expression<T>	Type for query expressions.
Expression	Deprecated. As of JSP 2.1, replaced by ValueExpression
ExpressionEvaluator	Deprecated. As of JSP 2.1, replaced by ExpressionFactory
ExpressionFactory	Provides an implementation for creating and evaluating Jakarta Expression Language expressions.
Extension	Service interface implemented by extensions.
Extension	A simple representation of a websocket extension as a name and map of extension parameters.
Extension.Parameter	This member interface defines a single websocket extension parameter.
ExternalContext	This class allows the Faces API to be unaware of the nature of its containing application environment.
ExternalContextFactory	ExternalContextFactory is a factory object that creates (if needed) and returns new ExternalContext instances, initialized for the processing of the specified request and response objects.
ExternalContextWrapper	Provides a simple implementation of ExternalContext that can be subclassed by developers wishing to provide specialized behavior to an existing ExternalContext instance.
ExtractedValue	Marks the type parameter of a generic container type to which a ValueExtractor is tied or specifies the type of the wrapped element(s) of non-generic container types.
Facelet	The parent or root object in a FaceletHandler composition.
FaceletCache<V>	This API defines the facility by which the Facelets ViewDeclarationLanguage creates and caches instances of Facelets.
FaceletCache.MemberFactory<V>	Factory interface for creating Facelet or View Metadata Facelet instances.
FaceletCacheFactory	Allows customization of the implementation of FaceletCache.
FaceletContext	Context representative of a single request from a Facelet.
FaceletException	An Exception from the Facelet implementation
FaceletHandler	This is the root class for markup elements in Facelets VDL.
FaceletsAttachedObjectHandler	Root class for all tag handlers that represent attached objetcts in a Facelets page.
FacesBehavior	The presence of this annotation on a class automatically registers the class with the runtime as a Behavior.
FacesBehavior.Literal	Supports inline instantiation of the FacesBehavior qualifier.
FacesBehaviorRenderer	The presence of this annotation on a class automatically registers the class with the runtime as a ClientBehaviorRenderer.
FacesComponent	The presence of this annotation on a class that extends UIComponent must cause the runtime to register this class as a component suitable for inclusion in a view.
FacesConfig	The presence of this annotation on a class deployed within an application guarantees activation of Jakarta Faces and its CDI specific features, even when /WEB-INF/faces-config.xml is absent and FacesServlet is not explicitly registered.
FacesConfig.Literal	Supports inline instantiation of the FacesConfig qualifier.
FacesConfig.Version	Deprecated, for removal: This API element is subject to removal in a future version. It has no effect anymore as per Jakarta Faces version 4.0; the actual impl version should be leading.
FacesContext	FacesContext contains all of the per-request state information related to the processing of a single Jakarta Faces request, and the rendering of the corresponding response.
FacesContextFactory	FacesContextFactory is a factory object that creates (if needed) and returns new FacesContext instances, initialized for the processing of the specified request and response objects.
FacesContextWrapper	Provides a simple implementation of FacesContext that can be subclassed by developers wishing to provide specialized behavior to an existing FacesContext instance.
FacesConverter	The presence of this annotation on a class automatically registers the class with the runtime as a Converter.
FacesConverter.Literal	Supports inline instantiation of the FacesConverter qualifier.
FacesDataModel
FacesDataModel.Literal	Supports inline instantiation of the FacesDataModel qualifier.
FacesEvent	FacesEvent is the base class for user interface and application events that can be fired by UIComponents.
FacesException	This class encapsulates general Jakarta Faces exceptions.
FacesListener	A generic base interface for event listeners for various types of FacesEvents.
FacesMessage	FacesMessage represents a single validation (or other) message, which is typically associated with a particular component in the view.
FacesMessage.Severity	Class used to represent message severity levels in a typesafe enumeration.
FacesRenderer	The presence of this annotation on a class automatically registers the class with the runtime as a Renderer.
FacesServlet	FacesServlet is a Jakarta Servlet servlet that manages the request processing lifecycle for web applications that are utilizing Jakarta Faces to construct the user interface.
FacesValidator	The presence of this annotation on a class automatically registers the class with the runtime as a Validator.
FacesValidator.Literal	Supports inline instantiation of the FacesValidator qualifier.
FacesWrapper<T>	Any wrapper class in Jakarta Faces that must provide access to the object it wraps must implement this interface.
FacetHandler	An interface that allows other code to identify FaceletHandlers that correspond to component facets.
FactoryFinder	FactoryFinder implements the standard discovery algorithm for all factory objects specified in the Jakarta Faces APIs.
FaultAction	The FaultAction annotation is used inside an Action annotation to allow an explicit association of a WS-Addressing Action message addressing property with the fault messages of the WSDL operation mapped from the exception class.
Feature	A feature extension contract.
FeatureContext	A configurable context passed to Feature and DynamicFeature instances by JAX-RS runtime during the phase of their configuration.
Fetch<Z,X>	Represents a join-fetched association or attribute.
FetchParent<Z,X>	Represents an element of the from clause which may function as the parent of Fetches.
FetchProfile	Clients use a FetchProfile to list the Message attributes that it wishes to prefetch from the server for a range of messages.
FetchProfile.Item	This inner class is the base class of all items that can be requested in a FetchProfile.
FetchType	Defines strategies for fetching data from the database.
FieldConfig	Allows adding annotations to and removing annotations from a field.
FieldInfo	A field, declared in some class.
FieldResult	Used in conjunction with the EntityResult annotation to map columns specified in the SELECT list of a SQL query to the properties or fields of an entity class.
FileDataSource	The FileDataSource class implements a simple DataSource object that encapsulates a file.
FileTypeMap	The FileTypeMap is an abstract class that provides a data typing interface for files.
Filter	A filter is an object that performs filtering tasks on either the request to a resource (a servlet or static content), or on the response from a resource, or both.
FilterChain	A FilterChain is an object provided by the servlet container to the developer giving a view into the invocation chain of a filtered request for a resource.
FilterConfig	A filter configuration object used by a servlet container to pass information to a filter during initialization.
FilterRegistration	Interface through which a Filter may be further configured.
FilterRegistration.Dynamic	Interface through which a Filter registered via one of the addFilter methods on ServletContext may be further configured.
FinderException	The FinderException exception must be included in the throws clause of every finder method of an entity bean's home or local home interface.
Flags	The Flags class represents the set of flags on a Message.
Flags.Flag	This inner class represents an individual system flag.
FlagTerm	This class implements comparisons for Message Flags.
Flash	The Flash concept is taken from Ruby on Rails and provides a way to pass temporary objects between the user views generated by the faces lifecycle.
FlashFactory	FlashFactory is a factory object that creates (if needed) and returns Flash instances.
FlashWrapper	Provides a simple implementation of Flash that can be subclassed by developers wishing to provide specialized behavior to an existing Flash instance.
FloatConverter	Converter implementation for java.lang.Float (and float primitive) values.
Flow	Flow is the runtime representation of a Faces Flow.
FlowBuilder	A Java language API for building Flows.
FlowBuilderParameter	The presence of this annotation on a CDI producer method for the FlowDefinition annotation causes the FlowBuilder to be passed to that method.
FlowBuilderParameter.Literal	Supports inline instantiation of the FlowBuilderParameter qualifier.
FlowCallBuilder	Create a flow call node in the current Flow.
FlowCallNode	A flow call node.
FlowDefinition	The presence of this annotation on a CDI producer method indicates that the method will produce a flow.
FlowDefinition.Literal	Supports inline instantiation of the FlowDefinition qualifier.
FlowHandler	FlowHandler is the main entry point that enables the runtime to interact with the faces flows feature.
FlowHandlerFactory	FlowHandlerFactory is used by the Application to create the singleton instance of FlowHandler.
FlowHandlerFactoryWrapper	FlowHandlerFactoryWrapper provides a simple implementation of FlowHandlerFactory that can be subclassed by developers wishing to provide specialized behavior to an existing FlowHandlerFactory instance.
FlowMap	The presence of this annotation (along with @Inject) on a field of type Map<Object, Object> causes the map returned from FlowHandler.getCurrentFlowScope() to be injected as the value of that field.
FlowMap.Literal	Supports inline instantiation of the ApplicationMap qualifier.
FlowNode	FlowNode is the base class for all nodes in a faces flow graph.
FlowScoped	FlowScoped is a CDI scope that causes the runtime to consider classes with this annotation to be in the scope of the specified Flow.
FlushModeType	Flush mode setting.
Folder	Folder is an abstract class that represents a folder for mail messages.
FolderAdapter	The adapter which receives Folder events.
FolderClosedException	This exception is thrown when a method is invoked on a Messaging object and the Folder that owns that object has died due to some reason.
FolderEvent	This class models Folder existence events.
FolderListener	This is the Listener interface for Folder events.
FolderNotFoundException	This exception is thrown by Folder methods, when those methods are invoked on a non existent folder.
ForbiddenException	A runtime exception indicating that an access to a resource requested by a client has been forbidden by the server.
ForeignKey	Used to specify the handling of foreign key constraints when schema generation is in effect.
Form	Represents the the HTML form data request entity encoded using the "application/x-www-form-urlencoded" content type.
FormAuthenticationMechanismDefinition	Annotation used to define a container authentication mechanism that implements FORM authentication as defined by the Servlet spec (13.6.3) and make that implementation available as an enabled CDI bean.
FormParam	Binds the value(s) of a form parameter contained within a request entity body to a resource method parameter.
From<Z,X>	Represents a bound type, usually an entity that appears in the from clause, but may also be an embeddable belonging to an entity in the from clause.
FromStringTerm	This class implements string comparisons for the From Address header.
FromTerm	This class implements comparisons for the From Address header.
FunctionInfo	Information for a function in a Tag Library.
FunctionMapper	The interface to a map between Jakarta Expression Language function names and methods.
FunctionMapper	Deprecated. As of JSP 2.1, replaced by FunctionMapper
Future	The annotated element must be an instant, date or time in the future.
Future.List	Defines several Future annotations on the same element.
FutureOrPresent	The annotated element must be an instant, date or time in the present or in the future.
FutureOrPresent.List	Defines several FutureOrPresent annotations on the same element.
Generated	The Generated annotation is used to mark source code that has been generated.
GeneratedValue	Provides for the specification of generation strategies for the values of primary keys.
GenerationType	Defines the types of primary key generation strategies.
GenericBootstrap	Defines the state used to bootstrap Jakarta Bean Validation and creates a provider agnostic Configuration.
GenericCredential	Deprecated. The preferred way to represent generic credential information is via the org.ietf.jgss.GSSCredential interface in J2SE Version 1.4, which provides similar functionality.
GenericEntity<T>	Represents a message entity of a generic type T.
GenericFilter	Defines a generic, protocol-independent filter.
GenericServlet	Defines a generic, protocol-independent servlet.
GenericType<T>	Represents a generic message entity type T.
GET	Indicates that the annotated method responds to HTTP GET requests.
GroupConversionDescriptor	A group conversion rule to be applied during cascaded validation.
GroupDefinitionException	Exception raised if a group definition is not legal.
GroupPrincipalCallback	Callback establishing group principals within the argument subject.
GroupSequence	Defines group sequence.
Handle	The Handle interface is implemented by all enterprise bean object handles.
HandleDelegate	The HandleDelegate interface is implemented by the enterprise bean container.
Handler<C extends MessageContext>	The Handler interface is the base interface for Jakarta XML Web Services handlers.
HandlerChain	Associates the Web Service with an externally defined handler chain.
HandlerResolver	HandlerResolver is an interface implemented by an application to get control over the handler chain set on proxy/dispatch objects at the time of their creation.
HandlesTypes	This annotation is used to declare the class types that a ServletContainerInitializer can handle.
HandshakeRequest	The handshake request represents the WebSocket defined HTTP GET request for the opening handshake of a WebSocket session.
HandshakeResponse	The handshake response represents the WebSocket-defined HTTP response that is the response to the opening handshake request.
HEAD	Indicates that the annotated method responds to HTTP HEAD requests.
Header	The Header class stores a name/value pair to represent headers.
HeaderMap	The presence of this annotation (along with @Inject) on a field of type Map<String, String> causes the map returned from ExternalContext.getRequestHeaderMap() to be injected as the value of that field.
HeaderMap.Literal	Supports inline instantiation of the HeaderMap qualifier.
HeaderParam	Binds the value(s) of a HTTP header to a resource method parameter, resource class field, or resource class bean property.
HeaderTerm	This class implements comparisons for Message headers.
HeaderTokenizer	This class tokenizes RFC822 and MIME headers into the basic symbols specified by RFC822 and MIME.
HeaderTokenizer.Token	The Token class represents tokens returned by the HeaderTokenizer.
HeaderValuesMap	The presence of this annotation (along with @Inject) on a field of type Map<String, String[]> causes the map returned from ExternalContext.getRequestHeaderValuesMap() to be injected as the value of that field.
HeaderValuesMap.Literal	Supports inline instantiation of the HeaderValuesMap qualifier.
HeuristicCommitException	This exception is thrown by the rollback operation on a resource to report that a heuristic decision was made and that all relevant updates have been committed.
HeuristicMixedException	This exception is thrown to report that a heuristic decision was made and that some relevant updates have been committed and others have been rolled back.
HeuristicRollbackException	This exception is thrown by the commit operation to report that a heuristic decision was made and that all relevant updates have been rolled back.
HexBinaryAdapter	XmlAdapter for xs:hexBinary.
HintsContext	A standard WorkContext that allows a Work instance to propagate quality-of-service (QoS) hints about the Work to the WorkManager.
Holder<T>	Holds a value of type T.
HomeHandle	The HomeHandle interface is implemented by all home object handles.
HtmlBody	NONE
HtmlBody.PropertyKeys	The property keys.
HtmlColumn	Represents a column that will be rendered in an HTML table element.
HtmlColumn.PropertyKeys	The property keys.
HtmlCommandButton	Represents an HTML input element for a button of type submit or reset.
HtmlCommandButton.PropertyKeys	Properties used by this component
HtmlCommandLink	Represents an HTML a element for a hyperlink that acts like a submit button.
HtmlCommandLink.PropertyKeys	Properties used by this component
HtmlCommandScript	Represents an HTML script element for a function that acts like an ajax form submit.
HtmlCommandScript.PropertyKeys	The property keys.
HtmlDataTable	Represents a set of repeating data (segregated into columns by child UIColumn components) that will be rendered in an HTML table element.
HtmlDataTable.PropertyKeys	The property keys.
HtmlDoctype	NONE
HtmlDoctype.PropertyKeys	The property keys.
HtmlForm	Represents an HTML form element.
HtmlForm.PropertyKeys	Properties used by this component
HtmlGraphicImage	Represents an HTML img element, used to retrieve and render a graphical image.
HtmlGraphicImage.PropertyKeys	Properties used by this component
HtmlHead	NONE
HtmlHead.PropertyKeys	The property keys.
HtmlInputFile	Represents an HTML input element of type file.
HtmlInputFile.PropertyKeys	Properties used by this component
HtmlInputHidden	Represents an HTML input element of type hidden.
HtmlInputHidden.PropertyKeys	Properties used by this component
HtmlInputSecret	Represents an HTML input element of type password.
HtmlInputSecret.PropertyKeys	Properties used by this component
HtmlInputText	Represents an HTML input element of type text.
HtmlInputText.PropertyKeys	The property keys.
HtmlInputTextarea	Represents an HTML textarea element.
HtmlInputTextarea.PropertyKeys	Properties used by this component
HtmlMessage	By default, the rendererType property must be set to "jakarta.faces.Message".
HtmlMessage.PropertyKeys	Properties used by this component
HtmlMessages	By default, the rendererType property must be set to "jakarta.faces.Messages".
HtmlMessages.PropertyKeys	The property keys.
HtmlOutcomeTargetButton	Represents an HTML input element of type "button" or image that may be used to link to a URL handled by the Faces Servlet resolved preemptively using the logical outcome defined by the outcome property.
HtmlOutcomeTargetButton.PropertyKeys	The property keys.
HtmlOutcomeTargetLink	Represents an HTML a (hyperlink) element that may be used to link to a URL handled by the Faces Servlet resolved preemptively using the logical outcome defined by the outcome property.
HtmlOutcomeTargetLink.PropertyKeys	The property keys.
HtmlOutputFormat	Represents a component that looks up a localized message in a resource bundle, optionally uses it as a MessageFormat pattern string and substitutes in parameter values from nested UIParameter components, and renders the result.
HtmlOutputFormat.PropertyKeys	The property keys.
HtmlOutputLabel	Represents an HTML label element, used to define an accessible label for a corresponding input element.
HtmlOutputLabel.PropertyKeys	The property keys.
HtmlOutputLink	Represents an HTML a (hyperlink) element that may be used to link to an arbitrary URL defined by the value property.
HtmlOutputLink.PropertyKeys	The property keys.
HtmlOutputText	Renders the component value as text, optionally wrapping in a span element if I18N attributes, CSS styles or style classes are specified.
HtmlOutputText.PropertyKeys	The property keys.
HtmlPanelGrid	Renders child components in a table, starting a new row after the specified number of columns.
HtmlPanelGrid.PropertyKeys	Properties used by this component
HtmlPanelGroup	Causes all child components of this component to be rendered.
HtmlPanelGroup.PropertyKeys	Properties used by this component
HtmlSelectBooleanCheckbox	Represents an HTML input element of type checkbox.
HtmlSelectBooleanCheckbox.PropertyKeys	The property keys.
HtmlSelectManyCheckbox	Represents a multiple-selection component that is rendered as a set of HTML input elements of type checkbox.
HtmlSelectManyCheckbox.PropertyKeys	Properties used by this component
HtmlSelectManyListbox	Represents a multiple-selection component that is rendered as an HTML select element, showing either all available options or the specified number of options.
HtmlSelectManyListbox.PropertyKeys	Properties used by this component
HtmlSelectManyMenu	Represents a multiple-selection component that is rendered as an HTML select element, showing a single available option at a time.
HtmlSelectManyMenu.PropertyKeys	The property keys.
HtmlSelectOneListbox	Represents a single-selection component that is rendered as an HTML select element, showing either all available options or the specified number of options.
HtmlSelectOneListbox.PropertyKeys	Properties used by this component
HtmlSelectOneMenu	Represents a single-selection component that is rendered as an HTML select element, showing a single available option at a time.
HtmlSelectOneMenu.PropertyKeys	Properties used by this component
HtmlSelectOneRadio	Represents a single-selection component that is rendered as a set of HTML input elements of type radio.
HtmlSelectOneRadio.PropertyKeys	The property keys.
HttpAuthenticationMechanism	HttpAuthenticationMechanism is a mechanism for obtaining a caller's credentials in some way, using the HTTP protocol where necessary.
HttpAuthenticationMechanismWrapper	This class is an implementation of the HttpAuthenticationMechanism interface that can be subclassed by developers wishing to provide extra or different functionality.
HTTPBinding	The HTTPBinding interface is an abstraction for the XML/HTTP binding.
HttpConstraint	This annotation is used within the ServletSecurity annotation to represent the security constraints to be applied to all HTTP protocol methods for which a corresponding HttpMethodConstraint element does NOT occur within the ServletSecurity annotation.
HttpConstraintElement	Java Class representation of an HttpConstraint annotation value.
HttpContext	HttpContext represents a mapping between the root URI path of a web service to a HttpHandler which is invoked to handle requests destined for that path on the associated container.
HTTPException	The HTTPException exception represents a XML/HTTP fault.
HttpExchange	This class encapsulates a HTTP request received and a response to be generated in one exchange.
HttpFilter	Provides an abstract class to be subclassed to create an HTTP filter suitable for a Web site.
HttpHandler	A handler which is invoked to process HTTP requests.
HttpHeaders	An injectable interface that provides access to HTTP header information.
HttpJspPage	The HttpJspPage interface describes the interaction that a JSP Page Implementation Class must satisfy when using the HTTP protocol.
HttpMessageContext	HttpMessageContext contains all of the per-request state information and encapsulates the client request, server response, container handler for authentication callbacks, and the subject representing the caller.
HttpMessageContextWrapper	This class is an implementation of the HttpMessageContext interface that can be subclassed by developers wishing to provide extra or different functionality.
HttpMethod	Associates the name of a HTTP method with an annotation.
HttpMethodConstraint	This annotation is used within the ServletSecurity annotation to represent security constraints on specific HTTP protocol messages.
HttpMethodConstraintElement	Java Class representation of an HttpMethodConstraint annotation value.
HttpServlet	Provides an abstract class to be subclassed to create an HTTP servlet suitable for a Web site.
HttpServletMapping	Allows runtime discovery of the manner in which the HttpServlet for the current HttpServletRequest was invoked.
HttpServletRequest	Extends the ServletRequest interface to provide request information for HTTP servlets.
HttpServletRequestWrapper	Provides a convenient implementation of the HttpServletRequest interface that can be subclassed by developers wishing to adapt the request to a Servlet.
HttpServletResponse	Extends the ServletResponse interface to provide HTTP-specific functionality in sending a response.
HttpServletResponseWrapper	Provides a convenient implementation of the HttpServletResponse interface that can be subclassed by developers wishing to adapt the response from a Servlet.
HttpSession	Provides a way to identify a user across more than one page request or visit to a Web site and to store information about that user.
HttpSessionActivationListener	Objects that are bound to a session may listen to container events notifying them that sessions will be passivated and that session will be activated.
HttpSessionAttributeListener	Interface for receiving notification events about HttpSession attribute changes.
HttpSessionBindingEvent	Events of this type are either sent to an object that implements HttpSessionBindingListener when it is bound or unbound from a session, or to an HttpSessionAttributeListener that has been configured in the deployment descriptor when any attribute is bound, unbound or replaced in a session.
HttpSessionBindingListener	Causes an object to be notified when it is bound to or unbound from a session.
HttpSessionEvent	This is the class representing event notifications for changes to sessions within a web application.
HttpSessionIdListener	Interface for receiving notification events about HttpSession id changes.
HttpSessionListener	Interface for receiving notification events about HttpSession lifecycle changes.
HttpUpgradeHandler	This interface encapsulates the upgrade protocol processing.
Id	Specifies the primary key of an entity.
IdClass	Specifies a composite primary key class that is mapped to multiple fields or properties of the entity.
IdentifiableType<X>	Instances of the type IdentifiableType represent entity or mapped superclass types.
IdentityStore	IdentityStore is a mechanism for validating a caller's credentials and accessing a caller's identity attributes.
IdentityStore.ValidationType	Determines the type of validation (operations) that should be done by this store.
IdentityStoreHandler	IdentityStoreHandler is a mechanism for validating a caller's credentials, and accessing a caller's identity attributes, by consulting a set of one or more IdentityStores.
IdentityStorePermission	Class for IdentityStore permissions.
IdentityToken	An Identity token is a security token that is issued in an authentication flow process.
IllegalLoopbackException	This exception indicates that an attempt was made to perform an illegal loopback invocation.
IllegalProductException	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.
IllegalStateException	This exception is thrown when a method is invoked at an illegal or inappropriate time or if the provider is not in an appropriate state for the requested operation.
IllegalStateException	An IllegalStateException is thrown from a method if the callee (resource adapter or application server for system contracts) is in an illegal or inappropriate state for the method invocation.
IllegalStateRuntimeException	This unchecked exception is thrown when a method is invoked at an illegal or inappropriate time or if the provider is not in an appropriate state for the requested operation, and the method signature does not permit a IllegalStateRuntimeException to be thrown.
IllegalWriteException	The exception thrown when a write is attempted on a read-only attribute of any Messaging object.
ImplicitObjectELResolver	Defines variable resolution behavior for the EL implicit objects defined in the JSP specification.
ImportELResolver	Defines variable resolution behavior for Class imports and static imports.
ImportHandler	Handles imports of class names and package names.
InboundSseEvent	Inbound Server-sent event.
Index	Used in schema generation to specify creation of an index.
IndexedRecord<E>	IndexedRecord represents an ordered collection of record elements based on the java.util.List interface.
IndexedValueExpression
Inheritance	Specifies the inheritance strategy to be used for an entity class hierarchy.
InheritanceType	Defines inheritance strategy options.
Init	Designates a method of a session bean that corresponds to a create<METHOD> method of an adapted home or local home interface (an interface that adapts an enterprise bean 2.1 or earlier EJBHome or EJBLocalHome client view respectively).
Initialized	An event with this qualifier is fired when a context is initialized, i.e.
Initialized.Literal	Supports inline instantiation of the Initialized qualifier.
InitParam	Deprecated.
InitParameterMap	The presence of this annotation (along with @Inject) on a field of type Map<String, String> causes the map returned from ExternalContext.getInitParameterMap() to be injected as the value of that field.
InitParameterMap.Literal	Supports inline instantiation of the InitParameterMap qualifier.
Inject	Identifies injectable constructors, methods, and fields.
InjectionException	Indicates a problem relating to dependency injection.
InjectionPoint	Provides access to metadata about an injection point.
InjectionPointConfigurator	This API is an helper to configure an existing InjectionPoint instance.
InjectionPointInfo	An injection point defined on some bean.
InjectionTarget<T>	Provides operations for performing dependency injection and lifecycle callbacks on an instance of a type.
InjectionTargetFactory<T>	An InjectionTargetFactory can create an InjectionTarget for a given bean.
InjectLiteral	Supports inline instantiation of the Inject annotation.
Instance<T>	Allows the application to dynamically obtain instances of beans with a specified combination of required type and qualifiers.
Instance.Handle<T>	This interface represents a contextual reference handle.
IntegerComparisonTerm	This class implements comparisons for integers.
IntegerConverter	Converter implementation for java.lang.Integer (and int primitive) values.
Interaction	The jakarta.resource.cci.Interaction enables a component to execute EIS functions.
InteractionSpec	An InteractionSpec holds properties for driving an Interaction with an EIS instance.
Intercepted	An interceptor may inject metadata about the bean it is intercepting.
InterceptionFactory<T>	InterceptionFactory allows to create a wrapper instance whose method invocations are intercepted by method interceptors and forwarded to a provided instance.
InterceptionType	Identifies the kind of lifecycle callback, EJB timeout method or business method interception.
Interceptor<T>	Represents an enabled interceptor.
Interceptor	Specifies that a class is an interceptor.
Interceptor.Priority	Priorities that define the order in which interceptors are invoked.
InterceptorBinding	Specifies that an annotation type is an interceptor binding type.
InterceptorContext	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).
InterceptorInfo	Interceptors are managed beans annotated @Interceptor.
Interceptors	Declares an ordered list of interceptors for a target class, or for a method or a constructor of a target class.
InternalServerErrorException	A runtime exception indicating an internal server error.
InternetAddress	This class represents an Internet email address using the syntax of RFC822.
InternetHeaders	InternetHeaders is a utility class that manages RFC822 style headers.
InternetHeaders.InternetHeader	An individual internet header.
InvalidClientIDException	This exception must be thrown when a client attempts to set a connection's client ID to a value that is rejected by a provider.
InvalidClientIDRuntimeException	This unchecked exception must be thrown when a client attempts to set a connection's client ID to a value that is rejected by a provider, and the method signature does not permit a InvalidClientIDException to be thrown.
InvalidDestinationException	This exception must be thrown when a destination either is not understood by a provider or is no longer valid.
InvalidDestinationRuntimeException	This unchecked exception must be thrown when a destination either is not understood by a provider or is no longer valid, and the method signature does not permit a InvalidDestinationException to be thrown.
InvalidPropertyException	This exception is thrown to indicate invalid configuration property settings.
InvalidSelectorException	This exception must be thrown when a Jakarta Messaging client attempts to give a provider a message selector with invalid syntax.
InvalidSelectorRuntimeException	This unchecked exception must be thrown when a Jakarta Messaging client attempts to give a provider a message selector with invalid syntax, and the method signature does not permit a InvalidSelectorException to be thrown.
InvalidTransactionException	This exception indicates that the request carried an invalid transaction context.
Invocation	A client request invocation.
Invocation.Builder	A client request invocation builder.
InvocationCallback<RESPONSE>	Callback that can be implemented to receive the asynchronous processing events from the invocation processing.
InvocationContext	Exposes contextual information about the intercepted invocation and operations that enable interceptor methods to control the behavior of the invocation chain.
Invoker	Invoker hides the detail of calling into application endpoint implementation.
ItemProcessListener	ItemProcessListener intercepts item processing.
ItemProcessor	ItemProcessor is used in chunk processing to operate on an input item and produce an output item.
ItemReader	ItemReader defines the batch artifact that reads items for chunk processing.
ItemReadListener	ItemReadListener intercepts item reader processing.
ItemWriteListener	ItemWriteListener intercepts item writer processing.
ItemWriter	ItemWriter defines the batch artifact that writes to a list of items for chunk processing.
IterableDataModel<E>	IterableDataModel is an implementation of DataModel that wraps an Iterable.
IteratedExpression
IteratedValueExpression
IterationTag	The IterationTag interface extends Tag by defining one additional method that controls the reevaluation of its body.
JAXB	Class that defines convenience methods for common, simple use of Jakarta XML Binding.
JAXBContext	The JAXBContext class provides the client's entry point to the Jakarta XML Binding API.
JAXBContextFactory	Factory that creates new JAXBContext instances.
JAXBElement<T>	Jakarta XML Binding representation of an Xml Element.
JAXBElement.GlobalScope	Designates global scope for an xml element.
JAXBException	This is the root exception class for all Jakarta XML Binding exceptions.
JAXBIntrospector	Provide access to Jakarta XML Binding xml binding data for a Jakarta XML Binding object.
JAXBPermission	This class is for Jakarta XML Binding permissions.
JAXBResult	JAXP Result implementation that unmarshals a Jakarta XML Binding object.
JAXBSource	JAXP Source implementation that marshals a Jakarta XML Binding-generated object.
JMSConnectionFactory	This annotation may be used on a field to specify the JNDI lookup name of a jakarta.jms.ConnectionFactory to be used when injecting a jakarta.jms.JMSContext object.
JMSConnectionFactoryDefinition	An application may use this annotation to specify a Jakarta Messaging ConnectionFactory resource that it requires in its operational environment.
JMSConnectionFactoryDefinitions	Specifies one or more JMSConnectionFactoryDefinition annotations.
JMSConsumer	A client using the simplified Jakarta Messaging API introduced for Jakarta Messaging 2.0 uses a JMSConsumer object to receive messages from a queue or topic.
JMSContext	A JMSContext is the main interface in the simplified Jakarta Messaging API introduced for Jakarta Messaging 2.0.
JMSDestinationDefinition	An application may use this annotation to specify a Jakarta Messaging Destination resource that it requires in its operational environment.
JMSDestinationDefinitions	Specifies one or more JMSDestinationDefinition annotations.
JMSException	This is the root class of all checked exceptions in the Jakarta Messaging API.
JMSPasswordCredential	This annotation may be used to specify the userName and password to be used when injecting a jakarta.jms.JMSContext object.
JMSProducer	A JMSProducer is a simple object used to send messages on behalf of a JMSContext.
JMSRuntimeException	This is the root class of all unchecked exceptions in the Jakarta Messaging API.
JMSSecurityException	This exception must be thrown when a provider rejects a user name/password submitted by a client.
JMSSecurityRuntimeException	This unchecked exception must be thrown when a provider rejects a user name/password submitted by a client, or for any case where a security restriction prevents a method from completing, and the method signature does not permit a JMSSecurityException to be thrown.
JMSSessionMode	This annotation may be used to specify the session mode to be used when injecting a jakarta.jms.JMSContext object.
JobContext	A JobContext provides information about the current job execution.
JobExecution	Provides a view of a job execution to the JobOperator.
JobExecutionAlreadyCompleteException	JobExecutionAlreadyCompleteException is thrown when restart is called for an already-completed job instance.
JobExecutionIsRunningException	JobExecutionIsRunningException is thrown when JobOperator.abandon(long) is called on a job execution which is currently running (i.e.
JobExecutionNotMostRecentException	JobExecutionNotMostRecentException is thrown when JobOperator.restart(long, java.util.Properties) is called on a job instance which has already completed (i.e.
JobExecutionNotRunningException	JobExecutionNotRunningException is thrown when JobOperator.stop(long) is called on a job instance which is not currently running.
JobInstance	Provides a view of a job instance to the JobOperator.
JobListener	JobListener intercepts job execution.
JobOperator	JobOperator provide the interface for operating on batch jobs.
JobRestartException	JobRestartException is thrown when an error occurs during the JobOperator restart operation.
JobSecurityException	SecurityException is thrown when an user is not authorized to run a JobOperator method, such as restart, stop, abandon, any getters, etc.
JobStartException	JobStartException is thrown when an error occurs during the JobOperator start operation.
Join<Z,X>	A join to an entity, embeddable, or basic type.
JoinColumn	Specifies a column for joining an entity association or element collection.
JoinColumns	Specifies the mapping for composite foreign keys.
JoinTable	Specifies the mapping of associations.
JoinType	Defines the three types of joins.
Json	Factory class for creating JSON processing objects.
JsonArray	JsonArray represents an immutable JSON array (an ordered sequence of zero or more values).
JsonArrayBuilder	A builder for creating JsonArray models from scratch, and for modifying a existing JsonArray.
Jsonb	Jsonb provides an abstraction over the JSON Binding framework operations:
JsonbAdapter<Original,Adapted>	Allows to define custom mapping for given java type.
JsonbAnnotation	Marks any relevant JSON Binding annotations.
JsonbBuilder	JsonbBuilder class provides the client's entry point to the JSON Binding API.
JsonbConfig	Supported Properties
JsonbCreator	This annotation identifies the custom constructor or factory method to use when creating an instance of the associated class.
JsonbDateFormat	Annotation provides way how to set custom date format to field or JavaBean property.
JsonbDeserializer<T>	Interface representing a custom deserializer for a given type.
JsonbException	Root class for all JSON Binding exceptions.
JsonbNillable	Specifies how fields having null values are serialized into JSON.
JsonbNumberFormat	Annotation provides way how to set custom number format to field or JavaBean property.
JsonbProperty	Allows customization of field (or JavaBean property) name.This name is used either in serialization or in deserialization.
JsonbPropertyOrder	Specifies order in which properties are serialized.
JsonbProvider	Service provider for JSON Binding implementations.
JsonbSerializer<T>	Interface representing a custom serializer for given type.
JsonbSubtype	Subtype is tightly bound to the JsonbTypeInfo.
JsonbTransient	Prevents mapping of a Java Bean property, field or type to JSON representation.
JsonbTypeAdapter	Annotation provides way how to set custom JsonbAdapter to field or JavaBean property.
JsonbTypeDeserializer	Annotation provides way how to set custom JsonbDeserializer to field or JavaBean property.
JsonbTypeInfo	Configuration annotation of the type information handling.
JsonbTypeSerializer	Annotation provides way how to set custom JsonbSerializer to field or JavaBean property.
JsonBuilderFactory	Factory to create JsonObjectBuilder and JsonArrayBuilder instances.
JsonbVisibility	Annotation provides way how to customize visibility strategy of the JSON Binding.
JsonCollectors	This class contains some implementations of java.util.stream.Collector for accumulating JsonValues into JsonArray and JsonObject.
JsonConfig	This class contains the Json properties and values.
JsonConfig.KeyStrategy	Contains the different values allowed for JsonConfig.KEY_STRATEGY.
JsonException	JsonException indicates that some exception happened during JSON processing.
JsonGenerationException	JsonGenerationException indicates an incorrect JSON is being generated.
JsonGenerator	Writes JSON data to an output source in a streaming way.
JsonGeneratorFactory	Factory to create JsonGenerator instances.
JsonLocation	Provides the location information of a JSON event in an input source.
JsonMergePatch	This interface represents an implementation of a JSON Merge Patch as defined by RFC 7396.
JsonNumber	An immutable JSON number value.
JsonObject	JsonObject class represents an immutable JSON object value (an unordered collection of zero or more name/value pairs).
JsonObjectBuilder	A builder for creating JsonObject models from scratch.
JsonParser	Provides forward, read-only access to JSON data in a streaming way.
JsonParser.Event	An event from JsonParser.
JsonParserFactory	Factory for creating JsonParser instances.
JsonParsingException	JsonParsingException is used when an incorrect JSON is being parsed.
JsonPatch	This interface represents an immutable implementation of a JSON Patch as defined by RFC 6902.
JsonPatch.Operation	This enum represents the list of valid JSON Patch operations as defined by RFC 6902.
JsonPatchBuilder	A builder for constructing a JSON Patch as defined by RFC 6902 by adding JSON Patch operations incrementally.
JsonPointer	This interface represents an immutable implementation of a JSON Pointer as defined by RFC 6901.
JsonProvider	Service provider for JSON processing objects.
JsonReader	Reads a JSON object or an array structure from an input source.
JsonReaderFactory	Factory to create JsonReader instances.
JsonString	An immutable JSON string value.
JsonStructure	Super type for the two structured types in JSON (objects and arrays).
JsonValue	JsonValue represents an immutable JSON value.
JsonValue.ValueType	Indicates the type of a JsonValue object.
JsonWriter	Writes a JSON object or array structure to an output source.
JsonWriterFactory	Factory to create JsonWriter instances.
JspApplicationContext	Stores application-scoped information relevant to JSP containers.
JspConfigDescriptor	This interface provides access to the <jsp-config> related configuration of a web application.
JspContext	JspContext serves as the base class for the PageContext class and abstracts all information that is not specific to servlets.
JspEngineInfo	The JspEngineInfo is an abstract class that provides information on the current JSP engine.
JspException	A generic exception known to the JSP engine; uncaught JspExceptions will result in an invocation of the errorpage machinery.
JspFactory	The JspFactory is an abstract class that defines a number of factory methods available to a JSP page at runtime for the purposes of creating instances of various interfaces and classes used to support the JSP implementation.
JspFragment	Encapsulates a portion of JSP code in an object that can be invoked as many times as needed.
JspIdConsumer	This interface indicates to the container that a tag handler wishes to be provided with a compiler generated ID.
JspPage	The JspPage interface describes the generic interaction that a JSP Page Implementation class must satisfy; pages that use the HTTP protocol are described by the HttpJspPage interface.
JspPropertyGroupDescriptor	This interface provides access to the <jsp-property-group> related configuration of a web application.
JspTag	Serves as a base class for Tag and SimpleTag.
JspTagException	Exception to be used by a Tag Handler to indicate some unrecoverable error.
JspWriter	The actions and template data in a JSP page is written using the JspWriter object that is referenced by the implicit variable out which is initialized automatically using methods in the PageContext object.
JwtClaims	Standard JWT claims.
LambdaExpression	Encapsulates a parameterized ValueExpression.
LastExecution	Contains information about the last execution of a task.
LazyAssociatableConnectionManager	This is a mix-in interface that may be optionally implemented by a ConnectionManager implementation.
LazyEnlistableConnectionManager	This is a mix-in interface that may be optionally implemented by a ConnectionManager implementation.
LazyEnlistableManagedConnection	This is a mix-in interface that may be optionally implemented by a ManagedConnection implementation.
LdapIdentityStoreDefinition	Annotation used to define a container-provided IdentityStore that stores caller credentials and identity attributes (together caller identities) in an LDAP store, and make that implementation available as an enabled CDI bean.
LdapIdentityStoreDefinition.LdapSearchScope	Enum representing LDAP search scope values.
LengthValidator	LengthValidator is a Validator that checks the number of characters in the String representation of the value of the associated component.
Lifecycle	Lifecycle manages the processing of the entire lifecycle of a particular Jakarta Faces request.
LifecycleFactory	LifecycleFactory is a factory object that creates (if needed) and returns Lifecycle instances.
LifecycleWrapper	Provides a simple implementation of Lifecycle that can be subclassed by developers wishing to provide specialized behavior to an existing Lifecycle instance.
LineInputStream	LineInputStream supports reading CRLF terminated lines that contain only US-ASCII characters from an input stream.
LineOutputStream	This interface is to support writing out Strings as a sequence of bytes terminated by a CRLF sequence.
Link	Class representing hypermedia links.
Link.Builder	Builder class for hypermedia links.
Link.JaxbAdapter	Deprecated.
Link.JaxbLink	Deprecated.
ListAttribute<X,E>	Instances of the type ListAttribute represent persistent java.util.List-valued attributes.
ListDataModel<E>	ListDataModel is a convenience implementation of DataModel that wraps an List of Java objects.
ListELResolver	Defines property resolution behavior on instances of List.
ListenerFor	Classes tagged with this annotation are installed as listeners using the method Application.subscribeToEvent(java.lang.Class<? extends jakarta.faces.event.SystemEvent>, java.lang.Class<?>, jakarta.faces.event.SystemEventListener) or UIComponent.subscribeToEvent(java.lang.Class<? extends jakarta.faces.event.SystemEvent>, jakarta.faces.event.ComponentSystemEventListener) (depending on the circumstances, described below).
ListenersFor	Container annotation to specify multiple ListenerFor annotations on a single class.
ListJoin<Z,E>	The ListJoin interface is the type of the result of joining to a collection over an association or element collection that has been specified as a java.util.List.
LoadState	Load states returned by the ProviderUtil SPI methods.
Lob	Specifies that a persistent property or field should be persisted as a large object to a database-supported large object type.
Local	Declares the local business interface(s) for a session bean.
LocalBean	Designates that a session bean exposes a no-interface view.
LocaleSupport	Class which exposes the locale-determination logic for resource bundles through convenience methods.
LocalHome	Declares the local home or adapted local home interface for a session bean.
LocalizationContext	Class representing an I18N localization context.
LocalTransaction	The LocalTransaction defines a transaction demarcation interface for resource manager local transactions.
LocalTransaction	LocalTransaction interface provides support for transactions that are managed internal to an EIS resource manager, and do not require an external transaction manager.
LocalTransactionException	A LocalTransactionException represents various error conditions related to the local transaction management contract.
Location	An object that represents the Location of a tag or attribute of a tag in a View Declaration Language file.
Lock	Declares a concurrency lock for a singleton session bean with container managed concurrency.
LockModeType	Lock modes can be specified by means of passing a LockModeType argument to one of the EntityManager methods that take locks (lock, find, or refresh) or to the Query.setLockMode() or TypedQuery.setLockMode() method.
LockTimeoutException	Thrown by the persistence provider when an pessimistic locking conflict occurs that does not result in transaction rollback.
LockType	Concurrency lock type for singleton beans with container-managed concurrency.
LogicalHandler<C extends LogicalMessageContext>	The LogicalHandler extends Handler to provide typesafety for the message context parameter.
LogicalMessage	The LogicalMessage interface represents a protocol agnostic XML message and contains methods that provide access to the payload of the message.
LogicalMessageContext	The LogicalMessageContext interface extends MessageContext to provide access to a the contained message as a protocol neutral LogicalMessage
LoginToContinue	The LoginToContinue annotation provides an application the ability to declaratively add login to continue functionality to an authentication mechanism.
LoginToContinue.Literal	Supports inline instantiation of the LoginToContinue annotation.
LogoutDefinition	LogoutDefinition annotation defines logout and RP session management configuration in openid connect client.
LongConverter	Converter implementation for java.lang.Long (and long primitive) values.
LongRangeValidator	LongRangeValidator is a Validator that checks the value of the corresponding component against specified minimum and maximum values.
LoopTag	The Jakarta Standard Tag Library allows developers to write custom iteration tags by implementing the LoopTag interface.
LoopTagStatus	Exposes the current status of an iteration.
LoopTagSupport	Base support class to facilitate implementation of iteration tags.
MailcapCommandMap	MailcapCommandMap extends the CommandMap abstract class.
MailcapRegistry	The MailcapRegistry interface is implemented by objects that can be used to store and retrieve MailcapEntries.
MailcapRegistryProvider	This interface defines a factory for MailcapRegistry.
MailDateFormat	Formats and parses date specification based on RFC 2822.
MailEvent	Common base class for mail events, defining the dispatch method.
MailSessionDefinition	Annotation used by Jakarta EE applications to define a MailSession to be registered with JNDI.
MailSessionDefinitions	Declares one or more MailSessionDefinition annotations.
ManageableThread	Interface to be implemented by the Jakarta™ EE product providers on threads that are created by calling ThreadFactory.newThread(java.lang.Runnable).
ManagedBean	Deprecated. This will be removed post Jakarta EE 10 and should be replaced with CDI beans
ManagedConnection	ManagedConnection instance represents a physical connection to the underlying EIS.
ManagedConnectionFactory	ManagedConnectionFactory instance is a factory of both ManagedConnection and EIS-specific connection factory instances.
ManagedConnectionMetaData	The ManagedConnectionMetaData interface provides information about the underlying EIS instance associated with a ManagedConnection instance.
ManagedExecutorDefinition	Defines a ManagedExecutorService to be registered in JNDI by the container under the JNDI name that is specified in the ManagedExecutorDefinition.name() attribute.
ManagedExecutorDefinition.List	Enables multiple ManagedExecutorDefinition annotations on the same type.
ManagedExecutors	Utility methods for classes defined in this package.
ManagedExecutorService	A manageable version of a ExecutorService.
ManagedProperty	The presence of this annotation (along with @Inject) on a field of any type causes the value returned from evaluating an expression language expression to be injected as the value of that field.
ManagedProperty.Literal	Supports inline instantiation of the ManagedProperty qualifier.
ManagedScheduledExecutorDefinition	Defines a ManagedScheduledExecutorService to be registered in JNDI by the container under the JNDI name that is specified in the ManagedScheduledExecutorDefinition.name() attribute.
ManagedScheduledExecutorDefinition.List	Enables multiple ManagedScheduledExecutorDefinition annotations on the same type.
ManagedScheduledExecutorService	A manageable version of a ScheduledExecutorService.
ManagedTask	A task submitted to an ManagedExecutorService or ManagedScheduledExecutorService can optionally implement this interface to provide identifying information about the task, to provide a ManagedTaskListener to get notification of lifecycle events of the task, or to provide additional execution properties.
ManagedTaskListener	A ManagedTaskListener is used to monitor the state of a task's Future.
ManagedThreadFactory	A manageable version of a ThreadFactory.
ManagedThreadFactoryDefinition	Defines a ManagedThreadFactory to be registered in JNDI by the container under the JNDI name that is specified in the ManagedThreadFactoryDefinition.name() attribute.
ManagedThreadFactoryDefinition.List	Enables multiple ManagedThreadFactoryDefinition annotations on the same type.
ManagedType<X>	Instances of the type ManagedType represent entity, mapped superclass, and embeddable types.
ManyToMany	Specifies a many-valued association with many-to-many multiplicity.
ManyToOne	Specifies a single-valued association to another entity class that has many-to-one multiplicity.
MapAttribute<X,K,V>	Instances of the type MapAttribute represent persistent java.util.Map-valued attributes.
MapELResolver	Defines property resolution behavior on instances of Map.
MapJoin<Z,K,V>	The MapJoin interface is the type of the result of joining to a collection over an association or element collection that has been specified as a java.util.Map.
MapKey	Specifies the map key for associations of type java.util.Map when the map key is itself the primary key or a persistent field or property of the entity that is the value of the map.
MapKeyClass	Specifies the type of the map key for associations of type java.util.Map.
MapKeyColumn	Specifies the mapping for the key column of a map whose map key is a basic type.
MapKeyEnumerated	Specifies the enum type for a map key whose basic type is an enumerated type.
MapKeyJoinColumn	Specifies a mapping to an entity that is a map key.
MapKeyJoinColumns	Supports composite map keys that reference entities.
MapKeyTemporal	This annotation must be specified for persistent map keys of type Date and Calendar.
MapMessage	A MapMessage object is used to send a set of name-value pairs.
MappedRecord<K,V>	The interface jakarta.resource.cci.MappedRecord is used for key-value map based representation of record elements.
MappedSuperclass	Designates a class whose mapping information is applied to the entities that inherit from it.
MappedSuperclassType<X>	Instances of the type MappedSuperclassType represent mapped superclass types.
MappingMatch	Enumeration of Servlet mapping types.
MapsId	Designates a ManyToOne or OneToOne relationship attribute that provides the mapping for an EmbeddedId primary key, an attribute within an EmbeddedId primary key, or a simple primary key of the parent entity.
MarshalException	This exception indicates that an error has occurred while performing a marshal operation that the provider is unable to recover from.
Marshaller	The Marshaller class is responsible for governing the process of serializing Java content trees back into XML data.
Marshaller.Listener	Register an instance of an implementation of this class with a Marshaller to externally listen for marshal events.
MatrixParam	Binds the value(s) of a URI matrix parameter to a resource method parameter, resource class field, or resource class bean property.
Max	The annotated element must be a number whose value must be lower or equal to the specified maximum.
Max.List	Defines several Max annotations on the same element.
MediaType	An abstraction for a media type.
Message	The Message interface is the root interface of all Jakarta Messaging messages.
Message	This class models an email message.
Message.RecipientType	This inner class defines the types of recipients allowed by the Message class.
MessageAware	An interface optionally implemented by DataSources to supply information to a DataContentHandler about the message context in which the data content object is operating.
MessageBodyReader<T>	Contract for a provider that supports the conversion of a stream to a Java type.
MessageBodyWriter<T>	Contract for a provider that supports the conversion of a Java type to a stream.
MessageChangedEvent	This class models Message change events.
MessageChangedListener	This is the Listener interface for MessageChanged events
MessageConsumer	A client uses a MessageConsumer object to receive messages from a destination.
MessageContext	The context in which a piece of Message content is contained.
MessageContext	The interface MessageContext abstracts the message context that is processed by a handler in the handle method.
MessageContext.Scope	Property scope.
MessageCountAdapter	The adapter which receives MessageCount events.
MessageCountEvent	This class notifies changes in the number of messages in a folder.
MessageCountListener	This is the Listener interface for MessageCount events.
MessageDriven	Component-defining annotation for a message driven bean.
MessageDrivenBean	The MessageDrivenBean interface defines methods that the enterprise bean container uses to notify a message driven bean instance of the instance's life cycle events.
MessageDrivenContext	The MessageDrivenContext interface provides access to the runtime message-driven context that the container provides for a message-driven bean instance.
MessageEndpoint	This defines a contract for a message endpoint.
MessageEndpointFactory	This serves as a factory for creating message endpoints.
MessageEOFException	This exception must be thrown when an unexpected end of stream has been reached when a StreamMessage or BytesMessage is being read.
MessageFactory	A factory for creating SOAPMessage objects.
MessageFormatException	This exception must be thrown when a Jakarta Messaging client attempts to use a data type not supported by a message or attempts to read data in a message as the wrong type.
MessageFormatRuntimeException	This unchecked exception must be thrown when a Jakarta Messaging application attempts to use a data type not supported by a message or attempts to read data in a message as the wrong type, and the method signature does not permit a MessageFormatException to be thrown.
MessageHandler	Developers implement MessageHandlers in order to receive incoming messages during a web socket conversation.
MessageHandler.Partial<T>	This kind of handler is notified by the implementation as it becomes ready to deliver parts of a whole message.
MessageHandler.Whole<T>	This kind of handler is notified by the container on arrival of a complete message.
MessageIDTerm	This term models the RFC822 "MessageId" - a message-id for Internet messages that is supposed to be unique per message.
MessageInfo	A container (message processing runtime) uses this interface to pass messages and message processing state to authentication contexts for processing by authentication mechanisms (modules).
MessageInterpolator	Interpolates a given constraint violation message.
MessageInterpolator.Context	Information related to the interpolation context.
MessageListener	A MessageListener object is used to receive asynchronously delivered messages.
MessageListener	This serves as a request-response message listener type that message endpoints (message-driven beans) may implement.
MessageNotReadableException	This exception must be thrown when a Jakarta Messaging client attempts to read a write-only message.
MessageNotWriteableException	This exception must be thrown when a Jakarta Messaging client attempts to write to a read-only message.
MessageNotWriteableRuntimeException	This unchecked exception must be thrown when a Jakarta Messaging client attempts to write to a read-only message.
MessageNumberTerm	This class implements comparisons for Message numbers.
MessagePolicy	This class defines a message authentication policy.
MessagePolicy.ProtectionPolicy	This interface is used to represent message authentication policy.
MessagePolicy.Target	This interface is used to represent and perform message targeting.
MessagePolicy.TargetPolicy	This class defines the message protection policies for specific Targets.
MessageProducer	A client uses a MessageProducer object to send messages to a destination.
MessageRemovedException	The exception thrown when an invalid method is invoked on an expunged Message.
Messages	Allows logging and producing errors during build compatible extension execution.
MessagingException	The base class for all exceptions thrown by the Messaging classes
MetaAnnotations	Allows registering custom CDI meta-annotations: qualifiers, interceptor bindings, stereotypes, and scopes.
Metadata	There are concrete subclasses within the implementation that map concepts in the Facelet VDL page to Jakarta Server Faces Java API calls the appropriate instances.
MetadataTarget	Information used with MetaRule for determining how and what Metadata should be wired.
Metamodel	Provides access to the metamodel of persistent entities in the persistence unit.
MetaRule	The root class of the abstraction that dictates how attributes on a markup element in a Facelets VDL page are wired to the Jakarta Faces API object instance associated with that element.
MetaRuleset	A mutable set of rules to be used in auto-wiring state to a particular object instance.
MetaTagHandler	Every kind of markup element in Facelets VDL that has attributes that need to take action on a Jakarta Faces Java API artifact is associated with an instance of this class.
MethodCallBuilder	Create a method call node in the current Flow.
MethodCallNode	Represents a method call node in the flow graph.
MethodConfig	Allows adding annotations to and removing annotations from a method.
MethodDescriptor	Describes a validated method.
MethodExpression	An Expression that refers to a method on an object.
MethodExpressionActionListener	MethodExpressionActionListener is an ActionListener that wraps a MethodExpression.
MethodExpressionValidator	MethodExpressionValidator is a Validator that wraps a MethodExpression, and it performs validation by executing a method on an object identified by the MethodExpression.
MethodExpressionValueChangeListener	MethodExpressionValueChangeListener is a ValueChangeListener that wraps a MethodExpression.
MethodInfo	Holds information about a method that a MethodExpression evaluated to.
MethodInfo	A method or a constructor, declared in some class.
MethodNotFoundException	Thrown when a method could not be found while evaluating a MethodExpression.
MethodNotSupportedException	The exception thrown when a method is not supported by the implementation
MethodReference	Provides information about the method to which a method expression resolves.
MethodType	Represents the type of a method: getter or non getter.
Metric	The Metric interface defines job metrics recorded by the batch runtime.
Metric.MetricType	The enum defining the specification-defined metric types.
MimeBodyPart	This class represents a MIME body part.
MimeHeader	An object that stores a MIME header name and its value.
MimeHeaders	A container for MimeHeader objects, which represent the MIME headers present in a MIME part of a message.
MimeMessage	This class represents a MIME style email message.
MimeMessage.RecipientType	This inner class extends the jakarta.mail.Message.RecipientType class to add additional RecipientTypes.
MimeMultipart	The MimeMultipart class is an implementation of the abstract Multipart class that uses MIME conventions for the multipart data.
MimePart	The MimePart interface models an Entity as defined by MIME (RFC2045, Section 2.4).
MimePartDataSource	A utility class that implements a DataSource out of a MimePart.
MimeType	A Multipurpose Internet Mail Extension (MIME) type, as defined in RFC 2045 and 2046.
MimeTypeEntry	Represents mapping between the file extension and the MIME type string.
MimeTypeParameterList	A parameter list of a MimeType as defined in RFC 2045 and 2046.
MimeTypeParseException	A class to encapsulate MimeType parsing related exceptions.
MimeTypeRegistry	The MimeTypeRegistry interface is implemented by objects that can be used to store and retrieve MimeTypeEntries.
MimeTypeRegistryProvider	This interface defines a factory for MimeTypeRegistry.
MimetypesFileTypeMap	This class extends FileTypeMap and provides data typing of files via their file extension.
MimeUtility	This is a utility class that provides various MIME related functionality.
Min	The annotated element must be a number whose value must be higher or equal to the specified minimum.
Min.List	Defines several Min annotations on the same element.
Model	The built-in stereotype intended for use with beans that define the model layer of an MVC web application architecture such as JSF.
MTOM	This feature represents the use of MTOM with a web service.
MTOMFeature	This feature represents the use of MTOM with a web service.
Multipart	Multipart is a container that holds multiple body parts.
MultipartConfig	Annotation that may be specified on a Servlet class, indicating that instances of the Servlet expect requests that conform to the multipart/form-data MIME type.
MultipartConfigElement	Java Class represntation of an MultipartConfig annotation value.
MultipartDataSource	MultipartDataSource is a DataSource that contains body parts.
MultivaluedHashMap<K,V>	A hash table based implementation of MultivaluedMap interface.
MultivaluedMap<K,V>	A map of key-values pairs.
Name	A representation of an XML name.
NameBinding	Meta-annotation used to create name binding annotations for filters and interceptors.
Named	String-based qualifier.
NamedAttributeNode	A NamedAttributeNode is a member element of a NamedEntityGraph.
NamedEntityGraph	Used to specify the path and boundaries for a find operation or query.
NamedEntityGraphs	Used to group NamedEntityGraph annotations.
NamedEvent	The presence of this annotation on a class automatically registers the class with the runtime as a ComponentSystemEvent for use with the <f:event /> tag in a page.
NamedLiteral	Supports inline instantiation of the Named qualifier.
NamedNativeQueries	Specifies multiple native SQL named queries.
NamedNativeQuery	Specifies a named native SQL query.
NamedQueries	Specifies multiple named Jakarta Persistence query language queries.
NamedQuery	Specifies a static, named query in the Jakarta Persistence query language.
NamedStoredProcedureQueries	Specifies multiple named stored procedure queries.
NamedStoredProcedureQuery	Specifies and names a stored procedure, its parameters, and its result type.
NamedSubgraph	A NamedSubgraph is a member element of a NamedEntityGraph.
NamingContainer	NamingContainer is an interface that must be implemented by any UIComponent that wants to be a naming container.
NavigationCase	NavigationCase represents a <navigation-case> in the navigation rule base, as well as the <from-view-id> with which this <navigation-case> is a sibling.
NavigationCaseBuilder	Create a navigation case in the current Flow.
NavigationCaseWrapper	Provides a simple implementation of NavigationCase that can be subclassed by developers wishing to provide specialized behavior to an existing NavigationCase instance.
NavigationHandler	A NavigationHandler is passed the outcome string returned by an application action invoked for this application, and will use this (along with related state information) to choose the view to be displayed next.
NavigationHandlerWrapper	NavigationHandlerWrapper provides a simple implementation of NavigationHandler that can be subclassed by developers wishing to provide specialized behavior to an existing NavigationHandler instance.
Negative	The annotated element must be a strictly negative number (i.e.
Negative.List	Defines several Negative constraints on the same element.
NegativeOrZero	The annotated element must be a negative number or 0.
NegativeOrZero.List	Defines several NegativeOrZero constraints on the same element.
NewCookie	Used to create a new HTTP cookie, transferred in a response.
NewCookie.AbstractNewCookieBuilder<T extends NewCookie.AbstractNewCookieBuilder<T>>	JAX-RS abstract NewCookie builder class.
NewCookie.Builder	JAX-RS NewCookie builder class.
NewCookie.SameSite	The available values for the SameSite cookie attribute.
NewsAddress	This class models an RFC1036 newsgroup address.
NoContentException	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.
Node	A representation of a node (element) in an XML document.
NodeBuilder	Base interface for building all kinds of flow nodes.
NoMoreTimeoutsException	This exception indicates that a calendar-based timer will not result in any more timeouts.
Nonbinding	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.
Nonbinding.Literal	Supports inline instantiation of the Nonbinding annotation.
NonexistentConversationException	Indicates that the conversation context could not be restored.
Nonnull	The annotated element must not be null.
NonUniqueResultException	Thrown by the persistence provider when Query.getSingleResult() or TypedQuery.getSingleResult() is executed on a query and there is more than one result from the query.
NoProviderFoundException	Exception raised if no Jakarta Bean Validation provider could be found.
NoResultException	Thrown by the persistence provider when Query.getSingleResult() or TypedQuery.getSingleResult()is executed on a query and there is no result to return.
NormalizedStringAdapter	XmlAdapter to handle xs:normalizedString.
NormalScope	Specifies that an annotation type is a normal scope type.
NoSuchEJBException	A NoSuchEJBException is thrown if an attempt is made to invoke a business method on a stateful session or singleton object that no longer exists.
NoSuchEntityException	The NoSuchEntityException exception is thrown by an entity bean instance to its container to report that the invoked business method or callback method could not be completed because of the underlying entity was removed from the database.
NoSuchJobException	Used in JobOperator methods when referencing a job name value which does not correspond to a job recognized by the implementation's repository.
NoSuchJobExecutionException	Used in JobOperator methods when referencing a job execution value which does not correspond to a job execution recognized by the implementation's repository.
NoSuchJobInstanceException	Used in JobOperator methods when referencing a job instance value which does not correspond to a job instance recognized by the implementation's repository.
NoSuchObjectLocalException	A NoSuchObjectLocalException is thrown if an attempt is made to invoke a method on a local object (local enterprise bean object or timer) that no longer exists.
NoSuchProviderException	This exception is thrown when Session attempts to instantiate a Provider that doesn't exist.
NotAcceptableException	A runtime exception indicating that a client request is not acceptable by the server.
NotAllowedException	A runtime exception indicating a client requesting a resource method that is not allowed.
NotAuthorizedException	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.
NotBlank	The annotated element must not be null and must contain at least one non-whitespace character.
NotBlank.List	Defines several @NotBlank constraints on the same element.
NotEmpty	The annotated element must not be null nor empty.
NotEmpty.List	Defines several @NotEmpty constraints on the same element.
NotFoundELResolver	Defines variable resolution when all other resolvers fail.
NotFoundException	A runtime exception indicating a resource requested by a client was not found on the server.
NotIdentifiableEvent	This event indicates that a problem was encountered resolving an ID/IDREF.
NotIdentifiableEventImpl	Default implementation of the NotIdentifiableEvent interface.
NotificationOptions	Notification options are used to configure observer notification.
NotificationOptions.Builder	Notification options builder.
NotNull	The annotated element must not be null.
NotNull.List	Defines several NotNull annotations on the same element.
NotSupportedException	A NotSupportedException is thrown to indicate that callee (resource adapter or application server for system contracts) cannot execute an operation because the operation is not a supported feature.
NotSupportedException	NotSupportedException exception indicates that the request cannot be executed because the operation is not a supported feature.
NotSupportedException	A runtime exception indicating that the client request entity media type is not supported.
NotTerm	This class implements the logical NEGATION operator.
Null	The annotated element must be null.
Null.List	Defines several Null annotations on the same element.
Nullable	The annotated element could be null under some circumstances.
NumberConverter	Converter implementation for java.lang.Number values.
ObjectMessage	An ObjectMessage object is used to send a message that contains a serializable object in the Java programming language ("Java object").
ObjectNotFoundException	The ObjectNotFoundException exception is thrown by a finder or select method to indicate that the specified enterprise bean object or local object does not exist.
ObserverException	Indicates that a checked exception was thrown by an observer method during event notification.
ObserverInfo	Observers are: observer methods synthetic observers Observer methods directly correspond to a method declaration in program source code.
ObserverMethod<T>	Represents an observer method of an enabled bean.
ObserverMethodConfigurator<T>	An ObserverMethodConfigurator can configure an ObserverMethod.
ObserverMethodConfigurator.EventConsumer<T>	Represents an operation that accepts a context of a fired event.
Observes	Identifies the event parameter of an observer method.
ObservesAsync	Identifies the event parameter of an asynchronous observer method.
OnClose	This method level annotation can be used to decorate a Java method that wishes to be called when a web socket session is closing.
OnError	This method level annotation can be used to decorate a Java method that wishes to be called in order to handle errors.
OneToMany	Specifies a many-valued association with one-to-many multiplicity.
OneToOne	Specifies a single-valued association to another entity that has one-to-one multiplicity.
Oneway	Indicates that the given @WebMethod has only an input message and no output.
OnMessage	This method level annotation can be used to make a Java method receive incoming web socket messages.
OnOpen	This method level annotation can be used to decorate a Java method that wishes to be called when a new web socket session is open.
OpenIdAuthenticationMechanismDefinition	Annotation used to define a container authentication mechanism that implements the Authorization Code flow and Refresh tokens as defined by the OpenId Connect specification and make that implementation available as an enabled CDI bean.
OpenIdClaims	User Claims received from the userinfo endpoint.
OpenIdConstant	Contains constant specific to OpenId Connect specification http://openid.net/specs/openid-connect-core-1_0.html
OpenIdContext	An injectable interface that provides access to access token, identity token, claims and OpenId Connect provider related information.
OpenIdProviderMetadata	OpenIdProviderMetadata annotation overrides the openid connect provider's endpoint value, discovered using providerUri.
OptimisticLockException	Thrown by the persistence provider when an optimistic locking conflict occurs.
OPTIONS	Indicates that the annotated method responds to HTTP OPTIONS requests.
Order	An object that defines an ordering over the query results.
OrderBy	Specifies the ordering of the elements of a collection valued association or element collection at the point when the association or collection is retrieved.
OrderColumn	Specifies a column that is used to maintain the persistent order of a list.
OrTerm	This class implements the logical OR operator on individual SearchTerms.
OutboundSseEvent	Representation of a single outbound Server-sent event.
OutboundSseEvent.Builder	A builder class used for creating OutboundSseEvent instances.
OverridesAttribute	Marks an attribute as overriding the attribute of a composing constraint.
OverridesAttribute.List	Defines several OverridesAttribute annotations on the same element
PackageInfo	A package, possibly annotated in package-info.java.
PageContext	PageContext extends JspContext to provide useful context information for when JSP technology is used in a Servlet environment.
PageData	Translation-time information on a JSP page.
ParamConverter<T>	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.
ParamConverter.Lazy	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.
ParamConverterProvider	Contract for a provider of ParamConverter instances.
Parameter	Represents a parameter in any of several places where parameters are needed when processing flows.
Parameter<T>	Type for query parameter objects.
ParameterConfig	Allows adding annotations to and removing annotations from a method parameter.
ParameterDescriptor	Describes a validated method or constructor parameter.
ParameterExpression<T>	Type of criteria query parameter expressions.
ParameterInfo	A method parameter or a constructor parameter, declared in some method or constructor.
ParameterizedType	A parameterized type.
ParameterList	This class holds MIME parameters (attribute-value pairs).
ParameterMode	Specifies the mode of a parameter of a stored procedure query.
ParameterNameProvider	Provides names for method and constructor parameters.
Parameters	A String-keyed parameter map.
ParseConversionEvent	This event indicates that a problem was encountered while converting a string from the XML data into a value of the target Java data type.
ParseConversionEventImpl	Default implementation of the ParseConversionEvent interface.
ParseException	The exception thrown due to an error in parsing RFC822 or MIME headers, including multipart bodies.
Part	The Part interface is the common base interface for Messages and BodyParts.
Part	This class represents a part or form item that was received within a multipart/form-data POST request.
PartialResponseWriter	PartialResponseWriter decorates an existing ResponseWriter to support the generation of a partial response suitable for Ajax operations.
PartialStateHolder	Components that want to leverage the partial state saving feature must implement this interface instead of implementing StateHolder, from which this interface inherits.
PartialViewContext	PartialViewContext contains methods and properties that pertain to partial request processing and partial response rendering on a view.
PartialViewContextFactory	PartialViewContextFactory is a factory object that creates (if needed) and returns new PartialViewContext instances.
PartialViewContextWrapper	Provides a simple implementation of PartialViewContext that can be subclassed by developers wishing to provide specialized behavior to an existing PartialViewContext instance.
PartitionAnalyzer	PartitionAnalyzer receives control to process data and final results from each partition.
PartitionCollector	PartitionCollector provides a way to pass data from individual partitions to a single point of control running on the step's parent thread.
PartitionMapper	PartitionMapper receives control at the start of a partitioned execution.
PartitionPlan	PartitionPlan is a helper class that carries partition processing information set by the @PartitionMapper method.
PartitionPlanImpl	The PartitionPlanImpl class provides a basic implementation of the PartitionPlan interface.
PartitionReducer	PartitionReducer provides unit of work demarcation across partitions.
PartitionReducer.PartitionStatus	An enum used in PartitionReducer.afterPartitionedStepCompletion(PartitionStatus).
PassivationCapable	Indicates that a custom implementation of Bean or Contextual is passivation capable.
Password	Represents a text-based password, and includes a built-in mechanism for securely clearing the value.
PasswordAuthentication	The class PasswordAuthentication is a data holder that is used by Authenticator.
PasswordCredential	The class PasswordCredential acts as a holder for username and password.
PasswordHash	PasswordHash is an interface for objects that can generate and verify password hashes.
PasswordValidationCallback	Callback for PasswordValidation.
Past	The annotated element must be an instant, date or time in the past.
Past.List	Defines several Past annotations on the same element.
PastOrPresent	The annotated element must be an instant, date or time in the past or in the present.
PastOrPresent.List	Defines several PastOrPresent annotations on the same element.
PATCH	Indicates that the annotated method responds to HTTP PATCH requests.
Path<X>	Represents a simple or compound attribute path from a bound type or collection, and is a "primitive" expression.
Path	Represents the navigation path from an object to another in an object graph.
Path	Identifies the URI path that a resource class or class method will serve requests for.
Path.BeanNode	Node representing a bean.
Path.ConstructorNode	Node representing a constructor.
Path.ContainerElementNode	Node representing an element in a generic container such as Optional, List or Map.
Path.CrossParameterNode	Node representing the element holding cross-parameter constraints of a method or constructor.
Path.MethodNode	Node representing a method.
Path.Node	Represents an element of a navigation path.
Path.ParameterNode	Node representing a parameter of a method or constructor.
Path.PropertyNode	Node representing a property.
Path.ReturnValueNode	Node representing the return value of a method or constructor.
PathParam	This annotation may be used to annotate method parameters on server endpoints where a URI-template has been used in the path-mapping of the ServerEndpoint annotation.
PathParam	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.
PathSegment	Represents a URI path segment and any associated matrix parameters.
Pattern	The annotated CharSequence must match the specified regular expression.
Pattern.Flag	Possible Regexp flags.
Pattern.List	Defines several Pattern annotations on the same element.
Payload	Payload type that can be attached to a given constraint declaration.
Pbkdf2PasswordHash	This interface represents the built-in Pbkdf2PasswordHash implementation.
PermitAll	Specifies that all security roles are allowed to invoke the specified method(s) — i.e., that the specified method(s) are "unchecked".
PermittedTaglibsTLV	A TagLibraryValidator class to allow a TLD to restrict what taglibs (in addition to itself) may be imported on a page where it's used.
Persistence	Bootstrap class that is used to obtain an EntityManagerFactory in Java SE environments.
PersistenceContext	Expresses a dependency on a container-managed EntityManager and its associated persistence context.
PersistenceContexts	Declares one or more PersistenceContext annotations.
PersistenceContextType	Specifies whether a transaction-scoped or extended persistence context is to be used in PersistenceContext.
PersistenceException	Thrown by the persistence provider when a problem occurs.
PersistenceProperty	Describes a single container or persistence provider property.
PersistenceProvider	Interface implemented by the persistence provider.
PersistenceProviderResolver	Determine the list of persistence providers available in the runtime environment.
PersistenceProviderResolverHolder	Holds the global PersistenceProviderResolver instance.
PersistenceUnit	Expresses a dependency on an EntityManagerFactory and its associated persistence unit.
PersistenceUnitInfo	Interface implemented by the container and used by the persistence provider when creating an EntityManagerFactory.
PersistenceUnits	Declares one or more PersistenceUnit annotations.
PersistenceUnitTransactionType	Specifies whether entity managers created by the EntityManagerFactory will be JTA or resource-local entity managers.
PersistenceUnitUtil	Utility interface between the application and the persistence provider managing the persistence unit.
PersistenceUtil	Utility interface between the application and the persistence provider(s).
PessimisticLockException	Thrown by the persistence provider when an pessimistic locking conflict occurs.
PessimisticLockScope	Defines the values of the jakarta.persistence.lock.scope property for pessimistic locking.
PhaseEvent	PhaseEvent represents the beginning or ending of processing for a particular phase of the request processing lifecycle, for the request encapsulated by the specified FacesContext.
PhaseId	Typesafe enumeration of the legal values that may be returned by the getPhaseId() method of the FacesEvent interface.
PhaseListener	An interface implemented by objects that wish to be notified at the beginning and ending of processing for each standard phase of the request processing lifecycle.
PluralAttribute<X,C,E>	Instances of the type PluralAttribute represent persistent collection-valued attributes.
PluralAttribute.CollectionType
PluralJoin<Z,C,E>	The PluralJoin interface defines functionality that is common to joins to all collection types.
PolicyConfiguration	The methods of this interface are used by containers to create policy statements in a Policy provider.
PolicyConfigurationFactory	Abstract factory and finder class for obtaining the instance of the class that implements the PolicyConfigurationFactory of a provider.
PolicyContext	This utility class is used by containers to communicate policy context identifiers and other policy relevant context to Policy providers.
PolicyContextException	This checked exception is thrown by implementations of the PolicyConfiguration Interface, the PolicyConfigurationFactory abstract class, the PolicyContext utility class, and implementations of the PolicyContextException Interface.
PolicyContextHandler	This interface defines the methods that must be implemented by handlers that are to be registered and activated by the PolicyContext class.
PongMessage	The PongMessage interface represents a web socket pong.
PortInfo	The PortInfo interface is used by a HandlerResolver to query information about the port it is being asked to create a handler chain for.
Positive	The annotated element must be a strictly positive number (i.e.
Positive.List	Defines several Positive constraints on the same element.
PositiveOrZero	The annotated element must be a positive number or 0.
PositiveOrZero.List	Defines several PositiveOrZero constraints on the same element.
POST	Indicates that the annotated method responds to HTTP POST requests.
PostActivate	Designates a method to receive a callback after a stateful session bean has been activated.
PostAddToViewEvent	When an instance of this event is passed to SystemEventListener.processEvent(jakarta.faces.event.SystemEvent) or ComponentSystemEventListener.processEvent(jakarta.faces.event.ComponentSystemEvent), the listener implementation may assume that the source of this event instance is a UIComponent instance and that either that instance or an ancestor of that instance was just added to the view.
PostConstruct	The PostConstruct annotation is used on a method that needs to be executed after dependency injection is done to perform any initialization.
PostConstructApplicationEvent	This event must be published by the runtime after all configuration resources have been parsed and processed.
PostConstructCustomScopeEvent	This class is provided to allow custom scopes to publish a "post construct" event in the same way that other scopes do to let the application become aware of the beginning of the scope.
PostConstructViewMapEvent	This event must be published by a call to {jakarta.faces.application.Application#publishEvent} when the view map is first created.
PostKeepFlashValueEvent	This event must be published by a call to Application.publishEvent(jakarta.faces.context.FacesContext, java.lang.Class<? extends jakarta.faces.event.SystemEvent>, java.lang.Object) when a value is kept in the flash.
PostLoad	Specifies a callback method for the corresponding lifecycle event.
PostPersist	Specifies a callback method for the corresponding lifecycle event.
PostPutFlashValueEvent	This event must be published by a call to Application.publishEvent(jakarta.faces.context.FacesContext, java.lang.Class<? extends jakarta.faces.event.SystemEvent>, java.lang.Object) when a value is stored in the flash.
PostRemove	Specifies a callback method for the corresponding lifecycle event.
PostRenderViewEvent	When an instance of this event is passed to SystemEventListener.processEvent(jakarta.faces.event.SystemEvent) or ComponentSystemEventListener.processEvent(jakarta.faces.event.ComponentSystemEvent), the listener implementation may assume that the source of this event instance is the UIViewRoot instance that has just been rendered.
PostRestoreStateEvent	When an instance of this event is passed to SystemEventListener.processEvent(jakarta.faces.event.SystemEvent) or ComponentSystemEventListener.processEvent(jakarta.faces.event.ComponentSystemEvent), the listener implementation may assume that the source of this event instance is in a tree that has just had its state restored.
PostUpdate	Specifies a callback method for the corresponding lifecycle event.
PostValidateEvent	When an instance of this event is passed to SystemEventListener.processEvent(jakarta.faces.event.SystemEvent) or ComponentSystemEventListener.processEvent(jakarta.faces.event.ComponentSystemEvent), the listener implementation may assume that the source of this event instance is the UIComponent instance that is that has just been validated.
PreClearFlashEvent	This event must be published by a call to Application.publishEvent(jakarta.faces.context.FacesContext, java.lang.Class<? extends jakarta.faces.event.SystemEvent>, java.lang.Object) before the flash is cleared.
PreDestroy	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.
PreDestroyApplicationEvent	This event must be published by the runtime before the factories associated with this Application are released.
PreDestroyCustomScopeEvent	This class is provided to allow custom scopes to publish a "pre construct" event in the same way that other scopes do to let the application become aware of the beginning of the scope.
PreDestroyViewMapEvent	This event must be published by a call to Application.publishEvent(jakarta.faces.context.FacesContext, java.lang.Class<? extends jakarta.faces.event.SystemEvent>, java.lang.Object) when the clear method is called on the map returned from UIViewRoot.getViewMap().
Predicate	The type of a simple or compound predicate: a conjunction or disjunction of restrictions.
Predicate.BooleanOperator
PreencodedMimeBodyPart	A MimeBodyPart that handles data that has already been encoded.
PreMatching	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.
PrePassivate	Designates a method to receive a callback before a stateful session bean is passivated.
PrePersist	Specifies a callback method for the corresponding lifecycle event.
PreRemove	Specifies a callback method for the corresponding lifecycle event.
PreRemoveFlashValueEvent	This event must be published by a call to Application.publishEvent(jakarta.faces.context.FacesContext, java.lang.Class<? extends jakarta.faces.event.SystemEvent>, java.lang.Object) when a value is removed from the flash.
PreRemoveFromViewEvent	When an instance of this event is passed to SystemEventListener.processEvent(jakarta.faces.event.SystemEvent) or ComponentSystemEventListener.processEvent(jakarta.faces.event.ComponentSystemEvent), the listener implementation may assume that the source of this event instance is a UIComponent instance that is about to be removed from the view.
PreRenderComponentEvent	When an instance of this event is passed to SystemEventListener.processEvent(jakarta.faces.event.SystemEvent) or ComponentSystemEventListener.processEvent(jakarta.faces.event.ComponentSystemEvent), the listener implementation may assume that the source of this event instance is the UIComponent instance that is about to be rendered and that it is safe to call UIComponent.getParent(), UIComponent.getClientId(), and other methods that depend upon the component instance being in the view.
PreRenderViewEvent	When an instance of this event is passed to SystemEventListener.processEvent(jakarta.faces.event.SystemEvent) or ComponentSystemEventListener.processEvent(jakarta.faces.event.ComponentSystemEvent), the listener implementation may assume that the source of this event instance is the UIViewRoot instance that is about to be rendered.
PreUpdate	Specifies a callback method for the corresponding lifecycle event.
PreValidateEvent	When an instance of this event is passed to SystemEventListener.processEvent(jakarta.faces.event.SystemEvent) or ComponentSystemEventListener.processEvent(jakarta.faces.event.ComponentSystemEvent), the listener implementation may assume that the source of this event instance is the UIComponent instance that is about to be validated.
PrimaryKeyJoinColumn	Specifies a primary key column that is used as a foreign key to join to another table.
PrimaryKeyJoinColumns	Groups PrimaryKeyJoinColumn annotations.
PrimitiveType	Primitive types are: boolean byte short int long float double char
PrimitiveType.PrimitiveKind
PrintConversionEvent	This event indicates that a problem was encountered while converting data from the Java content tree into its lexical representation.
PrintConversionEventImpl	Default implementation of the PrintConversionEvent interface.
Priorities	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.
Prioritized	This interface allows some SPI implementation to change their priority programmatically.
Priority	The Priority annotation can be applied to any program elements to indicate in what order they should be used.
PrivateKeyCallback	Callback for acquiring a Public Key Infrastructure (PKI) private key and its corresponding certificate chain.
PrivateKeyCallback.AliasRequest	Request type for private keys that are identified using an alias.
PrivateKeyCallback.DigestRequest	Request type for private keys that are identified using a certificate digest or thumbprint.
PrivateKeyCallback.IssuerSerialNumRequest	Request type for private keys that are identified using an issuer/serial number.
PrivateKeyCallback.Request	Marker interface for private key request types.
PrivateKeyCallback.SubjectKeyIDRequest	Request type for private keys that are identified using a SubjectKeyID
ProcessAnnotatedType<X>	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.
ProcessBean<X>	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.
ProcessBeanAttributes<T>	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.
ProcessingException	A base JAX-RS runtime processing exception.
ProcessInjectionPoint<T,X>	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 jakarta.annotation.ManagedBean, EJB session or message-driven bean, enabled bean, enabled interceptor or enabled decorator.
ProcessInjectionTarget<X>	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 jakarta.annotation.ManagedBean, EJB session or message-driven bean, enabled bean, enabled interceptor or enabled decorator.
ProcessManagedBean<X>	The container fires an event of this type for each enabled managed bean, before registering the Bean object.
ProcessObserverMethod<T,X>	The container fires an event of this type for each observer method of each enabled bean, before registering the ObserverMethod object.
ProcessProducer<T,X>	The container fires an event of this type for each producer method or field of each enabled bean, including resources.
ProcessProducerField<T,X>	The container fires an event of this type for each enabled producer field, before registering the Bean object.
ProcessProducerMethod<T,X>	The container fires an event of this type for each enabled producer method, before registering the Bean object.
ProcessSessionBean<X>	The container fires an event of this type for each enabled session bean, before registering the Bean object.
ProcessSyntheticAnnotatedType<X>	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)
ProcessSyntheticBean<X>	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.
ProcessSyntheticObserverMethod<T,X>	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.
Producer<T>	Provides a generic operation for producing an instance of a type.
ProducerConfigurator<T>	A ProducerConfigurator can configure a Producer.
ProducerFactory<X>	An ProducerFactory can create an Producer for a given bean.
Produces	Identifies a producer method or field.
Produces	Defines the media type(s) that the methods of a resource class or MessageBodyWriter can produce.
ProjectStage	This class enables a feature similar to the RAILS_ENV feature of the Ruby on Rails web framework.
PromptType	Prompt specifies whether the Authorization Server prompts the End-User for re-authentication and consent.
PropertyDescriptor	Describes a Java Bean property hosting validation constraints.
PropertyException	This exception indicates that an error was encountered while getting or setting a property.
PropertyNamingStrategy	Allows to define custom property naming strategy.
PropertyNotFoundException	Thrown when a property could not be found while evaluating a ValueExpression or MethodExpression.
PropertyNotWritableException	Thrown when a property could not be written to while setting the value on a ValueExpression.
PropertyOrderStrategy	Specifies predefined property order strategies.
PropertyVisibilityStrategy	Provides mechanism how to define customized property visibility strategy.
ProtectedViewException	This exception is thrown by the runtime when a violation of the view protection mechanism is encountered.
ProtocolException	The ProtocolException class is a base class for exceptions related to a specific protocol binding.
Provider<T>	Provides instances of T.
Provider	The Provider is a class that describes a protocol implementation.
Provider	Marks an implementation of an extension interface that should be discoverable by JAX-RS runtime during a provider scanning phase.
Provider<T>	Service endpoints may implement the Provider interface as a dynamic alternative to an SEI.
Provider	Service provider for ServiceDelegate and Endpoint objects.
Provider.Type	This inner class defines the Provider type.
Providers	An injectable interface providing runtime lookup of provider instances.
ProviderSpecificBootstrap<T extends Configuration<T>>	Defines the state used to bootstrap Jakarta Bean Validation and creates a provider specific Configuration of type T.
ProviderUtil	Utility interface implemented by the persistence provider.
Push	The CDI annotation @Push allows you to inject a PushContext associated with a given <f:websocket> channel in any container managed artifact in WAR.
Push.Literal	Supports inline instantiation of the Push qualifier.
PushBuilder	Build a request to be pushed.
PushContext	CDI interface to send a message object to the push socket channel as identified by @Push.
PUT	Indicates that the annotated method responds to HTTP PUT requests.
Qualifier	Identifies qualifier annotations.
QualifierLiteral	Supports inline instantiation of the Qualifier annotation.
Query	Interface used to control query execution.
QueryHint	Used to supply a query property or hint to the NamedQuery or NamedNativeQuery annotation.
QueryParam	Binds the value(s) of a HTTP query parameter to a resource method parameter, resource class field, or resource class bean property.
QueryTimeoutException	Thrown by the persistence provider when a query times out and only the statement is rolled back.
Queue	A Queue object encapsulates a provider-specific queue name.
QueueBrowser	A client uses a QueueBrowser object to look at messages on a queue without removing them.
QueueConnection	A QueueConnection object is an active connection to a point-to-point Jakarta Messaging provider.
QueueConnectionFactory	A client uses a QueueConnectionFactory object to create QueueConnection objects with a point-to-point Jakarta Messaging provider.
QueueReceiver	A client uses a QueueReceiver object to receive messages that have been delivered to a queue.
QueueRequestor	The QueueRequestor helper class simplifies making service requests.
QueueSender	A client uses a QueueSender object to send messages to a queue.
QueueSession	A QueueSession object provides methods for creating QueueReceiver, QueueSender, QueueBrowser, and TemporaryQueue objects.
Quota	This class represents a set of quotas for a given quota root.
Quota.Resource	An individual resource in a quota root.
QuotaAwareStore	An interface implemented by Stores that support quotas.
ReaderInterceptor	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).
ReaderInterceptorContext	Context class used by ReaderInterceptor to intercept calls to (@link jakarta.ws.rs.ext.MessageBodyReader#readFrom}.
ReadListener	This class represents a call-back mechanism that will notify implementations as HTTP request data becomes available to be read without blocking.
ReadOnlyFolderException	This exception is thrown when an attempt is made to open a folder read-write access when the folder is marked read-only.
ReceivedDateTerm	This class implements comparisons for the Message Received date
Reception	Distinguishes conditional observer methods from observer methods which are always notified.
RecipientStringTerm	This class implements string comparisons for the Recipient Address headers.
RecipientTerm	This class implements comparisons for the Recipient Address headers.
Record	The jakarta.resource.cci.Record interface is the base interface for the representation of an input or output to the execute methods defined on an Interaction.
RecordComponentInfo	A record component, declared in some record.
RecordFactory	The RecordFactory interface is used for creating MappedRecord and IndexedRecord instances.
RedirectionException	A runtime application exception indicating a request redirection (HTTP 3xx status codes).
Referenceable	The Referenceable interface extends the javax.naming.Referenceable interface.
RefreshToken	A refresh token provides continuous access to an authentication server while the user is not logged into an application by issuing a new access token.
RegexValidator	A Validator that checks against a Regular Expression (which is the pattern property).
Registration	3rd phase of build compatible extension execution.
Registration	Interface through which a Servlet or Filter may be further configured.
Registration.Dynamic	Interface through which a Servlet or Filter registered via one of the addServlet or addFilter methods, respectively, on ServletContext may be further configured.
RegistrationListener	An implementation of this interface may be associated with an AuthConfigProvider registration at an AuthConfigFactory at the time the AuthConfigProvider is obtained for use from the factory.
RememberMe	The RememberMe annotation provides an application the ability to declaratively designate that an authentication mechanism effectively "remembers" the authentication and auto applies this with every request.
RememberMe.Literal	Supports inline instantiation of the RememberMe annotation.
RememberMeCredential	RememberMeCredential represents a credential presented as a token, for the explicit usage with the Jakarta Security provided remember me function.
RememberMeIdentityStore	RememberMeIdentityStore is a mechanism for validating a caller's credentials and accessing a caller's identity attributes that's specifically tailored for the "remember me" feature.
Remote	Declares the remote business interface(s) for a session bean.
RemoteEndpoint	The RemoteEndpoint object is supplied by the container and represents the 'other end' or peer of the Web Socket conversation.
RemoteEndpoint.Async	This representation of the peer of a web socket conversation has the ability to send messages asynchronously.
RemoteEndpoint.Basic	This representation of the peer of a web socket conversation has the ability to send messages synchronously.
RemoteHome	Declares the remote home interface or adapted remote home interface for a session bean.
Remove	Applied to a business method of a stateful session bean class to indicate to the container that the stateful session bean is to be removed by the container after completion of the method.
RemoveException	The RemoveException is thrown at an attempt to remove an enterprise bean object or local enterprise bean object when the enterprise bean or the container does not allow the enterprise bean object to be removed.
Renderer<T extends UIComponent>	A Renderer converts the internal representation of UIComponents into the output stream (or writer) associated with the response we are creating for a particular request.
RendererWrapper	Provides a simple implementation of Renderer that can be subclassed by developers wishing to provide specialized behavior to an existing Renderer instance.
RenderKit	RenderKit represents a collection of Renderer instances that, together, know how to render Jakarta Faces UIComponent instances for a specific client.
RenderKitFactory	RenderKitFactory is a factory object that registers and returns RenderKit instances.
RenderKitWrapper	Provides a simple implementation of RenderKit that can be subclassed by developers wishing to provide specialized behavior to an existing RenderKit instance.
ReportAsSingleViolation	A constraint annotation hosting this annotation will return the composed annotation error report if any of the composing annotations fail.
Request	An injectable helper for request processing, all methods throw an IllegalStateException if called outside the scope of a request (e.g.
RequestContextController	The CDI container provides a built in instance of RequestContextController that is dependent scoped for the purposes of activating and deactivating.
RequestCookieMap	The presence of this annotation (along with @Inject) on a field of type Map<String, Object> causes the map returned from ExternalContext.getRequestCookieMap() to be injected as the value of that field.
RequestCookieMap.Literal	Supports inline instantiation of the RequestCookieMap qualifier.
RequestDispatcher	Defines an object that receives requests from the client and sends them to any resource (such as a servlet, HTML file, or JSP file) on the server.
RequestMap	The presence of this annotation (along with @Inject) on a field of type Map<String, Object> causes the map returned from ExternalContext.getRequestMap() to be injected as the value of that field.
RequestMap.Literal	Supports inline instantiation of the RequestMap qualifier.
RequestParameterMap	The presence of this annotation (along with @Inject) on a field of type Map<String, String> causes the map returned from ExternalContext.getRequestParameterMap() to be injected as the value of that field.
RequestParameterMap.Literal	Supports inline instantiation of the RequestParameterMap qualifier.
RequestParameterValuesMap	The presence of this annotation (along with @Inject) on a field of type Map<String, String []> causes the map returned from ExternalContext.getRequestParameterValuesMap() to be injected as the value of that field.
RequestParameterValuesMap.Literal	Supports inline instantiation of the RequestParameterValuesMap qualifier.
RequestScoped	Specifies that a bean is request scoped.
RequestScoped.Literal	Supports inline instantiation of the RequestScoped annotation.
RequestWrapper	Used to annotate methods in the Service Endpoint Interface with the request wrapper bean to be used at runtime.
RequiredValidator	A Validator that checks for an empty value in the same way that UIInput checks for a value.
ResolutionException	Indicates a problem relating to typesafe resolution.
Resource	The Resource annotation marks a resource that is needed by the application.
Resource	An instance of Resource is a Java object representation of the artifact that is served up in response to a resource request from the client.
Resource.AuthenticationType	The two possible authentication types for a resource.
ResourceAdapter	This represents a resource adapter instance and contains operations for lifecycle management and message endpoint setup.
ResourceAdapterAssociation	This interface specifies the methods to associate a ResourceAdapter object with other objects that implement this interface like ManagedConnectionFactory and ActivationSpec.
ResourceAdapterInternalException	A ResourceAdapterInternalException indicates any system-level error conditions related to a resource adapter.
ResourceAdapterMetaData	The interface jakarta.resource.cci.ResourceAdapterMetaData provides information about capabilities of a resource adapter implementation.
ResourceAllocationException	This exception is thrown when a provider is unable to allocate the resources required by a method.
ResourceAllocationException	A ResourceAllocationException can be thrown by an application server or resource adapter to indicate any failure to allocate system resources (example: threads, physical connections).
ResourceAllocationRuntimeException	This unchecked exception is thrown when a provider is unable to allocate the resources required by a method.
ResourceBundleELResolver	Defines property resolution behavior on instances of ResourceBundle.
ResourceContext	The resource context provides access to instances of resource classes.
ResourceDependencies	Container annotation to specify multiple ResourceDependency annotations on a single class.
ResourceDependency	Instances of UIComponent or Renderer that have this annotation (or ResourceDependencies attached at the class level will automatically have a resource dependency added so that the named resource will be present in user agent's view of the UIViewRoot in which this component or renderer is used.
ResourceException	This is the root interface of the exception hierarchy defined for Jakarta™ Connectors.
ResourceHandler	ResourceHandler is the run-time API by which UIComponent and Renderer instances, and the ViewDeclarationLanguage can reference Resource instances. An implementation of this class must be thread-safe.
ResourceHandlerWrapper	Provides a simple implementation of ResourceHandler that can be subclassed by developers wishing to provide specialized behavior to an existing ResourceHandler instance.
ResourceInfo	An injectable class to access the resource class and resource method matched by the current request.
Resources	This class is used to allow multiple resources declarations.
ResourceVisitOption	Defines the resource traversal options.
ResourceWarning	A ResourceWarning provides information on warnings related to execution of an interaction with an EIS.
ResourceWrapper	Provides a simple implementation of Resource that can be subclassed by developers wishing to provide specialized behavior to an existing Resource instance.
RespectBinding	This feature clarifies the use of the wsdl:binding in a Jakarta XML Web Services runtime.
RespectBindingFeature	This feature clarifies the use of the wsdl:binding in a Jakarta XML Web Services runtime.
Response	Defines the contract between a returned instance and the runtime when an application needs to provide meta-data to the runtime.
Response<T>	The Response interface provides methods used to obtain the payload and context of a message sent in response to an operation invocation.
Response.ResponseBuilder	A class used to build Response instances that contain metadata instead of or in addition to an entity.
Response.Status	Commonly used status codes defined by HTTP, see HTTP/1.1 documentation for the complete list.
Response.Status.Family	An enumeration representing the class of status code.
Response.StatusType	Base interface for statuses used in responses.
ResponseProcessingException	JAX-RS client-side runtime processing exception thrown to indicate that response processing has failed (e.g.
ResponseStateManager	ResponseStateManager is the helper class to StateManager that knows the specific rendering technology being used to generate the response.
ResponseStream	ResponseStream is an interface describing an adapter to an underlying output mechanism for binary output.
ResponseWrapper	Used to annotate methods in the Service Endpoint Interface with the response wrapper bean to be used at runtime.
ResponseWriter	ResponseWriter is an abstract class describing an adapter to an underlying output mechanism for character-based output.
ResponseWriterWrapper	Provides a simple implementation of ResponseWriter that can be subclassed by developers wishing to provide specialized behavior to an existing ResponseWriter instance.
Result	This interface represents the result of a <sql:query> action.
ResultSet	A ResultSet represents tabular data that is retrieved from an EIS instance by the execution of an Interaction..
ResultSetDataModel	ResultSetDataModel is a convenience implementation of DataModel that wraps a ResultSet of Java objects.
ResultSetInfo	The interface jakarta.resource.cci.ResultSetInfo provides information on the support provided for ResultSet by a connected EIS instance.
ResultSupport	Supports the creation of a jakarta.servlet.jsp.jstl.sql.Result object from a source java.sql.ResultSet object.
RetryableException	A marker interface indicating that the Exception is transient.
RetryableUnavailableException	A subclass of the UnavailableException that indicates that the rejection of the work submission is transient.
RetryableWorkRejectedException	A subclass of the WorkRejectedException that indicates that the the service unavailability is transient.
RetryProcessListener	RetryProcessListener intercepts retry processing for an ItemProcessor.
RetryReadListener	RetryReadListener intercepts retry processing for an ItemReader.
RetryWriteListener	RetryWriteListener intercepts retry processing for an ItemWriter.
ReturnBuilder	Create a return node in the current Flow.
ReturnNode	Represents a return node in the flow graph.
ReturnValueDescriptor	Describes a validated return value of a method or constructor.
RolesAllowed	Specifies the list of security roles permitted to access method(s) in an application.
RollbackException	Thrown by the persistence provider when EntityTransaction.commit() fails.
RollbackException	RollbackException exception is thrown when the transaction has been marked for rollback only or the transaction has been rolled back instead of committed.
Root<X>	A root type in the from clause.
RunAs	Defines the identity of the application during execution.
RuntimeDelegate	Implementations of JAX-RS provide a concrete subclass of RuntimeDelegate and various JAX-RS API methods defer to methods of RuntimeDelegate for their functionality.
RuntimeDelegate.HeaderDelegate<T>	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.
RuntimeType	Enumeration of JAX-RS runtime types.
RxInvoker<T>	Uniform interface for reactive invocation of HTTP methods.
RxInvokerProvider<T extends RxInvoker>	RxInvoker provider.
SAAJMetaFactory	The access point for the implementation classes of the factories defined in the SAAJ API.
SAAJResult	Acts as a holder for the results of a JAXP transformation or a JAXB marshalling, in the form of a SAAJ tree.
ScalarDataModel<E>	ScalarDataModel is a convenience implementation of DataModel that wraps an individual Java object.
ScannedClasses	Allows adding additional classes to the set of types discovered during type discovery.
Schedule	Schedule a timer for automatic creation with a timeout schedule based on a cron-like time expression.
ScheduleExpression	A calendar-based timeout expression for an enterprise bean timer.
Schedules	Applied to a timer callback method to schedule multiple calendar-based timers for the method.
SchemaOutputResolver	Controls where a Jakarta XML Binding implementation puts the generates schema files.
Scope	Identifies scope annotations.
Scope
Scope	Scope looked at when discovering constraints.
ScopeContext	A structure that contains the name of the scope and the scope itself exposed as a Map<String, Object>.
ScopedAttributeELResolver	Defines variable resolution behavior for scoped attributes.
ScopeInfo	A scope of a bean.
ScriptFreeTLV	A TagLibraryValidator for enforcing restrictions against the use of JSP scripting elements.
SearchException	The exception thrown when a Search expression could not be handled.
SearchExpressionContext	A context object that is used to hold state relating to resolve a search expression.
SearchExpressionContextFactory	Provide for separation of interface and implementation for the SearchExpressionContext contract.
SearchExpressionHandler	The SearchExpressionHandler is responsible for resolving search expression(s)
SearchExpressionHandlerWrapper	Provides a simple implementation of SearchExpressionHandler that can be subclassed by developers wishing to provide specialized behavior to an existing SearchExpressionHandler instance.
SearchExpressionHint	An enum that specifies hints that impact the behavior of a component tree search.
SearchKeywordContext	SearchKeywordContext provides context information that may be useful to SearchKeywordResolver.resolve(jakarta.faces.component.search.SearchKeywordContext, jakarta.faces.component.UIComponent, java.lang.String) implementations.
SearchKeywordResolver	A SearchKeywordResolver is responsible for resolving a single keyword.
SearchTerm	Search criteria are expressed as a tree of search-terms, forming a parse-tree for the search expression.
SeBootstrap	Bootstrap class used to startup a JAX-RS application in Java SE environments.
SeBootstrap.Configuration	Provides information needed by the JAX-RS implementation for bootstrapping an application.
SeBootstrap.Configuration.Builder	Builder for bootstrap SeBootstrap.Configuration.
SeBootstrap.Configuration.SSLClientAuthentication	Secure socket client authentication policy
SeBootstrap.Instance	Handle of the running application instance.
SeBootstrap.Instance.StopResult	Result of stopping the application instance.
SecondaryTable	Specifies a secondary table for the annotated entity class.
SecondaryTables	Specifies multiple secondary tables for an entity.
SeContainer	Provides access to the current container in Java SE.
SeContainerInitializer	A CDI container initializer for Java SE.
SecretKeyCallback	Callback for acquiring a shared secret from a key repository.
SecretKeyCallback.AliasRequest	Request type for secret keys that are identified using an alias.
SecretKeyCallback.Request	Marker interface for secret key request types.
SecurityContext	A standard WorkContext that allows a Work instance to propagate security related context information from an EIS to an application server.
SecurityContext	The SecurityContext provides an access point for programmatic security; an injectable type that is intended to be used by application code to query and interact with Jakarta Security.
SecurityContext	An injectable interface that provides access to security related information.
SecurityException	A SecurityException indicates error conditions related to the security contract between an application server and resource adapter.
SecurityPermission	The SecurityPermission annotation can be used by the developer, as part of the Connector annotation, to specify the extended security permissions required by the resource adapter
Selection<X>	The Selection interface defines an item that is to be returned in a query result.
SelectItem	SelectItem represents a single item in the list of supported items associated with a UISelectMany or UISelectOne component.
SelectItemGroup	SelectItemGroup is a subclass of SelectItem that identifies a set of options that will be made available as a subordinate "submenu" or "options list", depending upon the requirements of the UISelectMany or UISelectOne renderer that is actually used.
SendFailedException	This exception is thrown when the message cannot be sent.
SendHandler	A simple callback object for asynchronous sending of web socket messages.
SendResult	The result of asynchronously sending a web socket message.
SentDateTerm	This class implements comparisons for the Message SentDate.
SequenceGenerator	Defines a primary key generator that may be referenced by name when a generator element is specified for the GeneratedValue annotation.
SequenceGenerators	Used to group SequenceGenerator annotations.
SerializationContext	Provides JSONB internals for custom serializers.
ServerApplicationConfig	Developers include implementations of ServerApplicationConfig in an archive containing websocket endpoints (WAR file, or JAR file within the WAR file) in order to specify the websocket endpoints within the archive the implementation must deploy.
ServerAuth	An implementation of this interface is used to validate received service request messages, and to secure service response messages.
ServerAuthConfig	This interface describes a configuration of ServerAuthConfiguration objects for a message layer and application context (for example, the messaging context of a specific application, or set of applications).
ServerAuthContext	This ServerAuthContext class encapsulates ServerAuthModules that are used to validate service requests received from clients, and to secure any response returned for those requests.
ServerAuthModule	A ServerAuthModule validates client requests and secures responses to the client.
ServerContainer	The ServerContainer is the specialized view of the WebSocketContainer available in server-side deployments.
ServerEndpoint	This class level annotation declares that the class it decorates is a web socket endpoint that will be deployed and made available in the URI-space of a web socket server.
ServerEndpointConfig	The ServerEndpointConfig is a special kind of endpoint configuration object that contains web socket configuration information specific only to server endpoints.
ServerEndpointConfig.Builder	The ServerEndpointConfig.Builder is a class used for creating ServerEndpointConfig.Builder objects for the purposes of deploying a server endpoint.
ServerEndpointConfig.Configurator	The ServerEndpointConfig.Configurator class may be extended by developers who want to provide custom configuration algorithms, such as intercepting the opening handshake, or providing arbitrary methods and algorithms that can be accessed from each endpoint instance configured with this configurator.
ServerErrorException	A base runtime application exception indicating a server error (HTTP 5xx status codes).
ServerSession	A ServerSession object is an application server object that is used by a server to associate a thread with a Jakarta Messaging session (optional).
ServerSessionPool	A ServerSessionPool object is an object implemented by an application server to provide a pool of ServerSession objects for processing the messages of a ConnectionConsumer (optional).
Service	An abstract class that contains the functionality common to messaging services, such as stores and transports.
Service	Service objects provide the client view of a Web service.
Service.Mode	The orientation of a dynamic client or service.
ServiceDelegate	Service delegates are used internally by Service objects to allow pluggability of Jakarta XML Web Services implementations.
ServiceMode	Used to indicate whether a Provider implementation wishes to work with entire protocol messages or just with protocol message payloads.
ServiceUnavailableException	A runtime exception indicating that the requested resource cannot be served.
Servlet	Defines methods that all servlets must implement.
ServletConfig	A servlet configuration object used by a servlet container to pass information to a servlet during initialization.
ServletConnection	Provides information about the connection made to the Servlet container.
ServletContainerInitializer	Interface which allows a library/runtime to be notified of a web application's startup phase and perform any required programmatic registration of servlets, filters, and listeners in response to it.
ServletContext	Defines a set of methods that a servlet uses to communicate with its servlet container, for example, to get the MIME type of a file, dispatch requests, or write to a log file.
ServletContextAttributeEvent	Event class for notifications about changes to the attributes of the ServletContext of a web application.
ServletContextAttributeListener	Interface for receiving notification events about ServletContext attribute changes.
ServletContextEvent	This is the event class for notifications about changes to the servlet context of a web application.
ServletContextListener	Interface for receiving notification events about ServletContext lifecycle changes.
ServletException	Defines a general exception a servlet can throw when it encounters difficulty.
ServletInputStream	Provides an input stream for reading binary data from a client request, including an efficient readLine method for reading data one line at a time.
ServletOutputStream	Provides an output stream for sending binary data to the client.
ServletRegistration	Interface through which a Servlet may be further configured.
ServletRegistration.Dynamic	Interface through which a Servlet registered via one of the addServlet methods on ServletContext may be further configured.
ServletRequest	Defines an object to provide client request information to a servlet.
ServletRequestAttributeEvent	This is the event class for notifications of changes to the attributes of the servlet request in an application.
ServletRequestAttributeListener	Interface for receiving notification events about ServletRequest attribute changes.
ServletRequestEvent	Events of this kind indicate lifecycle events for a ServletRequest.
ServletRequestListener	Interface for receiving notification events about requests coming into and going out of scope of a web application.
ServletRequestWrapper	Provides a convenient implementation of the ServletRequest interface that can be subclassed by developers wishing to adapt the request to a Servlet.
ServletResponse	Defines an object to assist a servlet in sending a response to the client.
ServletResponseWrapper	Provides a convenient implementation of the ServletResponse interface that can be subclassed by developers wishing to adapt the response from a Servlet.
ServletSecurity	This annotation is used on a Servlet implementation class to specify security constraints to be enforced by a Servlet container on HTTP protocol messages.
ServletSecurity.EmptyRoleSemantic	Defines the access semantic to be applied to an empty rolesAllowed array.
ServletSecurity.TransportGuarantee	Defines the data protection requirements that must be satisfied by the transport
ServletSecurityElement	Java Class representation of a ServletSecurity annotation value.
Session	A Session object is a single-threaded context for producing and consuming messages.
Session	The Session class represents a mail session and is not subclassed.
Session	A Web Socket session represents a conversation between two web socket endpoints.
SessionBean	The SessionBean interface defines methods that the enterprise bean container uses to notify a session bean instance of the instance's life cycle events.
SessionBeanType	Identifies the kind of EJB session bean.
SessionContext	The SessionContext interface provides access to the runtime session context that the container provides for a session bean instance.
SessionCookieConfig	Class that may be used to configure various properties of cookies used for session tracking purposes.
SessionException	A SessionException represents a general exception type reporting problems occurring on a websocket session.
SessionMap	The presence of this annotation (along with @Inject) on a field of type Map<String, Object> causes the map returned from ExternalContext.getSessionMap() to be injected as the value of that field.
SessionMap.Literal	Supports inline instantiation of the SessionMap qualifier.
SessionScoped	Specifies that a bean is session scoped.
SessionScoped.Literal	Supports inline instantiation of the SessionScoped annotation.
SessionSynchronization	The SessionSynchronization interface allows a stateful session bean instance to be notified by its container of transaction boundaries.
SessionTrackingMode	Enumeration of session tracking modes.
SetAttribute<X,E>	Instances of the type SetAttribute represent persistent java.util.Set-valued attributes.
SetJoin<Z,E>	The SetJoin interface is the type of the result of joining to a collection over an association or element collection that has been specified as a java.util.Set.
SharedByteArrayInputStream	A ByteArrayInputStream that implements the SharedInputStream interface, allowing the underlying byte array to be shared between multiple readers.
SharedCacheMode	Specifies how the provider must use a second-level cache for the persistence unit.
SharedFileInputStream	A SharedFileInputStream is a BufferedInputStream that buffers data from the file and supports the mark and reset methods.
SharedInputStream	An InputStream that is backed by data that can be shared by multiple readers may implement this interface.
SharingViolationException	This is thrown to indicate a connection sharing violation.
ShortConverter	Converter implementation for java.lang.Short (and short primitive) values.
Shutdown	A CDI event with payload of type Shutdown and qualifier Any is synchronously fired by CDI container during application shutdown.
SimpleTag	Interface for defining Simple Tag Handlers.
SimpleTagSupport	A base class for defining tag handlers implementing SimpleTag.
Singleton	Component-defining annotation for a singleton session bean.
Singleton	Identifies a type that the injector only instantiates once.
SingletonLiteral	Supports inline instantiation of the Singleton annotation.
SingularAttribute<X,T>	Instances of the type SingularAttribute represents persistent single-valued properties or fields.
Size	The annotated element size must be between the specified boundaries (included).
Size.List	Defines several Size annotations on the same element.
SizeTerm	This class implements comparisons for Message sizes.
SkipIfPortableExtensionPresent	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.
SkipPageException	Exception to indicate the calling page must cease evaluation.
SkippedException	Exception indicating that the result of a value-producing task cannot be retrieved because the task run was skipped.
SkipProcessListener	SkipProcessListener intercepts skippable itemProcess exception handling.
SkipReadListener	SkipReadListener intercepts skippable itemReader exception handling.
SkipWriteListener	SkipWriteListener intercepts skippable itemWriter exception handling.
SOAPBinding	Specifies the mapping of the Web Service onto the SOAP message protocol.
SOAPBinding	The SOAPBinding interface is an abstraction for the SOAP binding.
SOAPBinding.ParameterStyle	The style of mapping parameters onto SOAP messages
SOAPBinding.Style	The SOAP binding style
SOAPBinding.Use	The SOAP binding use
SOAPBody	An object that represents the contents of the SOAP body element in a SOAP message.
SOAPBodyElement	A SOAPBodyElement object represents the contents in a SOAPBody object.
SOAPConnection	A point-to-point connection that a client can use for sending messages directly to a remote party (represented by a URL, for instance).
SOAPConnectionFactory	A factory for creating SOAPConnection objects.
SOAPConstants	The definition of constants pertaining to the SOAP protocol.
SOAPElement	An object representing an element of a SOAP message that is allowed but not specifically prescribed by a SOAP specification.
SOAPEnvelope	The container for the SOAPHeader and SOAPBody portions of a SOAPPart object.
SOAPException	An exception that signals that a SOAP exception has occurred.
SOAPFactory	SOAPFactory is a factory for creating various objects that exist in the SOAP XML tree.
SOAPFault	An element in the SOAPBody object that contains error and/or status information.
SOAPFaultElement	A representation of the contents in a SOAPFault object.
SOAPFaultException	The SOAPFaultException exception represents a SOAP 1.1 or 1.2 fault.
SOAPHandler<T extends SOAPMessageContext>	The SOAPHandler class extends Handler to provide typesafety for the message context parameter and add a method to obtain access to the headers that may be processed by the handler.
SOAPHeader	A representation of the SOAP header element.
SOAPHeaderElement	An object representing the contents in the SOAP header part of the SOAP envelope.
SOAPMessage	The root class for all SOAP messages.
SOAPMessageContext	The interface SOAPMessageContext provides access to the SOAP message for either RPC request or response.
SOAPMessageHandler	Deprecated.
SOAPMessageHandlers	Deprecated. As of JSR-181 2.0 with no replacement.
SOAPPart	The container for the SOAP-specific portion of a SOAPMessage object.
Specializes	Indicates that a bean directly specializes another bean.
Specializes.Literal	Supports inline instantiation of the Specializes annotation.
SQLExecutionTag	This interface allows tag handlers implementing it to receive values for parameter markers in their SQL statements.
SqlResultSetMapping	Specifies the mapping of the result of a native SQL query or stored procedure.
SqlResultSetMappings	Is used to define one or more SqlResultSetMapping annotations.
Sse	Server-side entry point for creating OutboundSseEvent and SseBroadcaster.
SseBroadcaster	Server-Sent events broadcasting facility.
SseEvent	Base Server Sent Event definition.
SseEventSink	Outbound Server-Sent Events stream.
SseEventSource	Client for reading and processing incoming Server-Sent Events.
SseEventSource.Builder	JAX-RS SseEventSource builder class.
StandardELContext	A standard ELContext suitable for use in a stand alone environment.
Startup	Mark a singleton bean for eager initialization during the application startup sequence.
Startup	A CDI event with payload of type Startup and qualifier Any is synchronously fired by CDI container during application initialization.
Stateful	Component-defining annotation for a stateful session bean.
StatefulTimeout	Specifies the amount of time a stateful session bean can be idle (not receive any client invocations) before it is eligible for removal by the container.
StateHelper	Define a Map-like contract that makes it easier for components to implement PartialStateHolder.
StateHolder	This interface is implemented by classes that need to save their state between requests.
Stateless	Component-defining annotation for a stateless session bean.
StateManagementStrategy	Encapsulate the saving and restoring of the view to enable the VDL to take over the responsibility for handling this feature.
StateManager	StateManager directs the process of saving and restoring the view between requests.
StateManagerWrapper	Provides a simple implementation of StateManager that can be subclassed by developers wishing to provide specialized behavior to an existing StateManager instance.
StaticFieldELResolver	An ELResolver for resolving static fields, enum constants and static methods.
StaticMetamodel	The StaticMetamodel annotation specifies that the class is a metamodel class that represents the entity, mapped superclass, or embeddable class designated by the value element.
Status	The Status interface defines static variables used for transaction status codes.
StepContext	A StepContext provides information about the current step of a job execution.
StepExecution	Provides a view of a step execution to the JobOperator.
StepListener	StepListener intercepts step execution.
Stereotype	Specifies that an annotation type is a stereotype.
StereotypeInfo	A stereotype.
Store	An abstract class that models a message store and its access protocol, for storing and retrieving messages.
StoreClosedException	This exception is thrown when a method is invoked on a Messaging object and the Store that owns that object has died due to some reason.
StoredProcedureParameter	Specifies a parameter of a named stored procedure query.
StoredProcedureQuery	Interface used to control stored procedure query execution.
StoreEvent	This class models notifications from the Store connection.
StoreListener	This is the Listener interface for Store Notifications.
Streamable	Streamable interface enables a resource adapter to extract data from an input Record or set data into an output Record as a stream of bytes.
StreamingOutput	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.
StreamMessage	A StreamMessage object is used to send a stream of primitive types in the Java programming language.
StreamProvider	Service lookup is used to find implementations of this interface.
StreamProvider.EncoderTypes	Enumeration with the different encoder types supported by the Mail API.
StringTerm	This class implements the match method for Strings.
Subgraph<T>	This type represents a subgraph for an attribute node that corresponds to a Managed Type.
SubjectTerm	This class implements comparisons for the message Subject header.
Subquery<T>	The Subquery interface defines functionality that is specific to subqueries.
SupportedValidationTarget	Defines the target(s) a ConstraintValidator can validate.
Suspended	Inject a suspended AsyncResponse into a parameter of an invoked JAX-RS resource or sub-resource method.
SwitchBuilder	Create a switch node in the current Flow.
SwitchCase	Represents a case within a switch node in the flow graph.
SwitchCaseBuilder	Create a case in the current switch.
SwitchNode	Represents a switch node in the flow graph.
Synchronization	The transaction manager supports a synchronization mechanism that allows the interested party to be notified before and after the transaction completes.
SynchronizationType	Specifies whether the persistence context is always automatically synchronized with the current transaction or whether the persistence context must be explicitly joined to the current transaction by means of the EntityManager.joinTransaction() method.
SyncInvoker	Uniform interface for synchronous invocation of HTTP methods.
Synthesis	4th phase of build compatible extension execution.
SyntheticBeanBuilder<T>	Builder for synthetic beans.
SyntheticBeanCreator<T>	Creation function for a synthetic bean defined by SyntheticBeanBuilder.
SyntheticBeanDisposer<T>	Destruction function for a synthetic bean defined by SyntheticBeanBuilder.
SyntheticComponents	Allows registering synthetic beans and observers.
SyntheticObserver<T>	The event notification function for a synthetic observer defined by SyntheticObserverBuilder.
SyntheticObserverBuilder<T>	Builder for synthetic observers.
SystemEvent	SystemEvent is the base class for non-application specific events that can be fired by arbitrary objects.
SystemEventListener	By implementing this class, an object indicates that it is a listener for one or more kinds of SystemEvents.
SystemEventListenerHolder	Classes that implement this interface agree to maintain a list of SystemEventListener instances for each kind of SystemEvent they can generate.
SystemException	The SystemException is thrown by the transaction manager to indicate that it has encountered an unexpected error condition that prevents future transaction services from proceeding.
Table	Specifies the primary table for the annotated entity.
TableGenerator	Defines a primary key generator that may be referenced by name when a generator element is specified for the GeneratedValue annotation.
TableGenerators	Used to group TableGenerator annotations.
Tag	The runtime must create an instance of this class for each element in the Facelets XHTML view.
Tag	The interface of a classic tag handler that does not want to manipulate its body.
TagAdapter	Wraps any SimpleTag and exposes it using a Tag interface.
TagAttribute	Representation of an XML attribute name=value pair on an XML element in a Facelet file.
TagAttributeException	An Exception caused by a TagAttribute
TagAttributeInfo	Information on the attributes of a Tag, available at translation time.
TagAttributes	A set of TagAttributes, usually representing all attributes on a Tag.
TagConfig	Passed to the constructor of TagHandler subclass, it defines the document definition of the handler we are instantiating.
TagData	The (translation-time only) attribute/value information for a tag instance.
TagDecorator	Provides the ability to completely change the Tag before it's processed for compiling with the associated TagHandler.
TagException	An Exception caused by a Tag
TagExtraInfo	Optional class provided by the tag library author to describe additional translation-time information not described in the TLD.
TagFileInfo	Tag information for a tag file in a Tag Library; This class is instantiated from the Tag Library Descriptor file (TLD) and is available only at translation time.
TagHandler	Foundation class for FaceletHandlers associated with a markup element in a Facelet document.
TagHandlerDelegate	Abstract class that defines methods relating to helping tag handler instances.
TagHandlerDelegateFactory	Abstract factory for creating instances of TagHandlerDelegate.
TagInfo	Tag information for a tag in a Tag Library; This class is instantiated from the Tag Library Descriptor file (TLD) and is available only at translation time.
TaglibDescriptor	This interface provides access to the <taglib> related configuration of a web application.
TagLibraryInfo	Translation-time information associated with a taglib directive, and its underlying TLD file.
TagLibraryValidator	Translation-time validator class for a JSP page.
TagSupport	A base class for defining new tag handlers implementing Tag.
TagVariableInfo	Variable information for a tag in a Tag Library; This class is instantiated from the Tag Library Descriptor file (TLD) and is available only at translation time.
Temporal	This annotation must be specified for persistent fields or properties of type java.util.Date and java.util.Calendar.
TemporalType	Type used to indicate a specific mapping of java.util.Date or java.util.Calendar.
TemporaryQueue	A TemporaryQueue object is a unique Queue object created for the duration of a Connection.
TemporaryTopic	A TemporaryTopic object is a unique Topic object created for the duration of a Connection.
Text	A representation of a node whose value is text.
TextHandler	An interface that allows other code to identify FaceletHandlers that may provide text (String) content.
TextMessage	A TextMessage object is used to send a message containing a java.lang.String.
ThreadContextProvider	Third party providers of thread context implement this interface to participate in thread context capture and propagation.
ThreadContextRestorer	Restores the prior context on a thread after a contextual task or action completes.
ThreadContextSnapshot	An immutable snapshot of a particular type of thread context.
TimedObject	The TimedObject interface contains a callback method that is used to deliver timer expiration notifications.
Timeout	Designates a method on a stateless session bean class, a singleton session bean class, a message driven bean class, or an enterprise bean 2.x entity bean class that should receive enterprise bean timer expirations for that bean.
TimeoutHandler	Asynchronous response suspend time-out handler.
Timer	The Timer interface contains information about a timer that was created through the enterprise bean Timer Service.
TimerConfig	TimerConfig is used to specify additional timer configuration settings during timer creation.
TimerHandle	The TimerHandle interface allows the bean provider to obtain a serializable timer handle that may be persisted.
TimerService	The TimerService interface provides enterprise bean components with access to the container-provided Timer Service.
Topic	A Topic object encapsulates a provider-specific topic name.
TopicConnection	A TopicConnection object is an active connection to a publish/subscribe Jakarta Messaging provider.
TopicConnectionFactory	A client uses a TopicConnectionFactory object to create TopicConnection objects with a publish/subscribe Jakarta Messaging provider.
TopicPublisher	A client uses a TopicPublisher object to publish messages on a topic.
TopicRequestor	The TopicRequestor helper class simplifies making service requests.
TopicSession	A TopicSession object provides methods for creating TopicPublisher, TopicSubscriber, and TemporaryTopic objects.
TopicSubscriber	A client uses a TopicSubscriber object to receive messages that have been published to a topic.
Transaction	The Transaction interface allows operations to be performed against the transaction in the target Transaction object.
Transactional	The jakarta.transaction.Transactional annotation provides the application the ability to declaratively control transaction boundaries on CDI managed beans, as well as classes defined as managed beans by the Jakarta EE specification, at both the class and method level where method level annotations override those at the class level.
Transactional.TxType	The TxType element of the annotation indicates whether a bean method is to be executed within a transaction context where the values provide the following corresponding behavior.
TransactionalException	The TransactionalException thrown from the Transactional interceptors implementation contains the original exception as its nested exception and is a RuntimeException, therefore, by default any transaction that was started as a result of a Transactional annotation earlier in the call stream will be marked for rollback as a result of the TransactionalException being thrown by the Transactional interceptor of the second bean.
TransactionAttribute	The TransactionAttribute annotation specifies whether the container is to invoke a business method within a transaction context.
TransactionAttributeType	The enum TransactionAttributeType is used with the TransactionAttribute annotation to specify whether the methods of a session bean or message driven bean are called with a valid transaction context.
TransactionContext	A standard WorkContext that allows a Work instance to propagate transaction related context information from an EIS to an application server.
TransactionInProgressException	This exception is thrown when an operation is invalid because a transaction is in progress.
TransactionInProgressRuntimeException	This unchecked exception is thrown when an operation is invalid because a transaction is in progress.
TransactionManagement	Specifies whether a session bean or message driven bean has container managed transactions or bean managed transactions.
TransactionManagementType	The enum TransactionManagementType is used with the TransactionManagement annotation to specify whether container-managed or bean-managed transaction management is used.
TransactionManager	The TransactionManager interface defines the methods that allow an application server to manage transaction boundaries.
TransactionPhase	Distinguishes the various kinds of transactional observer methods from regular observer methods which are notified immediately.
TransactionRequiredException	Thrown by the persistence provider when a transaction is required but is not active.
TransactionRequiredException	This exception indicates that a request carried a null transaction context, but the target object requires an active transaction.
TransactionRequiredLocalException	This exception is thrown to a local client to indicate that a request carried a null transaction context, but the target object requires an active transaction.
TransactionRolledbackException	This exception indicates that the transaction associated with processing of the request has been rolled back, or it has been marked to roll back.
TransactionRolledBackException	This exception must be thrown when a call to Session.commit results in a rollback of the current transaction.
TransactionRolledbackLocalException	This exception is thrown to a local client to indicate that the transaction associated with processing of the request has been rolled back, or marked to roll back.
TransactionRolledBackRuntimeException	This unchecked exception must be thrown when a call to JMSContext.commit results in a rollback of the current transaction.
TransactionScoped	The jakarta.transaction.TransactionScoped annotation provides the ability to specify a standard CDI scope to define bean instances whose lifecycle is scoped to the currently active Jakarta Transactions transaction.
TransactionSupport	This interface may be optionally implemented by a ManagedConnectionFactory to provide its level of transaction support at runtime.
TransactionSupport.TransactionSupportLevel	An enumerated type that represents the levels of transaction support a resource adapter may support.
TransactionSynchronizationRegistry	This interface is intended for use by system level application server components such as persistence managers, resource adapters, as well as Jakarta Enterprise Beans and Web application components.
TransformerException	Thrown by the persistence provider when a problem during class re-definition occurs.
Transient	Specifies that the property or field is not persistent.
TransientReference	If a parameter annotated with @TransientReference resolves to a dependent scoped bean, then the bean will be destroyed after the invocation completes.
TransientReference.Literal	Supports inline instantiation of the TransientReference annotation.
TransientStateHelper	Define a Map-like contract that makes it easier for components to implement TransientStateHolder.
TransientStateHolder	This interface is implemented by classes that need to save state that is expected to be available only within the scope of the current request.
Transport	An abstract class that models a message transport.
TransportAdapter	The adapter which receives Transport events.
TransportEvent	This class models Transport events.
TransportListener	This is the Listener interface for Transport events
TraversableResolver	Contract determining if a property can be accessed by the Jakarta Bean Validation provider.
Trigger	Triggers allow application developers to plug in rules for when and how often a task should run.
TrustStoreCallback	Callback for trusted certificate KeyStore.
TryCatchFinally	The auxiliary interface of a Tag, IterationTag or BodyTag tag handler that wants additional hooks for managing resources.
Tuple	Interface for extracting the elements of a query result tuple.
TupleElement<X>	The TupleElement interface defines an element that is returned in a query result tuple.
Type	A type is used in a program source code, but does not have to be declared anywhere.
Type<X>	Instances of the type Type represent persistent object or attribute types.
Type.Kind
Type.PersistenceType
TypeConstraintException	This exception indicates that a violation of a dynamically checked type constraint was detected.
TypeConverter	A convenient class for writing an ELResolver to do custom type conversions.
Typed	Restricts the bean types of a bean.
Typed.Literal	Supports inline instantiation of the Typed annotation.
TypedQuery<X>	Interface used to control the execution of typed queries.
TypeLiteral<T>	Supports inline instantiation of objects that represent parameterized types with actual type parameters.
Types	Factory for types.
TypeVariable	Type variables represent type parameters declared on generic classes or methods.
UIColumn	UIColumn is a UIComponent that represents a single column of data within a parent UIData component.
UICommand	UICommand is a UIComponent that represents a user interface component which, when activated by the user, triggers an application specific "command" or "action".
UIComponent	UIComponent is the base class for all user interface components in Jakarta Server Faces.
UIComponentBase	UIComponentBase is a convenience base class that implements the default concrete behavior of all methods defined by UIComponent.
UIData	UIData is a UIComponent that supports data binding to a collection of data objects represented by a DataModel instance, which is the current value of this component itself (typically established via a ValueExpression).
UIDFolder	The UIDFolder interface is implemented by Folders that can support the "disconnected" mode of operation, by providing unique-ids for messages in the folder.
UIDFolder.FetchProfileItem	A fetch profile item for fetching UIDs.
UIForm	UIForm is a UIComponent that represents an input form to be presented to the user, and whose child components represent (among other things) the input fields to be included when the form is submitted.
UIGraphic	UIGraphic is a UIComponent that displays a graphical image to the user.
UIImportConstants
UIInput	UIInput is a UIComponent that represents a component that both displays output to the user (like UIOutput components do) and processes request parameters on the subsequent request that need to be decoded.
UIMessage	This component is responsible for displaying messages for a specific UIComponent, identified by a clientId or component id relative to the closest ancestor NamingContainer.
UIMessages	The renderer for this component is responsible for obtaining the messages from the FacesContext and displaying them to the user.
UINamingContainer	UINamingContainer is a convenience base class for components that wish to implement NamingContainer functionality.
UIOutcomeTarget	This component is paired with the jakarta.faces.Button or jakarta.faces.Link renderers and encapsulates properties relating to the rendering of outcomes directly to the response.
UIOutput	UIOutput is a UIComponent that has a value, optionally retrieved from a model tier bean via a value expression, that is displayed to the user.
UIPanel	UIPanel is a UIComponent that manages the layout of its child components.
UIParameter	UIParameter is a UIComponent that represents an optionally named configuration parameter for a parent component.
UISelectBoolean	UISelectBoolean is a UIComponent that represents a single boolean (true or false) value.
UISelectItem	UISelectItem is a component that may be nested inside a UISelectMany or UISelectOne component, and causes the addition of a SelectItem instance to the list of available options for the parent component.
UISelectItemGroup	UISelectItemGroup is a component that may be nested inside a UISelectMany or UISelectOne component, and causes the addition of one SelectItemGroup of one or more SelectItem instances to the list of available options in the parent component.
UISelectItemGroups	UISelectItemGroups is a component that may be nested inside a UISelectMany or UISelectOne component, and causes the addition of one or more SelectItemGroup of one or more SelectItem instances to the list of available options in the parent component.
UISelectItems	UISelectItems is a component that may be nested inside a UISelectMany or UISelectOne component, and causes the addition of one or more SelectItem instances to the list of available options in the parent component.
UISelectMany	UISelectMany is a UIComponent that represents the user's choice of a zero or more items from among a discrete set of available options.
UISelectOne	UISelectOne is a UIComponent that represents the user's choice of zero or one items from among a discrete set of available options.
UIViewAction	UIViewAction represents a method invocation that occurs during the request processing lifecycle, usually in response to an initial request, as opposed to a postback.
UIViewParameter	UIViewParameter represents a binding between a request parameter and a model property or UIViewRoot property.
UIViewParameter.Reference	Inner class to encapsulate a UIViewParameter instance so that it may be safely referenced regardless of whether or not the current view is the same as the view in which this UIViewParameter resides.
UIViewRoot	UIViewRoot is the UIComponent that represents the root of the UIComponent tree.
UIWebsocket	The <f:websocket> tag opens an one-way (server to client) websocket based push connection in client side which can be reached from server side via PushContext interface injected in any CDI/container managed artifact via @Push annotation.
UnavailableException	This is thrown to indicate that a service is unavailable.
UnavailableException	Defines an exception that a servlet or filter throws to indicate that it is permanently or temporarily unavailable.
UnexpectedTypeException	Exception raised in the case that the constraint validator resolution cannot determine a suitable validator for a given type.
UniqueConstraint	Specifies that a unique constraint is to be included in the generated DDL for a primary or secondary table.
UniqueIdVendor	UniqueIdVendor is an interface implemented by UIComponents that also implement NamingContainer so that they can provide unique ids based on their own clientId.
Unmanaged<T>	Helper class for injecting and calling lifecycle callbacks unmanaged instances for use by framework and library integrators.
Unmanaged.UnmanagedInstance<T>	Represents a non-contextual instance.
UnmarshalException	This exception indicates that an error has occurred while performing an unmarshal operation that prevents the Jakarta XML Binding Provider from completing the operation.
Unmarshaller	The Unmarshaller class governs the process of deserializing XML data into newly created Java content trees, optionally validating the XML data as it is unmarshalled.
Unmarshaller.Listener	Register an instance of an implementation of this class with Unmarshaller to externally listen for unmarshal events.
UnmarshallerHandler	Unmarshaller implemented as SAX ContentHandler.
UnproxyableResolutionException	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.
UnsatisfiedResolutionException	Indicates that no bean matches a certain combination of required type and required qualifiers and is eligible for injection into a certain class.
UnsupportedDataTypeException	Signals that the requested operation does not support the requested data type.
UntargetableComponent	Components implementing this interface are ignored by the algorithm - especially in the implementation of @child(n), @next and @previous.
UnwrapByDefault	Marks a ValueExtractor definition so that it is applied automatically when detecting constraints declared on the container type supported by the extractor, causing the constraints to be applied to the container's elements instead of the container.
Unwrapping	Set of interfaces used in the payload() of a constraint to indicate if a value should be unwrapped before validation.
Unwrapping.Skip	Skip the unwrapping if it has been enabled on the ValueExtractor by the UnwrapByDefault annotation.
Unwrapping.Unwrap	Unwrap the value before validation.
UpdateModelException	This exception indicates a failure to update the model and is created to wrap any exception that occurs during UIInput.updateModel(jakarta.faces.context.FacesContext).
UriBuilder	URI template-aware utility class for building URIs from their components.
UriBuilderException	A runtime exception thrown by UriBuilder.build(Object...) methods when a URI cannot be constructed based on the current state of the builder.
UriInfo	An injectable interface that provides access to application and request URI information.
URLDataSource	The URLDataSource class provides an object that wraps a URL object in a DataSource interface.
URLName	The name of a URL.
UsernamePasswordCredential	Represents the credentials typically used by standard caller name/password authentication.
UserTransaction	The UserTransaction interface defines the methods that allow an application to explicitly manage transaction boundaries.
Valid	Marks a property, method parameter or method return type for validation cascading.
ValidateOnExecution	Expresses which executables (methods or constructors) should have their parameters and return value validated upon execution.
ValidateUnwrappedValue	The unwrapping behavior that can be applied to a specific constraint.
ValidatingManagedConnectionFactory	This interface is implemented by a ManagedConnectionFactory instance that supports the ability to validate ManagedConnection objects.
Validation	5th phase of build compatible extension execution.
Validation	This class is the entry point for Jakarta Bean Validation.
ValidationEvent	This event indicates that a problem was encountered while validating the incoming XML data during an unmarshal operation, while performing on-demand validation of the Java content tree, or while marshalling the Java content tree back to XML data.
ValidationEventCollector	ValidationEventHandler implementation that collects all events.
ValidationEventHandler	A basic event handler interface for validation errors.
ValidationEventImpl	Default implementation of the ValidationEvent interface.
ValidationEventLocator	Encapsulate the location of a ValidationEvent.
ValidationEventLocatorImpl	Default implementation of the ValidationEventLocator interface.
ValidationException	Base exception of all Jakarta Bean Validation "unexpected" problems.
ValidationException	This exception indicates that an error has occurred while performing a validate operation.
ValidationMessage	A validation message from either TagLibraryValidator or TagExtraInfo.
ValidationMode	The validation mode to be used by the provider for the persistence unit.
ValidationProvider<T extends Configuration<T>>	Contract between the validation bootstrap mechanism and the provider engine.
ValidationProviderResolver	Determines the list of Jakarta Bean Validation providers available in the runtime environment
ValidationTarget	List of possible targets for a ConstraintValidator.
Validator<T>	A Validator implementation is a class that can perform validation (correctness checks) on a EditableValueHolder.
Validator	Validates bean instances.
ValidatorConfig	Used in creating ValidatorHandler and all implementations.
ValidatorContext	Represents the context that is used to create Validator instances.
ValidatorException	A ValidatorException is an exception thrown by the validate() method of a Validator to indicate that validation failed.
ValidatorFactory	Factory returning initialized Validator instances.
ValidatorHandler	Handles setting a Validator instance on an EditableValueHolder parent.
ValueChangeEvent	A ValueChangeEvent is a notification that the local value of the source component has been change as a result of user interface activity.
ValueChangeListener	A listener interface for receiving ValueChangeEvents.
ValueExpression	An Expression that can get or set a value.
ValueExtractor<T>	Defines the logic used to extract the values from a container object of type T.
ValueExtractor.ValueReceiver	Provides a set of methods receiving value extracted by the ValueExtractor.
ValueExtractorDeclarationException	Raised if the configuration of ValueExtractor is illegal, e.g.
ValueExtractorDefinitionException	Raised if a ValueExtractor definition is illegal, e.g.
ValueHolder	ValueHolder is an interface that may be implemented by any concrete UIComponent that wishes to support a local value, as well as access data in the model tier via a value expression, and support conversion between String and the model tier data's native data type.
ValueHolderAttachedObjectHandler	A VDL handler that exposes Converter to a page author.
ValueHolderAttachedObjectTarget	A marker interface for VDL tags that represent <composite:valueHolder/> for use by the composite component page author.
ValueReference	This encapsulates a base model object and one of its properties.
VariableInfo	Information on the scripting variables that are created/modified by a tag (at run-time).
VariableMapper	The interface to a map between Jakarta Expression Language variables and the Jakarta Expression Language expressions they are associated with.
VariableResolver	Deprecated. As of JSP 2.1, replaced by ELResolver
Variant	Abstraction for a resource representation variant.
Variant.VariantListBuilder	A builder for a list of representation variants.
Version	Specifies the version field or property of an entity class that serves as its optimistic lock value.
Vetoed	Veto the processing of the class.
Vetoed.Literal	Supports inline instantiation of the Vetoed annotation.
View	The presence of this annotation on a target (type, method, parameter or field) within an application is used to indicate that this target is somehow handling a Faces View Id or Ids.
View.Literal	Supports inline instantiation of the View annotation.
ViewBuilder	Create a view node in the current Flow.
ViewDeclarationLanguage	The contract that a view declaration language must implement to interact with the Jakarta Faces runtime.
ViewDeclarationLanguageFactory	ViewDeclarationLanguageFactory is a factory object that creates (if needed) and returns a new ViewDeclarationLanguage instance based on the VDL found in a specific view.
ViewDeclarationLanguageWrapper	Provides a simple implementation of ViewDeclarationLanguage that can be subclassed by developers wishing to provide specialized behavior to an existing ViewDeclarationLanguage instance.
ViewExpiredException	Implementations must throw this FacesException when attempting to restore the view StateManagementStrategy.restoreView(FacesContext, String, String) results in failure on postback.
ViewHandler	ViewHandler is the pluggablity mechanism for allowing implementations of or applications using the Jakarta Faces Specification to provide their own handling of the activities in the Render Response and Restore View phases of the request processing lifecycle.
ViewHandlerWrapper	Provides a simple implementation of ViewHandler that can be subclassed by developers wishing to provide specialized behavior to an existing ViewHandler instance.
ViewMap	The presence of this annotation (along with @Inject) on a field of type Map<String, Object> causes the map returned from UIViewRoot.getViewMap() to be injected as the value of that field.
ViewMap.Literal	Supports inline instantiation of the ViewMap qualifier.
ViewMapListener	Marker interface for SystemEvents that indicate the view map has been created (PostConstructViewMapEvent, or destroyed (PreDestroyViewMapEvent).
ViewMetadata	ViewMetadata is reponsible for extracting and providing view parameter metadata from VDL views.
ViewNode	ViewNode is the class that represents a VDL view in a faces flow graph.
ViewResource	Superclass of Resource that is only for use with views.
ViewScoped	When this annotation, along with jakarta.inject.Named is found on a class, the runtime must place the bean in a CDI scope such that it remains active as long as NavigationHandler.handleNavigation(jakarta.faces.context.FacesContext, java.lang.String, java.lang.String) does not cause a navigation to a view with a viewId that is different than the viewId of the current view.
ViewVisitOption	Defines the view traversal options.
VisitCallback	A simple callback interface that enables taking action on a specific UIComponent (either facet or child) during a component tree visit.
VisitContext	A context object that is used to hold state relating to performing a component tree visit.
VisitContextFactory	Provide for separation of interface and implementation for the VisitContext contract.
VisitContextWrapper	Provides a simple implementation of VisitContext that can be subclassed by developers wishing to provide specialized behavior to an existing VisitContext instance.
VisitHint	An enum that specifies hints that impact the behavior of a component tree visit.
VisitResult	An enum that specifies the possible results of a call to VisitCallback.visit(jakarta.faces.component.visit.VisitContext, jakarta.faces.component.UIComponent).
VoidType	The void pseudo-type.
W3CDomHandler	DomHandler implementation for W3C DOM (org.w3c.dom package.)
W3CEndpointReference	This class represents a W3C Addressing EndpointReferece which is a remote reference to a web service endpoint that supports the W3C WS-Addressing 1.0 - Core Recommendation.
W3CEndpointReferenceBuilder	This class is used to build W3CEndpointReference instances.
WebApplicationException	Runtime exception for applications.
WebConnection	This interface encapsulates the connection for an upgrade request.
WebEndpoint	Used to annotate the getPortName() methods of a generated service interface.
WebFault	Used to annotate service specific exception classes to customize to the local and namespace name of the fault element and the name of the fault bean.
WebFilter	Annotation used to declare a servlet filter.
WebInitParam	This annotation is used on a Servlet or Filter implementation class to specify an initialization parameter.
WebListener	This annotation is used to declare a WebListener.
WebMethod	Customizes a method that is exposed as a Web Service operation.
WebParam	Customizes the mapping of an individual parameter to a Web Service message part and XML element.
WebParam.Mode	The direction in which the parameter flows
WebResourcePermission	Class for Jakarta Servlet web resource permissions.
WebResult	Customizes the mapping of the return value to a WSDL part and XML element.
WebRoleRefPermission	Class for Jakarta Servlet isUserInRole (String reference) permissions.
WebService	Marks a Java class as implementing a Web Service, or a Java interface as defining a Web Service interface.
WebServiceClient	Used to annotate a generated service interface.
WebServiceContext	A WebServiceContext makes it possible for a web service endpoint implementation class to access message context and security information relative to a request being served.
WebServiceException	The WebServiceException class is the base exception class for all Jakarta XML Web Services API runtime exceptions.
WebServiceFeature	A WebServiceFeature is used to represent a feature that can be enabled or disabled for a web service.
WebServiceFeatureAnnotation	Annotation used to identify other annotations as a WebServiceFeature.
WebServicePermission	This class defines web service permissions.
WebServiceProvider	Used to annotate a Provider implementation class.
WebServiceRef	The WebServiceRef annotation is used to define a reference to a web service and (optionally) an injection target for it.
WebServiceRefs	The WebServiceRefs annotation allows multiple web service references to be declared at the class level.
WebServlet	Annotation used to declare a servlet.
WebSocketContainer	A WebSocketContainer is an implementation provided object that provides applications a view on the container running it.
WebsocketEvent	This web socket event will be fired when a new <f:websocket> has been @WebsocketEvent.Opened or @WebsocketEvent.Closed.
WebsocketEvent.Closed	Indicates that a <f:websocket> has closed.
WebsocketEvent.Closed.Literal	Supports inline instantiation of the WebsocketEvent.Closed qualifier.
WebsocketEvent.Opened	Indicates that a <f:websocket> has opened.
WebsocketEvent.Opened.Literal	Supports inline instantiation of the WebsocketEvent.Opened qualifier.
WebTarget	A resource target identified by the resource URI.
WebUserDataPermission	Class for Jakarta Servlet Web user data permissions.
WildcardType	A wildcard type.
WithAnnotations	WithAnnotations may be applied to any portable extension observer method with an event parameter type of ProcessAnnotatedType to filter the events delivered.
Work	This models a Work instance that would be executed by a WorkManager upon submission.
WorkAdapter	This class is provided as a convenience for easily creating WorkListener instances by extending this class and overriding only those methods of interest.
WorkCompletedException	This exception is thrown by a WorkManager to indicate that a submitted Work instance has completed with an exception.
WorkContext	This class serves as a standard mechanism for a resource adapter to propagate an imported context from an enterprise information system to an application server.
WorkContextErrorCodes	This class models the possible error conditions that might occur during associating an WorkContext with a Work instance.
WorkContextLifecycleListener	This class models the various events that occur during the processing of the WorkContexts associated with a Work instance.
WorkContextProvider	This interface specifies the methods a Work instance uses to associate a List of WorkContext instances to be set when the Work instance gets executed by a WorkManager.
WorkEvent	This class models the various events that occur during the processing of a Work instance.
WorkException	A common base class for all Work processing related exceptions.
WorkListener	This models a WorkListener instance which would be notified by the WorkManager when the various Work processing events (work accepted, work rejected, work started, work completed) occur.
WorkManager	This interface models a WorkManager which provides a facility to submit Work instances for execution.
WorkRejectedException	This exception is thrown by a WorkManager to indicate that a submitted Work instance has been rejected.
WriteListener	Callback notification mechanism that signals to the developer it's possible to write content without blocking.
WriterInterceptor	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).
WriterInterceptorContext	Context class used by WriterInterceptor to intercept 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).
XAConnection	The XAConnection interface extends the capability of Connection by providing an XASession (optional).
XAConnectionFactory	The XAConnectionFactory interface is a base interface for the XAQueueConnectionFactory and XATopicConnectionFactory interfaces.
XAJMSContext	The XAJMSContext interface extends the capability of JMSContext by adding access to a Jakarta Messaging provider's support for the Java Transaction API (JTA) (optional).
XAQueueConnection	An XAQueueConnection provides the same create options as QueueConnection (optional).
XAQueueConnectionFactory	An XAQueueConnectionFactory provides the same create options as a QueueConnectionFactory (optional).
XAQueueSession	An XAQueueSession provides a regular QueueSession, which can be used to create QueueReceiver, QueueSender, and QueueBrowser objects (optional).
XASession	The XASession interface extends the capability of Session by adding access to a Jakarta Messaging provider's support for the Java Transaction API (JTA) (optional).
XATerminator	The XATerminator interface is used for transaction completion and crash recovery flows.
XATopicConnection	An XATopicConnection provides the same create options as TopicConnection (optional).
XATopicConnectionFactory	An XATopicConnectionFactory provides the same create options as a TopicConnectionFactory (optional).
XATopicSession	An XATopicSession provides a regular TopicSession.
XmlAccessOrder	Used by XmlAccessorOrder to control the ordering of properties and fields in a Jakarta XML Binding bound class.
XmlAccessorOrder	Controls the ordering of fields and properties in a class.
XmlAccessorType	Controls whether fields or Javabean properties are serialized by default.
XmlAccessType	Used by XmlAccessorType to control serialization of fields or properties.
XmlAdapter<ValueType,BoundType>	Adapts a Java type for custom marshaling.
XmlAnyAttribute	Maps a JavaBean property to a map of wildcard attributes.
XmlAnyElement	Maps a JavaBean property to XML infoset representation and/or JAXBElement.
XmlAttachmentRef	Marks a field/property that its XML form is a uri reference to mime content.
XmlAttribute	Maps a JavaBean property to a XML attribute.
XmlElement	Maps a JavaBean property to a XML element derived from property name.
XmlElement.DEFAULT	Used in XmlElement.type() to signal that the type be inferred from the signature of the property.
XmlElementDecl	Maps a factory method to a XML element.
XmlElementDecl.GLOBAL	Used in XmlElementDecl.scope() to signal that the declaration is in the global scope.
XmlElementRef	Maps a JavaBean property to a XML element derived from property's type.
XmlElementRef.DEFAULT	Used in XmlElementRef.type() to signal that the type be inferred from the signature of the property.
XmlElementRefs	Marks a property that refers to classes with XmlElement or JAXBElement.
XmlElements	A container for multiple @XmlElement annotations.
XmlElementWrapper	Generates a wrapper element around XML representation.
XmlEnum	Maps an enum type Enum to XML representation.
XmlEnumValue	Maps an enum constant in Enum type to XML representation.
XmlID	Maps a JavaBean property to XML ID.
XmlIDREF	Maps a JavaBean property to XML IDREF.
XmlInlineBinaryData	Disable consideration of XOP encoding for datatypes that are bound to base64-encoded binary data in XML.
XmlJavaTypeAdapter	Use an adapter that implements XmlAdapter for custom marshaling.
XmlJavaTypeAdapter.DEFAULT	Used in XmlJavaTypeAdapter.type() to signal that the type be inferred from the signature of the field, property, parameter or the class.
XmlJavaTypeAdapters	A container for multiple @XmlJavaTypeAdapter annotations.
XmlList	Used to map a property to a list simple type.
XmlMimeType	Associates the MIME type that controls the XML representation of the property.
XmlMixed	Annotate a JavaBean multi-valued property to support mixed content.
XmlNs	Associates a namespace prefix with a XML namespace URI.
XmlNsForm	Enumeration of XML Schema namespace qualifications.
XmlRegistry	Marks a class that has XmlElementDecls.
XmlRootElement	Maps a class or an enum type to an XML element.
XmlSchema	Maps a package name to a XML namespace.
XmlSchemaType	Maps a Java type to a simple schema built-in type.
XmlSchemaType.DEFAULT	Used in XmlSchemaType.type() to signal that the type be inferred from the signature of the property.
XmlSchemaTypes	A container for multiple @XmlSchemaType annotations.
XmlSeeAlso	Instructs Jakarta XML Binding to also bind other classes when binding this class.
XmlTransient	Prevents the mapping of a JavaBean property/type to XML representation.
XmlType	Maps a class or an enum type to a XML Schema type.
XmlType.DEFAULT	Used in XmlType.factoryClass() to signal that either factory mehod is not used or that it's in the class with this XmlType itself.
XmlValue	Enables mapping a class to a XML Schema complex type with a simpleContent or a XML Schema simple type.
ZonedTrigger	Triggers allow application developers to plug in rules for when and how often a task should run.