kstreams

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

type AssignedOrRevoked struct {
	Assigned map[string][]int32
	Revoked  map[string][]int32
}

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

type Deserializer[T any] func([]byte) (T, error)

type Flusher interface {
	Flush(context.Context) error
}

type Input[Kin any, Vin any] struct {
}

type InputProcessor[K any, V any] interface {
	Process(context.Context, K, V) error
}

type InternalProcessorContext[Kout any, Vout any] struct {
	// contains filtered or unexported fields
}

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

type Nexter[K, V any] interface {
	AddNext(InputProcessor[K, V])
}

type Node interface {
	Init() error
	Close() error
}

type NullWriter struct{}

type Option func(*App)

type Output[Kout any, Vout any] struct {
}

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

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

type Processor[Kin any, Vin any, Kout any, Vout any] interface {
	Init(ProcessorContext[Kout, Vout]) error
	Close() error
	Process(ctx context.Context, k Kin, v Vin) error
}

type ProcessorBuilder[Kin any, Vin any, Kout any, Vout any] func() Processor[Kin, Vin, Kout, Vout]

type ProcessorContext[Kout any, Vout any] interface {
	// Forward to all child nodes.
	Forward(ctx context.Context, k Kout, v Vout)
	// Forward to specific child node. Panics if child node is not found.
	ForwardTo(ctx context.Context, k Kout, v Vout, childName string) // TBD: should forward return error ? or are errs...ignored?
	// Get state store by name. Returns nil if not found.
	GetStore(name string) Store
}

type ProcessorInterceptor[K any, V any, Kout any, Vout any] func(ctx context.Context, k K, v V, processor Processor[K, V, Kout, Vout])

type ProcessorNode[Kin any, Vin any, Kout any, Vout any] struct {
	// contains filtered or unexported fields
}

type Record[K, V any] struct {
	Key   K
	Value V
	X     kgo.Record
}

type RecordProcessor interface {
	Process(ctx context.Context, m *kgo.Record) error
}

type RoutineState string

type SerDe[T any] struct {
	Serializer   Serializer[T]
	Deserializer Deserializer[T]
}

type Serializer[T any] func(T) ([]byte, error)

type SinkNode[K any, V any] struct {
	KeySerializer   Serializer[K]
	ValueSerializer Serializer[V]
	// contains filtered or unexported fields
}

type SourceNode[K any, V any] struct {
	KeyDeserializer   Deserializer[K]
	ValueDeserializer Deserializer[V]

	DownstreamProcessors []InputProcessor[K, V]
}

type Store interface {
	Init() error
	Flush() error
	Close() error
}

type StoreBackend interface {
	Store
	Set(k, v []byte) error
	Get(k []byte) (v []byte, err error)
}

type StoreBackendBuilder func(name string, p int32) (StoreBackend, error)

type StoreBuilder func(name string, partition int32) (Store, error)

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

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

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

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

type TopologyProcessor struct {
	Name           string
	Build          func(stores map[string]Store) Node
	ChildNodeNames []string
	AddChildFunc   func(parent any, child any, childName string) // TODO - possible to do w/o parent ?
	StoreNames     []string
}

type TopologySink struct {
	Name    string
	Builder func(*kgo.Client) Flusher
}

type TopologySource struct {
	Name           string
	Build          func() RecordProcessor
	ChildNodeNames []string
	AddChildFunc   func(parent any, child any, childName string) // TODO - possible to do w/o parent ?
}

type TopologyStore struct {
	Name  string
	Build StoreBuilder
}

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

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