es

type Base struct {
	EvtID         ID        `json:"id"`
	EvtOccurredOn time.Time `json:"occurred-on"`
	MetaData      MetaData  `json:"meta"`
}

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

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

type DomainEvent interface {
	ID() ID
	OccurredOn() time.Time
	Meta() *MetaData
}

type DomainEventStream chan DomainEvent

type DomainEvents []DomainEvent

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

type ID string

type LimitOffset struct {
	Limit  uint64
	Offset uint64
}

type MetaData map[string]interface{}

type QueryParams struct {
	StreamID string
	ToDate   time.Time
	Type     string
	SortASC  bool
}

type RawEvent struct {
	ID          ID              `json:"id,omitempty"`          // the unique id of the event
	StoreIndex  uint64          `json:"store-index"`           // the index of the event within the whole store
	StreamID    string          `json:"stream-id,omitempty"`   // the id of the current stream
	StreamIndex uint64          `json:"stream-index"`          // the index of the event within the current stream
	RecordedOn  time.Time       `json:"recorded-on,omitempty"` // the time the event was first recorded
	OccurredOn  time.Time       `json:"occurred-on,omitempty"` // the time the event occurred
	Type        string          `json:"type"`                  // the type of the domain event
	Data        json.RawMessage `json:"data,omitempty"`        // the data of the domain event
}

type RawEventStream chan RawEvent

type RawEvents []RawEvent

type RawEventsStream chan RawEvents

type SqliteXStore struct {
	*log.Hook
	// contains filtered or unexported fields
}

type Store interface {
	Close()
	Subscribe(streamID StreamID) *StreamUpdateSubscription
	StreamVersion(streamID StreamID) uint64
	StoreVersion() uint64
	Append(streamID StreamID, expectedVersion uint64, events ...RawEvent) error
	Create(events ...RawEvent) error
	LoadSlice(streamID StreamID, lo LimitOffset) (RawEvents, error)
	LoadSliceUntil(streamID StreamID, lo LimitOffset, until time.Time) (RawEvents, error)
	LoadSliceDescending(streamID StreamID, lo LimitOffset) (RawEvents, error)
	LoadSliceFromVersion(streamID StreamID, version uint64, lo LimitOffset) (RawEvents, error)
	Query(params QueryParams, lo LimitOffset) (RawEvents, error)
	QueryWithTypePrefix(prefix string, params QueryParams, lo LimitOffset) (RawEvents, error)
	Find(id ID) (RawEvent, bool)

	PurgeBefore(t time.Time) (numDeleted int, err error)
	AllStreamIDs() ([]StreamID, error)

	LoadLatestFromAll() (RawEvents, error)
	LoadLatestFrom(streamIDs []string) (RawEvents, error)
}

type StreamID string

type StreamUpdatePublisher struct {
	sync.RWMutex
	// contains filtered or unexported fields
}

type StreamUpdateSubscription struct {
	C chan StreamID
	// contains filtered or unexported fields
}

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