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) Flux clients.An abstract base class for converting data of type
I to type O.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 Flux Capacitor 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.
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 Flux Capacitor.
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 composite constraint that requires all inner constraints to match.
A composite constraint that requires at least one inner constraint to match.
Command to publish messages to a specific log in Flux (e.g., commands, events, metrics, etc.).
Metric payload used for internal monitoring and logging.
Command used to append one or more event batches to the event store.
Compact metric representation of an
AppendEvents command.A
PropertySource that loads environment-specific properties from an application-<env>.properties file
on the classpath.Central utility for resolving configuration properties within a Flux application.
A
PropertySource implementation that loads properties from an application.properties file located on
the classpath.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 routed to a stateful handler instance (typically annotated with
Stateful).A thread-safe batching queue that asynchronously flushes its content to a consumer in configurable batch sizes.
A function that consumes a batch of items and returns a future that completes when processing is done.
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.
A
Constraint that filters documents based on whether a value in a specific path lies between two bounds.A generic response containing a boolean value, typically used to indicate success/failure.
Represents a single operation in a bulk document update.
Supported bulk operation types.
Command to perform a batch update of documents in the search/document store.
Metric representation for monitoring or observability.
A generic cache interface for storing and managing objects identified by unique keys.
Represents an eviction from a
Cache.Indicates the cause for a cache entry eviction.
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 Flux platform.Exception used to cancel a periodic schedule from a schedule handler.
Command to cancel a previously scheduled message using its
CancelSchedule.scheduleId.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.
Implementation of
Encryption using the ChaCha20-Poly1305 authenticated encryption algorithm.A request to claim a message segment for consumption in client-controlled tracking mode.
Result of a
ClaimSegment request.Lightweight metric representation of a
ClaimSegmentResult, used for telemetry.Defines the low-level client contract used by
FluxCapacitorBuilder to construct a
FluxCapacitor instance.Functional interface for monitoring the dispatch of messages by a
Client.Base interface for client lifecycle events such as
ConnectEvent and DisconnectEvent.Utility class offering client-side support functions for working with Flux Capacitor.
A
MessageStore implementation backed by a collection in an InMemorySearchStore.Base class for commands sent to the Flux platform.
Gateway interface for publishing command messages in Flux Capacitor.
Enumeration of supported compression algorithms used for serializing and deserializing byte data.
Utility class for compressing and decompressing byte arrays using common compression algorithms.
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 platform-generated event that indicates a client has successfully connected to the Flux platform.
Utility class for computing segment assignments using consistent hashing.
A marker message type published to the Flux error gateway for error-level log entries.
A marker message type published to the Flux error gateway for warning-level log entries.
Base interface for defining filter conditions (constraints) used in document search queries.
Declares a
Consumer within a Flux application.Configuration class that defines how a message consumer behaves during message tracking and handler invocation.
A constraint that matches document entries containing the specified phrase, with optional wildcard-like flexibility.
Represents an interface for filtering content before it is passed to a specified viewer.
Interface for converting
Data objects from one format or representation to another.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 Flux Capacitor.Strategy interface for extracting correlation metadata from the current context.
Command to configure to use a search collection as a searchable audit trail.
This provides cron support for java8 using java-time.
Resolves handler method parameters of type
User.A generic container for holding a value along with serialization metadata such as type, revision, and format.
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.A
PropertySource decorator that transparently decrypts encrypted property values.Default implementation of the
AggregateRepository interface.Default implementation of the
Cache interface using key-level synchronized access and soft references for
value storage.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.Default serializer for
Document instances in the Flux platform.Default implementation of the
Encryption interface used in the Flux platform.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
Handler interface.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.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
MemberInvoker using high-performance method handle-based invocation.A default implementation of the
MemoizingBiFunction interface that memoizes (caches) results of a
BiFunction based on a pair of input arguments.A default implementation of the
MemoizingFunction interface that provides caching functionality for computed
function results.A default implementation of the
MemoizingSupplier interface that memoizes (caches)
the result of a computation performed by a supplied Supplier.Default implementation of the
MessageScheduler interface.Default implementation of the
MetricsGateway interface.A layered
PropertySource implementation used as the default source for resolving application properties in a
Flux application.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.Encapsulates a callback mechanism to handle both intermediate and final responses when processing requests.
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, responsible for managing snapshots of aggregate roots
in an event-sourced system.Default implementation of a
SocketSession for managing Flux 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.Streaming strategy that allows multiple clients to concurrently consume a message stream.
Default implementation of
WebRequestContext that adapts a DeserializingMessage of type
MessageType.WEBREQUEST to a Jooby-compatible Context.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.The default
ContainerProvider used to create and manage websocket sessions with Flux Platform.A base implementation of
Entity that forwards all method calls to a delegated Entity instance.An extendable
UserProvider that delegates to another UserProvider.Command to delete an entire search collection, removing all documents within it.
A bulk update operation that deletes a document from a given collection using its ID.
Command to delete a single document from the search store by its collection and ID.
Command to delete documents from the search store based on a search query.
Command to permanently delete all events associated with a specific aggregate ID.
Command to delete a value from the legacy key-value store by key.
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.Resolves handler method parameters of type
DeserializingMessage.A wrapper around a
SerializedObject that supports lazy deserialization of its payload.A simple implementation of
AbstractExecutorService that executes tasks directly in the calling thread without
using any worker threads.Interceptor that disables the dispatch of outbound
MessageType.METRICS messages.A platform-generated event that indicates a client has disconnected from the Flux platform.
Command used to explicitly disconnect a tracker from the Flux platform and release any claimed message segments.
Mechanism that enables modification, monitoring, or conditional suppression of messages before they are dispatched to
local handlers or published to the Flux platform.
Represents a structured, searchable, and indexable document within a Flux Capacitor collection.
Represents a typed field value within a document (e.g. text, number, boolean).
Enumerates the supported types of values that can appear in a
Document entry.Represents a navigable field access path for a
Document entry.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.Represents aggregate statistics for a group of documents, including values for specified fields.
Statistical summary for a single document field.
Interface for storing, updating, and querying documents in the Flux Capacitor platform.
This class represents an exception that is thrown by the
DocumentStore when a document store operation
fails.Represents a single low-level document update operation to be applied to a search collection.
Declares a method that transforms an object from a newer revision to an older one.
Indicates that a message handler method or constructor is the final usage point for protected data.
Defines a contract for encrypting and decrypting sensitive values within the system.
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.Represents a key-value pair with a string-based identifier.
A
PropertySource that resolves property values from system environment variables.Gateway interface for reporting errors during message handling.
Functional interface for handling errors during tasks.
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.A generic error response returned when a request could not be completed successfully.
Represents a batch of serialized events for a specific aggregate.
A compact metric representation of an
EventBatch, used in AppendEvents.Metric.Gateway for publishing event messages to Flux Capacitor.
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 storage and publication.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 Flux Capacitor.
A
Constraint that checks whether one or more paths exist in a document.Marker annotation on fields and methods that indicates that a property is to be used as facet when indexing a
document for search.
A constraint that matches documents containing a specific
FacetEntry.Represents a single facet field-value pair within a document.
Represents the count of documents matching a specific facet value.
Utility class for reading and writing files and classpath resources.
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 Flux Capacitor platform.
Builder interface for constructing a
FluxCapacitor instance.Central configuration interface for a Flux Capacitor client instance.
Callback interface that can be implemented by Spring beans to customize the
FluxCapacitorBuilder
before it is used to build the main FluxCapacitor instance.A
BatchInterceptor that ensures the correct FluxCapacitor 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 Flux Capacitor
platform.
Spring configuration class for automatically wiring and initializing common Flux Capacitor components in a Spring
application context.
Wrapper class representing a prototype-scoped Spring handler type within Flux Capacitor.
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 a complete form object 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 Flux Capacitor.
Utility class for resolving generic type information in class hierarchies.
Request to retrieve all aggregate identifiers associated with a given entity ID.
Response to a
GetAggregateIds request, returning a mapping of aggregate IDs to types.Request to fetch a single document from the search store by ID and collection.
Result returned in response to a
GetDocument request.Lightweight structure for representing
GetDocumentResult in Flux metrics logs.Request to compute statistics on documents that match a given
SearchQuery.Response to a
GetDocumentStats request.Compact summary of the result, used for internal monitoring purposes.
A request to fetch stored events for a specific aggregate in an event-sourced system.
Response to a
GetEvents request, returning a batch of events for an aggregate.Lightweight metric representation of a
GetEventsResult used for monitoring.Request to retrieve aggregated counts for all
facet fields across documents matching the given
SearchQuery.Result returned for a
GetFacetStats request.Lightweight summary of the facet statistics result, used for internal metric tracking.
Response to a
GetPosition request, containing the current tracked position for a specific consumer and
MessageType.Request to retrieve all aggregate relationships for a given entity ID.
Response to a
GetRelationships request, containing all known relationships for a given entity ID.Request to retrieve a scheduled message by its
GetSchedule.scheduleId.Response to a
GetSchedule request, containing the matching SerializedSchedule, if found.Metric payload used for internal monitoring and logging.
Request to compute a time-based histogram over documents that match a given query.
Result of a
GetSearchHistogram request.Request to retrieve a value from the legacy key-value store.
Response to a
GetValue request, returning the value associated with the given key.Represents a group key for aggregating documents in
DocumentStats.Represents a grouped search query in the Flux Capacitor search framework.
Represents a delivery or completion guarantee for messages or state changes in Flux Capacitor.
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).Represents a container for a message handler and the mechanism to resolve a
HandlerInvoker for a given
message.Abstract base class for
Handler implementations that delegate to another handler.Configuration object used to define how message handler methods are selected and filtered for a given message type.
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.Represents a predicate used to determine whether a given method should be considered a valid message handler.
Utility for inspecting and constructing handler components from annotated methods.
A matcher that encapsulates metadata and resolution logic for a single handler method or constructor.
A composite
HandlerMatcher that delegates to a list of individual matchers.Intercepts individual message handling operations, enabling cross-cutting behavior around handler invocation.
Implementation of
Handler that delegates to another handler and applies a HandlerInterceptor.Represents an invocable handler method.
A
HandlerInvoker that delegates all behavior to another instance.A simple invoker backed by a
Callable, typically used for test utilities or framework-internal logic.Defines the logic to determine whether a given target object can handle a message, and how to invoke it.
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.A request to check whether a document exists in a given collection.
Represents an object, typically a message used for invocation, that has an associated
Entity.Interface for exposing a string-based representation of an object's identifier.
Base interface for gateways that support registering local message handlers.
Interface for objects that expose a backing
Message instance.Interface for components that expose a
MessageStore.Marker interface for objects that carry associated
Metadata.Marker interface for wrapper objects that retain a reference to their originating source.
Injects an HTTP request header into a handler method parameter.
Defines constants for standard and extended HTTP request methods used by Flux Capacitor's web handling system.
Enumerates supported HTTP protocol versions for web requests and responses handled through the Flux platform.
Object that represents the identifier of a specific entity.
Strategy interface for generating unique identifiers used throughout the Flux platform.
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.A bulk update operation that indexes (inserts or replaces) a document in the store.
A bulk update operation that indexes a document only if it does not already exist in the store.
Command used to index a collection of
SerializedDocument instances in the search store.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.An in-memory implementation of the
TaskScheduler interface, enabling scheduling and execution of tasks in a
virtualized time environment.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.
Interface responsible for converting a domain object into a
SerializedDocument for indexing, and vice
versa—deserializing a byte[] representation into the original object type.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.Implementation of
Inverter that uses Jackson to invert an Object into a SerializedDocument and back
into a JsonNode.A concrete
Serializer implementation based on Jackson.Base class for
PropertySource implementations backed by a Properties object.Marker interface for all low-level request and response types in the Flux protocol.
Utility class for JSON serialization, deserialization, and file-based JSON resource loading.
This validator uses JSR 380 annotations.
Represents a service to store and retrieve a piece of serialized data by key.
Represents a single key-value entry in the legacy key-value store.
A simple interface for storing, retrieving, and removing key-value pairs.
Thrown when a key-value store operation fails.
Provides utilities for bridging Java reflection with Kotlin reflection.
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.
An in-memory
Client implementation used for local development, testing, or isolated runtime environments
where no connection to the Flux Platform is required.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.
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.
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 Flux platform.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 Flux Capacitor'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 Flux Capacitor consumers.A constraint that supports search-as-you-type functionality by matching terms or phrases that start with a given
input string.
A
BatchInterceptor specialization that transforms a MessageBatch before it is passed to the
consumer for processing.A constraint that matches indexed document values based on text equality or normalized phrase matching.
Indicates that the annotated field or getter represents a nested entity or collection of entities within an
aggregate.
Abstraction for invoking a
Member (e.g.A
BiFunction that memoizes (caches) its results based on a pair of input arguments.A
Function that memoizes (caches) its results by key.A
Supplier that memoizes (caches) the result of a single computation.Represents a unit of communication within the Flux platform, wrapping a payload and its metadata.
Represents a batch of messages retrieved from the message store for a specific segment range.
Compact summary of a
MessageBatch, used for logging and performance tracking.Defines a predicate that determines whether a given message is applicable to a handler method.
A functional interface for formatting
DeserializingMessage instances into human-readable strings.Resolves handler method parameters of type
Message.A
DispatchInterceptor that assigns a routing segment to messages prior to dispatch.Interface for scheduling deferred or periodic execution of messages in the Flux Capacitor platform.
A low-level store for serialized messages.
Enumerates the types of messages recognized and routed by the Flux platform.
Represents immutable metadata associated with a Message in the Flux platform.
Resolves handler method parameters of type
Metadata.Gateway interface for publishing metrics messages in Flux Capacitor.
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 Flux platform.A mutable view on a nested entity within a
ModifiableAggregateRoot.Represents a resource or component that can be monitored.
The MurmurHash3 algorithm was created by Austin Appleby and placed in the public domain.
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
Constraint implementation that matches all documents and imposes no filtering conditions.A no-op implementation of the
Encryption interface that performs no actual encryption or decryption.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 no-operation
PropertySource implementation that never returns any property values.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.A constraint that negates the result of another constraint.
This annotation allows a message handler or payload to be invoked even if the current user is not authenticated.
A custom Jackson module that configures deserialization behavior to treat null collections as empty collections.
Utility class for common object handling, memoization, concurrency, stream processing, and error handling.
Registry for accessing method parameter names at runtime in environments where Java reflection does not retain them
(e.g.
Mechanism to resolve method parameters in message handler methods (e.g. those annotated with
HandleEvent,
HandleCommand, etc.).Wrapper around a
Value representing a resolved parameter value in a web request.Declares a path prefix that contributes to the final URI of a web handler.
Abstract base class for constraints that apply to specific paths in a
Document.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.Represents the tracking state of a consumer, i.e. the last known indexes of consumed messages per segment.
Interface for storing and retrieving
Position objects representing the last processed message indexes
per segment for a given consumer.Represents a source of configuration properties.
Marks a field within a message payload as containing sensitive information that should be protected.
A
Constraint that parses a human-friendly query string into a structured tree of constraints.Gateway interface for dispatching queries and receiving responses in Flux Capacitor.
Injects an HTTP query parameter into a handler method parameter.
Command to read a batch of messages from the Flux platform for a given consumer and tracker.
Request to fetch a batch of messages from a given log starting from a given index.
Result for a
ReadFromIndex request.Metric representation of a
ReadFromIndexResult, used for internal monitoring and analytics.Result returned in response to a
Read request for a batch of messages.Compact representation of the
ReadResult used for monitoring.Utility class for high-performance reflection-based operations across the Flux platform.
Annotation to register a class or package for inclusion in the
TypeRegistry.Represents a handle for a cancellable registration, such as a subscription, listener, or callback.
Describes a relationship between an entity and the aggregate that contains or owns it.
Command to repair or re-index the relationships for an existing aggregate.
Provides access to a singleton-style repository for a given class type.
Base class for requests sent to the Flux platform.
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.Represents a batch of requests to be sent to the Flux platform in a single network round-trip.
Handles the lifecycle of request/response interactions in a Flux Capacitor client.
Marker interface for responses to
Request objects (including commands and queries).Declares role-based access control for message handlers or payload types.
Indicates that a handler or message requires the presence of an authenticated user.
Command to forcibly reset the tracked position for a given consumer and message type.
A strategy interface for converting arbitrary response objects into
Message instances.Represents a batch of results returned from the Flux platform in response to a
RequestBatch.Gateway interface for sending result messages in response to a command or query.
Configuration for retry behavior when executing a task using
TimingUtils.retryOnFailure(java.lang.Runnable, java.time.Duration).An
ErrorHandler implementation that retries failed operations a configurable number of times, with optional
propagation or suppression of unrecoverable errors.Represents the current status of a retry operation.
Specifies the revision number of a persistable object, such as a message payload, document, or aggregate snapshot.
Annotation used to identify the routing key of a message, which in turn is used to compute the message segment using
consistent hashing.
Command to schedule a batch of messages for future delivery.
Represents a scheduled message to be delivered at a specific future time.
Lightweight metric representation of this
Schedule command, used for monitoring purposes.Wrapper for a serialized command message scheduled for deferred execution.
Internal handler responsible for executing scheduled commands when they are due.
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 Flux Capacitor.
Intercepts scheduled messages to handle periodic scheduling logic.
Fluent interface for building and executing document search queries in Flux Capacitor.
Indicates that instances of the annotated type should be indexed for search within Flux Capacitor.
Low-level interface for interacting with a search and indexing service in Flux.
Request used to perform a search over documents indexed in the Flux search store.
The result of a
SearchDocuments request.Lightweight metric representation used for logging search result metadata.
Marker annotation that indicates that a property is to be ignored when indexing a document for search.
Represents a histogram over a time range, typically returned by
GetSearchHistogramResult.Represents a single result returned by a
Search query.Marker annotation that indicates that a property is to be included when indexing a document for search.
Represents configuration options extracted from the
@Searchable annotation on a domain type.A query for filtering documents in one or more search collections.
Builder class for constructing instances of
SearchQuery.Utility class for search-related functionality such as term normalization, path transformation, glob pattern
matching, and primitive value extraction.
A
MessageFilter that restricts handler invocation based on segment membership, using routing keys.Thrown to indicate that a problem occurred during the serialization of an object.
Represents a serialized form of a search document stored in a Flux Capacitor collection.
Represents a fully serialized message for transmission or storage within the Flux platform.
Represents a scheduled message to be delivered at a specific
SerializedSchedule.timestamp.Metric representation of the
SerializedSchedule for tracking/monitoring.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 Flux platform.Utility class for constructing internal service endpoint paths used to route messages to the Flux platform.
Utility class for constructing fully qualified service endpoint URLs for various Flux Platform features
based on the client's configuration.
A thread-safe pool of reusable WebSocket
Session objects, supporting concurrent access and routing.Command to set or update the retention period for a message log in the Flux platform.
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.A simple in-memory implementation of the
PropertySource interface backed by a Map.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 beans annotated with SocketEndpoint
and registers them as FluxPrototype definitions for use in Flux Capacitor.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.
Marker annotation on fields and getters that indicates that a property is to be used for sorting and filtering.
Represents a sortable entry in a
Document for use in search
operations.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 automatically detects beans annotated with Stateful
and registers them as FluxPrototype definitions for use in Flux Capacitor.Command sent to the Flux platform to update the tracked position for a specific consumer and segment range.
Stores a key-value pair only if the specified key does not already exist in the key-value store.
Lightweight metric representation for logging or monitoring.
Legacy API: This command stores key-value pairs in the legacy key-value store mechanism.
Lightweight metric representation of this command.
Deprecated.
Metric representation of the deprecated store call.
A generic response containing a string value.
A Jackson module that customizes the deserialization of strings.
A
PropertySource implementation that reads configuration properties from the JVM system properties.Interface for in-memory scheduling of tasks in a way that supports deterministic testing and virtualized time.
Exception indicating a technical or unexpected failure within the application.
BiConsumer-like interface whose ThrowingBiConsumer.accept(Object, Object) method may throw a
checked Exception.Variant of
BiFunction whose ThrowingBiFunction.apply(Object, Object) method is allowed to
throw a checked Exception.Functional counterpart to
Consumer that allows the ThrowingConsumer.accept(Object) method to
throw a checked Exception.An
ErrorHandler implementation that forcefully halts message tracking by throwing any encountered errors.Runnable-like interface whose
ThrowingRunnable.run() method is allowed to throw a checked Exception.Annotation to be placed on requests (i.e. queries and commands).
Utility class for measuring execution time and retrying operations with configurable backoff and error handling.
A
Tracker represents an active consumer of messages for a particular ConsumerConfiguration.Represents the client-side tracking context during message consumption in Flux Capacitor.
Represents the current set of
Trackers that are connected for a specific consumer.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 the initialization of message tracking in Flux Capacitor.
A
TrackingStrategy defines how a Tracker consumes messages from a message log or distributed segment space.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 FluxPrototype beans for use by Flux Capacitor.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.Abstract base class for
ParameterResolvers that resolve parameters based on type matching.Interface for resolving registered types by alias or simplified name.
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.
Defines the strategy for handling unknown or unresolvable types during deserialization.
Declares a method that transforms an object from a previous revision to a newer one.
Command to inform the Flux platform about changes in entity-aggregate relationships.
Represents an authenticated or system-level user identity within the Flux platform.
Resolves parameters of type
User, typically representing the current user in a request context.Service interface for managing
User identities in Flux Capacitor.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.
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.
A generic response indicating successful completion of a request without returning any payload.
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, or @FormParam.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 Flux platform.
Fluent builder for
WebRequest.Interface representing a context for handling web requests.
Gateway for sending outbound web requests via Flux Capacitor’s proxy mechanism.
Configuration settings for a
WebRequest sent via the WebRequestGateway.Represents a response to a
WebRequest in the Flux platform.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 Flux Platform using WebSocket connections.Configuration class for creating a
WebSocketClient.Configuration for a tracking client assigned to a specific
MessageType.WebSocket-based implementation of the
EventStoreClient, enabling interaction with the Flux Platform's event
store via a persistent WebSocket connection.A
GatewayClient implementation that sends serialized messages to the Flux Platform 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 Flux Platform.A
DispatchInterceptor that modifies outgoing WebResponse messages in response to WebSocket-based
WebRequests.WebSocket-based implementation of the
SchedulingClient interface that communicates with the Flux Platform.WebSocket-based implementation of the
SearchClient that connects to the Flux platform.WebSocket-based implementation of the
TrackingClient that connects to the Flux platform.Utility methods for working with web request and response data, including cookies, headers, and handler annotations.
StoreValuesinstead.