interfaces

type AIRepository interface {

	// SaveAnalysis stores an AI analysis result
	SaveAnalysis(ctx context.Context, analysis *ai.AIAnalysis) error

	// GetAnalysis retrieves the most recent AI analysis for an object
	GetAnalysis(ctx context.Context, objectID string) (*ai.AIAnalysis, error)

	// GetAnalysisByID retrieves a specific AI analysis by ID
	GetAnalysisByID(ctx context.Context, objectID, analysisID string) (*ai.AIAnalysis, error)

	// GetStats retrieves AI analysis statistics for a given period
	GetStats(ctx context.Context, period string) (*ai.AIStats, error)

	// QueueForAnalysis marks an object for AI analysis
	QueueForAnalysis(ctx context.Context, objectID string) error

	// AnalyzeContent performs comprehensive AI content analysis
	AnalyzeContent(ctx context.Context, content string, modelType string) (*ai.AIAnalysis, error)

	// GetContentClassifications retrieves AI-powered content categorization
	GetContentClassifications(ctx context.Context, contentID string) ([]string, error)

	// UpdateModelPerformance tracks AI model performance with accuracy metrics
	UpdateModelPerformance(ctx context.Context, modelID string, performanceMetrics map[string]float64) error

	// ProcessMLFeedback handles feedback for continuous learning systems
	ProcessMLFeedback(ctx context.Context, analysisID string, feedback map[string]interface{}) error

	// MonitorAIHealth performs health checks on AI processing systems
	MonitorAIHealth(ctx context.Context) error
}

type AccountRepository interface {
	// Core account operations
	CreateAccount(ctx context.Context, account *storage.Account) error
	GetAccount(ctx context.Context, username string) (*storage.Account, error)
	GetAccountByURL(ctx context.Context, actorURL string) (*storage.Account, error)
	GetAccountByEmail(ctx context.Context, email string) (*storage.Account, error)
	UpdateAccount(ctx context.Context, account *storage.Account) error
	DeleteAccount(ctx context.Context, username string) error

	// Account discovery and search
	SearchAccounts(ctx context.Context, query string, opts PaginationOptions) (*PaginatedResult[*storage.Account], error)
	GetSuggestedAccounts(ctx context.Context, forUserID string, opts PaginationOptions) (*PaginatedResult[*storage.AccountSuggestion], error)
	GetFeaturedAccounts(ctx context.Context, opts PaginationOptions) (*PaginatedResult[*storage.Account], error)

	// Account verification and moderation
	ApproveAccount(ctx context.Context, username string) error
	SuspendAccount(ctx context.Context, username string, reason string) error
	UnsuspendAccount(ctx context.Context, username string) error
	SilenceAccount(ctx context.Context, username string, reason string) error
	UnsilenceAccount(ctx context.Context, username string) error

	// Account metadata and preferences
	UpdateAccountPreferences(ctx context.Context, username string, preferences map[string]interface{}) error
	GetAccountPreferences(ctx context.Context, username string) (map[string]interface{}, error)
	UpdateAccountFeatures(ctx context.Context, username string, features map[string]bool) error
	GetAccountFeatures(ctx context.Context, username string) (map[string]bool, error)

	// Authentication and session management
	ValidateCredentials(ctx context.Context, username, password string) (*storage.Account, error)
	UpdatePassword(ctx context.Context, username, newPasswordHash string) error
	CreatePasswordReset(ctx context.Context, reset *storage.PasswordReset) error
	GetPasswordReset(ctx context.Context, token string) (*storage.PasswordReset, error)
	UsePasswordReset(ctx context.Context, token string) error

	// Activity and usage tracking
	RecordLogin(ctx context.Context, attempt *storage.LoginAttempt) error
	GetLoginHistory(ctx context.Context, username string, opts PaginationOptions) (*PaginatedResult[*storage.LoginAttempt], error)
	UpdateLastActivity(ctx context.Context, username string, activity time.Time) error

	// Bookmark operations
	AddBookmark(ctx context.Context, username, objectID string) error
	RemoveBookmark(ctx context.Context, username, objectID string) error
	GetBookmarks(ctx context.Context, username string, limit int, cursor string) ([]*storage.Bookmark, string, error)
	GetBookmarkedStatuses(ctx context.Context, username string, opts PaginationOptions) (*PaginatedResult[*models.Status], error)

	// Batch operations
	GetAccountsByUsernames(ctx context.Context, usernames []string) ([]*storage.Account, error)
	GetAccountsCount(ctx context.Context) (int64, error)
}

type ActivityRepository interface {

	// CreateActivity stores an activity in the database
	CreateActivity(ctx context.Context, activity *activitypub.Activity) error

	// GetActivity retrieves an activity by ID
	GetActivity(ctx context.Context, id string) (*activitypub.Activity, error)

	// GetInboxActivities retrieves inbox activities for a user with pagination
	GetInboxActivities(ctx context.Context, username string, limit int, cursor string) ([]*activitypub.Activity, string, error)

	// GetOutboxActivities retrieves activities created by a user with pagination
	GetOutboxActivities(ctx context.Context, username string, limit int, cursor string) ([]*activitypub.Activity, string, error)

	// GetCollection retrieves a collection for an actor (inbox, outbox, followers, following, liked)
	GetCollection(ctx context.Context, username, collectionType string, limit int, cursor string) (*activitypub.OrderedCollectionPage, error)

	// GetWeeklyActivity retrieves weekly activity statistics
	GetWeeklyActivity(ctx context.Context, weekTimestamp int64) (*storage.WeeklyActivity, error)

	// RecordActivity records general activity metrics
	RecordActivity(ctx context.Context, activityType string, actorID string, timestamp time.Time) error

	// GetHashtagActivity retrieves activities related to a hashtag since a given time
	GetHashtagActivity(ctx context.Context, hashtag string, since time.Time) ([]*storage.Activity, error)

	// RecordFederationActivity records federation activity metrics
	RecordFederationActivity(ctx context.Context, activity *storage.FederationActivity) error
}

type ActorRepository interface {
	// Core actor operations
	CreateActor(ctx context.Context, actor *activitypub.Actor, privateKey string) error
	GetActor(ctx context.Context, username string) (*activitypub.Actor, error)
	GetActorByUsername(ctx context.Context, username string) (*activitypub.Actor, error)
	GetActorByNumericID(ctx context.Context, numericID string) (*activitypub.Actor, error)
	GetActorWithMetadata(ctx context.Context, username string) (*activitypub.Actor, *storage.ActorMetadata, error)
	GetActorPrivateKey(ctx context.Context, username string) (string, error)
	UpdateActor(ctx context.Context, actor *activitypub.Actor) error
	UpdateActorLastStatusTime(ctx context.Context, username string) error
	SetActorFields(ctx context.Context, username string, fields []storage.ActorField) error
	DeleteActor(ctx context.Context, username string) error

	// Search and discovery
	SearchAccounts(ctx context.Context, query string, limit int, resolve bool, offset int) ([]*activitypub.Actor, error)
	GetSearchSuggestions(ctx context.Context, prefix string) ([]storage.SearchSuggestion, error)
	GetAccountSuggestions(ctx context.Context, userID string, limit int) ([]*activitypub.Actor, error)
	RemoveAccountSuggestion(ctx context.Context, userID, targetID string) error

	// Remote actor caching
	GetCachedRemoteActor(ctx context.Context, handle string) (*activitypub.Actor, error)

	// Migration operations
	UpdateAlsoKnownAs(ctx context.Context, username string, alsoKnownAs []string) error
	UpdateMovedTo(ctx context.Context, username string, movedTo string) error
	CheckAlsoKnownAs(ctx context.Context, username string, targetActorID string) (bool, error)
	GetActorMigrationInfo(ctx context.Context, username string) (*MigrationInfo, error)
}

type AnnouncementRepository interface {
	// CreateAnnouncement creates a new announcement
	CreateAnnouncement(ctx context.Context, announcement *storage.Announcement) error

	// GetAnnouncement retrieves a single announcement by ID
	GetAnnouncement(ctx context.Context, id string) (*storage.Announcement, error)

	// GetAnnouncements retrieves all announcements (for backward compatibility)
	GetAnnouncements(ctx context.Context, active bool) ([]*storage.Announcement, error)

	// GetAnnouncementsPaginated retrieves announcements with pagination
	GetAnnouncementsPaginated(ctx context.Context, active bool, limit int, cursor string) ([]*storage.Announcement, string, error)

	// GetAnnouncementsByAdmin retrieves announcements created by a specific admin
	GetAnnouncementsByAdmin(ctx context.Context, adminUsername string, limit int, cursor string) ([]*storage.Announcement, string, error)

	// UpdateAnnouncement updates an existing announcement
	UpdateAnnouncement(ctx context.Context, announcement *storage.Announcement) error

	// DeleteAnnouncement deletes an announcement
	DeleteAnnouncement(ctx context.Context, id string) error

	// DismissAnnouncement marks an announcement as dismissed by a user
	DismissAnnouncement(ctx context.Context, username, announcementID string) error

	// IsDismissed checks if a user has dismissed an announcement
	IsDismissed(ctx context.Context, username, announcementID string) (bool, error)

	// GetDismissedAnnouncements gets all announcement IDs dismissed by a user
	GetDismissedAnnouncements(ctx context.Context, username string) ([]string, error)

	// AddAnnouncementReaction adds a user's reaction to an announcement
	AddAnnouncementReaction(ctx context.Context, username, announcementID, emojiName string) error

	// RemoveAnnouncementReaction removes a user's reaction from an announcement
	RemoveAnnouncementReaction(ctx context.Context, username, announcementID, emojiName string) error

	// GetAnnouncementReactions gets all reactions for an announcement
	GetAnnouncementReactions(ctx context.Context, announcementID string) (map[string][]string, error)
}

type ArticleRepository interface {

	// GetDB returns the underlying DynamoDB connection for advanced operations
	GetDB() dynamormcore.DB

	// CreateArticle creates a new article
	CreateArticle(ctx context.Context, article *models.Article) error

	// GetArticle retrieves an article by ID
	GetArticle(ctx context.Context, id string) (*models.Article, error)

	// UpdateArticle updates an existing article
	UpdateArticle(ctx context.Context, article *models.Article) error

	// DeleteArticle deletes an article
	DeleteArticle(ctx context.Context, id string) error

	// ListArticles lists articles with a limit
	ListArticles(ctx context.Context, limit int) ([]*models.Article, error)

	// ListArticlesPaginated lists articles with cursor pagination
	ListArticlesPaginated(ctx context.Context, limit int, cursor string) ([]*models.Article, string, error)

	// ListArticlesByAuthorPaginated lists articles for a specific author with pagination
	ListArticlesByAuthorPaginated(ctx context.Context, authorActorID string, limit int, cursor string) ([]*models.Article, string, error)

	// ListArticlesBySeriesPaginated lists articles for a specific series with pagination
	ListArticlesBySeriesPaginated(ctx context.Context, seriesID string, limit int, cursor string) ([]*models.Article, string, error)

	// ListArticlesByCategoryPaginated lists articles for a specific category with pagination
	ListArticlesByCategoryPaginated(ctx context.Context, categoryID string, limit int, cursor string) ([]*models.Article, string, error)
}

type AuditRepository interface {

	// StoreAuditLog stores an audit log entry
	StoreAuditLog(ctx context.Context, log *models.AuthAuditLog) error

	// GetAuditLogByID retrieves an audit log by ID and date
	GetAuditLogByID(ctx context.Context, id string, date time.Time) (*models.AuthAuditLog, error)

	// GetUserAuditLogs retrieves audit logs for a specific user
	GetUserAuditLogs(ctx context.Context, username string, limit int, startTime, endTime time.Time) ([]*models.AuthAuditLog, error)

	// GetIPAuditLogs retrieves audit logs for a specific IP address
	GetIPAuditLogs(ctx context.Context, ipAddress string, limit int, startTime, endTime time.Time) ([]*models.AuthAuditLog, error)

	// GetSessionAuditLogs retrieves audit logs for a specific session
	GetSessionAuditLogs(ctx context.Context, sessionID string) ([]*models.AuthAuditLog, error)

	// GetSecurityEvents retrieves security events by severity within a time range
	GetSecurityEvents(ctx context.Context, severity string, startTime, endTime time.Time, limit int, cursor string) ([]*models.AuthAuditLog, string, error)

	// GetRecentFailedLogins gets recent failed login attempts for a user
	GetRecentFailedLogins(ctx context.Context, username string, duration time.Duration) (int, error)

	// GetRecentIPFailures gets recent failures from an IP address
	GetRecentIPFailures(ctx context.Context, ipAddress string, duration time.Duration) (int, error)

	// CleanupOldLogs removes audit logs older than retention period
	CleanupOldLogs(ctx context.Context, retentionDays int) error

	// StoreAuditEvent stores an audit event with full metadata
	StoreAuditEvent(ctx context.Context, eventType, severity, username, userID, ipAddress, userAgent, deviceName, sessionID, requestID string, success bool, failureReason string, metadata map[string]interface{}) error
}

type BookmarkRepository interface {
	// CreateBookmark creates a new bookmark for a user
	CreateBookmark(ctx context.Context, username, objectID string) (*models.Bookmark, error)

	// DeleteBookmark removes a bookmark
	DeleteBookmark(ctx context.Context, username, objectID string) error

	// GetBookmark retrieves a specific bookmark
	GetBookmark(ctx context.Context, username, objectID string) (*models.Bookmark, error)

	// GetUserBookmarks retrieves all bookmarks for a user with pagination
	GetUserBookmarks(ctx context.Context, username string, limit int, cursor string) ([]*models.Bookmark, string, error)

	// IsBookmarked checks if a user has bookmarked an object
	IsBookmarked(ctx context.Context, username, objectID string) (bool, error)

	// CountUserBookmarks returns the total number of bookmarks by a user
	CountUserBookmarks(ctx context.Context, username string) (int64, error)

	// CheckBookmarksForStatuses returns a map of statusID -> bookmarked for the provided IDs
	CheckBookmarksForStatuses(ctx context.Context, username string, statusIDs []string) (map[string]bool, error)

	// AddBookmark provides Storage interface compatibility
	AddBookmark(ctx context.Context, username, objectID string) error

	// RemoveBookmark provides Storage interface compatibility
	RemoveBookmark(ctx context.Context, username, objectID string) error

	// GetBookmarks provides Storage interface compatibility - returns storage.Bookmark format
	GetBookmarks(ctx context.Context, username string, limit int, cursor string) ([]*storage.Bookmark, string, error)

	// CascadeDeleteUserBookmarks deletes all bookmarks for a user
	CascadeDeleteUserBookmarks(ctx context.Context, username string) error

	// CascadeDeleteObjectBookmarks deletes all bookmarks for an object
	CascadeDeleteObjectBookmarks(ctx context.Context, objectID string) error
}

type BudgetPeriodStatus struct {
	Period              string
	BudgetMicroCents    int64
	UsedMicroCents      int64
	UsagePercent        float64
	Status              string
	RemainingMicroCents int64
}

type BudgetStatus struct {
	UserID          string
	Budgets         map[string]*BudgetPeriodStatus
	AllowConnection bool
	AllowMessages   bool
	ExceededBudgets []string
	WarningBudgets  []string
}

type CacheConfig struct {
	// EnableCache enables in-memory caching for frequently accessed data
	EnableCache bool

	// CacheTTL is the default time-to-live for cached items
	CacheTTL time.Duration

	// MaxCacheSize is the maximum number of items to store in cache
	MaxCacheSize int

	// CacheKeyPrefix is the prefix for all cache keys
	CacheKeyPrefix string
}

type CategoryRepository interface {

	// GetDB returns the underlying DynamoDB connection for advanced operations
	GetDB() dynamormcore.DB

	// CreateCategory creates a new category
	CreateCategory(ctx context.Context, category *models.Category) error

	// GetCategory retrieves a category by ID
	GetCategory(ctx context.Context, id string) (*models.Category, error)

	// Update updates an existing category
	Update(ctx context.Context, category *models.Category) error

	// Delete deletes a category by PK and SK
	Delete(ctx context.Context, pk, sk string) error

	// ListCategories lists all categories (optionally filtered by parent)
	ListCategories(ctx context.Context, parentID *string, limit int) ([]*models.Category, error)

	// UpdateArticleCount atomically increments/decrements a category's ArticleCount
	UpdateArticleCount(ctx context.Context, categoryID string, delta int) error
}

type CloudWatchMetricsRepository interface {

	// GetServiceMetrics retrieves comprehensive metrics for a service over the specified period
	GetServiceMetrics(ctx context.Context, serviceName string, period time.Duration) (*ServiceMetrics, error)

	// GetInstanceMetrics retrieves instance-level metrics for the past period
	GetInstanceMetrics(ctx context.Context, period time.Duration) (*ServiceMetrics, error)

	// GetCostBreakdown retrieves detailed cost breakdown for the specified period
	GetCostBreakdown(ctx context.Context, period time.Duration) (*CostBreakdown, error)

	// CacheMetrics stores metrics in DynamoDB for performance optimization
	CacheMetrics(ctx context.Context, serviceName string, metrics *ServiceMetrics) error

	// GetCachedMetrics retrieves cached metrics from DynamoDB
	GetCachedMetrics(ctx context.Context, serviceName string) (*ServiceMetrics, error)
}

type CommunityNoteRepository interface {

	// CreateCommunityNote creates a new community note
	CreateCommunityNote(ctx context.Context, note *storage.CommunityNote) error

	// GetCommunityNote retrieves a note by ID
	GetCommunityNote(ctx context.Context, noteID string) (*storage.CommunityNote, error)

	// GetVisibleCommunityNotes retrieves visible notes for an object
	GetVisibleCommunityNotes(ctx context.Context, objectID string) ([]*storage.CommunityNote, error)

	// GetCommunityNotesByAuthor retrieves community notes authored by a specific actor
	GetCommunityNotesByAuthor(ctx context.Context, authorID string, limit int, cursor string) ([]*storage.CommunityNote, string, error)

	// UpdateCommunityNoteScore updates a note's score and visibility
	UpdateCommunityNoteScore(ctx context.Context, noteID string, score float64, status string) error

	// UpdateCommunityNoteAnalysis updates AI analysis results for a note
	UpdateCommunityNoteAnalysis(ctx context.Context, noteID string, sentiment, objectivity, sourceQuality float64) error

	// CreateCommunityNoteVote creates a vote on a note
	CreateCommunityNoteVote(ctx context.Context, vote *storage.CommunityNoteVote) error

	// GetCommunityNoteVotes retrieves votes on a specific community note
	GetCommunityNoteVotes(ctx context.Context, noteID string) ([]*storage.CommunityNoteVote, error)

	// GetUserCommunityNoteVotes retrieves a user's votes on specific notes
	GetUserCommunityNoteVotes(ctx context.Context, userID string, noteIDs []string) (map[string]*storage.CommunityNoteVote, error)

	// GetUserVotingHistory retrieves a user's voting history for reputation calculation
	GetUserVotingHistory(ctx context.Context, userID string, limit int) ([]*storage.CommunityNoteVote, error)
}

type ConcreteRelationshipRepository interface {

	// CreateRelationship creates a new follow relationship
	CreateRelationship(ctx context.Context, followerUsername, followingUsername, activityID string) error

	// DeleteRelationship removes a follow relationship
	DeleteRelationship(ctx context.Context, followerUsername, followingUsername string) error

	// GetRelationship retrieves a specific follow relationship
	GetRelationship(ctx context.Context, followerUsername, followingUsername string) (*models.RelationshipRecord, error)

	// UpdateRelationship updates relationship settings
	UpdateRelationship(ctx context.Context, followerUsername, followingUsername string, updates map[string]interface{}) error

	// IsFollowing checks if followerUsername is following the targetActorID
	IsFollowing(ctx context.Context, followerUsername, targetActorID string) (bool, error)

	// GetFollowRequest gets a follow request by follower and target IDs
	GetFollowRequest(ctx context.Context, followerID, targetID string) (*storage.RelationshipRecord, error)

	// HasFollowRequest checks if there's a follow request between two users
	HasFollowRequest(ctx context.Context, requesterID, targetID string) (bool, error)

	// HasPendingFollowRequest checks if there's a pending follow request between two users
	HasPendingFollowRequest(ctx context.Context, requesterID, targetID string) (bool, error)

	// GetPendingFollowRequests retrieves pending follow requests for a user
	GetPendingFollowRequests(ctx context.Context, username string, limit int, cursor string) ([]string, string, error)

	// AcceptFollowRequest accepts a follow request
	AcceptFollowRequest(ctx context.Context, followerUsername, followingUsername string) error

	// RejectFollowRequest rejects a follow request
	RejectFollowRequest(ctx context.Context, followerUsername, followingUsername string) error

	// GetFollowers retrieves all followers for a user
	GetFollowers(ctx context.Context, username string, limit int, cursor string) ([]string, string, error)

	// GetFollowing retrieves all users that a user is following
	GetFollowing(ctx context.Context, username string, limit int, cursor string) ([]string, string, error)

	// CountFollowers returns the number of followers for a user
	CountFollowers(ctx context.Context, username string) (int, error)

	// CountFollowing returns the number of users that a user is following
	CountFollowing(ctx context.Context, username string) (int, error)

	// GetFollowerCount returns the number of followers for a user (int64 version)
	GetFollowerCount(ctx context.Context, userID string) (int64, error)

	// GetFollowingCount returns the number of users that a user is following (int64 version)
	GetFollowingCount(ctx context.Context, userID string) (int64, error)

	// CountRelationshipsByDomain counts follower/following relationships involving a remote domain
	CountRelationshipsByDomain(ctx context.Context, domain string) (followers, following int, err error)

	// Unfollow removes a follow relationship (wrapper for DeleteRelationship)
	Unfollow(ctx context.Context, followerID, followingID string) error

	// CreateBlock creates a new block relationship
	CreateBlock(ctx context.Context, blockerActor, blockedActor, activityID string) error

	// DeleteBlock removes a block relationship
	DeleteBlock(ctx context.Context, blockerActor, blockedActor string) error

	// BlockUser blocks another user
	BlockUser(ctx context.Context, blockerID, blockedID string) error

	// UnblockUser removes a block relationship
	UnblockUser(ctx context.Context, blockerID, blockedID string) error

	// IsBlocked checks if one actor has blocked another
	IsBlocked(ctx context.Context, blockerActor, blockedActor string) (bool, error)

	// IsBlockedBidirectional checks if either actor has blocked the other
	IsBlockedBidirectional(ctx context.Context, actor1, actor2 string) (bool, error)

	// GetBlockedUsers returns a list of users blocked by the given actor
	GetBlockedUsers(ctx context.Context, blockerActor string, limit int, cursor string) ([]string, string, error)

	// GetUsersWhoBlocked returns a list of users who have blocked the given actor
	GetUsersWhoBlocked(ctx context.Context, blockedActor string, limit int, cursor string) ([]string, string, error)

	// GetBlock retrieves a specific block relationship
	GetBlock(ctx context.Context, blockerActor, blockedActor string) (*storage.Block, error)

	// CountBlockedUsers returns the number of users blocked by the given actor
	CountBlockedUsers(ctx context.Context, blockerActor string) (int, error)

	// CountUsersWhoBlocked returns the number of users who have blocked the given actor
	CountUsersWhoBlocked(ctx context.Context, blockedActor string) (int, error)

	// CreateMute creates a new mute relationship
	CreateMute(ctx context.Context, muterActor, mutedActor, activityID string, hideNotifications bool, duration *time.Duration) error

	// DeleteMute removes a mute relationship
	DeleteMute(ctx context.Context, muterActor, mutedActor string) error

	// UnmuteUser removes a mute relationship
	UnmuteUser(ctx context.Context, muterID, mutedID string) error

	// IsMuted checks if one actor has muted another
	IsMuted(ctx context.Context, muterActor, mutedActor string) (bool, error)

	// GetMutedUsers returns a list of users muted by the given actor
	GetMutedUsers(ctx context.Context, muterActor string, limit int, cursor string) ([]string, string, error)

	// GetUsersWhoMuted returns a list of users who have muted the given actor
	GetUsersWhoMuted(ctx context.Context, mutedActor string, limit int, cursor string) ([]string, string, error)

	// GetMute retrieves a specific mute relationship
	GetMute(ctx context.Context, muterActor, mutedActor string) (*storage.Mute, error)

	// CountMutedUsers returns the number of users muted by the given actor
	CountMutedUsers(ctx context.Context, muterActor string) (int, error)

	// CountUsersWhoMuted returns the number of users who have muted the given actor
	CountUsersWhoMuted(ctx context.Context, mutedActor string) (int, error)

	// IsEndorsed checks if a user has endorsed (pinned) a target account
	IsEndorsed(ctx context.Context, userID, targetID string) (bool, error)

	// CreateEndorsement creates a new endorsement (account pin) relationship
	CreateEndorsement(ctx context.Context, endorsement *storage.AccountPin) error

	// DeleteEndorsement removes an endorsement (account pin) relationship
	DeleteEndorsement(ctx context.Context, endorserID, endorsedID string) error

	// GetEndorsements retrieves all endorsements (account pins) for a user
	GetEndorsements(ctx context.Context, userID string, limit int, cursor string) ([]*storage.AccountPin, string, error)

	// GetRelationshipNote retrieves a private note on an account
	GetRelationshipNote(ctx context.Context, userID, targetID string) (*storage.AccountNote, error)

	// CreateMove creates a new move record
	CreateMove(ctx context.Context, move *storage.Move) error

	// GetMove retrieves the most recent move for an actor
	GetMove(ctx context.Context, actor string) (*storage.Move, error)

	// GetAccountMoves retrieves all moves for an account (as actor)
	GetAccountMoves(ctx context.Context, actor string) ([]*storage.Move, error)

	// UpdateMoveProgress updates move migration progress
	UpdateMoveProgress(ctx context.Context, actor, target string, progress map[string]interface{}) error

	// VerifyMove marks a move as verified
	VerifyMove(ctx context.Context, actor, target string) error

	// GetPendingMoves retrieves moves that haven't been fully processed
	GetPendingMoves(ctx context.Context, limit int) ([]*storage.Move, error)

	// GetMoveByTarget retrieves all moves to a specific target account
	GetMoveByTarget(ctx context.Context, target string) ([]*storage.Move, error)

	// HasMovedFrom checks if newActor has moved from oldActor
	HasMovedFrom(ctx context.Context, oldActor, newActor string) (bool, error)

	// AddToCollection adds an item to a collection
	AddToCollection(ctx context.Context, collection string, item *storage.CollectionItem) error

	// RemoveFromCollection removes an item from a collection
	RemoveFromCollection(ctx context.Context, collection, itemID string) error

	// GetCollectionItems retrieves items from a collection with pagination
	GetCollectionItems(ctx context.Context, collection string, limit int, cursor string) ([]*storage.CollectionItem, string, error)

	// IsInCollection checks if an item is in a collection
	IsInCollection(ctx context.Context, collection, itemID string) (bool, error)

	// CountCollectionItems returns the count of items in a collection
	CountCollectionItems(ctx context.Context, collection string) (int, error)

	// ClearCollection removes all items from a collection
	ClearCollection(ctx context.Context, collection string) error
}

type ConversationRepository interface {

	// CreateConversation creates a new conversation with participants
	CreateConversation(ctx context.Context, conversation *models.Conversation, participants []string) error

	// GetConversation retrieves a conversation by ID
	GetConversation(ctx context.Context, id string) (*models.Conversation, error)

	// UpdateConversation updates a conversation
	UpdateConversation(ctx context.Context, conversation *models.Conversation) error

	// DeleteConversation deletes a conversation by ID
	DeleteConversation(ctx context.Context, id string) error

	// GetUserConversations retrieves conversations for a user with pagination
	GetUserConversations(ctx context.Context, userID string, opts PaginationOptions) (*PaginatedResult[*models.Conversation], error)

	// GetConversationByParticipants finds a conversation with exact participants
	GetConversationByParticipants(ctx context.Context, participants []string) (*models.Conversation, error)

	// GetUnreadConversations retrieves unread conversations for a user
	GetUnreadConversations(ctx context.Context, userID string, opts PaginationOptions) (*PaginatedResult[*models.Conversation], error)

	// SearchConversations searches conversations for a user by query
	SearchConversations(ctx context.Context, userID, query string, opts PaginationOptions) (*PaginatedResult[*models.Conversation], error)

	// MarkConversationRead marks a conversation as read for a user
	MarkConversationRead(ctx context.Context, conversationID, username string) error

	// MarkConversationUnread marks a conversation as unread for a user
	MarkConversationUnread(ctx context.Context, conversationID, userID string) error

	// GetUnreadConversationCount gets the count of unread conversations for a user
	GetUnreadConversationCount(ctx context.Context, username string) (int, error)

	// AddStatusToConversation adds a status/message to a conversation
	AddStatusToConversation(ctx context.Context, conversationID, statusID, senderUsername string) error

	// GetConversationStatuses retrieves messages in a conversation with pagination
	GetConversationStatuses(ctx context.Context, conversationID string, limit int, cursor string) ([]*storage.ConversationStatus, string, error)

	// RemoveStatusFromConversation removes a status from a conversation
	RemoveStatusFromConversation(ctx context.Context, conversationID, statusID string) error

	// MarkStatusRead marks a specific status as read by a user
	MarkStatusRead(ctx context.Context, conversationID, statusID, username string) error

	// GetUnreadStatusCount gets the count of unread statuses in a conversation for a user
	GetUnreadStatusCount(ctx context.Context, conversationID, username string) (int, error)

	// UpdateConversationLastStatus updates the last status in a conversation
	UpdateConversationLastStatus(ctx context.Context, id, lastStatusID string) error

	// AddParticipant adds a participant to a conversation
	AddParticipant(ctx context.Context, conversationID, participantID string) error

	// RemoveParticipant removes a participant from a conversation
	RemoveParticipant(ctx context.Context, conversationID, participantID string) error

	// GetConversationParticipants retrieves the list of participants in a conversation
	GetConversationParticipants(ctx context.Context, conversationID string) ([]string, error)

	// LeaveConversation removes a participant from a conversation
	LeaveConversation(ctx context.Context, conversationID, username string) error

	// CreateConversationMute creates a new conversation mute
	CreateConversationMute(ctx context.Context, mute *storage.ConversationMute) error

	// DeleteConversationMute removes a conversation mute
	DeleteConversationMute(ctx context.Context, username, conversationID string) error

	// IsConversationMuted checks if a conversation is muted by a user
	IsConversationMuted(ctx context.Context, username, conversationID string) (bool, error)

	// GetMutedConversations retrieves all muted conversations for a user
	GetMutedConversations(ctx context.Context, username string) ([]string, error)
}

type CostBreakdown struct {
	TotalCost        float64
	DynamoDBCost     float64
	LambdaCost       float64
	APIGatewayCost   float64
	S3Cost           float64
	DataTransferCost float64
	Breakdown        []*CostItem
}

type CostDataPoint struct {
	Timestamp     time.Time
	CostDollars   float64
	Operations    int64
	ReadCapacity  float64
	WriteCapacity float64
}

type CostItem struct {
	Operation string
	Count     int
	Cost      float64
}

type CostTrend struct {
	Period          string
	OperationType   string
	StartTime       time.Time
	EndTime         time.Time
	DataPoints      []CostDataPoint
	TotalCost       float64
	AverageCost     float64
	MinCost         float64
	MaxCost         float64
	TrendPercentage float64
}

type DLQAnalytics struct {
	Service               string                         `json:"service"`
	TimeRange             DLQTimeRange                   `json:"time_range"`
	TotalMessages         int                            `json:"total_messages"`
	NewMessages           int                            `json:"new_messages"`
	ReprocessingMessages  int                            `json:"reprocessing_messages"`
	ResolvedMessages      int                            `json:"resolved_messages"`
	FailedMessages        int                            `json:"failed_messages"`
	AbandonedMessages     int                            `json:"abandoned_messages"`
	ResolutionRate        float64                        `json:"resolution_rate"`
	AbandonmentRate       float64                        `json:"abandonment_rate"`
	TotalCostMicroCents   int64                          `json:"total_cost_micro_cents"`
	TotalCostDollars      float64                        `json:"total_cost_dollars"`
	AverageCostPerMessage float64                        `json:"average_cost_per_message"`
	ErrorTypeStats        map[string]*DLQErrorTypeStats  `json:"error_type_stats"`
	ServiceStats          map[string]*DLQServiceStats    `json:"service_stats"`
	SimilarityGroups      map[string]*DLQSimilarityGroup `json:"similarity_groups"`
}

type DLQDailyStats struct {
	Date                time.Time      `json:"date"`
	MessageCount        int            `json:"message_count"`
	TotalCostMicroCents int64          `json:"total_cost_micro_cents"`
	TotalCostDollars    float64        `json:"total_cost_dollars"`
	ErrorTypes          map[string]int `json:"error_types"`
	StatusCounts        map[string]int `json:"status_counts"`
}

type DLQErrorTypeStats struct {
	ErrorType           string  `json:"error_type"`
	Count               int     `json:"count"`
	ResolvedCount       int     `json:"resolved_count"`
	ResolutionRate      float64 `json:"resolution_rate"`
	TotalCostMicroCents int64   `json:"total_cost_micro_cents"`
}

type DLQHealthStatus struct {
	Service           string         `json:"service"`
	CheckTime         time.Time      `json:"check_time"`
	TotalMessages     int            `json:"total_messages"`
	NewMessages       int            `json:"new_messages"`
	ReprocessingCount int            `json:"reprocessing_count"`
	AbandonedCount    int            `json:"abandoned_count"`
	ErrorRates        map[string]int `json:"error_rates"`
	AverageRetryCount float64        `json:"average_retry_count"`
	IsHealthy         bool           `json:"is_healthy"`
	Alerts            []string       `json:"alerts"`
}

type DLQRepository interface {

	// CreateDLQMessage creates a new DLQ message
	CreateDLQMessage(ctx context.Context, message *models.DLQMessage) error

	// GetDLQMessage retrieves a DLQ message by ID
	GetDLQMessage(ctx context.Context, id string) (*models.DLQMessage, error)

	// UpdateDLQMessage updates an existing DLQ message
	UpdateDLQMessage(ctx context.Context, message *models.DLQMessage) error

	// DeleteDLQMessage deletes a DLQ message
	DeleteDLQMessage(ctx context.Context, message *models.DLQMessage) error

	// BatchUpdateDLQMessages updates multiple DLQ messages
	BatchUpdateDLQMessages(ctx context.Context, messages []*models.DLQMessage) error

	// GetDLQMessagesByService retrieves DLQ messages for a specific service with pagination
	GetDLQMessagesByService(ctx context.Context, service string, date time.Time, limit int, cursor string) ([]*models.DLQMessage, string, error)

	// GetDLQMessagesByServiceDateRange retrieves DLQ messages for a service across multiple dates
	GetDLQMessagesByServiceDateRange(ctx context.Context, service string, startDate, endDate time.Time, limit int) ([]*models.DLQMessage, error)

	// GetDLQMessagesByErrorType retrieves DLQ messages by error type with pagination
	GetDLQMessagesByErrorType(ctx context.Context, errorType string, limit int, cursor string) ([]*models.DLQMessage, string, error)

	// GetDLQMessagesForReprocessing retrieves messages that can be reprocessed
	GetDLQMessagesForReprocessing(ctx context.Context, service string, status string, limit int, cursor string) ([]*models.DLQMessage, string, error)

	// GetDLQMessagesByStatus retrieves messages by status
	GetDLQMessagesByStatus(ctx context.Context, service, status string, limit int, cursor string) ([]*models.DLQMessage, string, error)

	// SearchDLQMessages searches DLQ messages with various filters
	SearchDLQMessages(ctx context.Context, filter *DLQSearchFilter) ([]*models.DLQMessage, string, error)

	// GetSimilarMessages finds messages with the same similarity hash
	GetSimilarMessages(ctx context.Context, similarityHash string, limit int) ([]*models.DLQMessage, error)

	// GetDLQAnalytics returns analytics data for DLQ messages
	GetDLQAnalytics(ctx context.Context, service string, timeRange DLQTimeRange) (*DLQAnalytics, error)

	// GetDLQTrends returns trend data for DLQ messages over time
	GetDLQTrends(ctx context.Context, service string, days int) (*DLQTrends, error)

	// AnalyzeFailurePatterns analyzes DLQ messages to identify common failure patterns
	AnalyzeFailurePatterns(ctx context.Context, service string, days int) (map[string]*DLQSimilarityGroup, error)

	// SendToDeadLetterQueue creates and stores a DLQ message with proper error categorization
	SendToDeadLetterQueue(ctx context.Context, service, messageID, messageBody, errorType, errorMessage string, isPermanent bool) error

	// RetryFailedMessage attempts to reprocess a DLQ message with exponential backoff
	RetryFailedMessage(ctx context.Context, messageID string) error

	// GetRetryableMessages returns messages that are ready for retry based on backoff schedule
	GetRetryableMessages(ctx context.Context, service string, limit int) ([]*models.DLQMessage, error)

	// CleanupExpiredMessages deletes expired DLQ messages
	CleanupExpiredMessages(ctx context.Context, before time.Time) (int, error)

	// MonitorDLQHealth provides health metrics for DLQ monitoring and alerting
	MonitorDLQHealth(ctx context.Context, service string) (*DLQHealthStatus, error)
}

type DLQSearchFilter struct {
	Service     string    `json:"service"`
	ErrorType   string    `json:"error_type,omitempty"`
	Status      string    `json:"status,omitempty"`
	Priority    string    `json:"priority,omitempty"`
	IsPermanent *bool     `json:"is_permanent,omitempty"`
	StartTime   time.Time `json:"start_time,omitempty"`
	EndTime     time.Time `json:"end_time,omitempty"`
	SearchText  string    `json:"search_text,omitempty"`
	Limit       int       `json:"limit,omitempty"`
	Cursor      string    `json:"cursor,omitempty"`
}

type DLQServiceStats struct {
	Service             string  `json:"service"`
	MessageCount        int     `json:"message_count"`
	ErrorTypes          int     `json:"error_types"`
	ResolutionRate      float64 `json:"resolution_rate"`
	TotalCostMicroCents int64   `json:"total_cost_micro_cents"`
}

type DLQSimilarityGroup struct {
	SimilarityHash string    `json:"similarity_hash"`
	ErrorType      string    `json:"error_type"`
	Service        string    `json:"service"`
	MessageCount   int       `json:"message_count"`
	MessageIDs     []string  `json:"message_ids"`
	FirstSeen      time.Time `json:"first_seen"`
	LastSeen       time.Time `json:"last_seen"`
	SampleError    string    `json:"sample_error"`
}

type DLQTimeRange struct {
	StartTime time.Time `json:"start_time"`
	EndTime   time.Time `json:"end_time"`
}

type DLQTrends struct {
	Service    string                    `json:"service"`
	Days       int                       `json:"days"`
	DailyStats map[string]*DLQDailyStats `json:"daily_stats"`
}

type DNSCacheRepository interface {
	// GetDNSCache retrieves a cached DNS lookup result
	GetDNSCache(ctx context.Context, hostname string) (*storage.DNSCacheEntry, error)

	// SetDNSCache stores a DNS lookup result in the cache
	SetDNSCache(ctx context.Context, entry *storage.DNSCacheEntry) error

	// InvalidateDNSCache removes a DNS cache entry
	InvalidateDNSCache(ctx context.Context, hostname string) error
}

type DailyAggregate struct {
	Date            time.Time
	TotalCost       float64
	TotalOperations int64
}

type DomainBlockRepository interface {

	// AddDomainBlock adds a domain to the user's block list
	AddDomainBlock(ctx context.Context, username, domain string) error

	// RemoveDomainBlock removes a domain from the user's block list
	RemoveDomainBlock(ctx context.Context, username, domain string) error

	// GetUserDomainBlocks retrieves all domains blocked by a user
	GetUserDomainBlocks(ctx context.Context, username string, limit int, cursor string) ([]string, string, error)

	// IsBlockedDomain checks if a domain is blocked by a user
	IsBlockedDomain(ctx context.Context, username, domain string) (bool, error)

	// CreateInstanceDomainBlock creates an instance-level domain block
	CreateInstanceDomainBlock(ctx context.Context, block *storage.InstanceDomainBlock) error

	// GetInstanceDomainBlock retrieves a domain block by domain
	GetInstanceDomainBlock(ctx context.Context, domain string) (*storage.InstanceDomainBlock, error)

	// GetInstanceDomainBlockByID retrieves a domain block by ID
	GetInstanceDomainBlockByID(ctx context.Context, id string) (*storage.InstanceDomainBlock, error)

	// ListInstanceDomainBlocks lists all instance domain blocks with pagination
	ListInstanceDomainBlocks(ctx context.Context, limit int, cursor string) ([]*storage.InstanceDomainBlock, string, error)

	// UpdateInstanceDomainBlock updates an existing domain block
	UpdateInstanceDomainBlock(ctx context.Context, domain string, updates map[string]any) error

	// DeleteInstanceDomainBlock deletes a domain block
	DeleteInstanceDomainBlock(ctx context.Context, domain string) error

	// IsInstanceDomainBlocked checks if a domain is blocked at the instance level
	IsInstanceDomainBlocked(ctx context.Context, domain string) (bool, *storage.InstanceDomainBlock, error)

	// GetDomainBlocks retrieves instance-level domain blocks with pagination
	GetDomainBlocks(ctx context.Context, limit int, cursor string) ([]*storage.InstanceDomainBlock, string, error)

	// GetDomainBlock retrieves a specific domain block by ID
	GetDomainBlock(ctx context.Context, id string) (*storage.InstanceDomainBlock, error)

	// CreateDomainBlock creates a new instance-level domain block
	CreateDomainBlock(ctx context.Context, block *storage.InstanceDomainBlock) error

	// UpdateDomainBlock updates an existing domain block
	UpdateDomainBlock(ctx context.Context, id string, updates map[string]any) error

	// DeleteDomainBlock removes a domain block
	DeleteDomainBlock(ctx context.Context, id string) error

	// IsDomainBlocked checks if a domain is blocked at the instance level
	IsDomainBlocked(ctx context.Context, domain string) (bool, *storage.InstanceDomainBlock, error)

	// CreateEmailDomainBlock creates an email domain block
	CreateEmailDomainBlock(ctx context.Context, block *storage.EmailDomainBlock) error

	// GetEmailDomainBlocks retrieves email domain blocks with pagination
	GetEmailDomainBlocks(ctx context.Context, limit int, cursor string) ([]*storage.EmailDomainBlock, string, error)

	// DeleteEmailDomainBlock deletes an email domain block
	DeleteEmailDomainBlock(ctx context.Context, id string) error

	// GetDomainAllows retrieves domain allows (for allowlist mode)
	GetDomainAllows(ctx context.Context, limit int, cursor string) ([]*storage.DomainAllow, string, error)

	// CreateDomainAllow adds a domain to the allowlist
	CreateDomainAllow(ctx context.Context, allow *storage.DomainAllow) error

	// DeleteDomainAllow removes a domain from the allowlist
	DeleteDomainAllow(ctx context.Context, id string) error
}

type DraftRepository interface {

	// CreateDraft creates a new draft
	CreateDraft(ctx context.Context, draft *models.Draft) error

	// GetDraft retrieves a draft by author ID and draft ID
	GetDraft(ctx context.Context, authorID, draftID string) (*models.Draft, error)

	// UpdateDraft updates an existing draft
	UpdateDraft(ctx context.Context, draft *models.Draft) error

	// DeleteDraft deletes a draft
	DeleteDraft(ctx context.Context, authorID, draftID string) error

	// ListDraftsByAuthor lists drafts for an author
	ListDraftsByAuthor(ctx context.Context, authorID string, limit int) ([]*models.Draft, error)

	// ListDraftsByAuthorPaginated lists drafts for an author with cursor pagination
	ListDraftsByAuthorPaginated(ctx context.Context, authorID string, limit int, cursor string) ([]*models.Draft, string, error)

	// ListScheduledDraftsDuePaginated lists drafts scheduled to publish at or before the provided time
	ListScheduledDraftsDuePaginated(ctx context.Context, dueBefore time.Time, limit int, cursor string) ([]*models.Draft, string, error)
}

type EmojiRepository interface {

	// CreateCustomEmoji creates a new custom emoji
	CreateCustomEmoji(ctx context.Context, emoji *storage.CustomEmoji) error

	// GetCustomEmoji retrieves a custom emoji by shortcode
	GetCustomEmoji(ctx context.Context, shortcode string) (*storage.CustomEmoji, error)

	// GetCustomEmojis retrieves all custom emojis (not disabled)
	GetCustomEmojis(ctx context.Context) ([]*storage.CustomEmoji, error)

	// UpdateCustomEmoji updates an existing custom emoji
	UpdateCustomEmoji(ctx context.Context, emoji *storage.CustomEmoji) error

	// DeleteCustomEmoji deletes a custom emoji
	DeleteCustomEmoji(ctx context.Context, shortcode string) error

	// GetRemoteEmoji retrieves a remote emoji by shortcode and domain
	GetRemoteEmoji(ctx context.Context, shortcode, domain string) (*storage.CustomEmoji, error)

	// GetCustomEmojisByCategory retrieves custom emojis by category
	GetCustomEmojisByCategory(ctx context.Context, category string) ([]*storage.CustomEmoji, error)

	// SearchEmojis performs sophisticated emoji searches with relevance scoring
	SearchEmojis(ctx context.Context, query string, limit int) ([]*storage.CustomEmoji, error)

	// GetPopularEmojis retrieves emojis by popularity score, optionally filtered by domain
	GetPopularEmojis(ctx context.Context, domain string, limit int) ([]*storage.CustomEmoji, error)

	// IncrementEmojiUsage increments the usage count for an emoji
	IncrementEmojiUsage(ctx context.Context, shortcode string) error
}

type ExportRepository interface {

	// CreateExport creates a new export record
	CreateExport(ctx context.Context, export *models.Export) error

	// GetExport retrieves an export by ID
	GetExport(ctx context.Context, exportID string) (*models.Export, error)

	// UpdateExportStatus updates the status and metadata of an export
	UpdateExportStatus(ctx context.Context, exportID, status string, completionData map[string]any, errorMsg string) error

	// GetExportsForUser retrieves all exports for a user
	GetExportsForUser(ctx context.Context, username string, limit int, cursor string) ([]*models.Export, string, error)

	// GetUserExportsByStatus retrieves exports for a user filtered by status
	GetUserExportsByStatus(ctx context.Context, username string, statuses []string) ([]*models.Export, error)

	// CreateExportCostTracking creates a new export cost tracking record
	CreateExportCostTracking(ctx context.Context, costTracking *models.ExportCostTracking) error

	// GetExportCostTracking retrieves export cost tracking records for an export
	GetExportCostTracking(ctx context.Context, exportID string) ([]*models.ExportCostTracking, error)

	// GetUserExportCosts retrieves export costs for a user within a date range
	GetUserExportCosts(ctx context.Context, username string, startDate, endDate time.Time, limit int) ([]*models.ExportCostTracking, error)

	// GetExportCostsByDateRange retrieves export costs for all users within a date range
	GetExportCostsByDateRange(ctx context.Context, startDate, endDate time.Time, limit int) ([]*models.ExportCostTracking, error)

	// GetExportCostSummary calculates cost summary for a user's exports
	GetExportCostSummary(ctx context.Context, username string, startDate, endDate time.Time) (*models.ExportCostSummary, error)

	// GetHighCostExports returns export operations that exceed a cost threshold
	GetHighCostExports(ctx context.Context, thresholdMicroCents int64, startDate, endDate time.Time, limit int) ([]*models.ExportCostTracking, error)
}

type FeaturedTagRepository interface {

	// CreateFeaturedTag creates a new featured tag for a user
	CreateFeaturedTag(ctx context.Context, tag *storage.FeaturedTag) error

	// DeleteFeaturedTag removes a featured tag
	DeleteFeaturedTag(ctx context.Context, username, name string) error

	// GetFeaturedTags returns all featured tags for a user
	GetFeaturedTags(ctx context.Context, username string) ([]*storage.FeaturedTag, error)

	// GetTagSuggestions returns suggested tags based on user's usage
	GetTagSuggestions(ctx context.Context, username string, limit int) ([]string, error)
}

type FederationRepository interface {

	// GetInstanceInfo retrieves information about a federated instance
	GetInstanceInfo(ctx context.Context, domain string) (*storage.InstanceInfo, error)

	// UpsertInstanceInfo creates or updates instance information
	UpsertInstanceInfo(ctx context.Context, info *storage.InstanceInfo) error

	// GetKnownInstances retrieves a list of known federated instances
	GetKnownInstances(ctx context.Context, limit int, cursor string) ([]*storage.InstanceInfo, string, error)

	// GetFederationStatistics retrieves federation statistics for a time range
	GetFederationStatistics(ctx context.Context, startTime, endTime time.Time) (*storage.FederationStats, error)

	// GetInstanceStats retrieves comprehensive statistics for a specific instance
	GetInstanceStats(ctx context.Context, domain string) (*storage.InstanceStats, error)

	// RecordFederationActivity records a single federation activity for cost tracking
	RecordFederationActivity(ctx context.Context, activity *storage.FederationActivity) error

	// GetFederationCosts retrieves aggregated federation costs
	GetFederationCosts(ctx context.Context, startTime, endTime time.Time, limit int, cursor string) ([]*storage.FederationCost, string, error)

	// GetInstanceHealthReport generates a health report for a specific instance
	GetInstanceHealthReport(ctx context.Context, domain string, period time.Duration) (*storage.InstanceHealthReport, error)

	// GetCostProjections generates cost projections based on historical data
	GetCostProjections(ctx context.Context, period string) (*storage.CostProjection, error)

	// GetFederationNodes retrieves federation nodes up to a certain depth
	GetFederationNodes(ctx context.Context, depth int) ([]*storage.FederationNode, error)

	// GetFederationNodesByHealth retrieves federation nodes filtered by health status
	GetFederationNodesByHealth(ctx context.Context, healthStatus string, limit int) ([]*storage.FederationNode, error)

	// GetFederationEdges retrieves edges between specified domains
	GetFederationEdges(ctx context.Context, domains []string) ([]*storage.FederationEdge, error)

	// GetInstanceMetadata retrieves metadata for a specific instance
	GetInstanceMetadata(ctx context.Context, domain string) (*storage.InstanceMetadata, error)

	// CalculateFederationClusters calculates instance clusters based on connections
	CalculateFederationClusters(ctx context.Context) ([]*storage.InstanceCluster, error)
}

type FilterRepository interface {
	// Core filter operations
	CreateFilter(ctx context.Context, filter *models.Filter) error
	GetFilter(ctx context.Context, filterID string) (*models.Filter, error)
	UpdateFilter(ctx context.Context, filter *models.Filter) error
	DeleteFilter(ctx context.Context, filterID string) error

	// User filter management
	GetUserFilters(ctx context.Context, username string) ([]*models.Filter, error)
	GetActiveFilters(ctx context.Context, username string, context []string) ([]*models.Filter, error)

	// Filter keyword operations
	AddFilterKeyword(ctx context.Context, keyword *models.FilterKeyword) error
	RemoveFilterKeyword(ctx context.Context, keywordID string) error
	GetFilterKeywords(ctx context.Context, filterID string) ([]*models.FilterKeyword, error)

	// Filter status operations
	AddFilterStatus(ctx context.Context, filterStatus *models.FilterStatus) error
	RemoveFilterStatus(ctx context.Context, filterStatusID string) error
	GetFilterStatuses(ctx context.Context, filterID string) ([]*models.FilterStatus, error)

	// Content filtering evaluation
	EvaluateFilters(ctx context.Context, username string, content string, context []string) ([]*models.Filter, error)
	CheckContentFiltered(ctx context.Context, username, statusID string, context []string) (bool, []*models.Filter, error)
}

type HashtagRepository interface {
	// IndexHashtag indexes a hashtag when used in a status
	IndexHashtag(ctx context.Context, hashtag string, statusID string, authorID string, visibility string) error

	// IndexStatusHashtags indexes a status with its hashtags for efficient search
	IndexStatusHashtags(ctx context.Context, statusID string, authorID string, authorHandle string, statusURL string, content string, hashtags []string, published time.Time, visibility string) error

	// RemoveStatusFromHashtagIndex removes a status from all hashtag indexes
	RemoveStatusFromHashtagIndex(ctx context.Context, statusID string) error

	// GetHashtagInfo retrieves information about a specific hashtag
	GetHashtagInfo(ctx context.Context, hashtag string) (*storage.Hashtag, error)

	// GetHashtagUsageHistory retrieves recent usage history for a hashtag
	GetHashtagUsageHistory(ctx context.Context, hashtag string, days int) ([]int64, error)

	// GetHashtagActivity retrieves activities for a hashtag since a specific time
	GetHashtagActivity(ctx context.Context, hashtag string, since time.Time) ([]*storage.Activity, error)

	// GetHashtagStats retrieves hashtag statistics
	GetHashtagStats(ctx context.Context, hashtag string) (any, error)

	// GetHashtagTimelineAdvanced retrieves hashtag timeline with advanced filtering
	GetHashtagTimelineAdvanced(ctx context.Context, hashtag string, maxID *string, limit int, visibility string) ([]*storage.StatusSearchResult, error)

	// GetMultiHashtagTimeline retrieves timeline for multiple hashtags
	GetMultiHashtagTimeline(ctx context.Context, hashtags []string, maxID *string, limit int, userID string) ([]*storage.StatusSearchResult, error)

	// GetSuggestedHashtags gets suggested hashtags for a user
	GetSuggestedHashtags(ctx context.Context, userID string, limit int) ([]*storage.HashtagSearchResult, error)

	// FollowHashtag creates a hashtag follow relationship
	FollowHashtag(ctx context.Context, userID, hashtag string) error

	// UnfollowHashtag removes a hashtag follow relationship
	UnfollowHashtag(ctx context.Context, userID, hashtag string) error

	// IsFollowingHashtag checks if a user is following a hashtag
	IsFollowingHashtag(ctx context.Context, userID, hashtag string) (bool, error)

	// GetHashtagFollow retrieves the hashtag follow record for a user
	GetHashtagFollow(ctx context.Context, userID string, hashtag string) (*models.HashtagFollow, error)

	// GetHashtagMute retrieves the hashtag mute record for a user
	GetHashtagMute(ctx context.Context, userID string, hashtag string) (*models.HashtagMute, error)
}

type ImportRepository interface {

	// CreateImport creates a new import record
	CreateImport(ctx context.Context, importRecord *models.Import) error

	// GetImport retrieves an import by ID
	GetImport(ctx context.Context, importID string) (*models.Import, error)

	// UpdateImportStatus updates the status and metadata of an import
	UpdateImportStatus(ctx context.Context, importID, status string, completionData map[string]any, errorMsg string) error

	// UpdateImportProgress updates the progress of an import
	UpdateImportProgress(ctx context.Context, importID string, progress int) error

	// GetImportsForUser retrieves all imports for a user
	GetImportsForUser(ctx context.Context, username string, limit int, cursor string) ([]*models.Import, string, error)

	// GetUserImportsByStatus retrieves imports for a user filtered by status
	GetUserImportsByStatus(ctx context.Context, username string, statuses []string) ([]*models.Import, error)

	// CreateImportCostTracking creates a new import cost tracking record
	CreateImportCostTracking(ctx context.Context, costTracking *models.ImportCostTracking) error

	// GetImportCostTracking retrieves import cost tracking records for an import
	GetImportCostTracking(ctx context.Context, importID string) ([]*models.ImportCostTracking, error)

	// GetUserImportCosts retrieves import costs for a user within a date range
	GetUserImportCosts(ctx context.Context, username string, startDate, endDate time.Time, limit int) ([]*models.ImportCostTracking, error)

	// GetImportCostsByDateRange retrieves import costs for all users within a date range
	GetImportCostsByDateRange(ctx context.Context, startDate, endDate time.Time, limit int) ([]*models.ImportCostTracking, error)

	// GetImportCostSummary calculates cost summary for a user's imports
	GetImportCostSummary(ctx context.Context, username string, startDate, endDate time.Time) (*models.ImportCostSummary, error)

	// GetHighCostImports returns import operations that exceed a cost threshold
	GetHighCostImports(ctx context.Context, thresholdMicroCents int64, startDate, endDate time.Time, limit int) ([]*models.ImportCostTracking, error)

	// CreateImportBudget creates a new import budget configuration
	CreateImportBudget(ctx context.Context, budget *models.ImportBudget) error

	// UpdateImportBudget updates an existing import budget
	UpdateImportBudget(ctx context.Context, budget *models.ImportBudget) error

	// GetImportBudget retrieves import budget configuration for a user
	GetImportBudget(ctx context.Context, username, period string) (*models.ImportBudget, error)

	// CheckBudgetLimits checks if a user is within their budget limits
	CheckBudgetLimits(ctx context.Context, username string, importCostMicroCents, exportCostMicroCents int64) (*models.ImportBudget, bool, error)

	// UpdateBudgetUsage updates the current usage for a user's budget
	UpdateBudgetUsage(ctx context.Context, username, period string, importCostMicroCents, exportCostMicroCents int64) error
}

type InstanceRepository interface {

	// GetInstanceState returns the current instance activation state
	GetInstanceState(ctx context.Context) (*models.InstanceState, error)

	// EnsureInstanceState ensures the instance state record exists and returns it
	EnsureInstanceState(ctx context.Context) (*models.InstanceState, error)

	// SetInstanceLocked updates the instance lock state
	SetInstanceLocked(ctx context.Context, locked bool) error

	// SetBootstrapWalletAddress sets the bootstrap wallet address used for setup authentication
	SetBootstrapWalletAddress(ctx context.Context, address string) error

	// SetPrimaryAdminUsername records the primary admin username created during setup
	SetPrimaryAdminUsername(ctx context.Context, username string) error

	// GetAgentInstanceConfig returns the current instance agent policy.
	GetAgentInstanceConfig(ctx context.Context) (*models.AgentInstanceConfig, error)

	// EnsureAgentInstanceConfig ensures the instance agent policy record exists and returns it.
	EnsureAgentInstanceConfig(ctx context.Context) (*models.AgentInstanceConfig, error)

	// SetAgentInstanceConfig updates the instance agent policy.
	SetAgentInstanceConfig(ctx context.Context, cfg *models.AgentInstanceConfig) error

	// GetInstanceRules retrieves the instance rules
	GetInstanceRules(ctx context.Context) ([]storage.InstanceRule, error)

	// SetInstanceRules updates the instance rules
	SetInstanceRules(ctx context.Context, rules []storage.InstanceRule) error

	// GetRulesByCategory retrieves rules filtered by category
	GetRulesByCategory(ctx context.Context, category string) ([]storage.InstanceRule, error)

	// GetExtendedDescription retrieves the instance extended description
	GetExtendedDescription(ctx context.Context) (string, time.Time, error)

	// SetExtendedDescription updates the instance extended description
	SetExtendedDescription(ctx context.Context, description string) error

	// GetTotalUserCount returns the total number of users
	GetTotalUserCount(ctx context.Context) (int64, error)

	// GetTotalStatusCount returns the total number of statuses
	GetTotalStatusCount(ctx context.Context) (int64, error)

	// GetTotalDomainCount returns the total number of known domains
	GetTotalDomainCount(ctx context.Context) (int64, error)

	// GetActiveUserCount returns the number of active users in the last N days
	GetActiveUserCount(ctx context.Context, days int) (int64, error)

	// GetDailyActiveUserCount returns the number of daily active users
	GetDailyActiveUserCount(ctx context.Context) (int64, error)

	// GetLocalPostCount returns the number of local posts
	GetLocalPostCount(ctx context.Context) (int64, error)

	// GetLocalCommentCount returns the number of local comments
	GetLocalCommentCount(ctx context.Context) (int64, error)

	// GetWeeklyActivity retrieves weekly activity data for a specific week
	GetWeeklyActivity(ctx context.Context, weekTimestamp int64) (*storage.WeeklyActivity, error)

	// RecordActivity records activity data for analytics
	RecordActivity(ctx context.Context, activityType string, userID string, timestamp time.Time) error

	// GetContactAccount returns the contact account for the instance
	GetContactAccount(ctx context.Context) (*storage.ActorRecord, error)

	// GetStorageUsage returns current storage usage statistics
	GetStorageUsage(ctx context.Context) (any, error)

	// GetStorageHistory returns storage usage history for the last N days
	GetStorageHistory(ctx context.Context, days int) ([]any, error)

	// GetUserGrowthHistory returns user growth data for the last N days
	GetUserGrowthHistory(ctx context.Context, days int) ([]any, error)

	// GetDomainStats returns statistics for a specific domain
	GetDomainStats(ctx context.Context, domain string) (any, error)

	// RecordDailyMetrics records daily historical metrics for the instance
	RecordDailyMetrics(ctx context.Context, date string, metrics map[string]interface{}) error

	// GetMetricsSummary returns aggregated metrics for a given time range
	GetMetricsSummary(ctx context.Context, timeRange string) (map[string]interface{}, error)
}

type LikeRepository interface {
	// CreateLike creates a new like
	CreateLike(ctx context.Context, actor, object, statusAuthorID string) (*models.Like, error)

	// DeleteLike removes a like
	DeleteLike(ctx context.Context, actor, object string) error

	// GetLike retrieves a specific like
	GetLike(ctx context.Context, actor, object string) (*models.Like, error)

	// GetObjectLikes retrieves all likes for an object with pagination
	GetObjectLikes(ctx context.Context, objectID string, limit int, cursor string) ([]*models.Like, string, error)

	// GetActorLikes retrieves all likes by an actor with pagination
	GetActorLikes(ctx context.Context, actorID string, limit int, cursor string) ([]*models.Like, string, error)

	// CountActorLikes returns the total number of likes by an actor
	CountActorLikes(ctx context.Context, actorID string) (int64, error)

	// HasLiked checks if an actor has liked an object
	HasLiked(ctx context.Context, actor, object string) (bool, error)

	// CascadeDeleteLikes deletes all likes for an object
	CascadeDeleteLikes(ctx context.Context, objectID string) error

	// TombstoneObject creates a tombstone for a deleted object
	TombstoneObject(ctx context.Context, objectID string, deletedBy string) error

	// GetTombstone retrieves a tombstone by object ID
	GetTombstone(ctx context.Context, objectID string) (*storage.Tombstone, error)

	// GetLikeCount counts likes for a status
	GetLikeCount(ctx context.Context, statusID string) (int64, error)

	// GetBoostCount counts boosts/announces for a status
	GetBoostCount(ctx context.Context, statusID string) (int64, error)

	// IncrementReblogCount increments the reblog count on a status
	IncrementReblogCount(ctx context.Context, objectID string) error

	// HasReblogged checks if a user has reblogged/boosted a specific status
	HasReblogged(ctx context.Context, actorID, statusID string) (bool, error)

	// CountForObject provides Storage interface compatibility for CountObjectLikes
	CountForObject(ctx context.Context, objectID string) (int64, error)

	// GetForObject provides Storage interface compatibility for GetObjectLikes
	GetForObject(ctx context.Context, objectID string, limit int, cursor string) ([]*models.Like, string, error)

	// GetLikedObjects provides Storage interface compatibility
	GetLikedObjects(ctx context.Context, actorID string, limit int, cursor string) ([]*models.Like, string, error)
}

type ListRepository interface {
	// Core list operations
	CreateList(ctx context.Context, list *models.List) error
	GetList(ctx context.Context, listID string) (*models.List, error)
	UpdateList(ctx context.Context, list *models.List) error
	DeleteList(ctx context.Context, listID string) error

	// User list management
	GetUserLists(ctx context.Context, username string, opts PaginationOptions) (*PaginatedResult[*models.List], error)
	GetListsByMember(ctx context.Context, memberUsername string, opts PaginationOptions) (*PaginatedResult[*models.List], error)
	GetListsForUser(ctx context.Context, username string) ([]*storage.List, error)
	GetListsForUserPaginated(ctx context.Context, username string, limit int, cursor string) ([]*storage.List, string, error)
	CountUserLists(ctx context.Context, username string) (int, error)

	// List membership operations
	AddListMember(ctx context.Context, listID, memberUsername string) error
	RemoveListMember(ctx context.Context, listID, memberUsername string) error
	GetListMembers(ctx context.Context, listID string, opts PaginationOptions) (*PaginatedResult[*storage.Account], error)
	IsListMember(ctx context.Context, listID, memberUsername string) (bool, error)
	CountListMembers(ctx context.Context, listID string) (int, error)

	// Account list operations
	GetAccountLists(ctx context.Context, accountID string) ([]*storage.List, error)
	GetAccountListsPaginated(ctx context.Context, accountID string, limit int, cursor string) ([]*storage.List, string, error)
	GetAccountListsForUser(ctx context.Context, accountID, username string) ([]*storage.List, error)
	RemoveAccountFromAllLists(ctx context.Context, accountID string) error

	// Exclusive lists
	GetExclusiveLists(ctx context.Context, username string) ([]*storage.List, error)

	// Batch operations
	AddAccountsToList(ctx context.Context, listID string, accountIDs []string) error
	RemoveAccountsFromList(ctx context.Context, listID string, accountIDs []string) error
	GetListAccounts(ctx context.Context, listID string) ([]string, error)
	GetListsContainingAccount(ctx context.Context, accountID, username string) ([]*storage.List, error)

	// List timeline operations
	GetListTimeline(ctx context.Context, listID string, opts PaginationOptions) (*PaginatedResult[*models.Status], error)
	GetListStatuses(ctx context.Context, listID string, opts PaginationOptions) (*PaginatedResult[*models.Status], error)
}

type MarkerRepository interface {
	// SaveMarker saves or updates a timeline position marker
	SaveMarker(ctx context.Context, username, timeline string, lastReadID string, version int) error

	// GetMarkers retrieves timeline position markers for specified timelines
	GetMarkers(ctx context.Context, username string, timelines []string) (map[string]*storage.Marker, error)
}

type MediaAnalyticsRepository interface {
	// Core analytics operations
	RecordMediaAnalytics(ctx context.Context, analytics *models.MediaAnalytics) error
	GetMediaAnalyticsByID(ctx context.Context, format string, timestamp time.Time, mediaID string) (*models.MediaAnalytics, error)
	UpdateMediaAnalytics(ctx context.Context, analytics *models.MediaAnalytics) error
	StoreMediaAnalytics(ctx context.Context, analytics *models.MediaAnalytics) error

	// Analytics queries by date and variant
	GetMediaAnalyticsByDate(ctx context.Context, date string) ([]*models.MediaAnalytics, error)
	GetMediaAnalyticsByVariant(ctx context.Context, variantKey string) ([]*models.MediaAnalytics, error)
	GetMediaAnalyticsByTimeRange(ctx context.Context, mediaID string, startTime, endTime time.Time, limit int) ([]*models.MediaAnalytics, error)
	GetAllMediaAnalyticsByTimeRange(ctx context.Context, startTime, endTime time.Time, limit int) ([]*models.MediaAnalytics, error)

	// Cost and summary operations
	GetDailyCostSummary(ctx context.Context, date string) (map[string]interface{}, error)
	GetTopVariantsByDemand(ctx context.Context, date string, limit int) ([]map[string]interface{}, error)

	// Media view and behavior tracking
	RecordMediaView(ctx context.Context, mediaID, userID string, duration time.Duration, quality string) error
	TrackUserBehavior(ctx context.Context, userID string, behaviorData map[string]interface{}) error

	// Popularity and metrics
	CalculatePopularityMetrics(ctx context.Context, mediaID string, days int) (map[string]interface{}, error)
	GetMediaMetricsForDate(ctx context.Context, mediaID, date string) (map[string]interface{}, error)

	// Reporting and recommendations
	GenerateAnalyticsReport(ctx context.Context, startDate, endDate string) (map[string]interface{}, error)
	GetContentRecommendations(ctx context.Context, userID string, limit int) ([]map[string]interface{}, error)

	// Bandwidth and popular media queries
	GetBandwidthByTimeRange(ctx context.Context, startTime, endTime time.Time, limit int) ([]*models.MediaAnalytics, error)
	GetPopularMedia(ctx context.Context, startTime, endTime time.Time, limit int, cursor *string) ([]*models.MediaAnalytics, error)

	// Cleanup operations
	CleanupOldAnalytics(ctx context.Context, olderThan time.Duration) error
}

type MediaMetadataRepository interface {
	// Core metadata operations
	CreateMediaMetadata(ctx context.Context, metadata *models.MediaMetadata) error
	GetMediaMetadata(ctx context.Context, mediaID string) (*models.MediaMetadata, error)
	UpdateMediaMetadata(ctx context.Context, metadata *models.MediaMetadata) error
	DeleteMediaMetadata(ctx context.Context, mediaID string) error

	// Status-based queries
	GetMediaMetadataByStatus(ctx context.Context, status string, limit int) ([]*models.MediaMetadata, error)
	GetPendingMediaMetadata(ctx context.Context, limit int) ([]*models.MediaMetadata, error)
	GetProcessingMediaMetadata(ctx context.Context, limit int) ([]*models.MediaMetadata, error)

	// Processing status updates
	MarkProcessingStarted(ctx context.Context, mediaID string) error
	MarkProcessingComplete(ctx context.Context, mediaID string, result ProcessingResult) error
	MarkProcessingFailed(ctx context.Context, mediaID string, errorMsg string) error

	// Cleanup operations
	CleanupExpiredMetadata(ctx context.Context) error
}

type MediaPopularityRepository interface {
	// Core popularity operations
	UpsertPopularity(ctx context.Context, popularity *models.MediaPopularity) error
	GetPopularityForMedia(ctx context.Context, mediaID, period string) (*models.MediaPopularity, error)

	// Popular media queries
	GetPopularMediaByPeriod(ctx context.Context, period string, limit int, cursor *string) ([]*models.MediaPopularity, error)

	// View count operations
	IncrementViewCount(ctx context.Context, mediaID, period string, incrementBy int64) error
}

type MediaRepository interface {
	// Core media operations
	CreateMedia(ctx context.Context, media *models.Media) error
	GetMedia(ctx context.Context, mediaID string) (*models.Media, error)
	UpdateMedia(ctx context.Context, media *models.Media) error
	DeleteMedia(ctx context.Context, mediaID string) error

	// Media queries
	GetMediaByUser(ctx context.Context, userID string, limit int) ([]*models.Media, error)
	GetMediaByStatus(ctx context.Context, status string, limit int) ([]*models.Media, error)
	GetMediaByContentType(ctx context.Context, contentType string, limit int) ([]*models.Media, error)
	GetUserMediaLegacy(ctx context.Context, username string) ([]any, error)

	// User media queries (paginated)
	GetUserMedia(ctx context.Context, userID string, opts PaginationOptions) (*PaginatedResult[*models.Media], error)
	GetUserMediaByType(ctx context.Context, userID, contentType string, opts PaginationOptions) (*PaginatedResult[*models.Media], error)
	GetUnusedMedia(ctx context.Context, olderThan time.Time, opts PaginationOptions) (*PaginatedResult[*models.Media], error)

	// Media processing
	MarkMediaProcessing(ctx context.Context, mediaID string) error
	MarkMediaReady(ctx context.Context, mediaID string) error
	MarkMediaFailed(ctx context.Context, mediaID, errorMsg string) error
	GetPendingMedia(ctx context.Context, opts PaginationOptions) (*PaginatedResult[*models.Media], error)
	GetProcessingMedia(ctx context.Context, opts PaginationOptions) (*PaginatedResult[*models.Media], error)

	// Media variants and thumbnails
	AddMediaVariant(ctx context.Context, mediaID, variantName string, variant models.MediaVariant) error
	GetMediaVariant(ctx context.Context, mediaID, variantName string) (*models.MediaVariant, error)
	DeleteMediaVariant(ctx context.Context, mediaID, variantName string) error

	// Media attachment updates
	UpdateMediaAttachment(ctx context.Context, mediaID string, updates map[string]any) error
	UnmarkAllMediaAsSensitive(ctx context.Context, username string) error

	// Media usage tracking
	MarkMediaUsed(ctx context.Context, mediaID string) error
	GetMediaUsageStats(ctx context.Context, mediaID string) (usageCount int, lastUsed *time.Time, err error)

	// Content moderation
	SetMediaModeration(ctx context.Context, mediaID string, isNSFW bool, score float64, labels []string) error
	GetModerationPendingMedia(ctx context.Context, opts PaginationOptions) (*PaginatedResult[*models.Media], error)

	// Batch operations
	GetMediaByIDs(ctx context.Context, mediaIDs []string) ([]*models.Media, error)
	DeleteExpiredMedia(ctx context.Context, expiredBefore time.Time) (int64, error)

	// Storage and CDN operations
	GetMediaStorageUsage(ctx context.Context, userID string) (int64, error)
	GetTotalStorageUsage(ctx context.Context) (int64, error)

	// Media job operations
	CreateMediaJob(ctx context.Context, job *models.MediaJob) error
	GetMediaJob(ctx context.Context, jobID string) (*models.MediaJob, error)
	UpdateMediaJob(ctx context.Context, job *models.MediaJob) error
	DeleteMediaJob(ctx context.Context, jobID string) error
	GetJobsByStatus(ctx context.Context, status string, limit int) ([]*models.MediaJob, error)
	GetJobsByUser(ctx context.Context, username string, limit int) ([]*models.MediaJob, error)

	// User media configuration
	CreateUserMediaConfig(ctx context.Context, config *models.UserMediaConfig) error
	GetUserMediaConfig(ctx context.Context, userID string) (*models.UserMediaConfig, error)
	GetUserMediaConfigByUsername(ctx context.Context, username string) (*models.UserMediaConfig, error)
	UpdateUserMediaConfig(ctx context.Context, config *models.UserMediaConfig) error
	DeleteUserMediaConfig(ctx context.Context, userID string) error

	// Media spending tracking
	CreateMediaSpending(ctx context.Context, spending *models.MediaSpending) error
	GetMediaSpending(ctx context.Context, userID, period string) (*models.MediaSpending, error)
	UpdateMediaSpending(ctx context.Context, spending *models.MediaSpending) error
	GetMediaSpendingByTimeRange(ctx context.Context, userID string, periodType string, limit int) ([]*models.MediaSpending, error)
	GetOrCreateMediaSpending(ctx context.Context, userID, period, periodType string) (*models.MediaSpending, error)

	// Spending transactions
	CreateMediaSpendingTransaction(ctx context.Context, transaction *models.MediaSpendingTransaction) error
	GetMediaSpendingTransactions(ctx context.Context, userID string, limit int) ([]*models.MediaSpendingTransaction, error)
	AddSpendingTransaction(ctx context.Context, transaction *models.MediaSpendingTransaction) error

	// Transcoding job operations
	CreateTranscodingJob(ctx context.Context, job *models.TranscodingJob) error
	GetTranscodingJob(ctx context.Context, jobID string) (*models.TranscodingJob, error)
	UpdateTranscodingJob(ctx context.Context, job *models.TranscodingJob) error
	GetTranscodingJobsByUser(ctx context.Context, userID string, limit int) ([]*models.TranscodingJob, error)
	GetTranscodingJobsByMedia(ctx context.Context, mediaID string, limit int) ([]*models.TranscodingJob, error)
	GetTranscodingJobsByStatus(ctx context.Context, status string, limit int) ([]*models.TranscodingJob, error)
	DeleteTranscodingJob(ctx context.Context, jobID string) error
	GetTranscodingCostsByUser(ctx context.Context, userID string, timeRange string) (map[string]int64, error)

	// Dependencies
	SetDependencies(deps map[string]interface{})
}

type MediaRepositoryInterface interface {
	GetMedia(ctx context.Context, mediaID string) (*models.Media, error)
}

type MediaSessionRepository interface {
	// Session lifecycle operations
	StartStreamingSession(ctx context.Context, userID, mediaID string, format types.MediaFormat, quality types.Quality) (*types.StreamingSession, error)
	EndStreamingSession(ctx context.Context, sessionID string) error
	UpdateStreamingMetrics(ctx context.Context, sessionID string, segmentIndex int, bytesTransferred int64, bufferHealth float64, currentQuality types.Quality) error

	// Legacy session operations
	CreateSession(ctx context.Context, session *types.StreamingSession) error
	GetSession(ctx context.Context, sessionID string) (*types.StreamingSession, error)
	UpdateSession(ctx context.Context, session *types.StreamingSession) error
	EndSession(ctx context.Context, sessionID string) error

	// Session queries
	GetActiveStreams(ctx context.Context, limit int) ([]*types.StreamingSession, error)
	GetUserSessions(ctx context.Context, userID string) ([]*types.StreamingSession, error)
	GetMediaSessions(ctx context.Context, mediaID string, limit int32) ([]*types.StreamingSession, error)
	GetSessionsByTimeRange(ctx context.Context, startTime, endTime time.Time, limit int32) ([]*types.StreamingSession, error)

	// Session validation and access
	ValidateSessionAccess(ctx context.Context, sessionID, userID string) (bool, error)

	// Session analytics and monitoring
	GetActiveSessionsCount(ctx context.Context) (int, error)

	// Session cleanup
	CleanupExpiredSessions(ctx context.Context, maxAge time.Duration) error

	// Session TTL configuration
	SetSessionTTL(ttl time.Duration)
}

type MetricRecordRepository interface {

	// CreateMetricRecord creates a new metric record
	CreateMetricRecord(ctx context.Context, record *models.MetricRecord) error

	// BatchCreateMetricRecords creates multiple metric records efficiently
	BatchCreateMetricRecords(ctx context.Context, records []*models.MetricRecord) error

	// GetMetricRecord retrieves a single metric record by its keys
	GetMetricRecord(ctx context.Context, metricType, bucket, timestamp string) (*models.MetricRecord, error)

	// UpdateMetricRecord updates an existing metric record
	UpdateMetricRecord(ctx context.Context, record *models.MetricRecord) error

	// DeleteMetricRecord deletes a metric record by its keys
	DeleteMetricRecord(ctx context.Context, metricType, bucket, timestamp string) error

	// GetMetricsByService queries metrics by service within a time range using GSI1
	GetMetricsByService(ctx context.Context, serviceName string, startTime, endTime time.Time) ([]*models.MetricRecord, error)

	// GetMetricsByType queries metrics by type within a time range using GSI2
	GetMetricsByType(ctx context.Context, metricType string, startTime, endTime time.Time) ([]*models.MetricRecord, error)

	// GetMetricsByDate queries metrics by date and service using GSI3
	GetMetricsByDate(ctx context.Context, date time.Time, serviceName string) ([]*models.MetricRecord, error)

	// GetMetricsByAggregationLevel queries metrics by aggregation level within a time range using GSI4
	GetMetricsByAggregationLevel(ctx context.Context, level string, startTime, endTime time.Time) ([]*models.MetricRecord, error)

	// GetServiceMetricsStats calculates statistics for a service's metrics
	GetServiceMetricsStats(ctx context.Context, serviceName string, metricType string, startTime, endTime time.Time) (*MetricRecordStats, error)
}

type MetricRecordStats struct {
	Service    string
	Type       string
	StartTime  time.Time
	EndTime    time.Time
	Count      int
	TotalCount int64
	TotalSum   float64
	Average    float64
	Min        float64
	Max        float64
}

type MetricsConfig struct {
	// EnableMetrics enables metrics collection and reporting
	EnableMetrics bool

	// MetricsPrefix is the prefix for all metric names
	MetricsPrefix string

	// EnableDetailedMetrics enables detailed operation-level metrics
	EnableDetailedMetrics bool

	// MetricsInterval is the interval for metrics aggregation and reporting
	MetricsInterval time.Duration
}

type MigrationInfo struct {
	AlsoKnownAs []string `json:"also_known_as"`
	MovedTo     string   `json:"moved_to,omitempty"`
}

type ModerationMLRepository interface {

	// CreateSample creates a new moderation training sample
	CreateSample(ctx context.Context, sample *models.ModerationSample) error

	// GetSample retrieves a sample by ID
	GetSample(ctx context.Context, sampleID string) (*models.ModerationSample, error)

	// ListSamplesByLabel retrieves samples with a specific label
	ListSamplesByLabel(ctx context.Context, label string, limit int) ([]*models.ModerationSample, error)

	// ListSamplesByReviewer retrieves samples submitted by a specific reviewer
	ListSamplesByReviewer(ctx context.Context, reviewerID string, limit int) ([]*models.ModerationSample, error)

	// CreateModelVersion creates a new model version record
	CreateModelVersion(ctx context.Context, version *models.ModerationModelVersion) error

	// GetModelVersion retrieves a model version by ID
	GetModelVersion(ctx context.Context, versionID string) (*models.ModerationModelVersion, error)

	// GetActiveModelVersion retrieves the currently active model version
	GetActiveModelVersion(ctx context.Context) (*models.ModerationModelVersion, error)

	// UpdateModelVersion updates an existing model version
	UpdateModelVersion(ctx context.Context, version *models.ModerationModelVersion) error

	// CreateEffectivenessMetric creates a new effectiveness metric record
	CreateEffectivenessMetric(ctx context.Context, metric *models.ModerationEffectivenessMetric) error

	// GetEffectivenessMetric retrieves effectiveness metrics for a pattern/period
	GetEffectivenessMetric(ctx context.Context, patternID, period string, startTime time.Time) (*models.ModerationEffectivenessMetric, error)

	// ListEffectivenessMetricsByPattern retrieves all metrics for a pattern
	ListEffectivenessMetricsByPattern(ctx context.Context, patternID string, limit int) ([]*models.ModerationEffectivenessMetric, error)

	// ListEffectivenessMetricsByPeriod retrieves top-performing patterns for a period
	ListEffectivenessMetricsByPeriod(ctx context.Context, period string, limit int) ([]*models.ModerationEffectivenessMetric, error)
}

type ModerationRepository interface {

	// CreateModerationEvent creates a new moderation event
	CreateModerationEvent(ctx context.Context, event *storage.ModerationEvent) error

	// GetModerationEvent retrieves a moderation event by ID
	GetModerationEvent(ctx context.Context, eventID string) (*storage.ModerationEvent, error)

	// GetModerationEvents retrieves moderation events with optional filters
	GetModerationEvents(ctx context.Context, filter *storage.ModerationEventFilter, limit int, cursor string) ([]*storage.ModerationEvent, string, error)

	// GetModerationEventsByObject retrieves all moderation events for an object
	GetModerationEventsByObject(ctx context.Context, objectID string, limit int, cursor string) ([]*storage.ModerationEvent, string, error)

	// GetModerationEventsByActor retrieves all moderation events created by an actor
	GetModerationEventsByActor(ctx context.Context, actorID string, limit int, cursor string) ([]*storage.ModerationEvent, string, error)

	// GetModerationQueue retrieves pending moderation events
	GetModerationQueue(ctx context.Context, filter *storage.ModerationFilter) ([]*storage.ModerationQueueItem, error)

	// GetModerationQueuePaginated retrieves pending moderation events with pagination
	GetModerationQueuePaginated(ctx context.Context, limit int, cursor string) ([]*storage.ModerationQueueItem, string, error)

	// GetModerationQueueCount returns the count of items in the moderation queue
	GetModerationQueueCount(ctx context.Context) (int, error)

	// AddModerationReview adds a review to a moderation event
	AddModerationReview(ctx context.Context, review *storage.ModerationReview) error

	// GetModerationReviews retrieves all reviews for a moderation event
	GetModerationReviews(ctx context.Context, eventID string) ([]*storage.ModerationReview, error)

	// CreateAdminReview creates an admin review that overrides consensus
	CreateAdminReview(ctx context.Context, eventID string, adminID string, action storage.ActionType, reason string) error

	// GetReviewerStats retrieves statistics for a reviewer
	GetReviewerStats(ctx context.Context, reviewerID string) (*storage.ReviewerStats, error)

	// CreateModerationDecision creates a consensus decision
	CreateModerationDecision(ctx context.Context, decision *storage.ModerationDecision) error

	// GetModerationDecision retrieves the current decision for an object
	GetModerationDecision(ctx context.Context, objectID string) (*storage.ModerationDecision, error)

	// StoreModerationDecision stores a moderation decision (alias for CreateModerationDecision)
	StoreModerationDecision(ctx context.Context, decision *storage.ModerationDecision) error

	// UpdateModerationDecision updates a moderation decision based on a review
	UpdateModerationDecision(ctx context.Context, contentID string, review *storage.ModerationReview) error

	// CreateModerationPattern creates a new moderation pattern
	CreateModerationPattern(ctx context.Context, pattern *storage.ModerationPattern) error

	// GetModerationPattern retrieves a specific moderation pattern
	GetModerationPattern(ctx context.Context, patternID string) (*storage.ModerationPattern, error)

	// GetModerationPatterns retrieves moderation patterns based on criteria
	GetModerationPatterns(ctx context.Context, active bool, severity string, limit int) ([]*storage.ModerationPattern, error)

	// UpdateModerationPattern updates an existing moderation pattern
	UpdateModerationPattern(ctx context.Context, pattern *storage.ModerationPattern) error

	// DeleteModerationPattern deletes a moderation pattern
	DeleteModerationPattern(ctx context.Context, patternID string) error

	// RecordPatternMatch records a moderation pattern match for analytics
	RecordPatternMatch(ctx context.Context, patternID string, matched bool, timestamp time.Time) error

	// GetModerationHistory retrieves the complete moderation history for an object
	GetModerationHistory(ctx context.Context, objectID string) (*storage.ModerationHistory, error)

	// CreateFilter creates a new filter
	CreateFilter(ctx context.Context, filter *storage.Filter) error

	// GetFilter retrieves a filter by ID
	GetFilter(ctx context.Context, filterID string) (*storage.Filter, error)

	// GetFiltersForUser retrieves all filters for a user
	GetFiltersForUser(ctx context.Context, username string) ([]*storage.Filter, error)

	// UpdateFilter updates a filter
	UpdateFilter(ctx context.Context, filterID string, updates map[string]any) error

	// DeleteFilter deletes a filter and all its associated keywords and statuses
	DeleteFilter(ctx context.Context, filterID string) error

	// AddFilterKeyword adds a new keyword to a filter
	AddFilterKeyword(ctx context.Context, filterID string, keyword *storage.FilterKeyword) error

	// GetFilterKeywords retrieves all keywords for a filter
	GetFilterKeywords(ctx context.Context, filterID string) ([]*storage.FilterKeyword, error)

	// UpdateFilterKeyword updates a filter keyword
	UpdateFilterKeyword(ctx context.Context, keywordID string, updates map[string]any) error

	// DeleteFilterKeyword deletes a filter keyword
	DeleteFilterKeyword(ctx context.Context, keywordID string) error

	// AddFilterStatus adds a new status to a filter
	AddFilterStatus(ctx context.Context, filterID string, status *storage.FilterStatus) error

	// GetFilterStatuses retrieves all statuses for a filter
	GetFilterStatuses(ctx context.Context, filterID string) ([]*storage.FilterStatus, error)

	// DeleteFilterStatus deletes a filter status
	DeleteFilterStatus(ctx context.Context, statusID string) error

	// CreateReport creates a new report
	CreateReport(ctx context.Context, report *storage.Report) error

	// GetReport retrieves a report by ID
	GetReport(ctx context.Context, id string) (*storage.Report, error)

	// GetUserReports retrieves all reports created by a user
	GetUserReports(ctx context.Context, username string, limit int, cursor string) ([]*storage.Report, string, error)

	// GetReportsByTarget retrieves reports targeting a specific account
	GetReportsByTarget(ctx context.Context, targetAccountID string, limit int, cursor string) ([]*storage.Report, string, error)

	// GetReportsByStatus retrieves reports with a specific status
	GetReportsByStatus(ctx context.Context, status storage.ReportStatus, limit int, cursor string) ([]*storage.Report, string, error)

	// UpdateReportStatus updates the status of a report
	UpdateReportStatus(ctx context.Context, id string, status storage.ReportStatus, actionTaken string, moderatorID string) error

	// AssignReport assigns a report to a moderator
	AssignReport(ctx context.Context, reportID string, assignedTo string) error

	// UnassignReport removes assignment from a report
	UnassignReport(ctx context.Context, reportID string) error

	// GetOpenReportsCount returns the count of open reports
	GetOpenReportsCount(ctx context.Context) (int, error)

	// GetReportedStatuses retrieves statuses associated with a report
	GetReportedStatuses(ctx context.Context, reportID string) ([]any, error)

	// GetReportStats retrieves reporting statistics for a user
	GetReportStats(ctx context.Context, username string) (*storage.ReportStats, error)

	// IncrementFalseReports increments the false report count for a user
	IncrementFalseReports(ctx context.Context, username string) error

	// CreateFlag creates a new flag
	CreateFlag(ctx context.Context, flag *storage.Flag) error

	// GetFlag retrieves a flag by ID
	GetFlag(ctx context.Context, id string) (*storage.Flag, error)

	// GetFlagsByObject retrieves all flags for a specific object
	GetFlagsByObject(ctx context.Context, objectID string, limit int, cursor string) ([]*storage.Flag, string, error)

	// GetFlagsByActor retrieves all flags created by a specific actor
	GetFlagsByActor(ctx context.Context, actorID string, limit int, cursor string) ([]*storage.Flag, string, error)

	// GetPendingFlags retrieves all pending flags
	GetPendingFlags(ctx context.Context, limit int, cursor string) ([]*storage.Flag, string, error)

	// UpdateFlagStatus updates the status of a flag
	UpdateFlagStatus(ctx context.Context, id string, status storage.FlagStatus, reviewedBy string, reviewNote string) error

	// CountPendingFlags returns the count of pending flags
	CountPendingFlags(ctx context.Context) (int, error)

	// DeleteFlag removes a flag
	DeleteFlag(ctx context.Context, id string) error

	// CreateAuditLog creates a new audit log entry
	CreateAuditLog(ctx context.Context, auditLog *storage.AuditLog) error

	// GetAuditLogs retrieves audit log entries with pagination
	GetAuditLogs(ctx context.Context, limit int, cursor string) ([]*storage.AuditLog, string, error)

	// GetAuditLogsByAdmin retrieves audit log entries for a specific admin
	GetAuditLogsByAdmin(ctx context.Context, adminID string, limit int, cursor string) ([]*storage.AuditLog, string, error)

	// GetAuditLogsByTarget retrieves audit log entries for a specific target
	GetAuditLogsByTarget(ctx context.Context, targetID string, limit int, cursor string) ([]*storage.AuditLog, string, error)

	// GetPendingModerationCount returns the count of pending moderation tasks for a specific moderator
	GetPendingModerationCount(ctx context.Context, moderatorID string) (int, error)

	// StoreAnalysisResult stores detailed analysis results for audit/appeals
	StoreAnalysisResult(ctx context.Context, analysisData map[string]interface{}) error

	// StoreDecision stores a moderation decision with enforcement tracking
	StoreDecision(ctx context.Context, decisionData map[string]interface{}) error

	// GetReviewQueue retrieves review queue items with filtering
	GetReviewQueue(ctx context.Context, filters map[string]interface{}) ([]*models.ModerationReviewQueue, error)

	// GetDecisionHistory retrieves decision history for a specific content ID
	GetDecisionHistory(ctx context.Context, contentID string) ([]*models.ModerationDecisionResult, error)

	// UpdateEnforcementStatus updates the enforcement status of a decision
	UpdateEnforcementStatus(ctx context.Context, contentID, status string) error

	// GetModerationDecisionsByModerator retrieves moderation decisions made by a specific moderator
	GetModerationDecisionsByModerator(ctx context.Context, moderatorUsername string, limit int) ([]*models.ModerationReview, error)
}

type MonthlyAggregate struct {
	Year            int
	Month           int
	TotalCost       float64
	TotalOperations int64
}

type NotificationDispatcher interface {
	DispatchPushForNotification(ctx context.Context, notification *models.Notification)
}

type NotificationRepository interface {
	// Dispatcher configuration
	SetDispatcher(dispatcher NotificationDispatcher)

	// Core notification operations
	CreateNotification(ctx context.Context, notification *models.Notification) error
	GetNotification(ctx context.Context, notificationID string) (*models.Notification, error)
	UpdateNotification(ctx context.Context, notification *models.Notification) error
	DeleteNotification(ctx context.Context, notificationID string) error

	// User notification queries
	GetUserNotifications(ctx context.Context, userID string, opts PaginationOptions) (*PaginatedResult[*models.Notification], error)
	GetUnreadNotifications(ctx context.Context, userID string, opts PaginationOptions) (*PaginatedResult[*models.Notification], error)
	GetNotificationsByType(ctx context.Context, userID, notificationType string, opts PaginationOptions) (*PaginatedResult[*models.Notification], error)

	// Notification status management
	MarkNotificationRead(ctx context.Context, notificationID string) error
	MarkNotificationUnread(ctx context.Context, notificationID string) error
	MarkAllNotificationsRead(ctx context.Context, userID string) error
	MarkNotificationsReadByType(ctx context.Context, userID, notificationType string) error

	// Push notification tracking
	MarkNotificationPushSent(ctx context.Context, notificationID string) error
	MarkNotificationPushFailed(ctx context.Context, notificationID, errorMsg string) error
	GetPendingPushNotifications(ctx context.Context, opts PaginationOptions) (*PaginatedResult[*models.Notification], error)

	// Notification grouping and consolidation
	GetNotificationGroups(ctx context.Context, userID string, opts PaginationOptions) (*PaginatedResult[*models.Notification], error)
	ConsolidateNotifications(ctx context.Context, groupKey string) error

	// Notification counts and summaries
	GetUnreadNotificationCount(ctx context.Context, userID string) (int64, error)
	GetNotificationCountsByType(ctx context.Context, userID string) (map[string]int64, error)

	// Batch operations
	CreateNotifications(ctx context.Context, notifications []*models.Notification) error
	DeleteNotificationsByType(ctx context.Context, userID, notificationType string) error
	DeleteNotificationsByObject(ctx context.Context, objectID string) error
	DeleteExpiredNotifications(ctx context.Context, expiredBefore time.Time) (int64, error)

	// Filtered and advanced queries
	GetNotificationsFiltered(ctx context.Context, username string, filter map[string]interface{}) ([]*models.Notification, string, error)
	ClearOldNotifications(ctx context.Context, username string, olderThan time.Time) (int, error)
	GetNotificationsAdvanced(ctx context.Context, userID string, filters map[string]interface{}, pagination PaginationOptions) (*PaginatedResult[*models.Notification], error)

	// Notification preferences
	GetNotificationPreferences(ctx context.Context, userID string) (*models.NotificationPreferences, error)
	UpdateNotificationPreferences(ctx context.Context, prefs *models.NotificationPreferences) error
	SetNotificationPreference(ctx context.Context, userID string, preferenceType string, enabled bool) error
}

type OAuthRepository interface {

	// StoreOAuthState stores OAuth state for CSRF protection
	StoreOAuthState(ctx context.Context, state string, data *storage.OAuthState) error

	// GetOAuthState retrieves OAuth state
	GetOAuthState(ctx context.Context, state string) (*storage.OAuthState, error)

	// DeleteOAuthState deletes OAuth state
	DeleteOAuthState(ctx context.Context, state string) error

	// CreateAuthorizationCode creates a new OAuth authorization code
	CreateAuthorizationCode(ctx context.Context, code *storage.AuthorizationCode) error

	// GetAuthorizationCode retrieves an OAuth authorization code
	GetAuthorizationCode(ctx context.Context, code string) (*storage.AuthorizationCode, error)

	// DeleteAuthorizationCode deletes an OAuth authorization code
	DeleteAuthorizationCode(ctx context.Context, code string) error

	// CreateRefreshToken creates a new OAuth refresh token
	CreateRefreshToken(ctx context.Context, token *storage.RefreshToken) error

	// GetRefreshToken retrieves an OAuth refresh token
	GetRefreshToken(ctx context.Context, token string) (*storage.RefreshToken, error)

	// DeleteRefreshToken deletes an OAuth refresh token
	DeleteRefreshToken(ctx context.Context, token string) error

	// CreateOAuthClient creates a new OAuth client
	CreateOAuthClient(ctx context.Context, client *storage.OAuthClient) error

	// GetOAuthClient retrieves an OAuth client by client ID
	GetOAuthClient(ctx context.Context, clientID string) (*storage.OAuthClient, error)

	// UpdateOAuthClient updates an existing OAuth client
	UpdateOAuthClient(ctx context.Context, clientID string, updates map[string]any) error

	// DeleteOAuthClient deletes an OAuth client
	DeleteOAuthClient(ctx context.Context, clientID string) error

	// ListOAuthClients lists OAuth clients with pagination
	ListOAuthClients(ctx context.Context, limit int32, cursor string) ([]*storage.OAuthClient, string, error)

	// DeleteExpiredTokens removes expired OAuth tokens
	DeleteExpiredTokens(ctx context.Context) error

	// SaveUserAppConsent saves user consent for an OAuth app
	SaveUserAppConsent(ctx context.Context, consent *storage.UserAppConsent) error

	// GetUserAppConsent retrieves user consent for an OAuth app
	GetUserAppConsent(ctx context.Context, userID, appID string) (*storage.UserAppConsent, error)
}

type ObjectRepository interface {

	// CreateObject stores a generic ActivityPub object
	CreateObject(ctx context.Context, object any) error

	// GetObject retrieves an object by ID
	GetObject(ctx context.Context, id string) (any, error)

	// UpdateObject updates an existing object
	UpdateObject(ctx context.Context, object any) error

	// UpdateObjectWithHistory updates an object and tracks the edit history
	UpdateObjectWithHistory(ctx context.Context, object any, updatedBy string) error

	// DeleteObject deletes an object by ID
	DeleteObject(ctx context.Context, objectID string) error

	// GetObjectsByActor retrieves objects created by a specific actor
	GetObjectsByActor(ctx context.Context, actorID string, cursor string, limit int) ([]any, string, error)

	// GetStatus retrieves a status by ID (alias for GetObject)
	GetStatus(ctx context.Context, statusID string) (any, error)

	// GetUserStatusCount counts the number of statuses by a user
	GetUserStatusCount(ctx context.Context, userID string) (int, error)

	// GetStatusReplyCount counts replies to a specific status
	GetStatusReplyCount(ctx context.Context, statusID string) (int, error)

	// CountObjectReplies counts the number of replies to an object
	CountObjectReplies(ctx context.Context, objectID string) (int, error)

	// CountReplies counts the number of replies to an object using GSI6
	CountReplies(ctx context.Context, objectID string) (int, error)

	// GetReplies retrieves replies to an object with pagination
	GetReplies(ctx context.Context, objectID string, limit int, cursor string) ([]any, string, error)

	// IncrementReplyCount increments the reply count for an object
	IncrementReplyCount(ctx context.Context, objectID string) error

	// GetReplyCount gets the reply count for a status
	GetReplyCount(ctx context.Context, statusID string) (int64, error)

	// TombstoneObject marks an object as deleted by creating a tombstone
	TombstoneObject(ctx context.Context, objectID string, deletedBy string) error

	// CreateTombstone creates a tombstone for a deleted object
	CreateTombstone(ctx context.Context, tombstone *models.Tombstone) error

	// GetTombstone retrieves a tombstone by object ID
	GetTombstone(ctx context.Context, objectID string) (*models.Tombstone, error)

	// IsTombstoned checks if an object has been tombstoned (deleted)
	IsTombstoned(ctx context.Context, objectID string) (bool, error)

	// GetTombstonesByActor retrieves all tombstones created by a specific actor
	GetTombstonesByActor(ctx context.Context, actorID string, limit int, cursor string) ([]*models.Tombstone, string, error)

	// GetTombstonesByType retrieves tombstones by their former type
	GetTombstonesByType(ctx context.Context, formerType string, limit int, cursor string) ([]*models.Tombstone, string, error)

	// CleanupExpiredTombstones removes tombstones that have exceeded their TTL
	CleanupExpiredTombstones(ctx context.Context, batchSize int) (int, error)

	// ReplaceObjectWithTombstone atomically replaces an object with a tombstone
	ReplaceObjectWithTombstone(ctx context.Context, objectID, formerType, deletedBy string) error

	// CreateUpdateHistory creates a new update history entry for an object
	CreateUpdateHistory(ctx context.Context, history *storage.UpdateHistory) error

	// GetUpdateHistory retrieves update history for an object
	GetUpdateHistory(ctx context.Context, objectID string, limit int) ([]*storage.UpdateHistory, error)

	// GetObjectHistory retrieves the version history of an object
	GetObjectHistory(ctx context.Context, objectID string) ([]*storage.UpdateHistory, error)

	// AddToCollection adds an item to a collection
	AddToCollection(ctx context.Context, collection string, item *storage.CollectionItem) error

	// RemoveFromCollection removes an item from a collection
	RemoveFromCollection(ctx context.Context, collection, itemID string) error

	// GetCollectionItems retrieves items from a collection with pagination
	GetCollectionItems(ctx context.Context, collection string, limit int, cursor string) ([]*storage.CollectionItem, string, error)

	// IsInCollection checks if an item is in a collection
	IsInCollection(ctx context.Context, collection, itemID string) (bool, error)

	// CountCollectionItems returns the count of items in a collection
	CountCollectionItems(ctx context.Context, collection string) (int, error)

	// CountQuotes counts the number of quotes for a specific note
	CountQuotes(ctx context.Context, noteID string) (int, error)

	// CountWithdrawnQuotes counts the number of withdrawn quotes for a specific note
	CountWithdrawnQuotes(ctx context.Context, noteID string) (int, error)

	// CreateQuoteRelationship creates a new quote relationship between notes
	CreateQuoteRelationship(ctx context.Context, quote *storage.QuoteRelationship) error

	// GetQuotesForNote retrieves quotes for a specific note with pagination
	GetQuotesForNote(ctx context.Context, noteID string, limit int, cursor string) ([]*storage.QuoteRelationship, string, error)

	// IsQuoted checks if a note is quoted by a specific actor
	IsQuoted(ctx context.Context, actorID, noteID string) (bool, error)

	// WithdrawQuote withdraws a quote by marking it as withdrawn
	WithdrawQuote(ctx context.Context, quoteNoteID string) error

	// WithdrawStatusFromQuotes withdraws a status from being quoted with proper cascade effects
	WithdrawStatusFromQuotes(ctx context.Context, statusID string) error

	// UpdateQuotePermissions updates the quote permissions for a status
	UpdateQuotePermissions(ctx context.Context, statusID string, permissions *storage.QuotePermissions) error

	// IsQuoteAllowed checks if a quote is allowed for a status by a quoter
	IsQuoteAllowed(ctx context.Context, statusID, quoterID string) (bool, error)

	// GetQuoteType returns the quote type for a status
	GetQuoteType(ctx context.Context, statusID string) (string, error)

	// IsWithdrawnFromQuotes checks if a status is withdrawn from quotes
	IsWithdrawnFromQuotes(ctx context.Context, statusID string) (bool, error)

	// GetQuotesOfStatus retrieves quotes of a specific status
	GetQuotesOfStatus(ctx context.Context, statusID string, limit int) ([]*storage.StatusSearchResult, error)

	// GetMissingReplies returns a list of known missing replies in a thread
	GetMissingReplies(ctx context.Context, statusID string) ([]*storage.StatusSearchResult, error)

	// MarkThreadAsSynced marks a thread as successfully synced
	MarkThreadAsSynced(ctx context.Context, statusID string) error

	// SyncThreadFromRemote syncs a thread from a remote server
	SyncThreadFromRemote(ctx context.Context, statusID string) (*storage.StatusSearchResult, error)

	// SyncMissingRepliesFromRemote syncs missing replies from remote servers
	SyncMissingRepliesFromRemote(ctx context.Context, statusID string) ([]*storage.StatusSearchResult, error)

	// GetThreadContext retrieves the thread context for a status with full hierarchy
	GetThreadContext(ctx context.Context, statusID string) (*storage.ThreadContext, error)
}

type OperationCostStats struct {
	OperationType           string
	Count                   int64
	TotalCostMicroCents     int64
	TotalCostDollars        float64
	AverageCostMicroCents   int64
	TotalReadCapacityUnits  float64
	TotalWriteCapacityUnits float64
}

type PaginatedResult[T any] struct {
	Items      []T    // The actual data items
	NextCursor string // Cursor for the next page (empty if no more pages)
	HasMore    bool   // Whether there are more pages available
	Total      int64  // Total count (if available, -1 if not calculated)
}

type PaginationOptions struct {
	Limit  int    // Maximum number of items to return
	Cursor string // Pagination cursor/token for the next page
	Since  *time.Time
	Until  *time.Time
}

type PaginationResult struct {
	HasNextPage bool
	NextCursor  string
	TotalCount  int
}

type PollRepository interface {
	// Core poll operations
	CreatePoll(ctx context.Context, poll *storage.Poll) error
	GetPoll(ctx context.Context, pollID string) (*storage.Poll, error)
	GetPollByStatusID(ctx context.Context, statusID string) (*storage.Poll, error)

	// Voting operations
	VoteOnPoll(ctx context.Context, pollID string, voterID string, choices []int) error
	GetPollVotes(ctx context.Context, pollID string) (map[string][]int, error)
	HasUserVoted(ctx context.Context, pollID string, userID string) (bool, []int, error)
}

type ProcessingResult struct {
	Width    int                 `json:"width"`
	Height   int                 `json:"height"`
	Duration int                 `json:"duration"` // Duration in milliseconds
	FileSize int                 `json:"file_size"`
	Blurhash string              `json:"blurhash"`
	Sizes    map[string]SizeInfo `json:"sizes"`
}

type PublicationMemberRepository interface {

	// CreateMember adds a new member to a publication
	CreateMember(ctx context.Context, member *models.PublicationMember) error

	// GetMember retrieves a member by publication ID and user ID
	GetMember(ctx context.Context, publicationID, userID string) (*models.PublicationMember, error)

	// Update updates an existing publication member
	Update(ctx context.Context, member *models.PublicationMember) error

	// DeleteMember removes a member from a publication
	DeleteMember(ctx context.Context, publicationID, userID string) error

	// ListMembers lists all members of a publication
	ListMembers(ctx context.Context, publicationID string) ([]*models.PublicationMember, error)

	// ListMembershipsForUserPaginated lists publications a user is a member of with pagination
	ListMembershipsForUserPaginated(ctx context.Context, userID string, limit int, cursor string) ([]*models.PublicationMember, string, error)
}

type PublicationRepository interface {

	// GetDB returns the underlying DynamoDB connection for advanced operations
	GetDB() dynamormcore.DB

	// CreatePublication creates a new publication
	CreatePublication(ctx context.Context, publication *models.Publication) error

	// GetPublication retrieves a publication by ID
	GetPublication(ctx context.Context, id string) (*models.Publication, error)

	// Update updates an existing publication
	Update(ctx context.Context, publication *models.Publication) error

	// Delete deletes a publication by PK and SK
	Delete(ctx context.Context, pk, sk string) error
}

type PushSubscriptionRepository interface {
	// Push subscription operations
	CreatePushSubscription(ctx context.Context, username string, subscription *storage.PushSubscription) error
	GetPushSubscription(ctx context.Context, username, subscriptionID string) (*storage.PushSubscription, error)
	GetUserPushSubscriptions(ctx context.Context, username string) ([]*storage.PushSubscription, error)
	UpdatePushSubscription(ctx context.Context, username, subscriptionID string, alerts storage.PushSubscriptionAlerts) error
	DeletePushSubscription(ctx context.Context, username, subscriptionID string) error
	DeleteAllPushSubscriptions(ctx context.Context, username string) error

	// VAPID key management
	GetVAPIDKeys(ctx context.Context) (*storage.VAPIDKeys, error)
	SetVAPIDKeys(ctx context.Context, keys *storage.VAPIDKeys) error
}

type QuoteRepository interface {
	// Core quote operations
	CreateQuoteRelationship(ctx context.Context, relationship *models.QuoteRelationship) error
	GetQuoteRelationship(ctx context.Context, quoteStatusID, targetStatusID string) (*models.QuoteRelationship, error)
	UpdateQuoteRelationship(ctx context.Context, relationship *models.QuoteRelationship) error
	DeleteQuoteRelationship(ctx context.Context, quoteStatusID, targetStatusID string) error

	// Quote discovery
	GetQuotesForStatus(ctx context.Context, statusID string, opts PaginationOptions) (*PaginatedResult[*models.QuoteRelationship], error)
	GetQuotesByUser(ctx context.Context, userID string, opts PaginationOptions) (*PaginatedResult[*models.QuoteRelationship], error)

	// Quote permissions
	CreateQuotePermissions(ctx context.Context, permissions *models.QuotePermissions) error
	GetQuotePermissions(ctx context.Context, username string) (*models.QuotePermissions, error)
	UpdateQuotePermissions(ctx context.Context, permissions *models.QuotePermissions) error
	DeleteQuotePermissions(ctx context.Context, username string) error

	// Quote counts and statistics
	GetQuoteCount(ctx context.Context, statusID string) (int64, error)
	IncrementQuoteCount(ctx context.Context, statusID string) error
	DecrementQuoteCount(ctx context.Context, statusID string) error

	// Quote withdrawal operations
	WithdrawQuotes(ctx context.Context, noteID, userID string) (int, error)
}

type RateLimitRepository interface {

	// RecordLoginAttempt records a login attempt for rate limiting
	RecordLoginAttempt(ctx context.Context, identifier string, success bool) error

	// GetLoginAttemptCount returns the number of login attempts since the given time
	GetLoginAttemptCount(ctx context.Context, identifier string, since time.Time) (int, error)

	// IsRateLimited checks if an identifier is currently rate limited
	IsRateLimited(ctx context.Context, identifier string) (bool, time.Time, error)

	// ClearLoginAttempts clears all login attempts for an identifier
	ClearLoginAttempts(ctx context.Context, identifier string) error

	// CheckAPIRateLimit checks and updates API rate limiting for a user/endpoint combination
	CheckAPIRateLimit(ctx context.Context, userID, endpoint string, limit int, window time.Duration) error

	// GetAPIRateLimitInfo returns current rate limit info for response headers
	GetAPIRateLimitInfo(ctx context.Context, userID, endpoint string, limit int, window time.Duration) (remaining int, resetTime time.Time, err error)

	// CheckFederationRateLimit checks and updates federation rate limiting for a domain/endpoint combination
	CheckFederationRateLimit(ctx context.Context, domain, endpoint string, limit int, window time.Duration) error

	// GetFederationRateLimitInfo returns current federation rate limit info
	GetFederationRateLimitInfo(ctx context.Context, domain, endpoint string, limit int, window time.Duration) (remaining int, resetTime time.Time, err error)

	// GetViolationCount returns the number of violations in a time period for escalating penalties
	GetViolationCount(ctx context.Context, userID, domain string, since time.Duration) (int, error)

	// IsUserBlocked checks if a user is currently blocked due to rate limiting
	IsUserBlocked(ctx context.Context, userID string) (bool, time.Time, error)

	// IsDomainBlocked checks if a federation domain is currently blocked
	IsDomainBlocked(ctx context.Context, domain string) (bool, time.Time, error)

	// CheckCommunityNoteRateLimit checks if a user can create more community notes today
	CheckCommunityNoteRateLimit(ctx context.Context, userID string, limit int) (bool, int, error)
}

type RecoveryRepository interface {

	// StoreTrustee stores a trustee configuration for social recovery
	StoreTrustee(ctx context.Context, username string, trustee *storage.TrusteeConfig) error

	// GetTrustees retrieves all trustees for a user
	GetTrustees(ctx context.Context, username string) ([]*storage.TrusteeConfig, error)

	// DeleteTrustee removes a trustee
	DeleteTrustee(ctx context.Context, username, trusteeActorID string) error

	// UpdateTrusteeConfirmed updates the confirmed status of a trustee
	UpdateTrusteeConfirmed(ctx context.Context, username, trusteeActorID string, confirmed bool) error

	// StoreRecoveryRequest stores a social recovery request
	StoreRecoveryRequest(ctx context.Context, request *storage.SocialRecoveryRequest) error

	// GetRecoveryRequest retrieves a recovery request by ID
	GetRecoveryRequest(ctx context.Context, requestID string) (*storage.SocialRecoveryRequest, error)

	// UpdateRecoveryRequest updates a recovery request
	UpdateRecoveryRequest(ctx context.Context, request *storage.SocialRecoveryRequest) error

	// DeleteRecoveryRequest deletes a recovery request
	DeleteRecoveryRequest(ctx context.Context, requestID string) error

	// GetActiveRecoveryRequests gets all active recovery requests for a user
	GetActiveRecoveryRequests(ctx context.Context, username string) ([]*storage.SocialRecoveryRequest, error)

	// StoreRecoveryCode stores a recovery code
	StoreRecoveryCode(ctx context.Context, username string, code *storage.RecoveryCodeItem) error

	// GetRecoveryCodes retrieves all recovery codes for a user
	GetRecoveryCodes(ctx context.Context, username string) ([]*storage.RecoveryCodeItem, error)

	// MarkRecoveryCodeUsed marks a recovery code as used
	MarkRecoveryCodeUsed(ctx context.Context, username, codeHash string) error

	// DeleteAllRecoveryCodes deletes all recovery codes for a user
	DeleteAllRecoveryCodes(ctx context.Context, username string) error

	// CountUnusedRecoveryCodes counts how many unused recovery codes the user has
	CountUnusedRecoveryCodes(ctx context.Context, username string) (int, error)

	// StoreRecoveryToken stores a generic recovery token with data
	StoreRecoveryToken(ctx context.Context, key string, data map[string]any) error

	// GetRecoveryToken retrieves a recovery token by key
	GetRecoveryToken(ctx context.Context, key string) (map[string]any, error)

	// DeleteRecoveryToken deletes a recovery token
	DeleteRecoveryToken(ctx context.Context, key string) error
}

type RelationshipRepository interface {
	// Core relationship operations
	CreateFollowRequest(ctx context.Context, followerID, followingID string) error
	AcceptFollowRequest(ctx context.Context, followerID, followingID string) error
	RejectFollowRequest(ctx context.Context, followerID, followingID string) error
	Unfollow(ctx context.Context, followerID, followingID string) error

	// Relationship queries
	IsFollowing(ctx context.Context, followerID, followingID string) (bool, error)
	GetFollowStatus(ctx context.Context, followerID, followingID string) (string, error) // pending, accepted, rejected, none
	GetFollowRelationship(ctx context.Context, followerID, followingID string) (*models.RelationshipRecord, error)

	// Follower/Following lists
	GetFollowers(ctx context.Context, userID string, opts PaginationOptions) (*PaginatedResult[*storage.Account], error)
	GetFollowing(ctx context.Context, userID string, opts PaginationOptions) (*PaginatedResult[*storage.Account], error)
	GetFollowRequests(ctx context.Context, userID string, opts PaginationOptions) (*PaginatedResult[*storage.Account], error)
	GetPendingFollowRequests(ctx context.Context, userID string, opts PaginationOptions) (*PaginatedResult[*storage.Account], error)

	// Mutual relationships
	GetMutualFollows(ctx context.Context, userID, otherUserID string, opts PaginationOptions) (*PaginatedResult[*storage.Account], error)

	// Blocking operations
	BlockUser(ctx context.Context, blockerID, blockedID string) error
	UnblockUser(ctx context.Context, blockerID, blockedID string) error
	IsBlocked(ctx context.Context, blockerID, blockedID string) (bool, error)
	GetBlockedUsers(ctx context.Context, userID string, opts PaginationOptions) (*PaginatedResult[*storage.Account], error)

	// Muting operations
	MuteUser(ctx context.Context, muterID, mutedID string) error
	UnmuteUser(ctx context.Context, muterID, mutedID string) error
	IsMuted(ctx context.Context, muterID, mutedID string) (bool, error)
	GetMutedUsers(ctx context.Context, userID string, opts PaginationOptions) (*PaginatedResult[*storage.Account], error)

	// Relationship counts
	GetFollowerCount(ctx context.Context, userID string) (int64, error)
	GetFollowingCount(ctx context.Context, userID string) (int64, error)
	GetMutualFollowCount(ctx context.Context, userID, otherUserID string) (int64, error)

	// Batch operations
	GetRelationships(ctx context.Context, requestingUserID string, targetUserIDs []string) (map[string]*models.RelationshipRecord, error)
}

type RelayRepository interface {

	// StoreRelayInfo stores relay information
	StoreRelayInfo(ctx context.Context, relay *storage.RelayInfo) error

	// GetRelayInfo retrieves relay information
	GetRelayInfo(ctx context.Context, relayURL string) (*storage.RelayInfo, error)

	// RemoveRelayInfo removes relay information
	RemoveRelayInfo(ctx context.Context, relayURL string) error

	// GetActiveRelays retrieves all active relays
	GetActiveRelays(ctx context.Context) ([]*storage.RelayInfo, error)

	// GetAllRelays retrieves all relays with pagination
	GetAllRelays(ctx context.Context, limit int, cursor string) ([]*storage.RelayInfo, string, error)

	// ListRelays retrieves all relays (alias for GetAllRelays without pagination)
	ListRelays(ctx context.Context) ([]*storage.RelayInfo, error)

	// UpdateRelayStatus updates the active status of a relay
	UpdateRelayStatus(ctx context.Context, relayURL string, active bool) error

	// UpdateRelayState updates multiple relay fields beyond just active status
	UpdateRelayState(ctx context.Context, relayURL string, state storage.RelayState) error

	// CreateRelay creates a new relay
	CreateRelay(ctx context.Context, relay *storage.RelayInfo) error

	// GetRelay retrieves a relay by URL (alias for GetRelayInfo)
	GetRelay(ctx context.Context, relayURL string) (*storage.RelayInfo, error)

	// DeleteRelay removes a relay (alias for RemoveRelayInfo)
	DeleteRelay(ctx context.Context, relayURL string) error
}

type RepositoryAccess interface {
	// Repository access methods - return interface{} to allow flexibility with actual repository types
	Account() interface{}
	Actor() interface{}
	Object() interface{}
	Activity() interface{}
	Timeline() interface{}
	Notification() interface{}
	Like() interface{}
	Moderation() interface{}
	List() interface{}
	Media() interface{}
	MediaMetadata() interface{}
	Poll() interface{}
	PushSubscription() interface{}
	Hashtag() interface{}
	ScheduledStatus() interface{}
	Announcement() interface{}
	DomainBlock() interface{}
	Relationship() interface{}
	Instance() interface{}
	Federation() interface{}
	Recovery() interface{}
	Analytics() interface{} // Analytics/Trending repository
	Social() interface{}
	User() interface{}
	Status() interface{}
	Cost() interface{}
	WebSocketCost() interface{}
	Trust() interface{}
	Search() interface{}
	Relay() interface{}
	CommunityNote() interface{}
	Emoji() interface{}
	RateLimit() interface{}
	Conversation() interface{}
	Marker() interface{}
	FeaturedTag() interface{}
	AI() interface{}
	Export() interface{}
	Import() interface{}
	DLQ() interface{}
	MetricRecord() interface{}
	CloudWatchMetrics() interface{}
	StreamingCloudWatch() interface{}
	Audit() interface{}
	OAuth() interface{}
	DNSCache() interface{}
	Filter() interface{}

	// Utility methods
	GetDB() interface{}
	GetTableName() string
	GetLogger() interface{}
}

type RepositoryRegistry interface {
	Status() StatusRepository
	Account() AccountRepository
	Relationship() RelationshipRepository
	Media() MediaRepository
	Conversation() ConversationRepository
	List() ListRepository
	Filter() FilterRepository
	Notification() NotificationRepository
	Like() LikeRepository
	Social() SocialRepository
	Quote() QuoteRepository
}

type RevisionRepository interface {

	// CreateRevision creates a new revision
	CreateRevision(ctx context.Context, revision *models.Revision) error

	// GetRevision retrieves a revision by object ID and version
	GetRevision(ctx context.Context, objectID string, version int) (*models.Revision, error)

	// Delete deletes a revision by PK and SK
	Delete(ctx context.Context, pk, sk string) error

	// ListRevisions lists revisions for an object
	ListRevisions(ctx context.Context, objectID string, limit int) ([]*models.Revision, error)

	// ListRevisionsPaginated lists revisions for an object with cursor pagination
	ListRevisionsPaginated(ctx context.Context, objectID string, limit int, cursor string) ([]*models.Revision, string, error)
}

type ScheduledStatusRepository interface {
	// CreateScheduledStatus creates a new scheduled status
	CreateScheduledStatus(ctx context.Context, scheduled *storage.ScheduledStatus) error

	// GetScheduledStatus retrieves a scheduled status by ID
	GetScheduledStatus(ctx context.Context, id string) (*storage.ScheduledStatus, error)

	// GetScheduledStatuses retrieves scheduled statuses for a user
	GetScheduledStatuses(ctx context.Context, username string, limit int, cursor string) ([]*storage.ScheduledStatus, string, error)

	// UpdateScheduledStatus updates a scheduled status
	UpdateScheduledStatus(ctx context.Context, scheduled *storage.ScheduledStatus) error

	// DeleteScheduledStatus deletes a scheduled status
	DeleteScheduledStatus(ctx context.Context, id string) error

	// GetDueScheduledStatuses retrieves scheduled statuses that are due to be published
	GetDueScheduledStatuses(ctx context.Context, before time.Time, limit int) ([]*storage.ScheduledStatus, error)

	// MarkScheduledStatusPublished marks a scheduled status as published
	MarkScheduledStatusPublished(ctx context.Context, id string) error

	// GetScheduledStatusMedia gets media for scheduled status
	GetScheduledStatusMedia(ctx context.Context, id string) ([]*models.Media, error)

	// SetMediaRepository sets the media repository dependency
	SetMediaRepository(mediaRepo MediaRepositoryInterface)
}

type SearchRepository interface {

	// SearchAccounts searches for accounts matching the given query
	SearchAccounts(ctx context.Context, query string, limit int, followingOnly bool, offset int) ([]*activitypub.Actor, error)

	// SearchAccountsWithPrivacy searches for accounts with privacy enforcement
	SearchAccountsWithPrivacy(ctx context.Context, query string, limit int, followingOnly bool, offset int, searcherActorID string) ([]*activitypub.Actor, error)

	// SearchAccountsAdvanced searches for accounts with advanced filtering
	SearchAccountsAdvanced(ctx context.Context, query string, resolve bool, limit int, offset int, following bool, accountID string) ([]*activitypub.Actor, error)

	// SearchStatuses searches for statuses matching the given query
	SearchStatuses(ctx context.Context, query string, limit int) ([]*storage.StatusSearchResult, error)

	// SearchStatusesWithOptions searches for statuses with advanced options
	SearchStatusesWithOptions(ctx context.Context, query string, options storage.StatusSearchOptions) ([]*storage.StatusSearchResult, error)

	// SearchStatusesWithOptionsPaginated searches for statuses with advanced options and pagination support
	SearchStatusesWithOptionsPaginated(ctx context.Context, query string, options storage.StatusSearchOptions) ([]*storage.StatusSearchResult, *PaginationResult, error)

	// SearchStatusesWithPrivacy searches for statuses with privacy enforcement
	SearchStatusesWithPrivacy(ctx context.Context, query string, options storage.StatusSearchOptions, searcherActorID string) ([]*storage.StatusSearchResult, error)

	// SearchStatusesWithPrivacyPaginated searches for statuses with privacy enforcement and pagination
	SearchStatusesWithPrivacyPaginated(ctx context.Context, query string, options storage.StatusSearchOptions, searcherActorID string) ([]*storage.StatusSearchResult, *PaginationResult, error)

	// SearchStatusesAdvanced searches for statuses with advanced filtering
	SearchStatusesAdvanced(ctx context.Context, query string, limit int, maxID, minID *string, accountID string) ([]*storage.StatusSearchResult, error)

	// SetDependencies sets the dependencies for cross-repository operations
	SetDependencies(deps SearchRepositoryDeps)
}

type SearchRepositoryDeps interface {
	GetFollowing(ctx context.Context, username string, limit int, cursor string) ([]string, string, error)
	IsBlocked(ctx context.Context, blockerActor, blockedActor string) (bool, error)
	IsBlockedBidirectional(ctx context.Context, actor1, actor2 string) (bool, error)
	GetFollowers(ctx context.Context, username string, limit int, cursor string) ([]string, string, error)
}