All Classes and Interfaces
Class
Description
DTO for an HTML <a>
element.
DTO for an HTML <abbr>
element.
Builder twin of the About page (
about.ftlh).About: what the petstore demonstrates, as prose cards, plus Juneau's REST utility beans shown against the
Pet domain bean.Revision-neutral base class for Model Context Protocol (MCP) clients.
Fluent, self-typed builder for
AbstractMcpClient subclasses.Drop-in
BasicRestServlet subclass that exposes a single MCP JSON-RPC endpoint at POST /.Shared abstract base for the
RestBuilder flavor builders (RestServlet.Builder,
RestResource.Builder, RestMixin.Builder).Represents a parsed Accept HTTP request header.
Represents an HTTP Accept header.
Represents a parsed Accept-Charset HTTP request header.
Represents an HTTP Accept-Charset header.
Represents an HTTP 202 Accepted response.
Represents an HTTP 202 Accepted response.
Unmodifiable point-in-time snapshot of the enclosing
Accepted response.Unmodifiable point-in-time snapshot of the enclosing
Accepted response.Represents a parsed Accept-Encoding HTTP request header.
Represents an HTTP Accept-Encoding header.
Represents a parsed Accept-Language HTTP request header.
Represents an HTTP Accept-Language header.
Represents a parsed Accept-Range HTTP response header.
Represents an HTTP Accept-Ranges header.
Abstract base class for reflection info classes that wrap
AccessibleObject.One item in an action bar: either an
ActionRef (opaque id naming a write action on the
enclosing view) or a SafeAction (client-only, no endpoint).An opaque id naming a write action on the enclosing view.
The visual weight an
ActionRef button is painted with.One row-state rule gating an
ActionRef.The typed result a row action's submit returns — the load-bearing half of the write path.
The outcome discriminator a row-action submit reports.
The result of a
ReactiveStreamsAdapter.adapt(...) call:
either a single-value CompletionStage or a multi-value
Flow.Publisher.The JSON Patch
"add" operation per
RFC 6902 § 4.1.DTO for an HTML <address>
element.
Mixin that serves operational-introspection endpoints under
/admin/*: thread dump,
heap statistics, configurable cache-flush hooks, and rate-limit-bucket inspection.Builder for
AdminMixin instances.Flavor-neutral operational-introspection worker bean shared by the admin
@Rest flavors.Builder for
AdminProvider instances.Child-resource flavor of the
AdminMixin mixin.Standalone servlet companion of the
AdminMixin mixin.Built-in default
RequestStateCodec: AES-256-GCM keyed by a pluggable KeyProvider.Represents a parsed Age HTTP response header.
Represents an HTTP Age header.
Represents a parsed Allow HTTP response header.
Represents an HTTP Allow header.
Represents an HTTP 208 Already Reported response.
Represents an HTTP 208 Already Reported response.
Unmodifiable point-in-time snapshot of the enclosing
AlreadyReported response.Unmodifiable point-in-time snapshot of the enclosing
AlreadyReported response.Identifies possible values for the
HtmlSerializer.Builder.uriAnchorText(AnchorText) setting.Interface for all annotatable wrapper classes.
Enum representing the type of reflective object.
Class used to add properties to a context builder (e.g.
Applied to annotations that belong to a similar group (e.g.
Encapsulates information about an annotation instance and the element it's declared on.
A concrete implementation of a Java annotation that can be created programmatically at runtime.
Builder for
AnnotationObject objects.Enhanced annotation provider that returns
AnnotationInfo objects and supports runtime annotations.Builder for creating configured
AnnotationProvider instances.The built-in
annotations decorator: ECharts markPoint presets (max, min, average) on every series,
or explicit points on a carrier series juneau-annotations-<n>.Defines traversal options for annotation searches.
Annotation utilities.
A unit of work for applying an annotation to a context builder.
A list of
AnnotationWork objects.Used for assertion calls against generic POJOs.
HttpTransport implementation backed by Apache HttpClient 4.5.Fluent builder for
ApacheHc45Transport.HttpTransportProvider implementation that supplies an ApacheHc45Transport.HttpTransport implementation backed by Apache HttpClient 5.x.Fluent builder for
ApacheHc5Transport.HttpTransportProvider implementation that supplies an ApacheHc5Transport.AuthFilter that authenticates requests via a raw API-key string.Builder class.
Source of the API-key string.
AuthN
RestGuard that authenticates requests via a raw API-key string.Builder class.
Source of the API-key string.
SPI for resolving a raw API key string to its associated
Principal.Petstore Jetty/Microservice deployment entry point.
Petstore Spring Boot deployment entry point.
Entry-point class.
Application-specific configuration class contributing the top-level REST servlet and the console, API and admin
boundary filters.
Application-specific configuration class contributing the
LoadConfigResource servlet.An implementation of an annotation that can be dynamically applied to classes, methods, fields, and constructors at runtime.
Builder for
AppliedAnnotationObject objects.Builder for applied annotations targeting constructors.
Builder for applied annotations targeting methods.
Builder for applied annotations targeting methods and fields.
Builder for applied annotations targeting classes.
Builder for applied annotations targeting classes and methods.
Builder for applied annotations targeting classes, methods, and fields.
Builder for applied annotations targeting classes, methods, fields, and constructors.
An implementation of an annotation that can be dynamically applied to classes, methods, fields, and constructors,
with additional support for type-safe class targeting via the
AppliedOnClassAnnotationObject.onClass() property.DTO for an HTML <area>
element.
General exception due to a malformed Java parameter.
Lean parser for command-line arguments passed in through a
main(String[] args) method.Builder for
Args with configurable grammar hooks.Property source backed by
Args.Provider for
ArgsPropertySource.JVM args variable resolver.
Arithmetic functions for the
#{...} script catalog.#{abs(a)} — returns the absolute value of a.#{add(a, b)} — returns a + b.#{divide(a, b)} — returns a / b.#{max(a, b)} — returns the larger of two numbers.#{min(a, b)} — returns the smaller of two numbers.#{modulo(a, b)} — returns a % b.#{multiply(a, b)} — returns a * b.#{subtract(a, b)} — returns a - b.Used for assertion calls against arrays.
Capability role for parsers that can stream the elements of a top-level wire array, yielding
each element as a separate record.
Capability role for serializers that can emit each element of a top-level wire array as a
separate record.
DTO for an HTML <article>
element.
Stores a Map of ASCII characters to Strings in a quick-lookup array.
Stores a set of ASCII characters for quick lookup.
Builder class.
DTO for an HTML <aside>
element.
Identifies possible float values for
HtmlDocSerializer.Builder.asideFloat(AsideFloat).Base class for all assertion objects.
Wrapper around a
Predicate that allows for an error message for when the predicate fails.Encapsulates multiple predicates into a single AND operation.
Negates an assertion.
Encapsulates multiple predicates into a single OR operation.
Predefined
AssertionPredicate objects.Main class for creation of assertions for stand-alone testing.
Test helper that checks every asset a rendered console page links (stylesheets, scripts, images, icons) actually
resolves.
The
assetUrl(path) FreeMarker method: appends ?v=<crc32> of an adopter's own bundled static asset
to its URL path, so a browser cannot keep a stale copy after a deploy.A single in-memory, one-shot async job — the streamed-progress + terminal-result unit of a future async write
variant.
The result of null while the job is still running).
AsyncJob.awaitUpdate(int, Duration): the newly-available progress events and the terminal
result (The "job accepted" envelope a row action's submit returns instead of a terminal
ActionResult when
the write is asynchronous.An in-memory, per-process registry of
async jobs — the single-process job store a future
async write variant runs on.Mixin interface that exposes the async-job SSE progress stream and cancel endpoint on any Juneau REST resource.
Response processor that unwraps
CompletableFuture / CompletionStage return values from
@RestOp-annotated methods and bridges them to the servlet container's
asynchronous request lifecycle.Various useful static methods for creating ATOM elements.
Atom feed example.
Atom feed HTML example.
Atom feed JSON example.
Atom feed XML example.
REST request attribute annotation.
DTO for an HTML <audio>
element.
MCP
audio content block (base64 data).One audit-trail record: who changed which petstore entity, how, and when.
Audit log: a read-only, server-mode table over the store's audit trail.
Marks a
@RestOp-method parameter as the authenticated Principal for the current request.Resolves
@RestOp-method parameters that represent the authenticated Principal.An
HttpServletRequestWrapper that surfaces the filter-resolved Principal and aggregated roles via the
standard servlet API surface.Specialization of
Unauthorized thrown by BearerTokenGuard, ApiKeyGuard, and
user-supplied TokenValidator / ApiKeyStore implementations to signal AuthN failure.Lowest-level authentication contract shared by the servlet-filter layer (
AuthFilter,
AuthFilterChain) and the resource layer (RestAuthenticator).Abstract base class for Juneau authentication servlet filters.
Orchestrates multiple
AuthFilter instances with first-success principal resolution, role aggregation, and
all-failure aggregation semantics.Builder class.
Represents a parsed Authorization HTTP request header.
Represents an HTTP Authorization header.
Fluent builder for assembling an HTTP Authorization credentials value.
Immutable value type returned by
Authenticator.authenticate(jakarta.servlet.http.HttpServletRequest) on success.Controls how an
AuthResult merges with results accumulated earlier in an authenticator chain.Mutable helper that folds a sequence of
AuthResults into a single result, honoring
AuthResult.MergeMode.A dynamic object swap based on reflection of a Java class that converts objects to Lists.
A dynamic object swap based on reflection of a Java class that converts Objects to serializable Maps.
A dynamic object swap based on reflection of a Java class that converts Objects to Number serializable objects.
A dynamic object swap based on reflection of a Java class that converts Objects to serializable objects.
A dynamic string swap that serializes objects via
Object.toString() and deserializes via
fromString(String), valueOf(String), or a single-String-argument constructor.DTO for an HTML <b>
element.
Represents an HTTP 502 Bad Gateway error response.
Unmodifiable point-in-time snapshot of the enclosing
BadGateway exception.An overlay badge on a header action (a bell count, for example) or a
BarBadge.A count badge in the page contract, fed by a JSON endpoint and polled by
juneau-badges.js.placement wire tokens.scope.by wire tokens.tone wire tokens.The
<@badge> FreeMarker twin of PageSpec.badge(BadgeDef): every scalar or enum BadgeDef
field is a plain attribute (the label templates as labelOne, labelOther and labelMine, the
scope as scopeParam and scopeBy, the state filter as stateFilterColumn).Exception representing an HTTP 400 (Bad Request).
Represents an HTTP 400 Bad Request error response.
Unmodifiable point-in-time snapshot of the enclosing
BadRequest exception.Unmodifiable point-in-time snapshot of the enclosing
BadRequest exception.The built-in
bands decorator: shaded x ranges from a list, a same-origin src, a data: topic,
or the gaps in the first series (Bands.gaps()).A labelled count widget in a
BarSlot — the "N change pending"-style badge to the right of the subtab
ribbon.An additive trailing region beside the subtab ribbon: a small row of
BarWidgets (concept #9).A static contextual label widget in a
BarSlot.DTO for an HTML <base>
element.
Base class for implementations of
HttpPartParserBuilder class.
Base class for implementations of
HttpPartParserSessionBase class for implementations of
HttpPartSerializerBuilder class.
Base class for implementations of
HttpPartSerializerSessionConvenience assembly of the Actuator-style management surface under a single configurable path prefix.
An extension of
AssertionError with helper constructors for messages with printf-style arguments.An extension of
AssertionError with helper constructors for messages with message-style arguments.Default implementation of
BeanConverter for Bean-Centric Test (BCT) object conversion.Builder for creating customized BasicBeanConverter instances.
Simple implementation of the
MarshallingDefMapper interface.Basic implementation of
WritableBeanStore.Category of headers that consist of a single boolean value.
A
NameValuePair that consists of a single boolean value.A concrete
CachingConverter that supports common type conversions without
requiring a MarshallingContext or MarshallingSession.A
NameValuePair that consists of a comma-delimited list of string values.Category of headers that consist of a comma-delimited list of string values.
Category of headers that consist of a single HTTP-date.
A
NameValuePair that consist of a single HTTP-date.Category of headers that consist of a single entity validator value.
Category of headers that consist of a comma-delimited list of entity validator values.
Basic implementation of a
FileFinder.Superclass of all headers defined in this package.
Basic implementation of a
HeaderIterator.A basic template for the HTML doc serializer.
Concrete
HtmlWriter leaf for standard HTML output.A basic
HttpEntity implementation with additional features.Basic implementation of the
HttpResponse interface for error responses.Base class for HTTP error response exceptions (4xx and 5xx) in the
org.apache.juneau.http stack.Unmodifiable point-in-time snapshot of the enclosing
BasicHttpException.Unmodifiable point-in-time snapshot of the enclosing
BasicHttpException.Basic implementation of the
HttpResponse interface.Base class for concrete HTTP response objects in the
org.apache.juneau.http stack.Category of headers that consist of a single integer value.
A
NameValuePair that consists of a single integer value.Basic implementation of a Jetty server factory.
Basic configuration for a REST resource that supports JSON 5 transport.
Basic configuration for a REST resource that supports JSON transport.
Basic configuration for a REST resource that supports JSON and HTML transport.
Concrete
JsonWriter leaf for standard JSON output.Category of headers that consist of a single long value.
A
NameValuePair that consists of a single long value.Default
McpSubscriptionBroker: a ConcurrentHashMap-backed registry doing filtered fan-out.Category of headers that consist of multiple parameterized string values.
Category of headers that consist of a single parameterized string value.
Basic extensible microservice listener with default no-op method implementations.
Implementation of a named object.
A simple immutable implementation of
NameValuePair.Basic configuration for a REST resource that supports OpenAPI transport.
Basic implementation of an
OpenApiProvider.A single session of generating an OpenAPI 3.1 document.
Implementation of
NameValuePair for serializing POJOs as URL-encoded form post entries.Basic implementation of a
PartIterator.Default property namer.
Basic configuration for a REST resource that supports Protobuf Text Format transport.
A basic
HttpResource implementation with additional features.Default HTTP call handler.
A default implementation of a
RestCallInterceptor.Default
RestClientDebugFormatter implementation — secure by default.Default
RestDebugFormatter implementation — secure by default.Identical to
BasicRestServlet but doesn't extend from HttpServlet.Identical to
BasicRestServletGroup but doesn't extend from HttpServlet.Subclass of
RestServlet with default settings and standard endpoints defined.Specialized subclass of
BasicRestServlet for showing "group" pages.Subclass of runtime exceptions that take in a message and zero or more arguments.
Subclass of runtime exceptions that take in a message and zero or more arguments.
Subclass of
SpringRestServlet with default settings and standard endpoints defined.Specialized subclass of
BasicSpringRestServlet for showing "group" pages.API for retrieving localized static files from either the classpath or file system.
A basic implementation of the
StatusLine interface.An unmodifiable point-in-time snapshot of a
BasicStatusLine.Category of headers that consist of a single string value.
A
NameValuePair that consists of a single string value.Category of headers that consist of simple comma-delimited lists of strings with q-values.
Basic implementation of a
SwaggerProvider.A single session of generating a Swagger document.
Default
RestDebugFormatter registered by MockRestClient / mock.classic.MockRestClient for
mocked resources.Shared, marshall-free test utilities common to Juneau test modules.
Basic implementation of a Tomcat server factory.
Basic configuration for a REST resource that supports TOML transport.
Predefined configuration for a REST resource that supports all languages
and provides common default configuration values.
Identical to
BasicUniversalConfig but includes RDF marshalling support.Category of headers that consist of a single URL value.
A
NameValuePair that consists of a single URL value.Concrete
XmlWriter leaf for standard XML output.Basic configuration for a REST resource that supports YAML transport.
Comprehensive utility class for Bean-Centric Tests (BCT) and general testing operations.
Annotation for configuring BCT settings in JUnit 5 tests.
JUnit 5 extension that processes
BctConfig annotations.Configuration utility for Bean-Centric Testing (BCT) framework.
Holder for
@Value-resolved BCT default sort flags.Bean-Centric Testing utility methods.
DTO for an HTML <bdi>
element.
DTO for an HTML <bdo>
element.
Bean injection annotation.
Utility classes and methods for the
@Bean annotation.A collection of
@Bean annotations.Builder class.
Used for assertion calls against Java beans.
A lifecycle-aware round-trip interface that combines both
BeanSupplier (for serialization)
and BeanConsumer (for parsing) on the same property or class.Annotation for specifying bean-modeling config properties on REST classes and methods.
Utility classes and methods for the
@BeanConfig annotation.Utility classes and methods for the
@BeanConfig annotation.Applies
BeanConfig annotations to a MarshallingContext.Builder.Immutable runtime configuration for the bean-modeling layer.
Builder for
BeanConfigContext.A lifecycle-aware consumer for use as a parser target, receiving deserialized beans one at a time.
Abstract interface for Bean-Centric Test (BCT) object conversion and property access.
Unchecked exception thrown when a bean creator method is found but its invocation fails.
Maps constructor arguments to property names on beans with read-only properties.
Utility classes and methods for the
@BeanCtor annotation.Builder class.
Dynamically applies a
@BeanCtor annotation to specified constructors.A collection of
@BeanCtorApply annotations.Utility classes and methods for the
@BeanCtorApply annotation.Applies targeted
BeanCtorApply annotations to a Context.Builder.Builder class.
Simple serializable bean description.
Information about a bean property.
Represents a collection of bean classes that make up a bean dictionary.
Represents a map of dictionary type names to bean classes that make up a bean dictionary.
Utility class for comparing two versions of a POJO.
Builder class.
Sample class which shows the usage of DTO module which is a
Sub module of the core.
A universal factory interface used with @Marshalled (factory=X.class) for any bean type the
framework needs to instantiate.
Sentinel class used as the default value for
@BeanType(factory=...) and
@BeanProp(factory=...) when no factory is specified.Bean-modeling SPI seam that exposes the per-class filter surface the bean-runtime types
(
BeanMeta-equivalent) need without coupling the bean-modeling layer to the marshalling-side
MarshalledFilter.Excludes a class, field, method, or constructor from bean introspection.
Utility classes and methods for the
@BeanIgnore annotation.Builder class.
Dynamically applies a
@BeanIgnore annotation to specified classes, methods, fields, or constructors.A collection of
@BeanIgnoreApply annotations.Utility classes and methods for the
@BeanIgnoreApply annotation.Applies targeted
BeanIgnoreApply annotations to a Context.Builder.Builder class.
Bean-modeling SPI seam that exposes the type-classification surface the bean-runtime types
(
BeanMeta-equivalents, BeanPropertyMeta-equivalents, etc.) need without coupling
the bean-modeling layer to the marshalling-side ClassMeta.Utility class for creating beans through constructors, creator methods, and builders.
Builder for
BeanInstantiator.Lifecycle scope for the bean being created.
Bean interceptor.
Non-existent bean interceptor.
Used for assertion calls against Java beans.
Java bean wrapper class.
Represents a single entry in a bean map.
Marshalling-side helper for loading
BeanMap contents from JSON text or a reader/parser pair.Encapsulates all access to the properties of a bean class (like a souped-up
BeanInfo).Represents the result of creating a BeanMeta, including the bean metadata and any reason why it's not a bean.
Bean-modeling SPI seam that exposes marshalling-aware
BeanMeta construction hooks.Annotation that can be applied to bean fields, getter/setter methods, and constructor parameters
to control bean introspection and property modeling.
Utility classes and methods for the
@BeanProp annotation.Builder class.
Dynamically applies a
@BeanProp annotation to specified classes, methods, or fields.A collection of
@BeanPropApply annotations.Utility classes and methods for the
@BeanPropApply annotation.Applies targeted
BeanPropApply annotations to a Context.Builder.Builder class.
Represents a consumer of a single bean property value.
Contains metadata about a bean property.
BeanPropertyMeta builder class.
Bean-modeling SPI seam that applies marshalling-side post-processing to a
BeanPropertyMeta.Builder
after BeanPropertyMeta.Builder#validate() succeeds.Represents a simple bean property value and the meta-data associated with it.
Provides an
InvocationHandler for creating dynamic proxy instances of bean interfaces.A protocol-agnostic query request against a collection of beans: what to search, which columns to return, how to
sort, and which page to return (design §5.1, §5.3).
Builds an immutable
BeanQuery.A group of cross-column conditions built with
BeanQuery.Builder.or(Consumer),
BeanQuery.Builder.and(Consumer), or BeanQuery.Builder.not(Consumer).The reusable, immutable, server-side half of a BeanQuery engine: which columns may be searched, sorted and viewed,
which operators apply, and the limits every session enforces.
The settings every engine's context builder shares.
A server-side failure while running a valid
BeanQuery: a SQLException, a connection failure, or a
column accessor that throws.One unit of query work against a
BeanQueryContext: the rows (or connection) to query, plus optional
per-request narrowing of the context's settings.The settings every engine's session builder shares.
Thrown when a
$-search expression names an unknown operator or is otherwise malformed (an unclosed
parenthesis, a wrong argument count, junk after the close paren, an empty expression, and so on), or when a
higher-level check (column allow-list, sort keys, paging, regex policy, operator/type mismatch, an unparseable
typed value) rejects a caller-supplied query.Stable identity for a
BeanQuerySyntaxException, independent of the (free-text) message.A lookup table for resolving bean types by name.
Bean-modeling SPI seam that exposes the dictionary-lookup surface the bean-runtime types need without
coupling the bean-modeling layer to the marshalling-side
BeanRegistry.A
RuntimeException wrapper around common reflection exceptions.Minimum runtime surface that the bean-modeling layer needs from a marshalling session.
Spring-bean-like interface for looking up beans by type and name.
Marker interface for builders that accept an overriding
BeanStore — a layer
whose entries take precedence over the builder's local bean registrations during construction-time
reflective injection.A lifecycle-aware producer for use as a serializer source, providing beans lazily one at a time.
Utility class for testing bean functionality in a standardized way.
Annotation that can be applied to classes to control bean introspection and modeling.
Utility classes and methods for the
@BeanType annotation.Builder class.
Dynamically applies a
@BeanType annotation to specified classes.A collection of
@BeanTypeApply annotations.Utility classes and methods for the
@BeanTypeApply annotation.Applies targeted
BeanTypeApply annotations to a Context.Builder.Builder class.
Bean-modeling SPI seam that exposes the type-resolution operations the bean-property
validation pass needs from the marshalling layer.
Static dispatcher for the optional Jakarta Bean Validation 3.x integration.
AuthFilter that authenticates requests via the
RFC 6750 Bearer Token scheme.Builder class.
AuthN
RestGuard that authenticates requests via the
RFC 6750 Bearer Token scheme.Builder class.
How a header/menu action behaves when the user activates it.
A bidirectional map with reverse key lookup by value.
Builder class for
BidiMap.Supported wire formats for
BigInteger and BigDecimal values.Supported wire formats for
byte []Discriminant returned by
TokenReader.getNativeKind() that classifies the
binary-native metadata (if any) carried by the cursor's current token.Thin delegating swap for top-level
byte[] values in textual serializers.Supported wire formats for
BitSet values.Base64 blob body for
resources/read results or embedded resource content.Base64 blob body for
resources/read results or embedded resource content.DTO for an HTML <blockquote>
element.
DTO for an HTML <body>
element.
Converts a Java object passed to
RestRequest.body(Object) into a TransportBody.A checked function used by
BodyConverter.of(Class, ThrowingConverter).Used for assertion calls against booleans.
Supported wire formats for
Boolean / boolean Boolean-logic and comparison functions for the
#{...} script catalog.#{and(a, b, ...)} — returns "true" only if all args are true.#{eq(a, b)} — string-equality.#{gt(a, b)} — numeric greater-than.#{gte(a, b)} — numeric greater-than-or-equal.#{lt(a, b)} — numeric less-than.#{lte(a, b)} — numeric less-than-or-equal.#{neq(a, b)} — string-inequality.#{not(a)} — returns the boolean negation of a.#{or(a, b, ...)} — returns "true" if any arg is true.#{xor(a, b)} — returns a XOR b.A simple mutable boolean value.
Why a
RequestBoundary refused a request.The outcome of
RequestBoundary.check(jakarta.servlet.http.HttpServletRequest): either allowed, or a
rejection carrying the reason, the HTTP status to answer with, and a message safe to return to the caller.Thread-safe bounded LRU implementation of
TokenCache.ServletInputStream wrapper around a normal input stream with support for limiting input.
DTO for an HTML <br>
element.
Declares one server bridge in the page contract's
bridges list.<@bridge id transport session downstream upstream? maxAttempts?/>: declares a server bridge in the
contract's bridges list.Annotation that can be applied to classes, fields, and methods to tweak how they are handled by
BsonSerializer and BsonParser.A pairing of a
BsonSerializer and BsonParser into a single class with convenience to/of methods.Utility classes and methods for the
@Bson annotation.Builder class.
Dynamically applies a
@Bson annotation to specified classes, methods, or fields.A collection of
@BsonApply annotations.Utility classes and methods for the
@BsonApply annotation.Applies targeted
BsonApply annotations to a Context.Builder.Builder class.
A
Bson variant that represents binary values as Base64 text instead of raw BSON bytes.Metadata on bean properties specific to the BSON serializers and parsers pulled from the
@Bson
annotation on the bean property.Metadata on classes specific to the BSON serializers and parsers pulled from the
@Bson annotation on
the class.Annotation for specifying config properties defined in
BsonSerializer and BsonParser.Utility classes and methods for the
@BsonConfig annotation.Applies
BsonConfig annotations to a BsonParser.Builder.Applies
BsonConfig annotations to a BsonSerializer.Builder.IEEE 754-2008 Decimal128 BID (Binary Integer Decimal) encoding for BSON.
Specialized input stream for parsing BSON (Binary JSON) streams.
Interface for providing access to
BsonClassMeta and BsonBeanPropertyMeta objects.Specialized output stream for serializing BSON (Binary JSON) streams.
Parses BSON (Binary JSON) into POJO models.
Default parser, string input encoded as BASE64.
Builder class.
Default parser, string input encoded as spaced-hex.
Session object that lives for the duration of a single use of
BsonParser.Builder class.
Serializes POJO models to BSON (Binary JSON).
Default serializer, BASE64 string output.
Builder class.
Default serializer, spaced-hex string output.
Session object that lives for the duration of a single use of
BsonSerializer.Builder class.
A
Bson variant that represents binary values as spaced hexadecimal text instead of
raw BSON bytes.Identifies a class as a builder for a POJO class.
Specialized transform for builder classes.
The bulk-mutate opt-in for a
ViewTable — the second, INDEPENDENT half of the row-selection /
bulk-mutate separability guarantee.The request body of an
aggregate-mode bulk action (RowAction.BulkMode.AGGREGATE) —
every selected row's stable id, plus a client-generated idempotency key so a retried submit (e.g. after a
dropped connection) never double-applies.The response shape of an
aggregate-mode bulk action (RowAction.BulkMode.AGGREGATE) —
one outcome per id submitted in the matching BulkRequest.A mutable builder for
BulkResult.One failed-outcome entry: the id that was submitted, and why it failed.
Exposes the bus's session POST and SSE stream on a REST resource.
The bus wire format, version 1: one JSON object per frame, in a canonical field order shared with the
browser codec and pinned by
bus-frames-corpus.json.What a
ServerBus will carry, in which direction, to whom.Builder for
BusPolicy.A named refusal from the bus: the session POST's
400/403/429/501 answers and the codec's
bus:bad-frame.One page's bridge session.
The handshake guards of the bus's WebSocket endpoint (Origin, Host, fetch-site and capability checks).
The per-connection endpoint of the bus's WebSocket transport.
Registers the bus's WebSocket endpoint on the servlet container (Jakarta WebSocket 2.2).
Static check of a page contract's message-bus wiring: rule R-10 (every
subscription has a publisher), rule R-11 (every
publisher:"server" topic rides a bridge downstream), and the
E-40..E-54 and E-58 shape rules on topics, bridges, card publishes / subscribes and ribbon
target / publish items.One wiring problem.
DTO for an HTML <button>
element.
Used for assertion calls against byte arrays.
An
HttpBody backed by a raw byte array.A repeatable entity that obtains its content from a byte array.
Unmodifiable point-in-time snapshot of the enclosing
ByteArrayEntity.A repeatable resource that obtains its content from a byte array.
An unmodifiable snapshot of a
ByteArrayResource.A simple mutable byte value.
Simple in-memory cache for storing and retrieving objects by key.
Builder for creating configured
Cache instances.Simple in-memory cache for storing and retrieving objects by two-part keys.
Builder for creating configured
Cache2 instances.Simple in-memory cache for storing and retrieving objects by three-part keys.
Builder for creating configured
Cache3 instances.Simple in-memory cache for storing and retrieving objects by four-part keys.
Builder for creating configured
Cache4 instances.Simple in-memory cache for storing and retrieving objects by five-part keys.
Builder for creating configured
Cache5 instances.Shared SEP-2549 cache-hint base for the five cacheable
2026-07-28 result carriers
(tools/list, prompts/list, resources/list, resources/templates/list, and
resources/read).Represents a parsed Cache-Control HTTP request header.
Represents an HTTP Cache-Control header.
Fluent builder for assembling an HTTP Cache-Control header value.
Cache modes for
Cache and related cache classes.Server-side caching decorator layering an optional
TokenCache over the role-neutral
OAuthClientCredentialsFlow.Builder.
An abstract
Converter implementation that caches previously determined type conversions.Wraps an
HttpServletRequest and tees a bounded copy of the request body into memory for debug logging.Wraps an
HttpServletResponse and tees a bounded copy of the output stream into memory for debug logging.Memoizing decorator for a
PropertySource whose answers can never change after construction.A reusable month-calendar definition: month/year navigation, event categories, and a display-only legend
(parent concept #10).
The view families; v1 ships
MONTH only so an author cannot set a value that only fails at validate().The first column of the week grid.
A single calendar event — also the element type of the per-month event GET envelope's
events.Supported wire formats for
Calendar values.A map of possible out-of-band callbacks related to the parent operation.
Parameters for "tools/call".
Parameters for "tools/call".
Result payload for "tools/call".
Result payload for "tools/call".
DTO for an HTML <canvas>
element.
DTO for an HTML <caption>
element.
The
<@card> FreeMarker directive: adds one entry to the page contract's cards[].A rail section holding one ordinary card.
One authored card handed to a
CardTypeHandler: its attributes, its raw body, and helpers to parse the
body as JSON5 or capture it as a <template data-card>.Builds a
CardSource.Type-agnostic card entry in the page contract:
id, type, optional src,
title, template, plus a type-specific body map.Server half of a console card type: validates an authored card and returns its page-contract fragment.
The open set of server-side card type handlers.
Builds a
CardTypeRegistry on top of an existing one, or from scratch.Marker interface for response processors that act as catch-alls — i.e. processors that
accept any non-null return value when no more-specific processor matches.
Represents a category or tag associated with a feed or entry.
Annotation that can be applied to classes, fields, and methods to tweak how they are handled by
CborSerializer and CborParser.A pairing of a
CborSerializer and CborParser into a single class with convenience read/write methods.Utility classes and methods for the
@Cbor annotation.Builder class.
Dynamically applies a
@Cbor annotation to specified classes, methods, or fields.A collection of
@CborApply annotations.Utility classes and methods for the
@CborApply annotation.Applies targeted
CborApply annotations to a Context.Builder.Builder class.
A
Cbor variant that represents binary values as Base64 text instead of raw CBOR bytes.Metadata on bean properties specific to the CBOR serializers and parsers pulled from the
@Cbor
annotation on the bean property.Metadata on classes specific to the CBOR serializers and parsers pulled from the
@Cbor annotation on
the class.Annotation for specifying config properties defined in
CborSerializer and CborParser.Utility classes and methods for the
@CborConfig annotation.Applies
CborConfig annotations to a CborParser.Builder.Applies
CborConfig annotations to a CborSerializer.Builder.Specialized input stream for parsing CBOR streams (RFC 8949).
Interface for providing access to
CborClassMeta and CborBeanPropertyMeta objects.A
Cbor variant whose parser is in native mode, exposing low-level CBOR tag and
type information in the token stream instead of normalizing it away.Specialized output stream for serializing CBOR streams (RFC 8949).
Parses CBOR streams (RFC 8949) into POJO models.
Default parser, string input encoded as BASE64.
Builder class.
Default parser, string input encoded as spaced-hex.
Session object that lives for the duration of a single use of
CborParser.Builder class.
Serializes POJO models to CBOR (RFC 8949).
Default serializer, BASE64 string output.
Builder class.
Default serializer, spaced-hex string output.
Session object that lives for the duration of a single use of
CborSerializer.Builder class.
A
Cbor variant that represents binary values as spaced hexadecimal text instead of
raw CBOR bytes.Reference implementation of the public
TokenReader surface for the CBOR format
(RFC 8949).Reference implementation of the public
TokenWriter surface for the CBOR format
(RFC 8949).Cursor-level settings honored by
CborTokenWriter.Author-declared per-cell popover attached to a
Render.Builder twin of the Pending changes page (P10,
changes.ftlh).Pending changes: the staged-edits table.
A simple mutable character value.
A subclass of
Marshaller for character-based serializers and parsers.A
Reader implementation that reads from any CharSequence (String, StringBuilder, StringBuffer, etc.).The built-in
chart card type: a JSON5 body naming a helper, a legacy flat kind, or a raw
ECharts option, with data from exactly one of src=, an inline data array or a source
(data: topic).Typed builder for a
chart card.Charts: the chart-core demo page, built with
DevPageBuilders.charts() only (it has no template twin).Content-checksum utility methods.
Host-side setting seed for the
@Rest(childrenDefs=...) attribute.Utility classes and methods for the
@Child annotation.Builder class.
A POJO structure that describes the list of child resources associated with a resource.
A rail section of checkboxes over the distinct values of one dictionary column of a data source.
DTO for an HTML <cite>
element.
A
Principal that exposes typed read-only access to a map of claims.Defines how array types should be formatted when rendered as strings.
Supported wire formats for
Class values.Thin delegating swap for
Class values driven by the context-configured ClassFormat.Lightweight utility class for introspecting information about a class.
Generic, typed variant of
ClassInfo.A wrapper class around the
Class object that provides cached information about that class.General class metadata runtime operation exception.
Defines how class names should be formatted when rendered as strings.
A themeable/configurable asset-serving mixin's cache of classpath-shipped assets: reads each configured
resource's bytes once, computes and caches its
content hash, and wraps
bytes as a cacheable HttpResource - the read+cache+hash+cache-buster-URL+serve bundle that
ConsoleChromeMixin (juneau-console) and ViewsMixin (juneau-console-views)
previously each hand-rolled as their own private statics and static cache maps.Classpath-based storage location for configuration files.
Builder class.
Utility methods for working with classes.
Class-related utility methods.
Internal utility for recognizing failures caused by the client disconnecting before the response completed.
MCP client capability advertisement in
InitializeRequest.MCP client capability advertisement carried by RequestMeta.
Represents a parsed Client-Version HTTP request header.
Represents an HTTP Client-Version header.
Specialized matcher for matching client versions.
A ByteArrayInputStream with a usable close() method.
A StringReader with a usable close() method.
DTO for an HTML <code>
element.
DTO for an HTML <col>
element.
DTO for an HTML <colgroup>
element.
Used for assertion calls against collections objects.
Specifies how collection-valued query/form parameters are serialized to a single string.
Static strings used for Swagger parameter collection format types.
Utility methods for working with collections and maps.
One datatable column's search configuration — its value
SearchType and the optional
per-column SearchOperatorSet.Maps a logical column name to its dialect-quoted SQL reference, for
SqlSearchCompiler.Repository command executed by the server.
Base class for all Atom elements, providing common attributes.
Base class for feed-level and entry-level Atom elements.
The default
MarkdownRenderer implementation: a thin wrapper around
commonmark-java with the GFM tables
extension enabled, HTML-escaped raw markup, and URL allowlisting on <a href> / <img src>.Used for assertion calls against comparable objects.
Parameters for "completion/complete".
Parameters for "completion/complete".
Result payload for "completion/complete".
Result payload for "completion/complete".
Completion values for a "completion/complete" request.
Completion values for a "completion/complete" request.
Identifies the prompt argument or resource-template variable being completed, and its current partial value.
Identifies the prompt argument or resource-template variable being completed, and its current partial value.
Empty marker capability advertising "completion/complete" support (structure may grow with
the spec).
Empty marker capability advertising "completion/complete" support (structure may grow with
the spec).
Optional already-resolved argument values supplied alongside a
completion/complete request.Optional already-resolved argument values supplied alongside a
completion/complete request.Polymorphic "completion/complete" target reference (prompt or resource template).
Polymorphic "completion/complete" target reference (prompt or resource template).
Holds a set of reusable objects for different aspects of the OpenAPI Specification.
Parquet compression codecs supported by this implementation.
Predicate hook used by
Conditional.Generic registration guard based on a custom
Condition.Conditional and routing functions for the
#{...} script catalog.#{coalesce(a, b, ...)} — replacement for the legacy $CO{...}.#{if(cond, then, else)} — replacement for the legacy $IF{...}.#{notEmpty(s)} — replacement for the legacy $NE{...}.#{switch(value, case1, val1, case2, val2, ..., default)} — replacement for the
legacy $SW{...}.Condition that requires a class to be present.
Container for repeatable
ConditionalOnClass.Condition that requires a bean to be absent in the current store.
Container for repeatable
ConditionalOnMissingBean.Container for repeatable
ConditionalOnProperty.Condition that checks a setting value.
Container annotation for repeatable
Conditional.Runtime context for evaluating
Condition instances.Main configuration API class.
Builder class.
Implements the 'config' console command to get or set configuration.
Represents a change to a config.
Listener that can be used to listen for change events in config maps.
Represents a list of
ConfigEvent objects.Possible event types for the
ConfigEvent class.An exception that typically occurs when trying to perform an invalid operation on a configuration property.
Format strategy for config map persistence.
Configuration item representing a named value (e.g., a config file section).
Represents the parsed contents of a configuration.
Represents a single entry in a configuration.
Declares a class as a prefix-scoped, whole-object config binding target — Juneau's analog of
Spring's
@ConfigurationProperties.Reusable, prefix-scoped whole-object config binder — usable with or without the
@ConfigProperties annotation.Post-bind extension seam for
ConfigPropertiesBinder.PropertySource adapter for Config.Auto-registers a classpath-default
juneau.cfg (and the other names returned by
Config.getCandidateSystemDefaultConfigNames()) as a PropertySource for the
process-wide Settings singleton.Shows contents of the microservice configuration file, and updates it.
Represents a storage location for configuration files.
Builder class.
Listens for changes to stored config files.
A
BasicConverter subclass that supports pluggable type conversion discovery via ConversionFinder.Marks a type that contributes one or more
Bean declarations.Config file variable resolver.
Exception representing an HTTP 409 (Conflict).
Represents an HTTP 409 Conflict error response.
Unmodifiable point-in-time snapshot of the enclosing
Conflict exception.Unmodifiable point-in-time snapshot of the enclosing
Conflict exception.Represents a parsed Connection HTTP request header.
Represents an HTTP Connection header.
A utility for logging formatted messages to the console.
Serves the console chrome assets (the structural
chrome.css, the stock theme packs and
juneau-console.js) at the context-root /juneau-console/* URLs that every console page links.Mixin that serves the admin-console chrome stylesheet at
/juneau-console/chrome.css.Builder for
ConsoleChromeMixin.The two head insertion points for a colour-scheme-aware page.
Implements a command that can be invoked from the console of the microservice.
The
<@console> document-shell FreeMarker directive.A
FreemarkerMixin that additionally makes the reserved-classpath admin-console chrome template
(org/apache/juneau/console/base.ftlh) — and the <@tag> macro it defines — resolvable
from any consumer template, without shadowing the consumer's own basePath-rooted template tree.Builder for
ConsoleFreemarkerMixin.The capture-only console slot directives:
<@head>, <@scripts>, <@brand>,
<@actions>, <@title>, <@footer>, and <@body>.Static lint for console FreeMarker templates.
One lint finding.
The console's write gate.
Global constants used across the Juneau framework.
Global constants used across the Juneau framework.
Constants used by the
RdfSerializer and RdfParser classes.Lightweight utility class for introspecting information about a Java constructor.
A functional interface representing an operation that accepts two arguments and returns no result.
A functional interface representing an operation that accepts three arguments and returns no result.
A functional interface representing an operation that accepts four arguments and returns no result.
A functional interface representing an operation that accepts five arguments and returns no result.
Contact information for the exposed API.
Contact information for the exposed API.
Swagger contact annotation.
Utility classes and methods for the
@Contact annotation.Builder class.
Represents the content of an Atom entry.
Polymorphic MCP content block (tool results, prompt messages).
Polymorphic MCP content block (tool results, prompt messages).
REST request body annotation.
Represents a parsed Content-Disposition HTTP request header.
Represents an HTTP Content-Disposition header.
Fluent builder for assembling an HTTP Content-Disposition header value.
Represents a parsed Content-Encoding HTTP response header.
Represents an HTTP Content-Encoding header.
Represents a parsed Content-Language HTTP response header.
Represents an HTTP Content-Language header.
Represents a parsed Content-Length HTTP request/response header.
Represents an HTTP Content-Length header.
Represents a parsed Content-Location HTTP response header.
Represents an HTTP Content-Location header.
Represents a parsed Content-Range HTTP response header.
Represents an HTTP Content-Range header.
Fluent builder for assembling an HTTP Content-Range header value.
Represents an HTTP Content-Security-Policy (or Content-Security-Policy-Report-Only ) response header.
Fluent builder for assembling a Content-Security-Policy header value.
Represents a parsed Content-Type HTTP request/response header.
Represents an HTTP Content-Type header.
Widget that returns back a list of hyperlinks for rendering the contents of a page in a variety of content types.
Base class for all Context beans.
Builder class.
Applied to Config annotations to identify the class used to push the values into a property store.
Utility class for instantiating a Context bean.
General runtime operation exception that can occur in any of the context classes.
A one-time-use non-thread-safe object that's meant to be used once and then thrown away.
Builder class.
Represents an HTTP 100 Continue response.
Represents an HTTP 100 Continue response.
Unmodifiable point-in-time snapshot of the enclosing
Continue response.Unmodifiable point-in-time snapshot of the enclosing
Continue response.Functional interface representing a single type conversion used by
CachingConverter.A pluggable strategy for discovering
Conversion functions between type pairs.Interface for converting objects between types.
Provides contextual objects to
Conversion functions at call time.Utility class for common type conversions and building typed collections and maps.
A simple list of
Cookie objects.The JSON Patch
"copy" operation per
RFC 6902 § 4.5.Utility methods for making copies and clones of collections, maps, arrays, and cloneable objects.
Which counts a
find / findValues call computes alongside its page of rows.What a caller asks
BeanQuery.Builder.counts(CountRequest) to write onto a BeanQuery's
opts (design §5).The two neutral row counts a session can report:
Counts.total() (the rows in scope before the query's search) and
Counts.matched() (the rows that survive the search, before any page limit).Represents an HTTP 201 Created response.
Represents an HTTP 201 Created response.
Unmodifiable point-in-time snapshot of the enclosing
Created response.Unmodifiable point-in-time snapshot of the enclosing
Created response.Parameters for "sampling/createMessage", a server-to-client duplex request (MCP sampling).
Result payload for "sampling/createMessage" (MCP sampling).
The cross-site request forgery boundary for an application reachable from the network: decides whether a
state-changing request came from this application's own page, or from a client that is not a browser, and refuses
it when it came from some other site's page.
Builder for
CsrfBoundary.The one header family whose forwarded origin the boundary trusts.
How an unsafe request with neither
Origin nor Sec-Fetch-Site is treated.Where the request's own origin, which
Origin must equal, comes from.Where a CSRF synchronizer token comes from, and how it is masked for embedding and checked on the way back.
The per-session strategy: the token is HMAC-SHA256(key, UTF-8(sessionId)) .
Annotation that can be applied to classes, fields, and methods to tweak how they are handled by
CsvSerializer and CsvParser.A pairing of a
CsvSerializer and CsvParser into a single class with convenience to/of methods.Utility classes and methods for the
@Csv annotation.Builder class.
Dynamically applies a
@Csv annotation to specified classes, methods, or fields.Utility classes and methods for the
@CsvApply annotation.Metadata on bean properties specific to the CSV serializers and parsers pulled from the
@Csv
annotation on the bean property.Format for serializing
byte[] arrays in CSV cells.Parses CSV cell inline notation:
{key:val;key2:val2} and [val1;val2;val3].Serializes nested objects and arrays to CSV cell inline notation:
{key:val;key2:val2} and [val1;val2;val3].Metadata on classes specific to the CSV serializers and parsers pulled from the
@Csv annotation on
the class.Annotation for specifying config properties defined in
CsvSerializer and CsvParser.Utility classes and methods for the
@CsvConfig annotation.Applies
CsvConfig annotations to a CsvParser.Builder.Applies
CsvConfig annotations to a CsvSerializer.Builder.Interface for providing access to
CsvClassMeta and CsvBeanPropertyMeta objects.Parses CSV (Comma Separated Values) input into Java objects.
Builder class.
Session object that lives for the duration of a single use of
CsvParser.Builder class.
Specialized reader for parsing CSV input.
Serializes POJO models to CSV (Comma Separated Values) format.
Builder class.
Session object that lives for the duration of a single use of
CsvSerializer.Builder class.
Specialized writer for serializing CSV.
Supported wire formats for
Currency values.The Custom cards page, which shows how an adopter writes a card type, and the feeds its cards read.
Dashboard: the dashboard-chrome demo page, built with
DevPageBuilders.dashboard(String, int) only.A dashboard: a rail of filter sections beside a grid of card panels, with a status header and optional persistence.
DTO for an HTML <data>
element.
DTO for an HTML <datalist>
element.
Data sources: a demo page built with
DevPageBuilders.data() only (it has no template twin).Declares a console data source: a browser loader that fetches rows from a same-origin URL, builds a columnar frame
and publishes it on the topic data:<id> , which chart cards read with
ChartDef.source(...).The aggregate request: a bucket unit, up to 3 groupBy dims, and the measures.
Where closed chunks are kept.
How the window is split into requests; UTC calendar units.
The built-in parser for each wire format.
How the frame is produced.
The built-in
datatables card type, registered through META-INF/services: validates the author
catalog and resolves per-column search metadata, with no shape lift — the catalog stays in author shape
(key/label, not VIEW_META's data/title); NS.card.liftCatalog
(juneau-views.js) does the lift at mount time.Generates a DataTables
columns
array from the bean properties of a row type, so the browser-side column list doesn't have to be hand-duplicated.Mixin that serves Juneau's first-party DataTables glue script at
/juneau-datatables.js.Maps a DataTables
request bean onto a BeanQuery, runs it against a
BeanQuerySession, and copies the result onto a DataTablesResults response bean.The DataTables server-side-processing request envelope — the JSON input bean paired with the
DataTablesResults JSON output bean.A DataTables column descriptor (
columns[i]).A DataTables 2.x fixed search term (
search.fixed[i]): a named search applied through the DataTables API
(search.fixed(name, term)) rather than typed by the user.A DataTables ordering descriptor (
order[i]): the index of the ordered column plus its direction.A DataTables search descriptor (
{value, regex, fixed}), used for both the global search and a column
search.The DataTables server-side-processing response envelope.
Builds a DataTables-ready HTML
Table DOM bean from a collection of rows — a server-rendered "plain
table" that the browser upgrades in place with $('#id').DataTable().BSON element type codes per the
BSON Specification 1.1.
Represents a parsed Date HTTP request/response header.
Represents an HTTP Date header.
Used for assertion calls against
Date objects.Supported wire formats for
Date values.Date/time functions for the
#{...} script catalog.#{now()} — current epoch milliseconds (UTC).#{parseDate(s)} / #{parseDate(s, format)} — parses an ISO-8601 string or
a DateTimeFormatter-pattern string to epoch milliseconds.A utility class for parsing and formatting HTTP dates as used in cookies and other headers.
DTO for an HTML <dd>
element.
Represents a parsed Debug HTTP request/response header.
Represents an HTTP Debug header.
Microservice debug utilities.
Neutralizes log-forging (log-injection) in client-controlled strings before they are written to a log line.
A chart decorator entry: one element of a chart card's
decorators[], run in the browser by the decorator
registered under its use name (JuneauCharts.decorator).Resolves method parameters on
RestOp-annotated Java methods by retrieving them by type from the REST object bean store.Predefined REST configuration that defines common default values for all configurations.
Predefined REST configuration that defines common default values for HTML Doc serializers.
Wraps a
TemporalAccessor to provide default values wherever possible instead of throwing unsupported field exceptions.Interface for the resolution of vars with a default value if the resolve() method returns null .
Maintain the list of default swaps used by all serializers and parsers.
DTO for an HTML <del>
element.
An object that represents another object, often wrapping that object.
Represents a wrapped
BeanMap where property values can be overridden, removed, or reordered without
affecting the underlying bean.Represents a wrapped
Collection where entries in the list can be removed or reordered without affecting the
underlying list.Represents a wrapped
Map where entries in the map can be removed without affecting the underlying map.Deny-all
RestGuard — rejects every request with 403 Forbidden.Declares a derived data source: transforms run in the browser on each new frame of another source, published on
data:<as> .
Identifies an arbitrary detail level such as the detail of log messages.
Builder twins of the Developer pages: Custom cards (
cards.ftlh), Rendering flavors (flavors.ftlh,
flavors-react.ftlh), Secure (secure.ftlh), Themes (themes.ftlh), Charts (builder only),
Data sources (builder only) and Dashboard (builder only).The petstore console's Developer section: custom cards, themes, rendering flavors and the secure API demo.
DTO for an HTML <dfn>
element.
REST resource that allows access to a file system directory.
File action link.
Used to aid in serialization, deserialization, and validation.
DTO for an HTML <div>
element.
DTO for an HTML <dl>
element.
Property source backed by a dotenv file.
Provider for
DotenvPropertySource.Dotenv file variable resolver.
A simple mutable double value.
DTO for an HTML <dt>
element.
Shared worker for the diagnostic dump endpoints (
/threaddump, /heapdump).Mixin flavor of the diagnostic dump endpoints (
/threaddump, /heapdump).Child-resource flavor of the diagnostic dump endpoints (
/threaddump, /heapdump).Deny-by-default exposure settings for the diagnostic dump endpoints (
/threaddump, /heapdump).Builder for
DumpsSettings.Supported wire formats for
Duration values.Represents an HTTP 103 Early Hints response.
Represents an HTTP 103 Early Hints response.
Unmodifiable point-in-time snapshot of the enclosing
EarlyHints response.Unmodifiable point-in-time snapshot of the enclosing
EarlyHints response.Mixin that serves a request-echo / round-trip introspection endpoint at
/echo/*
(configurable).Builder for
EchoMixin instances.Enumeration of possible modifiers and attributes that can be present on classes, methods, fields, and constructors.
Abstract base class for all reflection wrapper objects providing common modifier checking functionality.
Closed action set for an elicitation answer (MCP
2026-07-28 SEP-2322).Client elicitation capability (SEP-2322): presence on
ClientCapabilities.getElicitation() signals the
client understands input_required elicitation-flavored requests.Static helper for reading server→client MCP
2026-07-28 SEP-2322 elicitation requests out of
McpClient.callRaw(java.lang.String, org.apache.juneau.bean.mcp.v20260728.RequestParams<?>)'s raw Map<String,Object> result (MRTR, the Multi-Round-Trip Requests
loop, client side).Static helper that builds an
McpInputRequiredSignal from one or more typed ElicitRequests (MCP
2026-07-28 SEP-2322 elicitation, riding the Multi-Round-Trip Requests loop).Static helper for encoding the client's answers to server→client MCP
2026-07-28 SEP-2322
elicitation requests back into the raw inputResponses wire shape a resume call expects (MRTR,
the Multi-Round-Trip Requests loop, client side).Static helper that parses typed
ElicitResults out of an McpMrtrResumeContext (MCP
2026-07-28 SEP-2322 elicitation, riding the Multi-Round-Trip Requests loop).One entry of an
input_required pause's inputRequests map for an elicitation sub-request (MCP
2026-07-28 SEP-2322), built by a tools/call/prompts/get/resources/read handler
and placed via org.apache.juneau.rest.server.mcp.v20260728.ElicitationRequests.The end user's answer to an
ElicitRequest (MCP 2026-07-28 SEP-2322), echoed back keyed by the
same server-assigned id in a follow-up request's inputResponses and decoded via
org.apache.juneau.rest.server.mcp.v20260728.ElicitationResponses.Fluent builder for a restricted elicitation JSON Schema (MCP
2026-07-28 SEP-2322), producing the
JsonMap consumed by ElicitRequest.setRequestedSchema(java.util.Map).DTO for an HTML <em>
element.
DTO for an HTML <embed>
element.
MCP
resource content block (inline resource body).MCP
resource content block (inline resource body).Used for enabling decompression on requests and compression on responses, such as support for GZIP compression.
Represents a encoder and encoding that matches an HTTP Accept-Encoding header value.
Represents the set of
encoders keyed by codings.Builder class.
An identifier that the previous encoders in this group should be inherited.
An identifier that the previous encoders in this group should not be inherited.
A single encoding definition applied to a single schema property.
Encoding / escaping functions for the
#{...} script catalog.#{base64Decode(s)} — Base64-decodes s (UTF-8 result).#{base64Encode(s)} — Base64-encodes s (UTF-8).#{htmlEscape(s)} — escapes &, <, >, ", '
(the OWASP minimal HTML-injection-safe set).#{htmlUnescape(s)} — inverse of EncodingFunctions.HtmlEscape.#{urlDecode(s)} — URL-form-decodes.#{urlEncode(s)} — URL-form-encodes (i.e.Represents a validator value.
A list of
EntityTag beans.Represents an individual entry within an Atom feed or as a standalone Atom document.
A single entry in a
Config file.A fluent builder for adding or updating a single
Config entry.Supported wire formats for
Enum values.Environment-file variable resolver.
Environment variable variable resolver.
A read-only
SecretStore backed by System.getenv(String).Provider for
EnvVarSecretStore, discoverable through SecretStores.fromServiceLoader().A
@Configuration that supplies a Jetty Server bound to an OS-assigned ephemeral port
(port 0) for use by @MicroserviceTest-driven integration tests.Built-in default
KeyProvider: a random AES-256 key with a random keyId, both fixed for the
lifetime of the instance.Single-use, TTL-bounded store for the per-authorization
state → (codeVerifier, expectedIssuer)
association created when an interactive authorization-code + PKCE flow is started and consumed when the loopback
redirect arrives.A pending-authorization association awaiting the IdP loopback callback.
Mixin providing the residual
[* /error] endpoint.Represents a parsed ETag HTTP response header.
Represents an HTTP ETag header.
A declared calendar event category — a legend entry and the color family its events paint with.
The fixed category color families, each mapped to an existing
--jc-tag-* token family.information for Examples object.
Identifies examples for POJOs.
Utility classes and methods for the
@Example annotation.Builder class.
Dynamically applies an
@Example annotation to specified classes, methods, or fields.A collection of
@ExampleApply annotations.Utility classes and methods for the
@ExampleApply annotation.Applies targeted
ExampleApply annotations to a Context.Builder.Builder class.
A guided, end-to-end walkthrough of every
ExampleMcpServer surface using the v2
McpClient.A complete, runnable MCP 2026-07-28 server exposing every major surface of the protocol
over one tiny, coherent scenario: an in-memory
notes service.Boots
ExampleMcpServer on an embedded Jetty server.General exception that occurs when trying to execute a constructor, method, or field using reflection.
Abstract base class containing common functionality for
ConstructorInfo and MethodInfo.Implements the 'exit' console command to gracefully shut down the microservice and JVM.
Represents a parsed Expect HTTP request header.
Represents an HTTP Expect header.
Exception representing an HTTP 417 (Expectation Failed).
Represents an HTTP 417 Expectation Failed error response.
Unmodifiable point-in-time snapshot of the enclosing
ExpectationFailed exception.Unmodifiable point-in-time snapshot of the enclosing
ExpectationFailed exception.Represents a parsed Expires HTTP response header.
Represents an HTTP Expires header.
Defines extended language-specific metadata associated with a bean.
Defines extended language-specific metadata associated with a bean property.
Defines extended language-specific metadata associated with a class.
Superclass of all extended metadata classes.
Swagger external documentation annotation.
Utility classes and methods for the
@ExternalDocs annotation.Builder class.
Allows referencing an external resource for extended documentation.
Allows referencing an external resource for extended documentation.
The
<@facts> FreeMarker twin of the <@console facts=> attribute: a JSON5 object body, merged
last-wins with any other chrome-side facts.Exception representing an HTTP 424 (Failed Dependency).
Represents an HTTP 424 Failed Dependency error response.
Unmodifiable point-in-time snapshot of the enclosing
FailedDependency exception.Unmodifiable point-in-time snapshot of the enclosing
FailedDependency exception.The policy a network- or OS-backed
SecretStore applies when its backing store cannot answer — for
example when the OS keychain tool is missing or a remote vault is unreachable.Mixin that serves a
favicon.ico icon at /favicon.ico.Builder for
FaviconMixin instances.Flavor-neutral favicon worker bean shared by the favicon
@Rest flavors.Builder for
FaviconProvider instances.Child-resource flavor of the
FaviconMixin mixin.Standalone servlet companion of the
FaviconMixin mixin.Represents a top-level Atom feed document.
How a field-grid catalog entry (or a remaining declarative field) is painted.
Lightweight utility class for introspecting information about a Java field.
DTO for an HTML <fieldset>
element.
How many of a field-grid's columns one catalog entry occupies.
DTO for an HTML <figcaption>
element.
DTO for an HTML <figure>
element.
A repeatable entity that obtains its content from a
File.Unmodifiable point-in-time snapshot of the enclosing
FileEntity.Utility class for finding regular or localized files on the classpath and file system.
Builder class.
Represents no file finder
A sparse, bounded index from 1-based line numbers to byte offsets in one UTF-8 text file that may keep growing
while it is read.
Builder for
FileLineIndex.The result of a
FileLineIndex.refresh().A fluent builder for creating
Reader instances from files with configurable character encoding.A repeatable resource that obtains its content from a
File.An unmodifiable snapshot of a
FileResource.Filesystem-based storage location for configuration files.
Builder class.
A
TerminalSource that tails one growing log file of raw terminal bytes.Builder for
FileTerminalSource.A
TerminalViewSource over one growing JSON Lines file, one event per line, paged through a
FileLineIndex.Builder for
FileTerminalViewSource.File utilities.
File resource variable resolver
A fluent builder for creating
Writer instances for writing to files with configurable options.A resolved, engine-neutral search tree (design §7) — the
ResolvedQuery.filter() replacement for
the earlier flat Term/terms() list.An AND of two or more (or, at the top level, zero) sub-filters.
One resolved
column=expression leaf, with the column's SearchType carried alongside for the
engine.The negation of exactly one sub-filter.
An OR of two or more sub-filters.
Wrapper around a map where the key names are overridden.
A list wrapper that filters elements based on a
Predicate when they are added.Builder for creating
FilteredList instances.A map wrapper that filters entries based on a
BiPredicate when they are added.Builder for creating
FilteredMap instances.A set wrapper that filters elements based on a
Predicate when they are added.Builder for creating
FilteredSet instances.Interface that identifies an output stream has having a finish() method.
A wrapped finish() method.
PrintWriter with an added A wrapped finish() method.
ServletOutputStream with an added A simple mutable boolean flag.
The four petstore rendering flavors shown under Developer > Rendering flavors.
The pet rows every rendering flavor shows: the first 10 pets by id, with display-ready strings.
Rendering flavors: the same pet list rendered by each of the petstore's view technologies, inside the console.
A simple mutable float value.
Helpers shared across all flow types.
Used for assertion calls against generic POJOs.
Used for fluent assertion calls against array objects.
Parent class of all fluent assertion calls.
Used for fluent assertion calls against Java beans.
Used for fluent assertion calls against lists of beans.
Used for fluent assertion calls against booleans.
Used for fluent assertion calls against byte arrays.
Used for fluent assertion calls against collections objects.
Used for fluent assertion calls against comparable objects.
Used for fluent assertion calls against dates.
Used for fluent assertion calls against integers.
A fluent wrapper around an arbitrary list that provides convenient methods for adding elements.
Used for fluent assertion calls against lists.
Used for fluent assertion calls against longs.
A fluent wrapper around an arbitrary map that provides convenient methods for adding entries.
Used for fluent assertion calls against maps.
Used for fluent assertion calls against POJOs.
Used for fluent assertion calls against primitive array objects (e.g.
Used for fluent assertion calls against
HttpProtocolVersion objects.Used for fluent assertion calls against
RequestContent objects.Used for fluent assertion calls against
RequestFormParam objects.Used for fluent assertion calls against
RequestHeader objects.Used for fluent assertion calls against
HttpRequestLine objects.Used for fluent assertion calls against
RequestQueryParam objects.Used for fluent assertion calls against
ResponseContent objects.Used for fluent assertion calls against
ResponseHeader objects.Used for fluent assertion calls against a response
StatusLine object.A fluent wrapper around an arbitrary set that provides convenient methods for adding elements.
Used for fluent assertion calls against strings.
Used for fluent assertion calls against lists of strings.
Used for fluent assertion calls against throwables.
Used for fluent assertion calls against
Version objects.Used for fluent assertion calls against
ZonedDateTime objects.Builds
$fn markers: JSON values the chart glue replaces with a function from JuneauCharts.fn.DTO for an HTML <footer>
element.
Exception representing an HTTP 403 (Forbidden).
Represents an HTTP 403 Forbidden error response.
Unmodifiable point-in-time snapshot of the enclosing
Forbidden exception.Unmodifiable point-in-time snapshot of the enclosing
Forbidden exception.DTO for an HTML <form>
element.
Static strings used for Swagger parameter format types.
REST request form-data annotation.
The declarative source of a row-action modal's input form (the form half of a
present=dialog action).A single typed form input painted client-side with
createElement (never innerHTML).A single
select option: a submit value and its visible label.One labelled group of inputs inside a sectioned form: the multi-page dialog shape.
Represents a parsed Forwarded HTTP request header.
Represents an HTTP Forwarded header.
Fluent builder for assembling an HTTP Forwarded header value.
Represents an HTTP 302 Found response.
Represents an HTTP 302 Found response.
Unmodifiable point-in-time snapshot of the enclosing
Found response.Unmodifiable point-in-time snapshot of the enclosing
Found response.A transport's outbound side, handed to
ServerBus.connect(BusSession, FrameSink) for one connection.Flavor-neutral worker bean carrying the FreeMarker raw-template-dispatch logic shared by the
FreemarkerMixin mixin, the FreemarkerServlet servlet, and the
FreemarkerResource child flavors.Builder for
FreemarkerDispatcher.The Freemarker rendering flavor: the pet list rendered from
fragments/pets.ftlh.Mixin that wires Apache FreeMarker view-rendering onto any Juneau REST resource.
Builder for
FreemarkerMixin.Request-scoped handle so FreeMarker
TemplateDirectiveModels can resolve per-request
asset URLs during template.process.Child-resource flavor of the
FreemarkerMixin mixin.Standalone servlet companion of the
FreemarkerMixin mixin.Immutable value class returned from
@RestOp-annotated methods to ask the framework to
render an Apache FreeMarker template.Marker for an attribute value that promises to be adopted during the render (unwrapped from the data model by
some directive and applied to render-scoped state), and wants the render to fail if that never happens
instead of silently behaving as if the attribute was absent.
ResponseProcessor that detects FreemarkerView-typed return values and asks the
configured Configuration to render them directly onto the response writer.Represents a parsed From HTTP request header.
Represents an HTTP From header.
A functional interface representing a function that accepts two arguments and produces a result.
A functional interface representing a function that accepts three arguments and produces a result.
A functional interface representing a function that accepts four arguments and produces a result.
A functional interface representing a function that accepts five arguments and produces a result.
A functional interface for creating read-only
PropertySource instances from a function.A writable
PropertyStore implementation created from functional interfaces.A subclass of
ObjectSwap that allows swap and unswap methods to be defined as functions.Represents an HTTP 504 Gateway Timeout error response.
Unmodifiable point-in-time snapshot of the enclosing
GatewayTimeout exception.Identifies the software agent used to generate an Atom feed.
Command that fetches configuration from a Git repository for a given project and branch.
Parameters for "prompts/get".
Parameters for "prompts/get".
Result payload for "prompts/get".
Result payload for "prompts/get".
Callback interface for retrieving a value after asynchronous execution.
Git repository control operations for cloning, pulling, pushing, and committing.
Exception representing an HTTP 410 ().
Represents an HTTP 410 Gone error response.
Unmodifiable point-in-time snapshot of the enclosing
Gone exception.Unmodifiable point-in-time snapshot of the enclosing
Gone exception.A ZonedDateTime with precision information for granular time operations.
An ordinary Spring-managed service, injected into an MCP tool handler by
SpringExampleMcpServer
to prove that Spring dependency injection flows into MCP handlers when the server extends
SpringMcpRestServlet.The groom-pet demo runs behind the Jobs page's terminal cards.
One groom run.
Encoder for handling "gzip" encoding and decoding.
DTO for an HTML <h1>
element.
DTO for an HTML <h2>
element.
DTO for an HTML <h3>
element.
DTO for an HTML <h4>
element.
DTO for an HTML <h5>
element.
DTO for an HTML <h6>
element.
Represents a HAL Link Object as defined by
draft-kelly-json-hal-08 § 5.
Represents a list of
HalLink objects.Per-property
ObjectSwap applied to HAL _links maps so that each map entry round-trips
as either a single HalLink (JSON object) or a HalLinkArray (JSON array) per the spec.Represents a HAL Resource Object as defined by
draft-kelly-json-hal-08 § 4.
Represents a list of
HalResource objects.Per-property
ObjectSwap applied to HAL _embedded maps so that each map entry round-trips
as either a single HalResource (JSON object) or a HalResourceArray (JSON array) per the
spec.The
Host values of a WebSocket handshake; over RFC 8441 with no Host, one value from the request
URI's authority.REST has-form-data annotation.
Resolves method parameters annotated with
HasFormData on RestOp-annotated Java methods.Utility class for generating integer hash codes.
Represents a composite key composed of multiple values, suitable for use as a key in hash-based collections.
REST has-query-parameter annotation.
The
jcHasToolkit(name) FreeMarker method: whether the current <@page toolkit=…> lists
name.DTO for an HTML <head>
element.
DTO for an HTML <header>
element.
REST request header annotation.
Identifies a class that can be converted to a
Header object.Holds metadata about header beans (POJOs that get serialized as HTTP headers).
Represents a parsed element from an HTTP header value.
Describes a single HTTP header.
Describes a single HTTP header.
A simple list of HTTP headers with various convenience methods.
An unmodifiable snapshot of a
HeaderList.Represents no header list in annotations.
Lightweight parser for HTTP header values as defined by RFC 2616.
Component health result returned from a
HealthIndicator.Builder for
Health.Shared health-probe aggregation worker bean.
Component payload in the response.
Probe response payload.
Functional SPI for reporting health of one component.
Mixin flavor of the built-in health/readiness/liveness probe capability.
Probe categories supported by the built-in health probe resource.
Opt-in probe configuration that auto-mounts
HealthServlet.Opt-in probe configuration that auto-mounts
HealthServlet.Settings for the built-in health probe resource.
Builder for
HealthProbeSettings.Child-resource flavor of the built-in health/readiness/liveness probe capability.
Servlet flavor of the built-in health/readiness/liveness probe capability.
Status values returned by
HealthIndicator checks.Sample Spring bean injected into
HelloResource to demonstrate the @Autowired pattern under
Juneau SpringRestServlet-based deployments.Tiny REST resource that demonstrates Spring
@Autowired injection into a Juneau @Rest servlet
under a Spring Boot deployment.Implements the 'help' console command to provide help on other commands.
Annotation for customizing Hjson serialization and parsing behavior on classes, methods, and fields.
A pairing of a
HjsonSerializer and HjsonParser into a single class with convenience to/of methods.Utility classes and methods for the
@Hjson annotation.Dynamically applies a
@Hjson annotation to specified classes, methods, or fields.A collection of
@HjsonApply annotations.Utility classes and methods for the
@HjsonApply annotation.Applies targeted
HjsonApply annotations to a Context.Builder.Builder class.
Metadata on bean properties specific to Hjson serializers and parsers.
A
Hjson variant that produces compact (single-line) Hjson output.Metadata on classes specific to Hjson serializers and parsers.
Annotation for specifying config properties defined in
HjsonSerializer and HjsonParser.Utility classes and methods for the
@HjsonConfig annotation.Applies
HjsonConfig annotations to an HjsonParser.Builder.Applies
HjsonConfig annotations to an HjsonSerializer.Builder.Interface for providing access to
HjsonClassMeta and HjsonBeanPropertyMeta objects.Parses Hjson (Human JSON) text into POJO models.
Builder class.
Session for parsing Hjson format into POJOs.
Builder for Hjson parser session.
Serializes POJO models to Hjson (Human JSON).
Builder class.
Session for serializing objects to Hjson format.
Builder for Hjson serializer session.
Tokenizer for Hjson format.
A token with optional string or number value.
Token types produced by the tokenizer.
Specialized writer for serializing Hjson format.
Annotation for customizing HOCON serialization and parsing behavior on classes, methods, and fields.
A pairing of a
HoconSerializer and HoconParser into a single class with convenience to/of methods.Utility classes and methods for the
@Hocon annotation.Dynamically applies a
@Hocon annotation to specified classes, methods, or fields.A collection of
@HoconApply annotations.Utility classes and methods for the
@HoconApply annotation.Applies targeted
HoconApply annotations to a Context.Builder.Builder class.
Metadata on bean properties specific to HOCON serializers and parsers.
A
Hocon variant that produces readable HOCON output with the root braces retained
(the Hocon.DEFAULT form omits them).A
Hocon variant that produces compact (single-line) HOCON output.Metadata on classes specific to HOCON serializers and parsers.
Annotation for specifying config properties defined in
HoconSerializer and HoconParser.Utility classes and methods for the
@HoconConfig annotation.Applies
HoconConfig annotations to an HoconParser.Builder.Applies
HoconConfig annotations to an HoconSerializer.Builder.Interface for providing access to
HoconClassMeta and HoconBeanPropertyMeta objects.Parses HOCON (Human-Optimized Config Object Notation) text into POJO models.
Builder class.
Session for parsing HOCON format into POJOs.
Builder for HOCON parser session.
Resolves ${var} and ${?
Serializes POJO models to HOCON (Human-Optimized Config Object Notation).
Builder class.
Session for serializing objects to HOCON format.
Builder for HOCON serializer session.
Tokenizer for HOCON (Human-Optimized Config Object Notation) format.
A token with optional string or number value.
Token types produced by the tokenizer.
Intermediate representation for parsed HOCON data before conversion to Java beans.
HOCON array (maps to List or array).
HOCON boolean value.
HOCON value concatenation (adjacent values concatenated).
HOCON null value.
HOCON number value.
HOCON object (maps to Java bean or Map).
HOCON string value.
HOCON substitution reference (${var} or ${?
Value type.
Specialized writer for serializing HOCON format.
A generic mutable value wrapper.
Represents a parsed Host HTTP request header.
Represents an HTTP Host header.
DTO for an HTML <hr>
element.
Mixin providing the residual
[GET /htdocs/*] static-file endpoint.DTO for an HTML <html>
element.
Annotation that can be applied to classes, fields, and methods to tweak how they are handled by
HtmlSerializer.A pairing of a
HtmlSerializer and HtmlParser into a single class with convenience to/of methods.Utility classes and methods for the
@Html annotation.Builder class.
Dynamically applies a
@Html annotation to specified classes, methods, or fields.A collection of
@HtmlApply annotations.Utility classes and methods for the
@HtmlApply annotation.Applies targeted
HtmlApply annotations to a Context.Builder.Builder class.
Defines the Java classes that make up the HTML DTO type dictionary.
Metadata on bean properties specific to the HTML serializers and parsers pulled from the
@Html
annotation on the bean property.Various useful static methods for creating HTML elements.
The built-in
html card type: markup-only (JSON5 bodies are E-25), with an optional body auto-captured
as a <template data-card="{id}">.Metadata on classes specific to the HTML serializers and parsers pulled from the
@Html annotation on
the class.Sample class which shows the complex usage of HtmlSerializer and HtmlParser.
Annotation for specifying config properties defined in
HtmlSerializer, HtmlParser, and HtmlDocSerializer.Utility classes and methods for the
@HtmlConfig annotation.Applies
HtmlConfig annotations to a HtmlParser.Builder.Applies
HtmlConfig annotations to a HtmlSerializer.Builder.Annotation for specifying config properties defined in
HtmlSerializer, HtmlParser, and HtmlDocSerializer.Utility classes and methods for the
@HtmlDocConfig annotation.Applies
HtmlDocConfig annotations to a HtmlDocSerializer.Builder.Serializes POJOs to HTTP responses as HTML documents.
Builder class.
Concrete default builder leaf for the non-subclassed
HtmlDocSerializer.create() / HtmlDocSerializer.copy() path.Context object that lives for the duration of a single serialization of
HtmlSerializer and its subclasses.Builder class.
Concrete default builder leaf for the non-subclassed
create() path (CRTP terminal).Defines the interface for rendering the contents of an HTML page produced by the
HtmlDocSerializer
serializer.Represents a non-existent doc template.
Superclass for all HTML elements.
A subclass of HTML elements that contain only other elements, not text.
A subclass of HTML elements that contain mixed content (elements and text).
A subclass of HTML elements that contain raw text
only.
A subclass of HTML elements that contain text only.
A subclass of HTML elements that have no content or end tags.
The Html rendering flavor: the pet list built with the HTML5 bean builder.
Identifies possible values for the
Html.format() annotation.Used in conjunction with the
HtmlSerializer class to define hyperlinks.Utility classes and methods for the
@HtmlLink annotation.Builder class.
Dynamically applies a
@HtmlLink annotation to specified classes.A collection of
@HtmlLinkApply annotations.Utility classes and methods for the
@HtmlLinkApply annotation.Applies targeted
HtmlLinkApply annotations to a Context.Builder.Builder class.
Interface for providing access to
HtmlClassMeta and HtmlBeanPropertyMeta objects.Parses text generated by the
HtmlSerializer class back into a POJO model.Builder class.
ContextSession object that lives for the duration of a single use of
HtmlParser.Builder class.
Allows custom rendering of bean property values when serialized as HTML.
Serializes POJO metamodels to HTML.
Builder class.
Context object that lives for the duration of a single serialization of
HtmlSchemaDocSerializer and its subclasses.Builder class.
Serializes POJO metamodels to HTML.
Builder class.
Default serializer, with whitespace.
Default serializer, single quotes, simple mode.
Default serializer, single quotes, simple mode, with whitespace.
Context object that lives for the duration of a single serialization of
HtmlSchemaSerializer and its subclasses.Builder class.
Serializes POJO models to HTML.
Builder class.
Concrete default builder leaf for the non-subclassed
HtmlSerializer.create() / HtmlSerializer.copy() path.Default serializer, single quotes.
Default serializer, single quotes, whitespace added.
Session object that lives for the duration of a single use of
HtmlSerializer.Builder class.
Concrete default builder leaf for the non-subclassed
create() path (CRTP terminal).Sample class which shows the simple usage of HtmlSerializer and HtmlParser.
An
Html variant that produces output with single-quoted attributes and JSON type
hint tags disabled (a "simple" flavor of the single-quote variant).An
Html variant that produces output with attributes quoted using single quotes
instead of double quotes.An
Html variant that produces readable (indented, multi-line) output with attributes
quoted using single quotes.Serializes POJOs to HTTP responses as stripped HTML.
Builder class.
Concrete default builder leaf for the non-subclassed
HtmlStrippedDocSerializer.create() / HtmlStrippedDocSerializer.copy() path.Session object that lives for the duration of a single use of
HtmlStrippedDocSerializer.HtmlStrippedDocSerializerSession.Builder<SELF extends HtmlStrippedDocSerializerSession.Builder<SELF>>
Builder class.
Concrete default builder leaf for the non-subclassed
create() path (CRTP terminal).An object that gets serialized as raw XML by the XML and HTML serializers.
Defines an interface for resolvers of "$W{...}"
A collection of
HtmlWidget objects keyed by their names.HTML widget variable resolver.
Specialized writer for serializing HTML.
Static factory methods for creating common HTTP body types.
An HTTP message body (entity), providing content and its associated metadata.
A mutable wrapper around an
HttpBody that allows overriding the content type.Response handler for
HttpBody objects (transport-neutral replacement for the historical
Apache HttpClient 4.5 HttpEntity-keyed processor).Base for boolean headers.
An
HttpPart whose value is a boolean.An
HttpPart whose value is a comma-delimited list of strings.Base for simple comma-separated token lists.
Base for HTTP-date headers.
An
HttpPart whose value is an ISO-8601 date-time.Standard predefined HTTP entities.
Base for single entity-tag headers.
Base for multiple entity-tags headers.
An HTTP header field: a name/value pair that appears in request or response messages.
Root concrete implementation of
HttpHeader.A mutable, ordered list of
HttpHeader instances.An unmodifiable snapshot of a
HttpHeaderList.Represents no header list in annotations.
Standard predefined HTTP headers.
Static factory methods for creating common HTTP headers.
Base for integer headers.
An
HttpPart whose value is an integer.Base for long headers.
An
HttpPart whose value is a long integer.Base type for headers whose wire format is an Accept -style list of media ranges.
Base type for headers whose value is a single
MediaType (e.g.Represents valid HTTP 1.1 method name static strings per the RFC 2616 spec.
A name/value pair representing a single query parameter, form field, or path variable.
Represents an instance of an HTTP part.
Root concrete implementation of
HttpPart.Valid values for the collectionFormat field.
Valid values for the type field.
Valid values for the format field.
A mutable, ordered list of
HttpPart instances.An unmodifiable snapshot of a
HttpPartList.Represents no part list in annotations.
Specifies the
HttpPartSerializer and HttpPartParser to use for serializing/parsing HTTP parts.Interface used to convert HTTP headers, query parameters, form-data parameters, and URI path variables to POJOs
A creator for a part parser.
Represent "no" part parser.
Session object that lives for the duration of a single use of
HttpPartParser.Standard predefined HTTP parts.
Static factory methods for creating HTTP parts (query parameters, form fields, path variables).
Represents an OpenAPI schema definition.
Builder class.
Interface used to convert POJOs to simple strings in HTTP headers, query parameters, form-data parameters, and URI
path variables.
A creator for a part serializer.
Represent "no" part part serializer.
Session object that lives for the duration of a single use of
HttpPartSerializer.Represents possible enum values for HTTP part types.
The HTTP protocol version that appears in request and response start lines (e.g.
The first line of an HTTP request message, containing the method, request URI, and protocol version.
Default immutable implementation of
HttpRequestLine.An extension of an
HttpEntity that also includes arbitrary headers.An
HttpBody that carries additional headers (such as Content-Type,
Content-Disposition, or Content-Language) alongside the body.Default immutable implementation of
HttpResource: an HttpBody bundled with a set of
associated headers (such as Content-Type, Content-Disposition, or Content-Language).Response handler for
HttpResource objects.Standard predefined HTTP resources.
A complete HTTP response message: status line, headers, and optional body.
Response handler for
HttpResponseMessage objects (transport-neutral replacement for HttpResponse).Standard predefined HTTP responses.
Static factory methods for creating pre-defined HTTP response and exception objects.
Resolves method parameters on
RestOp-annotated Java methods of types found on the HttpServletRequest object.Resolves method parameters on
RestOp-annotated Java methods of types found on the HttpServletResponse object.Resolves method parameters on
RestOp-annotated Java methods of types found on the HttpSession object.The first line of an HTTP response message, containing the protocol version, status code, and reason phrase.
Default immutable implementation of
HttpStatusLine.Base type for HTTP headers whose value is an opaque string (or lazy
Supplier of string).An
HttpPart whose value is a string.Base for comma-separated tokens with optional q-values.
SPI for pluggable HTTP transports.
A builder interface for configuring and creating
HttpTransport instances.ServiceLoader SPI for auto-discovering HttpTransport implementations on the classpath.Base for single-URI headers.
An
HttpPart whose value is a URI.HTTP utilities.
Exception representing an HTTP 505 ().
Represents an HTTP 505 HTTP Version Not Supported error response.
Unmodifiable point-in-time snapshot of the enclosing
HttpVersionNotSupported exception.Unmodifiable point-in-time snapshot of the enclosing
HttpVersionNotSupported exception.Defines a simple hyperlink class.
DTO for an HTML <i>
element.
Represents a small icon image for visual identification of a feed.
MCP icon descriptor (the schema's
Icons.icons entry shape), used by Implementation.Icon color-scheme hint, restricted to the schema's two legal values (MCP wire uses lowercase strings).
Represents a permanent, universally unique identifier for a feed or entry.
A server-minted idempotency key for a row-action submit, bound at mint time to the
(action, targetId) pair
it was issued for.Encoder for handling "identity" encoding and decoding.
Wraps Nimbus's
IDTokenValidator to validate an OpenID Connect ID token's signature and claims
and project the verified claims onto a Juneau ClaimsPrincipal.Builder.
Represents a parsed If-Match HTTP request header.
Represents a parsed If-Modified-Since HTTP request header.
Represents an HTTP If-Modified-Since header.
Represents a parsed If-None-Match HTTP request header.
DTO for an HTML <iframe>
element.
Represents a parsed If-Range HTTP request header.
Represents an HTTP If-Range header.
Represents a parsed If-Unmodified-Since HTTP request header.
Represents an HTTP If-Unmodified-Since header.
MCP
image content block (base64 data).MCP
image content block (base64 data).Example parser that converts byte streams to
BufferedImage objects.Example serializer that converts
BufferedImage objects to byte streams.DTO for an HTML <img>
element.
MCP
Implementation object (name / version).MCP
Implementation object (BaseMetadata + Icons per the schema): required
name / version, plus optional title, description, and ordered icons.Represents an HTTP 226 IM Used response.
Represents an HTTP 226 IM Used response.
Unmodifiable point-in-time snapshot of the enclosing
IMUsed response.Unmodifiable point-in-time snapshot of the enclosing
IMUsed response.Provides metadata about the API.
Provides metadata about the API.
Shared worker for the
/info management endpoint: renders the running application's
ManifestFile main attributes (build/version/git metadata) as a map.Mixin flavor of the
/info endpoint: renders the running application's manifest
(build/version/git metadata) resolved from the host bean store.Child-resource flavor of the
/info endpoint.Dummy class that indicates that serializers, parsers, or transforms should be inherited from parent-class-to-class or class-to-method.
Annotation for customizing INI serialization and parsing behavior on classes, methods, and fields.
A pairing of an
IniSerializer and IniParser into a single class with convenience to/of methods.Utility classes and methods for the
@Ini annotation.Dynamically applies a
@Ini annotation to specified classes, methods, or fields.A collection of
@IniApply annotations.Utility classes and methods for the
@IniApply annotation.Applies targeted
IniApply annotations to a Context.Builder.Builder class.
Metadata on bean properties specific to INI serializers and parsers, from
@Ini.Metadata on classes specific to INI serializers and parsers, from
@Ini.Annotation for specifying config properties defined in
IniSerializer and IniParser.Utility classes and methods for the
@IniConfig annotation.Applies
IniConfig annotations to an IniParser.Builder.Applies
IniConfig annotations to an IniSerializer.Builder.INI config format.
Interface for providing access to
IniClassMeta and IniBeanPropertyMeta objects.Parses INI-formatted text into POJO models.
Builder for
IniParser.Session for parsing INI format into POJOs.
Builder for INI parser session.
An
Ini variant that produces readable (spaced) INI output.Serializes POJO models to INI format.
Builder class.
Session for serializing objects to INI format.
Builder for INI serializer session.
MCP
initialize request parameters.MCP
initialize result payload.Specialized writer for serializing INI format.
Marks constructors, methods, fields, or parameters as injection points.
Guards shipped resources against a literal closing script tag (
</script, matched case-insensitively).The in-memory
BeanQueryContext: runs BeanQuerys against an in-JVM collection of beans or maps.Builder for
InMemoryBeanQueryContext.A
BeanQuerySession over one in-memory collection.Builder for
InMemoryBeanQuerySession.The shipped, single-node default
LoginStateStore: a single-use, TTL-bounded, size-bounded
in-memory store for the per-login state → LoginStateStore.PendingLogin association
created during OidcRelyingParty.startLogin(jakarta.servlet.http.HttpServletRequest, jakarta.servlet.http.HttpServletResponse) and consumed during OidcRelyingParty.completeLogin(jakarta.servlet.http.HttpServletRequest, jakarta.servlet.http.HttpServletResponse).Thread-safe, process-scoped default
McpClientRegistrationStore keying registrations by
issuer.toString() (SEP-2352 "separate registration state per authorization server").Built-in, process-local, in-memory default implementation of
McpResponseCache.Built-in default
ReplayCache: a per-process, ConcurrentHashMap-backed seen-identifier set with
self-eviction bounded by each record's own expiresAtMs.Built-in default
SecretStore: a per-process, ConcurrentHashMap-backed key-to-secret map.In-memory
SessionStore backed by a bounded-LRU map, indexed by sub and sid so
it can satisfy back-channel logout.DTO for an HTML <input>
element.
Result of a
tools/call, prompts/get, or resources/read handler pausing to request more
input (MCP 2026-07-28 SEP-2322 Multi-Round-Trip Requests).Subclass of
Parser for byte-based parsers.Builder class.
Concrete default builder leaf for the non-subclassed
InputStreamParser.create() / Parser.copy() path.Resolves method parameters of type
InputStreamParser on RestOp-annotated Java methods.Subclass of parser session objects for byte-based parsers.
Builder class.
Concrete default builder leaf for the non-subclassed
create() path (CRTP terminal).Response processor for
InputStream objects.Transforms
InputStreams to Strings.Converts
InputStreams to BASE-64 encoding.Converts
InputStreams to hex encoding.Converts
InputStreams to spaced-hex encoding.DTO for an HTML <ins>
element.
Exception representing an HTTP 507 ().
Represents an HTTP 507 Insufficient Storage error response.
Unmodifiable point-in-time snapshot of the enclosing
InsufficientStorage exception.Unmodifiable point-in-time snapshot of the enclosing
InsufficientStorage exception.Used for assertion calls against integers.
A simple mutable integer value.
Exception representing an HTTP 500 (Internal Server Error).
Represents an HTTP 500 Internal Server Error error response.
Unmodifiable point-in-time snapshot of the enclosing
InternalServerError exception.Unmodifiable point-in-time snapshot of the enclosing
InternalServerError exception.Converter for enablement of @RestOp -annotated method.
ObjectIntrospector support on response objects returned by a
Deny-by-default allow-list settings for the
Introspectable converter.Builder for
IntrospectableSettings.Defines an invalid usage of an annotation.
Thrown by
Converter.to(Object, Class) when no conversion path exists between two types.General invalid conversion exception.
The server half of the Custom cards page's validated card type: an inventory gauge for one species.
Various I/O related utility methods.
Centralized ISO 8601 formatting and parsing utility for date/time and Duration types.
A limited subset of JSON-Schema's items object.
A limited subset of JSON-Schema's items object.
Swagger items annotation.
Utility classes and methods for the
@Items annotation.Builder class.
HttpTransport implementation backed by the JDK's built-in HttpClient.Fluent builder for
JavaHttpTransport.HttpTransportProvider implementation that supplies a JavaHttpTransport.A pairing of a
JcsSerializer and JsonParser into a single class with
convenience to/of methods.Annotation for specifying config properties for
JcsSerializer.Utility classes and methods for the
@JcsConfig annotation.Applies
JcsConfig annotations to a JcsSerializer.Builder.Serializes POJO models to canonical JSON per RFC 8785 (JCS).
Builder class.
Session object for
JcsSerializer that produces RFC 8785 canonical JSON.Builder class.
JSON writer for JCS (RFC 8785) canonical output.
Reads Jest's --json output.
Microservice bootstrap.HttpTransport implementation backed by Jetty 12 HttpClient.Fluent builder for
JettyHttpTransport.HttpTransportProvider implementation that supplies a JettyHttpTransport.Zero-config convenience launcher for a Jetty-backed Juneau microservice.
Drives the Jetty server lifecycle on behalf of the microservice via the
MicroserviceListener fan-out.Interface for creating Jetty servers.
Programmatic settings for the Jetty server contributed by
JettyConfiguration.Builder for
JettySettings.The stock "record the minted key" store for row-bound job keys: issues an
IdempotencyKey bound to
(action, targetId[, principal]), and verifies a submitted key value against that recorded binding.A successful verify.
The built-in
job-log card type: a form that submits to an endpoint returning an AsyncJobRef, then
streams the job's progress from AsyncJobsMixin into a log pane, with cancel and reload re-attach.The shared shape checks of a job-log declaration, used by the console's page-level
job-log card and by a
JobLogRegion, so the two cannot drift.Where a job-log declaration lives.
The author-facing declaration of a job-log row-detail region, compiled to a
RegionDef.The optional field grid painted above the form, whose slots
output.target.field can address.One
submit.fields entry.Where a terminal result is written.
The
submit declaration.Jobs: the console's async-job reference.
A per-host groom step period.
A per-host override of the jobs hard timeout.
A per-host clock for the row-key ledger, so a test can age a key past its TTL.
The restock request.
A per-host species-row hold: how long a species row's restock holds after its effect.
Annotation for specifying various JSON options for the JSON serializers and parsers.
A pairing of a
JsonSerializer and JsonParser into a single class with convenience read/write methods.A pairing of a
Json5Serializer and Json5Parser into a single class with convenience read/write methods.Pairs
Json5lSerializer and Json5lParser into a single class with convenience
to/of methods.Annotation for specifying config properties for REST classes and methods using JSON5L.
Utility classes and methods for the
@Json5lConfig annotation.Applies
Json5lConfig annotations to a JsonParser.Builder.Applies
Json5lConfig annotations to a JsonSerializer.Builder.JSON5-flavored
MarshalledList.Parses JSON5L (JSON5 Lines) input into POJO models.
Builder class.
Session object that lives for the duration of a single use of
Json5lParser.Builder class.
Serializes POJO models to JSON5L (JSON5 Lines).
Builder class.
Session object that lives for the duration of a single use of
Json5lSerializer.Builder class.
Reference implementation of the public
TokenReader surface for the JSON5L format.JSON5-flavored
MarshalledMap.Parses any valid JSON text into a POJO model.
Builder class.
Session object that lives for the duration of a single use of
Json5Parser.Builder class.
A
Json5 variant that produces readable (indented, multi-line) JSON5 output.Serializes POJO models to Simplified JSON.
Builder class.
Default serializer, single quotes, simple mode, with whitespace.
Session object that lives for the duration of a single use of
Json5Serializer.Builder class.
Reference implementation of the public
TokenReader surface for the JSON5 format.Utility classes and methods for the
@Json annotation.Builder class.
Represents the top-level JSON:API document as defined by
JSON:API v1.1 § Document Structure.
Represents a JSON:API Error Object as defined by
JSON:API v1.1 § Error Objects.
Represents the
source sub-object of a JSON:API Error Object.Represents a JSON:API Link Object as defined by
JSON:API v1.1 § Links.
Per-property
ObjectSwap applied to JSON:API links maps so that each map entry round-trips
as either a JSON string URL or a JsonApiLink JSON object per the spec.Represents a JSON:API Relationship Object as defined by
JSON:API v1.1 § Relationships.
Represents a JSON:API Resource Object as defined by
JSON:API v1.1 § Resource Objects.
Represents a JSON:API Resource Identifier Object as defined by
JSON:API v1.1 § Resource Identifier Objects.
Represents the JSON:API top-level
jsonapi member.Dynamically applies a
@Json annotation to specified classes, methods, or fields.A collection of
@JsonApply annotations.Utility classes and methods for the
@JsonApply annotation.Applies targeted
JsonApply annotations to a Context.Builder.Builder class.
Metadata on bean properties specific to the JSON serializers and parsers pulled from the
@Json
annotation on the bean property.Metadata on classes specific to the JSON serializers and parsers pulled from the
@Json annotation on
the class.Sample class which shows the complex usage of JsonSerializer and JsonParser.
Annotation for specifying config properties defined in
JsonSerializer and JsonParser.Utility classes and methods for the
@JsonConfig annotation.Applies
JsonConfig annotations to a JsonParser.Builder.Applies
JsonConfig annotations to a JsonSerializer.Builder.Json configuration example.
JSON-navigation functions for the
#{...} script catalog.#{get(json, key)} — extracts json[key] (object) or json[index]
(array, when key parses as int).#{jsonPath(json, path)} / #{jsonPath(json, path, default)} — extracts a
value via a slash-rooted path (e.g.#{keys(json)} — returns a JSON-array-shortcut string of an object's keys.#{size(json)} — returns the count: object key count, array length, string
length, or 0 for null/primitives.#{values(json)} — returns a JSON-array-shortcut string of an object's values (or array elements).Pairs
JsonlSerializer and JsonlParser into a single class with convenience
to/of methods.Annotation for specifying config properties for REST classes and methods using JSONL.
Utility classes and methods for the
@JsonlConfig annotation.Applies
JsonlConfig annotations to a JsonParser.Builder.Applies
JsonlConfig annotations to a JsonSerializer.Builder.A pairing of a
JsonLdSerializer and JsonLdParser into a single class with convenience to/of methods.Subclass of
RdfParser for parsing JSON-LD into POJOs.Subclass of
RdfSerializer for serializing POJOs to JSON-LD format.Java implementation of a JSON array.
Parses JSONL (JSON Lines) input into POJO models.
Session object that lives for the duration of a single use of
JsonlParser.Builder class.
Serializes POJO models to JSONL (JSON Lines).
Session object that lives for the duration of a single use of
JsonlSerializer.Builder class.
Reference implementation of the public
TokenReader surface for the JSONL / NDJSON
format.Reference implementation of the public
TokenWriter surface for the JSONL / NDJSON
format.Java implementation of a JSON object.
Interface for providing access to
JsonClassMeta and JsonBeanPropertyMeta objects.Parses any valid RFC 8259 JSON text into a POJO model.
Builder class.
Session object that lives for the duration of a single use of
JsonParser.Builder class.
Concrete default builder leaf for the non-subclassed
create() path (CRTP terminal).Represents a JSON Patch document per
RFC 6902.
A pairing of a
JsonSerializer and JsonParser into a single class with convenience to/of methods,
pre-wired for JSON Patch's JsonPatchOperation discriminator.Abstract base for a JSON Patch operation per
RFC 6902.
An RFC 6901 JSON Pointer that addresses a
single value within a
Map/List tree (such as the MarshalledMap/MarshalledList family).A
Json variant that produces readable (indented, multi-line) JSON output.JSON-RPC 2.0 error object.
JSON-RPC 2.0 request envelope.
JSON-RPC 2.0 success or error response envelope.
Represents a top-level schema object bean in the JSON-Schema core specification.
JSON Schema subset used by MCP tool
inputSchema objects.Used during parsing to convert the additionalItems property to the correct class type.
Used during parsing to convert the additionalProperties property to the correct class type.
Used during parsing to convert the items property to the correct class type.
Used during parsing to convert the type property to the correct class type.
Represents a list of
JsonSchema objects.Bridge for generating typed
JsonSchema beans from Java types.Builder for
JsonSchemaBeanGenerator.Metadata on bean properties specific to the JSON-Schema pulled from the
@Schema annotation
on the bean property.Metadata on classes specific to the JSON-Schema serializer and pulled from the
@Schema annotation on
the class.Annotation for specifying config properties defined in
JsonSchemaGenerator.Utility classes and methods for the
@JsonSchemaConfig annotation.Applies
JsonSchemaConfig annotations to a JsonSchemaGenerator.Builder.Generates JSON-schema metadata about POJOs.
Builder class.
Session object that lives for the duration of a single use of
JsonSchemaSerializer.Builder class.
A container for retrieving JSON
JsonSchema objects by URI.Interface for providing access to
JsonSchemaClassMeta and JsonSchemaBeanPropertyMeta objects.Represents a JSON property in the JSON-Schema core specification.
Convenience class for representing a property that's an array of simple types.
PropertyValidatorFactory implementation backed by the typed JsonSchema bean.Convenience class for representing a schema reference such as "{'$ref':'/url/to/ref'}" .
Serializes POJO metadata to HTTP responses as JSON-Schema.
Builder class.
Default serializer, with whitespace.
Session object that lives for the duration of a single use of
JsonSchemaSerializer.Builder class.
Validates values against a
JsonSchema bean per the JSON Schema Draft 2020-12 specification.Serializes POJO models to RFC 8259 JSON.
Builder class.
Concrete default builder leaf for the non-subclassed
JsonSerializer.create() / JsonSerializer.copy() path.Default serializer, with whitespace.
Session object that lives for the duration of a single use of
JsonSerializer.Builder class.
Concrete default builder leaf for the non-subclassed
create() path (CRTP terminal).Sample class which shows the simple usage of JsonSerializer and JsonParser.
Reference implementation of the public
TokenReader surface for the JSON format.Cursor-level settings honored by
JsonTokenReader.Reference implementation of the public
TokenWriter surface for the JSON format.Output-formatting settings honored by
JsonTokenWriter.Represents possible JSON types in the JSON-Schema core specification.
Represents a list of
JsonType objects.Bounded, iterative walker that validates already-materialized JSON values against structural safety limits.
Specialized writer for serializing JSON.
Flavor-neutral worker bean carrying the JSP raw-template-dispatch logic shared by the
JspMixin mixin, the JspServlet servlet, and the JspResource child flavors.Builder for
JspDispatcher.Mixin that wires JSP view-rendering onto any Juneau REST resource.
Builder for
JspMixin.Child-resource flavor of the
JspMixin mixin.Standalone servlet companion of the
JspMixin mixin.Immutable value class returned from
@RestOp-annotated methods to ask the framework to
render a JSP template.ResponseProcessor that detects JspView-typed return values and dispatches them
to the underlying JSP engine via
ServletContext.getRequestDispatcher(...).forward(...).FQN-based support for JSR-style annotation detection.
LogBackend implementation for java.util.logging (JUL).JUnit 5 extension that discovers
@TestBean-annotated members on a test class and exposes them as
a TestBeanStore overlay.The flattened result of
JuneauBeanStoreExtension.discoverOverrides(Object): the @TestBean overlay store, the unified
Mode of all declarations, and whether any were found.Opt-in Spring Boot auto-configuration that mounts every
RestServlet bean at its
self-declared top-level path without an explicit ServletRegistrationBean per servlet.Spring Boot logging bridge auto-configuration.
Plain Servlet-spec
ServletContainerInitializer that auto-mounts RestServlet
subclasses at their self-declared top-level paths in non-Spring (e.g.Always-available factory helper that builds a Spring Boot
ServletRegistrationBean whose
URL mappings are derived from a Juneau servlet's self-declared top-level paths.Reads a single JUnit-XML report file, such as pytest's --junitxml output.
TokenValidator that validates signed JWTs against a JWKS-backed key source.Builder class for
JwtTokenValidator.DTO for an HTML <kbd>
element.
A security keychain CLI (generic passwords).
SecretStore backed by the macOS Provider that contributes a
KeychainSecretStore via ServiceLoader, discoverable through
SecretStores.fromServiceLoader() when this module is on the classpath and the host is macOS.A key paired with the identifier an operator chose for it, as returned by
KeyProvider.currentKey()
and resolved by KeyProvider.resolveKey(String).DTO for an HTML <keygen>
element.
SPI for supplying the key(s) used to seal/unseal MCP MRTR
requestState continuation tokens (see
AeadRequestStateCodec).A specialized set for storing and efficiently looking up language keywords.
DTO for an HTML <label>
element.
Represents a parsed Last-Modified HTTP response header.
Represents an HTTP Last-Modified header.
DTO for an HTML <legend>
element.
Exception representing an HTTP 411 ().
Represents an HTTP 411 Length Required error response.
Unmodifiable point-in-time snapshot of the enclosing
LengthRequired exception.Unmodifiable point-in-time snapshot of the enclosing
LengthRequired exception.DTO for an HTML <li>
element.
License information for the exposed API.
License information for the exposed API.
Swagger license annotation.
Utility classes and methods for the
@License annotation.Builder class.
Represents a reference from an entry or feed to a Web resource.
DTO for an HTML <link>
element.
The Link object represents a possible design-time link for a response.
Simple bean that implements a hyperlink for the HTML serializer.
Used for assertion calls against lists.
A simple in-memory
BeanChannel implementation backed by an ArrayList.Functional interface for converting collection-like objects to standardized List<Object> format.
Collection of standard listifier implementations for the Bean-Centric Testing framework.
Identifies how to add elements to a list.
Result payload for "prompts/list".
Result payload for "prompts/list".
Result payload for "resources/list".
Result payload for "resources/list".
Result payload for "resources/templates/list".
Result payload for "resources/templates/list".
A fluent builder for constructing
List instances with various configuration options.Result payload for "tools/list".
Result payload for "tools/list".
REST resource for loading configuration from a Git repository.
Represents a directory that can be located either on the classpath or in the file system.
Supported wire formats for
Locale values.Represents a file that can be located either on the classpath or in the file system.
Localized string variable resolver.
Represents a parsed Location HTTP response header.
Represents an HTTP Location header.
Exception representing an HTTP 423 (Locked).
Represents an HTTP 423 Locked error response.
Unmodifiable point-in-time snapshot of the enclosing
Locked exception.Unmodifiable point-in-time snapshot of the enclosing
Locked exception.SPI behind the
/loggers management endpoint: reads and sets logger levels for one concrete logging
backend at runtime.LogBackend adapter for Logback (the SLF4J native
backend), for use behind the /loggers management endpoint.Can be used for configuration of simple logging in the microservice.
A thread-confined, MDC-style key/value context whose entries are auto-attached to every
LogRecord
emitted by a RichLogger on the same thread while a scope is open.An open context scope.
Log entry formatter.
Logger-name normalization for resource classes.
Shared worker for the
/loggers management endpoint: reads and sets logger levels at runtime by
delegating to the LogBackend resolved from the host context.Mixin flavor of the
/loggers runtime log-level management endpoint.Child-resource flavor of the
/loggers runtime log-level management endpoint.Exposure settings for the
/loggers endpoint.Builder for
LoggersSettings.Server logging capability marker (structure may grow with the spec).
Server logging capability marker (structure may grow with the spec).
SPI for the single-use, TTL-bounded
state → (nonce, PKCE code_verifier,
redirect target) association created during OidcRelyingParty.startLogin(jakarta.servlet.http.HttpServletRequest, jakarta.servlet.http.HttpServletResponse) and consumed during
OidcRelyingParty.completeLogin(jakarta.servlet.http.HttpServletRequest, jakarta.servlet.http.HttpServletResponse).A pending-login association awaiting the IdP callback.
Represents a larger logo image for visual identification of a feed.
Utility class for reading log files.
LogRecord that supports lazy message formatting.
Captures log records for testing purposes.
Handle returned by
LogRecordCapture.quiet(String).Identity-keyed side table that carries a
LogContext snapshot alongside a LogRecord.Interface for listening to log records.
REST resource for viewing and accessing log files.
File action link.
File or directory details for REST response.
Used for assertion calls against longs.
A simple mutable long value.
The request-authenticity half of a loopback application's write protection: decides whether a request came from
the page this process served, and refuses it when it did not.
Builder for
LoopbackBoundary.A
RequestBoundaryFilter applying a LoopbackBoundary.A minimal loopback (
http://127.0.0.1) HTTP listener that captures the single authorization-code redirect an
IdP sends back to a native/CLI OAuth client (SEP-837 loopback redirect handling).Builds the pair of loopback redirect URIs (SEP-837 loopback redirect handling) an MCP native/CLI client registers
with an authorization server during Dynamic Client Registration.
Exception representing an HTTP 508 (Loop Detected).
Represents an HTTP 508 Loop Detected error response.
Unmodifiable point-in-time snapshot of the enclosing
LoopDetected exception.Unmodifiable point-in-time snapshot of the enclosing
LoopDetected exception.DTO for an HTML <main>
element.
The
<@main/> console FreeMarker directive: the positional placeholder that renders the captured page body
inside exactly one <main class="jc-main">.Lean accessor for the contents of a Jar manifest file.
Property source backed by
ManifestFile.Provider for
ManifestFilePropertySource.Manifest file entries variable resolver.
DTO for an HTML <map>
element.
Used for assertion calls against lists.
A fluent builder for constructing
Map instances with various configuration options.A writable
PropertyStore implementation backed by a thread-safe map.Abstract subclass for object swaps that swap objects for object maps.
A subclass of
DefaultingVar that simply pulls values from a Map.DTO for an HTML <mark>
element.
Annotation for customizing Markdown serialization and parsing behavior on classes, methods, and fields.
A pairing of a
MarkdownSerializer and MarkdownParser into a single class with convenience to/of methods.Utility classes and methods for the
@Markdown annotation.Dynamically applies a
@Markdown annotation to specified classes, methods, or fields.A collection of
@MarkdownApply annotations.Utility classes and methods for the
@MarkdownApply annotation.Applies targeted
MarkdownApply annotations to a Context.Builder.Builder class.
Metadata on bean properties specific to the Markdown serializers and parsers pulled from the
@Markdown annotation on the bean property.Metadata on classes specific to the Markdown serializers and parsers pulled from the
@Markdown
annotation on the class.Annotation for specifying config properties defined in
MarkdownSerializer
and MarkdownParser.Utility classes and methods for the
@MarkdownConfig annotation.Applies
MarkdownConfig annotations to a MarkdownParser.Builder.Applies
MarkdownConfig annotations to a MarkdownSerializer.Builder.A pairing of a
MarkdownDocSerializer and MarkdownDocParser into a single class with
convenience to/of methods for document-mode Markdown (headings + tables).Parses Markdown document-mode output (headings + tables) back to POJOs.
Builder class.
Session object for
MarkdownDocParser.Builder class.
Serializes POJO models to Markdown document mode (headings + tables).
Builder class.
Session object for
MarkdownDocSerializer.Builder class.
Rendering format for Markdown serialization.
Interface for providing access to
MarkdownClassMeta and MarkdownBeanPropertyMeta objects.Parses Markdown fragment-mode output (tables and lists) back to POJOs.
Builder class.
Concrete default builder leaf for the non-subclassed
MarkdownParser.create() / MarkdownParser.copy() path.Session object for
MarkdownParser.Builder class.
Concrete default builder leaf for the non-subclassed
create() path (CRTP terminal).A pluggable markdown-to-HTML renderer: hand it a markdown string, get back an HTML fragment.
Serializes POJO models to Markdown (fragment mode: tables and lists).
Builder class.
Concrete default builder leaf for the non-subclassed
MarkdownSerializer.create() / MarkdownSerializer.copy() path.Session object for
MarkdownSerializer.Builder class.
Concrete default builder leaf for the non-subclassed
create() path (CRTP terminal).Low-level Markdown writer providing helper methods for producing Markdown output.
The built-in
markers decorator: vertical mark lines at x values from a list, a same-origin src, a
data: topic, or the current time.Annotation that can be applied to classes to control how they are marshalled.
Utility classes and methods for the
@Marshalled annotation.Builder class.
Dynamically applies a
@Marshalled annotation to specified classes.A collection of
@MarshalledApply annotations.Utility classes and methods for the
@MarshalledApply annotation.Applies targeted
MarshalledApply annotations to a Context.Builder.Builder class.
Specifies the marshalling strategy for a type annotated with
@Marshalled.Annotation for specifying marshalling-only config properties defined in
MarshallingContext and MarshallingTraverseContext.Utility classes and methods for the
@MarshalledConfig annotation.Applies
MarshalledConfig annotations to a MarshallingContext.Builder.Filter for customizing how POJOs and beans are handled during serialization and parsing.
Builder class.
Skip a type entirely during marshalling.
Utility classes and methods for the
@MarshalledIgnore annotation.Builder class.
Dynamically applies a
@MarshalledIgnore annotation to specified classes, methods, or fields.A collection of
@MarshalledIgnoreApply annotations.Utility classes and methods for the
@MarshalledIgnoreApply annotation.Applies targeted
MarshalledIgnoreApply annotations to a Context.Builder.Builder class.
Neutral, marshaller-agnostic list of objects.
Neutral, marshaller-agnostic map of string-to-object entries.
Typed tree façade over the generic-collections model (
MarshalledMap / MarshalledList and their
JsonMap / JsonList subclasses).Used to tailor how bean properties get marshalled by the framework.
Utility classes and methods for the
@MarshalledProp annotation.Builder class.
Dynamically applies a
@MarshalledProp annotation to specified classes, methods, or fields.A collection of
@MarshalledPropApply annotations.Utility classes and methods for the
@MarshalledPropApply annotation.Applies targeted
MarshalledPropApply annotations to a Context.Builder.Builder class.
Top-level class for a pairing of a
Serializer and Parser into a single class with convenience read/write methods.Bean context.
Builder class.
Context class for classes that use
MarshallingContext objects.Builder class.
Generic object converter implementation.
Interface used to retrieve identifiers and URIs for bean classes.
Represents the absence of a bean definition mapper class.
Exception that indicates that a recursion was detected while traversing a POJO model.
Session object that lives for the duration of a single use of
MarshallingContext.Builder class.
Concrete default builder leaf for the non-subclassed
create() path (CRTP terminal).Transforms beans into
Strings by simply calling the Object.toString() method.Parent class for all classes that traverse POJOs.
Builder class.
ContextSession that lives for the duration of a single use of
MarshallingTraverseContext.Builder class.
Convenience static methods for serializing objects with all supported Juneau marshalling formats.
Transforms
MatchResults to List objects.Represents a parsed Max-Forwards HTTP request header.
Represents an HTTP Max-Forwards header.
The OIDC Dynamic Client Registration
application_type (SEP-837) declared by an MCP client when it registers
with an authorization server.RFC 8707 audience enforcement — the
confused-deputy defense pairing with the MCP client's resource indicator.
Runtime exception raised by the MCP client-side auth layer when metadata discovery, PRM fetch/parse, an issuer
(
iss) validation check, or token acquisition fails.A builder-configurable auth-token seam implemented as a
RestCallInterceptor.Interactive authorization-code + PKCE (S256) token acquisition for headless / CLI use.
Builder.
Fluent, insertion-ordered builder for a
WWW-Authenticate: Bearer ... challenge value (RFC 6750 §3, RFC
9728 §5.1) emitted by the 2026-07-28 MCP resource server on a 401.Binding-owned, immutable-after-construction cache configuration for a v2
McpRevision.A single
ttlMs/cacheScope configuration pair applied to a v2 cacheable result.SEP-2549 cache-hint authorization scope for a
CacheableResult (MCP wire uses lowercase strings).A single revision-neutral change event published through
McpSubscriptions and fanned out by an
McpSubscriptionBroker to every matching McpSubscription.The kind of change a neutral MCP subscription can be notified about.
Typed 2025-06-18 Model Context Protocol (MCP) client facade.
Typed 2026-07-28 Model Context Protocol (MCP) client facade.
Fluent builder for
McpClient.Fluent builder for
McpClient.Immutable result of a Dynamic Client Registration (SEP-837) round-trip — the client credentials and metadata an
authorization server issued, keyed by the AS
issuer for SEP-2352 credential binding.Orchestrates SEP-2352 registration-mechanism selection, issuer-keying, and re-registration on authorization-server
migration, returning a usable
McpClientRegistration for a discovered AS.Builder.
Bridges a Dynamic-Client-Registration result (
McpClientRegistration) into the existing token flows —
the McpAuthorizationCodeAcquirer (interactive auth-code + PKCE) and McpTokenProvider
(client-credentials / refresh).SEP-2352 optional persistence SPI for Dynamic-Client-Registration / pre-registered credentials, keyed by the
authorization server's
issuer identifier.Application behavior invoked for a
completion/complete request against a declared prompt
argument (McpPromptArgument.getCompleter()) or resource-template variable
(McpResourceTemplateHandler.completer(String)).Revision-neutral identification of the declaration a
completion/complete request targets.The kind of declaration a
McpCompletionRef targets.Revision-neutral invocation of an
McpCompleter.Revision-neutral, as-returned-by-the-application result of an
McpCompleter invocation.The normalized shape of a completion result, ready for wire mapping.
Revision-neutral content block returned by tool calls and prompt messages.
Which content variant is populated.
Pagination strategy for MCP
list dispatchers (tools / prompts / resources / resource templates).The non-notification result of one
McpRevision.dispatch(McpExchange, McpServerConfig, org.apache.juneau.commons.inject.BeanStore)
call: either a complete JSON-RPC response envelope (McpResponseResult) or a held-open streaming
publisher (McpStreamResult, for a revision-specific method whose successful result is not a
single JSON-RPC envelope, e.g. the 2026-07-28 subscriptions/listen method).Dispatches server-initiated JSON-RPC requests delivered over an MCP client's duplex event-stream channel to a
single registered
McpServerRequestHandler.Performs an RFC 7591 / OpenID Connect Dynamic Client Registration (SEP-837) round-trip against an authorization
server's
registration_endpoint, returning the issued credentials as a redaction-safe
McpClientRegistration keyed by the AS issuer (the SEP-2352 binding key).Builder.
Caller-supplied callback that answers one round of server→client MCP
2026-07-28 SEP-2322
elicitation requests during a client-side Multi-Round-Trip-Request (MRTR) auto-resume loop.Thrown by the client-side MRTR (SEP-2322) auto-resume helpers
(
McpClient.callToolWithElicitation(java.lang.String, java.util.Map<java.lang.String, java.lang.Object>, org.apache.juneau.rest.client.mcp.v20260728.McpElicitationHandler), McpClient.getPromptWithElicitation(java.lang.String, java.util.Map<java.lang.String, java.lang.Object>, org.apache.juneau.rest.client.mcp.v20260728.McpElicitationHandler),
McpClient.readResourceWithElicitation(java.lang.String, org.apache.juneau.rest.client.mcp.v20260728.McpElicitationHandler)) when a server keeps returning input_required pauses past
the loop's configured maximum number of resume rounds.Mixin interface that exposes a
2025-06-18 MCP endpoint at POST /mcp on any Juneau
REST resource.Mixin interface that exposes a
2026-07-28 MCP endpoint at POST /mcp on any Juneau REST
resource.Mixin interface that exposes an MCP JSON-RPC endpoint at
POST /mcp on any Juneau REST resource.Revision-neutral classification of a dispatch failure.
Runtime exception carrying JSON-RPC error fields for mapping to
JsonRpcError.The inbound JSON-RPC envelope plus request-header access, with no servlet or HTTP types attached.
Thrown by a handler's ordinary
call/get/read body to signal that it needs more input
before it can complete (MCP 2026-07-28 SEP-2322 Multi-Round-Trip Requests).Signals that an MCP call was rejected with a SEP-2350
401/403 insufficient_scope step-up challenge.Discriminates which MCP
2026-07-28 list-changed notification a
McpSubscriptionListener.onListChanged(McpListChangedKind) callback is reporting.JSON-RPC method names used by MCP over HTTP.
JSON-RPC method names used by MCP over HTTP.
Bean always stashed into the
BeanStore passed to a
tools/call/prompts/get/resources/read handler (both first-round and resume calls),
exposing whether the original request's client advertised MRTR/elicitation support.Binding-owned MRTR (Multi-Round-Trip Request) configuration for a v2
McpRevision.Bean stashed into the
BeanStore passed to a handler on a RESUME call,
carrying the decoded continuation and the client's collected answers.The resolved MCP operation an
McpOperationScopeResolver decides required scopes for (SEP-2350 per-operation
step-up).Resolves the set of scopes required to invoke a specific MCP operation (SEP-2350 per-operation step-up enforcement).
Binding-owned behavior configuration ("how" a
2026-07-28 MCP endpoint behaves) — the single
v2-only aggregate consolidating every per-binding tunable McpEndpoint/McpRestServlet previously
exposed as six separate hooks: capabilities, instructions, cache, mrtr,
subscriptions, and subscriptionBroker.Slice of MCP descriptors returned by
McpCursor.page(List, String, org.apache.juneau.commons.inject.BeanStore).Shared internal plumbing for revision
McpRevision.dispatch(org.apache.juneau.rest.server.mcp.McpExchange, org.apache.juneau.rest.server.mcp.McpServerConfig, org.apache.juneau.commons.inject.BeanStore) implementations.Revision-neutral declared argument of a prompt.
Handler for a single MCP prompt.
Revision-neutral single message within a prompt result.
Revision-neutral result of a
prompts/get invocation.Revision-neutral prompt descriptor returned from
prompts/list.Immutable view of an RFC 9728 Protected Resource Metadata (PRM) document, as an MCP client consumes it to discover
which authorization server(s) protect a given MCP server.
Server-side representation of an RFC 9728
Protected Resource Metadata (PRM) document, emitted by the
2026-07-28 MCP resource server from its
.well-known/oauth-protected-resource endpoint so a client can discover which authorization server(s) protect
this MCP server.Fetches and parses an RFC 9728 Protected Resource Metadata (PRM) document, and resolves the authorization server a
protected MCP resource delegates to.
Builder.
MCP protocol version strings carried in
initialize requests and results.MCP protocol version strings carried in per-request
_meta and server/discover.The dispatcher-owned payload sealed into an opaque
requestState token by RequestStateCodec.Revision-neutral resource payload, either inline text or a base64 blob.
Which payload variant is populated.
Handler for a single MCP resource.
Revision-neutral result of a
resources/read invocation.Binding-owned OAuth 2.1 resource-server (RS) configuration for a
2026-07-28 MCP endpoint — the
authorization-hardening baseline.Request-time glue for the OAuth 2.1 resource-server baseline — bearer validation, RFC 8707 audience
enforcement,
401/403 challenge emission, and RFC 9728 Protected Resource Metadata construction —
driven by an McpResourceServerConfig.Revision-neutral resource descriptor returned from
resources/list.Handler for a single MCP resource template.
A three-argument function from (
uri, variables, ctx) to a
McpResourceOutcome, matching McpResourceTemplateHandler.ReadFunction.read(String, Map, BeanStore)'s signature.Revision-neutral resource-template descriptor returned from
resources/templates/list.An opt-in, off-by-default response cache for MCP client results.
A
McpDispatchResult wrapping a complete JSON-RPC response envelope — the common (non-streaming)
McpRevision.dispatch(org.apache.juneau.rest.server.mcp.McpExchange, org.apache.juneau.rest.server.mcp.McpServerConfig, org.apache.juneau.commons.inject.BeanStore) outcome.Abstract MCP servlet bound to protocol revision
2025-06-18.Abstract MCP servlet bound to protocol revision
2026-07-28.Service-provider interface implemented once per MCP protocol revision.
McpRevision implementation for MCP revision 2025-06-18.McpRevision implementation for MCP revision 2026-07-28.Revision-neutral role for
McpPromptMessage entries.Shared SEP-2243 routing-name helper used by both the
2026-07-28 server adapter and client adapter.Revision-neutral carrier for a tool's input schema.
Computes and tracks the SEP-2350 step-up scope union — the set of scopes a client re-authorizes with after a
server emits a per-operation
insufficient_scope challenge.Aggregate configuration consumed by the bound
McpRevision.The result of
McpServerConfig.resolveResourceTemplate(String): the winning resource-template handler paired
with the variables decoded from the concrete request URI.Callback invoked by
McpDuplexDispatcher to handle a single server-initiated JSON-RPC request
delivered over an MCP client's duplex event-stream channel (for example sampling/createMessage;
illustrative only, as sampling is deprecated per SEP-2577).Client-side SEP-2350 step-up state machine: wraps an MCP call so that, on a
401/403 insufficient_scope
challenge, it computes the required-scope union (McpScopeAccumulator), drives (re-)authorization via a
caller-supplied McpStepUpAuthorizer.Reauthorizer, and retries the original call — bounded by a hard attempt cap with
per-(resource, operation) attempt tracking so a misconfigured server can't drive an unbounded
re-authorization loop (spec "no more than a few times").Builder.
Drives (re-)authorization with the computed scope union and installs the resulting token.
A caller-supplied MCP call that throws
McpInsufficientScopeException on a step-up challenge.A
McpDispatchResult wrapping a held-open streaming publisher, for a revision-specific method
whose successful result is not a single JSON-RPC envelope (for example the 2026-07-28
subscriptions/listen method).Per-subscription queue handle minted by an
McpSubscriptionBroker.Revision-neutral registry + filtered fan-out publisher for MCP
subscriptions/listen.A revision-neutral, immutable subscription filter: the set of change kinds and resource URIs one
McpSubscription is interested in.Closeable handle for a live
McpClient.listen(org.apache.juneau.bean.mcp.v20260728.SubscriptionFilter, McpSubscriptionListener)
subscription.Typed callback sink for
McpClient.listen(SubscriptionFilter, McpSubscriptionListener) frames.App-facing, revision-neutral change-publish SPI for MCP
subscriptions/listen.Binding-owned MCP
subscriptions/listen (SEP-2575) configuration for a v2 McpRevision.A headless bearer-token provider that feeds the
McpAuthInterceptor token seam (Supplier<String>).Builder.
Handler for a single MCP tool.
Revision-neutral result of a
tools/call invocation.Revision-neutral tool descriptor returned from
tools/list.Bridges
typed tool handlers into raw McpToolHandlers.Adapter that converts a
McpTypedPromptHandler into the raw McpPromptHandler interface
consumed by McpRevision.Typed variant of
McpPromptHandler where MCP prompts/get arguments bind into a Juneau bean.Strongly-typed tool handler whose argument and result Java types drive schema derivation and binding.
Hand-rolled, dependency-free compiler and reverse matcher for the narrow, reliably-invertible subset of
RFC 6570 URI templates used by MCP
resource-template reads.
Pure, side-effect-free construction of the RFC 9728 / SEP-2351 well-known Protected Resource Metadata (PRM) URIs for a
given canonical resource identifier.
Bridges SLF4J MDC context from the request (dispatch) thread to the
CompletableFuture
completion thread.Describes a single type used in content negotiation between an HTTP client and server, as described in
Section 14.1 and 14.7 of RFC2616 (the HTTP/1.1 specification).
A parsed Accept or similar header value.
Provides schema and examples for the media type identified by its key.
Describes a single media type used in content negotiation between an HTTP client and server, as described in
Section 14.1 and 14.7 of RFC2616 (the HTTP/1.1 specification).
A thread-safe supplier that caches the result of the first call and supports resetting the cache.
Filesystem-based storage location for configuration files.
Builder class.
A
TerminalSource over a fixed-capacity ring buffer, for producers that run in the same process.A single row in an attached header or avatar menu.
A subclass of widgets for rendering menu items with drop-down windows.
Strategy interface for rendering log message patterns.
A lightweight message-bundle loader for the assertions classes.
An enhanced
ResourceBundle.Builder class.
DTO for an HTML <meta>
element.
DTO for an HTML <meter>
element.
Annotation that can be applied to a parameter of a
@RestOp annotated method to identify it as the HTTP
method.Method execution statistics.
Builder class.
Method execution statistics database.
Builder class.
Lightweight utility class for introspecting information about a Java method.
A wrapper around a
Method.invoke(Object, Object...) method that allows for basic instrumentation.A simple list of
Method objects.Exception representing an HTTP 405 (Method Not Allowed).
Represents an HTTP 405 Method Not Allowed error response.
Unmodifiable point-in-time snapshot of the enclosing
MethodNotAllowed exception.Unmodifiable point-in-time snapshot of the enclosing
MethodNotAllowed exception.Thrown by
ObjectIntrospector when an attempt is made to invoke a method that has not been
explicitly allow-listed.Which HTTP methods are safe, and the startup check that an operation declared
Mutating is not bound to
one of them.Shared worker for the
/metrics management endpoint: resolves a consumer-provided Micrometer
MeterRegistry from the host bean store and renders a scrape payload.Mixin flavor of the
/metrics endpoint: renders a Prometheus scrape from a consumer-provided
Micrometer MeterRegistry resolved from the host bean store.SPI for receiving per-request metric events from
juneau-rest-server.Child-resource flavor of the
/metrics endpoint.MetricsRecorder bridge that records every @RestOp call as a Micrometer
Timer sample on the configured MeterRegistry.Parent class for all microservices.
Builder class.
JUnit 5 extension behind
@MicroserviceTest: boots a whole
Microservice (config + lifecycle + embedded Jetty on an ephemeral port) for the test class, with
@TestBean mock-bean injection and convenience parameter resolution.Listener class for microservice lifecycle events.
Boots a whole
Microservice (config + lifecycle +
embedded Jetty server) for the annotated JUnit 5 test class — the standalone-microservice analog of
Spring's @SpringBootTest.A lightweight MIME type detector that doesn't require Jakarta Activation.
Builder class for creating MimeTypeDetector instances.
Exception representing an HTTP 421 (Misdirected Request).
Represents an HTTP 421 Misdirected Request error response.
Unmodifiable point-in-time snapshot of the enclosing
MisdirectedRequest exception.Unmodifiable point-in-time snapshot of the enclosing
MisdirectedRequest exception.Thrown when parser input (or the source map of a
Map-to-bean conversion) does not contain one or more
properties marked @BeanProp(required=true).Rich mixin definition for the
@Rest(mixinDefs=...) attribute.Utility classes and methods for the
@Mixin annotation.Builder class.
A capturing
PrintStream that allows you to easily capture console output.An implementation of
HttpSession for mocking purposes.A programmable in-process
HttpTransport for unit testing.Fluent builder for
MockHttpTransport.A handler that maps an incoming
TransportRequest to a TransportResponse.Simplified logger for intercepting and asserting logging messages.
Used to resolve incoming URLS to the various URL artifacts of HttpServletRequest .
Mocked
RestClient.Next-generation mock REST client that routes requests in-process to a Juneau
RestContext.Builder class.
Fluent builder for
MockRestClient.A subclass of
RestRequest with additional features for mocked testing.A subclass of
RestResponse with additional features for mocked testing.A mutable implementation of
HttpServletRequest for mocking purposes.An implementation of
HttpServletResponse for mocking purposes.Specifies an entry modifier that is used to encode during write and decode during read of config entries.
The declarative modal (dialog) a
present=dialog row action opens — the payload the
modal-open confirmation fetch returns.One entry in a dialog's
ModalDef.childActions catalog — a stacked step a type="action"
input inside this dialog's form may open.A single typed confirmation field: a label and a value, painted client-side with
textContent (never
innerHTML).One page of a
ModalDef.steps wizard: an id, an optional title and confirm-button label, and the typed
display fields painted for that page.Wiring mode for a
@TestBean-declared override.A model family/name hint for
ModelPreferences.getHints() (MCP sampling).Model-selection preferences for
CreateMessageRequest (MCP sampling).Represents an HTTP 301 Moved Permanently response.
Represents an HTTP 301 Moved Permanently response.
Unmodifiable point-in-time snapshot of the enclosing
MovedPermanently response.Unmodifiable point-in-time snapshot of the enclosing
MovedPermanently response.The JSON Patch
"move" operation per
RFC 6902 § 4.4.A pairing of a
MsgPackSerializer and MsgPackParser into a single class with convenience to/of methods.Annotation that can be applied to classes, fields, and methods to tweak how they are handled by
MsgPackSerializer and MsgPackParser.Utility classes and methods for the
@MsgPack annotation.Builder class.
Dynamically applies a
@MsgPack annotation to specified classes, methods, or fields.A collection of
@MsgPackApply annotations.Utility classes and methods for the
@MsgPackApply annotation.Applies targeted
MsgPackApply annotations to a Context.Builder.Builder class.
A
MsgPack variant that represents binary values as Base64 text instead of raw
MessagePack bytes.Metadata on bean properties specific to the MessagePack serializers and parsers pulled from the
@MsgPack
annotation on the bean property.Metadata on classes specific to the MessagePack serializers and parsers pulled from the
@MsgPack annotation on
the class.Annotation for specifying config properties defined in
MsgPackSerializer and MsgPackParser.Utility classes and methods for the
@MsgPackConfig annotation.Applies
MsgPackConfig annotations to a MsgPackParser.Builder.Applies
MsgPackConfig annotations to a MsgPackSerializer.Builder.Specialized input stream for parsing MessagePack streams.
Interface for providing access to
MsgPackClassMeta and MsgPackBeanPropertyMeta objects.A
MsgPack variant whose parser is in native mode, exposing low-level MessagePack
extension type information in the token stream instead of normalizing it away.Specialized output stream for serializing MessagePack streams.
Parses a MessagePack stream into a POJO model.
Default parser, string input encoded as BASE64.
Builder class.
Default parser, string input encoded as spaced-hex.
Session object that lives for the duration of a single use of
MsgPackParser.Builder class.
Serializes POJO models to MessagePack.
Default serializer, BASE64 string output.
Builder class.
Default serializer, spaced-hex string output.
Session object that lives for the duration of a single use of
MsgPackSerializer.Builder class.
A
MsgPack variant that represents binary values as spaced hexadecimal text instead
of raw MessagePack bytes.Reference implementation of the public
TokenReader surface for the MessagePack format.Reference implementation of the public
TokenWriter surface for the MessagePack format.Cursor-level settings honored by
MsgPackTokenWriter.A composite list that presents multiple lists as a single unified list.
A composite map that presents multiple maps as a single unified map.
REST proxy method-level multipart/form-data marker annotation.
An
HttpBody that serializes a multipart/form-data message (RFC 7578).Fluent builder for
MultipartBody.A single part within a
MultipartBody.Predefined matcher for matching requests with content type "multipart/form-data" .
Interface for the resolution of vars that can have one or more keys where the first non-null resolution is returned.
Interface for the resolution of vars that consist of a comma-delimited list.
Represents an HTTP 300 Multiple Choices response.
Represents an HTTP 300 Multiple Choices response.
Unmodifiable point-in-time snapshot of the enclosing
MultipleChoices response.Unmodifiable point-in-time snapshot of the enclosing
MultipleChoices response.A composite set that presents multiple collections as a single unified set.
Represents an HTTP 207 Multi-Status response.
Represents an HTTP 207 Multi-Status response.
Unmodifiable point-in-time snapshot of the enclosing
MultiStatus response.Unmodifiable point-in-time snapshot of the enclosing
MultiStatus response.Flavor-neutral worker bean carrying the Mustache raw-template-dispatch logic shared by the
MustacheMixin mixin, the MustacheServlet servlet, and the MustacheResource
child flavors.Builder for
MustacheDispatcher.The Mustache rendering flavor: the pet list rendered from
console/fragments/pets.mustache.Mixin that wires Mustache view-rendering onto any Juneau REST resource.
Builder for
MustacheMixin.Child-resource flavor of the
MustacheMixin mixin.Standalone servlet companion of the
MustacheMixin mixin.Immutable value class returned from
@RestOp-annotated methods to ask the framework to
render a Mustache template.ResponseProcessor that detects MustacheView-typed return values and asks the
configured MustacheFactory to render them directly onto the response writer.Declares that a REST operation changes state, so that binding it to an HTTP method defined as safe becomes a
startup failure instead of a silent mistake.
A pairing of a
N3Serializer and N3Parser into a single class with convenience to/of methods.Subclass of
RdfParser for parsing N3 (Notation3) into POJOs.Subclass of
RdfSerializer for serializing POJOs to N3 (Notation3) format.Specifies the parameter name for bean property mapping.
Identifies a bean-injection qualifier for constructor/method parameters and fields.
A simple named object.
A list of
NamedAttribute objects.Identifies a setter method or field for setting the name of a POJO as it's known by its parent object.
Utility classes and methods for the
@NameProperty annotation.Builder class.
Dynamically applies a
@NameProperty annotation to specified methods or fields.A collection of
@NamePropertyApply annotations.Utility classes and methods for the
@NamePropertyApply annotation.Applies targeted
NamePropertyApply annotations to a Context.Builder.Builder class.
Represents a simple namespace mapping between a simple name and URI.
A name/value pair parameter, typically used in HTTP headers and request parameters.
Identifies a class that can be converted to a
NameValuePair object.DTO for an HTML <nav>
element.
The
<@navigation> console FreeMarker directive: opens the nav tree on the PageCapture.Mixin providing the group-navigation endpoint (
[GET /]) that lists the host resource's child
resources.One node in the console navigation tree.
Exception representing an HTTP 511 (Network Authentication Required).
Represents an HTTP 511 Network Authentication Required error response.
Unmodifiable point-in-time snapshot of the enclosing
NetworkAuthenticationRequired exception.Unmodifiable point-in-time snapshot of the enclosing
NetworkAuthenticationRequired exception.A wrapper around an
OutputStream that prevents the underlying stream from being closed.A wrapper around a
Writer that prevents the underlying writer from being closed.Represents an HTTP 204 No Content response.
Represents an HTTP 204 No Content response.
Unmodifiable point-in-time snapshot of the enclosing
NoContent response.Unmodifiable point-in-time snapshot of the enclosing
NoContent response.The recursive
<@node> console FreeMarker directive: one entry in a <@navigation> tree, of any
depth, or (with under=) a page-scoped addition appended under an existing chrome nav node.Represents an HTTP 203 Non-Authoritative Information response.
Unmodifiable point-in-time snapshot of the enclosing
NonAuthoritativeInformation response.Represents an HTTP 203 Non-Authoritative Information response.
Unmodifiable point-in-time snapshot of the enclosing
NonAuthoritiveInformation response.Dummy class that indicates that serializers, parsers, or transforms for a Java class or method should not be inherited.
Default
MetricsRecorder implementation that drops every event on the floor.Default
TracerHook implementation that opens no spans and records nothing.No-op
Scope returned by NoOpTracerHook.DTO for an HTML <noscript>
element.
Exception representing an HTTP 406 (Not Acceptable).
Represents an HTTP 406 Not Acceptable error response.
Unmodifiable point-in-time snapshot of the enclosing
NotAcceptable exception.Unmodifiable point-in-time snapshot of the enclosing
NotAcceptable exception.The example's entire "domain": a tiny in-memory map of note title → note body.
Exception representing an HTTP 510 (Not Extended).
Represents an HTTP 510 Not Extended error response.
Unmodifiable point-in-time snapshot of the enclosing
NotExtended exception.Unmodifiable point-in-time snapshot of the enclosing
NotExtended exception.Exception representing an HTTP 404 (Not Found).
Represents an HTTP 404 Not Found error response.
Unmodifiable point-in-time snapshot of the enclosing
NotFound exception.Unmodifiable point-in-time snapshot of the enclosing
NotFound exception.Exception representing an HTTP 501 (Not Implemented).
Represents an HTTP 501 Not Implemented error response.
Unmodifiable point-in-time snapshot of the enclosing
NotImplemented exception.Unmodifiable point-in-time snapshot of the enclosing
NotImplemented exception.Represents an HTTP 304 Not Modified response.
Represents an HTTP 304 Not Modified response.
Unmodifiable point-in-time snapshot of the enclosing
NotModified response.Unmodifiable point-in-time snapshot of the enclosing
NotModified response.Represents a parsed No-Trace HTTP request header.
Represents an HTTP No-Trace header.
A pairing of a
NQuadsSerializer and NQuadsParser into a single class with convenience to/of methods.Subclass of
RdfParser for parsing N-Quads into POJOs.Subclass of
RdfSerializer for serializing POJOs to N-Quads format.A pairing of a
NTripleSerializer and NTripleParser into a single class with convenience to/of methods.Subclass of
RdfParser for parsing N-Triples into POJOs.Subclass of
RdfSerializer for serializing POJOs to N-Triples notation.A thread-safe reference that combines
AtomicReference with Optional-like functionality.A
Supplier whose value may be null, with Optional-like null-safe query methods.Per-property null-coercion modes consulted by parsers when an explicit
null (or absent
Optional) is encountered on the wire.Sample class which shows the simple usage of OpenApiSerializer.
Authorization-code grant (RFC 6749 §4.1) flow helper with mandatory PKCE per RFC 7636.
Builder.
Client-credentials grant (RFC 6749 §4.4) flow helper.
Builder.
AuthFilter that authenticates requests carrying an OAuth 2.0 / OIDC access token via the
standard RFC 6750 Bearer Token
scheme.Builder.
Configuration details for a supported OAuth Flow.
Runtime exception thrown by any OAuth flow helper when the IdP rejects the request, the HTTP round-trip
fails, or the response can't be parsed.
Allows configuration of the supported OAuth Flows.
TokenValidator that validates opaque OAuth 2.0 access tokens via the
RFC 7662 Token Introspection
endpoint.Builder for
OAuthIntrospectionValidator.Refresh-token grant (RFC 6749 §6) flow helper.
Builder.
Immutable record returned by every OAuth 2.0 flow helper on a successful token acquisition.
DTO for an HTML <object>
element.
Used for assertion calls against arbitrary POJOs.
POJO method introspector.
POJO merger.
Used to swap out non-serializable objects with serializable replacements during serialization, and vis-versa during
parsing.
Canonical home for object-level helpers: null/empty checks, equality, comparison,
coalescing, boolean folds, identity/stringify, small numeric helpers, and optionals.
Handle to one in-flight custom (non-request) observation.
Static facade over an explicitly-installed default
Observer for ergonomic custom
(non-request) observations.A minimal, self-contained, in-process stand-in for a real OAuth 2.1 authorization server (AS), so the
secured MCP example (and its end-to-end test) run entirely offline — no external IdP, no
network access, no pre-shared secrets checked into source control.Fetches a Juneau-native
OidcMetadata record describing an authorization server, supporting both the RFC 8414
OAuth Authorization Server Metadata endpoint (/.well-known/oauth-authorization-server) and the OpenID Connect
Discovery endpoint (/.well-known/openid-configuration).Builder.
Thrown by
OidcDiscoveryClient.discover() when the IdP returns metadata that cannot be parsed.Immutable record produced by
OidcDiscoveryClient carrying the metadata fields a Juneau OAuth /
OIDC consumer typically needs.Facade orchestrating an OpenID Connect Authorization-Code-with-PKCE Relying Party login flow on
top of the
juneau-rest-server-auth-oauth building blocks.Builder.
Immutable record describing a logged-in OpenID Connect Relying Party session.
AuthFilter that resolves the OIDC Relying Party session cookie into a ClaimsPrincipal
on each request, so RoleBasedRestGuard and @Auth Principal injection see the
filter-resolved identity (via AuthenticatedRequestWrapper) with zero downstream changes.Represents an HTTP 200 OK response.
Represents an HTTP 200 OK response.
Unmodifiable point-in-time snapshot of the enclosing
Ok response.Unmodifiable point-in-time snapshot of the enclosing
Ok response.HttpTransport implementation backed by OkHttp 5.x.Fluent builder for
OkHttpTransport.HttpTransportProvider implementation that supplies an OkHttpTransport.DTO for an HTML <ol>
element.
The comparison operator of a declarative single-field rule.
This is the root document object for the OpenAPI specification.
A pairing of a
OpenApiSerializer and OpenApiParser into a single class with convenience to/of methods.Annotation that can be applied to classes, fields, and methods to tweak how they are handled by
OpenApiSerializer and OpenApiParser.Utility classes and methods for the
@OpenApi annotation.Builder class.
Dynamically applies a
@OpenApi annotation to specified classes, methods, or fields.A collection of
@OpenApiApply annotations.Utility classes and methods for the
@OpenApiApply annotation.Applies targeted
OpenApiApply annotations to a Context.Builder.Builder class.
Metadata on bean properties specific to the OpenAPI serializers and parsers pulled from the
@OpenApi
annotation on the bean property.Various useful static methods for creating OpenAPI elements.
Metadata on classes specific to the OpenApi serializers and parsers pulled from the
@OpenApi annotation on
the class.Annotation for specifying config properties defined in
MsgPackSerializer and MsgPackParser.Utility classes and methods for the
@OpenApiConfig annotation.Applies
OpenApiConfig annotations to a OpenApiParser.Builder.Applies
OpenApiConfig annotations to a OpenApiSerializer.Builder.Copy utilities for the OpenAPI 3.0 bean module.
Root class for all Swagger beans.
Interface for providing access to
OpenApiClassMeta and OpenApiBeanPropertyMeta objects.Mixin that publishes the OpenAPI 3.1 spec endpoints for a resource.
OpenAPI part parser.
Builder class.
Session object that lives for the duration of a single use of
OpenApiParser.Builder class.
Interface for retrieving an
OpenApi 3.1 document from a REST resource.Builder class for
OpenApiProvider instances.Represents no OpenApiProvider.
Wrapper bean for the resource class associated with an OpenAPI provider.
Serializes POJOs to values suitable for transmission as HTTP headers, query/form-data parameters, and path variables.
Builder class.
Session object that lives for the duration of a single use of
OpenApiSerializer.Builder class.
Generates an OpenAPI-UI interface from an OpenAPI document.
OpenAPI 3.1 attribute variable resolver — sibling of
SwaggerVar for the OpenAPI 3.1 path.Describes a single API operation on a path.
Describes a single API operation on a path.
Map meant for method-name/operation mappings.
Builder twins of the Operations pages: P6 Jobs (
jobs.ftlh) and P7 Audit (audit.ftlh).Operations: parent of the Jobs and Audit pages.
Extended annotation for
RestOp.swagger().Utility classes and methods for the
@OpSwagger annotation.Builder class.
DTO for an HTML <optgroup>
element.
DTO for an HTML <option>
element.
Ordering hint for beans where lower values have higher precedence.
Order domain bean.
Builder twin of the Orders page (P5,
orders.ftlh).The Orders page and its endpoints: the server-mode datatable query over BeanQuery, the
approve and
deliver status transitions, and the cancel dialog form with its DELETE.Lifecycle status of an
Order.Represents a parsed Origin HTTP request header.
Represents an HTTP Origin header.
DTO for an HTML <output>
element.
Subclass of
Serializer for byte-based serializers.Builder class.
Concrete default builder leaf for the non-subclassed
OutputStreamSerializer.create() / Serializer.copy() path.Subclass of
SerializerSession for stream-based serializers.Builder class.
Concrete default builder leaf for the non-subclassed
create() path (CRTP terminal).DTO for an HTML <p>
element.
Lightweight wrapper around a
Package object providing convenient access to package metadata and annotations.One page of query results, plus the optional counts selected by the session's
CountPolicy.Typed, per-render capture of one console page: theme, header, footer, nav tree, active nav, cards
and slot templates, held as FreeMarker
Environment custom state (see PageCapture.KEY) so every
directive in the render shares one instance.Mutable footer fields; mirrors
$defs/footer.Mutable header fields; mirrors
$defs/header.A nav-tree mutation deferred until the chrome's nav tree exists.
Test helper that extracts the
#juneau-page contract and <template> ids from a
rendered console page, validates them against PageContractSchema, and offers fluent
assertions so adopters assert on the contract instead of on rendered chrome HTML.Loads
juneau-page.schema.json from the classpath and validates contracts against it, plus
the cross-reference rules R-1..R-4 the schema cannot express.The
<@page> shared FreeMarker directive: capture the nested body into PageCapture, resolve the
toolkit= packs, then include the consumer chrome template.Java description of one console page: the active tab, toolkits, page CSS and init scripts, per-request header
fields, the stock theme by name, and the page's cards (tables, html and registered custom types) and body attributes.
DTO for an HTML <param>
element.
Describes a single operation parameter.
Describes a single operation parameter.
Lightweight utility class for introspecting information about a method or constructor parameter.
Static strings used for Swagger parameter types.
Identifies the possible values for the
UonSerializer.Builder.paramFormat(ParamFormat) setting.Identifies a setter method or field for adding a parent reference to a child object.
Utility classes and methods for the
@ParentProperty annotation.Builder class.
Dynamically applies a
@ParentProperty annotation to specified methods or fields.A collection of
@ParentPropertyApply annotations.Utility classes and methods for the
@ParentPropertyApply annotation.Applies targeted
ParentPropertyApply annotations to a Context.Builder.Builder class.
A pairing of
ParquetSerializer and ParquetParser for Apache Parquet binary format.Annotation for customizing Parquet serialization of types and properties.
Utility classes for the
@Parquet annotation.Dynamically applies a
@Parquet annotation to specified classes, methods, or fields.A collection of
@ParquetApply annotations.Utility classes and methods for the
@ParquetApply annotation.Applies targeted
ParquetApply annotations to a Context.Builder.Builder class.
Metadata on bean properties specific to Parquet serializers and parsers.
Metadata on classes specific to Parquet serializers and parsers.
Annotation for configuring Parquet serializer/parser on classes and methods.
Utility classes for the
@ParquetConfig annotation.A collection of
@ParquetConfig annotations.Applies
ParquetConfig annotations to a ParquetParser.Builder.Applies
ParquetConfig annotations to a ParquetSerializer.Builder.How to handle cyclic references when serializing to Parquet.
Interface for providing access to
ParquetClassMeta and ParquetBeanPropertyMeta objects.Parses Apache Parquet binary data into bean collections.
Builder class.
Session for
ParquetParser.Builder for parser sessions.
Builds Parquet schema (list of SchemaElement) from Juneau bean ClassMeta.
A Parquet schema element representing a field in the Parquet schema.
Serializes bean collections to Apache Parquet binary format.
Builder class.
Session for
ParquetSerializer.Builder for serializer sessions.
Simple bean for wrapping non-bean values (Map is not convertible to BeanMap).
Transforms the contents of a
Reader into an Object.Reader transform for reading HTML text.
Reader transform for reading JSON text.
Reader transform for reading plain text.
Reader transform for reading plain text.
Reader transform for reading plain text.
Reader transform for reading XML text.
Exception that indicates invalid syntax encountered during parsing.
Parent class for all Juneau parsers.
Builder class.
Concrete default builder leaf for the non-subclassed
Parser.create() / Parser.copy() path.Represents no Parser.
Utility classes and methods for the
@ParserConfig annotation.Applies
ParserConfig annotations to a InputStreamParser.Builder.Applies
ParserConfig annotations to a Parser.Builder.Applies
ParserConfig annotations to a ReaderParser.Builder.Input stream meant to be used as input for stream-based parsers.
Class for listening for certain parse events during a document parse.
Represents no parser listener.
Represents a parser and media type that matches an HTTP Content-Type header value.
A wrapper around an object that a parser reads its input from.
Similar to a
PushbackReader with a pushback buffer of 1 character.Session object that lives for the duration of a single use of
Parser.Builder class.
Concrete default builder leaf for the non-subclassed
create() path (CRTP terminal).Represents a group of
Parsers that can be looked up by media type.Builder class.
An identifier that the previous entries in this group should be inherited.
An identifier that the previous entries in this group should not be inherited.
REST request multipart/form-data part annotation.
Holds metadata about http part beans (POJOs that get serialized as HTTP parts such as form data or query parameters).
Represents an HTTP 206 Partial Content response.
Represents an HTTP 206 Partial Content response.
Unmodifiable point-in-time snapshot of the enclosing
PartialContent response.Unmodifiable point-in-time snapshot of the enclosing
PartialContent response.A type-safe iterator for
NameValuePair objects.An simple list of HTTP parts (form-data, query-parameters, path-parameters).
An unmodifiable snapshot of a
PartList.Represents no part list in annotations.
REST request path annotation.
Describes the operations available on a single path.
REST request path remainder annotation.
Resolves method parameters annotated with
PathRemainder on RestOp-annotated Java methods.Traversal engine for performing standard REST operations (GET, PUT, POST, DELETE) against nodes in a POJO model.
Generic exception thrown from the
PathTraversal class.Exception representing an HTTP 413 (Payload Too Large).
Represents an HTTP 413 Payload Too Large error response.
Unmodifiable point-in-time snapshot of the enclosing
PayloadTooLarge exception.Unmodifiable point-in-time snapshot of the enclosing
PayloadTooLarge exception.One staged inline edit of a pet field, waiting on the Pending changes page to be applied or discarded.
Lifecycle of a staged change.
The staging area for pet-detail inline edits: edits are staged here instead of mutating the pet, then applied
(perRow, with retry on failure) or discarded (aggregate) from the Pending changes page.
Result of an aggregate discard, mapped 1:1 onto the console's
BulkResult by ChangesRest.One failed id in a
PendingChanges.DiscardOutcome.Supported wire formats for
Period values.Represents an HTTP 308 Permanent Redirect response.
Represents an HTTP 308 Permanent Redirect response.
Unmodifiable point-in-time snapshot of the enclosing
PermanentRedirect response.Unmodifiable point-in-time snapshot of the enclosing
PermanentRedirect response.Save and restore of a dashboard's state topics.
Represents a person, corporation, or similar entity in an Atom document.
Pet domain bean.
Builder twins of the Pets pages: P2 Pets (
pets.ftlh), its ?mixed variant, P3 Sold
(pets-sold.ftlh) and P4 one pet (pet.ftlh).The pets JSON endpoints (server-mode datatable query over BeanQuery, create/replace/delete, sell, stage, and the
per-pet feeds), the Pets and Sold pages, the add/edit dialog form, and the P4 pet pages: Summary (inline edit),
Photo, Orders (with a row detail, and one order selected at nav depth 4) and History, whose nav nodes the page
appends under
pets as p<petId> and o<orderId>.Lifecycle status of a
Pet.The
/petstore API's CSRF boundary: a RequestBoundaryFilter over the framework's CsrfBoundary,
applied to /petstore and everything under it.Typed client view of the petstore pet CRUD surface, consumed via
org.apache.juneau.rest.client.RestClient#remote(Class).Thrown when a petstore operation conflicts with the entity's current state (HTTP 409 at the console layer).
The console's CSRF boundary: a
LoopbackBoundaryFilter applied to /console and everything under it.Base class for every petstore console page resource: registers the console FreeMarker mixin with
base.ftlh as chrome, and injects the shared PetStore.Root of the petstore admin console, mounted at
/console beside the /petstore API and sharing its
PetStore.Thrown by
PetStore when the requested entity does not exist.Petstore CRUD REST resource.
Petstore React SPA demo — serves the no-build single-page React UI from the core classpath.
Result payload for "ping".
A pairing of a
PlainTextSerializer and PlainTextParser into a single class with convenience to/of methods.Annotation that can be applied to classes, fields, and methods to tweak how they are handled by
PlainTextSerializer and PlainTextParser.Utility classes and methods for the
@PlainText annotation.Builder class.
Dynamically applies a
@PlainText annotation to specified classes, methods, or fields.A collection of
@PlainTextApply annotations.Utility classes and methods for the
@PlainTextApply annotation.Applies targeted
PlainTextApply annotations to a Context.Builder.Builder class.
Metadata on bean properties specific to the PlainText serializers and parsers pulled from the
@PlainText
annotation on the bean property.Metadata on classes specific to the PlainText serializers and parsers pulled from the
@PlainText annotation on
the class.Annotation for specifying config properties defined in
PlainTextSerializer and PlainTextParser.Utility classes and methods for the
@PlainTextConfig annotation.Applies
PlainTextConfig annotations to a PlainTextParser.Builder.Applies
PlainTextConfig annotations to a PlainTextSerializer.Builder.Interface for providing access to
PlainTextClassMeta and PlainTextBeanPropertyMeta objects.Parsers HTTP plain text request bodies into Group 5 POJOs.
Builder class.
Session object that lives for the duration of a single use of
PlainTextParser.Builder class.
Response handler for plain-old Java objects when a serializer match is not found and they're asking for plain/text or anything.
Serializes POJOs to plain text using just the toString() method on the serialized object.
Builder class.
Session object that lives for the duration of a single use of
PlainTextSerializer.Builder class.
Reads Playwright's --reporter=json output.
Sample pojo class.
Identifies a class as being a builder for a bean class.
Complex Pojo class.
Format-neutral POJO walker that re-emits an arbitrary object graph through a
TokenWriter.Databind-level settings honored by
PojoWalker.Shared Juneau-controlled redirect loop for SSRF-guard-active (
TransportRequest.isSsrfGuardActive())
@Remote requests.Performs a single pinned HTTP exchange for one hop of a policy-covered redirect chain.
One labelled value in a
CellPopover, bound to a top-level row-data key.Serving-path allowlist of populator names that may be named on a region (
RegionDef.populate).Identifies a position in a reader or input stream.
Interface for objects with positions (lines/columns/byte-positions for example).
Marks a no-arg lifecycle callback invoked after dependency injection.
The PostgreSQL
SqlDialect: the one dialect Juneau ships for the shared JDBC SqlBeanQueryContext.Widget that places a powered-by-Apache message on the page.
Widget that places a powered-by-Juneau message on the page.
Represents a parsed Pragma HTTP request/response header.
Represents an HTTP Pragma header.
DTO for an HTML <pre>
element.
Exception representing an HTTP 412 (Precondition Failed).
Represents an HTTP 412 Precondition Failed error response.
Unmodifiable point-in-time snapshot of the enclosing
PreconditionFailed exception.Unmodifiable point-in-time snapshot of the enclosing
PreconditionFailed exception.Exception representing an HTTP 428 (Precondition Required).
Represents an HTTP 428 Precondition Required error response.
Unmodifiable point-in-time snapshot of the enclosing
PreconditionRequired exception.Unmodifiable point-in-time snapshot of the enclosing
PreconditionRequired exception.Marks a no-arg lifecycle callback invoked during store shutdown.
Utility methods for composing
Predicate instances.Marks a bean contribution as preferred when multiple candidates exist.
Used for assertion calls against arrays.
SPI seam for locale-aware translation of
Problem.getTitle() / Problem.getDetail() (and any other
human-readable fields) before serialization.Aggregator bean for registering multiple
ProblemMappers with a single bean-store entry.Represents an HTTP 102 Processing response.
Represents an HTTP 102 Processing response.
Unmodifiable point-in-time snapshot of the enclosing
Processing response.Unmodifiable point-in-time snapshot of the enclosing
Processing response.A
ConfigStore decorator that layers profile overlays over a delegate store's base config.Builder class.
Merges a base configuration with one or more profile overlays into a single internal-INI string.
DTO for an HTML <progress>
element.
MCP prompt descriptor (
prompts/list entry).MCP prompt descriptor (
prompts/list entry).Declared argument for an MCP prompt.
Declared argument for an MCP prompt.
Server capability flags for prompts.
Server capability flags for prompts.
Single message line inside
GetPromptResult.Single message line inside
GetPromptResult.CompletionReference targeting a declared prompt by name.CompletionReference targeting a declared prompt by name.Params for the
notifications/prompts/list_changed notification.A typed property descriptor that allows you to specify arbitrary consumers and producers
corresponding to setters and getters.
Builder for constructing
Property instances.Interface for custom property extraction strategies in the Bean-Centric Testing framework.
Collection of standard property extractor implementations for the Bean-Centric Testing framework.
Property extractor for array and collection objects with numeric indexing and size access.
Property extractor for Map objects with direct key access and size property.
Standard JavaBean property extractor using reflection.
Tri-state result of a property lookup.
Defines an API for converting conventional bean property names to some other form.
Represents a non-existent class.
Converts property names to dashed-lower-case format.
Converts property names to dashed-upper-case-start format.
Converts property names to underscore-lower-case format.
Exception thrown when a requested property cannot be found on an object.
Interface for pluggable property sources used by
Settings.Provider SPI for augmenting
Settings with additional property sources.A writable extension of
PropertySource that supports modifying property values.Validates a bean-property value against a schema.
Builds
PropertyValidator instances from a JSON-Schema-shaped map of constraints.Discovery helper for
PropertyValidatorFactory via ServiceLoader.Unified property variable resolver.
A pairing of a
ProtobufSerializer and ProtobufParser into a single class with convenience read/write
methods.A pairing of a
PrototextSerializer and PrototextParser into a single class with convenience to/of methods.A
Prototext variant that produces readable (whitespace-padded) Protobuf Text Format output.Lightweight provider interface equivalent to JSR-330 provider contracts.
Represents a parsed Proxy-Authenticate HTTP response header.
Represents an HTTP Proxy-Authenticate header.
Fluent builder for assembling an HTTP Proxy-Authenticate challenge value.
Represents a parsed Proxy-Authorization HTTP request header.
Represents an HTTP Proxy-Authorization header.
Fluent builder for assembling an HTTP Proxy-Authorization credentials value.
DTO for an HTML <q>
element.
Meta-annotation used to declare qualifier annotations.
REST request form-data annotation.
Converter for enabling search/view/sort/paging support on response objects returned by a
@RestOp -annotated method, backed by the BeanQuery engine.
Per-resource limits and defaults for the
Queryable converter.Builder for
QueryableSettings.Widget that returns a menu-item drop-down form for entering BeanQuery search/view/sort/paging arguments
(search /view /sort /position /limit — see
Queryable and
BeanQueryRequest).The query view of a bean class: its readable properties (query columns), its writable properties, and how to create
an instance.
One bean property as BeanQuery sees it: its column name, value type and inferred
SearchType, and how to read
and write it.One item in a table's quick-stats strip (
quickStats.items[]): a plain tile, a meter (one value against a
maximum) or a segmented tile (a proportional bar of labelled counts).The tile's visual tone.
The rail of a dashboard: a column of
Sections beside the panel grid, with a splitter.Random / UUID functions for the
#{...} script catalog.#{rand()} — random double in [0.0, 1.0).#{randChoice(option1, option2, ...)} — variadic.#{randInt(max)} — random int in [0, max).#{randLong(min, max)} — random long in [min, max] (inclusive both ends).#{randString(length)} — random alphanumeric [A-Za-z0-9] string of
length characters.#{uuid()} — random UUID via UUID.randomUUID().Represents a parsed Range HTTP request header.
Represents an HTTP Range header.
Fluent builder for assembling an HTTP Range header value.
Exception representing an HTTP 416 (Range Not Satisfiable).
Represents an HTTP 416 Range Not Satisfiable error response.
Unmodifiable point-in-time snapshot of the enclosing
RangeNotSatisfiable exception.Unmodifiable point-in-time snapshot of the enclosing
RangeNotSatisfiable exception.A rail section of quick time-range presets, with an optional custom from/to.
Token-bucket
RestGuard that throttles requests on a configurable per-request key.Point-in-time view of a single token bucket as exposed by
RateLimitGuard.Storage.snapshot().Builder for
RateLimitGuard.Snapshot of rate-limit state passed to the
onLimitExceeded
callback and used to populate advisory response headers.SPI for storing per-key token-bucket state.
Outcome of a
tryAcquire attempt.Marker interface for objects whose
RawContent.toString() value should be emitted verbatim as raw element
content by the XML and HTML serializers.Engine-agnostic raw-template-dispatch contract shared by the view mixin resources and their
standalone servlet companions.
A re-serializable,
String-backed raw-content wrapper that the XML and HTML serializers emit verbatim.DTO for an HTML <rb>
element.
Annotation for specifying options for RDF serializers.
Utility classes and methods for the
@Rdf annotation.Builder class.
Dynamically applies a
@Rdf annotation to specified classes, methods, or fields.A collection of
@RdfApply annotations.Utility classes and methods for the
@RdfApply annotation.Applies targeted
RdfApply annotations to a Context.Builder.Builder class.
Metadata on beans specific to the RDF serializers and parsers pulled from the
@Rdf annotation on the
class.Metadata on bean properties specific to the RDF serializers and parsers pulled from the
@Rdf annotation
on the bean property.Metadata on classes specific to the RDF serializers and parsers pulled from the
@Rdf annotation on the
class.Used in conjunction with the
@Rdf(collectionFormat) annotation to fine-tune how
classes, beans, and bean properties are serialized, particularly collections.Annotation for specifying config properties defined in
XmlSerializer, XmlDocSerializer, and XmlParser.Utility classes and methods for the
@RdfConfig annotation.Applies
RdfConfig annotations to a RdfParser.Builder.Applies
RdfConfig annotations to a RdfSerializer.Builder.A pairing of a
RdfJsonSerializer and RdfJsonParser into a single class with convenience to/of methods.Subclass of
RdfParser for parsing RDF/JSON into POJOs.Subclass of
RdfSerializer for serializing POJOs to RDF/JSON notation.Namespace name/URL mapping pair.
Parses RDF into POJOs.
Builder class.
Concrete default builder leaf for the non-subclassed
RdfParser.create() / RdfParser.copy() path.Session object that lives for the duration of a single use of
RdfParser.Builder class.
A pairing of
RdfProtoSerializer and RdfProtoParser for RDF/PROTO binary format.Stream-based RDF parser for RDF/PROTO binary format.
Stream-based RDF serializer for RDF/PROTO binary format.
Identifies the default RDF namespaces at the package level.
Serializes POJOs to RDF.
Builder class.
Concrete default builder leaf for the non-subclassed
RdfSerializer.create() / RdfSerializer.copy() path.Session object that lives for the duration of a single use of
RdfSerializer.Builder class.
Stream-based RDF parser for binary formats (RDF/THRIFT, RDF/PROTO).
Builder class.
Concrete default builder leaf for the non-subclassed
RdfStreamParser.create() / RdfStreamParser.copy() path.Session object that lives for the duration of a single use of
RdfStreamParser.Builder class.
Stream-based RDF serializer for binary formats (RDF/THRIFT, RDF/PROTO).
Builder class.
Concrete default builder leaf for the non-subclassed
RdfStreamSerializer.create() / RdfStreamSerializer.copy() path.Session for stream-based RDF serialization (binary formats like RDF/THRIFT, RDF/PROTO).
Builder class.
A pairing of
RdfThriftSerializer and RdfThriftParser for RDF/THRIFT binary format.Stream-based RDF parser for RDF/THRIFT binary format.
Stream-based RDF serializer for RDF/THRIFT binary format.
Utility classes.
A pairing of a
RdfXmlSerializer and RdfXmlParser into a single class with convenience to/of methods.A pairing of a
RdfXmlAbbrevSerializer and RdfXmlParser into a single class with convenience to/of methods.Subclass of
RdfSerializer for serializing POJOs to RDF/XML-Abbrev (abbreviated XML notation).Subclass of
RdfParser for parsing RDF/XML into POJOs.Subclass of
RdfSerializer for serializing POJOs to RDF/XML (standard XML notation).Response processor that bridges Reactive Streams
return values from
@RestOp handlers to Juneau's response pipeline.SPI that bridges a third-party reactive return type to one of the two JDK-native shapes that the
ReactiveResponseProcessor understands: a CompletionStage (single value) or a
Flow.Publisher (a stream of values).Catch-all
ReactiveStreamsAdapter for any
Reactive-Streams
org.reactivestreams.Publisher<T> that is not already
handled by a more specific adapter.ReactiveStreamsAdapter for Project Reactor
return types.A streamed, non-repeatable entity that obtains its content from an
Reader.Unmodifiable point-in-time snapshot of the enclosing
ReaderEntity.InputStream implementation that reads a character stream from a Reader
and transforms it to a byte stream using a specified charset encoding.Subclass of
Parser for character-based parsers.Builder class.
Concrete default builder leaf for the non-subclassed
ReaderParser.create() / Parser.copy() path.Resolves method parameters of type
ReaderParser on RestOp-annotated Java methods.Subclass of parser session objects for character-based parsers.
Builder class.
Concrete default builder leaf for the non-subclassed
create() path (CRTP terminal).Response processor for
Reader objects.A streamed, non-repeatable resource that obtains its content from an
Reader.An unmodifiable snapshot of a
ReaderResource.Transforms
Readers to Strings.Shared, observable readiness flag consumed by
HealthAggregator to gate the readiness probe.Implemented by servlets that want to be told the embedded server's per-service
ReadinessState, so they
can react when shutdown begins (see ReadinessState.onOutOfService(Object, Runnable)).Parameters for "resources/read".
Parameters for "resources/read".
Result payload for "resources/read".
Result payload for "resources/read".
Static factories that produce buffered
RecordReader / RecordWriter instances for
formats whose token-stream surface is whole-value-only (no native TokenReader /
TokenWriter).Capability role for objects that can open a whole-value
RecordReader cursor.Public low-level whole-value pull cursor over a Juneau-formatted document.
Resolves method parameters of type
RecordReader (or any subtype) on
RestOp-annotated Java methods.Wrapper that lets a caller pass a
Consumer<RecordWriter> or
Consumer<TokenWriter> as the body of a @RemoteOp request.A streaming HTTP request body that emits its content through a token/record-streaming cursor.
Capability role for objects that can open a whole-value
RecordWriter cursor.Public low-level whole-value push generator over a Juneau-formatted document.
Resolves method parameters of type
RecordWriter (or any subtype) on
RestOp-annotated Java methods.Utility for masking the values of header names that commonly carry account credentials
(bearer tokens, session cookies, API keys, and the like) before they are written somewhere
observable, such as a log line or an echoed-back response body.
Pure decision logic for whether caller-set credential headers (such as
Authorization
or Cookie) should be forwarded or stripped when a REST call is transparently replayed
against a redirect target (an HTTP 3xx response's Location).The outcome of a credential-forwarding decision for a single redirect hop.
Mixin that publishes the Redoc HTML view at
/redoc for the OpenAPI 3.1 spec.Generates a Redoc-style documentation interface from an OpenAPI 3.1 document.
Represents a parsed Referer HTTP request header.
Represents an HTTP Referer header.
Maps arbitrary values to classes, methods, fields, and constructors based on name-based patterns.
Builder for creating
ReflectionMap instances.Utility class providing convenient static methods for creating reflection info objects.
Regex functions for the
#{...} script catalog.#{extract(s, regex)} / #{extract(s, regex, group)} — replacement for the
legacy $PE{...}.#{match(s, regex)} — replacement for the legacy $PM{...}.#{replaceRegex(s, regex, replacement)} — replacement for the legacy $PR{...}.A page "region": a named container whose contents a client-side populator fills in, chosen by name via
RegionDef.populate rather than declared inline.One entry in the field catalog: a label, an optional named renderer and its meta, an
optional href template, a paint format, a grid span, and per-field action-bar ids.
Builds the server-rendered delivery tree for a
RegionDef — an empty
data-juneau-region container plus one sidecar per host carrying every region descriptor that host
declares.A signed, relative-to-request-time duration value: wire literal
[+-]<n>(ms|s|m|h|d) (a request-time offset
that stays a plain literal on the wire).The duration unit, with its lowercase wire token (design review §3 Gap 2).
A
PropertySource decorator that adds relaxed binding over a delegate source.Identifies a proxy against a REST interface.
Creates Java proxy instances for
Remote-annotated interfaces, backed by an RestClient.Annotation applied to Java methods on REST proxy interface classes.
Annotation applied to Java methods on REST proxy interface classes.
Contains the meta-data about a REST proxy class.
Exceptions caused by invalid REST proxy classes.
Annotation applied to Java methods on REST proxy interface classes.
Represents the metadata about an annotated argument of a method on a REST proxy class.
Represents the metadata about an
Request-annotated argument of a method on a REST proxy class.Contains the meta-data about a Java method on a REST proxy class.
Represents the metadata about the returned object of a method on a remote proxy interface.
Annotation applied to Java methods on REST proxy interface classes.
Annotation applied to Java methods on REST proxy interface classes.
Shared helpers for the classic REST-proxy engine.
Annotation applied to Java methods on REST proxy interface classes.
Possible values for the
@RemoteOp(returns) annotation and the returns attribute on
RemoteGet, RemotePost, RemotePut, RemotePatch, and RemoteDelete.Resolves the
InetAddress candidates for a hostname.A validated, parsed per-client allow-list of special-purpose address ranges, the per-client counterpart of the
"RestClient.allowAddressRanges" system property.
Marks the current thread as executing an SSRF-guard-active
@Remote call, for the duration of one
blocking RestRequest.run() (including any internal retries/redirect hops it triggers on the same
thread).Utilities.
The JSON Patch
"remove" operation per
RFC 6902 § 4.2.A named cell-renderer reference in the
VIEW_META wire contract.The JSON Patch
"replace" operation per
RFC 6902 § 4.3.SPI for detecting reuse ("replay") of a one-time-use identifier.
The policy applied by
ReplayCache.checkAndRecord(String, long, FailMode, Consumer) when
ReplayCache.checkAndRecord(String, long) throws (the backing store could not answer).Bounds applied while reading a report, so a hostile or runaway file cannot exhaust memory.
Reads one test-report format.
Picks a
ReportReader by report kind.What a
ReportReader recovered from a report.One test recovered from a report.
Text helpers shared by the report readers.
Request bean annotation.
Represents a single request attribute on an HTTP request.
Represents the attributes in an HTTP request.
Request attribute variable resolver.
Represents the metadata gathered from a parameter or class annotated with
Request.Represents the metadata gathered from a getter method of a class annotated with
Request.Describes a single request body.
Decides whether a request came from a page this application served, and supplies the CSRF token such a page embeds.
Applies a
RequestBoundary to every request reaching the servlet container, rejecting those that did not
come from a page this application served.The
Supplier<String> this filter publishes under RequestBoundaryFilter.TOKEN_SUPPLIER_ATTRIBUTE.Contains the content of the HTTP request.
Request form data variable resolver.
Represents a single form-data parameter on an HTTP request.
Represents the parsed form-data parameters in an HTTP request.
Represents a single header on an HTTP request.
Exception representing an HTTP 431 (Request Header Fields Too Large).
Represents an HTTP 431 Request Header Fields Too Large error response.
Unmodifiable point-in-time snapshot of the enclosing
RequestHeaderFieldsTooLarge exception.Unmodifiable point-in-time snapshot of the enclosing
RequestHeaderFieldsTooLarge exception.Represents the headers in an HTTP request.
Request header variable resolver.
Represents a single HTTP part on an HTTP request.
Shared constants for the
X-Request-Id correlation-id contract.Thin configuration façade over the always-on request-id correlation resolver.
Builder for
RequestIdFilter.Configuration for the always-on request-id correlation resolver run at
RestSession build time.Builder for
RequestIdSettings.Opaque per-request MCP metadata carried under the JSON-RPC
params._meta property.CRTP base for MCP
2026-07-28 request params carrying optional negotiation/trace metadata under the
reserved _meta wire key.Metadata-only request params carrier for v2 methods whose only common params member is
_meta.Represents a single path parameter on an HTTP request.
Represents the path parameters in an HTTP request.
Request path variable resolver.
Represents a single query parameter on an HTTP request.
Represents the query parameters in an HTTP request.
Request query variable resolver.
Pluggable SPI for sealing/unsealing the opaque
requestState continuation token (MCP 2026-07-28
SEP-2322 Multi-Round-Trip Requests).Rest info variable resolver.
Request attribute variable resolver.
Represents an HTTP 205 Reset Content response.
Represents an HTTP 205 Reset Content response.
Unmodifiable point-in-time snapshot of the enclosing
ResetContent response.Unmodifiable point-in-time snapshot of the enclosing
ResetContent response.A
BeanQuery after validation: the engine-neutral input to every engine hook.One sort key: its column, the column's value type, and the direction.
Subclass of a
MarshalledMap that automatically resolves any SVL variables in values.MCP resource descriptor (
resources/list entry).MCP resource descriptor (
resources/list entry).Class-related utility methods.
Server capability flags for resources.
Server capability flags for resources.
Polymorphic MCP resource body (text or base64 blob).
Polymorphic MCP resource body (text or base64 blob).
Shortcut label for child resources.
A list of
ResourceDescription objects.Params for the
notifications/resources/list_changed notification.A supplier of a REST resource bean.
MCP resource-template descriptor (
resources/templates/list entry).MCP resource-template descriptor (
resources/templates/list entry).CompletionReference targeting a registered resource template by its exact URI-template string.CompletionReference targeting a registered resource template by its exact URI-template string.Params for the
notifications/resources/updated notification: a specific subscribed resource's
content changed.Describes a single response from an API operation.
REST response annotation.
Utility classes and methods for the
@Response annotation.Builder class.
A fluent assertion class for validating
RestResponse instances.Represents the metadata gathered from a parameter or class annotated with
Response.Response handler for
@Response-annotated objects.Represents the metadata gathered from a getter method of a class annotated with
Response.A fluent accessor for an HTTP response body returned by
RestResponse.A fluent assertion class for HTTP response bodies.
Resolves method parameters annotated with
StatusCode on RestOp-annotated Java methods.Represents the body of an HTTP response.
Represents a single header on an HTTP response.
A fluent accessor for a named HTTP response header.
A fluent assertion class for a named HTTP response header.
Describes a single response from an API operation.
Represents the information needed to serialize a response part such as a response header or content.
Defines the interface for processors that convert POJOs to appropriate HTTP responses.
A list of
ResponseProcessor objects.Builder class.
An implementation of
StatusLine that adds assertions methods.Used to denote that a class is a REST resource and to associate metadata on it.
Utility classes and methods for the
@Rest annotation.Builder class.
Implements the 'restart' console command to gracefully shut down and restart the microservice.
Resource-level authentication SPI for
@Rest resources.Sentinel "unset" type for
@Rest(authenticator=...);
never authenticates.Public, fluent, self-typed configuration surface for programmatically configuring a
@Rest resource,
child resource, or mixin instead of (or in addition to) the @Rest annotation.Exception representing a 400+ HTTP response code against a remote resource or other exception.
Exception thrown when an HTTP call fails at the REST client level (e.g. unexpected status code, body
deserialization failure, or interceptor rejection).
Interface that allows you to override the handling of HTTP requests.
Used to intercept http connection responses to allow modification of that response before processing and for
listening for call lifecycle events.
Lifecycle interceptor for REST calls made by
RestClient.Represents a matched
Rest-annotated child on an HTTP request.Implements the child resources of a
Rest-annotated class.Builder class.
Utility class for interfacing with remote REST interfaces.
Next-generation transport-agnostic REST client.
Builder class.
Fluent builder for
RestClient.Concrete default builder leaf for the non-subclassed
RestClient.create() / RestClient.copy() path.Per-tier formatter for JUL-level-driven REST client debug logging.
Defines the initial configuration of a RestServlet or @Rest annotated object.
Bootstrap arguments for
RestContext.The build-time kind of a
RestContext — which of the three construction flavors produced it.A routed child resource (mounted via
Rest.children()/Rest.childrenDefs()); isolated
resolution, with an optional host-seeded @Child payload injected at the least-derived slot of
its own annotation chain (see the class javadoc above).A per-mixin sub-context (composed via
Rest.mixins()/Rest.mixinDefs()); inherits the host chain.A top-level (host) resource, mock context, or servlet-mounted resource.
Normalized carrier for a routed child, produced by discovery from either a bare
Rest.children()
class or a rich @Child declaration — the exact structural analog of
RestContext.ResolvedMixin.The discovery-time normalized declaration of a single mixin.
Resolves method parameters on
RestOp-annotated Java methods of types found on the RestContext object.The env-driven
RestContext.* default properties for a resource, resolved as a single bound object.A snapshot of execution statistics for REST resource classes.
REST method response converter.
A list of
RestConverter objects.Builder class.
Optional operator-supplied transform applied to request/response body text before it is written to a REST debug log.
Per-tier formatter for JUL-level-driven REST debug logging.
The request-completion half of the JUL-level-driven REST debug pipeline.
Identifies a REST DELETE operation Java method on a
RestServlet implementation class.Utility classes and methods for the
@RestDelete annotation.Builder class.
Identifies a method that gets called during servlet destroy.
Utility classes and methods for the
@RestDestroy annotation.Builder class.
Identifies a method that gets called right before we exit the servlet service method.
Utility classes and methods for the
@RestEndCall annotation.Builder class.
Identifies a REST GET operation Java method on a
RestServlet implementation class.Utility classes and methods for the
@RestGet annotation.Builder class.
REST method guard.
A list of
RestGuard objects.Builder class.
Identifies a method that gets called during servlet initialization.
Utility classes and methods for the
@RestInit annotation.Builder class.
Class used for defining method-level matchers using the
@RestOp(matchers) annotation.A list of
RestMatcher objects.Builder class.
Optional base class for @Rest mixin classes — the third sibling of
RestServlet
(servlet flavor) and RestResource (child-resource flavor), completing the
servlet / resource / mixin naming triad.Fluent builder for programmatically configuring a
RestMixin subclass.Concrete default leaf builder returned by
RestMixin.builder(Class) for the common (non-subclassed)
case.Identifies a REST operation Java method on a
RestServlet implementation class.Utility classes and methods for the
@RestOp annotation.Builder class.
REST java method parameter resolver.
A list of
RestOpArg classes.Builder class.
Represents a single Java servlet/resource method annotated with
@RestOp.Resolves method parameters on
RestOp-annotated Java methods of types found on the RestOpContext object.Aggregates the HTTP method, URL, and optional body into a single bean.
Builder class.
A specialized invoker for methods that are called during a servlet request.
A session for a single HTTP request.
Builder class.
Resolves method parameters on
RestOp-annotated Java methods of types found on the RestOpSession object.Identifies a REST OPTIONS operation Java method on a
RestServlet implementation class.Utility classes and methods for the
@RestOptions annotation.Builder class.
Represents the possible parameter types as defined by the Swagger 2.0 specification.
Identifies a REST PATH operation Java method on a
RestServlet implementation class.Utility classes and methods for the
@RestPatch annotation.Builder class.
Identifies a REST POST operation Java method on a
RestServlet implementation class.Utility classes and methods for the
@RestPost annotation.Builder class.
Identifies a method that gets called immediately after the @RestOp annotated method gets called.
Utility classes and methods for the
@RestPostCall annotation.Builder class.
Identifies a method that gets called immediately after servlet initialization.
Utility classes and methods for the
@RestPostInit annotation.Builder class.
Identifies a method that gets called immediately before the @RestOp annotated method gets called.
Utility classes and methods for the
@RestPreCall annotation.Builder class.
Identifies a REST PUT operation Java method on a
RestServlet implementation class.Utility classes and methods for the
@RestPut annotation.Builder class.
Represents a request to a remote REST resource.
Fluent builder for a single HTTP request.
Represents an HTTP request for a REST resource.
Resolves method parameters on
RestOp-annotated Java methods of types found on the RestRequest object.Identify an
HttpRequest that was created by a RestRequest.TextMapGetter implementation that reads HTTP request headers from a RestRequest.Identical to
RestServlet but doesn't extend from HttpServlet.Fluent builder for programmatically configuring a
RestResource subclass.Concrete default leaf builder returned by
RestResource.builder(Class) for the common (non-subclassed)
case.Represents a response from a remote REST resource.
An HTTP response returned by
RestRequest.run().Represents an HTTP response for a REST resource.
Resolves method parameters on
RestOp-annotated Java methods of types found on the RestResponse object.Servlet implementation of a REST resource.
Fluent builder for programmatically configuring a
RestServlet subclass.Concrete default leaf builder returned by
RestServlet.builder(Class) for the common (non-subclassed)
case, so callers are not forced to spell the SELF type parameter.Represents a single HTTP request.
Builder class.
Resolves method parameters on
RestOp-annotated Java methods of types found on the RestSession object.Static constants shared across Juneau REST modules (for example
juneau-rest-server,
juneau-rest-client, and juneau-rest-mock) so wire names and other cross-tier
strings stay aligned.Identifies a method that is called immediately after the HttpServlet.service(HttpServletRequest, HttpServletResponse)
method is called.
Utility classes and methods for the
@RestStartCall annotation.Builder class.
Various reusable utility methods.
CRTP base for every successful MCP
2026-07-28 result, carrying the required resultType
discriminator and optional ResultMeta under the reserved _meta wire key.Opaque per-result MCP metadata carried under the JSON-RPC
result._meta property.Transforms an SQL
ResultSet into a list of maps.Represents a parsed Retry-After HTTP response header.
Represents an HTTP Retry-After header.
A reversed view of a list that does not modify the underlying list.
One ribbon (toolbar) entry above a table.
Extended logger that provides convenience methods for logging formatted messages.
Builder for creating configured
RichLogger views.Role for
PromptMessage entries (MCP wire uses lowercase strings).Role for
PromptMessage entries (MCP wire uses lowercase strings).RestGuard that uses role expressions to determine whether an authenticated user has access to a class or method.Utility class for matching JEE user roles against string expressions.
Root router resource for the Jetty deployment.
Root router resource for the Spring Boot deployment.
Client roots capability.
Client roots capability.
Describes a single route (an
@RestOp-annotated method) in a route-index listing.A list of
RouteDescription objects.Mixin that exposes a content-negotiated index of all
@RestOp-annotated methods on the
host resource (and any other mixins on it) at /options (configurable).A per-row action descriptor in the
VIEW_META wire contract (the transport-agnostic
"row-action intent" model).How an action behaves when driven from a bulk-mutate toolbar.
The non-safe HTTP method a row action submits with.
What the runtime does with a successful action result.
How a row action's form/confirmation is presented.
The visual tone of a row action's confirmation.
A declarative disable-with-reason rule gating a
RowAction on the row's own state, in the
VIEW_META wire contract.Row-detail panel for a table: the per-row GET endpoint, title template, icon and the row-detail region.
The action-envelope submit of a row job:
{action, targetId, idempotencyKey, fields}, the shape the
row-action dialog and the job-log card's envelope: "action" both send.DTO for an HTML <rp>
element.
Contains the meta-data about a remote proxy REST interface.
Holds resolved metadata for an interface annotated with
@Remote.Contains the meta-data about a Java method on a remote class.
Holds resolved metadata for a single method on an interface annotated with
Remote.Method-level content negotiation: the
accept and contentType media-type
overrides sourced from @RemoteOp/verb-annotation members.Method-level cross-cutting call policy: interceptors, per-call timeout, retries, and the
generic
throwOnError flag, sourced from @RemoteOp/verb annotation members.A specialized "RRPC" HTTP methods.
RestOpContext for handling A session for a single HTTP request against an RRPC Java method.
Builder class.
Abstract class for defining Remote Interface Services.
DTO for an HTML <rt>
element.
DTO for an HTML <rtc>
element.
DTO for an HTML <ruby>
element.
Unchecked wrapper used by the
iterator(...) /
stream(...) views to surface the checked
IOException / ParseException cause
through the Iterator / Stream API.ReactiveStreamsAdapter for RxJava 3
return types.DTO for an HTML <s>
element.
A client-only
ActionBarItem with no endpoint.Shared, dependency-free predicates for validating same-origin request paths declared by higher layers, plus
the single
polling floor those layers clamp declared poll intervals to.Validates a SAML 2.0
<samlp:Response> document and produces a ClaimsPrincipal marked
with issuerType=SAML.Builder for
SamlAssertionValidator.AuthFilter that authenticates requests carrying a SAML 2.0 <samlp:Response> delivered via
the SamlBinding.POST or SamlBinding.REDIRECT HTTP binding.Builder for
SamlAuthFilter.SAML 2.0 bindings supported by
SamlAuthFilter for delivering a <Response> from an IdP to the SP.Convenience factories for building
MetadataResolver instances backed by an OpenSAML implementation.DTO for an HTML <samp>
element.
Sample root REST resource.
Client sampling capability marker (MCP sampling): presence on
ClientCapabilities.getSampling() signals the client understands "sampling/createMessage".One message in
CreateMessageRequest.getMessages() (MCP sampling).Swagger/OpenAPI/JSON Schema annotation.
A collection of
@Schema annotations.Utility classes and methods for the
@Schema annotation.Builder class.
Dynamically applies a
@Schema annotation to specified classes, methods, or fields.A collection of
@SchemaApply annotations.Utility classes and methods for the
@SchemaApply annotation.Applies targeted
SchemaApply annotations to a Context.Builder.Builder class.
Allows the definition of input and output data types.
Allows the definition of input and output data types.
Utilities for working with the schema annotations.
Exception thrown when an HTTP part fails schema validation.
Lifecycle scope for a
@TestBean-declared override.Handle to one in-flight
TracerHook-managed span.DTO for an HTML <script>
element.
One node of the parse tree produced by
SearchExpressionParser: the resolved, validated form of a column's
$-search expression that a context walks to filter rows or build SQL.The single public parser for the
$-search language (design §5.1).The immutable definition of a single
$-search operator — its $-name, arity, the value types
it applies to, and its popup help text.Builder for
SearchOperator.An immutable, ordered collection of
SearchOperators that governs which $-operators the parser
recognizes.The leaf predicate an application supplies for a custom search operator so the in-memory context can evaluate
it against a cell value (design §5.3).
A rail section with one text input.
The SQL callback an application supplies for a custom search operator (design §5.3) so a SQL context can
render it into a
WHERE clause.The per-column value type that governs which search operators apply to a column and how a bare (no leading
$) pattern token is interpreted.SPI for storing and retrieving a secret by key — the secure, mutable sibling of
PropertySource.Opt-in bridge that exposes a chosen
SecretStore as a PropertySource, so a secret can be resolved
through the property/$P{...}/@Value machinery only where a consumer deliberately wires it in.Provider SPI for contributing a
SecretStore via ServiceLoader.Resolution helpers for selecting the active
SecretStore.DTO for an HTML <section>
element.
A single section in a config file.
A section of a dashboard
Rail.A section implemented in JS.
The bearer-token protected API behind the Secure page.
A guided walkthrough of calling
SecuredExampleMcpServer, showing the secured request/response
cycle a newcomer to MCP OAuth 2.1 needs to see: a rejected unauthenticated call (twice — once at the
raw wire level, once through the real McpClient SDK), the full RFC 9728 → RFC 8414 discovery
chain, a successful read-only call, a scoped step-up rejection, and finally a successful write once a token
carrying the write scope has been acquired.The OAuth 2.1-secured variant of
ExampleMcpServer: identical notes-service surface (tools, prompt,
resources, resource template, subscriptions), but every POST / JSON-RPC call now requires a valid
bearer token.Boots
SecuredExampleMcpServer on an embedded Jetty server, alongside an in-process
OfflineAuthorizationServer that stands in for a real OAuth 2.1 authorization server.Secure: an open console page demonstrating the bearer-token guarded
SecureApiRest.Lists the required security schemes for this operation.
Allows the definition of a security scheme that can be used by the operations.
Defines a security scheme that can be used by the operations.
Represents an HTTP 303 See Other response.
Represents an HTTP 303 See Other response.
Unmodifiable point-in-time snapshot of the enclosing
SeeOther response.Unmodifiable point-in-time snapshot of the enclosing
SeeOther response.Convenience subclass of
SeeOther for redirecting a response to the servlet root.DTO for an HTML <select>
element.
The row-selection opt-in for a
ViewTable — the first of the view table's two INDEPENDENT
opt-ins.Where a
SelectionDef's row selection lives across a view's lifetime.Marker specialization of
PropertySource whose values are sensitive and must be redacted anywhere they
would otherwise be surfaced — a toString(), a settings dump, or a log line.Mixin that serves SEO-conventional endpoints
/robots.txt and /sitemap.xml.Builder for
SeoMixin instances.Single sitemap entry (immutable).
HttpEntity for serializing POJOs as the body of HTTP requests.
Unmodifiable point-in-time snapshot of the enclosing
SerializedEntity.See Also:
Subclass of
NameValuePair for serializing POJOs as URL-encoded form post entries using the
class.Response handler for plain-old Java objects.
Serialized request attribute variable resolver.
General exception thrown whenever an error occurs during serialization.
Parent class for all Juneau serializers.
Builder class.
Concrete default builder leaf for the non-subclassed
Serializer.create() / Serializer.copy() path.Represents no Serializer.
A repeatable
HttpBody that serializes a POJO straight to the transport output stream.Annotation for specifying config properties defined in
Serializer, OutputStreamSerializer, and WriterSerializer.Utility classes and methods for the
@SerializerConfig annotation.Applies
SerializerConfig annotations to a OutputStreamSerializer.Builder.Applies
SerializerConfig annotations to a Serializer.Builder.Applies
SerializerConfig annotations to a WriterSerializer.Builder.Class for listening for serialize events during a serialization.
Represents no serializer listener.
Represents a serializer and media type that matches an HTTP Accept header value.
A wrapper around an object that a serializer sends its output to.
Serializer session that lives for the duration of a single use of
Serializer.Builder class.
Concrete default builder leaf for the non-subclassed
create() path (CRTP terminal).Represents a group of
Serializers that can be looked up by media type.Builder class.
An identifier that the previous entries in this group should be inherited.
An identifier that the previous entries in this group should not be inherited.
Simple wrapper around a standard
Writer with additional methods.Answers a console data source's aggregate request in one pass over a row stream.
A parsed aggregate request.
A rejected aggregate request: HTTP 400 with an E-75 message.
An aggregate result in columnar form: the dims, their types, and one value list per dim.
Streams rows to a console data source as CSV or NDJSON.
The output format.
One row;
SeriesSource.Row.get(String) returns the value for a column, or null.An object representing a Server.
Represents a parsed Server HTTP response header.
Represents an HTTP Server header.
The server half of the console message bus: a retained-value store plus the sessions that bridge it to pages.
MCP server capability advertisement in
InitializeResult.MCP server capability advertisement returned by
ServerDiscoverResult.Result payload for "server/discover".
A
Widget-marked declaration of named server-side scalar values.An internal, per-render resolver for a single
ServerValues declaration.An immutable named server-side scalar value declaration held by a
ServerValues bean.The "$FV{name}" / "$FV{name,default}" server-values variable.
The ServerVariable Object represents a server variable for server URL template substitution.
Exception representing an HTTP 503 (Service Unavailable).
Represents an HTTP 503 Service Unavailable error response.
Unmodifiable point-in-time snapshot of the enclosing
ServiceUnavailable exception.Unmodifiable point-in-time snapshot of the enclosing
ServiceUnavailable exception.A servlet filter, with the URL patterns, dispatcher types and order it is mounted at, that the server components
(
JettyServerComponent, TomcatServerComponent) mount before the server starts.Builder for
ServletFilterRegistration.Servlet init parameter variable resolver.
SPI for persisting
OidcSession instances and resolving them back from a session-cookie value.A fluent builder for constructing
Set instances with various configuration options.A memoizer that provides convenience methods for type conversion.
Encapsulates Java system properties with support for global and per-thread overrides for unit testing.
Builder for creating Settings instances.
A simple mutable short value.
Terse alias facade for the domain utility classes.
Provides the capability to shut down this REST microservice through a REST call.
How the process is stopped.
Stateless
SessionStore that serializes the session into an HMAC-signed compact JWT carried
entirely in the session cookie.Builder.
Utility class for creating custom HTML.
A simple auto-closeable wrapper around a
Lock that automatically acquires the lock
when created and releases it when closed.An unmodifiable, fixed-size map implementation backed by parallel key and value arrays.
An implementation of
HttpPartParser that takes in the strings and tries to convert them to POJOs using constructors and static create methods.Builder class.
Session object that lives for the duration of a single use of
SimplePartParser.An implementation of
HttpPartSerializer that simply serializes everything using Object.toString().Builder class.
Session object that lives for the duration of a single use of
SimplePartSerializer.An extension of
ReentrantReadWriteLock with convenience methods for creating
auto-closeable locks that work seamlessly with try-with-resources statements.An implementation of a
RestOpArg that takes in a ThrowingFunction for resolving a parameter value.Abstract superclass of all Simple Var Language variables that resolve to simple returned string values.
Scope marker indicating one instance per
BeanStore.Serving-path allowlist of renderer ids that may be named on a fill sink
(a field-grid catalog
render entry or PopoverField.render).Functional interface for computing the size of objects in test assertions.
DTO for an HTML <small>
element.
Opaque handle for a single pushed overlay frame on a
WritableBeanStore.A functional interface identical to
Runnable but allows the Snippet.run() method to throw checked exceptions.Annotation that can be applied to classes, fields, and methods to tweak how they are handled by
SoapXmlSerializer}.Utility classes and methods for the
@SoapXml annotation.Builder class.
Dynamically applies a
@SoapXml annotation to specified classes, methods, or fields.Utility classes and methods for the
@SoapXmlApply annotation.Applies targeted
SoapXmlApply annotations to a Context.Builder.Builder class.
Metadata on bean properties specific to the SOAP/XML serializers and parsers pulled from the
@SoapXml
annotation on the bean property.Metadata on classes specific to the SOAP/XML serializers and parsers pulled from the
@SoapXml annotation on
the class.Annotation for specifying config properties defined in
SoapXmlSerializer.Utility classes and methods for the
@SoapXmlConfig annotation.Applies
SoapXmlConfig annotations to a SoapXmlSerializer.Builder.Interface for providing access to
SoapXmlClassMeta and SoapXmlBeanPropertyMeta objects.Serializes POJOs to HTTP responses as XML+SOAP.
Builder class.
Session object that lives for the duration of a single use of
SoapXmlSerializer.Builder class.
A sorted list implementation backed by an
ArrayList.A sorted list implementation backed by a
LinkedList.Represents metadata from the source feed when an entry is copied from one feed to another.
DTO for an HTML <source>
element.
DTO for an HTML <span>
element.
Pet species enumeration.
A bean store that uses Spring bean resolution to find beans if they're not already in this store.
A minimal Spring Boot application that serves
SpringExampleMcpServer on embedded Tomcat.The Spring Boot flavor of the MCP server.
Convenience base class exposing a
2025-06-18 MCP endpoint on a Spring Boot resource with full
Spring dependency-injection support.Convenience base class exposing a
2026-07-28 MCP endpoint on a Spring Boot resource with full
Spring dependency-injection support.Subclass of a
RestServlet that hooks into Spring Boot for using Spring Beans.The shared JDBC
BeanQueryContext: renders validated queries into SQL for a SqlDialect and runs
them on a connection from a configured source.Builder for
SqlBeanQueryContext.A
BeanQuerySession on one JDBC connection.Builder for
SqlBeanQuerySession.The SQL-generation strategy for a SQL
BeanQueryContext: it quotes identifiers, renders each built-in
$-operator into a dialect-correct predicate, and renders pagination.A parameterized SQL predicate fragment: a boolean SQL expression plus the ordered bind values its
?
placeholders consume.Turns the current
ResultSet row into a bean, for BeanQuerySession.find(BeanQuery) and
BeanQuerySession.stream(BeanQuery).A fully-rendered SQL statement: the text (with
? placeholders) plus its ordered bind values, and the
selected column names in SELECT order.Example of a
ConfigStore that uses a relational database as a backend.Builder class.
Pairs text/event-stream wire format.
SseSerializer and SseParser into a single class with convenience
read/write methods for the In-memory server-side SSE broadcaster.
Resolves
SseBroadcaster method parameters.Represents a single Server-Sent Event
(SSE) frame on the wire.
Line-driven text/event-stream .
Iterator over the events in a Scheduled SSE heartbeat.
Parses text/event-stream input (WHATWG Server-Sent Events) into Java objects.
Builder class.
Session object that lives for the duration of a single use of
SseParser.Builder class.
Fluent SSE response helper.
Serializes text/event-stream wire format defined by the
WHATWG Server-Sent Events spec.
SseEvent objects to the Builder class.
Session object that lives for the duration of a single use of
SseSerializer.Builder class.
Subscriber queue for an
SseBroadcaster.Resolves
SseSubscription method parameters.Stack-aware
BeanStore overlay.Transforms
StackTraceElements to String objects.Enumeration of state machine states for use in parsing operations.
API for retrieving localized static files from either the classpath or file system.
Builder class.
Represents no static files
Mixin that serves static files from the active
StaticFiles implementation under
/static/* (configurable).Child-resource flavor of the static-files capability.
Standalone servlet companion of the
StaticFilesMixin mixin.Built-in, immutable, static-at-startup
KeyProvider: an operator-supplied keyring of one or more AES
keys, one of which is designated the current sealing key.Builder for
StaticKeyProvider.Mixin providing the residual
[GET /stats] timing-statistics endpoint.REST response status annotation.
The one closed status-tone palette shared by every surface that paints a semantic status colour:
info / success / warning / error / neutral.Builder twin of the Store page (P1,
store.ftlh).The Store page's quick-stat tiles, shared by both render paths.
The Store page, the petstore dashboard, and the feeds its charts, tiles and fragments read.
A non-repeatable
HttpBody that streams content from an InputStream.Abstract superclass of all Simple Var Language variables that write their values directly to a writer.
A streamed, non-repeatable entity that obtains its content from an
InputStream.Unmodifiable point-in-time snapshot of the enclosing
StreamEntity.O(1)-memory wrappers that adapt a fine-grained
TokenReader / TokenWriter to
the array-element record-stream contract.A subclass of
Marshaller for stream-based serializers and parsers.A streamed, non-repeatable resource that obtains its content from an
InputStream.An unmodifiable snapshot of a
StreamResource.Used for assertion calls against string objects.
An
HttpBody backed by a UTF-8 string.Identifies the exact static factory method to use for creating an instance of a POJO from a string.
A self contained, repeatable entity that obtains its content from a
String.Unmodifiable point-in-time snapshot of the enclosing
StringEntity.Utility class for matching strings against string expressions.
Printf-style string formatter with a small cache and lenient argument handling.
Built-in object swap implementation class for the
@MarshalledProp(format) annotation.String-manipulation functions for the
#{...} script catalog.#{concat(s1, s2, ...)} — variadic string concatenation.#{contains(s, substr)} — returns "true" or "false".#{endsWith(s, suffix)} — returns "true" or "false".#{format(pattern, args...)} — Java formatter-style
formatting.#{join(separator, parts...)} — concatenates parts with separator
between each pair.#{len(s)} / #{len(s, delimiter)} — replacement for the legacy
$LN{...}.#{lower(s)} — replacement for the legacy $LC{...}.#{pathToken(s)} — normalize a user-supplied path token for safe interpolation
into a path= template.#{repeat(s, n)} — repeats s n times.#{replace(s, target, replacement)} — literal (non-regex) string replacement.#{reverse(s)} — reverses the characters of s.#{split(s, separator)} — splits s on the literal separator
substring.#{startsWith(s, prefix)} — returns "true" or "false".#{stripLeading(s)} — strips leading whitespace.#{stripSlashes(s)} — strips leading and trailing / characters.#{stripTrailing(s)} — strips trailing whitespace.#{substring(s, start)} / #{substring(s, start, end)} — replacement for the
legacy $ST{...} SubstringVar.#{trim(s)} — strips leading and trailing whitespace.#{upper(s)} — replacement for the legacy $UC{...}.A simple mutable string value.
Functional interface for converting objects of a specific type to their string representation.
Collection of standard stringifier implementations for the Bean-Centric Testing framework.
Used for assertion calls against lists of strings.
Represents a single value in a comma-delimited header value that optionally contains a quality metric for
comparison and extension parameters.
A parsed Accept-Encoding or similar header value.
A self contained, repeatable resource that obtains its content from a
String.An unmodifiable snapshot of a
StringResource.A specialized
Setting for string values that provides convenience methods for type conversion.Abstract subclass for object swaps that swap objects for strings.
Reusable string utility methods.
DTO for an HTML <strong>
element.
Stub
TokenValidator for the petstore demo — recognises an in-memory map of opaque bearer tokens.DTO for an HTML <style>
element.
DTO for an HTML <sub>
element.
Swagger items annotation.
Utility classes and methods for the
@SubItems annotation.Builder class.
One entry of a card's
subscribes list: a concrete topic wired to a role the card type implements.What a subscriber does when the payload is cleared or a mapped path is missing.
Wire filter for
subscriptions/listen: which notification kinds and resource URIs a client wants
(see SubscriptionsListenRequest.getNotifications()), or the honored subset a server actually
granted (see SubscriptionsAcknowledgedNotification.getNotifications()).Mandatory first frame on every accepted
subscriptions/listen stream: echoes the honored subset of
the client's requested SubscriptionFilter (after capability gating).Request params for
subscriptions/listen (SEP-2575): the requested notification filter.Terminal JSON-RPC result for a gracefully-closed
subscriptions/listen stream.DTO for an HTML <sup>
element.
Supplier factories: memoizing wrappers moved from the former
Utils.Reads Maven Surefire (and Failsafe) TEST-*.xml reports.
Identifies a class as being a surrogate class.
Specialized
ObjectSwap for Surrogate classes.Simple Variable Language examples.
This is the root document object for the Swagger 2.0 API specification.
Extended annotation for
@Rest(swagger).Utility classes and methods for the
@Swagger annotation.Builder class.
Various useful static methods for creating Swagger elements.
Copy utilities for the Swagger 2.0 bean module.
Root class for all Swagger beans.
Mixin that publishes the Swagger v2 spec endpoint at
/api/*.Interface for retrieving Swagger on a REST resource.
Builder class.
Represents no SwaggerProvider.
Wrapper bean for the resource class associated with a Swagger provider.
Generates a Swagger-UI interface from a Swagger document.
Mixin that publishes the Swagger-UI HTML view at
/swagger.Swagger attribute variable resolver.
Associates
ObjectSwap and Surrogate classes with POJOs and bean properties.Utility classes and methods for the
@Swap annotation.A collection of
@Swap annotations.Builder class.
Dynamically applies a
@Swap annotation to specified classes, methods, or fields.A collection of
@SwapApply annotations.Utility classes and methods for the
@SwapApply annotation.Applies targeted
SwapApply annotations to a Context.Builder.Builder class.
Functional interface for pre-processing and transforming objects before conversion.
Collection of standard swapper implementations for the Bean-Centric Testing framework.
Represents an HTTP 101 Switching Protocols response.
Represents an HTTP 101 Switching Protocols response.
Unmodifiable point-in-time snapshot of the enclosing
SwitchingProtocols response.Unmodifiable point-in-time snapshot of the enclosing
SwitchingProtocols response.A server-held CSRF token: a secret minted in this process's memory, embedded into the pages this process
serves, and required back on every state-changing request.
Property source backed by
System.getenv(String).Provider for
SystemEnvPropertySource.System property variable resolver.
Property source backed by
System.getProperty(String).Provider for
SystemPropertyPropertySource.System utilities.
DTO for an HTML <table>
element.
Java description of one datatables view: data source, columns, ribbon, row styling, row actions, row detail,
selection and bulk actions.
Where a view's rows come from.
A default-sort direction.
Allows adding metadata to a single tag that is used by the operation object.
Allows adding metadata to a single tag that is used by the Operation Object.
Swagger tag annotation.
Utility classes and methods for the
@Tag annotation.Builder class.
DTO for an HTML <tbody>
element.
DTO for an HTML <td>
element.
Represents a parsed TE HTTP request header.
Represents an HTTP TE header.
DTO for an HTML <template>
element.
Supported wire formats for
TemporalAccessor values.Represents an HTTP 307 Temporary Redirect response.
Represents an HTTP 307 Temporary Redirect response.
Unmodifiable point-in-time snapshot of the enclosing
TemporaryRedirect response.Unmodifiable point-in-time snapshot of the enclosing
TemporaryRedirect response.The app's single answer to "who may watch" and "who may type".
A transport-neutral view of who is asking.
The built-in
terminal card type: validates a {contractVersion:'1', terminal:{...}} body through
TerminalDef and emits {terminal: ...}.One read from a
TerminalSource.The options of a
terminal card: where its bytes and (optionally) its step events come from.Static helpers that implement the terminal endpoints and serve the terminal runtime.
One event of a terminal-view stream.
The final status of a run.
The final status of a step.
The event kinds.
The level of a note.
The state of a step that has not ended.
The status of a test.
The
term.input upstream handler: hands keystrokes from a browser terminal card to a TerminalSink.Mixin interface that serves the terminal bytes and raw endpoints, plus this module's own JS and CSS.
Receives a notice that a terminal's bytes have grown.
Tells browser terminal cards that a terminal has new bytes, so they fetch immediately instead of waiting for the
next poll.
Runs one tool under a pseudo-terminal through
juneau_terminal.py --pty and exposes its output as a
FileTerminalSource and its steps as a FileTerminalViewSource.Receives a script's prompt lines from a
TerminalProcess started with a prompt channel.Where a caller's keystrokes go: the input end of one running terminal job.
A growing stream of raw terminal bytes, read by absolute byte offset.
Shared validation grammar; not intended for application use.
The author-facing declaration of a terminal-view region, compiled to a
RegionDef.Static helpers that implement the terminal-view events endpoint.
A thread-safe, in-memory
TerminalViewSource that a producer appends to directly.Mixin interface that serves the terminal-view events endpoint.
One page of a terminal-view event stream: the envelope the events endpoint returns and the client polls.
The read side of a terminal-view event stream.
Thrown for an unknown or stale token; endpoints answer 410 Gone .
Base test class that provides common test configuration for all test classes in the junit package.
Marks a field or method on a JUnit 5 test class as a test-time bean override.
Fluent
BasicBeanStore subclass for declaring test-time bean overrides.The JSON Patch
"test" operation per
RFC 6902 § 4.6.Represents human-readable text in an Atom document.
DTO for an HTML <textarea>
element.
MCP
text content block.MCP
text content block.Text body for
resources/read results or embedded resource content.Text body for
resources/read results or embedded resource content.DTO for an HTML <tfoot>
element.
DTO for an HTML <th>
element.
DTO for an HTML <thead>
element.
The validated token model behind the console's FTL
<@theme>/<@token> directives: an immutable theme
name, an ordered map of leaf tokens (literals) and an ordered map of alias tokens (live var() references).Builder for
Theme.The
<@theme name="…"> chrome FreeMarker directive: names the active stock theme once, in the chrome,
points the chrome at that theme's shipped stylesheet, and — when a nested <@token> body is present
— builds a Theme of custom overrides on top of it.Themes: the stock console themes and one custom token theme, switchable with
?theme=.The built-in
thresholds decorator: a horizontal mark line at a y value, on a carrier series
juneau-thresholds-<n>.Used for assertion calls against throwable objects.
Response handler for
Throwable objects.Various utility methods for working with throwables.
Interface used with
ThrowableUtils.safeSupplier(SupplierWithThrowable).A functional interface representing an operation that accepts a single argument, returns no result, and may throw a checked exception.
A functional interface representing an operation that accepts two arguments, returns no result, and may throw a checked exception.
A functional interface representing an operation that accepts three arguments, returns no result, and may throw a checked exception.
A functional interface representing an operation that accepts four arguments, returns no result, and may throw a checked exception.
A functional interface representing an operation that accepts five arguments, returns no result, and may throw a checked exception.
A functional interface representing a function that accepts one argument, produces a result, and may throw a checked exception.
A functional interface representing a function that accepts two arguments, produces a result, and may throw a checked exception.
A functional interface representing a function that accepts three arguments, produces a result, and may throw a checked exception.
A functional interface representing a function that accepts four arguments, produces a result, and may throw a checked exception.
A functional interface representing a function that accepts five arguments, produces a result, and may throw a checked exception.
A functional interface representing a supplier of results that may throw a checked exception.
Represents a parsed Thrown HTTP response header.
Represents an HTTP Thrown header.
Represents a single entry in this header.
Represents an entry in
ThrownStore.Builder class.
An in-memory cache of thrown exceptions.
Builder class.
Flavor-neutral worker bean carrying the Thymeleaf raw-template-dispatch logic shared by the
ThymeleafMixin mixin, the ThymeleafServlet servlet, and the
ThymeleafResource child flavors.Builder for
ThymeleafDispatcher.Mixin that wires Thymeleaf view-rendering onto any Juneau REST resource.
Builder for
ThymeleafMixin.Child-resource flavor of the
ThymeleafMixin mixin.Standalone servlet companion of the
ThymeleafMixin mixin.Immutable value class returned from
@RestOp-annotated methods to ask the framework to
render a Thymeleaf template.ResponseProcessor that detects ThymeleafView-typed return values and asks the
configured TemplateEngine to render them directly onto the response writer.DTO for an HTML <time>
element.
DTO for an HTML <title>
element.
SPI for caching the result of an OAuth introspection or token-acquisition call.
The
<@token name="--jc-…" value="…"/> / <@token name="--jc-…" alias="var(--jc-…)"/> chrome
FreeMarker directive: one custom theme-token override authored inside a <@theme> element.Capability role for parsers that additionally expose the structural
TokenReader cursor
(FULL formats: json, json5, jsonl, cbor, msgpack).Public low-level pull-parser cursor over a Juneau-formatted document.
Resolves method parameters of type
TokenReader (or any subtype) on
RestOp-annotated Java methods.Format-neutral token vocabulary for Juneau's low-level token-streaming API.
SPI for verifying an opaque bearer token and producing the associated
Principal.Capability role for serializers that additionally expose the structural
TokenWriter
cursor (FULL formats: json, json5, jsonl, cbor, msgpack, jsonschema, jcs).Public low-level push-generator that emits a Juneau-formatted document one structural event at a
time.
Resolves method parameters of type
TokenWriter (or any subtype) on
RestOp-annotated Java methods.Microservice bootstrap.Implementation of the embedded-Tomcat
Log façade based on Logger.Zero-config convenience launcher for an embedded-Tomcat-backed Juneau microservice.
Drives the embedded Tomcat server lifecycle on behalf of the microservice via the
MicroserviceListener fan-out.Interface for creating embedded Tomcat servers.
Programmatic settings for the embedded Tomcat server contributed by
TomcatConfiguration.Builder for
TomcatSettings.TOML marshaller combining
TomlSerializer and TomlParser.Annotation for customizing TOML serialization and parsing behavior on classes, methods, and fields.
Utility classes and methods for the
@Toml annotation.Dynamically applies a
@Toml annotation to specified classes, methods, or fields.A collection of
@TomlApply annotations.Utility classes and methods for the
@TomlApply annotation.Applies targeted
TomlApply annotations to a Context.Builder.Builder class.
Metadata on bean properties specific to TOML serializers and parsers.
Metadata on classes specific to TOML serializers and parsers.
Annotation for specifying config properties defined in
TomlSerializer and TomlParser.Utility classes and methods for the
@TomlConfig annotation.Applies
TomlConfig annotations to a TomlParser.Builder.Applies
TomlConfig annotations to a TomlSerializer.Builder.Interface for providing access to
TomlClassMeta and TomlBeanPropertyMeta objects.Parses TOML v1.0.0 text into POJOs.
Builder for
TomlParser.Session for parsing TOML into POJOs.
Builder for TOML parser session.
A
Toml variant that produces readable (whitespace-padded) TOML output.Serializes POJOs to TOML v1.0.0 format.
Builder class.
Session for serializing objects to TOML format.
Builder for TOML serializer session.
Specialized writer for serializing TOML v1.0.0.
MCP tool descriptor (
tools/list entry).MCP tool descriptor (
tools/list entry).Server capability flags for tools.
Server capability flags for tools.
One named toolkit pack: ordered CSS and JS asset paths, the packs it depends on, its
ToolkitPack.Kind, and the
resolver that turns each path into a URL.Builder for
ToolkitPack.Where a pack's assets are emitted on the page.
Registry of named toolkit packs for the
<@page toolkit=...> directive and for the packs cards require.Resolves an asset path to an absolute, cache-busted URL against the in-flight request.
Resolved absolute URLs, split by pack kind.
Params for the
notifications/tools/list_changed notification.Simple template for adding tooltips to HTML5 bean constructs, typically in menu item widgets.
Exception representing an HTTP 429 (Too Many Requests).
Represents an HTTP 429 Too Many Requests error response.
Unmodifiable point-in-time snapshot of the enclosing
TooManyRequests exception.Unmodifiable point-in-time snapshot of the enclosing
TooManyRequests exception.A custom topic declaration, for a card's
publishes or the page's top-level topics.Who publishes a page-level topic.
<@topic name="..." retain=true|false publisher="script|server|ribbon"/>: declares a page-level custom topic
in the contract's topics list.Builds framework topic names so callers do not hand-format "family:key" strings.
DTO for an HTML <tr>
element.
Reflective accessor for the currently-active OpenTelemetry trace / span id, used by
LogEntryFormatter to populate the optional {traceId} / {spanId} log fields.Neutral, tracer-agnostic carrier of W3C trace-context fields (
traceparent /
tracestate / baggage) from a source that need not be an HTTP request.TextMapGetter implementation that reads W3C trace-context fields from a neutral
TraceContextCarrier — for example an MCP request's params._meta object
— instead of HTTP request headers.TextMapSetter implementation that writes W3C trace-context fields into a neutral
TraceContextCarrier instead of an HTTP response.SPI for recognizing a non-HTTP trace-context carrier inside a resolved
@RestOp invocation.Writes the W3C Trace Context response headers (
traceparent and, when present,
tracestate) so a client calling this server can read the resulting trace identifiers back
off the response.Neutral, dependency-free helper for stamping a caller's current trace context into an arbitrary
TraceContextCarrier.Immutable, low-cardinality description of the operation a
TracerHook bridge should name a
span after, supplied to TracerHook.startSpan(org.apache.juneau.rest.server.RestRequest, TraceContextCarrier, TraceOperation)
alongside the extracted TraceContextCarrier.SPI for receiving per-request tracing events from
juneau-rest-server.DTO for an HTML <track>
element.
Represents a parsed Trailer HTTP response header.
Represents an HTTP Trailer header.
Represents a parsed Transfer-Encoding HTTP response header.
Represents an HTTP Transfer-Encoding header.
The body of a transport-layer request — a thin wrapper around
HttpBody that gives transports a
stable contract without needing to know about higher-level body types.Thrown by
HttpTransport.execute(TransportRequest) when a network-level error occurs (e.g. connection
refused, timeout, SSL handshake failure).An HTTP header name/value pair as seen by the transport layer.
A fully-resolved, transport-layer HTTP request.
Fluent builder for
TransportRequest.A transport-layer HTTP response.
Fluent builder for
TransportResponse.Converter for enabling path-addressing support on response objects returned by a @RestOp -annotated method.
A pairing of a
TriGSerializer and TriGParser into a single class with convenience to/of methods.Subclass of
RdfParser for parsing TriG into POJOs.Subclass of
RdfSerializer for serializing POJOs to TriG format.Three-state enumeration for boolean-like values that can be explicitly set or unset.
A pairing of a
TriXSerializer and TriXParser into a single class with convenience to/of methods.Subclass of
RdfParser for parsing TriX (XML) into POJOs.Subclass of
RdfSerializer for serializing POJOs to TriX (XML) format.Represents an immutable tuple containing a single value.
Represents an immutable tuple containing two values.
Represents a simple tuple of 3 objects.
Represents a simple tuple of 4 objects.
Represents a simple tuple of 5 objects.
A pairing of a
TurtleSerializer and TurtleParser into a single class with convenience to/of methods.Subclass of
RdfParser for parsing Turtle into POJOs.Subclass of
RdfSerializer for serializing POJOs to Turtle format.Represents possible values for JSONSCHEMA_addExamplesTo and JSONSCHEMA_addDescriptionsTo.
Type-conversion functions for the
#{...} script catalog.#{toBool(s)} — coerces s to boolean and renders as a String.#{toDouble(s)} — coerces s to double and renders as a String.#{toInt(s)} — coerces s to int and renders as a String.#{toLong(s)} — coerces s to long and renders as a String.Reflection-based base class for
VarFunction implementations that prefer typed
argument signatures over manual List<Object> unpacking.Encapsulates type variable implementations for a class hierarchy.
DTO for an HTML <u>
element.
DTO for an HTML <ul>
element.
Exception representing an HTTP 401 (Unauthorized).
Represents an HTTP 401 Unauthorized error response.
Unmodifiable point-in-time snapshot of the enclosing
Unauthorized exception.Unmodifiable point-in-time snapshot of the enclosing
Unauthorized exception.Exception representing an HTTP 451 (Unavailable For Legal Reasons).
Represents an HTTP 451 Unavailable For Legal Reasons error response.
Unmodifiable point-in-time snapshot of the enclosing
UnavailableForLegalReasons exception.Unmodifiable point-in-time snapshot of the enclosing
UnavailableForLegalReasons exception.Marker interface implemented by the nested
Unmodifiable snapshot variants of the HTTP bean families.Exception representing an HTTP 422 (Unprocessable Entity).
Represents an HTTP 422 Unprocessable Entity error response.
Unmodifiable point-in-time snapshot of the enclosing
UnprocessableEntity exception.Unmodifiable point-in-time snapshot of the enclosing
UnprocessableEntity exception.Exception representing an HTTP 415 (Unsupported Media Type).
Represents an HTTP 415 Unsupported Media Type error response.
Unmodifiable point-in-time snapshot of the enclosing
UnsupportedMediaType exception.Unmodifiable point-in-time snapshot of the enclosing
UnsupportedMediaType exception.A pairing of a
UonSerializer and UonParser into a single class with convenience to/of methods.Annotation that can be applied to classes, fields, and methods to tweak how they are handled by
UonSerializer and UonParser.Utility classes and methods for the
@Uon annotation.Builder class.
Dynamically applies a
@Uon annotation to specified classes, methods, or fields.Utility classes and methods for the
@UonApply annotation.Applies targeted
UonApply annotations to a Context.Builder.Builder class.
Metadata on bean properties specific to the UON serializers and parsers pulled from the
@Uon
annotation on the bean property.Metadata on classes specific to the UON serializers and parsers pulled from the
@Uon annotation on
the class.UON complex example.
Annotation for specifying config properties defined in
UonSerializer and UonParser.Utility classes and methods for the
@UonConfig annotation.Applies
UonConfig annotations to a UonParser.Builder.Applies
UonConfig annotations to a UonSerializer.Builder.A
Uon variant that percent-encodes reserved/URL-unsafe characters in its UON output.Sample class which shows the simple usage of UONSerializer.
Interface for providing access to
UonClassMeta and UonBeanPropertyMeta objects.Parses UON (a notation for URL-encoded query parameter values) text into POJO models.
Builder class.
Default parser, decoding.
Concrete default builder leaf for the non-subclassed
UonParser.create() / UonParser.copy() path.Session object that lives for the duration of a single use of
UonParser.Builder class.
Concrete default builder leaf for the non-subclassed
create() path (CRTP terminal).A
Uon variant that produces readable (whitespace-padded) UON output.Same functionality as %xx escape sequences.
ParserReader except automatically decoded Serializes POJO models to UON (a notation for URL-encoded query parameter values).
Builder class.
Concrete default builder leaf for the non-subclassed
UonSerializer.create() / UonSerializer.copy() path.Equivalent to
UonSerializer.create ().encoding().build();.Equivalent to
UonSerializer.create ().ws().build();.Session object that lives for the duration of a single use of
UonSerializer.Builder class.
Concrete default builder leaf for the non-subclassed
create() path (CRTP terminal).Utility methods for the UON and UrlEncoding serializers and parsers.
Specialized writer for serializing UON-encoded text.
Represents a parsed Upgrade HTTP request header.
Represents an HTTP Upgrade header.
Exception representing an HTTP 426 (Upgrade Required).
Represents an HTTP 426 Upgrade Required error response.
Unmodifiable point-in-time snapshot of the enclosing
UpgradeRequired exception.Unmodifiable point-in-time snapshot of the enclosing
UpgradeRequired exception.Handles one upstream topic (page → server, WebSocket bridges only).
Used to identify a class or bean property as a URI.
Utility classes and methods for the
@Uri annotation.Builder class.
Dynamically applies a
@Uri annotation to specified classes, methods, or fields.A collection of
@UriApply annotations.Utility classes and methods for the
@UriApply annotation.Applies targeted
UriApply annotations to a Context.Builder.Builder class.
Represents a URL broken into authority/context-root/servlet-path/path-info parts.
Identifies what relative URIs are relative to.
Identifies the possible types of URL resolution.
Class used to create absolute and root-relative URIs based on your current URI 'location' and rules about how to
make such resolutions.
Exception representing an HTTP 414 (URI Too Long).
Represents an HTTP 414 URI Too Long error response.
Unmodifiable point-in-time snapshot of the enclosing
UriTooLong exception.Unmodifiable point-in-time snapshot of the enclosing
UriTooLong exception.Various
URI-related utility methods.REST request dynamic-URL annotation.
Predefined matcher for matching requests with content type "application/x-www-form-urlencoded" .
URL-encoding variable resolver.
A pairing of a
UrlEncodingSerializer and UrlEncodingParser into a single class with convenience to/of methods.Annotation that can be applied to classes, fields, and methods to tweak how they are handled by
UrlEncodingSerializer and UrlEncodingParser.Utility classes and methods for the
@UrlEncoding annotation.Builder class.
Dynamically applies a
@UrlEncoding annotation to specified classes, methods, or fields.A collection of
@UrlEncodingApply annotations.Utility classes and methods for the
@UrlEncodingApply annotation.Applies targeted
UrlEncodingApply annotations to a Context.Builder.Builder class.
Metadata on bean properties specific to the URL-Encoding serializers and parsers pulled from the
@UrlEncoding
annotation on the bean property.Metadata on classes specific to the URL-Encoding serializers and parsers pulled from the
@UrlEncoding annotation on the class.Annotation for specifying config properties defined in
UrlEncodingSerializer and UrlEncodingParser.Utility classes and methods for the
@UrlEncodingConfig annotation.Applies
UrlEncodingConfig annotations to a UrlEncodingParser.Builder.Applies
UrlEncodingConfig annotations to a UrlEncodingSerializer.Builder.A
UrlEncoding variant that expands array/collection-valued properties into multiple
repeated key/value parameter pairs instead of a single UON-encoded array value.Interface for providing access to
UrlEncodingClassMeta and UrlEncodingBeanPropertyMeta objects.Parses URL-encoded text into POJO models.
Builder class.
Session object that lives for the duration of a single use of
UrlEncodingParser.Builder class.
A
UrlEncoding variant that leaves value parts in plain text (not UON-encoded) in its output.A
UrlEncoding variant that produces readable (whitespace-padded) URL-encoded output.Serializes POJO models to URL-encoded notation with UON-encoded values (a notation for URL-encoded query paramter values).
Builder class.
Equivalent to
UrlEncodingSerializer.create ().expandedParams().build();.Equivalent to
UrlEncodingSerializer.create ().plainTextParts().build();.Equivalent to
UrlEncodingSerializer.create ().useWhitespace().build();.Session object that lives for the duration of a single use of
UrlEncodingSerializer.Builder class.
Represents a parsed URL path-info string.
Represents a URL path pattern match.
A parsed path pattern constructed from a
@RestOp(path) value.A list of
UrlPathMatcher objects.URL variable resolver.
Represents an HTTP 305 Use Proxy response.
Represents an HTTP 305 Use Proxy response.
Unmodifiable point-in-time snapshot of the enclosing
UseProxy response.Unmodifiable point-in-time snapshot of the enclosing
UseProxy response.User domain bean.
Represents a parsed User-Agent HTTP request header.
Represents an HTTP User-Agent header.
Builder twin of the Users page (P11,
users.ftlh).The Users page and its endpoints.
A user as the console shows it: everything but the password.
Lifecycle status of a
User.Generator for
RFC 9562 §5.7 version-7 UUIDs.
Supported wire formats for
UUID values.Specialization of
BadRequest thrown by BeanValidator when one or more Jakarta Bean Validation
constraints on a @Content, @FormData, or @Request-bound parameter are violated.Wire-friendly snapshot of a single Jakarta Bean Validation constraint violation, suitable for inclusion in an
HTTP error response body.
Resolves a configuration value into a constructor parameter, setter, or field.
Listener interface for monitoring value changes in
Holder objects.Internal helper used by the reflection layer to resolve
@Value-annotated injection sites.DTO for an HTML <var>
element.
Abstract superclass of all Simple Var Language variables.
SPI for SVL
#{...} script-evaluation functions.Exception representing an HTTP 506 (Variant Also Negotiate).
Represents an HTTP 506 Variant Also Negotiates error response.
Unmodifiable point-in-time snapshot of the enclosing
VariantAlsoNegotiates exception.Unmodifiable point-in-time snapshot of the enclosing
VariantAlsoNegotiates exception.Simple list of variables that can consist of either variable classes or instances.
Utility class for resolving variables of the form "$X{key}" in strings.
Builder class.
Exception that occurs during a var resolver session.
A var resolver session that combines a
VarResolver with one or more session objects.A pre-compiled SVL template.
Represents a parsed Vary HTTP response header.
Represents an HTTP Vary header.
Utility class for performing simple validations on objects.
Represents a version string such as "1.2" or "1.2.3"
Used for assertion calls against
Version objects.Mixin that serves deployment-introspection metadata at
/version (configurable).Builder for
VersionMixin instances.Flavor-neutral version/build-metadata worker bean shared by the version
@Rest flavors.Builder for
VersionProvider instances.Represents an OSGi-style version range like "1.2" or "[1.0,2.0)" .
Child-resource flavor of the
VersionMixin version/build-metadata capability.Standalone servlet companion of the
VersionMixin mixin.Represents a parsed Via HTTP response header.
Represents an HTTP Via header.
DTO for an HTML <video>
element.
Engine-agnostic contract for a server-side-rendered template return value from an
@RestOp-annotated method.A datatable view definition — an ordered set of
Column definitions carrying each column's search
configuration.Minimal shared contract implemented by the builder of every view-engine mixin
(
JspMixin.Builder, ThymeleafMixin.Builder, MustacheMixin.Builder,
FreemarkerMixin.Builder).Marker interface for response processors that handle
View-typed return values.Abstract base for the child-resource flavors of the view mixin resources.
Abstract base for the standalone view-servlet companions of the view mixin resources.
Mixin that serves the first-party rich-view runtime assets —
juneau-views.js,
juneau-ribbon.js, juneau-renders.js, juneau-views.css, the opt-in
juneau-regions.js region-populate runtime, the opt-in juneau-config.js/juneau-config.css
column-chooser runtime — each at its stable path, plus deprecated compatibility mounts
for the two assets that have since moved to the widget module.Public DOM/CSS contract for a
data-juneau-view table.Defines class/field/method visibilities.
A presentation-only visibility rule: the element is shown only when every rule in its list matches.
Fluent operator picker returned by
VisibilityRule.when(String).Represents a parsed Warning HTTP request/response header.
Represents an HTTP Warning header.
Fluent builder for assembling an HTTP Warning header value.
Determines how often the file system is polled by the watcher in
FileStore.DTO for an HTML <wbr>
element.
Resolves a WebJar file to a cache-busted URL under the
WebJarsMixin mount.Mixin that serves WebJar files from the classpath at
/webjars/*.A simple weighted average of numbers.
Mixin that serves RFC 8615
/.well-known/* discovery endpoints.Builder for
WellKnownMixin instances.Marker for a reusable widget primitive.
Defines an interface for resolvers of "$W{...}"
The widget toolkit's serving-path mixin: the mount, asset-URL API and serving endpoints for the widget-owned
browser runtime (
juneau-calendar.js, juneau-calendar.css), plus the
contract-version handshake constants those runtimes bake in.The serving-path
Widget.validate() gate: fail-closed structural validation for any
REST response content that is a Widget, giving the JSON serving path the same gate the
juneau-console-views HTML emitters already give every Widget they consume.Extends
BeanStore with methods for adding beans.The views-toolkit's own structural gate token for
BulkMutateDef: proof that the caller's own write-gate
was consulted before a bulk-mutating affordance is configured (the opt-in separability
guarantee).Subclass of
Serializer for character-based serializers.Builder class.
Concrete default builder leaf for the non-subclassed
WriterSerializer.create() / WriterSerializer.copy() path.Subclass of
SerializerSession for character-based serializers.Builder class.
Concrete default builder leaf for the non-subclassed
create() path (CRTP terminal).Represents a parsed WWW-Authenticate HTTP response header.
Represents an HTTP WWW-Authenticate header.
Fluent builder for assembling an HTTP WWW-Authenticate challenge value.
A parsed
WWW-Authenticate: Bearer ... challenge as returned by an OAuth 2.1 / MCP resource server on a
401/403 response (RFC 6750 §3, RFC 9728 §5.1).A metadata object that allows for more fine-tuned XML model definitions.
A metadata object that allows for more fine-tuned XML model definitions.
A pairing of a
XmlSerializer and XmlParser into a single class with convenience to/of methods.Annotation for specifying various XML options for the XML and RDF/XML serializers.
Utility classes and methods for the
@Xml annotation.Builder class.
Dynamically applies a
@Xml annotation to specified classes, methods, or fields.A collection of
@XmlApply annotations.Utility classes and methods for the
@XmlApply annotation.Applies targeted
XmlApply annotations to a Context.Builder.Builder class.
Metadata on beans specific to the XML serializers and parsers pulled from the
@Xml annotation on the
class.Metadata on bean properties specific to the XML serializers and parsers pulled from the
@Xml annotation
on the bean property.Metadata on classes specific to the XML serializers and parsers pulled from the
@Xml annotation on the
class.Sample class which shows the complex usage of XmlSerializer.
Annotation for specifying config properties defined in
XmlSerializer, XmlDocSerializer, and XmlParser.Utility classes and methods for the
@XmlConfig annotation.Applies
XmlConfig annotations to a XmlParser.Builder.Applies
XmlConfig annotations to a XmlSerializer.Builder.Xml configuration example.
Serializes POJOs to HTTP responses as XML.
Default serializer without namespaces.
Session object that lives for the duration of a single use of
XmlDocSerializer.Builder class.
XMLEventAllocator base class.Represents the absence of this class.
XML format to use when serializing a POJO.
An
Xml variant that emits XML namespaces (the Xml.DEFAULT form omits them).Namespace name/URL mapping pair.
An
Xml variant that emits XML namespaces with attributes quoted using single quotes.An
Xml variant that produces readable (indented, multi-line) output with XML
namespaces and attributes quoted using single quotes.Parses text generated by the
XmlSerializer class back into a POJO model.Builder class.
Concrete default builder leaf for the non-subclassed
XmlParser.create() / XmlParser.copy() path.Session object that lives for the duration of a single use of
XmlParser.Builder class.
Concrete default builder leaf for the non-subclassed
create() path (CRTP terminal).Wrapper class around a
XMLStreamReader.XMLReporter base class.Represents the absence of this class.
XMLResolver base class.Represents the absence of this class.
Identifies the default XML namespaces at the package level.
Serializes POJO models to XML.
Builder class.
Concrete default builder leaf for the non-subclassed
XmlSerializer.create() / XmlSerializer.copy() path.Default serializer without namespaces.
Default serializer without namespaces, single quotes.
Default serializer without namespaces, single quotes, with whitespace.
Default serializer, single quotes.
Default serializer, single quotes, whitespace added.
Session object that lives for the duration of a single use of
XmlSerializer.Builder class.
Identifies what the contents were of a serialized bean.
Concrete default builder leaf for the non-subclassed
create() path (CRTP terminal).Sample class which shows the simple usage of XmlSerializer.
An
Xml variant that produces output with attributes quoted using single quotes
instead of double quotes.An
Xml variant that produces readable (indented, multi-line) output with attributes
quoted using single quotes.Shared test-support utilities for validating XML output.
XML utility methods.
Specialized writer for serializing XML.
Simply XOR+Base64 encoder for obscuring passwords and other sensitive data in INI config files.
Dummy variable for resolving
$X{...} variables.A pairing of a
YamlSerializer and YamlParser into a single class with convenience to/of methods.Annotation for customizing YAML serialization and parsing behavior on classes, methods, and fields.
Utility classes and methods for the
@Yaml annotation.Dynamically applies a
@Yaml annotation to specified classes, methods, or fields.A collection of
@YamlApply annotations.Utility classes and methods for the
@YamlApply annotation.Applies targeted
YamlApply annotations to a Context.Builder.Builder class.
Metadata on bean properties specific to YAML serializers and parsers.
Metadata on classes specific to YAML serializers and parsers.
Annotation for specifying config properties defined in
YamlSerializer and YamlParser.Utility classes and methods for the
@YamlConfig annotation.Applies
YamlConfig annotations to a YamlParser.Builder.Applies
YamlConfig annotations to a YamlSerializer.Builder.YAML config format.
Interface for providing access to
YamlClassMeta and YamlBeanPropertyMeta objects.Parses YAML text into a POJO model.
Builder class.
Session object that lives for the duration of a single use of
YamlParser.Builder class.
A
Yaml variant that produces readable (indented, multi-line) YAML output.Serializes POJO models to YAML.
Builder class.
Default serializer, with whitespace.
Session object that lives for the duration of a single use of
YamlSerializer.Builder class.
Specialized writer for serializing YAML.
Used for assertion calls against
ZonedDateTime objects.