projection

type Accumulate struct {
	AllowLateArrival time.Duration
}

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

type AccumulatingAndRetracting struct {
	AllowLateArrival time.Duration
}

type AllOf struct {
	Triggers []TriggerDescription
}

type AnyOf struct {
	Triggers []TriggerDescription
}

type AtPeriod struct {
	Duration time.Duration
}

type AtPeriod1 = AtPeriod

type AtWatermark struct {
	Timestamp int64
}

type AtWatermark1 = AtWatermark

type AtWindowItemSize struct {
	Number int
}

type AtWindowItemSize1 = AtWindowItemSize

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

type BagOf[A any] interface {
	Set(key string, value A) error
	Get(key string) (A, error)
	Del(key string) error
	Range(f func(key string, item A))
}

type Builder interface {
	Load(f Handler, opts ...ContextOptionFunc) Builder
	Window(opts ...ContextOptionFunc) Builder
	Map(f Handler, opts ...ContextOptionFunc) Builder
	Join(a, b Builder, opts ...ContextOptionFunc) Builder
	Build() []Node
}

type ContextOptionFunc func(c *DefaultContext)

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

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

type DebounceHandler struct {
	MaxSize int
	MaxTime time.Duration
	// contains filtered or unexported fields
}

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

type Discard struct{}

type DoJoin struct {
	Ctx   *DefaultContext
	Input []Node
}

type DoLoad struct {
	Ctx    *DefaultContext
	OnLoad Handler
}

type DoMap struct {
	Ctx   *DefaultContext
	OnMap Handler
	Input Node
}

type DoWindow struct {
	Ctx   *DefaultContext
	Input Node
}

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

type EvaluateTrigger[T0 TriggerDescription, T1 TriggerType] interface {
	MatchPeriod(*AtPeriod, *AtPeriod)
	MatchCount(*AtWindowItemSize, *AtWindowItemSize)
	MatchWatermark(*AtWatermark, *AtWatermark)
	MatchAnyOfAny(*AnyOf, TriggerType)
	MatchAllOfAny(*AllOf, TriggerType)
	MatchDefault(T0, T1)
}

type EventTime = int64

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

type ExecutionStatus int

type FilterHandler struct {
	Where *predicate.WherePredicates
}

type FixedWindow struct {
	Width time.Duration
}

type Game struct {
	SessionID string
	Players   []string
	Winner    string
	IsDraw    bool
}

type GenerateHandler struct {
	Load func(push func(message Item)) error
}

type Handler interface {
	Process(x Item, returning func(Item)) error
	Retract(x Item, returning func(Item)) error
}

type InMemoryBagOf[A any] struct {
	// contains filtered or unexported fields
}

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

type Item struct {
	Key       string
	Data      schema.Schema
	EventTime EventTime
	Window    *Window
	Type      ItemType
}

type ItemGroupedByKey struct {
	Key  string
	Data []Item
}

type ItemGroupedByWindow struct {
	Key    string
	Data   *schema.List
	Window *Window
}

type ItemType uint8

type JoinHandler[T any] struct {
	F func(a, b T, returning func(T)) error
}

type KeyedWindow struct {
	Key    string
	Window *Window
}

type ListAssert struct {
	Items []Item
	Err   error
	// contains filtered or unexported fields
}

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

type MapHandler[A any, B any] struct {
	F func(x A, returning func(key string, value B)) error
}

type MergeHandler[A any] struct {
	Combine   func(a, b A) (A, error)
	DoRetract func(a, b A) (A, error)
}

type Message struct {
	Offset int
	// at some point of time i may need to pass type reference
	Key       string
	Item      *Item
	Watermark *int64
	// contains filtered or unexported fields
}

type Node interface {
	AcceptNode(g NodeVisitor) any
}

type NodeUnionJSON struct {
	Type     string          `json:"$type,omitempty"`
	DoWindow json.RawMessage `json:"projection.DoWindow,omitempty"`
	DoMap    json.RawMessage `json:"projection.DoMap,omitempty"`
	DoLoad   json.RawMessage `json:"projection.DoLoad,omitempty"`
	DoJoin   json.RawMessage `json:"projection.DoJoin,omitempty"`
}

type NodeVisitor interface {
	VisitDoWindow(v *DoWindow) any
	VisitDoMap(v *DoMap) any
	VisitDoLoad(v *DoLoad) any
	VisitDoJoin(v *DoJoin) any
}

type PubSub[T comparable] struct {
	// contains filtered or unexported fields
}

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

type PubSubForInterpreter[T comparable] interface {
	Register(key T) error
	Publish(ctx context.Context, key T, msg Message) error
	Finish(ctx context.Context, key T)
	Subscribe(ctx context.Context, node T, fromOffset int, f func(Message) error) error
}

type PubSubMulti[T comparable] struct {
	// contains filtered or unexported fields
}

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

type PubSubSingler[T comparable] interface {
	Publish(msg T) error
	Process()
	Subscribe(f func(T) error) error
	Close()
}

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

type SessionWindow struct {
	GapDuration time.Duration
}

type SessionsStats struct {
	Wins  int
	Draws int
	Loose int
}

type SimpleProcessHandler struct {
	P func(x Item, returning func(Item)) error
	R func(x Item, returning func(Item)) error
}

type SlidingWindow struct {
	Width  time.Duration
	Period time.Duration
}

type Stats = map[string]int

type StatsCollector interface {
	Snapshot() Stats
	Incr(key string, increment int)
}

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

type TimeSignaler interface {
	SignalDuration(duration time.Duration)
}

type TriggerDescription interface {
	AcceptTriggerDescription(g TriggerDescriptionVisitor) any
}

type TriggerDescriptionUnionJSON struct {
	Type             string          `json:"$type,omitempty"`
	AtPeriod         json.RawMessage `json:"projection.AtPeriod,omitempty"`
	AtWindowItemSize json.RawMessage `json:"projection.AtWindowItemSize,omitempty"`
	AtWatermark      json.RawMessage `json:"projection.AtWatermark,omitempty"`
	AnyOf            json.RawMessage `json:"projection.AnyOf,omitempty"`
	AllOf            json.RawMessage `json:"projection.AllOf,omitempty"`
}

type TriggerDescriptionVisitor interface {
	VisitAtPeriod(v *AtPeriod) any
	VisitAtWindowItemSize(v *AtWindowItemSize) any
	VisitAtWatermark(v *AtWatermark) any
	VisitAnyOf(v *AnyOf) any
	VisitAllOf(v *AllOf) any
}

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

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

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

type TriggerType interface {
	AcceptTriggerType(g TriggerTypeVisitor) any
}

type TriggerTypeUnionJSON struct {
	Type              string          `json:"$type,omitempty"`
	AtPeriod1         json.RawMessage `json:"projection.AtPeriod1,omitempty"`
	AtWindowItemSize1 json.RawMessage `json:"projection.AtWindowItemSize1,omitempty"`
	AtWatermark1      json.RawMessage `json:"projection.AtWatermark1,omitempty"`
}

type TriggerTypeVisitor interface {
	VisitAtPeriod1(v *AtPeriod1) any
	VisitAtWindowItemSize1(v *AtWindowItemSize1) any
	VisitAtWatermark1(v *AtWatermark1) any
}

type WatermarkSignaler interface {
	SignalWatermark(timestamp int64)
}

type Window struct {
	Start int64
	End   int64
}

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

type WindowBufferSignaler interface {
	SignalWindowCreated(kw *KeyedWindow)
	SignalWindowDeleted(kw *KeyedWindow)
	SignalWindowSizeReached(kw *KeyedWindow, size int)
}

type WindowDescription interface {
	AcceptWindowDescription(g WindowDescriptionVisitor) any
}

type WindowDescriptionUnionJSON struct {
	Type          string          `json:"$type,omitempty"`
	SessionWindow json.RawMessage `json:"projection.SessionWindow,omitempty"`
	SlidingWindow json.RawMessage `json:"projection.SlidingWindow,omitempty"`
	FixedWindow   json.RawMessage `json:"projection.FixedWindow,omitempty"`
}

type WindowDescriptionVisitor interface {
	VisitSessionWindow(v *SessionWindow) any
	VisitSlidingWindow(v *SlidingWindow) any
	VisitFixedWindow(v *FixedWindow) any
}

type WindowFlushMode interface {
	AcceptWindowFlushMode(g WindowFlushModeVisitor) any
}

type WindowFlushModeUnionJSON struct {
	Type                      string          `json:"$type,omitempty"`
	Accumulate                json.RawMessage `json:"projection.Accumulate,omitempty"`
	Discard                   json.RawMessage `json:"projection.Discard,omitempty"`
	AccumulatingAndRetracting json.RawMessage `json:"projection.AccumulatingAndRetracting,omitempty"`
}

type WindowFlushModeVisitor interface {
	VisitAccumulate(v *Accumulate) any
	VisitDiscard(v *Discard) any
	VisitAccumulatingAndRetracting(v *AccumulatingAndRetracting) any
}

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