All Classes and Interfaces
Class
Description
An abstract base class for converting data of type
I to type O.Base implementation for built-in
RequestResult types.Cache implementation backed by the common hard-reference memory-aware cache support.Atomically adopts an application-verified staged Model document.
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 Fluxzero (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.Metric event emitted when a Fluxzero application instance starts or begins shutting down.
Application lifecycle phases published as metrics.
A
PropertySource implementation that loads properties from an application.properties file located on
the classpath.Waits until one materialized graph projection has completed every root update originating at or before a committed
model state.
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
Constraint that filters documents based on whether a value in a specific path lies between two bounds.Allocation-bounded primitive I/O shared by compact transports and persisted messages.
Unchecked cursor for validated embedded values whose public API does not expose I/O failures.
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.
Command to cancel a previously scheduled message using its
CancelSchedule.scheduleId.Implementation of
Encryption using the ChaCha20-Poly1305 authenticated encryption algorithm.Result of a segment claim in the tracking strategy domain.
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.Base class for commands sent to the Fluxzero Runtime.
Atomically commits the ordered state transitions produced by one model commit.
Payload-free model commit metrics.
Result of an accepted, rebase-requested, or conflict-rejected
CommitModels.Payload-free commit-result metrics.
Enumeration of supported compression algorithms used for serializing and deserializing byte data.
A runtime-generated event that indicates a client has successfully connected to the Fluxzero Runtime.
Utility class for computing segment assignments using consistent hashing.
Base interface for defining filter conditions (constraints) used in document search queries.
A constraint that matches document entries containing the specified phrase, with optional wildcard-like flexibility.
Interface for converting
Data objects from one format or representation to another.Command to configure to use a search collection as a searchable audit trail.
A generic container for holding a value along with serialization metadata such as type, revision, and format.
Read-only view of a byte-array range for serializers that can consume a slice directly.
A
PropertySource decorator that transparently decrypts encrypted property values.Default serializer for
Document instances in the Fluxzero Runtime.Default implementation of the
Encryption interface used in Fluxzero.Default implementation of the
Handler interface.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.A layered
PropertySource implementation used as the default source for resolving application properties in a
Fluxzero application.Streaming strategy that allows multiple clients to concurrently consume a message stream.
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.
Executes or resumes one explicit independent-model hard deletion.
Command to delete a value from the legacy key-value store by key.
A simple implementation of
AbstractExecutorService that executes tasks directly in the calling thread without
using any worker threads.A runtime-generated event that indicates a client has disconnected from the Fluxzero Runtime.
Command used to explicitly disconnect a tracker from the Fluxzero Runtime and release any claimed message segments.
Represents a structured, searchable, and indexable document within a Fluxzero 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.Represents aggregate statistics for a group of documents, including values for specified fields.
Statistical summary for a single document field.
Represents a single low-level document update operation to be applied to a search collection.
Defines a contract for encrypting and decrypting sensitive values within the system.
A
PropertySource that resolves property values from system environment variables.Functional interface for handling errors during tasks.
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.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.
A
PropertySource that loads extra configuration from locations declared through
"FLUXZERO_CONFIG_LOCATIONS".Shared low-overhead JFR events for Fluxzero batch operations across SDK and Runtime components.
One completed batch operation in the SDK or Runtime pipeline.
A
PropertySource that loads Fluxzero-specific settings from classpath resources.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 Fluxzero metrics logs.Request to fetch multiple documents from the search store by collection and their IDs.
Result returned in response to a
GetDocuments request.Lightweight structure for representing
GetDocumentsResult in Fluxzero 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.
Resolves the durable targets and exact state boundary of one independent-model commit substep.
Target-free metric representation.
Durable target identities and types for one model-commit substep.
Identity-free metric representation.
Batch-loads independent model stream memberships at one namespace-wide state boundary.
Model heads and stream memberships observed at one pinned
GetModelEventsResult.stateIndex.Resolves one bounded independent-model relationship graph and optionally includes the first page of every selected
model stream.
Requests freshness and backlog state for one materialized graph collection.
Temporal graph edges and one model-event page observed at the same pinned state boundary.
Retrieves the production and staged direct documents needed to verify one Model migration.
Production and staged state for an application-verified direct Model migration.
Content-free metrics representation.
Retrieves a bounded batch of staged direct Model migrations for application-level adoption.
A bounded batch of durable heads from the otherwise invisible Model-migration staging area.
Content-free metrics representation.
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 retrieve existing regular search collections and audit trails.
Response to a
GetSearchCollections request.Compact result summary used for metrics.
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 delivery or completion guarantee for messages or state changes in Fluxzero.
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.
Describes the handler method that is involved in a handling operation.
Represents a predicate used to determine whether a given method should be considered a valid message handler.
Provides the input for a prepared handler invocation.
Optional extension of
ParameterResolver for resolving handler parameters from a HandlerInput.Describes what a resolver decided for one handler parameter.
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.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.
A reusable, target-bound handler method.
A
HandlerMethod that delegates all behavior to another instance.Describes whether a handler method applies to a group of equivalent inputs and, when it does, how to invoke it.
A reusable plan for invoking one already selected handler method.
Selects and prepares a handler method so that the result can be reused for equivalent inputs.
The outcome of trying to prepare a handler method for repeated invocation.
Possible outcomes of preparing a handler method.
A request to check whether a document exists in a given collection.
Interface for exposing a string-based representation of an object's identifier.
Interface for components that expose a
MessageStore.Marker interface for objects that carry associated
Metadata.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.An in-memory implementation of the
TaskScheduler interface, enabling scheduling and execution of tasks in a
virtualized time environment.Interface responsible for converting a domain object into a
SerializedDocument for indexing, and vice
versa—deserializing a byte[] representation into the original object type.Implementation of
Inverter that uses Jackson to invert an Object into a SerializedDocument and back
into a JsonNode.Base class for
PropertySource implementations backed by a Properties object.Marker interface for all low-level request and response types in the Fluxzero protocol.
Utility class for JSON serialization, deserialization, and file-based JSON resource loading.
Optional extension for dynamic parameter resolvers whose applicability can be safely reused for messages with the
same low-cardinality key.
Cached outcome of evaluating one resolver for one handler parameter.
Represents a single key-value entry in the legacy key-value store.
Provides utilities for bridging Java reflection with Kotlin reflection.
Marker interface for value objects that should be treated as leaves during reflective traversal.
A constraint that supports search-as-you-type functionality by matching terms or phrases that start with a given
input string.
A constraint that matches indexed document values based on text equality or normalized phrase matching.
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.A hard-reference, weighted cache with LRU eviction and optional key ordering.
Unit represented by a cache weight.
Describes an entry removed from an
MemoryAwareCacheSupport.Determines whether caches should proactively shed entries.
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.
Coordinates maintenance operations that span the message log, tracking positions and active trackers.
A low-level store for serialized messages.
Result of scanning a message store for a tracking batch.
Enumerates the types of messages recognized and routed by the Fluxzero Runtime.
Represents immutable metadata associated with a Message in the Fluxzero Runtime.
Builder for compact metadata whose keys and values are already strings.
Validates method invocation arguments right before a handler method is invoked.
One model identity changed by a durable model-commit substep.
Owns storage-neutral Model commit description, head assignment and accepted-result construction.
Signals that one alias would identify two different models.
Final alias replacements and their requested owners in commit order.
Batch-loads current children for deleted parent IDs.
One fully assigned commit.
Storage-neutral work known before assignment.
Store head values needed to assign the next transition.
Receives assigned heads so a store can build only its own persistence representation.
Constructs a compact store-specific head from the values assigned by this owner.
The desired parent set for one child after a relationship-changing target.
Relationship changes and final parent deletions applied at one state index.
Mutable ordering state for one atomic assignment batch.
Current runtime positions for one model identity involved in a rejected model commit.
Owns generic model-commit conflict detection and conflict-policy outcomes.
One ordered original event and all model targets affected by it.
Persistence and lifecycle effects of one original event on one independently stored model.
Resulting stream/head metadata for one committed target model.
Structural validation for the independent-model wire protocol.
Compact websocket representation for the common one-event, one-target model commit.
Runtime behavior when an commit-scoped model changed after the commit's
readStateIndex.Required scope of an explicit independent-model hard deletion.
Bounded dry-run result for one explicit independent-model hard deletion.
Completed result of an idempotent independent-model hard deletion.
Optional direct current-document consequence of one model target transition.
Byte-range view containing one persisted model-event block.
Lightweight membership of one shared event payload in one model stream.
Reserved metadata keys identifying events emitted by an independent-model commit.
Expands the persisted blocks in a canonical model-event page into its logical payloads and stream memberships.
One original serialized event payload shared by every returned target membership at this state index.
One persisted global-event block transported without runtime-side decompression or re-encoding.
Head and ordered event memberships for one requested model.
One bounded model-stream read inside
GetModelEvents.Compact websocket representation for model-stream reads.
Optional bounds for composing current independent-model documents into the documents returned by a search.
Hidden structural description carried by a composed independent-model graph document.
One concrete placement in pre-order.
Applies graph-view constraints, sorting, field selection and pagination after live graph composition.
Deterministically composes direct current model documents using explicit relationship paths.
One temporal child-to-parent edge selected for a model graph.
Projection-local replacement for a canonical relationship path.
Durable definition of one asynchronous materialized model-graph document.
One independently evolvable direct-document schema participating in a materialized Graph.
Current progress of one asynchronous materialized graph projection.
Coordination head observed for one model at the response boundary.
One current, state, commit or event boundary shared by every Model read.
Current-state relationship constraint for independent model documents.
Relationship direction as observed from returned target documents.
Desired outgoing relationship from a changed child model to one parent.
Validates ordered relationship changes against a current parent graph without loading unrelated descendants.
Complete desired parent-ID set for one changed child.
Batch-loads current parents for child IDs.
One historically visible relationship boundary.
Signals that the proposed relationship boundary could not be proven acyclic.
Shared graph, ancestor, lineage and relationship-query policies for every Model store.
Storage-independent view of one temporal child-to-parent relationship interval.
State selected for a read and whether it came from the requested selector rather than an allowed fallback.
Shared breadth-first traversal mechanics for temporal model relationships.
Traversal bounds and the failure messages associated with exceeding them.
Supplies the relationships for one breadth-first frontier without requiring materialization.
Ordered traversal result, including edges only when an edge mapper was supplied.
Optional serialized snapshot consequence of one model target transition.
Encodes opaque model state indices as fixed-width text that retains signed-long ordering.
Decoder for the final persisted independent-model stream batch format.
One independently addressable stored model membership.
Resulting target heads of one committed model-commit substep.
Durable change represented by a
ModelUpdate.Compact websocket representation for model commits and model-event reads.
Represents a resource or component that can be monitored.
Command to move a single document to another collection.
Command to move matching documents to a collection.
The MurmurHash3 algorithm was created by Austin Appleby and placed in the public domain.
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 no-operation
PropertySource implementation that never returns any property values.A constraint that negates the result of another constraint.
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.).Abstract base class for constraints that apply to specific paths in a
Document.Creates a bounded, non-mutating hard-deletion plan.
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.Optional extension for
parameter resolvers that can prepare a resolver function for a
specific message in one step.Represents a source of configuration properties.
A
Constraint that parses a human-friendly query string into a structured tree of constraints.Command to read a batch of messages from the Fluxzero Runtime 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 Fluxzero Runtime.
Lazily computed reflection metadata for a single Java type.
Idempotently registers an asynchronous materialized model-graph projection.
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.
Base class for requests sent to the Fluxzero Runtime.
Represents a batch of requests to be sent to the Fluxzero Runtime in a single network round-trip.
Marker interface for responses to
Request objects (including commands and queries).Command to forcibly reset the tracked position for a given consumer and message type.
Represents a batch of results returned from the Fluxzero Runtime in response to a
RequestBatch.Request whose durable handler needs to distinguish an initial send from a transport retry.
Configuration for retry behavior when executing a task using
TimingUtils.retryOnFailure(Runnable, Duration).Represents the current status of a retry operation.
Specifies the revision number of a persistable object, such as a message payload, document, or model snapshot.
Conditionally replaces one materialized model-graph document after application-level schema migration.
Metric event emitted when a Fluxzero Runtime changes lifecycle phase.
Runtime lifecycle phases that are published as metrics.
Command to schedule a batch of messages for future delivery.
Lightweight metric representation of this
Schedule command, used for monitoring purposes.Describes an existing search collection and its storage type.
Supported search collection types.
Request used to perform a search over documents indexed in the Fluxzero 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 text search.
Represents a histogram over a time range, typically returned by
GetSearchHistogramResult.Marker annotation that indicates that a property is to be included when indexing a document for search.
Searches current independent model documents subject to bounded relationship constraints.
Searches independent model documents and composes their current child graph into every returned root document.
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.
Represents an index value for a contiguous range of segments.
Represents a serialized form of a search document stored in a Fluxzero collection.
A serialized message value.
Decodes the shared binary or legacy MessagePack representations used by the Fluxzero event store.
Represents a scheduled message to be delivered at a specific
SerializedSchedule.timestamp.Metric representation of the
SerializedSchedule for tracking/monitoring.Utility class for constructing internal service endpoint paths used to route messages to the Fluxzero Runtime.
Command to set or update the retention period for a message log in the Fluxzero Runtime.
A simple in-memory implementation of the
PropertySource interface backed by a Map.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.Command sent to the Fluxzero Runtime 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.
Exposes the mapped contents of a
Stream as an InputStream without buffering the full stream in
memory.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.
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.Runnable-like interface whose
ThrowingRunnable.run() method is allowed to throw a checked Exception.Utility for running tasks with a maximum execution duration.
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 current set of
Trackers that are connected for a specific consumer.A
TrackingStrategy defines how a Tracker consumes messages from a message log or distributed segment
space.Compact websocket representation for message publication and tracking.
Compact binary websocket representation for message publication and tracking.
Long-polls committed independent-model updates after a client-controlled state cursor.
One bounded page of model-commit updates returned by
TrackModelUpdates.Command to truncate a message log and its associated tracking positions.
Abstract base class for
ParameterResolvers that resolve parameters based on type matching.Interface for resolving registered types by alias or simplified name.
Command to inform the Fluxzero Runtime about changes in entity-aggregate relationships.
A generic response indicating successful completion of a request without returning any payload.
Utility methods for exchanging Fluxzero websocket client capabilities through handshake headers.
Optional compact representation for a protocol-specific websocket payload.
Encodes and decodes Fluxzero websocket transport payloads after format negotiation and before compression.
Factory and built-in implementations for Fluxzero websocket transport codecs.
Wire formats supported by the Fluxzero websocket transport.
StoreValuesinstead.