Table of Contents

Namespace Excalibur.EventSourcing

Classes

AppendCommitBoundary

Preserves commit certainty across a complete append, including its cleanup, so that Failed cannot be reported for an append that may have committed.

AppendOutcomeUnknownException

A save could not establish whether its atomic append committed.

AppendResult

Represents the result of appending events to the store.

AppliedMigration

Represents a migration that has been applied to the database.

ArchiveCandidate

Describes an aggregate with events eligible for archival to cold storage.

ArchivePolicy

Configuration for event archival policies that determine which events should be moved from hot to cold storage.

ArchiveScanCursor

Opaque provider-owned continuation for an archive scan round.

ArchiveScanPage

Immutable result of examining one bounded page of stream identities.

AutoSnapshotOptions

Configuration options for automatic snapshot creation after SaveAsync.

ColdStorageKey

Composes the tenant-qualified segment of a cold-storage object key.

CursorEncoder

Encodes and decodes opaque cursor strings for cursor-based (keyset) pagination.

CursorPagedResult<T>

Represents the result of a cursor-based page request.

ErasedEventMarker

Defines the framework-controlled marker that identifies a GDPR-erased (tombstoned) event in an event store.

ErasedStreamRepublicationException

The exception thrown when a save is recognised as an already-committed retry whose events are no longer retrievable, so the repository refuses to republish the caller's live in-memory payloads.

EventBatchTooLargeException

The exception thrown when a single atomic append exceeds the maximum number of events a provider can write in one all-or-nothing operation.

EventNotificationContext

Provides context about the aggregate whose events are being notified, passed to NotifyAsync(IReadOnlyList<IDomainEvent>, EventNotificationContext) and HandleAsync(TEvent, EventNotificationContext, CancellationToken).

EventNotificationOptions

Configuration options for the post-commit notification phase that runs at the end of EventSourcedRepository.SaveAsync, and for the apply-latency threshold the projection host warns at.

EventStoreEventState

Describes the committed identity and lifecycle state of an event without exposing its payload or metadata.

EventTypeNotDeclaredException

The exception thrown when an event's type is not declared by the type-info resolver the host configured, so the store cannot serialize it.

FilterParser

Utility for parsing filter keys into property names and operators.

IdentityMappedAggregateExtensions

Resolves externally-identified aggregates through an IIdentityMapStore without exposing the window between reserving an identity and writing the event stream.

InlineProjectionWait

Suspends the read-your-write wait that an inline projection normally performs on every save, for a bulk writer that will drive the projection cursor itself once at the end of its batch.

MaterializedViewPoisonEventException

Thrown when a materialized view replay reaches an event it cannot interpret, and halts rather than advancing past it.

MigrationResult

Represents the result of a migration or rollback operation.

PagedResult<T>

Represents a paginated result for a collection of items, with metadata about pagination.

ParsedFilter

Represents a parsed filter condition extracted from a dictionary key.

ProjectionAttestation

Identifies the roster and member lifetimes covered by a projection freshness observation.

ProjectionContext

Provides contextual information about the projection processing environment when handling events in a When<TEvent> handler.

ProjectionFilterBuilder

Fluent builder for constructing type-safe projection query filter dictionaries.

ProjectionFilterClause

Represents a partially-built filter condition awaiting an operator and value.

ProjectionHandlerContext

Provides context about the aggregate whose events are being projected, passed to HandleAsync(TProjection, TEvent, ProjectionHandlerContext, CancellationToken).

ProjectionSessionOptions

Configures how long a consistent read waits for a projection to catch up, and how often it looks.

ProjectionStoreExtensions

Extension methods for IProjectionStore<TProjection> providing common query operations with provider-optimized escape hatches.

ProjectionTenantBoundary

An immutable declaration of estate-wide storage or one enforced tenant partition.

ProjectionTransaction

Authoritative stream history and transaction owned by a transactional append.

ProjectionVersionAttribute

Declares the generation of a projection's read model, so that changing how the model is shaped or folded sends it to a new destination instead of mutating the one already serving reads.

ProjectionVersionConvention

Applies a projection's declared generation to the destination name its provider resolved.

QueryOptions

Options for projection queries including pagination and sorting.

ResolvedEventPayload

Serializes an event payload through the type-info resolver a host configured, translating a missing declaration into EventTypeNotDeclaredException.

SnapshotDecisionContext

Provides context for snapshot decision evaluation in CustomPolicy.

StoredEvent

Represents a stored event with persistence metadata.

TransactionalEventStoreMarker

Wire-time capability marker registered by an event-store provider whose concrete store implements ITransactionalEventStore.

Structs

ProjectionAdvanceResult

The outcome of a positioned write, with the position the store actually holds.

ProjectionCompletion

The result of completing projections after a committed save.

ProjectionPosition

A projection's progress assertion or terminal retirement state.

ProjectionProcessingResult

What one projection-processing invocation did.

ProjectionRead<TProjection>

A projection read, together with what can be said about how current it was.

ProjectionRebuildResult

The outcome of a rebuild. A SEPARATE type from ProjectionRefoldResult, deliberately.

ProjectionRefoldResult

The outcome of a re-fold. A SEPARATE type from ProjectionAdvanceResult, deliberately.

SaveResult

What a save produced: the version the aggregate reached, and the token a caller passes to a read that must observe this write.

Interfaces

IAggregateQuery<TAggregate>

Marker interface for aggregate query objects.

IAotProjectionGenerationReaderFactory<TProjection>

Optional capability for exact-destination reads using generated JSON metadata without reflective fallback.

IAotProjectionStore<TProjection>

Provides generated-metadata projection operations without reflection fallback.

IAsyncProjectionDestinationScope

Resolves a storage scope when the actual service must supply account or resource metadata.

IAtomicMaterializedViewStore

A IMaterializedViewStore that can persist a view and advance its processed position as one durable, all-or-nothing operation — the precondition for exactly-once projection.

IColdEventStore

Defines the contract for cold (archive) event storage operations.

IColdEventStoreMigration

Optional administrative capability for an offline cold archive namespace cutover.

ICursorMapStore

Persists cursor maps for multi-stream projections, tracking the last-processed event position per source stream.

ICursorProjectionStore<TProjection>

Extends IProjectionStore<TProjection> with cursor-based (keyset) pagination support.

IDistinctValuesProjectionStore<TProjection>

ISP sub-interface for projection stores that support optimized distinct value queries.

IEphemeralProjectionEngine

Builds projections on-demand by replaying events without persisting the result. Equivalent to Marten's "Live" projection mode.

IEventNotificationBroker

Orchestrates in-process event notification after events have been committed to the event store.

IEventNotificationHandler<TEvent>

Handles a domain event notification raised during EventSourcedRepository.SaveAsync.

IEventSourcedRepository<TAggregate>

Repository for loading and saving event-sourced aggregates with string identifiers.

IEventSourcedRepository<TAggregate, TKey>

Repository for loading and saving event-sourced aggregates with generic key support.

IEventStore

Defines the contract for event store operations supporting event sourcing patterns.

IEventStoreArchive

ISP interface for event stores that support archive operations.

IEventStoreArchiveReader

Optional administrative capability for reading a candidate's raw hot event history.

IEventStoreArchiveScanner

Administrative capability for bounded, resumable archive discovery.

IEventStoreAuthoritativeReader

Optional event-store capability for observing current committed event state independently of an earlier read.

IEventStoreErasure

Extends IEventStore with GDPR Article 17 (Right to Erasure) support.

IEventStoreVersionProbe

Optional IEventStore capability that reports the highest event version held for a stream, without loading the stream.

IEventUpgrader

Defines a contract for upgrading events from older versions to newer versions.

IExistsProjectionStore<TProjection>

ISP sub-interface for projection stores that support optimized existence checks.

IImmutableProjectionHandler<TProjection, TEvent>

Defines a typed, DI-resolved event handler for immutable projection transforms.

IMaterializedViewBuilder<TView>

Defines the contract for building materialized views from events.

IMaterializedViewProcessor

Defines the contract for processing events and updating materialized views.

IMaterializedViewStore

Defines the contract for materialized view persistence operations.

IMigrator

Defines the contract for database schema migration operations.

IPageableProjectionStore<TProjection>

Extends IProjectionStore<TProjection> with offset-based pagination support.

IPositionedProjectionStore<TProjection>

A projection whose stored state carries the position of the last event folded into it, so a write can be conditional on that position.

IProjectionDestinationIdentity

Identifies a projection's configured logical destination within its subscription scope.

IProjectionDestinationScope

Optional stable configuration identity of the actual projection cluster for automatic inline setup.

IProjectionEventHandler<TProjection, TEvent>

Defines a typed, DI-resolved event handler for projection updates.

IProjectionGenerationReaderFactory<TProjection>

Optional capability for opening exact destinations with the provider's conventional serializer.

IProjectionGenerationReader<TProjection>

A read-only handle pinned to one exact projection destination for one operation.

IProjectionGenerationRepoint

Conditionally changes the destination resolved by projection readers.

IProjectionProcessor

Applies committed events to persisted asynchronous projections on demand.

IProjectionRecovery

Re-folds one aggregate's projection row from its event stream, on demand.

IProjectionSessionReader

Reads a projection, optionally waiting until it has caught up to a write the caller made.

IProjectionStore<TProjection>

Defines the contract for projection storage operations.

IProjectionTenantBoundary

Describes the tenant boundary enforced by the actual projection destination.

IProjectionVisibilityBarrier

Establishes search visibility for projection writes observed by a processing page.

ISnapshotManager

Manages snapshot creation and restoration for aggregates.

ISnapshotSerializer

Provides serialization for aggregate snapshots.

ISnapshotStore

Provides storage operations for aggregate snapshots.

ISnapshotStrategy

Defines the strategy for creating snapshots of aggregates.

ISnapshotUpgrader

Defines a contract for upgrading snapshots from older versions to newer versions.

ITransactionalEventStore

Optional extension of IEventStore for providers that can append events and stage outbox messages atomically within a single database transaction.

ITransactionalProjectionCoordinator

Coordinates registered transactional projections for repository saves.

ITransactionalProjectionEventStore

Optional store-owned atomic append with aggregate-local projections.

ITransactionalProjectionStore<TProjection>

Optional persistence of a complete aggregate-local model in the event transaction.

Enums

AppendOutcome

What an append actually did, as a single named outcome rather than a combination of flags.

ColdArchiveLayout

Selects the persisted object layout of a cold event store.

FilterOperator

Filter comparison operators for projection queries.

NotificationFailurePolicy

Defines the failure handling policy for post-commit event notification handlers.

PageNavigation

Defines the navigation direction for pagination operations.

ProjectionAdvanceOutcome

What a positioned projection write did.

ProjectionDestinationKind

Which apply path owns a projection destination, declared where the store is built.

ProjectionFreshness

The projection completion observed by a save or verified by a consistent read.

ProjectionHaltReason

What caused processing to halt, so a caller can tell a transient stop from a terminal one.

ProjectionMode

Defines how a projection processes events.

ProjectionPositionKind

The meaning of a projection row's stored position.

ProjectionProcessingOutcome

Why a projection-processing invocation stopped.

ProjectionRebuildOutcome

What a rebuild did — writing a whole-stream fold over whatever the row held.

ProjectionRefoldOutcome

What a re-fold did — rewriting a projection's state at the position it already holds.

ViewDeliverySemantics

Declares the delivery guarantee a materialized-view projection requires from its view store.

ViewPositionSaveOutcome

Whether a view-position advance was taken or refused as stale.