All Classes and Interfaces

Class
Description
Exception indicating that the result of a task cannot be retrieved because the task failed to run for some reason other than being cancelled.
An exception that may be thrown by event listeners to terminate the processing of the current event.
The AbstractBatchlet provides default implementations of less commonly implemented methods.
The AbstractCheckpointAlgorithm provides default implementations of less commonly implemented methods.
The AbstractChunkListener provides default implementations of less commonly implemented methods.
The AbstractItemProcessListener provides default implementations of less commonly implemented methods.
The AbstractItemReader provides default implementations of less commonly implemented methods.
The AbstractItemReadListener provides default implementations of less commonly implemented methods.
The AbstractItemWriteListener provides default implementations of less commonly implemented methods.
The AbstractItemWriter provides default implementations of not commonly implemented methods.
The AbstractJobListener provides default implementations of less commonly implemented methods.
Partial default Marshaller implementation.
Abstract skeleton implementation of a MultivaluedMap that is backed by a [key, multi-value] store represented as a Map<K, List<V>>.
The AbstractPartitionAnalyzer provides default implementations of less commonly implemented methods.
The AbstractBatchlet provides default implementations of less commonly implemented methods.
The AbstractQuery interface defines functionality that is common to both top-level queries and subqueries.
The AbstractStepListener provides default implementations of less commonly implemented methods.
Partial default Unmarshaller implementation.
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.
An AccessLocalException is thrown to indicate that the caller does not have permission to call the method.
Specifies the amount of time in a given time unit that a concurrent access attempt should block before timing out.
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.
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.
An ActionEvent represents the activation of a user interface component (such as a UICommand).
A listener interface for receiving ActionEvents.
Provides a simple implementation of ActionListener that can be subclassed by developers wishing to provide specialized behavior to an existing ActionListener instance.
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 extends ActionSource and provides a JavaBeans property analogous to the "action" property on ActionSource.
A VDL handler that exposes ActionListener to a page author.
A marker interface for VDL tags that represent <composite:actionSource/> for use by the composite component page author.
Designates a JavaBean as an ActivationSpec.
Used to provide information to the deployer about the configuration of a message driven bean in its operational environment.
This interface serves as a marker.
This abstract class models the addresses in a message.
The exception thrown when a wrongly formatted address is encountered.
This annotation represents the use of WS-Addressing with either the SOAP 1.1/HTTP or SOAP 1.2/HTTP binding.
AddressingFeature represents the use of WS-Addressing with either the SOAP 1.1/HTTP or SOAP 1.2/HTTP binding.
If addressing is enabled, this property determines if endpoint requires the use of only anonymous responses, or only non-anonymous responses, or all.
This abstract class implements string comparisons for Message addresses.
This class implements Message Address comparisons.
Designates a JavaBean as an administered object.Administered objects are specific to a messaging style or message provider.
Annotation used to define a Connector administered object to be registered in JNDI.
Declares one or more AdministeredObjectDefinition annotations.
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.
Designate a stateful session bean method to receive the after begin session synchronization callback.
Designate a stateful session bean method to receive the after completion session synchronization callback.
The event type of the third event fired by the container after it has validated that there are no deployment problems and before creating contexts or processing requests.
This event type is thrown by the container after type discovery is complete.
An instance of this class is added as a ClientBehavior to a component using the ClientBehaviorHolder.addClientBehavior(java.lang.String, javax.faces.component.behavior.ClientBehavior) contract that components implement.
AjaxBehaviorEvent represents the component behavior specific to Ajax).
By implementing this class, an object indicates that it is a listener for one or more kinds of BehaviorEvents.
Provides an operation for obtaining and destroying contextual instances with a particular scope of any contextual type.
Specifies that a bean is an alternative.
Indicates that multiple beans match a certain combination of required type and required qualifiers and are eligible for injection into a certain class.
This class implements the logical AND operator on individual SearchTerms.
Represents a Java program element that can be annotated.
Represents a callable member of a Java type.
Represents a constructor of a Java class.
Represents a field of a Java class.
Represents a member of a Java type.
Represents a method of a Java type.
Represents a parameter of a method or constructor.
Represents a Java class or interface.
Supports inline instantiation of annotation type instances.
The built-in qualifier type.
Application represents a per-web-application singleton object where applications based on JavaServer Faces (or implementations wishing to provide extended functionality) can register application-wide singletons that provide functionality required by JavaServer Faces.
Defines the components of a JAX-RS application and supplies additional meta-data.
This class defines a java.util.ServiceLoader service which enables programmatic configuration of the JSF runtime using the existing Application Configuration Resources schema.
Applied to an exception to denote that it is an application exception and should be reported to the client directly (i.e., unwrapped).
ApplicationFactory is a factory object that creates (if needed) and returns Application instances.
Identifies the application path that serves as the base URI for all resource URIs provided by Path.
Specifies that a bean is application scoped.
When this annotation, along with ManagedBean is found on a class, the runtime must act as if a <managed-bean-scope>application<managed-bean-scope> element was declared for the corresponding managed bean.
An ApplicationServerInternalException is thrown by an application server to indicate error conditions specific to an application server.
Provides a simple implementation of Application that can be subclassed by developers wishing to provide specialized behavior to an existing Application instance.
Designates an interceptor method that receives a callback when the target class constructor is invoked.
Defines an interceptor method that interposes on business methods.
Defines an interceptor method that interposes on timeout methods.
ArrayDataModel is a convenience implementation of DataModel that wraps an array of Java objects.
Defines property resolution behavior on arrays.
The annotated element must be false.
Defines several AssertFalse annotations on the same element.
The annotated element must be true.
Defines several AssertTrue annotations on the same element.
Used to override a mapping for an entity relationship.
Used to override mappings of multiple relationship properties or fields.
Class representing the execution context for an asynchronous operation that was initiated on a ServletRequest.
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.
The AsyncHandler interface is implemented by clients that wish to receive callback notification of the completion of service endpoint operations invoked asynchronously.
Used to mark a session bean method as an asynchronous method or to designate all business methods of a session bean class as asynchronous.
Uniform interface for asynchronous invocation of HTTP methods.
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.
An injectable JAX-RS asynchronous response that provides means for asynchronous server side response processing.
Wraps the result of an asynchronous method call as a Future object, preserving compatability with the business interface signature.
The abstract base interface for a handler representing an attached object in a VDL page.
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.
Enable JAXB marshalling to optimize storage of binary data.
Enables JAXB unmarshalling of a root document containing optimized binary data formats.
Represents an attribute of a Java type.
 
A class that implements this interface can be used to convert entity attribute state into database column representation and back again.
An interface that allows other code to identify FaceletHandlers that correspond to component attributes.
Represents an attribute node of an entity graph.
Used to override the mapping of a Basic (whether explicit or default) property or field or Id property or field.
Used to override mappings of multiple properties or fields.
Deprecated.
The Faces implementation must now provide the implementation for this class.
This interface defines the common functionality implemented by Authentication context configuration objects.
This class is used to obtain AuthConfigProvider objects that can be used to obtain authentication context configuration objects, that is, ClientAuthConfig and ServerAuthConfig objects.
Represents the layer identifier, application context identifier, and description components of an AuthConfigProvider registration at the factory.
This interface is implemented by objects that can be used to obtain authentication context configuration objects, that is, ClientAuthConfig or ServerAuthConfig objects.
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).
 
An enumerated type that represents the various interfaces that a resource adapter may support for the representation of the credentials.
The class Authenticator represents an object that knows how to obtain authentication for a network connection.
A generic authentication exception.
The AuthStatus class is used to represent return values from Authentication modules and Authentication Contexts.
A runtime exception indicating a bad client request.
The simplest type of mapping to a database column.
Instances of the type BasicType represent basic types (including temporal and enumerated types).
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.
 
BatchRuntime represents the JSR 352 Batch Runtime.
 
BatchStatus enum defines the batch status values possible for a job.
Represents an enabled bean.
The BeanAttributes interface exposes the basic attributes of a bean.
Describes a constrained Java Bean and the constraints associated to it.
Defines property resolution behavior on objects using the JavaBeans component architecture.
Allows a portable extension to interact directly with the container.
An ELResolver for resolving user or container managed beans.
Resolves a bean by its known name.
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.
A Validator that delegates validation of the bean property to the Bean Validation API.
This event type is thrown by the container before the bean discovery process begins.
Designate a stateful session bean method to receive the before completion session synchronization callback.
The type of the final event the container fires after it has finished processing requests and destroyed all contexts.
The Behavior interface is the root API of the component behavior model.
BehaviorBase is a convenience base class that provides a default implementation of the Behavior contract.
Convey the id of a behavior declared in a view.
BehaviorEvent is the event that can be generated from component Behavior.
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, javax.faces.component.behavior.ClientBehavior).
Represent an attached object that is a BehaviorHolder in a VDL page.
Represent a BehaviorHolder attached object target in a VDL page.
A generic base interface for event listeners for various types of BehaviorEvents.
Converter implementation for java.math.BigDecimal values.
Converter implementation for java.math.BigInteger values.
Instances of the type Bindable represent object or attribute types that can be bound into a Path.
 
Enable synchronization between XML infoset nodes and JAXB objects representing same XML document.
The Binding interface is the base interface for JAX-WS protocol bindings.
The BindingProvider interface provides access to the protocol binding and associated context objects for request and response message processing.
The BindingType annotation is used to specify the binding to use for a web service endpoint implementation class.
An encapsulation of the evaluation of the body of an action so it is available to a tag handler.
This class models a Part that is contained within a Multipart.
The BodyTag interface extends IterationTag by defining additional methods that let a tag handler manipulate the content of evaluating its body.
A base class for defining tag handlers implementing BodyTag.
This class implements searches on a message body.
Converter implementation for java.lang.Boolean (and boolean primitive) values.
Represents the user specified default configuration in META-INF/validation.xml.
This provides a mechanism to pass a bootstrap context to a resource adapter instance when it is bootstrapped.
Defines the state used to bootstrap the Configuration.
Specifies standard measurements of the upper and lower limits of the value of an attribute.
The BoundedRangeStatistic model aggregates the attributes of RangeStatistic and BoundaryStatistic and provides standard measurements of a range that has fixed limits.
Indicates that the container has rejected a request because a concurrent request is associated with the same conversation context.
A DataSource backed by a byte array.
Converter implementation for java.lang.Byte (and byte primitive) values.
A BytesMessage object is used to send a message containing a stream of uninterpreted bytes.
Interface used to interact with the second-level cache.
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.
An abstraction for the value of a HTTP Cache-Control response header.
Used as the value of the javax.persistence.cache.retrieveMode property to specify the behavior when data is retrieved by the find methods and by queries.
Used as the value of the javax.persistence.cache.storeMode property to specify the behavior when data is read from the database and when data is committed into the database.
Callback for setting the container's caller (or Remote user) principal.
Represents a cascadable element.
Defines the set of cascadable operations that are propagated to the associated entity.
Provides access to the current container.
Interface implemented by a CDI provider to provide access to the current container
Callback for CertStore.
Converter implementation for java.lang.Character (and char primitive) values.
CheckpointAlgorithm provides a custom checkpoint policy for chunk steps.
ChunkListener intercepts chunk processing.
A persistence provider supplies an instance of this interface to the PersistenceUnitInfo.addTransformer method.
Client is the main entry point to the fluent API used to build and execute client requests in order to consume responses returned.
An implementation of this interface is used to secure service request messages, and validate received service response messages.
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).
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.
A ClientAuthModule secures request messages, and validates received response messages.
ClientBehavior is the base contract for Behaviors that attach script content to client-side events exposed by ClientBehaviorHolder components.
ClientBehaviorBase is a convenience base class that implements the default concrete behavior of all methods defined by ClientBehavior.
ClientBehaviorContext provides context information that may be useful to ClientBehavior.getScript(javax.faces.component.behavior.ClientBehaviorContext) implementations.
Parameter instances represent name/value pairs that "submitting" ClientBehavior implementations should include when posting back into the Faces lifecycle.
An enum that specifies hints that describes the behavior of ClientBehavior implementations.
The ClientBehaviorHolder interface may be implemented by any concrete UIComponent that wishes to support client behaviors as defined by ClientBehavior.
A ClientBehaviorRenderer produces the client-side script that implements a ClientBehavior's client-side logic.
Main entry point to the client API used to bootstrap Client instances.
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.
The ClientEndpointConfig is a special kind of endpoint configuration object that contains web socket configuration information specific only to client endpoints.
The ClientEndpointConfig.Builder is a class used for creating ClientEndpointConfig objects for the purposes of deploying a client endpoint.
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.
A base runtime application exception indicating a client request error (HTTP 4xx status codes).
Client request filter context.
An extension interface implemented by client request filters.
Client response filter context.
An extension interface implemented by client response filters.
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.
Create ClientWindow instances based on the incoming request.
Wrapper for ClientWindow
A class encapsulating the reason why a web socket has been closed, or why it is being asked to close.
A marker interface for the close codes.
An Enumeration of status codes for a web socket close that are defined in the specification.
Built-in XmlAdapter to handle xs:token and its derived types.
Instances of the type CollectionAttribute represent persistent java.util.Collection-valued attributes.
CollectionDataModel is a convenience implementation of DataModel that wraps an Collection of Java objects.
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.
Specifies the table that is used for the mapping of collections of basic or embeddable types.
Specifies the mapped column for a persistent property or field.
Used in conjunction with the SqlResultSetMapping annotation or ConstructorResult annotation to map a column of the SELECT list of a SQL query.
This indicates errors related to failed or interrupted communication with an EIS instance.
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.
This class models the comparison operator.
A request processing callback that receives request processing completion events.
A CompletionListener is implemented by the application and may be specified when a message is sent asynchronously.
Passed to the constructor of ComponentHandler.
Public base class for markup element instances that map to UIComponent instances in the view.
ComponentSystemEvent is the base class for SystemEvents that are specific to a UIComponent instance.
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.
This interface must be implemented by the Map returned by the composite component ELResolver, described in section JSF.5.6.2.2 of the specification, when evaluating #{cc.attrs} epressions.
Maintains an ordered composite list of child ELResolvers.
A FaceletHandler that is derived of 1 or more, inner FaceletHandlers.
The CompoundSelection interface defines a compound selection item (tuple, array, or result of constructor).
Declares a singleton session bean's concurrency management type.
Used to specify the value of the ConcurrencyManagement annotation for a singleton session bean.
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.
This exception indicates that an attempt to concurrently access a stateful session or singleton bean method resulted in a timeout.
Abstract class that facilitates implementation of conditional actions where the boolean result is exposed as a JSP scoped variable.
Class supporting access to configuration settings.
Designates a JavaBean property as a configuration property
Represents a client or server-side configurable context in JAX-RS.
ConfigurableNavigationHandler extends the contract of NavigationHandler to allow runtime inspection of the NavigationCases that make up the rule-base for navigation.
Provides a simple implementation of ConfigurableNavigationHandler that can be subclassed by developers wishing to provide specialized behavior to an existing ConfigurableNavigationHandler instance.
Receives configuration information, selects the appropriate Bean Validation provider and builds the appropriate ValidatorFactory.
A configuration state associated with a configurable JAX-RS context.
Contract between a Configuration and a ValidationProvider to create a ValidatorFactory.
A Connection object is a client's active connection to its JMS provider.
A Connection represents an application-level handle that is used by a client to access the underlying physical connection.
The adapter which receives connection events.
Asynchronous request processing lifecycle callback that receives connection related asynchronous response lifecycle events.
For application servers, Connection objects provide a special facility for creating a ConnectionConsumer (optional).
Defines a set of connection interfaces and classes pertaining to a particular connection type.
Defines a set of connection definitions that the JavaBean, that has been annotated with this annotation, is a part of.
This class models Connection events.
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.
The ConnectionEventListener interface provides an event callback mechanism to enable an application server to receive notifications from a ManagedConnection instance.
A ConnectionFactory object encapsulates a set of connection configuration parameters that has been defined by an administrator.
ConnectionFactory provides an interface for getting connection to an EIS instance.
Annotation used to define a Connector Connection Factory resource to be registered in JNDI.
Declares one or more ConnectionFactoryDefinition annotations.
This is the Listener interface for Connection events.
ConnectionManager interface provides a hook for the resource adapter to pass a connection request to the application server.
A ConnectionMetaData object provides information describing the Connection object.
The interface ConnectionMetaData provides information about an EIS instance connected through a Connection instance.
The ConnectionRequestInfo interface enables a resource adapter to pass its own request specific data structure across the connection request flow.
ConnectionSpec is used by an application component to pass connection request-specific properties to the ConnectionFactory.
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.
Indicates the run-time context in which an annotated JAX-RS provider is applicable.
Marks an annotation as being a Bean Validation constraint.
Exception raised if a constraint declaration is not legal.
Exception raised if a constraint definition is not legal.
Describes a single constraint and its composing constraints.
Used to control the application of a constraint.
Defines the constraint target.
Defines the logic to validate a given constraint A for a given object type T.
Provides contextual data and operation when applying a given constraint validator.
ConstraintViolation builder allowing to optionally associate the violation report to a sub path.
Represents a node whose context is configurable (i.e.
Represents a node whose context is known (i.e.
Represents refinement choices for a node which is in an Iterator or Map.
Represents a node whose context is configurable (i.e.
Represents a node whose context is known (i.e.
Represents refinement choices for a node which is in an Iterator or Map.
Instantiates a ConstraintValidator instance based off its class.
Describes a constraint violation.
Reports the result of constraint violations.
Describes a validated constructor.
Used in conjunction with the SqlResultSetMapping annotation to map the SELECT clause of a SQL query to a constructor.
Defines the media types that the methods of a resource class or MessageBodyReader can accept.
Provider class that allows the developer to get a reference to the implementation of the WebSocketContainer.
Container request filter context.
An extension interface implemented by container request filters.
Container response filter context.
An extension interface implemented by container response filters.
This class represents a MIME ContentDisposition value.
This class represents a MIME Content-Type value.
Provides an operation for obtaining contextual instances with a particular scope of any contextual type.
This annotation is used to inject information into a class field, bean property or method parameter.
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.
Indicates a problem relating to context management.
Indicates that a context is not active.
Contract for a provider that supplies context information to resource classes and other providers.
The ContextService provides methods for creating dynamic proxy objects (as defined by java.lang.reflect.Proxy) with the addition of context typically associated with applications executing in a Java™ EE environment.
Defines operations to create and destroy contextual instances of a certain type.
Allows the application to manage the conversation context by marking the current conversation as transient or long-running, specifying a conversation identifier, or setting the conversation timeout.
Specifies that a bean is conversation scoped.
Specifies the conversion of a Basic field or property.
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.
Specifies that the annotated class is a converter and defines its scope.
A Facelet version of the JSP ConverterTag.
ConverterELTag is a base class for all JSP custom actions that create and register a Converter instance on the ValueHolder associated with our most immediate surrounding instance of a tag whose implementation class is a subclass of UIComponentClassicTagBase.
ConverterException is an exception thrown by the getAsObject() or getAsText() method of a Converter, to indicate that the requested conversion cannot be performed.
Handles setting a Converter instance on a ValueHolder parent.
Deprecated.
This has been partially replaced by ConverterELTag.
Converts group from to group to during cascading.
Defines several ConvertGroup annotations on the same element.
Used to group Convert annotations.
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.
Represents the value of a HTTP cookie, transferred in a request.
Binds the value of a HTTP cookie to a resource method parameter, resource class field, or resource class bean property.
Specifies standard count measurements.
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.
Provides operations that are used by the Contextual implementation during instance creation and destruction.
Indicates that a checked exception was thrown during creation of a bean.
Used to construct criteria queries, compound selections, expressions, predicates, orderings.
Interface used to build general case expressions.
Interface used to build coalesce expressions.
Interface used to build in predicates.
Interface used to build simple case expressions.
Used to specify how strings are trimmed.
The CriteriaDelete interface defines functionality for performing bulk delete operations using the Criteria API
The CriteriaQuery interface defines functionality that is specific to top-level queries.
The CriteriaUpdate interface defines functionality for performing bulk update operations using the Criteria API.
Describes an element holding cross-parameter constraints of a method or constructor
When this annotation, along with ManagedBean is found on a class, the runtime must act as if a <managed-bean-scope>VALUE<managed-bean-scope> element was declared for the corresponding managed bean, where VALUE is the value of the CustomScoped.value() attribute, which must be an EL expression that evaluates to a Map.
Exception that represents a failure in a JAXB operation.
DataModel is an abstraction around arbitrary data binding technologies that can be used to adapt a variety of data sources for use by JavaServer Faces components that support per-row processing for their child components (such as UIData.
DataModelEvent represents an event of interest to registered listeners that occurred on the specified DataModel.
DataModelListener represents an event listener that wishes to be notified of DataModelEvents occurring on a particular DataModel instance.
Annotation used to define a container DataSource and be registered with JNDI.
Declares one or more DataSourceDefinition annotations.
The javaType binding declaration can be used to customize the binding of an XML schema datatype to a Java datatype.
The DatatypeConverterInterface is for JAXB provider use only.
This class implements comparisons for Dates
Converter implementation for java.util.Date values.
A Decider receives control as part of a decision element in a job.
The annotated element must be a number whose value must be lower or equal to the specified maximum.
Defines several DecimalMax annotations on the same element.
The annotated element must be a number whose value must be higher or equal to the specified minimum.
Defines several DecimalMin annotations on the same element.
Used by application to declare roles.
A general exception that occurs when trying to decode a custom object from a text or binary message.
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.
This interface defines how a custom object (of type T) is decoded from a web socket message in the form of a byte buffer.
This interface defines how a custom object is decoded from a web socket message in the form of a binary stream.
This interface defines how a custom object is decoded from a web socket message in the form of a string.
This interface defines how a custom object of type T is decoded from a web socket message in the form of a character stream.
A decorator may inject metadata about the bean it is decorating
Specifies that a class is a decorator.
Represents an enabled decorator.
The default qualifier type.
Default Bean Validation group.
JAXB 1.0 only default validation event handler.
Defines the default value of request meta-data that is bound using one of the following annotations: PathParam, QueryParam, MatrixParam, CookieParam, FormParam, or HeaderParam.
Thrown when a definition error occurs.
Identifies the delegate injection point of a decorator.
Enable the JSF 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.
Indicates that the annotated method responds to HTTP DELETE requests.
The delivery modes supported by the JMS API are PERSISTENT and NON_PERSISTENT.
Specifies that no security roles are allowed to invoke the specified method(s) - i.e that the methods are to be excluded from execution in the J2EE container.
Specifies that a bean belongs to the dependent pseudo-scope.
Used to express an initialization dependency between singleton components.
Thrown when a deployment problem occurs.
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.
A Destination object encapsulates a provider-specific address.
The @Destroyed qualifier.
The annotated element must be a number within accepted range Supported types are: BigDecimal BigInteger CharSequence byte, short, int, long, and their respective wrapper types
Defines several Digits annotations on the same element.
Specifies the discriminator column for the SINGLE_TABLE and JOINED Inheritance mapping strategies.
Defines supported types of the discriminator column.
Specifies the value of the discriminator column for entities of the given type.
The Dispatch interface provides support for the dynamic invocation of a service endpoint operations.
Enumeration of filter dispatcher types.
Identifies the disposed parameter of a disposer method.
This is a mix-in interface that may be optionally implemented by a ManagedConnection implementation.
This models a Work instance that would be distributed by a DistributableWorkManager for execution in a remote DistributableWorkManager
This interface models a WorkManager that supports distributed execution of Work instances.
Converts an element (and its descendants) from/to DOM (or similar) representation.
Converter implementation for java.lang.Double (and double primitive) values.
DoubleRangeValidator is a Validator that checks the value of the corresponding component against specified minimum and maximum values.
The DuplicateKeyException exception is thrown if an entity EJB object or EJB local object cannot be created because an object with the same key already exists.
For a tag to declare that it accepts dynamic attributes, it must implement this interface.
A JAX-RS meta-provider for dynamic registration of post-matching providers during a JAX-RS application setup at deployment time.
EditableValueHolder is an extension of ValueHolder that describes additional features supported by editable components, including ValueChangeEvents and Validators.
A VDL handler that exposes Validator or ValueChangeListener to a page author.
A marker interface for VDL tags that represent <composite:editableValueHolder/> for use by the composite component page author.
An EISSystemException is used to indicate any EIS specific system-level error conditions.
Indicates a dependency on the local, no-interface, or remote view of an Enterprise JavaBean.
This exception indicates that client access to a business method was denied.
Used to execute an EJB application in an embeddable container.
The EJBContainerProvider SPI is used by the embeddable container bootstrap class to initialize a suitable embeddable container.
The EJBContext interface provides an instance with access to the container-provided runtime context of an enterprise bean instance.
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.
The EJBHome interface must be extended by all enterprise beans' remote home interfaces.
The EJBLocalHome interface must be extended by all enterprise beans' local home interfaces.
The EJBLocalObject interface must be extended by all enterprise beans' local interfaces.
The EJBMetaData interface allows a client to obtain the enterprise bean's meta-data information.
Class for EJB method permissions.
The EJBObject interface is extended by all enterprise beans' remote interfaces.
Class for EJB isCallerInRole (String reference) permissions.
Declares multiple EJB annotations.
Specifies statistics provided by all EJB component types.
This exception indicates that a request carried a null transaction context, but the target object requires an active transaction.
This exception is thrown to a remote client to indicate that the transaction associated with processing of the request has been rolled back, or marked to roll back.
A runtime representation of a Class in the EL expressions.
Context information for expression parsing and evaluation.
An event which indicates that an ELContext has been created.
The listener interface for receiving notification when an ELContext is created.
This is an element marker interface.
Specifies a collection of instances of a basic type or embeddable class.
Describes a validated element (class, property, method etc.).
Declares restrictions on retrieved constraints.
Enum of possible kinds of elements encountered in Bean Validation.
Represents any of the exception conditions that can arise during expression evaluation.
Deprecated.
As of JSP 2.1, replaced by ELException
Manages EL parsing and evaluation environment.
Deprecated.
As of JSP 2.1, replaced by ELException
Provides an API for using EL in a stand-alone environment.
Enables customization of variable, property, method call, and type conversion resolution behavior for EL expression evaluation.
Specifies a class whose instances are stored as an intrinsic part of an owning entity and share the identity of the entity.
Instances of the type EmbeddableType represent embeddable types.
Specifies a persistent field or property of an entity whose value is an instance of an embeddable class.
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.
Disables automatic decoding of parameter values bound using QueryParam, PathParam, FormParam or MatrixParam.
A general exception that occurs when trying to encode a custom object to a string or binary message.
The Encoder interface defines how developers can provide a way to convert their custom objects into web socket messages.
This interface defines how to provide a way to convert a custom object into a binary message.
This interface may be implemented by encoding algorithms that want to write the encoded object to a binary stream.
This interface defines how to provide a way to convert a custom object into a text message.
This interface may be implemented by encoding algorithms that want to write the encoded object to a character stream.
A DataSource that also implements EncodingAware may specify the Content-Transfer-Encoding to use for its data.
The Web Socket Endpoint represents an object that can handle websocket conversations.
A Web service endpoint.
The endpoint configuration contains all the information needed during the handshake process for this end point.
EndpointContext allows multiple endpoints in an application to share any information.
This class represents an WS-Addressing EndpointReference which is a remote reference to a web service endpoint.
The EnterpriseBean interface is a common superinterface for the SessionBean, EntityBean and MessageDrivenBean interfaces.
Specifies that the class is an entity.
Encapsulates message entity including the associated variant information.
The EntityBean interface is implemented by every entity bean class.
Specifies statistics provided by entity beans.
The EntityContext interface provides an instance with access to the container-provided runtime context of an entity bean instance.
Thrown by the persistence provider when EntityManager.persist(Object) is called and the entity already exists.
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.
Specifies the callback listener classes to be used for an entity or mapped superclass.
Interface used to interact with the persistence context.
Interface used to interact with the entity manager factory for the persistence unit.
Thrown by the persistence provider when an entity reference obtained by EntityManager.getReference is accessed but the entity does not exist.
Used in conjunction with the SqlResultSetMapping annotation to map the SELECT clause of a SQL query to an entity result.
An abstraction for the value of a HTTP Entity Tag, used as the value of an ETag response header.
Interface used to control transactions on resource-local entity managers.
Instances of the type EntityType represent entity types.
Converter implementation for java.lang.Enum (and enum primitive) values.
Specifies that a persistent property or field should be persisted as a enumerated type.
Defines mapping for enumerated types.
Contains information about an error, for error pages.
Deprecated.
This has been replaced by ELException.
The listener interface for receiving notification when an EL expression is evaluated.
Allows the application to fire events of a particular type.
Provides access to metadata about an observed event payload.
ExceptionHandler is the central point for handling unexpected Exceptions that are thrown during the Faces lifecycle.
ExceptionHandlerFactory is a factory object that creates (if needed) and returns a new ExceptionHandler instance.
Provides a simple implementation of ExceptionHandler that can be subclassed by developers wishing to provide specialized behavior to an existing ExceptionHandler instance.
If a JMS provider detects a serious problem with a Connection object, it informs the Connection object's ExceptionListener, if one has been registered.
Contract for a provider that maps Java exceptions to Response.
The system event facility will create an instance of this class whenever Application.publishEvent(javax.faces.context.FacesContext, java.lang.Class<? extends javax.faces.event.SystemEvent>, java.lang.Object) is called with ExceptionQueuedEvent.class as systemEventClass argument.
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.
Used to exclude class-level interceptors for a lifecycle callback, business, or timeout method of a target class, or a constructor of a target class.
Used to exclude default interceptors for a target class or a lifecycle callback, business, or timeout method of a target class, or a constructor of a target class.
Specifies that the invocation of default listeners is to be excluded for the entity class (or mapped superclass) and its subclasses.
Specifies that the invocation of superclass listeners is to be excluded for the entity class (or mapped superclass) and its subclasses.
Provides the common functionality of MethodDescriptor and ConstructorDescriptor.
Defines the types of executables targeted by an operation.
Validates parameters and return values of methods and constructors.
This class models an execution context (transaction, security, etc) with which the Work instance must be executed.
Base class for the expression subclasses ValueExpression and MethodExpression, implementing characteristics common to both.
Type for query expressions.
Deprecated.
As of JSP 2.1, replaced by ValueExpression
Deprecated.
As of JSP 2.1, replaced by ExpressionFactory
Provides an implementation for creating and evaluating EL expressions.
Service interface implemented by extensions.
A simple representation of a websocket extension as a name and map of extension parameters.
This member interface defines a single websocket extension parameter.
This class allows the Faces API to be unaware of the nature of its containing application environment.
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.
Provides a simple implementation of ExternalContext that can be subclassed by developers wishing to provide specialized behavior to an existing ExternalContext instance.
The parent or root object in a FaceletHandler composition.
This API defines the facility by which the Facelets ViewDeclarationLanguage creates and caches instances of Facelets.
Factory interface for creating Facelet or View Metadata Facelet instances.
Allows customization of the implementation of FaceletCache.
Context representative of a single request from a Facelet.
An Exception from the Facelet implementation
This is the root class for markup elements in Facelets VDL.
Root class for all tag handlers that represent attached objetcts in a Facelets page.
The presence of this annotation on a class automatically registers the class with the runtime as a ResourceResolver.
The presence of this annotation on a class automatically registers the class with the runtime as a Behavior.
The presence of this annotation on a class automatically registers the class with the runtime as a ClientBehaviorRenderer.
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.
FacesContext contains all of the per-request state information related to the processing of a single JavaServer Faces request, and the rendering of the corresponding response.
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.
Provides a simple implementation of FacesContext that can be subclassed by developers wishing to provide specialized behavior to an existing FacesContext instance.
The presence of this annotation on a class automatically registers the class with the runtime as a Converter.
FacesEvent is the base class for user interface and application events that can be fired by UIComponents.
This class encapsulates general JavaServer Faces exceptions.
A generic base interface for event listeners for various types of FacesEvents.
FacesMessage represents a single validation (or other) message, which is typically associated with a particular component in the view.
Class used to represent message severity levels in a typesafe enumeration.
The presence of this annotation on a class automatically registers the class with the runtime as a Renderer.
FacesServlet is a servlet that manages the request processing lifecycle for web applications that are utilizing JavaServer Faces to construct the user interface.
The presence of this annotation on a class automatically registers the class with the runtime as a Validator.
Any wrapper class in JSF that must provide access to the object it wraps must implement this interface.
An interface that allows other code to identify FaceletHandlers that correspond to component facets.
FacetTag is the JSP mechanism for denoting a UIComponent is to be added as a facet to the component associated with its parent.
FactoryFinder implements the standard discovery algorithm for all factory objects specified in the JavaServer Faces APIs.
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.
A feature extension contract.
A configurable context passed to Feature and DynamicFeature instances by JAX-RS runtime during the phase of their configuration.
Represents a join-fetched association or attribute.
Represents an element of the from clause which may function as the parent of Fetches.
Clients use a FetchProfile to list the Message attributes that it wishes to prefetch from the server for a range of messages.
This inner class is the base class of all items that can be requested in a FetchProfile.
Defines strategies for fetching data from the database.
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.
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.
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.
A filter configuration object used by a servlet container to pass information to a filter during initialization.
Interface through which a Filter may be further configured.
Interface through which a Filter registered via one of the addFilter methods on ServletContext may be further configured.
The FinderException exception must be included in the throws clause of every finder method of an entity bean's home or local home interface.
The Flags class represents the set of flags on a Message.
This inner class represents an individual system flag.
This class implements comparisons for Message Flags.
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 is a factory object that creates (if needed) and returns Flash instances.
Provides a simple implementation of Flash that can be subclassed by developers wishing to provide specialized behavior to an existing Flash instance.
Converter implementation for java.lang.Float (and float primitive) values.
Flow is the runtime representation of a Faces Flow.
A Java language API for building Flows.
The presence of this annotation on a CDI producer method for the FlowDefinition annotation causes the FlowBuilder to be passed to that method.
Create a flow call node in the current Flow.
 
The presence of this annotation on a CDI producer method indicates that the method will produce a flow.
FlowHandler is the main entry point that enables the runtime to interact with the faces flows feature.
FlowHandlerFactory is used by the Application to create the singleton instance of FlowHandler.
FlowHandlerFactoryWrapper provides a simple implementation of FlowHandlerFactory that can be subclassed by developers wishing to provide specialized behavior to an existing FlowHandlerFactory instance.
FlowNode is the base class for all nodes in a faces flow graph.
FlowScoped is a CDI scope that causes the runtime to consider classes with this annotation to be in the scope of the specified Flow.
Flush mode setting.
Folder is an abstract class that represents a folder for mail messages.
The adapter which receives Folder events.
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.
This class models Folder existence events.
This is the Listener interface for Folder events.
This exception is thrown by Folder methods, when those methods are invoked on a non existent folder.
A runtime exception indicating that an access to a resource requested by a client has been forbidden by the server.
Used to specify the handling of foreign key constraints when schema generation is in effect.
Represents the the HTML form data request entity encoded using the "application/x-www-form-urlencoded" content type.
Binds the value(s) of a form parameter contained within a request entity body to a resource method parameter.
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.
This class implements string comparisons for the From Address header.
This class implements comparisons for the From Address header.
Information for a function in a Tag Library.
The interface to a map between EL function names and methods.
Deprecated.
As of JSP 2.1, replaced by FunctionMapper
The annotated element must be a date in the future.
Defines several Future annotations on the same element.
The Generated annotation is used to mark source code that has been generated.
Provides for the specification of generation strategies for the values of primary keys.
Defines the types of primary key generation strategies.
Defines the state used to bootstrap Bean Validation and creates a provider agnostic Configuration.
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.
Represents a message entity of a generic type T.
Defines a generic, protocol-independent servlet.
Represents a generic message entity type T.
Indicates that the annotated method responds to HTTP GET requests.
A group conversion rule to be applied during cascaded validation.
Exception raised if a group definition is not legal.
Callback establishing group principals within the argument subject.
Defines group sequence.
The Handle interface is implemented by all EJB object handles.
The HandleDelegate interface is implemented by the EJB container.
The Handler interface is the base interface for JAX-WS handlers.
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.
This annotation is used to declare the class types that a ServletContainerInitializer can handle.
The handshake request represents the web socket defined Http GET request for the opening handshake of a web socket session.
The handshake response represents the web socket-defined Http response that is the response to the opening handshake request.
Indicates that the annotated method responds to HTTP HEAD requests.
The Header class stores a name/value pair to represent headers.
Binds the value(s) of a HTTP header to a resource method parameter, resource class field, or resource class bean property.
This class implements comparisons for Message headers.
This class tokenizes RFC822 and MIME headers into the basic symbols specified by RFC822 and MIME.
The Token class represents tokens returned by the HeaderTokenizer.
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.
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.
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.
XmlAdapter for xs:hexBinary.
A standard WorkContext that allows a Work instance to propagate quality-of-service (QoS) hints about the Work to the WorkManager.
Holds a value of type T.
The HomeHandle interface is implemented by all home object handles.
The HTTPBinding interface is an abstraction for the XML/HTTP binding.
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.
Java Class representation of an HttpConstraint annotation value.
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.
The HTTPException exception represents a XML/HTTP fault.
This class encapsulates a HTTP request received and a response to be generated in one exchange.
A handler which is invoked to process HTTP requests.
An injectable interface that provides access to HTTP header information.
The HttpJspPage interface describes the interaction that a JSP Page Implementation Class must satisfy when using the HTTP protocol.
Associates the name of a HTTP method with an annotation.
This annotation is used within the ServletSecurity annotation to represent security constraints on specific HTTP protocol messages.
Java Class represntation of an HttpMethodConstraint annotation value.
Provides an abstract class to be subclassed to create an HTTP servlet suitable for a Web site.
Extends the ServletRequest interface to provide request information for HTTP servlets.
Provides a convenient implementation of the HttpServletRequest interface that can be subclassed by developers wishing to adapt the request to a Servlet.
Extends the ServletResponse interface to provide HTTP-specific functionality in sending a response.
Provides a convenient implementation of the HttpServletResponse interface that can be subclassed by developers wishing to adapt the response from a Servlet.
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.
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.
Interface for receiving notification events about HttpSession attribute changes.
Events of this type are either sent to an object that implements HttpSessionBindingListener when it is bound or unbound from a session, or to a HttpSessionAttributeListener that has been configured in the deployment descriptor when any attribute is bound, unbound or replaced in a session.
Causes an object to be notified when it is bound to or unbound from a session.
 
This is the class representing event notifications for changes to sessions within a web application.
Interface for receiving notification events about HttpSession id changes.
Interface for receiving notification events about HttpSession lifecycle changes.
This interface encapsulates the upgrade protocol processing.
 
Specifies the primary key of an entity.
Specifies a composite primary key class that is mapped to multiple fields or properties of the entity.
Instances of the type IdentifiableType represent entity or mapped superclass types.
This exception indicates that an attempt was made to perform an illegal loopback invocation.
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.
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.
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.
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.
The exception thrown when a write is attempted on a read-only attribute of any Messaging object.
Defines variable resolution behavior for the EL implicit objects defined in the JSP specification.
Handles imports of class names and package names.
Used in schema generation to specify creation of an index.
IndexedRecord represents an ordered collection of record elements based on the java.util.List interface.
 
Specifies the inheritance strategy to be used for an entity class hierarchy.
Defines inheritance strategy options.
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 EJB 2.1 or earlier EJBHome or EJBLocalHome client view respectively).
The @Initialized qualifier.
Identifies injectable constructors, methods, and fields.
Indicates a problem relating to dependency injection.
Provides access to metadata about an injection point.
Provides operations for performing dependency injection and lifecycle callbacks on an instance of a type.
An InjectionTargetFactory can create an InjectionTarget for a given bean.
Allows the application to dynamically obtain instances of beans with a specified combination of required type and qualifiers.
This class implements comparisons for integers.
Converter implementation for java.lang.Integer (and int primitive) values.
The javax.resource.cci.Interaction enables a component to execute EIS functions.
An InteractionSpec holds properties for driving an Interaction with an EIS instance.
An interceptor may inject metadata about the bean it is intercepting.
Identifies the kind of lifecycle callback, EJB timeout method or business method interception.
Represents an enabled interceptor.
Specifies that a class is an interceptor.
Priorities that define the order in which interceptors are invoked.
Specifies that an annotation type is an interceptor binding type.
Declares an ordered list of interceptors for a target class, a method or a constructor of a target class.
A runtime exception indicating an internal server error.
This class represents an Internet email address using the syntax of RFC822.
InternetHeaders is a utility class that manages RFC822 style headers.
An individual internet header.
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.
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.
This exception must be thrown when a destination either is not understood by a provider or is no longer valid.
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.
This exception is thrown to indicate invalid configuration property settings.
This exception must be thrown when a JMS client attempts to give a provider a message selector with invalid syntax.
This unchecked exception must be thrown when a JMS client attempts to give a provider a message selector with invalid syntax, and the method signature does not permit a InvalidSelectorException to be thrown.
This exception indicates that the request carried an invalid transaction context.
A client request invocation.
A client request invocation builder.
Callback that can be implemented to receive the asynchronous processing events from the invocation processing.
Exposes context information about the intercepted invocation and operations that enable interceptor methods to control the behavior of the invocation chain.
Invoker hides the detail of calling into application endpoint implementation.
ItemProcessListener intercepts item processing.
ItemProcessor is used in chunk processing to operate on an input item and produce an output item.
ItemReader defines the batch artifact that reads items for chunk processing.
ItemReadListener intercepts item reader processing.
ItemWriteListener intercepts item writer processing.
ItemWriter defines the batch artifact that writes to a list of items for chunk processing.
 
 
The IterationTag interface extends Tag by defining one additional method that controls the reevaluation of its body.
Specifies the statistics provided by a JavaMail resource.
Class that defines convenience methods for common, simple use of JAXB.
The JAXBContext class provides the client's entry point to the JAXB API.
JAXB representation of an Xml Element.
Designates global scope for an xml element.
This is the root exception class for all JAXB exceptions.
Provide access to JAXB xml binding data for a JAXB object.
This class is for JAXB permissions.
JAXP Result implementation that unmarshals a JAXB object.
JAXP Source implementation that marshals a JAXB-generated object.
Specifies the statistics provided by a JCA Connection Pool
Specifies the statistics provided by a JCA connection
Specifies statistics provided by a JCA resource
Specifies the statistics provided by a JDBC connection pool.
Specifies the statistics provided by all (pooled and non-pooled) JDBC connections.
Statistics provided by a JDBC resource
This annotation may be used to specify the JNDI lookup name of a javax.jms.ConnectionFactory to be used when injecting a javax.jms.JMSContext object.
An application may use this annotation to specify a JMS ConnectionFactory resource that it requires in its operational environment.
Specifies one or more JMSConnectionFactoryDefinition annotations.
Specifies the statistics provided by a JMS connection
A client using the simplified JMS API introduced for JMS 2.0 uses a JMSConsumer object to receive messages from a queue or topic.
Specifies the statistics provided by a JMS message consumer
A JMSContext is the main interface in the simplified JMS API introduced for JMS 2.0.
An application may use this annotation to specify a JMS Destination resource that it requires in its operational environment.
Specifies one or more JMSDestinationDefinition annotations.
Specifies the statistics provided by a JMS message producer or a JMS message consumer.
This is the root class of all checked exceptions in the JMS API.
This annotation may be used to specify the userName and password to be used when injecting a javax.jms.JMSContext object.
A JMSProducer is a simple object used to send messages on behalf of a JMSContext.
Specifies the statistics provided by a JMS message producer
This is the root class of all unchecked exceptions in the JMS API.
This exception must be thrown when a provider rejects a user name/password submitted by a client.
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.
This annotation may be used to specify the session mode to be used when injecting a javax.jms.JMSContext object.
Specifies the statistics provided by a JMS session.
Specifies the statistics provided by a JMS Resource
 
 
 
 
 
 
 
JobListener intercepts job execution.
JobOperator provide the interface for operating on batch jobs.
 
 
 
A join to an entity, embeddable, or basic type.
Specifies a column for joining an entity association or element collection.
Specifies the mapping for composite foreign keys.
Specifies the mapping of associations.
Defines the three types of joins.
Factory class for creating JSON processing objects.
JsonArray represents an immutable JSON array (an ordered sequence of zero or more values).
A builder for creating JsonArray models from scratch.
Factory to create JsonObjectBuilder and JsonArrayBuilder instances.
JsonException indicates that some exception happened during JSON processing.
JsonGenerationException indicates an incorrect JSON is being generated.
Writes JSON data to an output source in a streaming way.
Factory to create JsonGenerator instances.
Provides the location information of a JSON event in an input source.
An immutable JSON number value.
JsonObject class represents an immutable JSON object value (an unordered collection of zero or more name/value pairs).
A builder for creating JsonObject models from scratch.
Provides forward, read-only access to JSON data in a streaming way.
An event from JsonParser.
Factory for creating JsonParser instances.
JsonParsingException is used when an incorrect JSON is being parsed.
Service provider for JSON processing objects.
Reads a JSON object or an array structure from an input source.
Factory to create JsonReader instances.
An immutable JSON string value.
Super type for the two structured types in JSON (objects and arrays).
JsonValue represents an immutable JSON value.
Indicates the type of a JsonValue object.
Writes a JSON object or array structure to an output source.
Factory to create JsonWriter instances.
Stores application-scoped information relevant to JSP containers.
This interface provides access to the <jsp-config> related configuration of a web application.
JspContext serves as the base class for the PageContext class and abstracts all information that is not specific to servlets.
The JspEngineInfo is an abstract class that provides information on the current JSP engine.
A generic exception known to the JSP engine; uncaught JspExceptions will result in an invocation of the errorpage machinery.
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.
Encapsulates a portion of JSP code in an object that can be invoked as many times as needed.
This interface indicates to the container that a tag handler wishes to be provided with a compiler generated ID.
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.
This interface provides access to the <jsp-property-group> related configuration of a web application.
Serves as a base class for Tag and SimpleTag.
Exception to be used by a Tag Handler to indicate some unrecoverable error.
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.
Specifies the statistics provided by a JTA resource.
Specifies the statistics provided by a Java VM.
Encapsulates a parameterized ValueExpression.
Contains information about the last execution of a task.
This is a mix-in interface that may be optionally implemented by a ConnectionManager implementation.
This is a mix-in interface that may be optionally implemented by a ConnectionManager implementation.
This is a mix-in interface that may be optionally implemented by a ManagedConnection implementation.
LengthValidator is a Validator that checks the number of characters in the String representation of the value of the associated component.
Lifecycle manages the processing of the entire lifecycle of a particular JavaServer Faces request.
LifecycleFactory is a factory object that creates (if needed) and returns Lifecycle instances.
Provides a simple implementation of Lifecycle that can be subclassed by developers wishing to provide specialized behavior to an existing Lifecycle instance.
Class representing hypermedia links.
Builder class for hypermedia links.
An implementation of JAXB XmlAdapter that maps the JAX-RS Link type to a value that can be marshalled and unmarshalled by JAXB.
Value type for Link that can be marshalled and unmarshalled by JAXB.
Instances of the type ListAttribute represent persistent javax.util.List-valued attributes.
ListDataModel is a convenience implementation of DataModel that wraps an List of Java objects.
Defines property resolution behavior on instances of List.
ListenerRegistration defines the methods which clients of the MEJB use to add and remove event listeners.
Container annotation to specify multiple ListenerFor annotations on a single class.
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.
Load states returned by the ProviderUtil SPI methods.
Specifies that a persistent property or field should be persisted as a large object to a database-supported large object type.
Declares the local business interface(s) for a session bean.
Designates that a session bean exposes a no-interface view.
Class which exposes the locale-determination logic for resource bundles through convenience methods.
Declares the local home or adapted local home interface for a session bean.
Class representing an I18N localization context.
The LocalTransaction defines a transaction demarcation interface for resource manager local transactions.
LocalTransaction interface provides support for transactions that are managed internal to an EIS resource manager, and do not require an external transaction manager.
A LocalTransactionException represents various error conditions related to the local transaction management contract.
An object that represents the Location of a tag or attribute of a tag in a View Declaration Language file.
Declares a concurrency lock for a singleton session bean with container managed concurrency.
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.
Thrown by the persistence provider when an pessimistic locking conflict occurs that does not result in transaction rollback.
Concurrency lock type for singleton beans with container-managed concurrency.
The LogicalHandler extends Handler to provide typesafety for the message context parameter.
The LogicalMessage interface represents a protocol agnostic XML message and contains methods that provide access to the payload of the message.
The LogicalMessageContext interface extends MessageContext to provide access to a the contained message as a protocol neutral LogicalMessage
Converter implementation for java.lang.Long (and long primitive) values.
LongRangeValidator is a Validator that checks the value of the corresponding component against specified minimum and maximum values.
JSTL allows developers to write custom iteration tags by implementing the LoopTag interface.
Exposes the current status of an iteration.
Base support class to facilitate implementation of iteration tags.
Formats and parses date specification based on the draft-ietf-drums-msg-fmt-08 dated January 26, 2000.
Common base class for mail events, defining the dispatch method.
Annotation used by Java EE applications to define a MailSession to be registered with JNDI.
Declares one or more MailSessionDefinition annotations.
Interface to be implemented by the Java™ EE product providers on threads that are created by calling ThreadFactory.newThread(java.lang.Runnable).
The ManagedBean annotation marks a POJO (Plain Old Java Object) as a ManagedBean.A ManagedBean supports a small set of basic services such as resource injection, lifecycle callbacks and interceptors.
The presence of this annotation on a class automatically registers the class with the runtime as a managed bean class.
ManagedConnection instance represents a physical connection to the underlying EIS.
ManagedConnectionFactory instance is a factory of both ManagedConnection and EIS-specific connection factory instances.
The ManagedConnectionMetaData interface provides information about the underlying EIS instance associated with a ManagedConnection instance.
Utility methods for classes defined in this package.
A manageable version of a ExecutorService.
The presence of this annotation on a field of a class annotated with ManagedBean instructs the system to inject a value into this property as described in section JSF.5.3 of the spec prose document in the <managed-property> subsection.
A manageable version of a ScheduledExecutorService.
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.
A ManagedTaskListener is used to monitor the state of a task's Future.
A manageable version of a ThreadFactory.
Instances of the type ManagedType represent entity, mapped superclass, and embeddable types.
The Management interface provides the APIs to navigate and manipulate managed objects.
The required home interface for the J2EE Management EJB component (MEJB).
Specifies a many-valued association with many-to-many multiplicity.
Specifies a single-valued association to another entity class that has many-to-one multiplicity.
Instances of the type MapAttribute represent persistent java.util.Map-valued attributes.
Defines property resolution behavior on instances of Map.
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.
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.
Specifies the type of the map key for associations of type java.util.Map.
Specifies the mapping for the key column of a map whose map key is a basic type.
Specifies the enum type for a map key whose basic type is an enumerated type.
Specifies a mapping to an entity that is a map key.
Supports composite map keys that reference entities.
This annotation must be specified for persistent map keys of type Date and Calendar.
A MapMessage object is used to send a set of name-value pairs.
The interface javax.resource.cci.MappedRecord is used for key-value map based representation of record elements.
Designates a class whose mapping information is applied to the entities that inherit from it.
Instances of the type MappedSuperclassType represent mapped superclass types.
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.
This exception indicates that an error has occurred while performing a marshal operation that the provider is unable to recover from.
The Marshaller class is responsible for governing the process of serializing Java content trees back into XML data.
Register an instance of an implementation of this class with a Marshaller to externally listen for marshal events.
Binds the value(s) of a URI matrix parameter to a resource method parameter, resource class field, or resource class bean property.
The annotated element must be a number whose value must be lower or equal to the specified maximum.
Defines several Max annotations on the same element.
An abstraction for a media type.
The Message interface is the root interface of all JMS messages.
This class models an email message.
This inner class defines the types of recipients allowed by the Message class.
An interface optionally implemented by DataSources to supply information to a DataContentHandler about the message context in which the data content object is operating.
Contract for a provider that supports the conversion of a stream to a Java type.
Contract for a provider that supports the conversion of a Java type to a stream.
This class models Message change events.
This is the Listener interface for MessageChanged events
A client uses a MessageConsumer object to receive messages from a destination.
The context in which a piece of Message content is contained.
The interface MessageContext abstracts the message context that is processed by a handler in the handle method.
Property scope.
The adapter which receives MessageCount events.
This class notifies changes in the number of messages in a folder.
This is the Listener interface for MessageCount events.
Component-defining annotation for a message driven bean.
The MessageDrivenBean interface defines methods that the EJB container uses to notify a message driven bean instance of the instance's life cycle events.
Specifies the statistics provided by a message driven bean.
The MessageDrivenContext interface provides access to the runtime message-driven context that the container provides for a message-driven bean instance.
This defines a contract for a message endpoint.
This serves as a factory for creating message endpoints.
This exception must be thrown when an unexpected end of stream has been reached when a StreamMessage or BytesMessage is being read.
This exception must be thrown when a JMS client attempts to use a data type not supported by a message or attempts to read data in a message as the wrong type.
This unchecked exception must be thrown when a JMS 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.
Developers implement MessageHandlers in order to receive incoming messages during a web socket conversation.
This kind of handler is notified by the implementation as it becomes ready to deliver parts of a whole message.
This kind of handler is notified by the container on arrival of a complete message.
This term models the RFC822 "MessageId" - a message-id for Internet messages that is supposed to be unique per message.
A message processing runtime uses this interface to pass messages and message processing state to authentication contexts for processing by authentication modules.
Interpolates a given constraint violation message.
Information related to the interpolation context.
A MessageListener object is used to receive asynchronously delivered messages.
This serves as a request-response message listener type that message endpoints (message-driven beans) may implement.
This exception must be thrown when a JMS client attempts to read a write-only message.
This exception must be thrown when a JMS client attempts to write to a read-only message.
This unchecked exception must be thrown when a JMS client attempts to write to a read-only message.
This class implements comparisons for Message numbers.
This class defines a message authentication policy.
This interface is used to represent message authentication policy.
This interface is used to represent and perform message targeting.
This class defines the message protection policies for specific Targets.
A client uses a MessageProducer object to send messages to a destination.
The exception thrown when an invalid method is invoked on an expunged Message.
The base class for all exceptions thrown by the Messaging classes
There are concrete subclasses within the implementation that map concepts in the Facelet VDL page to JSF Java API calls the appropriate instances.
Information used with MetaRule for determining how and what Metadata should be wired.
Provides access to the metamodel of persistent entities in the persistence unit.
The root class of the abstraction that dictates how attributes on a markup element in a Facelets VDL page are wired to the JSF API object instance associated with that element.
A mutable set of rules to be used in auto-wiring state to a particular object instance.
Every kind of markup element in Facelets VDL that has attributes that need to take action on a JSF Java API artifact is associated with an instance of this class.
Deprecated.
This has been replaced by MethodExpression.
Create a method call node in the current Flow.
Represents a method call node in the flow graph.
Describes a validated method.
An Expression that refers to a method on an object.
MethodExpressionActionListener is an ActionListener that wraps a MethodExpression.
MethodExpressionValidator is a Validator that wraps a MethodExpression, and it performs validation by executing a method on an object identified by the MethodExpression.
MethodExpressionValueChangeListener is a ValueChangeListener that wraps a MethodExpression.
Holds information about a method that a MethodExpression evaluated to.
Thrown when a method could not be found while evaluating a MethodExpression.
Deprecated.
This has been replaced by MethodNotFoundException.
The exception thrown when a method is not supported by the implementation
Represents the type of a method: getter or non getter.
The Metric interface defines job metrics recorded by the batch runtime.
 
This class represents a MIME body part.
This class represents a MIME style email message.
This inner class extends the javax.mail.Message.RecipientType class to add additional RecipientTypes.
The MimeMultipart class is an implementation of the abstract Multipart class that uses MIME conventions for the multipart data.
The MimePart interface models an Entity as defined by MIME (RFC2045, Section 2.4).
A utility class that implements a DataSource out of a MimePart.
This is a utility class that provides various MIME related functionality.
The annotated element must be a number whose value must be higher or equal to the specified minimum.
Defines several Min annotations on the same element.
The built-in stereotype intended for use with beans that define the model layer of an MVC web application architecture such as JSF.
This feature represents the use of MTOM with a web service.
This feature represents the use of MTOM with a web service.
Multipart is a container that holds multiple body parts.
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.
Java Class represntation of an MultipartConfig annotation value.
MultipartDataSource is a DataSource that contains body parts.
A hash table based implementation of MultivaluedMap interface.
A map of key-values pairs.
Meta-annotation used to create name binding annotations for filters and interceptors.
String-based qualifier.
A NamedAttributeNode is a member element of a NamedEntityGraph.
Used to specify the path and boundaries for a find operation or query.
Used to group NamedEntityGraph annotations.
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.
Specifies multiple native SQL named queries.
Specifies a named native SQL query.
Specifies multiple named Java Persistence query language queries.
Specifies a static, named query in the Java Persistence query language.
Specifies multiple named stored procedure queries.
Specifies and names a stored procedure, its parameters, and its result type.
A NamedSubgraph is a member element of a NamedEntityGraph.
NamingContainer is an interface that must be implemented by any UIComponent that wants to be a naming container.
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.
Create a navigation case in the current Flow.
Provides a simple implementation of NavigationCase that can be subclassed by developers wishing to provide specialized behavior to an existing NavigationCase instance.
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 provides a simple implementation of NavigationHandler that can be subclassed by developers wishing to provide specialized behavior to an existing NavigationHandler instance.
The New qualifier was deprecated in CDI 1.1.
Used to create a new HTTP cookie, transferred in a response.
This class models an RFC1036 newsgroup address.
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.
Base interface for building all kinds of flow nodes.
This exception indicates that a calendar-based timer will not result in any more timeouts.
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.
When this annotation, along with ManagedBean is found on a class, the runtime must act as if a <managed-bean-scope>none<managed-bean-scope> element was declared for the corresponding managed bean.
Indicates that the conversation context could not be restored.
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.
Thrown by the persistence provider when Query.getSingleResult() or TypedQuery.getSingleResult()is executed on a query and there is no result to return.
XmlAdapter to handle xs:normalizedString.
Specifies that an annotation type is a normal scope type.
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.
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.
 
 
 
A NoSuchObjectLocalException is thrown if an attempt is made to invoke a method on a local object (local EJB object or timer) that no longer exists.
This exception is thrown when Session attempts to instantiate a Provider that doesn't exist.
A runtime exception indicating that a client request is not acceptable by the server.
A runtime exception indicating a client requesting a resource method that is not allowed.
A runtime exception indicating request authorization failure caused by one of the following scenarios: a client did not send the required authorization credentials to access the requested resource, i.e.
A runtime exception indicating a resource requested by a client was not found on the server.
This event indicates that a problem was encountered resolving an ID/IDREF.
Default implementation of the NotIdentifiableEvent interface.
The annotated element must not be null.
Defines several NotNull annotations on the same element.
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 exception indicates that the request cannot be executed because the operation is not a supported feature.
A runtime exception indicating that the client request entity media type is not supported.
This class implements the logical NEGATION operator.
The annotated element must be null.
Defines several Null annotations on the same element.
Converter implementation for java.lang.Number values.
An ObjectMessage object is used to send a message that contains a serializable object in the Java programming language ("Java object").
The ObjectNotFoundException exception is thrown by a finder or select method to indicate that the specified EJB object or local object does not exist.
Indicates that a checked exception was thrown by an observer method during event notification.
Represents an observer method of an enabled bean.
Identifies the event parameter of an observer method.
This method level annotation can be used to decorate a Java method that wishes to be called when a web socket session is closing.
This method level annotation can be used to decorate a Java method that wishes to be called in order to handle errors.
Specifies a many-valued association with one-to-many multiplicity.
Specifies a single-valued association to another entity that has one-to-one multiplicity.
This method level annotation can be used to make a Java method receive incoming web socket messages.
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.
Thrown by the persistence provider when an optimistic locking conflict occurs.
Indicates that the annotated method responds to HTTP OPTIONS requests.
An object that defines an ordering over the query results.
Specifies the ordering of the elements of a collection valued association or element collection at the point when the association or collection is retrieved.
Specifies a column that is used to maintain the persistent order of a list.
This class implements the logical OR operator on individual SearchTerms.
Marks an attribute as overriding the attribute of a composing constraint.
Defines several OverridesAttribute annotations on the same element
PageContext extends JspContext to provide useful context information for when JSP technology is used in a Servlet environment.
Translation-time information on a JSP page.
Defines a contract for a delegate responsible for converting between a String form of a message parameter value and the corresponding custom Java type T.
Mandates that a conversion of any default value delegated to a parameter converter annotated with @Lazy annotation SHOULD occur only once the value is actually required (e.g.
Contract for a provider of ParamConverter instances.
Represents a parameter in any of several places where parameters are needed when processing flows.
Type for query parameter objects.
Describes a validated method or constructor parameter.
Type of criteria query parameter expressions.
This class holds MIME parameters (attribute-value pairs).
Specifies the mode of a parameter of a stored procedure query.
Provides names for method and constructor parameters.
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.
Default implementation of the ParseConversionEvent interface.
The exception thrown due to an error in parsing RFC822 or MIME headers
The Part interface is the common base interface for Messages and BodyParts.
This class represents a part or form item that was received within a multipart/form-data POST request.
PartialResponseWriter decorates an existing ResponseWriter to support the generation of a partial response suitable for Ajax operations.
Components that want to leverage the partial state saving feature must implement this interface instead of implementing StateHolder, from which this interface inherits.
PartialViewContext contains methods and properties that pertain to partial request processing and partial response rendering on a view.
PartialViewContextFactory is a factory object that creates (if needed) and returns new PartialViewContext instances.
Provides a simple implementation of PartialViewContext that can be subclassed by developers wishing to provide specialized behavior to an existing PartialViewContext instance.
PartitionAnalyzer receives control to process data and final results from each partition.
PartitionCollector provides a way to pass data from individual partitions to a single point of control running on the step's parent thread.
PartitionMapper receives control at the start of a partitioned execution.
 
The PartitionPlanImpl class provides a basic implementation of the PartitionPlan interface.
PartitionReducer provides unit of work demarcation across partitions.
 
Indicates that a custom implementation of Bean or Contextual is passivation capable.
The class PasswordAuthentication is a data holder that is used by Authenticator.
The class PasswordCredential acts as a holder for username and password.
Callback for PasswordValidation.
The annotated element must be a date in the past.
Defines several Past annotations on the same element.
Represents a simple or compound attribute path from a bound type or collection, and is a "primitive" expression.
Represents the navigation path from an object to another in an object graph.
Identifies the URI path that a resource class or class method will serve requests for.
Node representing a bean.
Node representing a constructor.
Node representing the element holding cross-parameter constraints of a method or constructor.
Node representing a method.
Represents an element of a navigation path.
Node representing a parameter of a method or constructor.
Node representing a property.
Node representing the return value of a method or constructor.
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.
Binds the value of a URI template parameter or a path segment containing the template parameter to a resource method parameter, resource class field, or resource class bean property.
Represents a URI path segment and any associated matrix parameters.
The annotated CharSequence must match the specified regular expression.
Possible Regexp flags.
Defines several Pattern annotations on the same element.
Payload type that can be attached to a given constraint declaration.
Specifies that all security roles are allowed to invoke the specified method(s) i.e that the specified method(s) are "unchecked".
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.
Bootstrap class that is used to obtain an EntityManagerFactory in Java SE environments.
Expresses a dependency on a container-managed EntityManager and its associated persistence context.
Declares one or more PersistenceContext annotations.
Specifies whether a transaction-scoped or extended persistence context is to be used in PersistenceContext.
Thrown by the persistence provider when a problem occurs.
Describes a single container or persistence provider property.
Interface implemented by the persistence provider.
Determine the list of persistence providers available in the runtime environment.
Holds the global PersistenceProviderResolver instance.
Expresses a dependency on an EntityManagerFactory and its associated persistence unit.
Interface implemented by the container and used by the persistence provider when creating an EntityManagerFactory.
Declares one or more PersistenceUnit annotations.
Specifies whether entity managers created by the EntityManagerFactory will be JTA or resource-local entity managers.
Utility interface between the application and the persistence provider managing the persistence unit.
Utility interface between the application and the persistence provider(s).
Thrown by the persistence provider when an pessimistic locking conflict occurs.
Defines the values of the javax.persistence.lock.scope property for pessimistic locking.
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.
Typesafe enumeration of the legal values that may be returned by the getPhaseId() method of the FacesEvent interface.
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.
Instances of the type PluralAttribute represent persistent collection-valued attributes.
 
The PluralJoin interface defines functionality that is common to joins to all collection types.
The methods of this interface are used by containers to create policy statements in a Policy provider.
Abstract factory and finder class for obtaining the instance of the class that implements the PolicyConfigurationFactory of a provider.
This utility class is used by containers to communicate policy context identifiers and other policy relevant context to Policy providers.
This checked exception is thrown by implementations of the javax.security.jacc.PolicyConfiguration Interface, the javax.security.jacc.PolicyConfigurationFactory abstract class, the javax.security.jacc.PolicyContext utility class, and implementations of the javax.security.jacc.PolicyContextException Interface.
This interface defines the methods that must be implemented by handlers that are to be registered and activated by the PolicyContext class.
The PongMessage interface represents a web socket pong.
The PortInfo interface is used by a HandlerResolver to query information about the port it is being asked to create a handler chain for.
Indicates that the annotated method responds to HTTP POST requests.
Designates a method to receive a callback after a stateful session bean has been activated.
When an instance of this event is passed to SystemEventListener.processEvent(javax.faces.event.SystemEvent) or ComponentSystemEventListener.processEvent(javax.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.
The PostConstruct annotation is used on a method that needs to be executed after dependency injection is done to perform any initialization.
This event must be published by the runtime after all configuration resources have been parsed and processed.
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.
This event must be published by a call to {javax.faces.application.Application#publishEvent} when the view map is first created.
Specifies a callback method for the corresponding lifecycle event.
Specifies a callback method for the corresponding lifecycle event.
Specifies a callback method for the corresponding lifecycle event.
When an instance of this event is passed to SystemEventListener.processEvent(javax.faces.event.SystemEvent) or ComponentSystemEventListener.processEvent(javax.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.
Specifies a callback method for the corresponding lifecycle event.
When an instance of this event is passed to SystemEventListener.processEvent(javax.faces.event.SystemEvent) or ComponentSystemEventListener.processEvent(javax.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.
The PreDestroy annotation is used on methods as a callback notification to signal that the instance is in the process of being removed by the container.
This event must be published by the runtime before the factories associated with this Application are released.
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.
The type of a simple or compound predicate: a conjunction or disjunction of restrictions.
 
A MimeBodyPart that handles data that has already been encoded.
This ExceptionHandlerFactory instance produces JSF 1.2 compatible ExceptionHandler instances.
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.
Designates a method to receive a callback before a stateful session bean is passivated.
Specifies a callback method for the corresponding lifecycle event.
Specifies a callback method for the corresponding lifecycle event.
When an instance of this event is passed to SystemEventListener.processEvent(javax.faces.event.SystemEvent) or ComponentSystemEventListener.processEvent(javax.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.
When an instance of this event is passed to SystemEventListener.processEvent(javax.faces.event.SystemEvent) or ComponentSystemEventListener.processEvent(javax.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.
When an instance of this event is passed to SystemEventListener.processEvent(javax.faces.event.SystemEvent) or ComponentSystemEventListener.processEvent(javax.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.
Specifies a callback method for the corresponding lifecycle event.
When an instance of this event is passed to SystemEventListener.processEvent(javax.faces.event.SystemEvent) or ComponentSystemEventListener.processEvent(javax.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.
Specifies a primary key column that is used as a foreign key to join to another table.
Groups PrimaryKeyJoinColumn annotations.
This event indicates that a problem was encountered while converting data from the Java content tree into its lexical representation.
Default implementation of the PrintConversionEvent interface.
A collection of built-in priority constants for the JAX-RS components that are supposed to be ordered based on their javax.annotation.Priority class-level annotation value when used or applied by JAX-RS runtime.
The Priority annotation can be applied to classes to indicate in what order the classes should be used.
Callback for acquiring a Public Key Infrastructure (PKI) private key and its corresponding certificate chain.
Request type for private keys that are identified using an alias.
Request type for private keys that are identified using a certificate digest or thumbprint.
Request type for private keys that are identified using an issuer/serial number.
Marker interface for private key request types.
Request type for private keys that are identified using a SubjectKeyID
The container fires an event of this type for each Java class or interface it discovers in a bean archive, before it reads the declared annotations.
The container fires an event of this type for each enabled bean, interceptor or decorator deployed in a bean archive, before registering the Bean object.
The container fires an event of this type for each enabled bean, interceptor or decorator deployed in a bean archive before registering the Bean object.
A base JAX-RS runtime processing exception.
The container fires an event of this type for every injection point of every Java EE component class supporting injection that may be instantiated by the container at runtime, including every managed bean declared using javax.annotation.ManagedBean, EJB session or message-driven bean, enabled bean, enabled interceptor or enabled decorator.
The container fires an event of this type for every Java EE component class supporting injection that may be instantiated by the container at runtime, including every managed bean declared using javax.annotation.ManagedBean, EJB session or message-driven bean, enabled bean, enabled interceptor or enabled decorator.
The container fires an event of this type for each enabled managed bean, before registering the Bean object.
The container fires an event of this type for each observer method of each enabled bean, before registering the ObserverMethod object.
The container fires an event of this type for each producer method or field of each enabled bean, including resources.
The container fires an event of this type for each enabled producer field, before registering the Bean object.
The container fires an event of this type for each enabled producer method, before registering the Bean object.
The container fires an event of this type for each enabled session bean, before registering the Bean object.
The container fires an event of this type for each Java class or interface added by BeforeBeanDiscovery.addAnnotatedType(AnnotatedType).
Provides a generic operation for producing an instance of a type.
An ProducerFactory can create an Producer for a given bean.
Identifies a producer method or field.
Defines the media type(s) that the methods of a resource class or MessageBodyWriter can produce.
This class enables a feature similar to the RAILS_ENV feature of the Ruby on Rails web framework.
Describes a Java Bean property hosting validation constraints.
This exception indicates that an error was encountered while getting or setting a property.
Thrown when a property could not be found while evaluating a ValueExpression or MethodExpression.
Deprecated.
This has been replaced by PropertyNotFoundException.
Thrown when a property could not be written to while setting the value on a ValueExpression.
Deprecated.
This has been replaced by ELResolver.
This exception is thrown by the runtime when a violation of the view protection mechanism is encountered.
The ProtocolException class is a base class for exceptions related to a specific protocol binding.
Provides instances of T.
The Provider is a class that describes a protocol implementation.
Marks an implementation of an extension interface that should be discoverable by JAX-RS runtime during a provider scanning phase.
Service endpoints may implement the Provider interface as a dynamic alternative to an SEI.
Service provider for ServiceDelegate and Endpoint objects.
This inner class defines the Provider type.
An injectable interface providing runtime lookup of provider instances.
Defines the state used to bootstrap Bean Validation and creates a provider specific Configuration of type T.
Utility interface implemented by the persistence provider.
Indicates that the annotated method responds to HTTP PUT requests.
Identifies qualifier annotations.
Interface used to control query execution.
Used to supply a query property or hint to the NamedQuery or NamedNativeQuery annotation.
Binds the value(s) of a HTTP query parameter to a resource method parameter, resource class field, or resource class bean property.
Thrown by the persistence provider when a query times out and only the statement is rolled back.
A Queue object encapsulates a provider-specific queue name.
A client uses a QueueBrowser object to look at messages on a queue without removing them.
A QueueConnection object is an active connection to a point-to-point JMS provider.
A client uses a QueueConnectionFactory object to create QueueConnection objects with a point-to-point JMS provider.
A client uses a QueueReceiver object to receive messages that have been delivered to a queue.
The QueueRequestor helper class simplifies making service requests.
A client uses a QueueSender object to send messages to a queue.
A QueueSession object provides methods for creating QueueReceiver, QueueSender, QueueBrowser, and TemporaryQueue objects.
This class represents a set of quotas for a given quota root.
An individual resource in a quota root.
An interface implemented by Stores that support quotas.
Specifies standard measurements of the lowest and highest values an attribute has held as well as its current value.
Context class used by ReaderInterceptor to intercept calls to (@link javax.ws.rs.ext.MessageBodyReader#readFrom}.
This class represents a call-back mechanism that will notify implementations as HTTP request data becomes available to be read without blocking.
This exception is thrown when an attempt is made to open a folder read-write access when the folder is marked read-only.
This class implements comparisons for the Message Received date
Distinguishes conditional observer methods from observer methods which are always notified.
This class implements string comparisons for the Recipient Address headers.
This class implements comparisons for the Recipient Address headers.
The javax.resource.cci.Record interface is the base interface for the representation of an input or output to the execute methods defined on an Interaction.
The RecordFactory interface is used for creating MappedRecord and IndexedRecord instances.
A runtime application exception indicating a request redirection (HTTP 3xx status codes).
The Referenceable interface extends the javax.naming.Referenceable interface.
The presence of this annotation on a class is equivalent to the referenced-bean element in the application configuration resources.
Deprecated.
This has been replaced by ELException.
A Validator that checks against a Regular Expression (which is the pattern property).
Interface through which a Servlet or Filter may be further configured.
Interface through which a Servlet or Filter registered via one of the addServlet or addFilter methods, respectively, on ServletContext may be further configured.
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.
Declares the remote business interface(s) for a session bean.
The RemoteEndpoint object is supplied by the container and represents the 'other end' or peer of the Web Socket conversation.
This representation of the peer of a web socket conversation has the ability to send messages asynchronously.
This representation of the peer of a web socket conversation has the ability to send messages synchronously.
Declares the remote home interface or adapted remote home interface for a session bean.
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.
The RemoveException is thrown at an attempt to remove an EJB object or local EJB object when the enterprise bean or the container does not allow the EJB object to be removed.
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.
Provides a simple implementation of Renderer that can be subclassed by developers wishing to provide specialized behavior to an existing Renderer instance.
RenderKit represents a collection of Renderer instances that, together, know how to render JavaServer Faces UIComponent instances for a specific client.
RenderKitFactory is a factory object that registers and returns RenderKit instances.
Provides a simple implementation of RenderKit that can be subclassed by developers wishing to provide specialized behavior to an existing RenderKit instance.
A constraint annotation hosting this annotation will return the composed annotation error report if any of the composing annotations fail.
An injectable helper for request processing, all methods throw an IllegalStateException if called outside the scope of a request (e.g.
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.
Specifies that a bean is request scoped.
When this annotation, along with ManagedBean is found on a class, the runtime must act as if a <managed-bean-scope>request<managed-bean-scope> element was declared for the corresponding managed bean.
Used to annotate methods in the Service Endpoint Interface with the request wrapper bean to be used at runtime.
A Validator that checks for an empty value in the same way that UIInput checks for a value.
Indicates a problem relating to typesafe resolution.
The Resource annotation marks a resource that is needed by the application.
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.
The two possible authentication types for a resource.
This represents a resource adapter instance and contains operations for lifecycle management and message endpoint setup.
This interface specifies the methods to associate a ResourceAdapter object with other objects that implement this interface like ManagedConnectionFactory and ActivationSpec.
A ResourceAdapterInternalException indicates any system-level error conditions related to a resource adapter.
The interface javax.resource.cci.ResourceAdapterMetaData provides information about capabilities of a resource adapter implementation.
This exception is thrown when a provider is unable to allocate the resources required by a method.
A ResourceAllocationException can be thrown by an application server or resource adapter to indicate any failure to allocate system resources (example: threads, physical connections).
This unchecked exception is thrown when a provider is unable to allocate the resources required by a method.
Defines property resolution behavior on instances of ResourceBundle.
The resource context provides access to instances of resource classes.
Container annotation to specify multiple ResourceDependency annotations on a single class.
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.
This is the root interface of the exception hierarchy defined for the Connector architecture.
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.
Provides a simple implementation of ResourceHandler that can be subclassed by developers wishing to provide specialized behavior to an existing ResourceHandler instance.
An injectable class to access the resource class and resource method matched by the current request.
Deprecated.
This class is used to allow multiple resources declarations.
A ResourceWarning provides information on warnings related to execution of an interaction with an EIS.
Provides a simple implementation of Resource that can be subclassed by developers wishing to provide specialized behavior to an existing Resource instance.
This feature clarifies the use of the wsdl:binding in a JAX-WS runtime.
This feature clarifies the use of the wsdl:binding in a JAX-WS runtime.
Defines the contract between a returned instance and the runtime when an application needs to provide meta-data to the runtime.
The Response interface provides methods used to obtain the payload and context of a message sent in response to an operation invocation.
A class used to build Response instances that contain metadata instead of or in addition to an entity.
Commonly used status codes defined by HTTP, see {@link <a href="http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10">HTTP/1.1 documentation} for the complete list.
An enumeration representing the class of status code.
Base interface for statuses used in responses.
JAX-RS client-side runtime processing exception thrown to indicate that response processing has failed (e.g.
ResponseStateManager is the helper class to StateManager that knows the specific rendering technology being used to generate the response.
ResponseStream is an interface describing an adapter to an underlying output mechanism for binary output.
Used to annotate methods in the Service Endpoint Interface with the response wrapper bean to be used at runtime.
ResponseWriter is an abstract class describing an adapter to an underlying output mechanism for character-based output.
Provides a simple implementation of ResponseWriter that can be subclassed by developers wishing to provide specialized behavior to an existing ResponseWriter instance.
This interface represents the result of a <sql:query> action.
ResultDataModel is a convenience implementation of DataModel that wraps a JSTL Result object, typically representing the results of executing an SQL query via JSTL tags.
A ResultSet represents tabular data that is retrieved from an EIS instance by the execution of an Interaction..
ResultSetDataModel is a convenience implementation of DataModel that wraps a ResultSet of Java objects.
The interface javax.resource.cci.ResultSetInfo provides information on the support provided for ResultSet by a connected EIS instance.
Supports the creation of a javax.servlet.jsp.jstl.sql.Result object from a source java.sql.ResultSet object.
A marker interface indicating that the Exception is transient.
A subclass of the UnavailableException that indicates that the rejection of the work submission is transient.
A subclass of the WorkRejectedException that indicates that the the service unavailability is transient.
RetryProcessListener intercepts retry processing for an ItemProcessor.
RetryReadListener intercepts retry processing for an ItemReader.
RetryWriteListener intercepts retry processing for an ItemWriter.
Create a return node in the current Flow.
Represents a return node in the flow graph.
Describes a validated return value of a method or constructor.
Specifies the list of roles permitted to access method(s) in an application.
Thrown by the persistence provider when EntityTransaction.commit() fails.
RollbackException exception is thrown when the transaction has been marked for rollback only or the transaction has been rolled back instead of committed.
A root type in the from clause.
Defines the identity of the application during execution in a J2EE container.
Implementations of JAX-RS provide a concrete subclass of RuntimeDelegate and various JAX-RS API methods defer to methods of RuntimeDelegate for their functionality.
Defines the contract for a delegate that is responsible for converting between the String form of a HTTP header and the corresponding JAX-RS type T.
Enumeration of JAX-RS runtime types.
ScalarDataModel is a convenience implementation of DataModel that wraps an individual Java object.
Schedule a timer for automatic creation with a timeout schedule based on a cron-like time expression.
A calendar-based timeout expression for an enterprise bean timer.
Applied to a timer callback method to schedule multiple calendar-based timers for the method.
Controls where a JAXB implementation puts the generates schema files.
Identifies scope annotations.
Scope looked at when discovering constraints.
A structure that contains the name of the scope and the scope itself exposed as a Map<String, Object>.
Defines variable resolution behavior for scoped attributes.
A TagLibraryValidator for enforcing restrictions against the use of JSP scripting elements.
The exception thrown when a Search expression could not be handled.
Search criteria are expressed as a tree of search-terms, forming a parse-tree for the search expression.
Specifies a secondary table for the annotated entity class.
Specifies multiple secondary tables for an entity.
Callback for acquiring a shared secret from a key repository.
Request type for secret keys that are identified using an alias.
Marker interface for secret key request types.
A standard WorkContext that allows a Work instance to propagate security related context information from an EIS to an application server.
An injectable interface that provides access to security related information.
A SecurityException indicates error conditions related to the security contract between an application server and resource adapter.
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
The Selection interface defines an item that is to be returned in a query result.
SelectItem represents a single item in the list of supported items associated with a UISelectMany or UISelectOne component.
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.
This exception is thrown when the message cannot be sent.
A simple callback object for asynchronous sending of web socket messages.
The result of asynchronously sending a web socket message.
This class implements comparisons for the Message SentDate.
Defines a primary key generator that may be referenced by name when a generator element is specified for the GeneratedValue annotation.
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.
An implementation of this interface is used to validate received service request messages, and to secure service response messages.
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).
This ServerAuthContext class encapsulates ServerAuthModules that are used to validate service requests received from clients, and to secure any response returned for those requests.
A ServerAuthModule validates client requests and secures responses to the client.
The ServerContainer is the specialized view of the WebSocketContainer available in server-side deployments.
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.
The ServerEndpointConfig is a special kind of endpoint configuration object that contains web socket configuration information specific only to server endpoints.
The ServerEndpointConfig.Builder is a class used for creating ServerEndpointConfig.Builder objects for the purposes of deploying a server endpoint.
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.
A base runtime application exception indicating a server error (HTTP 5xx status codes).
A ServerSession object is an application server object that is used by a server to associate a thread with a JMS session (optional).
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).
An abstract class that contains the functionality common to messaging services, such as stores and transports.
Service objects provide the client view of a Web service.
The orientation of a dynamic client or service.
Service delegates are used internally by Service objects to allow pluggability of JAX-WS implementations.
Used to indicate whether a Provider implementation wishes to work with entire protocol messages or just with protocol message payloads.
A runtime exception indicating that the requested resource cannot be served.
Defines methods that all servlets must implement.
A servlet configuration object used by a servlet container to pass information to a servlet during initialization.
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.
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.
Event class for notifications about changes to the attributes of the ServletContext of a web application.
Interface for receiving notification events about ServletContext attribute changes.
This is the event class for notifications about changes to the servlet context of a web application.
Interface for receiving notification events about ServletContext lifecycle changes.
Defines a general exception a servlet can throw when it encounters difficulty.
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.
Provides an output stream for sending binary data to the client.
Interface through which a Servlet may be further configured.
Interface through which a Servlet registered via one of the addServlet methods on ServletContext may be further configured.
Defines an object to provide client request information to a servlet.
This is the event class for notifications of changes to the attributes of the servlet request in an application.
Interface for receiving notification events about ServletRequest attribute changes.
Events of this kind indicate lifecycle events for a ServletRequest.
Interface for receiving notification events about requests coming into and going out of scope of a web application.
Provides a convenient implementation of the ServletRequest interface that can be subclassed by developers wishing to adapt the request to a Servlet.
Defines an object to assist a servlet in sending a response to the client.
Provides a convenient implementation of the ServletResponse interface that can be subclassed by developers wishing to adapt the response from a Servlet.
This annotation is used on a Servlet implementation class to specify security constraints to be enforced by a Servlet container on HTTP protocol messages.
Defines the access semantic to be applied to an empty rolesAllowed array.
Defines the data protection requirements that must be satisfied by the transport
Java Class represntation of a ServletSecurity annotation value.
Specifies the statistics provided by a Servlet.
A Session object is a single-threaded context for producing and consuming messages.
The Session class represents a mail session and is not subclassed.
A Web Socket session represents a conversation between two web socket endpoints.
The SessionBean interface defines methods that the EJB container uses to notify a session bean instance of the instance's life cycle events.
Specifies the statistics provided by session beans of both stateful and stateless types.
Identifies the kind of EJB session bean.
The SessionContext interface provides access to the runtime session context that the container provides for a session bean instance.
Class that may be used to configure various properties of cookies used for session tracking purposes.
A SessionException represents a general exception type reporting problems occurring on a websocket session.
Specifies that a bean is session scoped.
When this annotation, along with ManagedBean is found on a class, the runtime must act as if a <managed-bean-scope>session<managed-bean-scope> element was declared for the corresponding managed bean.
The SessionSynchronization interface allows a stateful session bean instance to be notified by its container of transaction boundaries.
Enumeration of session tracking modes.
Instances of the type SetAttribute represent persistent java.util.Set-valued attributes.
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.
A ByteArrayInputStream that implements the SharedInputStream interface, allowing the underlying byte array to be shared between multiple readers.
Specifies how the provider must use a second-level cache for the persistence unit.
A SharedFileInputStream is a BufferedInputStream that buffers data from the file and supports the mark and reset methods.
An InputStream that is backed by data that can be shared by multiple readers may implement this interface.
This is thrown to indicate a connection sharing violation.
Converter implementation for java.lang.Short (and short primitive) values.
Interface for defining Simple Tag Handlers.
A base class for defining tag handlers implementing SimpleTag.
Ensures that servlets handle only one request at a time.
Component-defining annotation for a singleton session bean.
Identifies a type that the injector only instantiates once.
Instances of the type SingularAttribute represents persistent single-valued properties or fields.
The annotated element size must be between the specified boundaries (included).
Defines several Size annotations on the same element.
This class implements comparisons for Message sizes.
Exception to indicate the calling page must cease evaluation.
Exception indicating that the result of a value-producing task cannot be retrieved because the task run was skipped.
SkipProcessListener intercepts skippable itemProcess exception handling.
SkipReadListener intercepts skippable itemReader exception handling.
SkipWriteListener intercepts skippable itemWriter exception handling.
The SOAPBinding interface is an abstraction for the SOAP binding.
The SOAPFaultException exception represents a SOAP 1.1 or 1.2 fault.
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.
The interface SOAPMessageContext provides access to the SOAP message for either RPC request or response.
Indicates that a bean directly specializes another bean.
This interface allows tag handlers implementing it to receive values for parameter markers in their SQL statements.
Specifies the mapping of the result of a native SQL query or stored procedure.
Is used to define one or more SqlResultSetMapping annotations.
A standard ELContext suitable for use in a stand alone environment.
Mark a singleton bean for eager initialization during the application startup sequence.
Component-defining annotation for a stateful session bean.
Specifies the statistics provided by a stateful session bean.
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.
Define a Map-like contract that makes it easier for components to implement PartialStateHolder.
This interface is implemented by classes that need to save their state between requests.
Component-defining annotation for a stateless session bean.
Specifies the statistics provided by a stateless session bean.
Encapsulate the saving and restoring of the view to enable the VDL to take over the responsibility for handling this feature.
StateManager directs the process of saving and restoring the view between requests.
Provides a simple implementation of StateManager that can be subclassed by developers wishing to provide specialized behavior to an existing StateManager instance.
An ELResolver for resolving static fields, enum constants and static methods.
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.
The Statistic model and its sub-models specify the data models which are requried to be used to provide the performance data described by the specific attributes in the Stats models.
The Stats model and its submodels specify performance data attributes for each of the specific managed object types.
The Status interface defines static variables used for transaction status codes.
 
 
StepListener intercepts step execution.
Specifies that an annotation type is a stereotype.
An abstract class that models a message store and its access protocol, for storing and retrieving messages.
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.
Specifies a parameter of a named stored procedure query.
Interface used to control stored procedure query execution.
This class models notifications from the Store connection.
This is the Listener interface for Store Notifications.
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.
A type that may be used as a resource method return value or as the entity in a Response when the application wishes to stream the output.
A StreamMessage object is used to send a stream of primitive types in the Java programming language.
This class implements the match method for Strings.
This type represents a subgraph for an attribute node that corresponds to a Managed Type.
This class implements comparisons for the message Subject header.
The Subquery interface defines functionality that is specific to subqueries.
Defines the target(s) a ConstraintValidator can validate.
Inject a suspended AsyncResponse into a parameter of an invoked JAX-RS resource or sub-resource method.
Create a switch node in the current Flow.
Represents a case within a switch node in the flow graph.
Create a case in the current switch.
Represents a switch node in the flow graph.
The transaction manager supports a synchronization mechanism that allows the interested party to be notified before and after the transaction completes.
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.
Uniform interface for synchronous invocation of HTTP methods.
SystemEvent is the base class for non-application specific events that can be fired by arbitrary objects.
By implementing this class, an object indicates that it is a listener for one or more kinds of SystemEvents.
Classes that implement this interface agree to maintain a list of SystemEventListener instances for each kind of SystemEvent they can generate.
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.
Specifies the primary table for the annotated entity.
Defines a primary key generator that may be referenced by name when a generator element is specified for the GeneratedValue annotation.
The runtime must create an instance of this class for each element in the Facelets XHTML view.
The interface of a classic tag handler that does not want to manipulate its body.
Wraps any SimpleTag and exposes it using a Tag interface.
Representation of an XML attribute name=value pair on an XML element in a Facelet file.
An Exception caused by a TagAttribute
Information on the attributes of a Tag, available at translation time.
A set of TagAttributes, usually representing all attributes on a Tag.
Passed to the constructor of TagHandler subclass, it defines the document definition of the handler we are instantiating.
The (translation-time only) attribute/value information for a tag instance.
Provides the ability to completely change the Tag before it's processed for compiling with the associated TagHandler.
An Exception caused by a Tag
Optional class provided by the tag library author to describe additional translation-time information not described in the TLD.
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.
Foundation class for FaceletHandlers associated with a markup element in a Facelet document.
Abstract class that defines methods relating to helping tag handler instances.
Abstract factory for creating instances of TagHandlerDelegate.
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.
This interface provides access to the <taglib> related configuration of a web application.
Translation-time information associated with a taglib directive, and its underlying TLD file.
Translation-time validator class for a JSP page.
A base class for defining new tag handlers implementing Tag.
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.
This annotation must be specified for persistent fields or properties of type java.util.Date and java.util.Calendar.
Type used to indicate a specific mapping of java.util.Date or java.util.Calendar.
A TemporaryQueue object is a unique Queue object created for the duration of a Connection.
A TemporaryTopic object is a unique Topic object created for the duration of a Connection.
An interface that allows other code to identify FaceletHandlers that may provide text (String) content.
A TextMessage object is used to send a message containing a java.lang.String.
The TimedObject interface contains a callback method that is used to deliver timer expiration notifications.
Designates a method on a stateless session bean class, a singleton session bean class, a message driven bean class, or an EJB 2.x entity bean class that should receive EJB timer expirations for that bean.
Asynchronous response suspend time-out handler.
The Timer interface contains information about a timer that was created through the EJB Timer Service.
TimerConfig is used to specify additional timer configuration settings during timer creation.
The TimerHandle interface allows the bean provider to obtain a serializable timer handle that may be persisted.
The TimerService interface provides enterprise bean components with access to the container-provided Timer Service.
Specifies standard timing measurements.
A Topic object encapsulates a provider-specific topic name.
A TopicConnection object is an active connection to a publish/subscribe JMS provider.
A client uses a TopicConnectionFactory object to create TopicConnection objects with a publish/subscribe JMS provider.
A client uses a TopicPublisher object to publish messages on a topic.
The TopicRequestor helper class simplifies making service requests.
A TopicSession object provides methods for creating TopicPublisher, TopicSubscriber, and TemporaryTopic objects.
A client uses a TopicSubscriber object to receive messages that have been published to a topic.
The Transaction interface allows operations to be performed against the transaction in the target Transaction object.
The javax.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 Java EE specification, at both the class and method level where method level annotations override those at the class level.
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.
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.
The TransactionAttribute annotation specifies whether the container is to invoke a business method within a transaction context.
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.
A standard WorkContext that allows a Work instance to propagate transaction related context information from an EIS to an application server.
This exception is thrown when an operation is invalid because a transaction is in progress.
This unchecked exception is thrown when an operation is invalid because a transaction is in progress.
Specifies whether a session bean or message driven bean has container managed transactions or bean managed transactions.
The enum TransactionManagementType is used with the TransactionManagement annotation to specify whether container-managed or bean-managed transaction management is used.
The TransactionManager interface defines the methods that allow an application server to manage transaction boundaries.
Distinguishes the various kinds of transactional observer methods from regular observer methods which are notified immediately.
Thrown by the persistence provider when a transaction is required but is not active.
This exception indicates that a request carried a null transaction context, but the target object requires an active transaction.
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.
This exception indicates that the transaction associated with processing of the request has been rolled back, or it has been marked to roll back.
This exception must be thrown when a call to Session.commit results in a rollback of the current transaction.
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.
This unchecked exception must be thrown when a call to JMSContext.commit results in a rollback of the current transaction.
The javax.transaction.TransactionScoped annotation provides the ability to specify a standard CDI scope to define bean instances whose lifecycle is scoped to the currently active JTA transaction.
This interface may be optionally implemented by a ManagedConnectionFactory to provide its level of transaction support at runtime.
An enumerated type that represents the levels of transaction support a resource adapter may support.
This interface is intended for use by system level application server components such as persistence managers, resource adapters, as well as EJB and Web application components.
Specifies that the property or field is not persistent.
If a parameter annotated with @TransientReference resolves to a dependent scoped bean, then the bean will be destroyed after the invocation completes.
Define a Map-like contract that makes it easier for components to implement 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.
An abstract class that models a message transport.
The adapter which receives Transport events.
This class models Transport events.
This is the Listener interface for Transport events
Contract determining if a property can be accessed by the Bean Validation provider.
Triggers allow application developers to plug in rules for when and how often a task should run.
Callback for trusted certificate KeyStore.
The auxiliary interface of a Tag, IterationTag or BodyTag tag handler that wants additional hooks for managing resources.
Interface for extracting the elements of a query result tuple.
The TupleElement interface defines an element that is returned in a query result tuple.
Instances of the type Type represent persistent object or attribute types.
 
This exception indicates that a violation of a dynamically checked type constraint was detected.
A convenient class for writing an ELResolver to do custom type conversions.
Restricts the bean types of a bean.
Interface used to control the execution of typed queries.
Supports inline instantiation of objects that represent parameterized types with actual type parameters.
UIColumn is a UIComponent that represents a single column of data within a parent UIData component.
UICommand is a UIComponent that represents a user interface component which, when activated by the user, triggers an application specific "command" or "action".
UIComponent is the base class for all user interface components in JavaServer Faces.
UIComponentBase is a convenience base class that implements the default concrete behavior of all methods defined by UIComponent.
Deprecated.
All component tags now implement BodyTag.
UIComponentTagBase is the base class for all JSP tags that use the "classic" JSP tag interface that correspond to a UIComponent instance in the view.
UIComponentELTag specializes its superclass to allow for properties that take their values from EL API expressions.
Deprecated.
Use of this class has been replaced with UIComponentELTag, which extends UIComponentClassicTagBase to add properties that use the EL API introduced as part of JSP 2.1.
UIComponentTagBase is the base class for all JSP tags that correspond to a UIComponent instance in the view.
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).
The UIDFolder interface is implemented by Folders that can support the "disconnected" mode of operation, by providing unique-ids for messages in the folder.
A fetch profile item for fetching UIDs.
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 is a UIComponent that displays a graphical image to the user.
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.
This component is responsible for displaying messages for a specific UIComponent, identified by a clientId or component id relative to the closest ancestor NamingContainer.
The renderer for this component is responsible for obtaining the messages from the FacesContext and displaying them to the user.
UINamingContainer is a convenience base class for components that wish to implement NamingContainer functionality.
This component is paired with the javax.faces.Button or javax.faces.Link renderers and encapsulates properties relating to the rendering of outcomes directly to the response.
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 is a UIComponent that manages the layout of its child components.
UIParameter is a UIComponent that represents an optionally named configuration parameter for a parent component.
UISelectBoolean is a UIComponent that represents a single boolean (true or false) value.
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.
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 is a UIComponent that represents the user's choice of a zero or more items from among a discrete set of available options.
UISelectOne is a UIComponent that represents the user's choice of zero or one items from among a discrete set of available options.
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 represents a binding between a request parameter and a model property or UIViewRoot property.
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 is the UIComponent that represents the root of the UIComponent tree.
This is thrown to indicate that a service is unavailable.
Defines an exception that a servlet or filter throws to indicate that it is permanently or temporarily unavailable.
Exception raised in the case that the constraint validator resolution cannot determine a suitable validator for a given type.
Specifies that a unique constraint is to be included in the generated DDL for a primary or secondary table.
UniqueIdVendor is an interface implemented by UIComponents that also implement NamingContainer so that they can provide unique ids based on their own clientId.
Helper class for injecting and calling lifecycle callbacks unmanaged instances for use by framework and library integrators.
Represents a non-contextual instance.
This exception indicates that an error has occurred while performing an unmarshal operation that prevents the JAXB Provider from completing the operation.
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.
Register an instance of an implementation of this class with Unmarshaller to externally listen for unmarshal events.
Unmarshaller implemented as SAX ContentHandler.
Indicates that a contextual reference for a bean with a normal scope and a certain bean type cannot be obtained because the bean type cannot be proxied by the container.
Indicates that no bean matches a certain combination of required type and required qualifiers and is eligible for injection into a certain class.
This exception indicates a failure to update the model and is created to wrap any exception that occurs during UIInput.updateModel(javax.faces.context.FacesContext).
URI template-aware utility class for building URIs from their components.
A runtime exception thrown by UriBuilder.build(Object...) methods when a URI cannot be constructed based on the current state of the builder.
An injectable interface that provides access to application and request URI information.
The name of a URL.
Specifies the statistics provided by a URL resource.
The UserTransaction interface defines the methods that allow an application to explicitly manage transaction boundaries.
Marks a property, method parameter or method return type for validation cascading.
Expresses which executables (methods or constructors) should have their parameters and return value validated upon execution.
This interface is implemented by a ManagedConnectionFactory instance that supports the ability to validate ManagedConnection objects.
This class is the entry point for Bean Validation.
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.
ValidationEventHandler implementation that collects all events.
A basic event handler interface for validation errors.
Default implementation of the ValidationEvent interface.
Encapsulate the location of a ValidationEvent.
Default implementation of the ValidationEventLocator interface.
Base exception of all Bean Validation "unexpected" problems.
This exception indicates that an error has occurred while performing a validate operation.
A validation message from either TagLibraryValidator or TagExtraInfo.
The validation mode to be used by the provider for the persistence unit.
Contract between the validation bootstrap mechanism and the provider engine.
Determines the list of Bean Validation providers available in the runtime environment
List of possible targets for a ConstraintValidator.
A Validator implementation is a class that can perform validation (correctness checks) on a EditableValueHolder.
Validates bean instances.
Deprecated.
since JAXB 2.0
Used in creating ValidatorHandler and all implementations.
Represents the context that is used to create Validator instances.
ValidatorELTag is a base class for all JSP custom actions that create and register a Validator instance on the EditableValueHolder associated with our most immediate surrounding instance of a tag whose implementation class is a subclass of UIComponentTag.
A ValidatorException is an exception thrown by the validate() method of a Validator to indicate that validation failed.
Factory returning initialized Validator instances.
Handles setting a Validator instance on an EditableValueHolder parent.
Deprecated.
This has been partially replaced by ValidatorELTag.
Deprecated.
This has been replaced by ValueExpression.
A ValueChangeEvent is a notification that the local value of the source component has been change as a result of user interface activity.
A listener interface for receiving ValueChangeEvents.
An Expression that can get or set a value.
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.
A VDL handler that exposes Converter to a page author.
A marker interface for VDL tags that represent <composite:valueHolder/> for use by the composite component page author.
This encapsulates a base model object and one of its properties.
Information on the scripting variables that are created/modified by a tag (at run-time).
The interface to a map between EL variables and the EL expressions they are associated with.
Deprecated.
This has been replaced by ELResolver when operating with a null base argument.
Deprecated.
As of JSP 2.1, replaced by ELResolver
Abstraction for a resource representation variant.
A builder for a list of representation variants.
Specifies the version field or property of an entity class that serves as its optimistic lock value.
Veto the processing of the class.
Create a view node in the current Flow.
The contract that a view declaration language must implement to interact with the JSF runtime.
ViewDeclarationLanguageFactory is a factory object that creates (if needed) and returns a new ViewDeclarationLanguage instance based on the VDL found in a specific view.
Provides a simple implementation of ViewDeclarationLanguage that can be subclassed by developers wishing to provide specialized behavior to an existing ViewDeclarationLanguage instance.
Implementations must throw this FacesException when attempting to restore the view StateManager.restoreView(javax.faces.context.FacesContext, String, String) results in failure on postback.
ViewHandler is the pluggablity mechanism for allowing implementations of or applications using the JavaServer Faces specification to provide their own handling of the activities in the Render Response and Restore View phases of the request processing lifecycle.
Provides a simple implementation of ViewHandler that can be subclassed by developers wishing to provide specialized behavior to an existing ViewHandler instance.
Marker interface for SystemEvents that indicate the view map has been created (PostConstructViewMapEvent, or destroyed (PreDestroyViewMapEvent).
ViewMetadata is reponsible for extracting and providing view parameter metadata from VDL views.
ViewNode is the class that represents a VDL view in a faces flow graph.
Superclass of Resource that is only for use with views.
When this annotation, along with ManagedBean is found on a class, the runtime must act as if a <managed-bean-scope>view<managed-bean-scope> element was declared for the corresponding managed bean.
When this annotation, along with javax.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(javax.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.
A simple callback interface that enables taking action on a specific UIComponent (either facet or child) during a component tree visit.
A context object that is used to hold state relating to performing a component tree visit.
Provide for separation of interface and implementation for the VisitContext contract.
Provides a simple implementation of VisitContext that can be subclassed by developers wishing to provide specialized behavior to an existing VisitContext instance.
An enum that specifies hints that impact the behavior of a component tree visit.
DomHandler implementation for W3C DOM (org.w3c.dom package.)
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.
This class is used to build W3CEndpointReference instances.
Runtime exception for applications.
This interface encapsulates the connection for an upgrade request.
Used to annotate the getPortName() methods of a generated service interface.
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.
Annotation used to declare a servlet filter.
This annotation is used on a Servlet or Filter implementation class to specify an initialization parameter.
This annotation is used to declare a WebListener.
Class for Servlet web resource permissions.
Class for Servlet isUserInRole (String reference) permissions.
Used to annotate a generated service interface.
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.
The WebServiceException class is the base exception class for all JAX-WS API runtime exceptions.
A WebServiceFeature is used to represent a feature that can be enabled or disabled for a web service.
Annotation used to identify other annotations as a WebServiceFeature.
This class defines web service permissions.
Used to annotate a Provider implementation class.
The WebServiceRef annotation is used to define a reference to a web service and (optionally) an injection target for it.
The WebServiceRefs annotation allows multiple web service references to be declared at the class level.
Annotation used to declare a servlet.
A WebSocketContainer is an implementation provided object that provides applications a view on the container running it.
A resource target identified by the resource URI.
Class for Servlet Web user data permissions.
WithAnnotations may be applied to any portable extension observer method with an event parameter type of ProcessAnnotatedType to filter the events delivered.
This models a Work instance that would be executed by a WorkManager upon submission.
This class is provided as a convenience for easily creating WorkListener instances by extending this class and overriding only those methods of interest.
This exception is thrown by a WorkManager to indicate that a submitted Work instance has completed with an exception.
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.
This class models the possible error conditions that might occur during associating an WorkContext with a Work instance.
This class models the various events that occur during the processing of the WorkContexts associated with a Work instance.
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.
This class models the various events that occur during the processing of a Work instance.
A common base class for all Work processing related exceptions.
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.
This interface models a WorkManager which provides a facility to submit Work instances for execution.
This exception is thrown by a WorkManager to indicate that a submitted Work instance has been rejected.
Callback notification mechanism that signals to the developer it's possible to write content without blocking.
The XAConnection interface extends the capability of Connection by providing an XASession (optional).
The XAConnectionFactory interface is a base interface for the XAQueueConnectionFactory and XATopicConnectionFactory interfaces.
The XAException is thrown by the Resource Manager (RM) to inform the Transaction Manager of an error encountered by the involved transaction.
The XAJMSContext interface extends the capability of JMSContext by adding access to a JMS provider's support for the Java Transaction API (JTA) (optional).
An XAQueueConnection provides the same create options as QueueConnection (optional).
An XAQueueConnectionFactory provides the same create options as a QueueConnectionFactory (optional).
An XAQueueSession provides a regular QueueSession, which can be used to create QueueReceiver, QueueSender, and QueueBrowser objects (optional).
The XAResource interface is a Java mapping of the industry standard XA interface based on the X/Open CAE Specification (Distributed Transaction Processing: The XA Specification).
The XASession interface extends the capability of Session by adding access to a JMS provider's support for the Java Transaction API (JTA) (optional).
The XATerminator interface is used for transaction completion and crash recovery flows.
An XATopicConnection provides the same create options as TopicConnection (optional).
An XATopicConnectionFactory provides the same create options as a TopicConnectionFactory (optional).
An XATopicSession provides a regular TopicSession.
The Xid interface is a Java mapping of the X/Open transaction identifier XID structure.
Used by XmlAccessorOrder to control the ordering of properties and fields in a JAXB bound class.
Controls the ordering of fields and properties in a class.
Controls whether fields or Javabean properties are serialized by default.
Used by XmlAccessorType to control serialization of fields or properties.
Adapts a Java type for custom marshaling.
Maps a JavaBean property to a map of wildcard attributes.
Maps a JavaBean property to XML infoset representation and/or JAXB element.
Marks a field/property that its XML form is a uri reference to mime content.
Maps a JavaBean property to a XML attribute.
Maps a JavaBean property to a XML element derived from property name.
Used in XmlElement.type() to signal that the type be inferred from the signature of the property.
Maps a factory method to a XML element.
Used in XmlElementDecl.scope() to signal that the declaration is in the global scope.
Maps a JavaBean property to a XML element derived from property's type.
Used in XmlElementRef.type() to signal that the type be inferred from the signature of the property.
Marks a property that refers to classes with XmlElement or JAXBElement.
A container for multiple @XmlElement annotations.
Generates a wrapper element around XML representation.
Maps an enum type Enum to XML representation.
Maps an enum constant in Enum type to XML representation.
Maps a JavaBean property to XML ID.
Maps a JavaBean property to XML IDREF.
Disable consideration of XOP encoding for datatypes that are bound to base64-encoded binary data in XML.
Use an adapter that implements XmlAdapter for custom marshaling.
Used in XmlJavaTypeAdapter.type() to signal that the type be inferred from the signature of the field, property, parameter or the class.
A container for multiple @XmlJavaTypeAdapter annotations.
Used to map a property to a list simple type.
Associates the MIME type that controls the XML representation of the property.
Annotate a JavaBean multi-valued property to support mixed content.
Associates a namespace prefix with a XML namespace URI.
Enumeration of XML Schema namespace qualifications.
Marks a class that has XmlElementDecls.
Maps a class or an enum type to an XML element.
Maps a package name to a XML namespace.
Maps a Java type to a simple schema built-in type.
Used in XmlSchemaType.type() to signal that the type be inferred from the signature of the property.
A container for multiple @XmlSchemaType annotations.
Instructs JAXB to also bind other classes when binding this class.
Prevents the mapping of a JavaBean property/type to XML representation.
Maps a class or an enum type to a XML Schema type.
Used in XmlType.factoryClass() to signal that either factory mehod is not used or that it's in the class with this XmlType itself.
Enables mapping a class to a XML Schema complex type with a simpleContent or a XML Schema simple type.