handler

type BlockUserFetcher interface {
	Get(userId string) (user domain.User, err error)
}

type BlocksStorer interface {
	Block(blockerId, blockeeId string) error
	Unblock(blockerId, blockeeId string) error
	List(blockerId string, limit *uint64, cursor *string) ([]string, string, error)
}

type BookmarkStorer interface {
	Bookmark(userId, tweetId, ownerUserId string) error
	Unbookmark(userId, tweetId string) error
	List(userId string, limit *uint64, cursor *string) ([]domain.Bookmark, string, error)
}

type CRDTLikesCounter interface {
	GetLikesCount(tweetID string) (uint64, error)
}

type CRDTRepliesCounter interface {
	GetRepliesCount(tweetID string) (uint64, error)
}

type CRDTRetweetsCounter interface {
	GetRetweetsCount(tweetID string) (uint64, error)
}

type ChatAuthStorer interface {
	GetOwner() domain.Owner
}

type ChatStorer interface {
	CreateChat(chatId *string, ownerId, otherUserId string) (domain.Chat, error)
	DeleteChat(chatId string) error
	GetUserChats(userId string, limit *uint64, cursor *string) ([]domain.Chat, string, error)
	CreateMessage(msg domain.ChatMessage) (domain.ChatMessage, error)
	ListMessages(chatId string, limit *uint64, cursor *string) ([]domain.ChatMessage, string, error)
	GetMessage(chatId, id string) (domain.ChatMessage, error)
	DeleteMessage(chatId, id string) error
	GetChat(chatId string) (chat domain.Chat, err error)
}

type ChatStreamer interface {
	GenericStream(nodeId string, path stream.WarpRoute, data any) (_ []byte, err error)
	NodeInfo() warpnet.NodeInfo
}

type ChatUserFetcher interface {
	GetByNodeID(nodeID string) (user domain.User, err error)
	Get(userId string) (user domain.User, err error)
}

type DeviceStorer interface {
	SetDevice(ownerNodeId string, device domain.Device) error
}

type EngagementStreamer interface {
	GenericStream(nodeId string, path stream.WarpRoute, data any) (_ []byte, err error)
	NodeInfo() warpnet.NodeInfo
}

type FilterStorer interface {
	Create(userId string, f domain.Filter) (domain.Filter, error)
	Get(userId, filterId string) (domain.Filter, error)
	Update(userId string, f domain.Filter) (domain.Filter, error)
	Delete(userId, filterId string) error
	List(userId string, limit *uint64, cursor *string) ([]domain.Filter, string, error)
	AddKeyword(userId, filterId string, kw domain.FilterKeyword) (domain.FilterKeyword, error)
	UpdateKeyword(userId string, kw domain.FilterKeyword) (domain.FilterKeyword, error)
	DeleteKeyword(userId, keywordId string) error
}

type FollowNodeStreamer interface {
	GenericStream(nodeId string, path stream.WarpRoute, data any) ([]byte, error)
}

type FollowingAuthStorer interface {
	GetOwner() domain.Owner
}

type FollowingBroadcaster interface {
	SubscribeUserUpdate(userId string) (err error)
	UnsubscribeUserUpdate(userId string) (err error)
}

type FollowingStorer interface {
	Follow(fromUserId, toUserId string) error
	Unfollow(fromUserId, toUserId string) error
	GetFollowers(userId string, limit *uint64, cursor *string) ([]string, string, error)
	GetFollowings(userId string, limit *uint64, cursor *string) ([]string, string, error)
	IsFollowing(ownerId, otherUserId string) bool
	IsFollower(ownerId, otherUserId string) bool
	AddFollowRequest(targetUserId, followerId string) error
	RemoveFollowRequest(targetUserId, followerId string) error
	ListFollowRequests(targetUserId string, limit *uint64, cursor *string) ([]string, string, error)
}

type FollowingUserStorer interface {
	Get(userId string) (user domain.User, err error)
	List(limit *uint64, cursor *string) ([]domain.User, string, error)
	Create(user domain.User) (domain.User, error)
}

type ImportTweetStorer interface {
	Create(_ string, tweet domain.Tweet) (domain.Tweet, error)
}

type LikeStreamer interface {
	GenericStream(nodeId string, path stream.WarpRoute, data any) (_ []byte, err error)
	NodeInfo() warpnet.NodeInfo
}

type LikeTweetStorer interface {
	Like(tweetId, userId string) (likesNum uint64, err error)
	Unlike(tweetId, userId string) (likesNum uint64, err error)
	LikesCount(tweetId string) (likesNum uint64, err error)
	Likers(tweetId string, limit *uint64, cursor *string) (likers []string, cur string, err error)
}

type LikeTweetsStorer interface {
	Get(userID, tweetID string) (tweet domain.Tweet, err error)
	List(string, *uint64, *string) ([]domain.Tweet, string, error)
	Create(_ string, tweet domain.Tweet) (domain.Tweet, error)
	Delete(userID, tweetID string) error
}

type LikedTweetsLister interface {
	Liked(userId string, limit *uint64, cursor *string) ([]domain.LikedTweet, string, error)
}

type LikedUserFetcher interface {
	GetBatch(userIds ...string) (users []domain.User, err error)
	Get(userId string) (users domain.User, err error)
}

type LikersLister interface {
	Likers(tweetId string, limit *uint64, cursor *string) ([]string, string, error)
}

type LikesStorer interface {
	Like(tweetId, userId string) (likesNum uint64, err error)
	Unlike(tweetId, userId string) (likesNum uint64, err error)
	LikesCount(tweetId string) (likesNum uint64, err error)
	Likers(tweetId string, limit *uint64, cursor *string) (likers []string, cur string, err error)
	SetLiked(userId, tweetId, ownerUserId string) error
	RemoveLiked(userId, tweetId string) error
}

type MediaMetaStorer interface {
	SetImageMeta(userId, key string, meta database.MediaMeta) error
	GetImageMeta(userId, key string) (database.MediaMeta, error)
}

type MediaNodeInformer interface {
	NodeInfo() warpnet.NodeInfo
}

type MediaStorer interface {
	GetImage(userId, key string) (database.Base64Image, error)
	SetImage(userId string, img database.Base64Image) (_ database.ImageKey, err error)
	SetForeignImageWithTTL(userId, key string, img database.Base64Image) error
}

type MediaStreamer interface {
	GenericStream(nodeId string, path stream.WarpRoute, data any) (_ []byte, err error)
	NodeInfo() warpnet.NodeInfo
}

type MediaUserFetcher interface {
	Get(userId string) (user domain.User, err error)
}

type MetricsNodeInformer interface {
	NodeInfo() warpnet.NodeInfo
	Peerstore() warpnet.WarpPeerstore
	Network() warpnet.WarpNetwork
}

type MetricsProvider interface {
	Stats() map[string]string
}

type ModerationNotifier interface {
	Add(not domain.Notification) error
}

type ModerationTimelelineDeleter interface {
	DeleteTweetFromTimeline(userID, tweetID string) error
}

type ModerationTweetUpdater interface {
	Update(tweet domain.Tweet) error
}

type ModerationUserUpdater interface {
	Get(userId string) (domain.User, error)
	Update(userId string, user domain.User) (domain.User, error)
}

type MutesStorer interface {
	Mute(muterId, muteeId string) error
	Unmute(muterId, muteeId string) error
	List(muterId string, limit *uint64, cursor *string) ([]string, string, error)
}

type NodeAddresser interface {
	PublicAddrs() []warpnet.WarpAddress
}

type NodeInformer interface {
	NodeInfo() warpnet.NodeInfo
}

type NotifierAllMarker interface {
	MarkAllRead(userId string) error
}

type NotifierAuthStorer interface {
	GetOwner() domain.Owner
}

type NotifierFetcher interface {
	List(userId string, limit *uint64, cursor *string) ([]domain.Notification, string, error)
	ReverseList(userId string, cursor *string, limit *uint64) ([]domain.Notification, string, error)
	UnreadCount(userId string) (uint64, error)
}

type NotifierGetter interface {
	Get(userId, notificationId string) (domain.Notification, error)
}

type NotifierMarker interface {
	MarkRead(userId, notificationId string) error
}

type OwnerChatsStorer interface {
	GetOwner() domain.Owner
}

type OwnerReTweetStorer interface {
	GetOwner() domain.Owner
}

type OwnerTweetStorer interface {
	GetOwner() domain.Owner
}

type PairAuthStorer interface {
	SessionToken() string
}

type PeerBlocklister interface {
	BlocklistPermanent(peerId string) error
	BlocklistRemove(peerId string) error
}

type ReTweetsStorer interface {
	Get(userID, tweetID string) (tweet domain.Tweet, err error)
	NewRetweet(tweet domain.Tweet) (_ domain.Tweet, err error)
	UnRetweet(retweetedByUserID, tweetId string) error
	RetweetsCount(tweetId string) (uint64, error)
	Retweeters(tweetId string, limit *uint64, cursor *string) (_ []string, cur string, err error)
}

type RepliesTweetCounter interface {
	RepliesCount(tweetId string) (likesNum uint64, err error)
}

type ReportPublisher interface {
	PublishReport(ev event.ReportEvent) error
}

type RetweetStreamer interface {
	GenericStream(nodeId string, path stream.WarpRoute, data any) (_ []byte, err error)
	NodeInfo() warpnet.NodeInfo
}

type RetweetTimelineUpdater interface {
	AddTweetToTimeline(userId string, tweet domain.Tweet) error
}

type RetweetedUserFetcher interface {
	GetBatch(retweetersIds ...string) (users []domain.User, err error)
	Get(userId string) (users domain.User, err error)
}

type RetweetersLister interface {
	Retweeters(tweetId string, limit *uint64, cursor *string) ([]string, string, error)
}

type RetweetsTweetStorer interface {
	Get(userID, tweetID string) (tweet domain.Tweet, err error)
	NewRetweet(tweet domain.Tweet) (_ domain.Tweet, err error)
	UnRetweet(retweetedByUserID, tweetId string) error
	RetweetsCount(tweetId string) (uint64, error)
	Retweeters(tweetId string, limit *uint64, cursor *string) (_ []string, cur string, err error)
}

type SettingsAuthStorer interface {
	GetOwner() domain.Owner
}

type SettingsStorer interface {
	GetNotificationSettings(userId string) (domain.NotificationSettings, error)
	SetNotificationSettings(userId string, s domain.NotificationSettings) error
}

type SubscriptionStorer interface {
	Subscribe(selfId, targetUserId string) error
	Unsubscribe(selfId, targetUserId string) error
}

type TimelineFetcher interface {
	GetTimeline(string, *uint64, *string) ([]domain.Tweet, string, error)
}

type TimelineUpdater interface {
	AddTweetToTimeline(userId string, tweet domain.Tweet) error
	DeleteTweetFromTimeline(userID, tweetID string) error
}

type TweetBroadcaster interface {
	PublishUpdateToFollowers(ownerId, dest string, bt []byte) (err error)
}

type TweetFollowChecker interface {
	IsFollowing(ownerId, authorId string) bool
}

type TweetStreamer interface {
	GenericStream(nodeId string, path stream.WarpRoute, data any) (_ []byte, err error)
	NodeInfo() warpnet.NodeInfo
}

type TweetUserFetcher interface {
	Get(userId string) (user domain.User, err error)
}

type TweetsStorer interface {
	TweetsCount(userId string) (uint64, error)
	GetViewsCount(tweetId string) (uint64, error)
	IsBlocklisted(tweetId string) bool
	Blocklist(tweetId string) error
	Get(userID, tweetID string) (tweet domain.Tweet, err error)
	List(string, *uint64, *string) ([]domain.Tweet, string, error)
	Create(_ string, tweet domain.Tweet) (domain.Tweet, error)
	Delete(userID, tweetID string) error
	UnRetweet(retweetedByUserID, tweetId string) error
	Retweeters(tweetId string, limit *uint64, cursor *string) (_ []string, cur string, err error)
	CreateWithTTL(userId string, tweet domain.Tweet, duration time.Duration) (domain.Tweet, error)
	Update(tweet domain.Tweet) error
	Pin(userId, tweetId string) (domain.Tweet, error)
	Unpin(userId, tweetId string) (domain.Tweet, error)
	AppendEdit(edit domain.TweetEdit) (domain.TweetEdit, error)
	AddReply(reply domain.Tweet) (domain.Tweet, error)
	GetReply(parentID, replyID string) (domain.Tweet, error)
	DeleteReply(parentID, replyID string) (domain.Tweet, error)
	GetReplies(parentID string, limit *uint64, cursor *string) ([]domain.Tweet, string, error)
}

type UserAuthStorer interface {
	GetOwner() domain.Owner
}

type UserFetcher interface {
	Create(user domain.User) (domain.User, error)
	Get(userId string) (user domain.User, err error)
	List(limit *uint64, cursor *string) ([]domain.User, string, error)
	Search(query string, limit *uint64, cursor *string) ([]domain.User, string, error)
	WhoToFollow(limit *uint64, cursor *string) ([]domain.User, string, error)
	Update(userId string, newUser domain.User) (updatedUser domain.User, err error)
	CreateWithTTL(user domain.User, ttl time.Duration) (domain.User, error)
}

type UserFollowsCounter interface {
	GetFollowersCount(userId string) (uint64, error)
	GetFollowingsCount(userId string) (uint64, error)
	GetFollowers(userId string, limit *uint64, cursor *string) ([]string, string, error)
	GetFollowings(userId string, limit *uint64, cursor *string) ([]string, string, error)
}

type UserStreamer interface {
	GenericStream(nodeId string, path stream.WarpRoute, data any) (_ []byte, err error)
	NodeInfo() warpnet.NodeInfo
}

type UserTweetsCounter interface {
	TweetsCount(userID string) (uint64, error)
}

type ViewsStorer interface {
	RecordView(tweetId, viewerId string) (uint64, error)
	GetViewsCount(tweetId string) (uint64, error)
}