All Classes and Interfaces
Class
Description
Abstract base implementation of the
Client interface, providing shared logic and lifecycle management for
both local (in-memory) and remote (WebSocket-based) Fluxzero clients.Abstract base implementation of the
Serializer interface.Abstract base class for implementing
UserProviders that resolve user identities via a metadata key.Abstract base class for all WebSocket-based clients in the Fluxzero Java client.
A
DispatchInterceptor that enables thread-local, dynamically scoped interceptors during message dispatch.Marks a class as the root of an aggregate in the domain model.
Controls when aggregate changes are committed and whether multiple commits in the same completion phase may run
concurrently.
Controls how events published from an aggregate are assigned to a message segment.
A wrapper around a stream of aggregate events, enriched with metadata such as the aggregate ID and the last known
sequence number.
Repository interface for loading, managing, and repairing aggregates in Fluxzero.
Represents the root of an aggregate in a domain model.
Annotation used on properties of an entity value that provide an alternative identifier to find the entity.
A single child entity replacement within an
AnnotatedEntityHolder.Adds optional human-readable API documentation metadata to generated API docs.
Generic API documentation model extracted from Fluxzero web handlers.
Adds a raw OpenAPI component to generated API documentation.
Human-authored documentation metadata associated with an API endpoint.
Describes a single extracted web API endpoint.
Excludes a package, type, handler method, parameter, field, record component, or type use from generated API
documentation.
Extracts generic API documentation metadata from Fluxzero web handlers.
Adds top-level metadata to generated API documentation.
Describes an API parameter inferred from a route path or a web parameter annotation.
Describes a full request body parameter inferred from an unannotated web handler argument.
Adds an explicit response entry to generated API documentation.
Describes an explicitly documented API response.
Container annotation for repeatable
ApiDocResponse declarations.Describes a server entry for generated API documentation.
Automatic endpoint that serves an HTML API reference page for an
ApiDocInfo scope.Browser renderer for automatically served API reference pages.
Central utility for resolving configuration properties within a Fluxzero application.
Represents an event that has been applied to an aggregate along with its intended publication strategy.
Indicates that a method or constructor applies an update to an entity, or creates or deletes an entity.
Annotation to mark methods or fields that assert whether a command or query is legal, given the current state of an
aggregate.
Declares how a message should be associated with handler instances.
Thread-local scope for asynchronous work started from completion callbacks.
Message-scoped hook for infrastructure that wants to add context to authorization failures.
A batching wrapper for
HandlerRepository that delays persistence operations until the end of the current
message batch.Intercepts and decorates batch-level message handling for a
Tracker.Exception thrown during message batch processing to intentionally halt tracking after a specific message.
Injects a field from a JSON request body into a handler method parameter.
Fluent builder for applying multiple updates to a single document collection.
Represents an eviction event from a
Cache.Logs and publishes cache eviction events as metrics.
A wrapper around a delegate
AggregateRepository that ensures cached aggregates stay in sync with the event
log.A
TrackingClient implementation that wraps another client (typically a WebsocketTrackingClient)
and caches recent messages in memory to reduce redundant round trips to the Fluxzero Runtime.Exception used to cancel a periodic schedule from a schedule handler.
Meta-annotation that indicates a method performs a revision-based type transformation.
Functional interface representing a transformation from one stream of values to another, possibly adjusting for
version compatibility or format changes.
A composite
Caster that supports registration of multiple casting strategies.Represents metadata that uniquely identifies a version of a serialized data type, along with an optional delta
indicating how the revision should change after casting.
Deserializing view for a message whose payload is split across multiple indexed messages.
Reads serialized messages from a bounded index range while recovering chunked messages.
Defines the low-level client contract used by
FluxzeroBuilder to construct a
Fluxzero instance.Functional interface for monitoring the dispatch of messages by a
Client.Utility class offering client-side support functions for working with Fluxzero.
Namespace of the consumer handling a framework-created message.
A
MessageStore implementation backed by a collection in an InMemorySearchStore.Gateway interface for publishing command messages in Fluxzero.
Conditional that only matches when a bean of the specified type is present in the application context.Conditional that only matches when a bean of the specified type is not present in the context.Conditional that only matches when the specified property is either unset or blank.Conditional that only matches when a specific property is set and matches a given pattern.A marker message type published to the Fluxzero error gateway for error-level log entries.
A marker message type published to the Fluxzero error gateway for warning-level log entries.
Structured validation failure exposed by the Fluxzero validation API.
Declares a
Consumer within a Fluxzero application.Configuration class that defines how a message consumer behaves during message tracking and handler invocation.
Controls whether handlers for a consumer are invoked in the tracker thread or offloaded to a worker thread.
Collector for container metrics from cgroups (v1 and v2).
Container metrics collected from cgroups (v1 or v2).
Represents an interface for filtering content before it is passed to a specified viewer.
Injects the value of an HTTP cookie into a handler method parameter.
A
DispatchInterceptor that enriches outgoing messages with correlation metadata,
enabling full traceability across message flows within Fluxzero.Strategy interface for extracting correlation metadata from the current context.
Collector for CPU metrics using JMX.
CPU metrics for the process and system.
Validates that a character sequence is a credit card number according to the Luhn checksum.
Container annotation for repeatable
CreditCardNumber constraints.This provides cron support for java8 using java-time.
Resolves handler method parameters of type
User.A
DispatchInterceptor and HandlerInterceptor that supports secure transmission of sensitive data
fields by removing them from the payload before dispatch and restoring them during handling.Default implementation of the
AggregateRepository interface.Default aggregate cache facade that selects the current SDK cache implementation from Fluxzero cache properties.
Default implementation of the
CasterChain interface used for managing and applying casting operations—
typically upcasting or downcasting—on SerializedObject instances.A
SerializedObject wrapper that applies a Converter to translate data from one format to another.Represents a unique combination of serialized object
type and revision, used as a key in the
caster registry.Default implementation of the
CommandGateway interface.Default implementation of the
CorrelationDataProvider interface.The
DefaultEntityHelper provides the default implementation of the EntityHelper interface.Decorates a
DeserializingMessage with an associated entity.Wraps a message and its corresponding entity for use in interception or handler invocation.
Default implementation of the
ErrorGateway interface.Default implementation of the
EventGateway interface.Default implementation of the
EventStore interface, providing mechanisms to store and retrieve events
associated with aggregate instances.Default implementation of the
HandlerFactory for creating message handlers based on reflection.Default implementation of
HandlerRepository, backed by a DocumentStore.Default implementation of the
IndexOperation interface.Default reflection based Jakarta Validation implementation used by the SDK.
The default implementation of the
KeyValueStore interface that provides operations for storing, retrieving,
and deleting key-value pairs using a KeyValueClient and a Serializer.Default implementation of the
MessageScheduler interface.Default implementation of the
MetricsGateway interface.Default implementation of the
QueryGateway interface.A default implementation of the
RepositoryProvider interface that uses a ConcurrentHashMap for each
repository.Default implementation of the
RequestHandler interface.A default implementation of the
ResponseMapper interface that simply wraps the response in a MessageDefault implementation of the
ResultGateway interface for sending response messages.Default implementation of the
SnapshotStore interface.Default implementation of a
SocketSession for managing Fluxzero WebSocket sessions.A tracker keeps reading messages until it is stopped (generally only when the application is shut down).
Default implementation of the
Tracking interface that coordinates message tracking for a specific
MessageType.Canonical SDK entry point for Fluxzero's Validation implementation.
Default implementation of
WebRequestContext for Fluxzero web request messages.Default implementation of the
WebRequestGateway interface that delegates requests to a configured
GenericGateway.Default implementation of
WebResponseMapper that converts handler return values into WebResponse objects.A base implementation of
Entity that forwards all method calls to a delegated Entity instance.An extendable
UserProvider that delegates to another UserProvider.Thrown to indicate that a problem occurred during the deserialization of data.
Wrapper for a
Message that supports lazy deserialization, context caching, type adaptation, and batch-level
execution utilities.A wrapper around a
SerializedObject that supports lazy deserialization of its payload.Interceptor that disables the dispatch of outbound
MessageType.METRICS messages.Collector for disk space metrics.
Disk space metrics for monitored paths.
Metrics for an individual disk or filesystem path.
Mechanism that enables modification, monitoring, or conditional suppression of messages before they are dispatched to
local handlers or published to the Fluxzero Runtime.
A
HandlerDecorator that intercepts handler methods annotated with HandleDocument and synchronizes
their return values with a DocumentStore.Interface for converting domain objects to and from
SerializedDocument instances for indexing and searching.Interface for storing, updating, and querying documents in the Fluxzero Runtime.
This class represents an exception that is thrown by the
DocumentStore when a document store operation
fails.Declares a method that transforms an object from a newer revision to an older one.
Annotation indicating a collection of
Downcast methods grouped together for bulk registration.Indicates that a message handler method or constructor is the final usage point for protected data.
Represents an entity that encapsulates domain behavior and state.
Strategy interface for handling domain entity operations such as applying updates, validating state transitions, and
intercepting updates.
Marks a property (field or getter) as the unique identifier of an entity within an aggregate structure.
Resolves handler method parameters that reference an
Entity or the entity's value.Marker for handler-selection contexts where an
Entity parameter should only be matched from message
metadata.Represents a key-value pair with a string-based identifier.
Gateway interface for reporting errors during message handling.
An interface to handle errors encountered during message tracking and processing, with the ability to retry
operations.
HandlerInterceptor that reports exceptions to the configured ErrorGateway.Gateway for publishing event messages to Fluxzero.
Controls whether an applied update should result in event publication.
Strategy for controlling how applied updates (typically from
@Apply methods)
are handled in terms of event storage, event publication, and aggregate state updates.Thrown when an event sourcing operation fails.
High-level abstraction for accessing and storing domain events in an event-sourced system.
Low-level client interface for interacting with the event store in Fluxzero.
Collector for file descriptor metrics (Unix/Linux only).
File descriptor metrics (Unix/Linux only).
Declares that a method should be invoked to filter the visibility of an object for a specific
User.Interface for controlling flow regulation in a consumer.
High-level entry point for all interactions with the Fluxzero Runtime.
Builder interface for constructing a
Fluxzero instance.Central configuration interface for a Fluxzero client instance.
Callback interface that can be implemented by Spring beans to customize the
FluxzeroBuilder
before it is used to build the main Fluxzero instance.Stable identifiers for Fluxzero SDK errors.
Human-readable Fluxzero error report with a stable error code.
Builder for
FluxzeroErrorReport.Factory methods for human-readable SDK errors.
A
BatchInterceptor that ensures the correct Fluxzero instance is bound to the current thread for
the duration of a MessageBatch.A Logback-compatible appender that automatically publishes warning and error-level log events to the Fluxzero
Runtime.
Wrapper bean representing a handler type discovered through Spring integration.
Spring configuration class for automatically wiring and initializing common Fluxzero components in a Spring
application context.
Programmatic configuration for the Fluxzero Jakarta Validation provider.
Jakarta Validation provider that exposes the SDK validator through the standard bootstrap API.
Indicates that a handler method, class, package, or payload should not be invoked or processed if the current user
has any of the specified roles.
Indicates that a handler method, class, package, or payload should not be invoked or processed if a user is
currently authenticated.
A specialized
RetryingErrorHandler that retries failed operations indefinitely until they succeed.Injects an individual form field or multipart part into a handler method parameter.
A specialized, opt-in web request consumer that forwards incoming
MessageType.WEBREQUEST messages to a locally running HTTP server.Base class for user-facing exceptions that are intended to be serialized and transferred across system boundaries
(e.g., back to a calling client or frontend application).
Low-level interface for sending
SerializedMessages to a gateway (e.g. commands, events, queries).A generic message gateway for publication of messages in Fluxzero.
Represents a grouped search query in the Fluxzero search framework.
Marks a method or constructor as a handler for command messages (
MessageType.COMMAND).Marks a method or constructor as a handler for messages from a custom message topic.
A
MessageFilter implementation that filters DeserializingMessage instances
based on a custom topic defined in the HandleCustom annotation on handler methods.Handles incoming HTTP
DELETE requests for the specified path(s).Marks a method or constructor as a handler for document messages within a search collection.
A
MessageFilter that routes DeserializingMessage instances to methods annotated with
HandleDocument, based on the message's topic.Marks a method or constructor as a handler for error messages (
MessageType.ERROR).Marks a method or constructor as an event handler for incoming messages of type
MessageType.EVENT.Handles incoming HTTP
GET requests for the specified path(s).Handles incoming HTTP
HEAD requests for the specified path(s).Meta-annotation used to declare that an annotation marks a method as a message handler for a specific
MessageType.Marks a method or constructor as a handler for internal metrics events (
MessageType.METRICS).Marks a method or constructor as a handler for notification messages (
MessageType.NOTIFICATION).Handles incoming HTTP
OPTIONS requests for the specified path(s).Handles incoming HTTP
PATCH requests for the specified path(s).Handles incoming HTTP
POST requests for the specified path(s).Handles incoming HTTP
PUT requests for the specified path(s).Marks a method or constructor as a handler for query messages (
MessageType.QUERY).Shared utility for discovering and evaluating
Association definitions on handler types and handler methods.Functional interface for decorating
Handler instances that process DeserializingMessage objects.A composite decorator that merges two decorators into one.
Marks a method or constructor as a handler for result messages (
MessageType.RESULT).Factory interface for creating
Handler instances that process DeserializingMessages.Intercepts individual message handling operations, enabling cross-cutting behavior around handler invocation.
Implementation of
Handler that delegates to another handler and applies a HandlerInterceptor.Remaining portion of a prepared handler interceptor chain.
Represents the remaining interceptors and handler invocation in a prepared local handling chain.
Intercepts one prepared local invocation using a lazy
HandlerInput.A handler-method-specific interceptor plan.
Merged wrapper for interceptors that explicitly support method preparation.
Interface for registering and invoking local message handlers.
Combines two
HandlerRegistry instances into one.A no-op handler registry that performs no registration or dispatch.
Repository interface for storing and retrieving
@Stateful handler instances.Marks a method or constructor as a handler for scheduled messages (
MessageType.SCHEDULE).Handles a WebSocket connection close event.
Handles a WebSocket handshake request, invoked when a client first attempts to connect using a specialised
GET request.Handles an incoming WebSocket message.
Handles the opening of a WebSocket connection (after handshake).
Handles a
PONG WebSocket frame, typically sent in response to a PING.Handles incoming HTTP
TRACE requests for the specified path(s).Marks a method or meta-annotation as a handler for incoming web requests (
MessageType.WEBREQUEST).Marks a method as a handler for
MessageType.WEBRESPONSE messages.Represents an object, typically a message used for invocation, that has an associated
Entity.Base interface for gateways that support registering local message handlers.
Interface for objects that expose a backing
Message instance.Marker interface for wrapper objects that retain a reference to their originating source.
Injects an HTTP request header into a handler method parameter.
A combined snapshot of host metrics collected at a specific point in time.
Orchestrates periodic collection and publication of host metrics.
Configuration for host metrics collection.
Defines constants for standard and extended HTTP request methods used by Fluxzero's web handling system.
Enumerates supported HTTP protocol versions for web requests and responses handled through the Fluxzero Runtime.
Object that represents the identifier of a specific entity.
Deserializes concrete
Id subtypes from their scalar Id.functionalId representation.Strategy interface for generating unique identifiers used throughout the Fluxzero Runtime.
Metric event published when a tracked message matched a handler but was deliberately skipped before invocation.
Thrown to indicate that a command was rejected due to business logic violations.
Immutable representation of an
AggregateRoot, extending ImmutableEntity with additional metadata for
event sourcing.Immutable implementation of the
Entity interface, representing a snapshot of a domain entity.Builder-style interface for indexing documents into the
DocumentStore.Use 48 bits of the current time in milliseconds since epoch as the base of the index.
An implementation of the
EventStoreClient interface that provides an in-memory event storage solution.An in-memory implementation of the
KeyValueClient interface.An in-memory implementation of the
MessageStore interface for storing SerializedMessages without
external persistence.An in-memory implementation of a scheduling store that allows the scheduling, retrieval, and management of scheduled
messages.
In-memory implementation of the
SearchClient, intended for local testing and development.Resolves handler method parameters by simply injecting the input if the parameter type is assignable from the input
type.
Indicates that a method should intercept and potentially transform an update before it is applied to an entity.
Tracks the lifecycle and identity of a single message handler invocation.
A
ContentFilter implementation that uses Jackson to filter content dynamically for a specific User.Custom Jackson serializer that attempts to invoke a
FilterContent handler method during serialization.A concrete
Serializer implementation based on Jackson.Low-level Fluxzero websocket connector backed by the JDK
HttpClient websocket implementation.A
ParameterResolver that converts the message payload to the parameter's declared type
if that type is assignable to JsonNode.Collector for JVM class loading metrics using JMX.
JVM class loading metrics.
Collector for JVM garbage collection metrics using JMX.
JVM garbage collection metrics for all available GC collectors.
Metrics for an individual garbage collector.
Collector for JVM memory metrics using JMX.
JVM memory metrics including heap, non-heap, and individual memory pool statistics.
Metrics for an individual JVM memory pool.
Collector for JVM thread metrics using JMX.
JVM thread metrics including counts and state distribution.
Represents a service to store and retrieve a piece of serialized data by key.
A simple interface for storing, retrieving, and removing key-value pairs.
Thrown when a key-value store operation fails.
A lazily-loaded implementation of
AggregateRoot that defers deserialization and event application until the
entity value is explicitly accessed.A lazily initialized identifier that serializes as a plain string.
Validates that a character sequence length is between
Length.min() and Length.max(), inclusive.Container annotation for repeatable
Length constraints.An in-memory
Client implementation used for local development, testing, or isolated environments where no
connection to the Fluxzero Runtime is required.Describes the message characteristics that remain constant for a prepared local-dispatch policy.
A handler registry implementation intended for local testing and development that registers handlers for document
updates in a specific collection.
A client implementation for managing and storing events in an in-memory event store.
Holds the state of one payload-first local handler invocation.
Marks a message handler method, class, or package as a **local handler**—one that is invoked immediately in the
publishing thread rather than asynchronously through tracking.
Gives Fluxzero handling extensions access to a local invocation whose full message is created only when needed.
In-memory implementation of
HandlerRegistry that manages and dispatches local message handlers — i.e.,
handlers that are invoked directly in the publishing thread without involving the Fluxzero Runtime.Result of trying to handle a message locally.
A client implementation for managing scheduling operations using an in-memory schedule store.
Configuration for the local HTTP server used to handle
WebRequest messages outside of Fluxzero's own
web handling framework.In-memory implementation of the
TrackingClient and GatewayClient interfaces, designed for
local-only or test-time usage.The default
ErrorHandler implementation used by Fluxzero consumers.A
BatchInterceptor specialization that transforms a MessageBatch before it is passed to the
consumer for processing.Indicates that the annotated field or getter represents a nested entity or collection of entities within an
aggregate or stateful handler.
Instance-bound memoization store used by
Fluxzero for lightweight caching of values.Represents a unit of communication within the Fluxzero Runtime, wrapping a payload and its metadata.
Message-scoped log description used by infrastructure that can describe a message more clearly than its payload type.
A functional interface for formatting
DeserializingMessage instances into human-readable strings.Resolves handler method parameters of type
DeserializingMessage.A
DispatchInterceptor that assigns a routing segment to messages prior to dispatch.Interface for scheduling deferred or periodic execution of messages in the Fluxzero Runtime.
Resolves handler method parameters of type
Metadata.Interface for collecting a specific type of metric.
Gateway interface for publishing metrics messages in Fluxzero.
Indicates that a handler configured with
MissingProtectedDataPolicy.FAIL received a message for which one or
more protected values are no longer available.Determines how a handler responds when a message references protected data that is no longer available.
A mutable, stateful
AggregateRoot implementation that allows in-place updates and applies events
with commit support for persisting the state and synchronizing it with the Fluxzero Runtime.A mutable view on a nested entity within a
ModifiableAggregateRoot.A specialized
Handler that maintains and mutates an internal delegate instance.A
Cache implementation that wraps a delegate cache and applies a transformation to each key (ID) before
delegating operations to the underlying cache.A read-only, inert
Entity wrapper used exclusively during the loading phase of aggregate state.A no-op implementation of the
FlowRegulator interface that never requests a pause.A
SnapshotStore implementation that is used when snapshotting is explicitly disabled, such as when
snapshotPeriod <= 0 is configured on an aggregate via Aggregate.A
SnapshotTrigger implementation that never triggers snapshot creation.
This annotation allows a message handler or payload to be invoked even if the current user is not authenticated.
Automatic endpoint that serves the generated OpenAPI document for an
ApiDocInfo scope.Global options for rendering an
ApiDocCatalog as an OpenAPI document.Generates an OpenAPI document from Fluxzero web handler annotations during Java compilation.
Renders a generic
ApiDocCatalog as an OpenAPI JSON document.Declares the relative order in which Fluxzero applies interceptors and decorators.
Wrapper around a resolved parameter value in a web request.
Declares a path prefix that contributes to the final URI of a web handler.
Injects a path variable from the URI into a handler method parameter.
A
MessageFilter used to restrict message handling based on the payload type.Resolves handler method parameters by injecting the message payload.
Declares a message (typically a
Schedule) or its handler method as part of a periodic schedule.A
SnapshotTrigger that triggers snapshot creation at fixed intervals based on the aggregate's sequence number.Applies a
DispatchInterceptor to local dispatch without requiring Fluxzero to create a complete message
before handler selection.Marks a field or type within a message payload as containing sensitive information that should be protected.
Gateway interface for dispatching queries and receiving responses in Fluxzero.
Injects an HTTP query parameter into a handler method parameter.
Validates that a numeric value is between
Range.min() and Range.max(), inclusive.Container annotation for repeatable
Range constraints.Thrown when a message publication chain exceeds the configured maximum depth.
Prevents runaway recursive publication loops by carrying a publication depth in message metadata.
Mutable holder for a previously resolved user that may be refreshed while handling a message.
Optional extension for refreshing an already resolved
User.Provides access to a singleton-style repository for a given class type.
Marker interface for request messages (e.g., commands or queries) that expect a response of a specific type.
Annotation processor that validates whether handler methods annotated with
HandleCommand, HandleQuery
or HandleCustom correctly match the response type declared by a Request payload.Handles the lifecycle of request/response interactions in a Fluxzero client.
Declares role-based access control for message handlers or payload types.
Indicates that a handler or message requires the presence of an authenticated user.
A strategy interface for converting arbitrary response objects into
Message instances.Gateway interface for sending result messages in response to a command or query.
An
ErrorHandler implementation that retries failed operations a configurable number of times, with optional
propagation or suppression of unrecoverable errors.Annotation used to identify the routing key of a message, which in turn is used to compute the message segment using
consistent hashing.
Represents a scheduled message to be delivered at a specific future time.
Wrapper for a serialized command message scheduled for deferred execution.
Internal handler responsible for executing scheduled commands when they are due.
Represents a unique identifier for a schedule, consisting of a type and an id.
Exception thrown by a
MessageScheduler when scheduling a message fails.A lower-level client interface for scheduling and cancelling deferred messages (i.e., schedules) in Fluxzero.
Intercepts scheduled messages to handle periodic scheduling logic.
Resolves the Maven version of the Fluxzero Java SDK from build metadata packaged with the artifact.
Fluent interface for building and executing document search queries in Fluxzero.
Indicates that instances of the annotated type should be indexed for search within Fluxzero.
Low-level interface for interacting with a search and indexing service in Fluxzero.
Represents a single result returned by a
Search query.Represents configuration options extracted from the
@Searchable annotation on a domain type.A
MessageFilter that restricts handler invocation based on segment membership, using routing keys.A
Cache implementation that partitions values across two internal caches based on a provided
Predicate.Thrown to indicate that a problem occurred during the serialization of an object.
Mechanism to serialize and deserialize objects to and from
byte[] representations.Declares a static file handler that serves files from a resource or file system location at the specified web
path(s).
Exception thrown when a
Request fails and an ErrorResult is returned by
the Fluxzero Runtime.Utility class for constructing fully qualified service endpoint URLs for various Fluxzero Runtime features
based on the client's configuration.
A thread-safe pool of reusable
WebsocketSession objects, supporting concurrent access and routing.A functional, non-persistent
Entity wrapper that enables safe state mutation and validation without producing
side effects such as event publication or snapshot creation.An
ErrorHandler implementation that suppresses all processing errors and allows message tracking to
continue.Interface for managing snapshots of aggregates in an event-sourced system.
Functional interface used to determine whether a new snapshot should be created for an aggregate.
Declares a WebSocket endpoint that represents a single active client session.
Controls periodic keep-alive pings to detect inactive sessions.
A specialized
Handler that manages lifecycle events and message dispatching for WebSocket endpoints annotated
with SocketEndpoint.A stateful wrapper around a WebSocket endpoint instance, managing per-session behavior and message handling.
Spring
BeanDefinitionRegistryPostProcessor that detects
SocketEndpoint types within the application's component-scan scope and registers them as
FluxzeroPrototype definitions for use in Fluxzero.A wrapper representing a serialized request sent over a WebSocket session.
Represents a response to a
SocketRequest sent over a WebSocket session.Represents a WebSocket session that allows sending messages, requests, pings, and handling session lifecycle actions.
Cache implementation using key-level synchronized access and soft references for value storage.Resolves handler method parameters annotated with
Autowired from the Spring application context.A registry interface for registering Spring-based handler components with e.g.: a
TestFixture.A
PropertySource implementation that delegates property lookups to a Spring Environment.A
BatchInterceptor that stalls batch processing until a minimum desired batch size is reached or a timeout occurs.Declares that a class is a stateful message handler — i.e., one whose state is persisted and which can receive
messages via
Association.A
Handler implementation for classes annotated with Stateful, responsible for resolving and invoking
stateful handler instances based on Association metadata.Spring
BeanDefinitionRegistryPostProcessor that detects
Stateful handler types within the application's component-scan scope and registers them as
FluxzeroPrototype definitions for use in Fluxzero.A functional interface representing a resource with substitutable properties.
Exception indicating a technical or unexpected failure within the application.
Shared, opt-in context for thread-local values that belong to the same logical request.
A reusable snapshot of the context that was active when
ThreadLocalContext.capture() was called.An
ErrorHandler implementation that forcefully halts message tracking by throwing any encountered errors.Annotation to be placed on requests (i.e. queries and commands).
Represents the client-side tracking context during message consumption in Fluxzero.
The Tracking interface provides a mechanism to start and manage the tracking of messages by a given set of handlers.
Low-level client interface for tracking and consuming messages from a message log.
Exception thrown during message tracking in Fluxzero.
Indicates that a message payload class can handle itself as a message handler.
Spring
BeanDefinitionRegistryPostProcessor that detects classes
annotated with TrackSelf
and registers them as FluxzeroPrototype beans for use by Fluxzero.Injects the **triggering message** that caused the current message to be published or handled.
Resolves parameters annotated with
Trigger by loading the original trigger message that caused the current
handler method to execute.Thrown to signal that the user is not authenticated.
Thrown when an authenticated user attempts to access a resource or perform an action for which they lack the required
permissions.
Validates that an array or iterable value does not contain duplicate elements.
Container annotation for repeatable
UniqueElements constraints.Defines the strategy for handling unknown or unresolvable types during deserialization.
Declares a method that transforms serialized data from one revision to the next during deserialization.
Annotation indicating a collection of
Upcast methods grouped together for bulk registration.Collector for JVM uptime metrics using JMX.
JVM uptime metrics.
Validates that a character sequence can be parsed as a URL and optionally matches URL components.
Container annotation for repeatable
URL constraints.Represents an authenticated or system-level user identity within the Fluxzero Runtime.
Resolves parameters of type
User, typically representing the current user in a request context.Service interface for managing
User identities in Fluxzero.Validates that a character sequence is a canonical UUID string.
Container annotation for repeatable
UUID constraints.Default implementation of
IdentityProvider that generates random UUIDs.Specifies validation groups to apply when validating the annotated class.
A
HandlerInterceptor that validates the payload of messages before they are handled.Indicates that a request (typically a command or query) contains one or more field-level violations that prevent
further processing.
String-only validation failure summary for serialized validation responses.
Utility class providing common validation and authorization routines for message payloads such as commands, queries,
and web requests.
Strategy interface for validating message payloads and other objects prior to handler invocation.
Represents a single
multipart/form-data part.Specialized
HandlerMatcher that routes DeserializingMessages of type MessageType.WEBREQUEST
to matching handler methods based on annotated URI patterns, HTTP methods, and optional origins.Meta-annotation for parameter annotations used to inject values from an HTTP request.
Annotation processor that generates parameter name metadata for web request handler methods annotated with
@QueryParam, @PathParam, @HeaderParam, @CookieParam, @FormParam, or
@BodyParam.Internal configuration holder used to expand the URI and method mappings of a web request handler method.
Enumerates the sources of parameter values in an HTTP or WebSocket request.
Resolves method parameters in web handler methods based on meta-annotations derived from
WebParam.Represents a pattern used to match incoming
WebRequests to handler methods.Resolves a method parameter from the payload of a
WebRequest.Represents a web request message within the Fluxzero Runtime.
Fluent builder for
WebRequest.Interface representing a context for handling web requests.
Gateway for sending outbound web requests via Fluxzero’s proxy mechanism.
Configuration settings for a
WebRequest sent via the WebRequestGateway.Represents a response to a
WebRequest in the Fluxzero Runtime.Fluent builder for
WebResponse.A
DispatchInterceptor that applies GZIP compression to outgoing WebResponse messages based on request
headers and response size.Specialized implementation of the
ResultGateway interface for sending web response messages.Specialization of
ResponseMapper for mapping responses to WebResponse messages.A
Client implementation that connects to the Fluxzero Runtime using WebSocket connections.Configuration class for creating a
WebSocketClient.Configuration for a tracking client assigned to a specific
MessageType.WebSocket close information used by the low-level Fluxzero runtime clients.
Connection settings for the low-level runtime websocket connector.
Creates low-level websocket sessions for Fluxzero runtime clients.
Callback contract for low-level Fluxzero runtime websocket sessions.
Low-level receive timing captured before dispatching to the Fluxzero endpoint.
WebSocket-based implementation of the
EventStoreClient, enabling interaction with the Fluxzero Runtime's event
store via a persistent WebSocket connection.A
GatewayClient implementation that sends serialized messages to the Fluxzero Runtime over a WebSocket
connection.Decorator that adds WebSocket session support to handler classes and enables parameter injection for
SocketSession.WebSocket-based implementation of the
KeyValueClient interface for interacting with the Fluxzero Runtime.A
DispatchInterceptor that modifies outgoing WebResponse messages in response to WebSocket-based
WebRequests.WebSocket-based implementation of the
SchedulingClient interface that communicates with the Fluxzero Runtime.WebSocket-based implementation of the
SearchClient that connects to the Fluxzero Runtime.Minimal websocket session contract needed by the Fluxzero runtime clients.
WebSocket-based implementation of the
TrackingClient that connects to the Fluxzero Runtime.Utility methods for working with web request and response data, including cookies, headers, and handler annotations.