types

type Conflict struct {
	EventType     string
	AggregateID   string
	ChangedFields []string
	Metadata      map[string]interface{}

	Local  EventWithVersion
	Remote EventWithVersion
}

type ConflictResolver interface {
	Resolve(ctx context.Context, c Conflict) (ResolvedConflict, error)
}

type Event interface {
	// ID returns a unique identifier for this event
	ID() string

	// Type returns the event type (e.g., "UserCreated", "OrderUpdated")
	Type() string

	// AggregateID returns the ID of the aggregate this event belongs to
	AggregateID() string

	// Data returns the event payload
	Data() interface{}

	// Metadata returns additional event metadata
	Metadata() map[string]interface{}
}

type EventHandler = func([]EventWithVersion) error

type EventStore interface {
	// Store persists an event with the provided version (version may be ignored
	// by implementations that auto-generate versions, but must not fail).
	Store(ctx context.Context, event Event, version Version) error

	// Load retrieves all events strictly after the provided version.
	// Optional filters can be provided for type, tenant, aggregate_id, etc.
	// Variadic filters parameter is backward compatible - existing calls work unchanged.
	Load(ctx context.Context, since Version, filters ...Filter) ([]EventWithVersion, error)

	// LoadByAggregate retrieves events for a specific aggregate after the version.
	// Optional filters can be provided for type, tenant, etc.
	// Variadic filters parameter is backward compatible - existing calls work unchanged.
	LoadByAggregate(ctx context.Context, aggregateID string, since Version, filters ...Filter) ([]EventWithVersion, error)

	// LatestVersion returns the latest version in the store.
	LatestVersion(ctx context.Context) (Version, error)

	// ParseVersion converts a string representation into a Version implementation.
	ParseVersion(ctx context.Context, versionStr string) (Version, error)

	// Close releases resources.
	Close() error
}

type EventWithVersion struct {
	Event   Event
	Version Version
}

type Filter struct{ Key, Value string }

type ResolvedConflict struct {
	ResolvedEvents []EventWithVersion
	Decision       string
	Reasons        []string
}

type Transport interface {
	// Push sends a batch of events to the remote endpoint.
	Push(ctx context.Context, events []EventWithVersion) error

	// Pull retrieves events from the remote endpoint strictly after the version.
	Pull(ctx context.Context, since Version) ([]EventWithVersion, error)

	// GetLatestVersion efficiently retrieves the latest remote version without pulling events.
	GetLatestVersion(ctx context.Context) (Version, error)

	// Subscribe listens for real-time updates. Implementations may be streaming
	// or event-based callbacks. Handler should be invoked with batches.
	Subscribe(ctx context.Context, handler EventHandler) error

	// Close closes the transport connection and releases resources.
	Close() error
}

type Version interface {
	// Compare returns -1 if this version is before other, 0 if equal, 1 if after
	Compare(other Version) int

	// String returns a string representation of the version
	String() string

	// IsZero returns true if this is the zero/initial version
	IsZero() bool
}