mink

type Aggregate interface {
	// AggregateID returns the unique identifier for this aggregate instance.
	AggregateID() string

	// AggregateType returns the type/category of this aggregate (e.g., "Order", "Customer").
	AggregateType() string

	// Version returns the current version of the aggregate.
	// This is the number of events that have been applied.
	Version() int64

	// ApplyEvent applies an event to update the aggregate's state.
	// This method should be idempotent and deterministic.
	ApplyEvent(event interface{}) error

	// UncommittedEvents returns events that have been applied but not yet persisted.
	UncommittedEvents() []interface{}

	// ClearUncommittedEvents removes all uncommitted events after successful persistence.
	ClearUncommittedEvents()
}

type AggregateBase struct {
	// contains filtered or unexported fields
}

type AggregateCommand interface {
	Command

	// AggregateID returns the ID of the aggregate this command targets.
	// Returns empty string for commands that create new aggregates.
	AggregateID() string
}

type AggregateFactory func(id string) Aggregate

type AggregateHandler[C AggregateCommand, A Aggregate] struct {
	// contains filtered or unexported fields
}

type AggregateHandlerConfig[C AggregateCommand, A Aggregate] struct {
	Store     *EventStore
	Factory   func(id string) A
	Executor  func(ctx context.Context, agg A, cmd C) error
	NewIDFunc func() string
}

type AggregateRoot interface {
	Aggregate

	// GetID is an alias for AggregateID for DDD conventions.
	GetID() string
}

type AppendOption func(*appendConfig)

type AsyncOptions struct {
	// BatchSize is the maximum number of events to process in a batch.
	// Default: 100
	BatchSize int

	// BatchTimeout is the maximum time to wait for a full batch.
	// Default: 1 second
	BatchTimeout time.Duration

	// PollInterval is how often to poll for new events when idle.
	// Default: 100ms
	PollInterval time.Duration

	// RetryPolicy defines how to handle errors.
	RetryPolicy RetryPolicy

	// MaxRetries is the maximum number of retries for failed events.
	// Default: 3
	MaxRetries int

	// StartFromBeginning starts processing from the beginning of the event stream.
	// If false, starts from the last checkpoint.
	// Default: false
	StartFromBeginning bool
}

type AsyncProjection interface {
	Projection

	// Apply processes a single event asynchronously.
	Apply(ctx context.Context, event StoredEvent) error

	// ApplyBatch processes multiple events in a single batch for efficiency.
	// If not supported, implementations should process events sequentially.
	ApplyBatch(ctx context.Context, events []StoredEvent) error
}

type AsyncProjectionBase struct {
	ProjectionBase
}

type AsyncResult struct {
	// contains filtered or unexported fields
}

type CatchupSubscription struct {
	// contains filtered or unexported fields
}

type CategoryFilter struct {
	// contains filtered or unexported fields
}

type Checkpoint struct {
	// ProjectionName is the name of the projection.
	ProjectionName string

	// Position is the global position of the last processed event.
	Position uint64

	// UpdatedAt is when the checkpoint was last updated.
	UpdatedAt time.Time
}

type CheckpointStore interface {
	// GetCheckpoint returns the last processed position for a projection.
	// Returns 0 if no checkpoint exists.
	GetCheckpoint(ctx context.Context, projectionName string) (uint64, error)

	// SetCheckpoint stores the last processed position for a projection.
	SetCheckpoint(ctx context.Context, projectionName string, position uint64) error

	// DeleteCheckpoint removes the checkpoint for a projection.
	DeleteCheckpoint(ctx context.Context, projectionName string) error

	// GetAllCheckpoints returns checkpoints for all projections.
	GetAllCheckpoints(ctx context.Context) (map[string]uint64, error)
}

type Clearable interface {
	// Clear removes all data from the read model.
	Clear(ctx context.Context) error
}

type Command interface {
	// CommandType returns the type identifier for this command (e.g., "CreateOrder").
	CommandType() string

	// Validate checks if the command is valid.
	// Returns nil if valid, or an error describing validation failures.
	Validate() error
}

type CommandBase struct {
	// CommandID is an optional unique identifier for this command instance.
	CommandID string `json:"commandId,omitempty"`

	// CorrelationID links related commands and events for distributed tracing.
	CorrelationID string `json:"correlationId,omitempty"`

	// CausationID identifies the event or command that caused this command.
	CausationID string `json:"causationId,omitempty"`

	// Metadata contains arbitrary key-value pairs for application-specific data.
	Metadata map[string]string `json:"metadata,omitempty"`
}

type CommandBus struct {
	// contains filtered or unexported fields
}

type CommandBusOption func(*CommandBus)

type CommandContext struct {
	// Context is the standard Go context.
	Context context.Context

	// Command is the command being executed.
	Command Command

	// Result is the command execution result (set by handler).
	Result CommandResult

	// Metadata contains additional context data that can be set by middleware.
	Metadata map[string]interface{}
}

type CommandDispatcher interface {
	// Dispatch sends a command to its handler and returns the result.
	Dispatch(ctx context.Context, cmd Command) (CommandResult, error)
}

type CommandHandler interface {
	// CommandType returns the type of command this handler processes.
	CommandType() string

	// Handle processes the command and returns a result.
	Handle(ctx context.Context, cmd Command) (CommandResult, error)
}

type CommandHandlerFunc struct {
	// contains filtered or unexported fields
}

type CommandResult struct {
	// Success indicates whether the command executed successfully.
	Success bool

	// AggregateID is the ID of the aggregate affected by the command.
	// For create commands, this is the ID of the newly created aggregate.
	AggregateID string

	// Version is the new version of the aggregate after command execution.
	Version int64

	// Data contains any additional result data.
	Data interface{}

	// Error contains the error if the command failed.
	Error error
}

type CompositeFilter struct {
	// contains filtered or unexported fields
}

type ConcurrencyError struct {
	StreamID        string
	ExpectedVersion int64
	ActualVersion   int64
}

type ContextValueMiddleware struct {
	// contains filtered or unexported fields
}

type DataExporter struct {
	// contains filtered or unexported fields
}

type DataExporterOption func(*DataExporter)

type DispatchResult struct {
	CommandResult
	Error error
}

type EncryptionError = encryption.EncryptionError

type EncryptionOption func(*FieldEncryptionConfig)

type Event struct {
	// ID is the globally unique event identifier.
	ID string

	// StreamID identifies the stream this event belongs to.
	StreamID string

	// Type is the event type identifier.
	Type string

	// Data is the deserialized event payload.
	Data interface{}

	// Metadata contains contextual information.
	Metadata Metadata

	// Version is the position within the stream (1-based).
	Version int64

	// GlobalPosition is the position across all streams.
	GlobalPosition uint64

	// Timestamp is when the event was stored.
	Timestamp time.Time
}

type EventApplier func(aggregate interface{}, event interface{}) error

type EventData struct {
	// Type is the event type identifier (e.g., "OrderCreated").
	Type string

	// Data is the serialized event payload.
	Data []byte

	// Metadata contains optional contextual information.
	Metadata Metadata
}

type EventFilter interface {
	// Matches returns true if the event should be delivered.
	Matches(event StoredEvent) bool
}

type EventRegistry struct {
	// contains filtered or unexported fields
}

type EventStore struct {
	// contains filtered or unexported fields
}

type EventStoreWithOutbox struct {
	// contains filtered or unexported fields
}

type EventSubscriber interface {
	// SubscribeAll subscribes to all events starting from the given position.
	SubscribeAll(ctx context.Context, fromPosition uint64, opts ...SubscriptionOptions) (Subscription, error)

	// SubscribeStream subscribes to events from a specific stream.
	SubscribeStream(ctx context.Context, streamID string, fromVersion int64, opts ...SubscriptionOptions) (Subscription, error)

	// SubscribeCategory subscribes to events from all streams in a category.
	SubscribeCategory(ctx context.Context, category string, fromPosition uint64, opts ...SubscriptionOptions) (Subscription, error)
}

type EventTypeFilter struct {
	// contains filtered or unexported fields
}

type EventTypeNotRegisteredError struct {
	EventType string
}

type ExportError struct {
	SubjectID string
	Cause     error
}

type ExportFilter func(event StoredEvent) bool

type ExportHandler func(ctx context.Context, event ExportedEvent) error

type ExportRequest struct {
	// SubjectID identifies the data subject (required).
	SubjectID string

	// Streams lists specific stream IDs to export.
	// When provided, only these streams are loaded (efficient, no full scan).
	Streams []string

	// Filter selects which events to include.
	// When Streams is empty, the exporter scans all events and applies this filter
	// (requires the adapter to implement SubscriptionAdapter).
	// When Streams is provided, the filter is applied within each stream.
	Filter ExportFilter

	// FromTime limits export to events stored at or after this time.
	FromTime *time.Time

	// ToTime limits export to events stored at or before this time.
	ToTime *time.Time
}

type ExportResult struct {
	// SubjectID is the data subject identifier from the request.
	SubjectID string

	// Events contains all exported events, ordered by stream then version.
	Events []ExportedEvent

	// Streams lists all unique stream IDs that contained matching events.
	Streams []string

	// TotalEvents is the total number of events included (including redacted).
	TotalEvents int

	// RedactedCount is the number of events whose PII could not be decrypted
	// (e.g., due to crypto-shredding / key revocation).
	RedactedCount int

	// ExportedAt is the timestamp when the export was generated.
	ExportedAt time.Time
}

type ExportedEvent struct {
	// StreamID identifies the stream this event belongs to.
	StreamID string

	// EventType is the event type identifier.
	EventType string

	// Data is the deserialized event payload.
	// When Redacted is true, Data is nil.
	Data interface{}

	// RawData is the serialized event payload after decryption (JSON bytes).
	// When Redacted is true, RawData contains the original (encrypted) bytes.
	RawData []byte

	// Metadata contains non-PII contextual information about the event.
	Metadata ExportedMetadata

	// Version is the position within the stream (1-based).
	Version int64

	// GlobalPosition is the position across all streams.
	GlobalPosition uint64

	// Timestamp is when the event was stored.
	Timestamp time.Time

	// Redacted indicates the event's encrypted fields could not be decrypted
	// (e.g., because the encryption key was revoked via crypto-shredding).
	Redacted bool
}

type ExportedMetadata struct {
	CorrelationID string
	CausationID   string
	TenantID      string
	SchemaVersion int
}

type FieldDefinition struct {
	// Name is the field name.
	Name string

	// Type is the field type (e.g., "string", "int", "bool").
	Type string

	// Required indicates whether the field must be present.
	Required bool
}

type FieldEncryptionConfig struct {
	// contains filtered or unexported fields
}

type Filter struct {
	// Field is the field name to filter on.
	Field string

	// Op is the comparison operator.
	Op FilterOp

	// Value is the value to compare against.
	Value interface{}
}

type FilterOp string

type GenericHandler[C Command] struct {
	// contains filtered or unexported fields
}

type HandlerNotFoundError struct {
	CommandType string
}

type HandlerRegistry struct {
	// contains filtered or unexported fields
}

type IdempotencyConfig struct {
	// Store is the idempotency store to use.
	Store IdempotencyStore

	// TTL is how long to keep idempotency records.
	// Default is 24 hours.
	TTL time.Duration

	// KeyGenerator generates idempotency keys from commands.
	// If nil, GetIdempotencyKey is used.
	KeyGenerator func(Command) string

	// StoreErrors determines if failed commands should be stored.
	// If true, replaying a failed command returns the same error.
	// If false, failed commands can be retried.
	// Default is false.
	StoreErrors bool

	// SkipCommands is a list of command types to skip idempotency checking.
	SkipCommands []string
}

type IdempotencyRecord = adapters.IdempotencyRecord

type IdempotencyReplayError struct {
	Key     string
	Message string
}

type IdempotencyStore = adapters.IdempotencyStore

type IdempotentCommand interface {
	Command

	// IdempotencyKey returns a unique key for deduplication.
	// Commands with the same key will only be processed once.
	IdempotencyKey() string
}

type InMemoryRepository[T any] struct {
	// contains filtered or unexported fields
}

type IncompatibleSchemaError struct {
	EventType     string
	OldVersion    int
	NewVersion    int
	Compatibility SchemaCompatibility
	Reason        string
}

type InlineProjection interface {
	Projection

	// Apply processes a single event within the event store transaction.
	// The projection should update its read model based on the event.
	Apply(ctx context.Context, event StoredEvent) error
}

type JSONSerializer struct {
	// contains filtered or unexported fields
}

type KeyNotFoundError = encryption.KeyNotFoundError

type KeyRevokedError = encryption.KeyRevokedError

type LiveOptions struct {
	// BufferSize is the size of the event channel buffer.
	// Default: 1000
	BufferSize int
}

type LiveProjection interface {
	Projection

	// OnEvent is called for each event in real-time.
	// This method should not block for long periods.
	OnEvent(ctx context.Context, event StoredEvent)

	// IsTransient returns true if this projection doesn't persist state.
	// Transient projections are not checkpointed.
	IsTransient() bool
}

type LiveProjectionBase struct {
	ProjectionBase
	// contains filtered or unexported fields
}

type Logger interface {
	Debug(msg string, args ...interface{})
	Info(msg string, args ...interface{})
	Warn(msg string, args ...interface{})
	Error(msg string, args ...interface{})
}

type LoggingMiddleware struct {
	// contains filtered or unexported fields
}

type Metadata struct {
	// CorrelationID links related events across services for distributed tracing.
	CorrelationID string `json:"correlationId,omitempty"`

	// CausationID identifies the event or command that caused this event.
	CausationID string `json:"causationId,omitempty"`

	// UserID identifies the user who triggered this event.
	UserID string `json:"userId,omitempty"`

	// TenantID identifies the tenant for multi-tenant applications.
	TenantID string `json:"tenantId,omitempty"`

	// Custom contains arbitrary key-value pairs for application-specific metadata.
	Custom map[string]string `json:"custom,omitempty"`
}

type MetricsCollector interface {
	// RecordCommand records a command execution.
	RecordCommand(cmdType string, duration time.Duration, success bool, err error)
}

type Middleware func(next MiddlewareFunc) MiddlewareFunc

type MiddlewareFunc func(ctx context.Context, cmd Command) (CommandResult, error)

type MultiValidationError struct {
	// CommandType is the type of command that failed validation.
	CommandType string

	// Errors contains all validation errors.
	Errors []*ValidationError
}

type Option func(*EventStore)

type OrderBy struct {
	// Field is the field name to sort by.
	Field string

	// Desc specifies descending order.
	Desc bool
}

type OutboxMessage = adapters.OutboxMessage

type OutboxMetrics interface {
	RecordMessageProcessed(destination string, success bool)
	RecordMessageFailed(destination string)
	RecordMessageDeadLettered()
	RecordBatchDuration(duration time.Duration)
	RecordPendingMessages(count int64)
}

type OutboxOption func(*EventStoreWithOutbox)

type OutboxProcessor struct {
	// contains filtered or unexported fields
}

type OutboxRoute struct {
	// EventTypes is the list of event types this route matches. Empty matches all.
	EventTypes []string

	// Destination is the target (e.g., "webhook:https://example.com/events", "kafka:orders").
	Destination string

	// Transform optionally transforms the event payload before outbox scheduling.
	// Note: the event parameter is always nil because the outbox operates on raw serialized data.
	// Use the stored parameter to access stream ID, event type, raw data, and metadata.
	Transform func(event interface{}, stored StoredEvent) ([]byte, error)

	// Filter optionally filters events. Return true to include the event.
	// Note: the event parameter is always nil because the outbox operates on raw serialized data.
	// Use the stored parameter to access stream ID, event type, raw data, and metadata.
	Filter func(event interface{}, stored StoredEvent) bool
}

type OutboxStatus = adapters.OutboxStatus

type OutboxStore = adapters.OutboxStore

type PanicError struct {
	CommandType string
	Value       interface{}
	Stack       string
	// CommandData contains a sanitized JSON representation of the command for debugging.
	// Sensitive fields should be masked by the caller before setting this field.
	CommandData string
}

type ParallelRebuilder struct {
	// contains filtered or unexported fields
}

type PollingSubscription struct {
	// contains filtered or unexported fields
}

type ProcessorOption func(*OutboxProcessor)

type ProgressCallback func(progress RebuildProgress)

type Projection interface {
	// Name returns the unique identifier for this projection.
	// This name is used for checkpointing and management.
	Name() string

	// HandledEvents returns the list of event types this projection handles.
	// An empty list means the projection handles all event types.
	HandledEvents() []string
}

type ProjectionBase struct {
	// contains filtered or unexported fields
}

type ProjectionEngine struct {
	// contains filtered or unexported fields
}

type ProjectionEngineOption func(*ProjectionEngine)

type ProjectionError struct {
	ProjectionName string
	EventType      string
	Position       uint64
	Cause          error
}

type ProjectionMetrics interface {
	// RecordEventProcessed records that an event was processed.
	RecordEventProcessed(projectionName, eventType string, duration time.Duration, success bool)

	// RecordBatchProcessed records that a batch of events was processed.
	RecordBatchProcessed(projectionName string, count int, duration time.Duration, success bool)

	// RecordCheckpoint records a checkpoint update.
	RecordCheckpoint(projectionName string, position uint64)

	// RecordError records a projection error.
	RecordError(projectionName string, err error)
}

type ProjectionRebuilder struct {
	// contains filtered or unexported fields
}

type ProjectionRebuilderOption func(*ProjectionRebuilder)

type ProjectionState string

type ProjectionStatus struct {
	// Name is the projection name.
	Name string

	// State is the current state of the projection.
	State ProjectionState

	// LastPosition is the global position of the last processed event.
	LastPosition uint64

	// EventsProcessed is the total number of events processed.
	EventsProcessed uint64

	// LastProcessedAt is when the last event was processed.
	LastProcessedAt time.Time

	// Error contains the error message if the projection is faulted.
	Error string

	// Lag is the number of events behind the head of the event store.
	Lag uint64

	// AverageLatency is the average time to process an event.
	AverageLatency time.Duration
}

type Publisher interface {
	// Publish sends one or more messages to the external system.
	Publish(ctx context.Context, messages []*OutboxMessage) error

	// Destination returns the destination prefix this publisher handles (e.g., "webhook", "kafka", "sns").
	Destination() string
}

type Query struct {
	// Filters to apply.
	Filters []Filter

	// Ordering criteria.
	OrderBy []OrderBy

	// Maximum number of results to return.
	// 0 means no limit.
	Limit int

	// Number of results to skip.
	Offset int

	// IncludeCount includes the total count in paginated results.
	IncludeCount bool
}

type QueryResult[T any] struct {
	// Items contains the matching read models.
	Items []*T

	// TotalCount is the total number of matching items (before pagination).
	// Only populated if IncludeCount was true in the query.
	TotalCount int64

	// HasMore indicates if there are more results beyond the limit.
	HasMore bool
}

type ReadModelID interface {
	// GetID returns the read model's unique identifier.
	GetID() string
}

type ReadModelRepository[T any] interface {
	// Get retrieves a read model by ID.
	// Returns ErrNotFound if not found.
	Get(ctx context.Context, id string) (*T, error)

	// GetMany retrieves multiple read models by their IDs.
	// Missing IDs are silently skipped.
	GetMany(ctx context.Context, ids []string) ([]*T, error)

	// Find queries read models with the given criteria.
	Find(ctx context.Context, query Query) ([]*T, error)

	// FindOne returns the first read model matching the query.
	// Returns ErrNotFound if no match.
	FindOne(ctx context.Context, query Query) (*T, error)

	// Count returns the number of read models matching the query.
	Count(ctx context.Context, query Query) (int64, error)

	// Insert creates a new read model.
	// Returns ErrAlreadyExists if ID already exists.
	Insert(ctx context.Context, model *T) error

	// Update modifies an existing read model.
	// Returns ErrNotFound if not found.
	Update(ctx context.Context, id string, updateFn func(*T)) error

	// Upsert creates or updates a read model.
	Upsert(ctx context.Context, model *T) error

	// Delete removes a read model by ID.
	// Returns ErrNotFound if not found.
	Delete(ctx context.Context, id string) error

	// DeleteMany removes all read models matching the query.
	// Returns the number of deleted models.
	DeleteMany(ctx context.Context, query Query) (int64, error)

	// Clear removes all read models.
	Clear(ctx context.Context) error
}

type RebuildOptions struct {
	// DeleteCheckpoint deletes the existing checkpoint before rebuilding.
	// Default: true
	DeleteCheckpoint bool

	// ClearReadModel calls the projection's Clear method before rebuilding.
	// Only applicable for projections that implement Clearable.
	// Default: true
	ClearReadModel bool

	// ProgressCallback is called periodically with progress updates.
	ProgressCallback ProgressCallback

	// ProgressInterval is how often to call the progress callback.
	// Default: 1 second
	ProgressInterval time.Duration

	// FromPosition starts rebuilding from a specific position.
	// Default: 0 (from beginning)
	FromPosition uint64

	// ToPosition stops rebuilding at a specific position.
	// Default: 0 (to end)
	ToPosition uint64
}

type RebuildProgress struct {
	// ProjectionName is the name of the projection being rebuilt.
	ProjectionName string

	// TotalEvents is the total number of events to process.
	TotalEvents uint64

	// ProcessedEvents is the number of events processed so far.
	ProcessedEvents uint64

	// CurrentPosition is the current global position.
	CurrentPosition uint64

	// StartedAt is when the rebuild started.
	StartedAt time.Time

	// Duration is the elapsed time.
	Duration time.Duration

	// EventsPerSecond is the processing rate.
	EventsPerSecond float64

	// EstimatedRemaining is the estimated time remaining.
	EstimatedRemaining time.Duration

	// Completed indicates if the rebuild is complete.
	Completed bool

	// Error contains any error that occurred.
	Error error
}

type RetryConfig struct {
	// MaxAttempts is the maximum number of attempts (including the first one).
	MaxAttempts int

	// InitialDelay is the initial delay between retries.
	InitialDelay time.Duration

	// MaxDelay is the maximum delay between retries.
	MaxDelay time.Duration

	// Multiplier is the factor by which the delay increases on each retry.
	Multiplier float64

	// ShouldRetry determines if an error should be retried.
	// If nil, all errors are retried.
	ShouldRetry func(err error) bool
}

type RetryPolicy interface {
	// ShouldRetry returns true if the operation should be retried.
	ShouldRetry(attempt int, err error) bool

	// Delay returns the duration to wait before the next retry.
	Delay(attempt int) time.Duration
}

type Saga interface {
	// SagaID returns the unique identifier for this saga instance.
	SagaID() string

	// SagaType returns the type of this saga (e.g., "OrderFulfillment").
	SagaType() string

	// Status returns the current status of the saga.
	Status() SagaStatus

	// SetStatus sets the saga status.
	SetStatus(status SagaStatus)

	// CurrentStep returns the current step number (0-based).
	CurrentStep() int

	// SetCurrentStep sets the current step number.
	SetCurrentStep(step int)

	// CorrelationID returns the correlation ID for this saga.
	// Used to correlate events to this saga instance.
	CorrelationID() string

	// SetCorrelationID sets the correlation ID.
	SetCorrelationID(id string)

	// HandledEvents returns the list of event types this saga handles.
	HandledEvents() []string

	// HandleEvent processes an event and returns commands to dispatch.
	// The returned commands will be executed by the saga manager.
	HandleEvent(ctx context.Context, event StoredEvent) ([]Command, error)

	// Compensate is called when the saga needs to rollback.
	// It returns compensating commands to undo previous steps.
	Compensate(ctx context.Context, failedStep int, failureReason error) ([]Command, error)

	// IsComplete returns true if the saga has completed successfully.
	IsComplete() bool

	// StartedAt returns when the saga started.
	StartedAt() time.Time

	// SetStartedAt sets when the saga started.
	SetStartedAt(t time.Time)

	// CompletedAt returns when the saga completed (nil if not completed).
	CompletedAt() *time.Time

	// SetCompletedAt sets when the saga completed.
	SetCompletedAt(t *time.Time)

	// Data returns the saga's internal state as a map.
	// This is serialized and stored in the saga store.
	Data() map[string]interface{}

	// SetData restores the saga's internal state from a map.
	SetData(data map[string]interface{})

	// Version returns the saga version for optimistic concurrency.
	Version() int64

	// SetVersion sets the saga version.
	SetVersion(v int64)

	// IncrementVersion increments the saga version.
	IncrementVersion()
}