caches

type AccountDataUpdate struct {
	AccountData []state.AccountData
}

type CacheFinder interface {
	CacheForUser(userID string) *UserCache
}

type DeviceDataUpdate struct {
}

type DeviceEventsUpdate struct {
}

type EventData struct {
	Event     json.RawMessage
	RoomID    string
	EventType string
	StateKey  *string
	Content   gjson.Result
	Timestamp uint64
	Sender    string

	// the number of joined users in this room. Use this value and don't try to work it out as you
	// may get it wrong due to Synapse sending duplicate join events(!) This value has them de-duped
	// correctly.
	JoinCount   int
	InviteCount int

	// the absolute latest position for this event data. The NID for this event is guaranteed to
	// be <= this value. See PosAlwaysProcess and PosDoNotProcess for things outside the event timeline
	// e.g invites
	LatestPos int64

	// Flag set when this event should force the room contents to be resent e.g
	// state res, initial join, etc
	ForceInitial bool
}

type GlobalCache struct {
	LoadJoinedRoomsOverride func(userID string) (pos int64, joinedRooms map[string]*internal.RoomMetadata, err error)
	// contains filtered or unexported fields
}

type InviteData struct {
	InviteState          []json.RawMessage
	Heroes               []internal.Hero
	InviteEvent          *EventData
	NameEvent            string // the content of m.room.name, NOT the calculated name
	CanonicalAlias       string
	LastMessageTimestamp uint64
	Encrypted            bool
	IsDM                 bool
	// contains filtered or unexported fields
}

type InviteUpdate struct {
	RoomUpdate
	InviteData InviteData
}

type LeftRoomUpdate struct {
	RoomUpdate
}

type ReceiptUpdate struct {
	RoomUpdate
	EphemeralEvent json.RawMessage
}

type RoomAccountDataUpdate struct {
	RoomUpdate
	AccountData []state.AccountData
}

type RoomEventUpdate struct {
	RoomUpdate
	EventData *EventData
}

type RoomUpdate interface {
	Update
	RoomID() string
	GlobalRoomMetadata() *internal.RoomMetadata
	UserRoomMetadata() *UserRoomData
}

type TransactionIDFetcher interface {
	TransactionIDForEvents(deviceID string, eventIDs []string) (eventIDToTxnID map[string]string)
}

type TypingUpdate struct {
	RoomUpdate
}

type UnreadCountUpdate struct {
	RoomUpdate
	HasCountDecreased bool
}

type Update interface {
}

type UserCache struct {
	LazyRoomDataOverride func(loadPos int64, roomIDs []string, maxTimelineEvents int) map[string]UserRoomData
	UserID               string
	// contains filtered or unexported fields
}

type UserCacheListener interface {
	// Called when there is an update affecting a room e.g new event, unread count update, room account data.
	// Type-cast to find out what the update is about.
	OnRoomUpdate(ctx context.Context, up RoomUpdate)
	// Called when there is an update affecting this user but not in the room e.g global account data, presence.
	// Type-cast to find out what the update is about.
	OnUpdate(ctx context.Context, up Update)
}

type UserRoomData struct {
	IsDM              bool
	IsInvite          bool
	HasLeft           bool
	NotificationCount int
	HighlightCount    int
	// (event_id, last_event_id) -> closest prev_batch
	// We mux in last_event_id so we can invalidate prev batch tokens for the same event ID when a new timeline event
	// comes in, without having to do a SQL query.
	PrevBatches       *lru.Cache
	Timeline          []json.RawMessage
	Invite            *InviteData
	CanonicalisedName string // stripped leading symbols like #, all in lower case
	// Set of spaces this room is a part of, from the perspective of this user. This is NOT global room data
	// as the set of spaces may be different for different users.
	Spaces map[string]struct{}
	// Map of tag to order float.
	// See https://spec.matrix.org/latest/client-server-api/#room-tagging
	Tags map[string]float64
	// the load state of the timeline
	LoadPos int64
}