app

type AddCommentCommand struct {
	UserID          uuid.UUID
	ChapterID       int64
	ParentCommentID Nullable[int64]
	Content         string
}

type AddCommentResult struct {
	Comment CommentDto
}

type AddToCollectionsCommand struct {
	ActorUserID  uuid.UUID
	CollectionID []int64
	BookID       int64
}

type AgeRating string

type AuthService interface {
	SignIn(ctx context.Context, input SignInCommand) (SignInResult, error)
	CreateSessionForUser(ctx context.Context, userID uuid.UUID, userAgent, ip string) (string, error)
	SignOut(ctx context.Context, sessionID string) error
	EnsureAdminUserExists(ctx context.Context) error
}

type BanUserCommand struct {
	ActorUserID, UserID uuid.UUID
	Until               time.Time
	Reason              string
}

type BookActionType string

type BookAdultWarning struct {
	IsBookAdult bool
	HasAdultTag bool
}

type BookBackgroundService interface {
	BookRecalculationIngest
	Start() error
	Stop()
}

type BookCollectionDto struct {
	ID       int64  `json:"id,string"`
	Name     string `json:"name"`
	Position int    `json:"pos"`
	Size     int    `json:"size"`
}

type BookCover struct {
	URL string `json:"url"`
}

type BookDetailsAuthorDto struct {
	ID   uuid.UUID `json:"id"`
	Name string    `json:"name"`
}

type BookDetailsDto struct {
	ID                  int64                 `json:"id,string"`
	Name                string                `json:"name"`
	AgeRating           AgeRating             `json:"ageRating"`
	IsAdult             bool                  `json:"adult"`
	Tags                []DefinedTagDto       `json:"tags"`
	Words               int                   `json:"words"`
	WordsPerChapter     int                   `json:"wordsPerChapter"`
	CreatedAt           time.Time             `json:"createdAt"`
	Collections         []BookCollectionDto   `json:"collections"`
	Author              BookDetailsAuthorDto  `json:"author"`
	Permissions         BookUserPermissions   `json:"permissions"`
	Summary             string                `json:"summary"`
	Notifications       []GenericNotification `json:"notifications,omitempty"`
	Cover               BookCover             `json:"cover"`
	Rating              Nullable[float64]     `json:"rating"`
	Votes               int32                 `json:"votes"`
	Reviews             int32                 `json:"reviews"`
	IsPubliclyAvailable bool                  `json:"isPubliclyAvailable"`
	Slug                string                `json:"slug"`
	FirstChapterID      Nullable[int64]       `json:"firstChapterId"`
}

type BookExtremes struct {
	Words           Int32Range `json:"words"`
	Chapters        Int32Range `json:"chapters"`
	WordsPerChapter Int32Range `json:"wordsPerChapter"`
	Favorites       Int32Range `json:"favorites"`
}

type BookLibraryDto struct {
	ID          int64                                       `json:"id,string"`
	Name        string                                      `json:"name"`
	Cover       BookCover                                   `json:"cover"`
	AgeRating   AgeRating                                   `json:"ageRating"`
	LastChapter Nullable[BookReadingListItemLastChapterDto] `json:"lastChapter"`
}

type BookListDto struct {
	ID              int64                `json:"id,string"`
	Slug            string               `json:"slug"`
	Name            string               `json:"name"`
	Author          BookDetailsAuthorDto `json:"-"`
	CreatedAt       time.Time            `json:"createdAt"`
	AgeRating       AgeRating            `json:"ageRating"`
	Words           int                  `json:"words"`
	WordsPerChapter int                  `json:"wordsPerChapter"`
	Chapters        int                  `json:"chapters"`
	Cover           BookCover            `json:"cover"`
	IsPinned        bool                 `json:"isPinned"`
}

type BookLogResult struct {
	Entries         []BookModerationLog
	Page            int32
	PageSize        int32
	HasNextPage     bool
	HasPreviousPage bool
	TotalPages      uint32
}

type BookManagerService interface {
	GetUserBooks(ctx context.Context, input ManagerGetUserBooksQuery) (ManagerGetUserBooksQuery_Result, error)
	GetBook(ctx context.Context, query ManagerGetBookQuery) (ManagerGetBookQuery_Result, error)
	CreateBook(ctx context.Context, input CreateBookCommand) (int64, error)
	UpdateBook(ctx context.Context, input UpdateBookCommand) error
	UploadBookCover(ctx context.Context, input UploadBookCoverCommand) (UploadBookCoverCommand_Result, error)
	TrashBook(ctx context.Context, input TrashBookCommand) error
	UntrashBook(ctx context.Context, input UntrashBookCommand) error

	UpdateBookChaptersOrder(ctx context.Context, input UpdateBookChapterOrdersCommand) (UpdateBookChapterOrdersCommand_Result, error)
	CreateBookChapter(ctx context.Context, input CreateBookChapterCommand) (CreateBookChapterCommand_Result, error)
	ReorderChapters(ctx context.Context, input ReorderChaptersCommand) error
	GetBookChapters(ctx context.Context, query ManagerGetBookChaptersQuery) (ManagerGetBookChaptersQuery_Result, error)
	GetChapter(ctx context.Context, query ManagerGetChapterQuery) (ManagerGetChapterQuery_Result, error)
	UpdateBookChapter(ctx context.Context, cmd UpdateBookChapterCommand) error

	GetDraft(ctx context.Context, query GetDraftQuery) (DraftDto, error)
	UpdateDraft(ctx context.Context, cmd UpdateDraftCommand) error
	UpdateDraftChapterName(ctx context.Context, cmd UpdateDraftChapterNameCommand) error
	UpdateDraftContent(ctx context.Context, cmd UpdateDraftContentCommand) error
	DeleteDraft(ctx context.Context, cmd DeleteDraftCommand) error
	PublishDraft(ctx context.Context, cmd PublishDraftCommand) error
	ScheduleDraft(ctx context.Context, cmd ScheduleDraftCommand) error
	CreateDraft(ctx context.Context, cmd CreateDraftCommand) (int64, error)
	GetLatestDraft(ctx context.Context, cmd GetLatestDraftQuery) (Nullable[int64], error)
}

type BookManagerServiceDeps struct {
	fx.In

	DB                 DB
	TagsService        TagsService
	UsersService       UserService
	UploadService      *UploadService
	BookReindexService BookReindexService
	MetricService      analytics.MetricService
	Log                *zap.SugaredLogger
	Markup             *content.MarkupEngine
	FontPolicy         bookfont.Policy
}

type BookModerationChapter struct {
	ID                                   int64
	Name                                 string
	CreatedAt                            time.Time
	UpdatedAt                            *time.Time
	Words                                int32
	IsPubliclyVisible, HasPendingReports bool
}

type BookModerationInfo struct {
	ID                  int64
	Name                string
	Summary             string
	IsBanned            bool
	IsShadowBanned      bool
	IsPermDeleted       bool
	AuthorUserID        uuid.UUID
	AuthorUserName      string
	CreatedAt           time.Time
	AgeRating           string
	IsPubliclyVisible   bool
	Words               int32
	Chapters            int32
	ReportsCount        int64
	LatestPendingReport *BookPendingReport
	BanReason           string
}

type BookModerationLog struct {
	Time          time.Time
	Action        BookActionType
	Payload       json.RawMessage
	Reason        string
	ActorUserID   uuid.UUID
	ActorUserName string
}

type BookPendingReport struct {
	ID             int64
	Number, Reason string
	Time           time.Time
}

type BookReadingListDto struct {
	Status        ReadingListStatus     `json:"status"`
	ChapterID     Nullable[Int64String] `json:"chapterId"`
	ChapterName   string                `json:"chapterName"`
	ChapterOrder  int32                 `json:"chapterOrder"`
	LastUpdatedAt time.Time             `json:"lastUpdatedAt"`
}

type BookReadingListItemLastChapterDto struct {
	ID    int64  `json:"id,string"`
	Name  string `json:"name"`
	Order int32  `json:"order"`
}

type BookRecalculationIngest interface {
	ScheduleBookRecalculation(bookID int64)
}

type BookReindexService interface {
	Reindex(ctx context.Context, id int64) error
	ScheduleReindex(ctx context.Context, id int64)
	ScheduleReindexAll() error
}

type BookReviewsDistribution [10]int32

type BookSearchItem struct {
	ID              int64                `json:"id,string"`
	Name            string               `json:"name"`
	Slug            string               `json:"slug"`
	CreatedAt       time.Time            `json:"createdAt"`
	AgeRating       AgeRating            `json:"ageRating"`
	Words           int                  `json:"words"`
	WordsPerChapter int                  `json:"wordsPerChapter"`
	Chapters        int                  `json:"chapters"`
	Summary         string               `json:"summary"`
	Author          BookDetailsAuthorDto `json:"author"`
	Cover           BookCover            `json:"cover"`
	Tags            []Int64String        `json:"tags"`
	Collections     []BookCollectionDto  `json:"collections"`
}

type BookSearchQuery struct {
	UserID uuid.NullUUID

	Query string
	Sort  BookSearchSort

	Words           Int32Range
	Chapters        Int32Range
	WordsPerChapter Int32Range

	IncludeTags  []int64
	ExcludeTags  []int64
	IncludeUsers []uuid.UUID
	ExcludeUsers []uuid.UUID

	IncludeBanned bool
	IncludeHidden bool
	IncludeEmpty  bool

	Page     uint32
	PageSize uint
}

type BookSearchResult struct {
	TookUSTotal int64
	TookUS      int64
	Meta        BookSearchResultMeta
	Books       []BookSearchItem
	PageSize    uint32
	Page        uint32
	TotalPages  uint32
	Total       int64
	Tags        []DefinedTagDto
}

type BookSearchResultMeta struct {
	CacheKey    string `json:"cacheKey"`
	CacheHit    bool   `json:"cacheHit"`
	CacheTookUS int64  `json:"cacheTook"`
}

type BookSearchSort string

type BookService interface {
	GetBookDetails(ctx context.Context, query GetBookQuery) (BookDetailsDto, error)
	GetBookChapters(ctx context.Context, query GetBookChaptersQuery) ([]ChapterListDto, error)
	GetBookChapter(ctx context.Context, query GetBookChapterQuery) (GetBookChapterResult, error)
	GetRandomBookID(ctx context.Context) (Nullable[int64], error)
	GetPinnedBooks(ctx context.Context, input GetPinnedUserBooksQuery) (GetPinnedUserBooksResult, error)
	GetBooksById(ctx context.Context, ids []int64) ([]BookListDto, error)
}

type BookTags struct {
	ParentTagIds []int64
	TagIds       []int64
}

type BookUserPermissions struct {
	CanEdit bool `json:"canEdit"`
}

type CaptchaSettings struct {
	GoogleRecaptchaKey string
	Type               string
}

type CensorMode store.CensorMode

type ChapterDto struct {
	ID            int64                        `json:"id,string"`
	Name          string                       `json:"name"`
	Words         int32                        `json:"words"`
	Content       string                       `json:"content"`
	CreatedAt     time.Time                    `json:"createdAt"`
	Order         int32                        `json:"order"`
	Summary       string                       `json:"summary"`
	NextChapter   Nullable[ChapterNextPrevDto] `json:"nextChapter"`
	PrevChapter   Nullable[ChapterNextPrevDto] `json:"prevChapter"`
	BookID        int64                        `json:"bookId"`
	CommentsCount int64                        `json:"commentsCount"`
	Fonts         []string                     `json:"fonts"`
}

type ChapterListDto struct {
	ID        int64     `json:"id,string"`
	Order     int       `json:"order"`
	Name      string    `json:"name"`
	Words     int       `json:"words"`
	CreatedAt time.Time `json:"createdAt"`
	Summary   string    `json:"summary"`
}

type ChapterNextPrevDto struct {
	ID    int64  `json:"id,string"`
	Name  string `json:"name"`
	Order int32  `json:"order"`
}

type ChapterOrderModification struct {
	ChapterID        int64
	NewPositionIndex int
}

type CollectionBook2Dto struct {
	ID         int64
	Name       string
	Slug       string
	Summary    string
	AuthorName string
	AuthorID   uuid.UUID
	Cover      BookCover
	Tags       []DefinedTagDto
}

type CollectionBookDto struct {
	ID    int64
	Name  string
	Cover BookCover
}

type CollectionDto struct {
	ID            int64
	Name          string
	Slug          string
	BooksCount    int
	LastUpdatedAt Nullable[time.Time]
	UserID        uuid.UUID
	UserName      string
	IsPublic      bool
	Summary       string
}

type CollectionService interface {
	GetUserCollections(ctx context.Context, query GetUserCollectionsQuery) (GetUserCollectionsResult, error)
	GetRecentUserCollections(ctx context.Context, query GetRecentCollectionsQuery) ([]CollectionDto, error)
	CreateCollection(ctx context.Context, cmd CreateCollectionCommand) (int64, error)
	UpdateCollection(ctx context.Context, cmd UpdateCollectionCommand) error
	AddToCollections(ctx context.Context, cmd AddToCollectionsCommand) error
	RemoveFromCollection(ctx context.Context, cmd RemoveFromCollectionCommand) error
	GetBookCollections(ctx context.Context, query GetBookCollectionsQuery) ([]CollectionDto, error)

	GetCollectionBooks(ctx context.Context, query GetCollectionBooksQuery) (GetCollectionBooksResult, error)
	GetCollectionBooksMap(ctx context.Context, collections []CollectionDto) (map[int64][]CollectionBookDto, error)
	GetCollection(ctx context.Context, id int64) (Nullable[CollectionDto], error)
	DeleteCollection(ctx context.Context, cmd DeleteCollectionCommand) error
}

type CommentDto struct {
	ID             int64               `json:"id,string"`
	Content        string              `json:"content"`
	User           CommentUserDto      `json:"user"`
	CreatedAt      time.Time           `json:"createdAt"`
	UpdatedAt      Nullable[time.Time] `json:"updatedAt"`
	LikedAt        Nullable[time.Time] `json:"likedAt"`
	Likes          int64               `json:"likes"`
	LikesUpdatedAt time.Time           `json:"likesUpdatedAt"`
	Subcomments    int                 `json:"subcomments"`
	Deleted        bool                `json:"deleted"`
}

type CommentSort string

type CommentUserDto struct {
	ID     uuid.UUID `json:"id"`
	Name   string    `json:"name"`
	Avatar string    `json:"avatar"`
}

type CommentsService interface {
	GetList(ctx context.Context, query GetCommentsQuery) (GetCommentsResult, error)
	GetReplies(ctx context.Context, query GetCommentRepliesQuery) (GetCommentRepliesResult, error)

	AddComment(ctx context.Context, command AddCommentCommand) (AddCommentResult, error)
	UpdateComment(ctx context.Context, command UpdateCommentCommand) (UpdateCommentResult, error)
	LikeComment(ctx context.Context, command LikeCommentCommand) (bool, error)
}

type ContentModerationRepository interface {
	SetChapterVisibilityAndLog(ctx context.Context, chapterID int64, visible bool, log ModerationAuditEntry) error
	SetCommentRemovedAndLog(ctx context.Context, commentID int64, removed bool, log ModerationAuditEntry) error
	SetUserBanAndLog(ctx context.Context, userID uuid.UUID, expiresAt time.Time, banned bool, log ModerationAuditEntry) error
	RenameUserAndLog(ctx context.Context, userID uuid.UUID, name string, log ModerationAuditEntry) error
	ChangeUserAboutAndLog(ctx context.Context, userID uuid.UUID, about string, log ModerationAuditEntry) error
}

type ContentModerationService interface {
	HideChapter(context.Context, ModerateChapterCommand) error
	RestoreChapter(context.Context, ModerateChapterCommand) error
	RemoveComment(context.Context, ModerateCommentCommand) error
	RestoreComment(context.Context, ModerateCommentCommand) error
	BanUser(context.Context, BanUserCommand) error
	PermanentlyBanUser(context.Context, BanUserCommand) error
	UnbanUser(context.Context, BanUserCommand) error
	RenameUser(context.Context, ModerateUserProfileCommand) error
	ChangeUserAbout(context.Context, ModerateUserProfileCommand) error
}

type ContentRestrictions struct {
	// if true - whole website is considered "adult"
	AdultWebsite bool
}

type CreateBookChapterCommand struct {
	BookID            int64
	Name              string
	Content           string
	Summary           string
	UserID            uuid.UUID
	IsPubliclyVisible bool
}

type CreateBookChapterCommand_Result struct {
	ID int64
}

type CreateBookCommand struct {
	Name              string
	UserID            uuid.UUID
	AgeRating         AgeRating
	Tags              []int64
	Summary           string
	IsPubliclyVisible bool
}

type CreateCollectionCommand struct {
	Name        string
	Description string
	UserID      uuid.UUID
}

type CreateDraftCommand struct {
	BookID    int64
	ChapterID int64
	UserID    uuid.UUID
}

type CreateReportCommand struct {
	ReporterUserID uuid.UUID
	TargetType     ReportTargetType
	TargetID       string
	Reason         string
	Description    string
	BookChapterID  Nullable[int64]
	BookExcerpt    string
}

type CreateSessionCommand struct {
	UserID    uuid.UUID
	UserAgent string
	IpAddress string
	ExpiresAt time.Time
}

type CreateTagsCommand struct {
	Tags []TagDescriptor
}

type DecideModerationReportCommand struct {
	ActorUserID  uuid.UUID
	ReportID     int64
	Disposition  string
	Action       string
	PolicyReason string
	InternalNote string
	NotifyTarget bool
	Payload      json.RawMessage
}

type DefinedTagDto struct {
	ID          int64        `json:"id,string"`
	Name        string       `json:"name"`
	Description string       `json:"desc"`
	IsAdult     bool         `json:"adult"`
	IsSpoiler   bool         `json:"spoiler"`
	Category    TagsCategory `json:"cat"`
}

type DeleteCollectionCommand struct {
	ActorUserID  uuid.UUID
	CollectionID int64
}

type DeleteDraftCommand struct {
	DraftID int64
	UserID  uuid.UUID
}

type DeleteReviewCommand struct {
	UserID uuid.UUID
	BookID int64
}

type DetailedBookSearchQuery struct {
	Query string         `json:"query"`
	Sort  BookSearchSort `json:"sort"`

	Words           Int32Range `json:"words"`
	Chapters        Int32Range `json:"chapters"`
	WordsPerChapter Int32Range `json:"wordsPerChapter"`

	IncludeTags  []DefinedTagDto            `json:"includeTags"`
	ExcludeTags  []DefinedTagDto            `json:"excludeTags"`
	IncludeUsers []UserFromSearchRequestDto `json:"includeUsers"`
	ExcludeUsers []UserFromSearchRequestDto `json:"excludeUsers"`

	IncludeBanned bool `json:"includeBanned"`
	IncludeHidden bool `json:"includeHidden"`
	IncludeEmpty  bool `json:"includeEmpty"`

	Page     uint32 `json:"page"`
	PageSize uint   `json:"pageSize"`
}

type DraftDto struct {
	ID          int64               `json:"id,string"`
	ChapterName string              `json:"chapterName"`
	Content     string              `json:"content"`
	CreatedAt   time.Time           `json:"createdAt"`
	UpdatedAt   Nullable[time.Time] `json:"updatedAt"`
	ScheduledAt Nullable[time.Time] `json:"scheduledAt"`
	CreatedBy   struct {
		ID   uuid.UUID `json:"id"`
		Name string    `json:"name"`
	} `json:"createdBy"`
	Book struct {
		ID   int64  `json:"id,string"`
		Name string `json:"name"`
	} `json:"book"`
	Chapter struct {
		ID               int64     `json:"id,string"`
		ContentUpdatedAt time.Time `json:"contentUpdatedAt"`
		Fonts            []string  `json:"fonts"`
	} `json:"chapter"`
	IsChapterPubliclyAvailable bool `json:"isChapterPubliclyAvailable"`
}

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

type EmailVerificationStatus struct {
	CanSendAgainAfter Nullable[time.Time]
	WasSent           bool
}

type FollowUserCommand struct {
	UserID   uuid.UUID
	Follower uuid.UUID
}

type GenericNotification struct {
	ID   string `json:"id"`
	Text string `json:"text"`
}

type GetBookChapterQuery struct {
	BookID      int64
	ChapterID   int64
	ActorUserID uuid.NullUUID
}

type GetBookChapterResult struct {
	Chapter ChapterDto
}

type GetBookChaptersQuery struct {
	ID int64
}

type GetBookCollectionsQuery struct {
	ActorUserID uuid.UUID
	BookID      int64
}

type GetBookDraftsQuery struct {
	Page int
}

type GetBookInfoQuery struct {
	ActorUserID uuid.UUID
	BookID      int64
}

type GetBookLogQuery struct {
	Page        uint32
	PageSize    uint32
	OfTypes     []BookActionType
	BookID      int64
	ActorUserID uuid.UUID
}

type GetBookQuery struct {
	ID          int64
	ActorUserID uuid.NullUUID
}

type GetBookReviewsDistributionResult struct {
	Distribution BookReviewsDistribution
}

type GetBookReviewsQuery struct {
	BookID   int64
	PageSize int32
	Page     int32
}

type GetBookReviewsResult struct {
	Reviews    []ReviewDto
	Pagination PaginationOptions
}

type GetCollectionBooksQuery struct {
	CollectionID int64
	Page         int32
	PageSize     int32
}

type GetCollectionBooksResult struct {
	Books      []CollectionBook2Dto
	Page       int32
	TotalPages int32
	PageSize   int32
}

type GetCommentRepliesQuery struct {
	ActorUserID uuid.NullUUID
	Limit       int32
	Cursor      uint32
	CommentID   int64
}

type GetCommentRepliesResult struct {
	Cursor     uint32       `json:"cursor"`
	NextCursor uint32       `json:"nextCursor"`
	Comments   []CommentDto `json:"comments"`
}

type GetCommentsQuery struct {
	ActorUserID uuid.NullUUID
	Limit       int32
	Cursor      uint32
	ChapterID   int64
	Sort        CommentSort
}

type GetCommentsResult struct {
	Cursor     uint32
	NextCursor uint32
	Comments   []CommentDto
	Total      int64
}

type GetDraftQuery struct {
	UserID    uuid.UUID
	DraftID   int64
	ChapterID int64
	BookID    int64
}

type GetLatestDraftQuery struct {
	BookID    int64
	ChapterID int64
	UserID    uuid.UUID
}

type GetLoginHistoryQuery struct {
	ActorUserID, UserID uuid.UUID
	UserIDs             []uuid.UUID
	Search, Status      string
	DateFrom, DateTo    Nullable[time.Time]
	Page, PageSize      uint32
}

type GetModerationReportQuery struct {
	ActorUserID uuid.UUID
	ReportID    int64
}

type GetModerationUserQuery struct {
	ActorUserID uuid.UUID
	UserID      uuid.UUID
}

type GetPinnedUserBooksQuery struct {
	UserID uuid.UUID
	Limit  int
	Offset int
}

type GetPinnedUserBooksResult struct {
	Books   []BookListDto `json:"books"`
	HasMore bool          `json:"hasMore"`
}

type GetReadingListItemsQuery struct {
	UserID uuid.UUID
	Limit  uint32
	Status ReadingListStatus
}

type GetRecentCollectionsQuery struct {
	UserID uuid.UUID
	Limit  int32
}

type GetReviewQuery struct {
	UserID uuid.UUID
	BookID int64
}

type GetUserCollectionsQuery struct {
	UserID   uuid.UUID
	Page     int32
	PageSize int32
}

type GetUserCollectionsResult struct {
	Collections []CollectionDto
	TotalPages  int32
	Page        int32
}

type GetUserDataQuery struct {
	UserID          uuid.UUID
	Key             string
	IgnoreWhitelist bool
}

type GetUserQuery struct {
	ID     uuid.UUID
	UserID uuid.NullUUID
}

type IPLocation struct {
	Country string `json:"country"`
	Region  string `json:"region"`
	City    string `json:"city"`
}

type IPLocationService interface {
	Locate(context.Context, string) (IPLocation, error)
}

type Int32 struct {
	Valid bool
	Int32 int32
}

type Int32Range struct {
	Min Int32 `json:"min"`
	Max Int32 `json:"max"`
}

type Int64String int64

type LikeCommentCommand struct {
	CommentID int64
	UserID    uuid.UUID
	Like      bool
}

type ListTagsQuery struct {
	SearchQuery    string
	Page           uint32
	PageSize       uint32
	OnlyParentTags bool
	OnlyAdultTags  bool
	Category       Nullable[TagsCategory]
}

type ListTagsResult struct {
	Tags       []TagDetailsItemDto
	Page       uint32
	TotalPages uint32
	TotalCount uint32
}

type LoginHistoryEntry struct {
	ID                   int64
	UserID               uuid.UUID
	UserName             string
	IPAddress, UserAgent string
	Location             IPLocation
	LoggedInAt           time.Time
	IsTerminated         bool
	ExpiresAt            time.Time
}

type LoginHistoryRepository interface {
	Search(context.Context, GetLoginHistoryQuery, int32, int32) ([]LoginHistoryEntry, int64, error)
	RecentLocations(context.Context, uuid.UUID) ([]LoginLocation, error)
}

type LoginHistoryService interface {
	GetUserLoginHistory(context.Context, GetLoginHistoryQuery) (ModerationPage[LoginHistoryEntry], error)
	GetRecentLoginLocations(context.Context, GetLoginHistoryQuery) ([]LoginLocation, error)
}

type LoginLocation struct {
	IPLocation
	LastSeenAt time.Time
}

type ManagerBookChapterDetailsDto struct {
	ID                int64     `json:"id,string"`
	Name              string    `json:"name"`
	CreatedAt         time.Time `json:"createdAt"`
	Words             int       `json:"words"`
	Summary           string    `json:"summary"`
	Order             int32     `json:"order"`
	Content           string    `json:"content"`
	IsPubliclyVisible bool      `json:"isPubliclyVisible"`
	Fonts             []string  `json:"fonts"`
}

type ManagerBookChapterDto struct {
	ID                int64                 `json:"id,string"`
	Name              string                `json:"name"`
	CreatedAt         time.Time             `json:"createdAt"`
	Words             int                   `json:"words"`
	Summary           string                `json:"summary"`
	Order             int32                 `json:"order"`
	IsPubliclyVisible bool                  `json:"isPubliclyVisible"`
	DraftID           Nullable[Int64String] `json:"draftId"`
	ScheduledAt       Nullable[time.Time]   `json:"scheduledAt"`
}

type ManagerBookDetailsDto struct {
	ID                int64                   `json:"id,string"`
	Name              string                  `json:"name"`
	AgeRating         AgeRating               `json:"ageRating"`
	IsAdult           bool                    `json:"adult"`
	Tags              []DefinedTagDto         `json:"tags"`
	Words             int                     `json:"words"`
	WordsPerChapter   int                     `json:"wordsPerChapter"`
	CreatedAt         time.Time               `json:"createdAt"`
	Collections       []BookCollectionDto     `json:"collections"`
	Chapters          []ManagerBookChapterDto `json:"chapters"`
	Author            BookDetailsAuthorDto    `json:"author"`
	Summary           string                  `json:"summary"`
	IsPubliclyVisible bool                    `json:"isPubliclyVisible"`
	IsBanned          bool                    `json:"isBanned"`
	Cover             BookCover               `json:"cover"`
}

type ManagerBookDto struct {
	ID                int64                `json:"id,string"`
	Slug              string               `json:"slug"`
	Name              string               `json:"name"`
	CreatedAt         time.Time            `json:"createdAt"`
	AgeRating         AgeRating            `json:"ageRating"`
	Tags              []DefinedTagDto      `json:"tags"`
	Words             int                  `json:"words"`
	WordsPerChapter   int                  `json:"wordsPerChapter"`
	Chapters          int                  `json:"chapters"`
	Collections       []BookCollectionDto  `json:"collections"`
	IsPubliclyVisible bool                 `json:"isPubliclyVisible"`
	IsBanned          bool                 `json:"isBanned"`
	IsTrashed         bool                 `json:"isTrashed"`
	Summary           string               `json:"summary"`
	Cover             BookCover            `json:"cover"`
	Stats             ManagerBookDto_Stats `json:"stats"`
}

type ManagerBookDto_Stats struct {
	Views   analytics.MetricValues `json:"views"`
	Reviews int32                  `json:"reviews"`
	Ratings int32                  `json:"ratings"`
}

type ManagerGetBookChaptersQuery struct {
	BookID int64
	UserID uuid.UUID
}

type ManagerGetBookChaptersQuery_Result struct {
	Chapters []ManagerBookChapterDto
}

type ManagerGetBookQuery struct {
	ActorUserID uuid.UUID
	BookID      int64
}

type ManagerGetBookQuery_Result struct {
	Book ManagerBookDetailsDto
}

type ManagerGetChapterQuery struct {
	BookID    int64
	ChapterID int64
	UserID    uuid.UUID
}

type ManagerGetChapterQuery_Result struct {
	Chapter ManagerBookChapterDetailsDto
}

type ManagerGetUserBooksQuery struct {
	UserID      uuid.UUID
	ActorUserID Nullable[uuid.UUID]
	Page        uint32
	PageSize    uint32
	SearchQuery string
}

type ManagerGetUserBooksQuery_Result struct {
	Books      []ManagerBookDto
	TotalPages uint32
	PageSize   uint32
	Page       uint32
}

type MarkChapterCommand struct {
	ChapterID int64
	UserID    uuid.UUID
}

type ModerateChapterCommand struct {
	ActorUserID uuid.UUID
	ChapterID   int64
	Reason      string
}

type ModerateCommentCommand struct {
	ActorUserID uuid.UUID
	CommentID   int64
	Reason      string
}

type ModerateUserProfileCommand struct {
	ActorUserID, UserID uuid.UUID
	Value, Reason       string
}

type ModerationAction string

type ModerationAuditEntry struct {
	ID          int64
	Time        time.Time
	Action      ModerationAction
	ActorUserID uuid.UUID
	TargetType  string
	TargetID    string
	Reason      string
	Payload     []byte
}

type ModerationAuditLogEntry struct {
	ID                                                  int64
	Time                                                time.Time
	Action, TargetType, TargetID, Reason, ActorUserName string
	Payload                                             json.RawMessage
	ActorUserID                                         uuid.UUID
}

type ModerationAuditLogQuery struct {
	ActorUserID    uuid.UUID
	TargetType     string
	Page, PageSize uint32
}

type ModerationAuditLogService interface {
	GetAuditLog(context.Context, ModerationAuditLogQuery) (ModerationPage[ModerationAuditLogEntry], error)
}

type ModerationAuthorizer interface {
	AuthorizeModerator(ctx context.Context, actorUserID uuid.UUID) error
}

type ModerationBookListEntry struct {
	ID                                                                           int64
	Name                                                                         string
	CreatedAt                                                                    time.Time
	IsBanned, IsShadowBanned, IsTrashed, IsPermanentlyRemoved, IsPubliclyVisible bool
	Words, Chapters                                                              int32
	AuthorUserID                                                                 uuid.UUID
	AuthorUserName                                                               string
	ReportsCount                                                                 int64
}

type ModerationBookService interface {
	SearchBooks(ctx context.Context, query SearchModerationBooksQuery) (ModerationPage[ModerationBookListEntry], error)
	GetBookInfo(ctx context.Context, query GetBookInfoQuery) (BookModerationInfo, error)
	GetBookLog(ctx context.Context, query GetBookLogQuery) (BookLogResult, error)
	GetBookChapters(ctx context.Context, query GetBookInfoQuery) ([]BookModerationChapter, error)
	ChangeAgeRating(ctx context.Context, cmd ModerationPerformBookActionCommand) error
	ChangeSummary(ctx context.Context, cmd ModerationPerformBookActionCommand) error
	BanBook(ctx context.Context, cmd ModerationPerformBookActionCommand) error
	ShadowBanBook(ctx context.Context, cmd ModerationPerformBookActionCommand) error
	PermanentlyRemoveBook(ctx context.Context, cmd ModerationPerformBookActionCommand) error

	UnBanBook(ctx context.Context, cmd ModerationPerformBookActionCommand) error
	UnShadowBanBook(ctx context.Context, cmd ModerationPerformBookActionCommand) error
}

type ModerationPage[T any] struct {
	Entries    []T
	Page       uint32
	PageSize   uint32
	Total      int64
	TotalPages uint32
}

type ModerationPerformBookActionCommand struct {
	Reason      string
	Value       string
	ActorUserID uuid.UUID
	BookID      int64
}

type ModerationReportActivity struct {
	Time        time.Time
	Actor       string
	Description string
	Kind        string
	Decision    *ReportDecision
}

type ModerationReportBookContext struct {
	Scope            string
	Title            string
	Author           string
	CoverURL         string
	Chapter          string
	Excerpt          string
	Rating           string
	Warnings         []string
	PublicationState string
	LastUpdated      time.Time
	RelatedReports   int
	EditedAfter      time.Duration
}

type ModerationReportBookContextData struct {
	Title, Author, CoverID, Excerpt, Rating   string
	BookID                                    int64
	ChapterID                                 Nullable[int64]
	Chapter                                   Nullable[string]
	Warnings                                  []string
	IsPermanentlyRemoved, IsBanned, IsTrashed bool
	IsPubliclyVisible                         bool
	BookCreatedAt                             time.Time
	ChapterCreatedAt, ChapterUpdatedAt        Nullable[time.Time]
	ChapterContentUpdatedAt                   Nullable[time.Time]
	RelatedReports                            int
}

type ModerationReportCommentContextData struct {
	ID, ChapterID, BookID                      int64
	Content, AuthorName, ChapterName, BookName string
	AuthorID                                   uuid.UUID
	CreatedAt                                  time.Time
	UpdatedAt                                  Nullable[time.Time]
	DeletedAt                                  Nullable[time.Time]
	RelatedReports                             int
}

type ModerationReportDetail struct {
	Report
	ReporterUserName string
	Status           string
	Priority         string
	Activities       []ModerationReportActivity
	BookContext      *ModerationReportBookContext
	UserContext      *ModerationReportUserContextData
	CommentContext   *ModerationReportCommentContextData
	AvailableActions []string
}

type ModerationReportListEntry struct {
	Report
	ReporterUserName string
}

type ModerationReportService interface {
	GetReport(context.Context, GetModerationReportQuery) (ModerationReportDetail, error)
	SearchReports(context.Context, SearchModerationReportsQuery) (ModerationPage[ModerationReportListEntry], error)
	DecideReport(context.Context, DecideModerationReportCommand) error
}

type ModerationReportUserContextData struct {
	ID                       uuid.UUID
	Name, Email, About, Role string
	JoinedAt                 time.Time
	IsBanned                 bool
	RelatedReports           int
}

type ModerationUserBook struct {
	ID                int64
	Name              string
	CreatedAt         time.Time
	IsPubliclyVisible bool
	IsBanned          bool
	IsTrashed         bool
}

type ModerationUserComment struct {
	ID, ChapterID, BookID          int64
	Content, ChapterName, BookName string
	CreatedAt                      time.Time
	Deleted                        bool
}

type ModerationUserHistoryEntry struct {
	ID            int64
	Time          time.Time
	Type          string
	Reason        string
	Payload       json.RawMessage
	ActorUserID   uuid.UUID
	ActorUserName string
	TargetType    string
	TargetID      string
}

type ModerationUserInfo struct {
	ID              uuid.UUID
	Name            string
	Email           string
	About           string
	Avatar          string
	JoinedAt        time.Time
	Role            UserRole
	IsBanned        bool
	IsEmailVerified bool
	BooksTotal      int64
	CommentsTotal   int64
	FollowersTotal  int64
}

type ModerationUserListEntry struct {
	ID          uuid.UUID
	Name        string
	Avatar      string
	JoinedAt    time.Time
	Role        UserRole
	IsBanned    bool
	LastVisitAt *time.Time
	BannedAt    *time.Time
	BanReason   string
}

type ModerationUserPageQuery struct {
	ActorUserID uuid.UUID
	UserID      uuid.UUID
	Page        uint32
	PageSize    uint32
}

type ModerationUserReport struct {
	Number, TargetID, Reason, Description, ReporterUserName string
	ID                                                      int64
	Time                                                    time.Time
	TargetType                                              ReportTargetType
	ReporterUserID                                          uuid.UUID
}

type ModerationUserRepository interface {
	SearchUsers(context.Context, string, *uuid.UUID, string, string, int32, int32) ([]ModerationUserListEntry, int64, error)
	GetUserInfo(context.Context, uuid.UUID) (ModerationUserInfo, error)
	GetBooks(context.Context, uuid.UUID, int32, int32) ([]ModerationUserBook, error)
	GetComments(context.Context, uuid.UUID, int32, int32) ([]ModerationUserComment, error)
	GetHistory(context.Context, uuid.UUID, int32, int32) ([]ModerationUserHistoryEntry, int64, error)
	GetReports(context.Context, uuid.UUID, int32, int32) ([]ModerationUserReport, int64, error)
	CreateTemporaryRandomReports(context.Context, uuid.UUID, int) error
}

type ModerationUserService interface {
	SearchUsers(context.Context, ModerationUsersQuery) (ModerationPage[ModerationUserListEntry], error)
	GetUserInfo(context.Context, GetModerationUserQuery) (ModerationUserInfo, error)
	GetBooks(context.Context, ModerationUserPageQuery) (ModerationPage[ModerationUserBook], error)
	GetComments(context.Context, ModerationUserPageQuery) (ModerationPage[ModerationUserComment], error)
	GetHistory(context.Context, ModerationUserPageQuery) (ModerationPage[ModerationUserHistoryEntry], error)
	GetReports(context.Context, ModerationUserPageQuery) (ModerationPage[ModerationUserReport], error)
}

type ModerationUsersQuery struct {
	ActorUserID uuid.UUID
	Search      string
	Banned      string
	Role        string
	Page        uint32
	PageSize    uint32
}

type NormalizedSearchRequest struct {
	UserID uuid.NullUUID

	Words           Int32Range
	Chapters        Int32Range
	WordsPerChapter Int32Range
	Favorites       Int32Range

	IncludeTags  []int64
	ExcludeTags  []int64
	IncludeUsers []uuid.UUID
	ExcludeUsers []uuid.UUID

	IncludeBanned bool
	IncludeHidden bool
	IncludeEmpty  bool

	Limit  uint
	Offset uint
}

type Nullable[T any] struct {
	Value T
	Valid bool
}

type PaginationOptions struct {
	Page     int32 `json:"page"`
	PageSize int32 `json:"pageSize"`
}

type PaginationRestrictions struct {
	MaxPageSize  int32
	MaxPageCount int32
}

type PasswordRequirements struct {
	Digits         bool
	Symbols        string
	SymbolsEnabled bool
	DifferentCases bool
	MinLength      int
}

type PublishDraftCommand struct {
	DraftID    int64
	UserID     uuid.UUID
	MakePublic bool
}

type RatingAndReview struct {
	Rating Nullable[RatingValue] `json:"rating"`
	Review Nullable[ReviewDto]   `json:"review"`
}

type RatingValue uint8

type ReaderPreferences struct {
	FontSize   int16  `json:"fontSize"`
	FontFamily string `json:"fontFamily"`
	PageColor  string `json:"pageColor"`
	Theme      string `json:"theme"`
}

type ReaderPreferencesService interface {
	Get(ctx context.Context, userID uuid.UUID) (Nullable[ReaderPreferences], error)
	Save(ctx context.Context, userID uuid.UUID, preferences ReaderPreferences) error
}

type ReadingListService interface {
	MarksAsWantToRead(ctx context.Context, userID uuid.UUID, bookID int64) error
	MarkAsDnf(ctx context.Context, userID uuid.UUID, bookID int64) error
	MarkAsRead(ctx context.Context, userID uuid.UUID, bookID int64) error
	MarkAsPaused(ctx context.Context, userID uuid.UUID, bookID int64) error
	MarkAsReading(ctx context.Context, userID uuid.UUID, bookID int64) error
	MarkAsReadingWithChapterID(ctx context.Context, userID uuid.UUID, bookID int64, chapterID int64) error
	GetStatus(ctx context.Context, userID uuid.UUID, bookID int64) (Nullable[BookReadingListDto], error)
	GetReadingListBooks(ctx context.Context, query GetReadingListItemsQuery) ([]BookLibraryDto, error)
	MarkChapterRead(ctx context.Context, command MarkChapterCommand) error
}

type ReadingListStatus store.ReadingListStatus

type RemoveFromCollectionCommand struct {
	CollectionID int64
	BookID       int64
	UserID       uuid.UUID
}

type RenewSessionCommand struct {
	SessionID string
	UserAgent string
	IpAddress string
	ExpiresAt time.Time
}

type ReorderChaptersCommand struct {
	UserID     uuid.UUID
	BookID     int64
	ChapterIDs []int64
}

type Report struct {
	ID             int64
	Number         string
	Time           time.Time
	ReporterUserID uuid.UUID
	TargetType     ReportTargetType
	TargetID       string
	Reason         string
	Description    string
	BookChapterID  Nullable[int64]
	BookExcerpt    string
	Status         string
	Priority       string
}

type ReportActionExecutor interface {
	Execute(context.Context, Report, DecideModerationReportCommand) error
	AvailableActions(Report) []string
}

type ReportDecision struct {
	Time          time.Time
	ActorUserID   uuid.UUID
	ActorUserName string
	Disposition   string
	Action        string
	PolicyReason  string
	InternalNote  string
	NotifyTarget  bool
	Payload       []byte
}

type ReportRepository interface {
	TargetExists(context.Context, ReportTargetType, string) (bool, error)
	BookChapterExists(context.Context, int64, int64) (bool, error)
	Create(context.Context, Report) (Report, error)
	GetByID(context.Context, int64) (Report, string, error)
	GetBookContext(context.Context, int64) (*ModerationReportBookContextData, error)
	GetUserContext(context.Context, int64) (*ModerationReportUserContextData, error)
	GetCommentContext(context.Context, int64) (*ModerationReportCommentContextData, error)
	Search(context.Context, string, string, int32, int32) ([]ModerationReportListEntry, int64, error)
	GetEvents(context.Context, int64) ([]ReportDecision, error)
	AddDecision(context.Context, int64, string, ReportDecision) error
}

type ReportService interface {
	Create(context.Context, CreateReportCommand) (Report, error)
	GetReasons(ReportTargetType) ([]string, error)
}

type ReportTargetType string

type ReviewDto struct {
	User      ReviewUserDto       `json:"user"`
	Rating    RatingValue         `json:"rating"`
	Content   string              `json:"content"`
	CreatedAt time.Time           `json:"createdAt"`
	UpdatedAt Nullable[time.Time] `json:"updatedAt"`
	Likes     int32               `json:"likes"`
}

type ReviewUserDto struct {
	ID     uuid.UUID `json:"id"`
	Name   string    `json:"name"`
	Avatar string    `json:"avatar"`
}

type ReviewsService interface {
	GetBookReviewsDistribution(ctx context.Context, bookID int64) (GetBookReviewsDistributionResult, error)
	GetBookReviews(ctx context.Context, query GetBookReviewsQuery) (GetBookReviewsResult, error)

	UpdateReview(ctx context.Context, cmd UpdateReviewCommand) (ReviewDto, error)
	UpdateRating(ctx context.Context, cmd UpdateRatingCommand) error

	GetReview(ctx context.Context, query GetReviewQuery) (RatingAndReview, error)
	DeleteReview(ctx context.Context, cmd DeleteReviewCommand) error
}

type ScheduleDraftCommand struct {
	DraftID     int64
	ChapterID   int64
	BookID      int64
	UserID      uuid.UUID
	ScheduledAt time.Time
}

type SearchModerationBooksQuery struct {
	ActorUserID                              uuid.UUID
	Search                                   string
	ExactName, IncludeBanned, IncludeDeleted bool
	Page, PageSize                           uint32
}

type SearchModerationReportsQuery struct {
	ActorUserID uuid.UUID
	Search      string
	TargetType  string
	Page        uint32
	PageSize    uint32
}

type SearchService interface {
	SearchBooks(ctx context.Context, req BookSearchQuery) (*BookSearchResult, error)
	GetBookExtremes(ctx context.Context) (*BookExtremes, error)
	ExplainSearchQuery(ctx context.Context, req BookSearchQuery) (DetailedBookSearchQuery, error)
}

type SearchUserBooksQuery struct {
	UserID      uuid.UUID
	ActorUserID Nullable[uuid.UUID]
	Limit       int
	Offset      int
}

type SearchUserBooksResult struct {
}

type SelfUserDto struct {
	ID     uuid.UUID `json:"id"`
	Name   string    `json:"name"`
	Email  string    `json:"email"`
	Role   UserRole  `json:"role"`
	Avatar struct {
		LG string `json:"lg"`
		MD string `json:"md"`
	} `json:"avatar"`
	JoinedAt        time.Time `json:"joinedAt"`
	IsBanned        bool      `json:"isBanned"`
	IsEmailVerified bool      `json:"isEmailVerified"`
	PreferredTheme  string    `json:"preferredTheme"`
}

type SendEmailVerificationCommand struct {
	UserID          uuid.UUID
	BypassRateLimit bool
}

type SendEmailVerificationResult struct {
	CanResendAfter time.Time
}

type SessionInfo struct {
	ID           int64      `json:"id"`
	SID          string     `json:"sid"`
	CreatedAt    time.Time  `json:"createdAt"`
	ExpiresAt    time.Time  `json:"expiresAt"`
	UserID       uuid.UUID  `json:"userId"`
	UserAgent    string     `json:"userAgent"`
	IpAddress    string     `json:"ipAddr"`
	Location     IPLocation `json:"location"`
	UserName     string     `json:"userName"`
	UserJoinedAt time.Time  `json:"userJoinedAt"`
	UserRole     UserRole   `json:"userRole"`
}

type SessionPublicInfo struct {
	ID        int64         `json:"id,string"`
	UserAgent UserAgentInfo `json:"userAgent"`
	IpAddress string        `json:"ipAddress"`
	Location  IPLocation    `json:"location"`
	CreatedAt time.Time     `json:"createdAt"`
	ExpiresAt time.Time     `json:"expiresAt"`
}

type SessionService interface {
	GetBySID(ctx context.Context, sessionID string) (*SessionInfo, error)
	Create(ctx context.Context, command CreateSessionCommand) (*SessionInfo, error)
	GetByUserID(ctx context.Context, userID uuid.UUID) ([]SessionInfo, error)
	TerminateBySID(ctx context.Context, sessionID string) error
	TerminateAllByUserID(ctx context.Context, userID uuid.UUID) error
	Renew(ctx context.Context, command RenewSessionCommand) (*SessionInfo, error)
}

type SetUserDataQuery struct {
	UserID          uuid.UUID
	Key             string
	Data            json.RawMessage
	IgnoreWhitelist bool
}

type SignInCommand struct {
	Username  string
	Password  string
	UserAgent string
	IpAddress string
}

type SignInResult struct {
	SessionID string
	UserID    uuid.UUID
}

type SignUpCommand struct {
	Username                  string
	Password                  string
	Email                     string
	UserAgent                 string
	IpAddress                 string
	BypassEmailRequirement    bool
	BypassPasswordRequirement bool
}

type SignUpResult struct {
	Created                   bool
	CreatedUserID             uuid.UUID
	EmailTaken                bool
	EmailVerificationRequired bool
}

type SignUpService interface {
	SignUp(ctx context.Context, cmd SignUpCommand) (SignUpResult, error)
	VerifyEmail(ctx context.Context, cmd VerifyEmailCommand) error
	SendEmailVerification(ctx context.Context, cmd SendEmailVerificationCommand) (SendEmailVerificationResult, error)
	GetEmailVerificationStatus(ctx context.Context, userID uuid.UUID) (EmailVerificationStatus, error)
}

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

type SiteConfigData struct {
	CaptchaSettings      CaptchaSettings
	PasswordRequirements PasswordRequirements
	ContentRestrictions  ContentRestrictions
}

type SiteConfigEntry json.RawMessage

type TagDescriptor struct {
	Name      string
	Category  TagsCategory
	IsAdult   bool
	IsWarning bool
	IsSpoiler bool
}

type TagDetailsItemDto struct {
	DefinedTagDto

	SynonymOf Nullable[struct {
		ID   int64
		Name string
	}]
	CreatedAt time.Time
	IsDefault bool
}

type TagsCategory uint8

type TagsService interface {
	GetTag(ctx context.Context, id int64) (TagDetailsItemDto, error)
	GetTagsByIds(ctx context.Context, ids []int64) ([]DefinedTagDto, error)
	SearchTags(ctx context.Context, query string) ([]DefinedTagDto, error)
	FindParentTagIds(ctx context.Context, names []int64) (BookTags, error)
	CreateTags(ctx context.Context, cmd CreateTagsCommand) ([]DefinedTagDto, error)
	List(ctx context.Context, query ListTagsQuery) (ListTagsResult, error)
	UpdateTag(ctx context.Context, command UpdateTagCommand) error
}

type TrashBookCommand struct {
	BookID      int64
	ActorUserID uuid.UUID
}

type UnfollowUserCommand struct {
	UserID   uuid.UUID
	Follower uuid.UUID
}

type UntrashBookCommand struct {
	BookID      int64
	ActorUserID uuid.UUID
}

type UpdateBookChapterCommand struct {
	BookID            int64
	ChapterID         int64
	UserID            uuid.UUID
	Name              string
	Summary           string
	IsPubliclyVisible bool
}

type UpdateBookChapterOrdersCommand struct {
	BookID        int64
	Modifications []ChapterOrderModification
}

type UpdateBookChapterOrdersCommand_Result struct {
	ModifiedPositions map[int64]int
}

type UpdateBookCommand struct {
	BookID            int64
	UserID            uuid.UUID
	Name              string
	AgeRating         AgeRating
	Tags              []int64
	Summary           string
	IsPubliclyVisible bool
}

type UpdateCollectionCommand struct {
	ID          int64
	Name        string
	Public      bool
	Summary     string
	ActorUserID uuid.UUID
}

type UpdateCommentCommand struct {
	ID      int64
	Content string
	UserID  uuid.UUID
}

type UpdateCommentResult struct {
	Comment CommentDto
}

type UpdateDraftChapterNameCommand struct {
	ChapterName string
	ChapterID   int64
	BookID      int64
	DraftID     int64
	UserID      uuid.UUID
}

type UpdateDraftCommand struct {
	Content   string
	Summary   string
	Name      string
	DraftID   int64
	ChapterID int64
	BookID    int64
	UserID    uuid.UUID
}

type UpdateDraftContentCommand struct {
	Content   string
	DraftID   int64
	ChapterID int64
	BookID    int64
	UserID    uuid.UUID
}

type UpdateRatingCommand struct {
	BookID int64
	UserID uuid.UUID
	Rating RatingValue
}

type UpdateReviewCommand struct {
	BookID  int64
	UserID  uuid.UUID
	Rating  RatingValue
	Content string
}

type UpdateTagCommand struct {
	ID             int64
	Name           string
	Description    string
	IsAdult        bool
	IsSpoiler      bool
	SynonymOfTagID Nullable[int64]
	Type           TagsCategory
	UserID         uuid.UUID
}

type UpdateUserCommand struct {
	UserID      uuid.UUID
	ActorUserID uuid.NullUUID
	Password    string
	Role        Nullable[UserRole]
	About       string
	Gender      string
}

type UploadBookCoverCommand struct {
	UserID uuid.UUID
	BookID int64
	File   io.Reader
}

type UploadBookCoverCommand_Result struct {
	URL BookCover
}

type UploadConfig struct {
	Endpoint     string
	Region       string
	AccessKey    string
	SecretKey    string
	MainBucket   string
	PublicBucket string
	Secure       bool
}

type UploadService struct {
	Client       *minio.Client
	MainBucket   string
	PublicBucket string
	Region       string
	Secure       bool
	Endpoint     string
}

type UploadURI struct {
	Type UploadURIType
	Key  string
}

type UploadURIType int

type UserAboutDto struct {
	Bio    string `json:"bio"`
	Gender string `json:"gender"`
}

type UserAboutSettings struct {
	About  string `json:"about"`
	Status string `json:"status"`
	Gender string `json:"gender"`
}

type UserAgentInfo struct {
	Value   string `json:"value"`
	Version string `json:"ver"`
	Name    string `json:"name"`
	OS      string `json:"os"`
}

type UserCustomizationSetting struct {
	ProfileCSS       string `json:"profileCss"`
	DefaultTheme     string `json:"defaultTheme"`
	EnableProfileCSS bool   `json:"enableProfileCss"`
}

type UserDataService interface {
	Get(ctx context.Context, query GetUserDataQuery) (Nullable[json.RawMessage], error)
	Set(ctx context.Context, query SetUserDataQuery) error
}

type UserDetailsDto struct {
	ID     uuid.UUID `json:"id"`
	Name   string    `json:"name"`
	Email  string    `json:"email"`
	Avatar struct {
		LG string `json:"lg"`
		MD string `json:"md"`
	} `json:"avatar"`
	JoinedAt       time.Time    `json:"joinedAt"`
	IsBanned       bool         `json:"isBanned"`
	Role           UserRole     `json:"role"`
	HasCustomTheme bool         `json:"hasCustomTheme"`
	About          UserAboutDto `json:"about"`
	Followers      int32        `json:"followers"`
	Following      int32        `json:"following"`
	BooksTotal     int32        `json:"booksTotal"`
	HideEmail      bool         `json:"hideEmail"`
	HideStats      bool         `json:"hideStats"`
	HideFavorites  bool         `json:"hideFavorites"`
	IsFollowing    bool         `json:"isFollowing"`
}

type UserFromSearchRequestDto struct {
	ID     uuid.UUID `json:"id"`
	Name   string    `json:"name"`
	Avatar string    `json:"avatar"`
}

type UserListResponse struct {
	Users      []UserSearchItem `json:"users"`
	Total      int32            `json:"total"`
	Page       uint32           `json:"page"`
	TotalPages int32            `json:"totalPages"`
}

type UserModerationSettings struct {
	ShowAdultContent bool       `json:"showAdultContent"`
	CensoredTags     []string   `json:"censoredTags"`
	CensoredTagsMode CensorMode `json:"censoredTagsMode"`
}

type UserPrivacySettings struct {
	HideStats      bool `json:"hideStats"`
	HideFavorites  bool `json:"hideFavorites"`
	HideComments   bool `json:"hideComments"`
	HideEmail      bool `json:"hideEmail"`
	AllowSearching bool `json:"allowSearching"`
}

type UserRole string

type UserSearchItem struct {
	ID       uuid.UUID
	Name     string
	Role     UserRole
	IsBanned bool
	JoinedAt time.Time
	Avatar   string
}

type UserService interface {
	GetUserPrivacySettings(ctx context.Context, userID uuid.UUID) (*UserPrivacySettings, error)
	GetUserModerationSettings(ctx context.Context, userID uuid.UUID) (*UserModerationSettings, error)
	GetUserCustomizationSettings(ctx context.Context, userID uuid.UUID) (*UserCustomizationSetting, error)
	GetUserAboutSettings(ctx context.Context, userID uuid.UUID) (*UserAboutSettings, error)

	UpdateUserPrivacySettings(ctx context.Context, userID uuid.UUID, settings UserPrivacySettings) error
	UpdateUserModerationSettings(ctx context.Context, userID uuid.UUID, settings UserModerationSettings) error
	UpdateUserCustomizationSettings(ctx context.Context, userID uuid.UUID, settings UserCustomizationSetting) error
	UpdateUserAboutSettings(ctx context.Context, userID uuid.UUID, settings UserAboutSettings) error

	UpdateUser(ctx context.Context, cmd UpdateUserCommand) error

	GetUserDetails(ctx context.Context, query GetUserQuery) (*UserDetailsDto, error)
	GetUserSelfData(ctx context.Context, userID uuid.UUID) (*SelfUserDto, error)

	FollowUser(ctx context.Context, cmd FollowUserCommand) error
	UnfollowUser(ctx context.Context, cmd UnfollowUserCommand) error

	ListUsers(ctx context.Context, req UsersQuery) (UserListResponse, error)
}

type UsersQuery struct {
	Banned bool
	Role   []UserRole
	Query  string

	Page     uint32
	PageSize uint32
}

type VerifyEmailCommand struct {
	UserID uuid.UUID
	Code   string
}