handler

type AliasStorer interface {
	SetAlias(a domain.Alias) error
}

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 CRDTReactionsCounter interface {
	GetReactionsCount(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 ChatMediaChatFetcher interface {
	IsParticipants(ownerId, otherUserId string) bool
}

type ChatMediaStorer interface {
	GetImage(userId, key string) (domain.Base64Image, error)
	SetForeignImageWithTTL(userId, key string, img domain.Base64Image) error
	GetVideo(userId, key string) (domain.Base64Video, error)
	SetForeignVideoWithTTL(userId, key string, video domain.Base64Video) error
}

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

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

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

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 {
	GetAliases() (aliases []domain.Alias, err error)
	DeleteAlias(nodeId string) error
}

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

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

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 FollowNotifier interface {
	Add(not domain.Notification) 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 GatewaySettingsStorer interface {
	GetGatewaySettings(userId string) (domain.GatewaySettings, error)
	SetGatewaySettings(userId string, s domain.GatewaySettings) error
}

type ImageHashLister interface {
	ListImageHashes() ([]domain.TweetImageHashes, error)
}

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

type ImportNodeInformer interface {
	NodeInfo() warpnet.NodeInfo
}

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

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

type MediaNodeInformer interface {
	NodeInfo() warpnet.NodeInfo
}

type MediaStorer interface {
	GetImage(userId, key string) (domain.Base64Image, error)
	SetImage(userId string, img domain.Base64Image) (_ domain.ImageKey, err error)
	SetForeignImageWithTTL(userId, key string, img domain.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 ModerationAuthStorer interface {
	GetOwner() domain.Owner
}

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 {
	Addrs() []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 OrderCounter interface {
	CountConfirmed(buyerId string, from, to time.Time) (int, error)
}

type OrderSettingsFetcher interface {
	GetSponsoredSettings(userId string) (domain.SponsoredSettings, error)
}

type OrderStorer interface {
	OrderCounter
	Get(tweetId, buyerId string) (domain.Order, error)
	Save(o domain.Order) error
	Delete(tweetId, buyerId string) error
	IsPayerTaken(payer, buyerNodeId string) (bool, 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 PollStreamer interface {
	GenericStream(nodeId string, path stream.WarpRoute, data any) (_ []byte, err error)
	NodeInfo() warpnet.NodeInfo
}

type PollTweetFetcher interface {
	Get(userID, tweetID string) (tweet domain.Tweet, err error)
}

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

type PollVotesStorer interface {
	Vote(tweetId, userId string, option int, isTransitive bool) error
	Voted(tweetId, userId string) (option int, ok bool, err error)
	Results(tweetId string, optionsNum int) (votes []uint64, err error)
}

type RateLimitSettingsStorer interface {
	GetRateLimitSettings(userId string) (ratelimit.Settings, error)
	SetRateLimitSettings(userId string, s ratelimit.Settings) error
}

type RatingReader interface {
	View(peerID warpnet.WarpPeerID) (domain.NodeRating, error)
	Own() (domain.NodeRating, error)
}

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

type ReactedTweetsLister interface {
	Reacted(userId string, limit *uint64, cursor *string) ([]domain.ReactedTweet, string, error)
}

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

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

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

type ReactionTweetStorer interface {
	React(tweetId, userId, emoji string, isTransitive bool) (reactionsNum uint64, err error)
	Unreact(tweetId, userId string, isTransitive bool) (reactionsNum uint64, err error)
	ReactionsCount(tweetId string) (reactionsNum uint64, err error)
	Reactors(tweetId string, limit *uint64, cursor *string) (reactors []string, cur string, err error)
	Reactions(tweetId string) (map[string]uint64, error)
	Reaction(tweetId, userId string) (string, error)
}

type ReactionTweetsStorer 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 ReactionsStorer interface {
	React(tweetId, userId, emoji string, isTransitive bool) (reactionsNum uint64, err error)
	Unreact(tweetId, userId string, isTransitive bool) (reactionsNum uint64, err error)
	ReactionsCount(tweetId string) (reactionsNum uint64, err error)
	Reactors(tweetId string, limit *uint64, cursor *string) (reactors []string, cur string, err error)
	Reactions(tweetId string) (map[string]uint64, error)
	SetReacted(userId, tweetId, ownerUserId string) error
	RemoveReacted(userId, tweetId string) error
}

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

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

type ReportOwnerStorer interface {
	GetOwner() domain.Owner
}

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

type RetweetNotifier interface {
	Add(not domain.Notification) 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
	DeleteTweetFromTimeline(userID, tweetID string) error
}

type RetweetedUserFetcher interface {
	GetBatch(retweetersIds ...string) (users []domain.User, err error)
	Get(userId string) (users domain.User, err error)
	Create(user domain.User) (domain.User, 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, isTransitive bool) (_ domain.Tweet, err error)
	UnRetweet(retweetedByUserID, tweetId string, isTransitive bool) 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 SponsoredAuthStorer interface {
	GetOwner() domain.Owner
}

type SponsoredCopyLister interface {
	ListCopies(userId, originalKey string) ([]domain.MediaCopy, error)
}

type SponsoredCopyStorer interface {
	SetCopy(userId, key string, c domain.MediaCopy) error
}

type SponsoredMediaCopyStorer interface {
	GetCopy(userId, key string) (domain.MediaCopy, error)
	GetImage(userId, key string) (domain.Base64Image, error)
	SetForeignImageWithTTL(userId, key string, img domain.Base64Image) error
	GetVideo(userId, key string) (domain.Base64Video, error)
	SetForeignVideoWithTTL(userId, key string, video domain.Base64Video) error
}

type SponsoredMediaFetcher interface {
	GetImage(userId, key string) (domain.Base64Image, error)
	GetVideo(userId, key string) (domain.Base64Video, error)
}

type SponsoredMediaStorer interface {
	GetImage(userId, key string) (domain.Base64Image, error)
	GetVideo(userId, key string) (domain.Base64Video, error)
}

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

type SponsoredMediaUserFetcher interface {
	Get(userId string) (domain.User, error)
	Create(user domain.User) (domain.User, error)
}

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

type SponsoredSettingsStorer interface {
	GetSponsoredSettings(userId string) (domain.SponsoredSettings, error)
	SetSponsoredSettings(userId string, s domain.SponsoredSettings) error
}

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

type SponsoredTweetFetcher interface {
	Get(userID, tweetID string) (domain.Tweet, error)
}

type SponsoredUserFetcher interface {
	Get(userId string) (domain.User, error)
	Create(user domain.User) (domain.User, error)
	GetByNodeID(nodeId string) (domain.User, error)
}

type SponsoredWallet interface {
	Address(ctx context.Context, seed string) (string, error)
	Balance(ctx context.Context, address string) (wallet.Account, error)
	Pay(ctx context.Context, seed string, s wallet.Sponsorship) (wallet.Payment, error)
	Payment(ctx context.Context, s wallet.Sponsorship, since time.Time) (wallet.PaymentState, error)
	Quote(ctx context.Context, seed string, s wallet.Sponsorship) (wallet.Quote, error)
	IsPaid(ctx context.Context, txId string, s wallet.Sponsorship) (wallet.Receipt, error)
	IsAvailable(ctx context.Context) bool
	Splitter() string
	Splitters() []string
	MaxFeePercent() uint64
	Network() string
}

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

type TimelineAuthStorer interface {
	GetOwner() domain.Owner
}

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

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

type TimelineImageHashStorer interface {
	SetImageHashes(h domain.TweetImageHashes) error
}

type TimelinePeersRatings interface {
	IsMediaAllowed(peerID warpnet.WarpPeerID) bool
}

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

type TimelineTweetStorer interface {
	Blocklist(tweetId string) error
	Create(_ string, tweet domain.Tweet) (domain.Tweet, error)
	Delete(userID, tweetID string) error
}

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

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

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

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

type TweetImageFetcher interface {
	GetImage(userId, key string) (domain.Base64Image, error)
}

type TweetImageHashStorer interface {
	SetImageHashes(h domain.TweetImageHashes) error
}

type TweetMediaDeleter interface {
	DeleteImage(userId, key string) error
	DeleteVideo(userId, key string) error
}

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

type TweetPeersRatings interface {
	IsMediaAllowed(peerID warpnet.WarpPeerID) 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)
	Create(user domain.User) (domain.User, 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, isTransitive bool) 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, isTransitive bool) (domain.Tweet, error)
	GetReply(parentID, replyID string) (domain.Tweet, error)
	DeleteReply(parentID, replyID string, isTransitive bool) (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 VideoNodeInformer interface {
	NodeInfo() warpnet.NodeInfo
}

type VideoStorer interface {
	GetVideo(userId, key string) (domain.Base64Video, error)
	SetVideo(userId string, video domain.Base64Video) (_ domain.VideoKey, err error)
	SetForeignVideoWithTTL(userId, key string, video domain.Base64Video) error
}

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

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

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

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

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

type WalletAddressStorer interface {
	SetAddress(chain, userId, address string) error
	ListAddresses(chain string, limit *uint64, cursor *string) ([]domain.WalletAddress, string, error)
}

type WalletBackend interface {
	Address(ctx context.Context, seed string) (string, error)
	Balance(ctx context.Context, address string) (wallet.Account, error)
	Transfer(ctx context.Context, seed, asset, to, amount string) (string, error)
	Export(ctx context.Context, seed string) (address, privateKey string, err error)
	History(ctx context.Context, address, asset string, limit int) ([]wallet.Transfer, error)
	Stake(ctx context.Context, seed, amount string) (string, error)
	Unstake(ctx context.Context, seed, amount string) (string, error)
	Withdraw(ctx context.Context, seed string) (string, error)
	Token() string
	Decimals() uint8
	Network() string
	Splitter() string
}

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

type WalletOrderStorer interface {
	CountConfirmed(buyerId string, from, to time.Time) (int, error)
	IsPayerTaken(payer, buyerNodeId string) (bool, error)
}

type WalletOwnerStorer interface {
	GetOwner() domain.Owner
}

type WalletPeerFetcher interface {
	GetByNodeID(nodeId string) (domain.User, error)
}

type WalletSettingsFetcher interface {
	GetSponsoredSettings(userId string) (domain.SponsoredSettings, error)
}

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

type WalletUserFetcher interface {
	Get(userId string) (domain.User, error)
}

type WhoToFollowAuthStorer interface {
	GetOwner() domain.Owner
}

type WhoToFollowFollowsLister interface {
	GetFollowings(userId string, limit *uint64, cursor *string) ([]string, string, error)
}

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