Red Hat JBoss Enterprise Application Platform 8.1.1.GA + JBoss EAP XP 6.0.0.GA public API
Package
Description
Public core annotations, most of which are used to configure how
Data Mapping/Binding works.
Main public API classes of the core streaming JSON
processor: most importantly
JsonFactory
used for constructing
JSON parser (JsonParser)
and generator
(JsonGenerator)
instances.Package that contains abstractions needed to support optional
non-blocking decoding (parsing) functionality.
Base classes used by concrete Parser and Generator implementations;
contain functionality that is not specific to JSON or input
abstraction (byte vs char).
Package for some of
JsonProcessingException
subtypes contained by streaming API.Package that contains interfaces needed for dynamic, pluggable
format (auto)detection; as well as basic utility classes for
simple format detection functionality.
JSON-specific parser and generator implementation classes that
Jackson defines and uses.
Non-blocking ("async") JSON parser implementation.
Internal implementation classes for efficient handling of
of symbols in JSON (field names in Objects)
Contains classes needed for type introspection, mostly used by data binding
functionality.
Utility classes used by Jackson Core functionality.
Basic data binding (mapping) functionality that
allows for reading JSON content into Java Objects (POJOs)
and JSON Trees (
JsonNode), as well as
writing Java Objects and trees as JSON.Annotations that directly depend on classes in databinding bundle
(not just Jackson core) and cannot be included
in Jackson core annotations package (because it cannot have any
external dependencies).
Package that contains most of configuration-related classes;
exception being couple of most-commonly used configuration
things (like Feature enumerations) that are at the
main level (
com.fasterxml.jackson.databind).Contains implementation classes of deserialization part of
data binding.
Contains those implementation classes of deserialization part of
data binding that are not considered part of public or semi-public
interfaces.
Contains public standard implementations of abstraction that
Jackson uses.
Contains extended support for "external" packages: things that
may or may not be present in runtime environment, but that are
commonly enough used so that explicit support can be added.
Functionality needed for Bean introspection, required for detecting
accessors and mutators for Beans, as well as locating and handling
method annotations.
Contains helper class(es) needed to support some of JDK14+
features without requiring running or building using JDK 14.
Classes used for exposing logical structure of POJOs as Jackson
sees it, and exposed via
ObjectMapper.acceptJsonFormatVisitor(Class, JsonFormatVisitorWrapper)
and
ObjectMapper.acceptJsonFormatVisitor(com.fasterxml.jackson.databind.JavaType, JsonFormatVisitorWrapper)
methods.Classes needed for JSON schema support (currently just ability
to generate schemas using serialization part of data mapping)
Package that contains interfaces that define how to implement
functionality for dynamically resolving type during deserialization.
Package that contains standard implementations for
TypeResolverBuilder
and
TypeIdResolver.Package that contains classes and interfaces to help implement
custom extension
Modules
(which are registered using
ObjectMapper.registerModule(com.fasterxml.jackson.databind.Module).Contains concrete
JsonNode implementations
Jackson uses for the Tree model.Contains implementation classes of serialization part of
data binding.
Contains implementation classes of serialization part of
data binding.
Utility classes for Mapper package.
This package contains an implementation of a bounded
ConcurrentMap data structure.Package that contains annotations applicable to all content types.
Miscellaneous helper classes used by providers.
Jackson-based Jakarta-RS provider that can automatically
serialize and deserialize resources for
JSON content type (MediaType).
Package that contains annotations specific to JSON dataformat.
Package that contains support for using JAXB annotations for
configuring Jackson data-binding aspects.
Library for generating Java source code
Various resource file formats (classes that implement
JResourceFile).istack-commons runtime utilities.
istack-commons tool time utilities.
Annotation Processing related code.
Schema to Java compiler
API for programmatic invocation of XJC and schemagen.
implementation of the XJC API for schema to java.
FieldRenderer and its implementation classes.
Implementation of the
org.glassfish.jaxb.core.v2.model.core package for XJC.
Compile-time representation of Java type system.
Provides the outline of the generated Java source code so that
additional processing (such as adding more annotations) can be
done on the generated code.
Front-end that reads schema(s) and produce BGM.
Object Model that represents DTD binding information.
Binary expressions are left-associative.
internalization of external binding files and <jaxb:bindings> customizations.
Object Model that represents customization declarations.
Code generated into the user's packages in certain compilation mode.
TXW runtime.
Defines a set of annotations that can be used on TypedXmlWriter interfaces.
Defines XmlSerializer and its built-in implementations.
Interfaces that the client should use to access schema information.
Implementation of the
com.sun.xml.xsom package.Parser that reads XML Schema documents and builds an
XSSchemaSet object.Classes to parse XML Schema documents into objects of
com.sun.xml.xsom package.Visitor pattern support for the
com.sun.xml.xsom interfaces.Jakarta Activation is used by Jakarta Mail to manage MIME data.
Provides interfaces which implementations will be used as service providers for other services
that used by Jakarta Activation.
This package defines the common annotations.
This package contains the security common annotations.
Provides APIs used by Batch artifacts.
Provides APIs used by artifacts in a Batch chunk step.
Provides APIs defining listener artifacts for a Batch chunk step.
Provides APIs defining Batch job-level and step-level listener artifacts.
Provides APIs for artifacts specific to a Batch partitioned step.
Provides APIs for starting, managing, and viewing results of Batch job executions, along with a set of exceptions.
Provides APIs for viewing the detailed outcomes and metrics of Batch job executions.
Provides APIs for context classes allowing data sharing across Batch artifacts within a job instance and within a step.
Annotations relating to decorators.
Contains the Enterprise Bean classes
and interfaces that define the contracts between the enterprise bean
and its clients and between the enterprise bean and the enterprise bean container.
Defines the classes for the enterprise bean Embeddable API.
Defines interfaces that are implemented by
the enterprise bean container.
Classes and interfaces that make up the Jakarta Concurrency specification.
Interfaces for third-party providers of thread context to implement.
Annotations and interfaces relating to scopes and contexts.
The custom context SPI.
Annotations and interfaces relating to events.
The build compatible extension SPI.
The portable extension integration SPI.
The core interfaces of the language model that represent
annotations and
annotation targets.
Interfaces that represent declarations.
Interfaces that represent types.
Contains shared, general-purpose helper classes and annotations.
This package specifies a means for obtaining objects in such a way as to
maximize reusability, testability and maintainability compared to
traditional approaches such as constructors, factories, and service
locators (e.g., JNDI). This process, known as dependency
injection, is beneficial to most nontrivial applications.
Contains annotations and interfaces for defining interceptor methods and interceptor
classes, and for binding interceptor classes to target classes.
Provides an object model API to process JSON.
Provides JSON Binding API, which enables binding Java objects from and to
JSON documents.
Defines adapter related classes.
Defines annotations for customizing the mapping between Java program elements
and JSON documents.
Defines strategies and policies for customizing the mapping between Java program elements
and JSON documents.
Defines serializer depending classes.
Service Provider Interface (SPI) to plug in implementations of JSON
Binding API
JsonbBuilder objects.Service Provider Interface (SPI) to plug in implementations for
JSON processing objects.
Provides a streaming API to parse and generate
JSON.
This package defines annotations for light-weight web services programming model.
This package defines annotations for SOAP binding definition within light-weight web services programming model.
The Jakarta Mail API
provides classes that model a mail system.
Listeners and events for the Jakarta Mail API.
Classes specific to Internet mail systems.
Message search terms for the Jakarta Mail API.
Jakarta Mail API utility classes.
Jakarta Persistence is the API for the management for persistence and object/relational mapping.
Jakarta Persistence Criteria API
Jakarta Persistence Metamodel API
SPI for Jakarta Persistence providers
The jakarta.resource package is the top-level package for the Jakarta™ Connectors specification.
The jakarta.resource.cci package contains API specification for the Common
Client Interface (CCI).
The jakarta.resource.spi package contains APIs for the system
contracts defined in the Jakarta Connectors specification.
This package contains system contracts for service endpoint interactions.
The jakarta.resource.spi.security package contains APIs for the security
management contract.
This package contains APIs for the Work Management, Generic and Security Work Context contracts.
This package defines the core interfaces of Jakarta Authentication.
This package defines callback interfaces that may be used by a pluggable authentication mechanisms (aka message authentication modules)
to interact with the container (aka message processing runtime) that invoked the module.
This package defines the interfaces implemented by Jakarta Authentication compatible configuration systems.
This package defines the interfaces implemented by Jakarta Authentication compatible authentication mechanisms.
The main Jakarta Security package.
The HTTP authentication mechanism API package.
The Identity Store Credential API package.
The identity store API package.
The jakarta.servlet package contains a number of classes and interfaces that describe and define the contracts between a servlet class and the runtime environment provided for an instance of such a class by a conforming servlet container.
The jakarta.servlet.annotation package contains a number of annotations that allow users to use annotations to declare servlets, filters, listeners and specify the metadata for the declared component.
Provides programmatic access to a web application's configuration information that was aggregated from the
web.xml
and
web-fragment.xml
descriptors.The jakarta.servlet.http package contains a number of classes and interfaces that describe and define the contracts between a servlet class running under the HTTP protocol and the runtime environment provided for an instance of such a class by a conforming servlet container.
Provides the API that defines the contract between the transaction
manager and the various parties involved in a distributed transaction
namely : resource manager, application, and application server.
Top level package of the Jakarta Bean Validation API.
Package containing bootstrap specific objects.
Contains all the Jakarta Bean Validation provided constraints
also called built-in constraints.
Package containing constructs specific to constraint validators.
Package related to the control and execution of executable validation.
A group defines a subset of constraints.
Package containing all objects specifically used and returned by the
metadata API.
Package containing objects specific to the interaction between the
Jakarta Bean Validation bootstrapping process and Jakarta Bean Validation providers.
Package containing objects dedicated to extract values to validate from containers.
This package contains all the Jakarta WebSocket APIs common to both the client and server side.
This package contains all the Jakarta WebSocket APIs used only by server side applications.
High-level interfaces and annotations used to create RESTful service resources.
The JAX-RS client API
Container-specific JAX-RS API.
Low-level interfaces and annotations used to create RESTful service resources.
APIs that provide extensions to the types supported by the JAX-RS API.
Server-Sent Events related API.
Provides a runtime binding framework for client applications including
unmarshalling, marshalling, and validation capabilities.
Defines annotations for customizing Java program elements to XML Schema mapping.
XmlAdapter and its spec-defined
subclasses to allow arbitrary Java classes to be used with Jakarta XML Binding.This package is implemented by a MIME-based package processor that
enables the interpretation and creation of optimized binary data
within an MIME-based package format.
Jakarta XML Binding Provider Use Only: Provides partial default implementations for
some of the
jakarta.xml.bind interfaces.Useful client utility classes.
Provides the API for creating and building SOAP messages.
This package contains the core Jakarta XML Web Services APIs.
This package defines APIs for message handlers.
This package defines APIs for SOAP message handlers.
This package defines APIs specific to the HTTP binding.
This package defines APIs specific to the SOAP binding.
This package defines SPIs for Jakarta XML Web Services.
Provides HTTP SPI that is used for portable deployment of Jakarta XML Web Services
in containers (for example servlet containers).
This package defines APIs related to WS-Addressing.
Contains useful classes for spawning process from client classes
The JAXB POJOs for the XML configuration of ActiveMQ Artemis broker
This packages handles Linux libaio at a low level.
Public API for Log4j 2.
This package should be considered private.
Public Message Types used for Log4j 2.
Simple logging implementation.
Internal interfaces and classes to be used by authors of logging implementations or for internal use by
API classes.
Status API for Log4j 2.
Internal utility classes for the Log4j 2 API.
Licensed to the Apache Software Foundation (ASF) under one
or more contributor license agreements.
Licensed to the Apache Software Foundation (ASF) under one
or more contributor license agreements.
Licensed to the Apache Software Foundation (ASF) under one
or more contributor license agreements.
Licensed to the Apache Software Foundation (ASF) under one
or more contributor license agreements.
Licensed to the Apache Software Foundation (ASF) under one
or more contributor license agreements.
The NTRU algorithm based on the round 3 submission of the NIST post-quantum cryptography.
Contains the polynomial classes used in the NTRU round 3 algorithm.
Metadata for JWT RBAC for Microprofile
Configuration for Java MicroProfile
CDI Support for MicroProfile Config
This package contains classes which are used to implement the configuration API, and to extend the standard
configuration functionality in a portable way.
CDI Support for Microprofile Fault Tolerance
Exceptions for Microprofile Fault Tolerance
Microprofile Health
Microprofile Service Health Checks
Interoperable JWT RBAC for Microprofile
Microprofile LRA Support.
A set of Java interfaces, annotations and programming models which allow Java developers to natively produce OpenAPI
v3.1 documents from their Jakarta REST applications.
A set of annotations, many derived from Swagger Core library.
A set of annotations to represent callback URL or an array of relevant callback URLs that can be invoked for a
particular HTTP operation as well as the HTTP operation that will be invoked with the callback.
A set of parameters used by other annotations to represent their enumerable properties.
Annotations to represent additional data to extend existing OpenAPI specifications.
An annotation to describe a single header object.
A set of annotations to represent metadata about the API, including license information and contact information of
the exposed API.
Annotations to represent a design-time link for a response and the corresponding parameter to be passed to the linked
operation.
A set of annotations to represent input and output data type, media type and relevant examples.
A set of annotations to describe and encapsulate operation parameters and operation's request body.
Contains annotation to describe a single response from an API operation, and an annotation to encapsulate multiple
responses from an API operation.
A set of annotations to represent various security components of an OpenAPI app.
Annotations to represent servers used for a single API operation or for all operations in an OpenAPI document, as
well as a way to represent variables for server URL template substitution.
A set of annotations to represent a tag for an API endpoint and a container that encapsulates multiple such tags.
A set of interfaces for programmable models and their helper classes, many derived from Swagger Core library.
An interface to represent callback URL.
An interface to represent a programmable model of an example of a data type or a media type.
An interface of a programmable model to represent a single header object.
A set of interfaces of programmable models to represent metadata about the API, including license information and
contact information of the exposed API.
An interface of a model to represent a design-time link for a response.
A set of interfaces for programmable models to represent input and output data types and media types.
A set of model interfaces to describe operation parameters and operation's request body.
Model interfaces to describe a single response from an API operation, and an annotation to encapsulate multiple
responses from an API operation.
A set of model interfaces to represent various security components of an OpenAPI app.
Model interfaces to represent servers used for a single API operation or for all operations in an OpenAPI document,
as well as a way to represent variables for server URL template substitution.
Model interface to represent a tag of an API endpoint.
Service provider interface which allows vendors to set their implementations of OASFactoryResolver.
IMPORTANT
This package is a copy from the original package from the specification.
The MicroProfile Reactive Messaging API Connector SPI
MicroProfile Reactive Streams Operators.
The Reactive Streams utils SPI.
The in-memory model of the JAXB-bound beans.
Abstraction around the reflection library, to support various reflection models (such as java.lang.reflect and Annotation Processing).
TXW interfaces for writing episode file, which is what XJC needs to
handle separate compilation.
Runtime API for the JAX-WS RI
The JAXB 2.0 runtime
Abstraction around reading annotations, to support internal/external annotations.
Implementation of the org.glassfish.jaxb.j2s.model package.
The specialization of
org.glassfish.jaxb.core.v2.model.core for the runtime.Code that implements JAXBContext, Unmarshaller, and Marshaller.
Code that writes well-formed XML (
XmlOutput and its implementations}.Abstraction around accessing data of actual objects.
Schema generator.
XML Schema writer generated by TXW.
This package defines the central Hibernate APIs, beginning with
SessionFactory, which represents an instance of
Hibernate at runtime and is the source of new instances of
Session and StatelessSession,
the most important APIs exposing persistence-related operations for
entities.The various concrete action implementations.
This SPI package defines an abstraction over the notion of an "action"
which is scheduled for asynchronous execution by the event listeners.
A set of mapping annotations which extend the O/R mapping annotations defined by JPA.
Annotations used to drive annotation processors:
@Find
is used to generate finder methods using the Metamodel
Generator,
@HQL
and @SQL
are used to generate query methods using the Metamodel
Generator, and
CheckHQL
instructs the Query Validator to check all HQL queries
in the annotated package or type.This package defines an easy way to extend Hibernate with user-defined
annotations that define customized O/R mappings of annotated entities
and annotated entity attributes.
Built-in implementations of
AttributeBinder
and TypeBinder.This package contains the interfaces that make up the bootstrap API
for Hibernate.
The internals of archive scanning support.
Support for integrating Jakarta Bean Validation.
Implementation of the service for processing and handling
cfg.xml files.An SPI service for processing and handling
cfg.xml files.JAXB support for
orm.xml and hbm.xml mapping filesJAXB details.
Contains basic support for Java XML Processing (JAXP) via Streaming API for XML (StAX)
This package defines the boot-time metamodel, which is an interpretation
of the domain model (entity classes, embeddable classes, and attributes)
and the mapping of these "domain model parts" to the database.
Defines the SPI of a
registry
of JPA
AttributeConverters.This API allows intervention by generic code in the process of determining the names of
database objects (tables, columns, and constraints).
Defines an SPI used during the process of transforming
mapping sources into
the
Metadata reference.Some SPIs related to DDL generation and schema management.
Support for handling named queries during the bootstrap process.
Defines service registry contracts a program may use for
configuring Hibernate.
The class loading service internals.
The class loading service SPI.
The internals for building service registries.
Defines a feature set around named registration of implementations of various contracts
and the ability to select those implementations.
Internals for building StrategySelector
Defines actual contract used for
strategy selection.
A range of SPIs allowing integration with—and customization of—the process of building metadata.
Support for XSD handling.
This package defines an SPI for integrating bytecode libraries with Hibernate.
package containing bytecode enhancement code (internals)
specialized classes to keep track of changes
Package defining bytecode code enhancement (instrumentation) support.
Support for bytecode interceptor implementations.
Byte Buddy support internals
Package defining bytecode code enhancement (instrumentation) support.
This package defines the API of the second-level cache service.
Implementation of the second-level cache configuration SPI.
An SPI modelling various aspects of the second-level cache configuration.
Internal implementations and support for second-level caching.
Defines the integration aspect of Hibernate's second-level caching, allowing
a "caching backend" to be plugged in as a cache provider.
Defines contracts for transactional and concurrent access to cached
entity and
collection data.
This package defines formats for disassembled state kept in the second level cache.
This package provides a framework intended to reduce the work needed to implement
a caching provider.
This package defines APIs for configuring Hibernate.
This package historically provided backward-compatibility
with Hibernate 2.1 APIs which were deprecated in Hibernate 3.
Internal implementations and support for persistent collections.
This package defines the SPI of a framework for lazy-initializing
and state-tracking collection wrappers.
Internal implementations and support around "current session" handling.
SPI-level contracts around "current session" and "current tenant" support.
This package abstracts over the multifarious dialects of SQL
understood by the databases supported by Hibernate.
Support for
Dialect-specific aggregate column types,
including user-defined composite types, and JSON or XML types.Contains implementations of
SqmFunctionDescriptor
describing a range of relatively-sophisticated SQL functions available in various dialects.Support for query hints using
Dialect-specific syntax.Support for
Dialect-specific identity column handling.Support for
Dialect-specific locking strategies.Support for
Dialect-specific pagination strategies.Support for
Dialect-specific sequence handling.Support for temporary tables.
Support for
Dialect-specific unique constraint definition.This package contains classes which are "shared" by other subsystems,
and implementations of some key algorithms.
The built-in implementation of the configuration service.
Defines the SPI of the configuration service.
Support for many of the internal workings of Hibernate.
Support for various aspects of JDBC interaction.
Support for JDBC statement batching.
Internals for JDBC batching support.
Defines contracts for JDBC batching support.
Various implementations of the SPI contracts for obtaining JDBC
Connections.Defines SPI contracts for obtaining JDBC
Connections from a
provider implemented as a service.Internals for JDBC REF_CURSOR support.
Defines contracts for JDBC REF_CURSOR support.
Internal support for Dialect resolution (from JDBC metadata) and Dialect building.
Contracts supporting Dialect resolution (from JDBC metadata) and Dialect building.
Internals for supporting various aspects of JDBC interaction
Package defining support for executing mutation SQL statements produced by an
entity persister or
collection
persister.
SPI contracts supporting various aspects of JDBC interaction.
Support for JNDI within Hibernate
Internal contracts defining the JNDI support within Hibernate
The SPI contracts for integration with JNDI.
Models the fetch profiles defined by the application.
Support for dealing with parameters of native queries.
An SPI for dealing with parameters of native queries.
This package defines some central internal SPI abstractions
used throughout the implementation of Hibernate.
A range of container-specific implementations of
JtaPlatform.An SPI for integrating with container-provided implementations of JTA.
An SPI abstracting the object which implements
Transaction.This package defines a default set of event listeners that implement
the default behaviors of Hibernate session operations.
Implementation of the event listener registration service.
An SPI for the event listener registration service.
Defines the event types and event listener interfaces for
events produced by the stateful
Session.Defines certain very important flavors of
JDBCException,
along with an SPI for interpreting product-specific SQLExceptions
arising from a JDBC driver into something more uniform and meaningful.An SPI for
Dialect-specific exception
interpretation and conversion.This package defines an abstraction over all kinds of automatic
value generation, including id generation and version number
generation.
Contains a framework of strategies for efficient retrieval of
database-generated values.
Implements and extends the JPA-defined entity graph API.
This package defines an internal SPI abstracting over implementations
of the APIs defined in
org.hibernate.graph.This package and its subpackages, especially
org.hibernate.id.enhanced,
contain the built-in id generators, all of which implement either
IdentifierGenerator or
PostInsertIdentifierGenerator.Enhanced/improved versions of table and sequence based identifier generators
targeting portability and unified configuration.
Defines a service for creating
id generators.
Implementation of the SPI for id generator factories.
Contains an SPI for id generator factories.
Contains a framework of strategies for retrieving database-generated ids.
Contains the
UuidGenerator.Implementation of the SPI for extensions which integrate with Hibernate via the
Service mechanism.An SPI for extensions which integrate with Hibernate via the Java
ServiceLoader facility.An internal package containing implementations of central Hibernate APIs,
mostly defined in
org.hibernate.Internal utility classes
A small API allowing the client of a Hibernate session to interact directly
with JDBC, using the same connection and transaction obtained by the session.
The packages in this namespace are responsible for implementing certain
requirements of the JPA specification, especially things which are only
needed when Hibernate is acting as a JPA persistence provider.
Internal details of implementing support for JPA callbacks
The SPI contracts for supporting JPA lifecycle callbacks.
Defines Hibernate implementation of Java Persistence specification.
An SPI for managing cases where, by default, Hibernate intentionally violates
the letter of the JPA specification.
This package defines functionality for processing JDBC result sets
and returning complex graphs of persistent objects.
This package defines the Hibernate configuration-time mapping model.
This package defines an API for accessing details about model mapping.
This package defines an API for accessing the runtime metamodel describing persistent
entities in Java and their mappings to the relational database schema.
Defines the runtime mapping metamodel, which describes the mapping
of the application's domain model parts (entities, attributes) to
relational database objects (tables, columns).
Support for set and map ordering
Defines the runtime domain metamodel, which describes the Java aspect of
the application's domain model parts (entities, attributes).
Implementation of the SPI for the runtime domain metamodel.
An SPI for the runtime domain metamodel.
An SPI supporting custom instantiation of
entity instances and
embeddable objects.
This package abstracts persistence mechanisms for collections.
Defines support for performing mutation operations against collections.
This package abstracts persistence mechanisms for entities.
Defines support for performing mutation operations originating
from persistence-context events.
Built-in implementation of the SPI for integrating entity and collection persisters.
An SPI for integrating custom entity and collection persisters.
Package for "walking" associations through metadata definition.
Contains some functions for pretty-printing things for exception and log messages.
Defines support for executing database stored procedures and functions and accessing their outputs.
Defines the internal implementation of the stored procedure SPI.
Defines an SPI for calling stored procedures and functions.
Contains various implementations of
PropertyAccessStrategy.An SPI abstracting how persistent attributes of an entity or embeddable type
are accessed by Hibernate.
This package defines a framework for lazy-initializing entity proxies.
Proxies for entity objects represented as Java maps.
Proxies for plain Java objects.
Everything related to HQL/JPQL, native SQL, and criteria queries.
The JPA-standard criteria query API defines all the operations needed express
any query written in standard JPQL.
SPI for extending
HibernateCriteriaBuilder
with additional functionality by registering a Service.Package defining support for HQL, including JPQL as a subset of HQL.
Implementation of the SPIs for HQL support.
SPIs for HQL support.
Support for named queries
Support SQL functions in the SQM model.
Support for defining result set mappings used in
NativeQuery,
ProcedureCall, and StoredProcedureQuery.Support for immutable result/fetch builder graph nodes built from static sources
such as
SqlResultSetMapping or the hbm.xml
mapping element <resultset/>.Support for mutable result/fetch builder graphs nodes built dynamically via
Hibernate's
NativeQuery APIsDefines support for implicit ResultSet mappings.
Contains a range of internal abstractions for dealing with query execution,
query plans, query options, and query parameters.
Package defining support for native SQL queries.
Implementation of the SPIs for native SQL query support.
SPIs for native SQL query support.
This package defines a semantic model of HQL queries.
An SPI for defining, registering, and rendering functions in HQL.
Package for the SQM-backed Query implementation details
Support for multi-table SQM mutation (insert, update, delete) operations using
a table to temporarily hold the matching ids.
SPI for handling SQM UPDATE and DELETE queries
Package defining support for
SqmFunctionDescriptor handling.SPI-level SQM contracts
Package for the translation of SQM into SQL AST
This package contains the classes that make up the SQM tree nodes.
Nodes representing common table expressions (CTE) in the SQM tree.
Nodes representing
delete statements in the SQM tree.Nodes representing path expressions in the SQM tree.
Nodes representing expressions in the SQM tree.
Nodes representing root entities and joins in the SQM tree.
Nodes representing
insert statements in the SQM tree.Nodes representing logical predicates in the SQM tree.
Nodes representing
select statements in the SQM tree.Nodes representing
update statements in the SQM tree.Programmatic access to the schema management tool.
An implementation of the bean container SPI based on CDI.
An SPI abstracting over CDI-like bean containers.
Defines an SPI for integration with CDI-like containers.
A facility for managing logical JDBC connections and keeping track of other heavyweight resources.
Implementation of the SPI for managing JDBC connections and other heavyweight resources.
An SPI for managing JDBC connections and other heavyweight resources, based around the
idea of a "JDBC session".
Defines the resource-level transaction capabilities of Hibernate, centered
around the
TransactionCoordinator
contract.An implementation of
TransactionCoordinator
based on JdbcResourceTransaction.An SPI which models the concept of a JDBC resource-level transaction.
Implementations of
TransactionCoordinator
based on JTA.Internal implementation details for reacting to JTA transaction completion via
Synchronization
callbacksInternal implementation details for the resource-level transaction capabilities of Hibernate.
Extended SPI contracts for the resource-level transaction capabilities of Hibernate.
Defines support for dealing with results returned from database via JDBC.
This package contains everything related to the configuration of the Hibernate Search engine.
Defines a framework for pluggable services,
allowing for customization of key components of Hibernate, and abstraction of these
components as SPI interfaces.
Implementation of the SPI for integrating pluggable services.
Defines an SPI for integrating pluggable services.
A tiny SPI for dealing with compound names and navigable paths.
This package contains helper classes for rendering SQL fragments and SQL statements.
Package defining a SQL AST for use in generation of SQL.
Package defining support for creating and consuming a SQL AST.
Package defining the SQL AST.
Support for common table expressions (CTE) in a SQL tree.
AST nodes representing
delete statements in a SQL tree.AST nodes representing expressions in a SQL tree.
AST nodes representing root tables and joins in a SQL tree.
AST nodes representing
insert statements in a SQL tree.AST nodes representing logical predicates in a SQL tree.
AST nodes representing
select statements in a SQL tree.AST nodes representing
update statements in a SQL tree.Support for execution of SQL statements via JDBC.
Implementation of the SPI for execution of SQL statements via JDBC.
SPI for execution of SQL statements via JDBC.
Package contains specialized SQL AST nodes and builders for table mutations
of model parts
originating from normal persistence-context events.
SQL AST extensions for model mutations.
Support for building
TableMutation
references for persisting entity mutation eventsExtensions to
JdbcOperation for model mutations.Package for processing JDBC
ResultSets into hydrated domain model graphs
based on a "load plan" defined by a "domain result graph", that is, one or more
DomainResult nodes with zero or more
Fetch nodes.Support for caching of query results.
Defines domain result graphs.
This package exposes statistics
about a running instance of
SessionFactory and its
interaction with the database and second-level cache.The built-in implementation of the statistics collection service.
An SPI allowing customized statistics collection.
Contains tooling related to DDL generation, export, migration, and validation.
Implementation of the SPI for schema information extraction from the database via JDBC.
Defines an SPI for schema information extraction from the database via JDBC.
An implementation of the SPI for the tooling related to DDL generation, export, migration, and validation.
Support for exporting generated DDL to the database or to SQL scripts.
Support for reading SQL scripts supplied to the schema tooling.
An SPI for tooling related to DDL generation, export, migration, and validation.
Defines strategies for post-processing criteria query
results into a form convenient to the application.
Most contracts here have been replaced by the new runtime
mapping model.
A Hibernate
Type is a strategy for mapping a Java
property type to a JDBC type or types.Contracts for reading and writing values to and from JDBC.
Implements the SPI for basic-typed value conversions.
An SPI for basic-typed value conversions, including support for handling
JPA
AttributeConverter instances as part of
the Hibernate Type system.Integrates a range of types defined by the JDK with the type system
of Hibernate.
Defines handling of almost the full range of standard JDBC-defined SQL data types.
An API for working with abstract families of DDL types
parameterized by varying length, precision, and scale.
Includes several general-purpose implementations of
DdlType.Defines a registry for
DdlTypes.Support for type mappings which format composite values to a structured
text format (JSON or XML) for storage in a database-specific column type
supporting that structured format.
Implementations of
FormatMapper using Jackson.An implementation of
FormatMapper using Jakarta JSON.An implementation of
FormatMapper using JAXB.Defines a registry for Hibernate
Types.An API for user-defined custom types which extend the set of built-in
types defined in
org.hibernate.type.Bootstrap classes HibernateValidator and HibernateValidatorConfiguration which uniquely identify Hibernate Validator
and allow to configure it.
Public types dealing with the integration of Hibernate Validator and CDI ("Contexts and Dependency Injection
for JavaTM", JSR 346).
Classes for enabling Bean Validation CDI integration.
Classes for enabling Bean Validation method validation via a CDI interceptor.
Entry point for the programmatic constraint definition API.
Contains facet and creational context interfaces forming the API for programmatic constraint definition.
Constraint definition classes for programmatic constraint definition API.
Brazil specific constraint definition classes for programmatic constraint definition API.
Poland specific constraint definition classes for programmatic constraint definition API.
Russian specific constraint definition classes for programmatic constraint definition API.
Hibernate Validator specific constraints.
Hibernate Validator Brazilian constraints.
Hibernate Validator Polish constraints.
Hibernate Validator Russian constraints.
Hibernate Validator
Duration constraints.Custom Hibernate Validator specific constraint validation extension classes.
This package provides support for dynamic default group sequence definition.
Creational context implementations of the API for programmatic
constraint definition.
Implementations of the Bean Validation built-in constraints.
Implementations of the Bean Validation
NotEmpty constraint.Contains
ConstraintValidator implementations for
various number constraints.Contains
ConstraintValidator implementations for
min and max constraints for numbers.Contains
ConstraintValidator implementations for
Positive, PositiveOrZero,
Negative and NegativeOrZero
constraints.Implementations of the Bean Validation
Size constraint.Constraint validator implementations of the Bean Validation time related constraints.
Constraint validator implementations of the Bean Validation
Future constraint.Constraint validator implementations of the Bean Validation
FutureOrPresent constraint.Constraint validator implementations of the Bean Validation
Past constraint.Constraint validator implementations of the Bean Validation
PastOrPresent constraint.Implementations of Hibernate Validator specific constraints.
Implementations for the core interfaces of Jakarta Bean Validation.
Classes dealing with the representation of constraints and the management/instantitation of constraint
validators.
Helper classes for the processing of groups.
Helper classes for message interpolation.
Helper classes for setting up the Expression Language context for message interpolation.
Classes related to parsing a message descriptor and extracting interpolation terms.
Classes related to the Path.Node API.
Various implementations of the TraversableResolver interface.
Classes related to the evaluation of script with the JSR 223 ScriptEngine.
Contains various implementation of validation contexts and supporting classes.
Implementations of the Bean Validation metadata interfaces as well as Hibernate Validator specific meta data classes.
The classes in this package contain the aggregated meta data needed for an actual validation.
Contains MethodConfigurationRule and its subclasses used to validate the correctness of method constraints
on overridden/implemented methods in inheritance hierarchies.
Core classes of the internal model used for representing constraints and related metadata.
Implementation of the Bean Validation meta data API.
Contains the facet interfaces implemented by the aggregated meta data model types, allowing for a unified
validation routine for all kinds of validation (bean, parameter and return value validation).
Contains types for the representation of constraint locations.
Abstraction of the meta data sources - annotation, xml, programmatic.
The raw metadata is a reflection of all configured constraints including constraints defined via multiple
configuration sources.
Independent helper classes.
Annotation proxy and descriptor.
Contains classes for working with the elements of a class hierarchy.
Logging classes.
Implementations of PrivilegedAction in order to execute reflection operations in a security manager.
Classes for parsing of Bean Validation XML configuration files.
Implementations of the MessageInterpolator interface in particular ResourceBundleMessageInterpolator which can be
used by custom implementations of the interface for delegation.
Custom Hibernate Validator
jakarta.validation.ParameterNameProvider implementations.Hibernate Validator extensions around
jakarta.validation.Path.ResourceBundleLocator interface and its various implementations.
This package provides support for dynamic default group sequence definition.
This package provides support for customizing the getter detection logic.
ResourceBundleLocator interface.
This package provides support for customization of the script evaluation for
ScriptAssert
and ParameterScriptAssert constraints.This package contains utility classes.
This package contains the logging classes.
This package contains the event bridge implementation between Infinispan and CDI.
This package contains the adapters making the bridge between Infinispan cache events and CDI.
This package contains the adapters making the bridge between Infinispan cache manager events and CDI.
This package contains the logging classes.
This package contains the logging classes.
Hot Rod client API.
Hot Rod client annotations.
Hot Rod client configuration API.
Hot Rod client remote event API.
Hot Rod client exceptions.
Commons package
Commons API package
Commons Configuration package
Commons Executors package
Commons Hash package
Commons IO package
Pluggable lookup for MBeanServer.
Provides Infinispan-specific input and output streams, buffers and related utilities.
Provides Infinispan-specific extensions to the marshallers.
Commons package providing various utility classes
Provides commons interfaces and classes related to concurrency
Clustered Counters API.
Clustered Counters Exceptions.
Embedded Clustered Locks.
Clustered Locks API.
Clustered Locks Exceptions.
MultimapCache API.
Query API that lets you perform Ickle queries and look up values in caches.
Continuous querying API.
Mostly internal search related classes.
Query DSL API.
Query DSL implementation internals.
Query builder DSL implementation for Ickle (a JP-QL subset).
Query module internals.
Externalizers for several Lucene objects.
Query client support classes.
Hot Rod query client side implementation details.
The core client API for interacting with the management controllers for
either a JBoss Application Server Managed Domain or a standalone JBoss Application Server.
Convenience API built on top of the
core management API
to make it easier to perform common management tasks against a JBoss Application Server Managed Domain.Implementation classes to support the
managed domain convenience API.Convenience API built on top of the
core management API
to make it easier to perform common management tasks against a single standalone JBoss Application Server instance.Implementation classes to support the
standalone server convenience API.Implementation classes to support the
core JBoss AS management client API.Dynamic Model Representation (DMR) Streaming API for reading and writing DMR documents.
The modular service container base package.
Classes which implement value injection.
The service container implementation itself.
Classes which implement various indirect value types.
Public clustering API which facilitates remote command execution
on the cluster.
Public clustering API which represent cluster group and its members.
Public clustering API for registering services on a group of nodes.
Public clustering API for clustered registry that stores a unique key/value pair per node.
Common classes for a variety of purposes.
Classes for dealing with Zip and JAR format archives.
Classes related to the manipulation of byte sequences.
Classes relating to encoding and decoding.
Types related to management of contextual objects.
A set of utility classes to determine information about the runtime environment's CPU configuration.
Expression string parsing and expansion classes.
Classes which implement useful functions which are missing from
java.util.function.Classes related to iteration.
Classes which provide basic lock types.
Classes which perform various common mathematical functions.
Utilities relating abstractly to network-related activities.
Utilities related to the operating system and current process.
Classes which implement reference types which can be cleaned up automatically by a background thread.
Classes which are commonly useful for simple RPC applications.
Classes which perform various common string functions.
Classes which create XML related factories with safe defaults.
WildFly security base package.
AS1 constants and utilities.
Audit logging related resources.
Classes relating to authentication on the client and server side.
Extended callbacks and supporting utilities which allow efficient callback handler implementation.
Elytron Client enable remote clients to authenticate using Elytron.
JSR-196 Java Authentication SPI for Containers (JASPI) - Public API.
JSR-196 Java Authentication SPI for Containers (JASPI) - Internal Implementation.
Permissions which pertain to authentication and authorization.
The principal types used by this API.
Security realm implementations for Elytron.
Classes related to a
SecurityRealm implementation based on the JDBC (Java Database Connectivity) API.Classes related to mapping columns from a database table to internal representations of identity data (eg.: attributes, password and keys, etc).
Classes related to a
SecurityRealm implementation capable of integrating with
LDAP servers.Classes related to a
SecurityRealm implementation that handles different types of security tokens.Classes related to the different
TokenValidator implementations provided by Elytron.Server side of authentication provided by Elytron.
Miscellaneous utility classes and APIs for client and server login applications.
Elytron's Authorization API
JSR-115 Java Authorization Contract for Containers (JACC) implementation.
Package for Credential Store API/SPI classes and interfaces.
Private utility package containing utilities for encryption and keys.
The evidence types used by Elytron.
Package containing the HTTP based authentication APIs, SPIs and related classes.
Implementation classes which do not form part of the public API.
Package containing utility classes for HTTP authentication, predominantly special factory wrappers.
Utility classes providing and augmenting support for
KeyStore management.The WildFly security manager implementation and supporting utilities.
Packages and files for handling text passwords and their various encoding strategies.
The Elytron implementation of password types.
Interfaces which represent each of the supported password encoding strategies.
Classes intended to hold raw password material.
WildFly SASL providers base package.
Package to hold utility classes of the Elytron project.
Package containing X.500 representations.
Package containing APIs for generating certificates and certificate signing requests.
Key utilities.
X.500 utilities.