client

type Cache interface {
	AddDispatch(h uint32) bool
	HasDispatch(h uint32) bool
	ExpireDispatch(h uint32)
}

type Connection interface {
	Context() context.Context
	// Retrieve the hex-encoded ID of this session
	SessionID() string
	// Greet sends an Hello message to the client
	Greet(gctx global.Context) error
	// Listen for incoming and outgoing events
	Read(gctx global.Context)
	// SendHeartbeat lets the client know that the connection is healthy
	SendHeartbeat() error
	// SendAck sends an Ack message to the client
	SendAck(cmd events.Opcode, data json.RawMessage) error
	// SendError publishes an error message to the client
	SendError(txt string, fields map[string]any)
	// Write sends a message to the client
	Write(msg events.Message[json.RawMessage]) error
	// Actor returns the authenticated user for this connection
	Actor() *structures.User
	// Handler returns a utility to handle commands for the connection
	Handler() Handler
	// Subscriptions returns an instance of Events
	Events() *EventMap
	// Cache returns the connection's cache utility
	Cache() Cache
	// Buffer returns the connection's event buffer utility for resuming the session
	Buffer() EventBuffer
	// Ready returns a channel that is closed when the connection is ready
	OnReady() <-chan struct{}
	// OnClose returns a channel that is closed when the connection is closed
	OnClose() <-chan struct{}
	// Close sends a close frame with the specified code and ends the connection
	SendClose(code events.CloseCode, after time.Duration)
	// SetWriter defines the connection's writable stream (SSE only)
	SetWriter(w *bufio.Writer, f http.Flusher)
	// Return the name of the transport used by this connection
	Transport() Transport
}

type EventBuffer interface {
	Context() context.Context
	// Start begins tracking events and subscriptions
	Start(gctx global.Context) error
	// Push messages to the buffer
	Push(gctx global.Context, msg events.Message[events.DispatchPayload]) error
	// Recover retrieves the buffer from the previous session
	Recover(gctx global.Context) (eventList []events.Message[events.DispatchPayload], subList []StoredSubscription, err error)
	// Cleanup clears out redis keys
	Cleanup(gctx global.Context) error
}

type EventChannel struct {
	ID         []uint32                      `json:"id"`
	Conditions []events.EventCondition       `json:"conditions"`
	Properties []EventSubscriptionProperties `json:"properties"`
	// contains filtered or unexported fields
}

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

type EventSubscriptionProperties struct {
	TTL  time.Time
	Auto bool
}

type Handler interface {
	Subscribe(gctx global.Context, m events.Message[json.RawMessage]) (error, bool)
	Unsubscribe(gctx global.Context, m events.Message[json.RawMessage]) error
	OnDispatch(gctx global.Context, msg events.Message[events.DispatchPayload])
	OnResume(gctx global.Context, msg events.Message[json.RawMessage]) error
	OnBridge(gctx global.Context, msg events.Message[json.RawMessage]) error
}

type StoredSubscription struct {
	Type    events.EventType `json:"type"`
	Channel EventChannel     `json:"channel"`
}

type Transport string