streams

type Collector interface {
	// Collect ...
	Collect(ch chan<- Metric)
}

type Gatherer interface {
	// Gather ...
	Gather(collector Collector)
}

type Iterator interface {
	// Next moves the cursor to the next key/value pair, which will then be available through the Key, Value and Latest methods.
	// It returns false if the iterator is exhausted.
	Next() <-chan NextCursor
}

type Key interface {
	int | ~string | []byte
}

type MessageChannel[K, V any] chan msg.Message[K, V]

type MessageReceiver[K, V any] chan msg.Message[K, V]

type Messages[K, V any] chan msg.Message[K, V]

type Metric interface {
	// Write ...
	Write(m *Monitor) error
}

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

type Monitor struct {
	sync.Mutex
	// contains filtered or unexported fields
}

type NextCursor struct {
	Key    string
	Value  []byte
	Latest bool
}

type Node interface {
	// AddChild adds a child to a node.
	AddChild(Node)

	// Children returns the children of a node.
	Children() []Node

	// Name returns the name of a node.
	Name() string
}

type Opt func(*Opts)

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

type Predicate[K, V any] func(msg.Message[K, V]) (bool, error)

type Probe[K, V any] interface {
	// Do ...
	Do(ctx context.Context, monitor Monitor) error

	Collector
}

type Registry struct {
	*prometheus.Registry
}

type Sink[K, V any] interface {
	Write(...msg.Message[K, V]) error
}

type Source[K, V any] interface {
	// Messages returns a channel of messages.
	Messages() chan msg.Message[K, V]

	// Commit commits a message.
	Commit(...msg.Message[K, V]) error

	// Error returns an error.
	Error() error
}

type Stream[K Key, V Value] interface {
	// Close closes a stream.
	Close()

	// Do executes a function on a stream.
	Do(name string, fn func(msg.Message[K, V])) Stream[K, V]

	// Drain drains a stream.
	Drain()

	// FanOut splits a stream into multiple streams.
	FanOut(name string, predicates ...Predicate[K, V]) []Stream[K, V]

	// Filter filters a stream.
	Filter(name string, predicate Predicate[K, V]) Stream[K, V]

	// Map maps a stream.
	Map(name string, fn func(msg.Message[K, V]) (msg.Message[K, V], error)) Stream[K, V]

	// Mark marks a message.
	Mark() Stream[K, V]

	// Log logs a message.
	Log(name string) Stream[K, V]

	// Sink sends messages to a sink.
	Sink(name string, sink Sink[K, V])

	// Errors returns the first error.
	Error() error
}

type StreamImpl[K, V any] struct {
	Collector
	// contains filtered or unexported fields
}

type Table interface {
	// Set is setting a key/value pair.
	Set(key string, value []byte) error

	// Delete is deleting a key/value pair.
	Delete(key string) error

	// Setup is setting up the table.
	Setup() error

	// Error is returning the error.
	Error() error

	// Sink is the interface that wraps the basic Sink method.
	Sink[string, []byte]

	Iterator
}

type Topology interface {
	// Root returns the root node of a topology.
	Root() Node
}

type Unimplemented[K Key, V Value] struct{}

type Value interface {
	int | ~string | []byte
}