// Code generated by sqlc. DO NOT EDIT.
// versions:
//   sqlc v1.30.0
// source: queries.sql

package database

import (
	"context"

	"github.com/jackc/pgx/v5/pgtype"
)

const AddLibraryFolder = `-- name: AddLibraryFolder :one
INSERT INTO library_folders (library_id, folder_path) VALUES ($1, $2) RETURNING id, library_id, folder_path, created_at
`

type AddLibraryFolderParams struct {
	LibraryID  pgtype.UUID `db:"library_id" json:"library_id"`
	FolderPath string      `db:"folder_path" json:"folder_path"`
}

// Library Folders queries
func (q *Queries) AddLibraryFolder(ctx context.Context, arg AddLibraryFolderParams) (LibraryFolders, error) {
	row := q.db.QueryRow(ctx, AddLibraryFolder, arg.LibraryID, arg.FolderPath)
	var i LibraryFolders
	err := row.Scan(
		&i.ID,
		&i.LibraryID,
		&i.FolderPath,
		&i.CreatedAt,
	)
	return i, err
}

const CleanupExpiredRefreshTokens = `-- name: CleanupExpiredRefreshTokens :exec
DELETE FROM refresh_tokens WHERE expires_at < NOW() OR (revoked_at IS NOT NULL AND revoked_at < NOW() - INTERVAL '7 days')
`

func (q *Queries) CleanupExpiredRefreshTokens(ctx context.Context) error {
	_, err := q.db.Exec(ctx, CleanupExpiredRefreshTokens)
	return err
}

const CreateEbook = `-- name: CreateEbook :one
INSERT INTO media_items (library_id, title, author, isbn, description, file_path, file_size, mime_type, cover_image_path, series, series_number, tags, asin, date_published, publisher, contributors, added_by_admin_id)
VALUES ((SELECT id FROM libraries WHERE library_type_id = (SELECT id FROM library_types WHERE name = 'ebooks') LIMIT 1), $1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13, $14, $15, $16)
RETURNING id, library_id, title, author, isbn, description, file_path, file_size, mime_type, cover_image_path, series, series_number, tags, asin, date_published, publisher, contributors, added_by_admin_id, created_at, updated_at
`

type CreateEbookParams struct {
	Title          string      `db:"title" json:"title"`
	Author         pgtype.Text `db:"author" json:"author"`
	Isbn           pgtype.Text `db:"isbn" json:"isbn"`
	Description    pgtype.Text `db:"description" json:"description"`
	FilePath       string      `db:"file_path" json:"file_path"`
	FileSize       pgtype.Int8 `db:"file_size" json:"file_size"`
	MimeType       pgtype.Text `db:"mime_type" json:"mime_type"`
	CoverImagePath pgtype.Text `db:"cover_image_path" json:"cover_image_path"`
	Series         pgtype.Text `db:"series" json:"series"`
	SeriesNumber   pgtype.Int4 `db:"series_number" json:"series_number"`
	Tags           pgtype.Text `db:"tags" json:"tags"`
	Asin           pgtype.Text `db:"asin" json:"asin"`
	DatePublished  pgtype.Date `db:"date_published" json:"date_published"`
	Publisher      pgtype.Text `db:"publisher" json:"publisher"`
	Contributors   pgtype.Text `db:"contributors" json:"contributors"`
	AddedByAdminID pgtype.UUID `db:"added_by_admin_id" json:"added_by_admin_id"`
}

func (q *Queries) CreateEbook(ctx context.Context, arg CreateEbookParams) (MediaItems, error) {
	row := q.db.QueryRow(ctx, CreateEbook,
		arg.Title,
		arg.Author,
		arg.Isbn,
		arg.Description,
		arg.FilePath,
		arg.FileSize,
		arg.MimeType,
		arg.CoverImagePath,
		arg.Series,
		arg.SeriesNumber,
		arg.Tags,
		arg.Asin,
		arg.DatePublished,
		arg.Publisher,
		arg.Contributors,
		arg.AddedByAdminID,
	)
	var i MediaItems
	err := row.Scan(
		&i.ID,
		&i.LibraryID,
		&i.Title,
		&i.Author,
		&i.Isbn,
		&i.Description,
		&i.FilePath,
		&i.FileSize,
		&i.MimeType,
		&i.CoverImagePath,
		&i.Series,
		&i.SeriesNumber,
		&i.Tags,
		&i.Asin,
		&i.DatePublished,
		&i.Publisher,
		&i.Contributors,
		&i.AddedByAdminID,
		&i.CreatedAt,
		&i.UpdatedAt,
	)
	return i, err
}

const CreateEbookHighlight = `-- name: CreateEbookHighlight :one
INSERT INTO media_highlights (media_item_id, user_id, selection_text, start_position, end_position, color, note_id)
VALUES ($1, $2, $3, $4, $5, $6, $7)
RETURNING id, media_item_id, user_id, selection_text, start_position, end_position, color, note_id, created_at, updated_at
`

type CreateEbookHighlightParams struct {
	MediaItemID   pgtype.UUID `db:"media_item_id" json:"media_item_id"`
	UserID        pgtype.UUID `db:"user_id" json:"user_id"`
	SelectionText string      `db:"selection_text" json:"selection_text"`
	StartPosition pgtype.Text `db:"start_position" json:"start_position"`
	EndPosition   pgtype.Text `db:"end_position" json:"end_position"`
	Color         pgtype.Text `db:"color" json:"color"`
	NoteID        pgtype.UUID `db:"note_id" json:"note_id"`
}

// Backward compatibility - Ebook Highlights queries (using views)
func (q *Queries) CreateEbookHighlight(ctx context.Context, arg CreateEbookHighlightParams) (MediaHighlights, error) {
	row := q.db.QueryRow(ctx, CreateEbookHighlight,
		arg.MediaItemID,
		arg.UserID,
		arg.SelectionText,
		arg.StartPosition,
		arg.EndPosition,
		arg.Color,
		arg.NoteID,
	)
	var i MediaHighlights
	err := row.Scan(
		&i.ID,
		&i.MediaItemID,
		&i.UserID,
		&i.SelectionText,
		&i.StartPosition,
		&i.EndPosition,
		&i.Color,
		&i.NoteID,
		&i.CreatedAt,
		&i.UpdatedAt,
	)
	return i, err
}

const CreateEbookNote = `-- name: CreateEbookNote :one
INSERT INTO media_notes (media_item_id, user_id, content, position)
VALUES ($1, $2, $3, $4)
RETURNING id, media_item_id, user_id, content, position, created_at, updated_at
`

type CreateEbookNoteParams struct {
	MediaItemID pgtype.UUID `db:"media_item_id" json:"media_item_id"`
	UserID      pgtype.UUID `db:"user_id" json:"user_id"`
	Content     string      `db:"content" json:"content"`
	Position    pgtype.Text `db:"position" json:"position"`
}

// Backward compatibility - Ebook Notes queries (using views)
func (q *Queries) CreateEbookNote(ctx context.Context, arg CreateEbookNoteParams) (MediaNotes, error) {
	row := q.db.QueryRow(ctx, CreateEbookNote,
		arg.MediaItemID,
		arg.UserID,
		arg.Content,
		arg.Position,
	)
	var i MediaNotes
	err := row.Scan(
		&i.ID,
		&i.MediaItemID,
		&i.UserID,
		&i.Content,
		&i.Position,
		&i.CreatedAt,
		&i.UpdatedAt,
	)
	return i, err
}

const CreateEbookRating = `-- name: CreateEbookRating :one
INSERT INTO media_ratings (media_item_id, user_id, rating)
VALUES ($1, $2, $3)
ON CONFLICT (media_item_id, user_id)
DO UPDATE SET
    rating = EXCLUDED.rating,
    updated_at = NOW()
RETURNING id, media_item_id, user_id, rating, created_at, updated_at
`

type CreateEbookRatingParams struct {
	MediaItemID pgtype.UUID `db:"media_item_id" json:"media_item_id"`
	UserID      pgtype.UUID `db:"user_id" json:"user_id"`
	Rating      int32       `db:"rating" json:"rating"`
}

// Backward compatibility - Ebooks ratings (using views)
func (q *Queries) CreateEbookRating(ctx context.Context, arg CreateEbookRatingParams) (MediaRatings, error) {
	row := q.db.QueryRow(ctx, CreateEbookRating, arg.MediaItemID, arg.UserID, arg.Rating)
	var i MediaRatings
	err := row.Scan(
		&i.ID,
		&i.MediaItemID,
		&i.UserID,
		&i.Rating,
		&i.CreatedAt,
		&i.UpdatedAt,
	)
	return i, err
}

const CreateLibrary = `-- name: CreateLibrary :one
INSERT INTO libraries (name, description, library_type_id, created_by_admin_id)
VALUES ($1, $2, $3, $4)
RETURNING id, name, description, library_type_id, created_by_admin_id, created_at, updated_at
`

type CreateLibraryParams struct {
	Name             string      `db:"name" json:"name"`
	Description      pgtype.Text `db:"description" json:"description"`
	LibraryTypeID    pgtype.UUID `db:"library_type_id" json:"library_type_id"`
	CreatedByAdminID pgtype.UUID `db:"created_by_admin_id" json:"created_by_admin_id"`
}

// Libraries queries
func (q *Queries) CreateLibrary(ctx context.Context, arg CreateLibraryParams) (Libraries, error) {
	row := q.db.QueryRow(ctx, CreateLibrary,
		arg.Name,
		arg.Description,
		arg.LibraryTypeID,
		arg.CreatedByAdminID,
	)
	var i Libraries
	err := row.Scan(
		&i.ID,
		&i.Name,
		&i.Description,
		&i.LibraryTypeID,
		&i.CreatedByAdminID,
		&i.CreatedAt,
		&i.UpdatedAt,
	)
	return i, err
}

const CreateMediaHighlight = `-- name: CreateMediaHighlight :one
INSERT INTO media_highlights (media_item_id, user_id, selection_text, start_position, end_position, color, note_id)
VALUES ($1, $2, $3, $4, $5, $6, $7)
RETURNING id, media_item_id, user_id, selection_text, start_position, end_position, color, note_id, created_at, updated_at
`

type CreateMediaHighlightParams struct {
	MediaItemID   pgtype.UUID `db:"media_item_id" json:"media_item_id"`
	UserID        pgtype.UUID `db:"user_id" json:"user_id"`
	SelectionText string      `db:"selection_text" json:"selection_text"`
	StartPosition pgtype.Text `db:"start_position" json:"start_position"`
	EndPosition   pgtype.Text `db:"end_position" json:"end_position"`
	Color         pgtype.Text `db:"color" json:"color"`
	NoteID        pgtype.UUID `db:"note_id" json:"note_id"`
}

// Media Highlights queries
func (q *Queries) CreateMediaHighlight(ctx context.Context, arg CreateMediaHighlightParams) (MediaHighlights, error) {
	row := q.db.QueryRow(ctx, CreateMediaHighlight,
		arg.MediaItemID,
		arg.UserID,
		arg.SelectionText,
		arg.StartPosition,
		arg.EndPosition,
		arg.Color,
		arg.NoteID,
	)
	var i MediaHighlights
	err := row.Scan(
		&i.ID,
		&i.MediaItemID,
		&i.UserID,
		&i.SelectionText,
		&i.StartPosition,
		&i.EndPosition,
		&i.Color,
		&i.NoteID,
		&i.CreatedAt,
		&i.UpdatedAt,
	)
	return i, err
}

const CreateMediaItem = `-- name: CreateMediaItem :one
INSERT INTO media_items (library_id, title, author, isbn, description, file_path, file_size, mime_type, cover_image_path, series, series_number, tags, asin, date_published, publisher, contributors, added_by_admin_id)
VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13, $14, $15, $16, $17)
RETURNING id, library_id, title, author, isbn, description, file_path, file_size, mime_type, cover_image_path, series, series_number, tags, asin, date_published, publisher, contributors, added_by_admin_id, created_at, updated_at
`

type CreateMediaItemParams struct {
	LibraryID      pgtype.UUID `db:"library_id" json:"library_id"`
	Title          string      `db:"title" json:"title"`
	Author         pgtype.Text `db:"author" json:"author"`
	Isbn           pgtype.Text `db:"isbn" json:"isbn"`
	Description    pgtype.Text `db:"description" json:"description"`
	FilePath       string      `db:"file_path" json:"file_path"`
	FileSize       pgtype.Int8 `db:"file_size" json:"file_size"`
	MimeType       pgtype.Text `db:"mime_type" json:"mime_type"`
	CoverImagePath pgtype.Text `db:"cover_image_path" json:"cover_image_path"`
	Series         pgtype.Text `db:"series" json:"series"`
	SeriesNumber   pgtype.Int4 `db:"series_number" json:"series_number"`
	Tags           pgtype.Text `db:"tags" json:"tags"`
	Asin           pgtype.Text `db:"asin" json:"asin"`
	DatePublished  pgtype.Date `db:"date_published" json:"date_published"`
	Publisher      pgtype.Text `db:"publisher" json:"publisher"`
	Contributors   pgtype.Text `db:"contributors" json:"contributors"`
	AddedByAdminID pgtype.UUID `db:"added_by_admin_id" json:"added_by_admin_id"`
}

// Media Items queries
func (q *Queries) CreateMediaItem(ctx context.Context, arg CreateMediaItemParams) (MediaItems, error) {
	row := q.db.QueryRow(ctx, CreateMediaItem,
		arg.LibraryID,
		arg.Title,
		arg.Author,
		arg.Isbn,
		arg.Description,
		arg.FilePath,
		arg.FileSize,
		arg.MimeType,
		arg.CoverImagePath,
		arg.Series,
		arg.SeriesNumber,
		arg.Tags,
		arg.Asin,
		arg.DatePublished,
		arg.Publisher,
		arg.Contributors,
		arg.AddedByAdminID,
	)
	var i MediaItems
	err := row.Scan(
		&i.ID,
		&i.LibraryID,
		&i.Title,
		&i.Author,
		&i.Isbn,
		&i.Description,
		&i.FilePath,
		&i.FileSize,
		&i.MimeType,
		&i.CoverImagePath,
		&i.Series,
		&i.SeriesNumber,
		&i.Tags,
		&i.Asin,
		&i.DatePublished,
		&i.Publisher,
		&i.Contributors,
		&i.AddedByAdminID,
		&i.CreatedAt,
		&i.UpdatedAt,
	)
	return i, err
}

const CreateMediaNote = `-- name: CreateMediaNote :one
INSERT INTO media_notes (media_item_id, user_id, content, position)
VALUES ($1, $2, $3, $4)
RETURNING id, media_item_id, user_id, content, position, created_at, updated_at
`

type CreateMediaNoteParams struct {
	MediaItemID pgtype.UUID `db:"media_item_id" json:"media_item_id"`
	UserID      pgtype.UUID `db:"user_id" json:"user_id"`
	Content     string      `db:"content" json:"content"`
	Position    pgtype.Text `db:"position" json:"position"`
}

// Media Notes queries
func (q *Queries) CreateMediaNote(ctx context.Context, arg CreateMediaNoteParams) (MediaNotes, error) {
	row := q.db.QueryRow(ctx, CreateMediaNote,
		arg.MediaItemID,
		arg.UserID,
		arg.Content,
		arg.Position,
	)
	var i MediaNotes
	err := row.Scan(
		&i.ID,
		&i.MediaItemID,
		&i.UserID,
		&i.Content,
		&i.Position,
		&i.CreatedAt,
		&i.UpdatedAt,
	)
	return i, err
}

const CreateMediaRating = `-- name: CreateMediaRating :one
INSERT INTO media_ratings (media_item_id, user_id, rating)
VALUES ($1, $2, $3)
ON CONFLICT (media_item_id, user_id)
DO UPDATE SET
    rating = EXCLUDED.rating,
    updated_at = NOW()
RETURNING id, media_item_id, user_id, rating, created_at, updated_at
`

type CreateMediaRatingParams struct {
	MediaItemID pgtype.UUID `db:"media_item_id" json:"media_item_id"`
	UserID      pgtype.UUID `db:"user_id" json:"user_id"`
	Rating      int32       `db:"rating" json:"rating"`
}

func (q *Queries) CreateMediaRating(ctx context.Context, arg CreateMediaRatingParams) (MediaRatings, error) {
	row := q.db.QueryRow(ctx, CreateMediaRating, arg.MediaItemID, arg.UserID, arg.Rating)
	var i MediaRatings
	err := row.Scan(
		&i.ID,
		&i.MediaItemID,
		&i.UserID,
		&i.Rating,
		&i.CreatedAt,
		&i.UpdatedAt,
	)
	return i, err
}

const CreateRefreshToken = `-- name: CreateRefreshToken :one
INSERT INTO refresh_tokens (user_id, token, expires_at)
VALUES ($1, $2, $3)
RETURNING id, user_id, token, expires_at, created_at, revoked_at
`

type CreateRefreshTokenParams struct {
	UserID    pgtype.UUID        `db:"user_id" json:"user_id"`
	Token     string             `db:"token" json:"token"`
	ExpiresAt pgtype.Timestamptz `db:"expires_at" json:"expires_at"`
}

// Refresh Tokens queries
func (q *Queries) CreateRefreshToken(ctx context.Context, arg CreateRefreshTokenParams) (RefreshTokens, error) {
	row := q.db.QueryRow(ctx, CreateRefreshToken, arg.UserID, arg.Token, arg.ExpiresAt)
	var i RefreshTokens
	err := row.Scan(
		&i.ID,
		&i.UserID,
		&i.Token,
		&i.ExpiresAt,
		&i.CreatedAt,
		&i.RevokedAt,
	)
	return i, err
}

const CreateUser = `-- name: CreateUser :one
INSERT INTO users (email, username, password_hash, first_name, last_name, theme, role)
VALUES ($1, $2, $3, $4, $5, $6, $7)
RETURNING id, email, username, theme, first_name, last_name, role, created_at, updated_at
`

type CreateUserParams struct {
	Email        string      `db:"email" json:"email"`
	Username     string      `db:"username" json:"username"`
	PasswordHash string      `db:"password_hash" json:"password_hash"`
	FirstName    pgtype.Text `db:"first_name" json:"first_name"`
	LastName     pgtype.Text `db:"last_name" json:"last_name"`
	Theme        pgtype.Text `db:"theme" json:"theme"`
	Role         string      `db:"role" json:"role"`
}

type CreateUserRow struct {
	ID        pgtype.UUID        `db:"id" json:"id"`
	Email     string             `db:"email" json:"email"`
	Username  string             `db:"username" json:"username"`
	Theme     pgtype.Text        `db:"theme" json:"theme"`
	FirstName pgtype.Text        `db:"first_name" json:"first_name"`
	LastName  pgtype.Text        `db:"last_name" json:"last_name"`
	Role      string             `db:"role" json:"role"`
	CreatedAt pgtype.Timestamptz `db:"created_at" json:"created_at"`
	UpdatedAt pgtype.Timestamptz `db:"updated_at" json:"updated_at"`
}

func (q *Queries) CreateUser(ctx context.Context, arg CreateUserParams) (CreateUserRow, error) {
	row := q.db.QueryRow(ctx, CreateUser,
		arg.Email,
		arg.Username,
		arg.PasswordHash,
		arg.FirstName,
		arg.LastName,
		arg.Theme,
		arg.Role,
	)
	var i CreateUserRow
	err := row.Scan(
		&i.ID,
		&i.Email,
		&i.Username,
		&i.Theme,
		&i.FirstName,
		&i.LastName,
		&i.Role,
		&i.CreatedAt,
		&i.UpdatedAt,
	)
	return i, err
}

const DeleteEbook = `-- name: DeleteEbook :exec
DELETE FROM media_items WHERE id = $1
`

func (q *Queries) DeleteEbook(ctx context.Context, id pgtype.UUID) error {
	_, err := q.db.Exec(ctx, DeleteEbook, id)
	return err
}

const DeleteEbookHighlight = `-- name: DeleteEbookHighlight :exec
DELETE FROM media_highlights WHERE id = $1
`

func (q *Queries) DeleteEbookHighlight(ctx context.Context, id pgtype.UUID) error {
	_, err := q.db.Exec(ctx, DeleteEbookHighlight, id)
	return err
}

const DeleteEbookNote = `-- name: DeleteEbookNote :exec
DELETE FROM media_notes WHERE id = $1
`

func (q *Queries) DeleteEbookNote(ctx context.Context, id pgtype.UUID) error {
	_, err := q.db.Exec(ctx, DeleteEbookNote, id)
	return err
}

const DeleteEbookRating = `-- name: DeleteEbookRating :exec
DELETE FROM media_ratings WHERE media_item_id = $1 AND user_id = $2
`

type DeleteEbookRatingParams struct {
	MediaItemID pgtype.UUID `db:"media_item_id" json:"media_item_id"`
	UserID      pgtype.UUID `db:"user_id" json:"user_id"`
}

func (q *Queries) DeleteEbookRating(ctx context.Context, arg DeleteEbookRatingParams) error {
	_, err := q.db.Exec(ctx, DeleteEbookRating, arg.MediaItemID, arg.UserID)
	return err
}

const DeleteLibrary = `-- name: DeleteLibrary :exec
DELETE FROM libraries WHERE id = $1
`

func (q *Queries) DeleteLibrary(ctx context.Context, id pgtype.UUID) error {
	_, err := q.db.Exec(ctx, DeleteLibrary, id)
	return err
}

const DeleteLibraryFolder = `-- name: DeleteLibraryFolder :one
DELETE FROM library_folders WHERE library_id = $1 AND folder_path = $2 RETURNING id, library_id, folder_path, created_at
`

type DeleteLibraryFolderParams struct {
	LibraryID  pgtype.UUID `db:"library_id" json:"library_id"`
	FolderPath string      `db:"folder_path" json:"folder_path"`
}

func (q *Queries) DeleteLibraryFolder(ctx context.Context, arg DeleteLibraryFolderParams) (LibraryFolders, error) {
	row := q.db.QueryRow(ctx, DeleteLibraryFolder, arg.LibraryID, arg.FolderPath)
	var i LibraryFolders
	err := row.Scan(
		&i.ID,
		&i.LibraryID,
		&i.FolderPath,
		&i.CreatedAt,
	)
	return i, err
}

const DeleteMediaHighlight = `-- name: DeleteMediaHighlight :exec
DELETE FROM media_highlights WHERE id = $1
`

func (q *Queries) DeleteMediaHighlight(ctx context.Context, id pgtype.UUID) error {
	_, err := q.db.Exec(ctx, DeleteMediaHighlight, id)
	return err
}

const DeleteMediaItem = `-- name: DeleteMediaItem :exec
DELETE FROM media_items WHERE id = $1
`

func (q *Queries) DeleteMediaItem(ctx context.Context, id pgtype.UUID) error {
	_, err := q.db.Exec(ctx, DeleteMediaItem, id)
	return err
}

const DeleteMediaNote = `-- name: DeleteMediaNote :exec
DELETE FROM media_notes WHERE id = $1
`

func (q *Queries) DeleteMediaNote(ctx context.Context, id pgtype.UUID) error {
	_, err := q.db.Exec(ctx, DeleteMediaNote, id)
	return err
}

const DeleteMediaRating = `-- name: DeleteMediaRating :exec
DELETE FROM media_ratings WHERE media_item_id = $1 AND user_id = $2
`

type DeleteMediaRatingParams struct {
	MediaItemID pgtype.UUID `db:"media_item_id" json:"media_item_id"`
	UserID      pgtype.UUID `db:"user_id" json:"user_id"`
}

func (q *Queries) DeleteMediaRating(ctx context.Context, arg DeleteMediaRatingParams) error {
	_, err := q.db.Exec(ctx, DeleteMediaRating, arg.MediaItemID, arg.UserID)
	return err
}

const DeleteReadingProgress = `-- name: DeleteReadingProgress :exec
DELETE FROM reading_progress WHERE media_item_id = $1 AND user_id = $2
`

type DeleteReadingProgressParams struct {
	MediaItemID pgtype.UUID `db:"media_item_id" json:"media_item_id"`
	UserID      pgtype.UUID `db:"user_id" json:"user_id"`
}

func (q *Queries) DeleteReadingProgress(ctx context.Context, arg DeleteReadingProgressParams) error {
	_, err := q.db.Exec(ctx, DeleteReadingProgress, arg.MediaItemID, arg.UserID)
	return err
}

const DeleteUser = `-- name: DeleteUser :exec
DELETE FROM users WHERE id = $1
`

func (q *Queries) DeleteUser(ctx context.Context, id pgtype.UUID) error {
	_, err := q.db.Exec(ctx, DeleteUser, id)
	return err
}

const GetEbook = `-- name: GetEbook :one
SELECT id, library_id, title, author, isbn, description, file_path, file_size, mime_type, cover_image_path, series, series_number, tags, asin, date_published, publisher, contributors, added_by_admin_id, created_at, updated_at FROM ebooks WHERE id = $1
`

// Backward compatibility - Ebooks queries (using views)
func (q *Queries) GetEbook(ctx context.Context, id pgtype.UUID) (Ebooks, error) {
	row := q.db.QueryRow(ctx, GetEbook, id)
	var i Ebooks
	err := row.Scan(
		&i.ID,
		&i.LibraryID,
		&i.Title,
		&i.Author,
		&i.Isbn,
		&i.Description,
		&i.FilePath,
		&i.FileSize,
		&i.MimeType,
		&i.CoverImagePath,
		&i.Series,
		&i.SeriesNumber,
		&i.Tags,
		&i.Asin,
		&i.DatePublished,
		&i.Publisher,
		&i.Contributors,
		&i.AddedByAdminID,
		&i.CreatedAt,
		&i.UpdatedAt,
	)
	return i, err
}

const GetEbookByFilePath = `-- name: GetEbookByFilePath :one

SELECT id, library_id, title, author, isbn, description, file_path, file_size, mime_type, cover_image_path, series, series_number, tags, asin, date_published, publisher, contributors, added_by_admin_id, created_at, updated_at FROM ebooks WHERE file_path = $1
`

// Note: User ebook folders replaced by library folders system
// Legacy folder management is now handled through libraries
func (q *Queries) GetEbookByFilePath(ctx context.Context, filePath string) (Ebooks, error) {
	row := q.db.QueryRow(ctx, GetEbookByFilePath, filePath)
	var i Ebooks
	err := row.Scan(
		&i.ID,
		&i.LibraryID,
		&i.Title,
		&i.Author,
		&i.Isbn,
		&i.Description,
		&i.FilePath,
		&i.FileSize,
		&i.MimeType,
		&i.CoverImagePath,
		&i.Series,
		&i.SeriesNumber,
		&i.Tags,
		&i.Asin,
		&i.DatePublished,
		&i.Publisher,
		&i.Contributors,
		&i.AddedByAdminID,
		&i.CreatedAt,
		&i.UpdatedAt,
	)
	return i, err
}

const GetEbookHighlight = `-- name: GetEbookHighlight :one
SELECT id, media_item_id, user_id, selection_text, start_position, end_position, color, note_id, created_at, updated_at, ebook_id FROM ebook_highlights WHERE id = $1
`

func (q *Queries) GetEbookHighlight(ctx context.Context, id pgtype.UUID) (EbookHighlights, error) {
	row := q.db.QueryRow(ctx, GetEbookHighlight, id)
	var i EbookHighlights
	err := row.Scan(
		&i.ID,
		&i.MediaItemID,
		&i.UserID,
		&i.SelectionText,
		&i.StartPosition,
		&i.EndPosition,
		&i.Color,
		&i.NoteID,
		&i.CreatedAt,
		&i.UpdatedAt,
		&i.EbookID,
	)
	return i, err
}

const GetEbookHighlights = `-- name: GetEbookHighlights :many
SELECT id, media_item_id, user_id, selection_text, start_position, end_position, color, note_id, created_at, updated_at, ebook_id FROM ebook_highlights WHERE ebook_id = $1 AND user_id = $2 ORDER BY created_at DESC
`

type GetEbookHighlightsParams struct {
	EbookID pgtype.UUID `db:"ebook_id" json:"ebook_id"`
	UserID  pgtype.UUID `db:"user_id" json:"user_id"`
}

func (q *Queries) GetEbookHighlights(ctx context.Context, arg GetEbookHighlightsParams) ([]EbookHighlights, error) {
	rows, err := q.db.Query(ctx, GetEbookHighlights, arg.EbookID, arg.UserID)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	items := []EbookHighlights{}
	for rows.Next() {
		var i EbookHighlights
		if err := rows.Scan(
			&i.ID,
			&i.MediaItemID,
			&i.UserID,
			&i.SelectionText,
			&i.StartPosition,
			&i.EndPosition,
			&i.Color,
			&i.NoteID,
			&i.CreatedAt,
			&i.UpdatedAt,
			&i.EbookID,
		); err != nil {
			return nil, err
		}
		items = append(items, i)
	}
	if err := rows.Err(); err != nil {
		return nil, err
	}
	return items, nil
}

const GetEbookNote = `-- name: GetEbookNote :one
SELECT id, media_item_id, user_id, content, position, created_at, updated_at, ebook_id FROM ebook_notes WHERE id = $1
`

func (q *Queries) GetEbookNote(ctx context.Context, id pgtype.UUID) (EbookNotes, error) {
	row := q.db.QueryRow(ctx, GetEbookNote, id)
	var i EbookNotes
	err := row.Scan(
		&i.ID,
		&i.MediaItemID,
		&i.UserID,
		&i.Content,
		&i.Position,
		&i.CreatedAt,
		&i.UpdatedAt,
		&i.EbookID,
	)
	return i, err
}

const GetEbookNotes = `-- name: GetEbookNotes :many
SELECT id, media_item_id, user_id, content, position, created_at, updated_at, ebook_id FROM ebook_notes WHERE ebook_id = $1 AND user_id = $2 ORDER BY created_at DESC
`

type GetEbookNotesParams struct {
	EbookID pgtype.UUID `db:"ebook_id" json:"ebook_id"`
	UserID  pgtype.UUID `db:"user_id" json:"user_id"`
}

func (q *Queries) GetEbookNotes(ctx context.Context, arg GetEbookNotesParams) ([]EbookNotes, error) {
	rows, err := q.db.Query(ctx, GetEbookNotes, arg.EbookID, arg.UserID)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	items := []EbookNotes{}
	for rows.Next() {
		var i EbookNotes
		if err := rows.Scan(
			&i.ID,
			&i.MediaItemID,
			&i.UserID,
			&i.Content,
			&i.Position,
			&i.CreatedAt,
			&i.UpdatedAt,
			&i.EbookID,
		); err != nil {
			return nil, err
		}
		items = append(items, i)
	}
	if err := rows.Err(); err != nil {
		return nil, err
	}
	return items, nil
}

const GetEbookRating = `-- name: GetEbookRating :one
SELECT id, media_item_id, user_id, rating, created_at, updated_at, ebook_id FROM ebook_ratings WHERE ebook_id = $1 AND user_id = $2
`

type GetEbookRatingParams struct {
	EbookID pgtype.UUID `db:"ebook_id" json:"ebook_id"`
	UserID  pgtype.UUID `db:"user_id" json:"user_id"`
}

func (q *Queries) GetEbookRating(ctx context.Context, arg GetEbookRatingParams) (EbookRatings, error) {
	row := q.db.QueryRow(ctx, GetEbookRating, arg.EbookID, arg.UserID)
	var i EbookRatings
	err := row.Scan(
		&i.ID,
		&i.MediaItemID,
		&i.UserID,
		&i.Rating,
		&i.CreatedAt,
		&i.UpdatedAt,
		&i.EbookID,
	)
	return i, err
}

const GetEbookRatings = `-- name: GetEbookRatings :many
SELECT er.id, er.media_item_id, er.user_id, er.rating, er.created_at, er.updated_at, er.ebook_id, u.username
FROM ebook_ratings er
JOIN users u ON er.user_id = u.id
WHERE er.ebook_id = $1
ORDER BY er.created_at DESC
`

type GetEbookRatingsRow struct {
	ID          pgtype.UUID        `db:"id" json:"id"`
	MediaItemID pgtype.UUID        `db:"media_item_id" json:"media_item_id"`
	UserID      pgtype.UUID        `db:"user_id" json:"user_id"`
	Rating      int32              `db:"rating" json:"rating"`
	CreatedAt   pgtype.Timestamptz `db:"created_at" json:"created_at"`
	UpdatedAt   pgtype.Timestamptz `db:"updated_at" json:"updated_at"`
	EbookID     pgtype.UUID        `db:"ebook_id" json:"ebook_id"`
	Username    string             `db:"username" json:"username"`
}

func (q *Queries) GetEbookRatings(ctx context.Context, ebookID pgtype.UUID) ([]GetEbookRatingsRow, error) {
	rows, err := q.db.Query(ctx, GetEbookRatings, ebookID)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	items := []GetEbookRatingsRow{}
	for rows.Next() {
		var i GetEbookRatingsRow
		if err := rows.Scan(
			&i.ID,
			&i.MediaItemID,
			&i.UserID,
			&i.Rating,
			&i.CreatedAt,
			&i.UpdatedAt,
			&i.EbookID,
			&i.Username,
		); err != nil {
			return nil, err
		}
		items = append(items, i)
	}
	if err := rows.Err(); err != nil {
		return nil, err
	}
	return items, nil
}

const GetLibrary = `-- name: GetLibrary :one
SELECT l.id, l.name, l.description, l.library_type_id, l.created_by_admin_id, l.created_at, l.updated_at, lt.name as type_name, lt.description as type_description
FROM libraries l
JOIN library_types lt ON l.library_type_id = lt.id
WHERE l.id = $1
`

type GetLibraryRow struct {
	ID               pgtype.UUID        `db:"id" json:"id"`
	Name             string             `db:"name" json:"name"`
	Description      pgtype.Text        `db:"description" json:"description"`
	LibraryTypeID    pgtype.UUID        `db:"library_type_id" json:"library_type_id"`
	CreatedByAdminID pgtype.UUID        `db:"created_by_admin_id" json:"created_by_admin_id"`
	CreatedAt        pgtype.Timestamptz `db:"created_at" json:"created_at"`
	UpdatedAt        pgtype.Timestamptz `db:"updated_at" json:"updated_at"`
	TypeName         string             `db:"type_name" json:"type_name"`
	TypeDescription  pgtype.Text        `db:"type_description" json:"type_description"`
}

func (q *Queries) GetLibrary(ctx context.Context, id pgtype.UUID) (GetLibraryRow, error) {
	row := q.db.QueryRow(ctx, GetLibrary, id)
	var i GetLibraryRow
	err := row.Scan(
		&i.ID,
		&i.Name,
		&i.Description,
		&i.LibraryTypeID,
		&i.CreatedByAdminID,
		&i.CreatedAt,
		&i.UpdatedAt,
		&i.TypeName,
		&i.TypeDescription,
	)
	return i, err
}

const GetLibraryFolders = `-- name: GetLibraryFolders :many
SELECT id, library_id, folder_path, created_at FROM library_folders WHERE library_id = $1 ORDER BY created_at
`

func (q *Queries) GetLibraryFolders(ctx context.Context, libraryID pgtype.UUID) ([]LibraryFolders, error) {
	rows, err := q.db.Query(ctx, GetLibraryFolders, libraryID)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	items := []LibraryFolders{}
	for rows.Next() {
		var i LibraryFolders
		if err := rows.Scan(
			&i.ID,
			&i.LibraryID,
			&i.FolderPath,
			&i.CreatedAt,
		); err != nil {
			return nil, err
		}
		items = append(items, i)
	}
	if err := rows.Err(); err != nil {
		return nil, err
	}
	return items, nil
}

const GetLibraryType = `-- name: GetLibraryType :one
SELECT id, name, description, allowed_extensions, created_at FROM library_types WHERE id = $1
`

func (q *Queries) GetLibraryType(ctx context.Context, id pgtype.UUID) (LibraryTypes, error) {
	row := q.db.QueryRow(ctx, GetLibraryType, id)
	var i LibraryTypes
	err := row.Scan(
		&i.ID,
		&i.Name,
		&i.Description,
		&i.AllowedExtensions,
		&i.CreatedAt,
	)
	return i, err
}

const GetLibraryTypeByName = `-- name: GetLibraryTypeByName :one
SELECT id, name, description, allowed_extensions, created_at FROM library_types WHERE name = $1
`

func (q *Queries) GetLibraryTypeByName(ctx context.Context, name string) (LibraryTypes, error) {
	row := q.db.QueryRow(ctx, GetLibraryTypeByName, name)
	var i LibraryTypes
	err := row.Scan(
		&i.ID,
		&i.Name,
		&i.Description,
		&i.AllowedExtensions,
		&i.CreatedAt,
	)
	return i, err
}

const GetLibraryTypes = `-- name: GetLibraryTypes :many
SELECT id, name, description, allowed_extensions, created_at FROM library_types ORDER BY name
`

// Library Types queries
func (q *Queries) GetLibraryTypes(ctx context.Context) ([]LibraryTypes, error) {
	rows, err := q.db.Query(ctx, GetLibraryTypes)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	items := []LibraryTypes{}
	for rows.Next() {
		var i LibraryTypes
		if err := rows.Scan(
			&i.ID,
			&i.Name,
			&i.Description,
			&i.AllowedExtensions,
			&i.CreatedAt,
		); err != nil {
			return nil, err
		}
		items = append(items, i)
	}
	if err := rows.Err(); err != nil {
		return nil, err
	}
	return items, nil
}

const GetLibraryVisibility = `-- name: GetLibraryVisibility :one
SELECT id, user_id, library_id, is_visible, created_at, updated_at FROM library_visibility WHERE user_id = $1 AND library_id = $2
`

type GetLibraryVisibilityParams struct {
	UserID    pgtype.UUID `db:"user_id" json:"user_id"`
	LibraryID pgtype.UUID `db:"library_id" json:"library_id"`
}

func (q *Queries) GetLibraryVisibility(ctx context.Context, arg GetLibraryVisibilityParams) (LibraryVisibility, error) {
	row := q.db.QueryRow(ctx, GetLibraryVisibility, arg.UserID, arg.LibraryID)
	var i LibraryVisibility
	err := row.Scan(
		&i.ID,
		&i.UserID,
		&i.LibraryID,
		&i.IsVisible,
		&i.CreatedAt,
		&i.UpdatedAt,
	)
	return i, err
}

const GetMediaHighlight = `-- name: GetMediaHighlight :one
SELECT id, media_item_id, user_id, selection_text, start_position, end_position, color, note_id, created_at, updated_at FROM media_highlights WHERE id = $1
`

func (q *Queries) GetMediaHighlight(ctx context.Context, id pgtype.UUID) (MediaHighlights, error) {
	row := q.db.QueryRow(ctx, GetMediaHighlight, id)
	var i MediaHighlights
	err := row.Scan(
		&i.ID,
		&i.MediaItemID,
		&i.UserID,
		&i.SelectionText,
		&i.StartPosition,
		&i.EndPosition,
		&i.Color,
		&i.NoteID,
		&i.CreatedAt,
		&i.UpdatedAt,
	)
	return i, err
}

const GetMediaHighlights = `-- name: GetMediaHighlights :many
SELECT id, media_item_id, user_id, selection_text, start_position, end_position, color, note_id, created_at, updated_at FROM media_highlights WHERE media_item_id = $1 AND user_id = $2 ORDER BY created_at DESC
`

type GetMediaHighlightsParams struct {
	MediaItemID pgtype.UUID `db:"media_item_id" json:"media_item_id"`
	UserID      pgtype.UUID `db:"user_id" json:"user_id"`
}

func (q *Queries) GetMediaHighlights(ctx context.Context, arg GetMediaHighlightsParams) ([]MediaHighlights, error) {
	rows, err := q.db.Query(ctx, GetMediaHighlights, arg.MediaItemID, arg.UserID)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	items := []MediaHighlights{}
	for rows.Next() {
		var i MediaHighlights
		if err := rows.Scan(
			&i.ID,
			&i.MediaItemID,
			&i.UserID,
			&i.SelectionText,
			&i.StartPosition,
			&i.EndPosition,
			&i.Color,
			&i.NoteID,
			&i.CreatedAt,
			&i.UpdatedAt,
		); err != nil {
			return nil, err
		}
		items = append(items, i)
	}
	if err := rows.Err(); err != nil {
		return nil, err
	}
	return items, nil
}

const GetMediaItem = `-- name: GetMediaItem :one
SELECT id, library_id, title, author, isbn, description, file_path, file_size, mime_type, cover_image_path, series, series_number, tags, asin, date_published, publisher, contributors, added_by_admin_id, created_at, updated_at FROM media_items WHERE id = $1
`

func (q *Queries) GetMediaItem(ctx context.Context, id pgtype.UUID) (MediaItems, error) {
	row := q.db.QueryRow(ctx, GetMediaItem, id)
	var i MediaItems
	err := row.Scan(
		&i.ID,
		&i.LibraryID,
		&i.Title,
		&i.Author,
		&i.Isbn,
		&i.Description,
		&i.FilePath,
		&i.FileSize,
		&i.MimeType,
		&i.CoverImagePath,
		&i.Series,
		&i.SeriesNumber,
		&i.Tags,
		&i.Asin,
		&i.DatePublished,
		&i.Publisher,
		&i.Contributors,
		&i.AddedByAdminID,
		&i.CreatedAt,
		&i.UpdatedAt,
	)
	return i, err
}

const GetMediaItemByFilePath = `-- name: GetMediaItemByFilePath :one
SELECT id, library_id, title, author, isbn, description, file_path, file_size, mime_type, cover_image_path, series, series_number, tags, asin, date_published, publisher, contributors, added_by_admin_id, created_at, updated_at FROM media_items WHERE file_path = $1
`

func (q *Queries) GetMediaItemByFilePath(ctx context.Context, filePath string) (MediaItems, error) {
	row := q.db.QueryRow(ctx, GetMediaItemByFilePath, filePath)
	var i MediaItems
	err := row.Scan(
		&i.ID,
		&i.LibraryID,
		&i.Title,
		&i.Author,
		&i.Isbn,
		&i.Description,
		&i.FilePath,
		&i.FileSize,
		&i.MimeType,
		&i.CoverImagePath,
		&i.Series,
		&i.SeriesNumber,
		&i.Tags,
		&i.Asin,
		&i.DatePublished,
		&i.Publisher,
		&i.Contributors,
		&i.AddedByAdminID,
		&i.CreatedAt,
		&i.UpdatedAt,
	)
	return i, err
}

const GetMediaNote = `-- name: GetMediaNote :one
SELECT id, media_item_id, user_id, content, position, created_at, updated_at FROM media_notes WHERE id = $1
`

func (q *Queries) GetMediaNote(ctx context.Context, id pgtype.UUID) (MediaNotes, error) {
	row := q.db.QueryRow(ctx, GetMediaNote, id)
	var i MediaNotes
	err := row.Scan(
		&i.ID,
		&i.MediaItemID,
		&i.UserID,
		&i.Content,
		&i.Position,
		&i.CreatedAt,
		&i.UpdatedAt,
	)
	return i, err
}

const GetMediaNotes = `-- name: GetMediaNotes :many
SELECT id, media_item_id, user_id, content, position, created_at, updated_at FROM media_notes WHERE media_item_id = $1 AND user_id = $2 ORDER BY created_at DESC
`

type GetMediaNotesParams struct {
	MediaItemID pgtype.UUID `db:"media_item_id" json:"media_item_id"`
	UserID      pgtype.UUID `db:"user_id" json:"user_id"`
}

func (q *Queries) GetMediaNotes(ctx context.Context, arg GetMediaNotesParams) ([]MediaNotes, error) {
	rows, err := q.db.Query(ctx, GetMediaNotes, arg.MediaItemID, arg.UserID)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	items := []MediaNotes{}
	for rows.Next() {
		var i MediaNotes
		if err := rows.Scan(
			&i.ID,
			&i.MediaItemID,
			&i.UserID,
			&i.Content,
			&i.Position,
			&i.CreatedAt,
			&i.UpdatedAt,
		); err != nil {
			return nil, err
		}
		items = append(items, i)
	}
	if err := rows.Err(); err != nil {
		return nil, err
	}
	return items, nil
}

const GetMediaRating = `-- name: GetMediaRating :one
SELECT id, media_item_id, user_id, rating, created_at, updated_at FROM media_ratings WHERE media_item_id = $1 AND user_id = $2
`

type GetMediaRatingParams struct {
	MediaItemID pgtype.UUID `db:"media_item_id" json:"media_item_id"`
	UserID      pgtype.UUID `db:"user_id" json:"user_id"`
}

func (q *Queries) GetMediaRating(ctx context.Context, arg GetMediaRatingParams) (MediaRatings, error) {
	row := q.db.QueryRow(ctx, GetMediaRating, arg.MediaItemID, arg.UserID)
	var i MediaRatings
	err := row.Scan(
		&i.ID,
		&i.MediaItemID,
		&i.UserID,
		&i.Rating,
		&i.CreatedAt,
		&i.UpdatedAt,
	)
	return i, err
}

const GetMediaRatings = `-- name: GetMediaRatings :many
SELECT mr.id, mr.media_item_id, mr.user_id, mr.rating, mr.created_at, mr.updated_at, u.username
FROM media_ratings mr
JOIN users u ON mr.user_id = u.id
WHERE mr.media_item_id = $1
ORDER BY mr.created_at DESC
`

type GetMediaRatingsRow struct {
	ID          pgtype.UUID        `db:"id" json:"id"`
	MediaItemID pgtype.UUID        `db:"media_item_id" json:"media_item_id"`
	UserID      pgtype.UUID        `db:"user_id" json:"user_id"`
	Rating      int32              `db:"rating" json:"rating"`
	CreatedAt   pgtype.Timestamptz `db:"created_at" json:"created_at"`
	UpdatedAt   pgtype.Timestamptz `db:"updated_at" json:"updated_at"`
	Username    string             `db:"username" json:"username"`
}

func (q *Queries) GetMediaRatings(ctx context.Context, mediaItemID pgtype.UUID) ([]GetMediaRatingsRow, error) {
	rows, err := q.db.Query(ctx, GetMediaRatings, mediaItemID)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	items := []GetMediaRatingsRow{}
	for rows.Next() {
		var i GetMediaRatingsRow
		if err := rows.Scan(
			&i.ID,
			&i.MediaItemID,
			&i.UserID,
			&i.Rating,
			&i.CreatedAt,
			&i.UpdatedAt,
			&i.Username,
		); err != nil {
			return nil, err
		}
		items = append(items, i)
	}
	if err := rows.Err(); err != nil {
		return nil, err
	}
	return items, nil
}

const GetReadingProgress = `-- name: GetReadingProgress :one
SELECT id, media_item_id, user_id, current_page, total_pages, last_read_at FROM reading_progress WHERE media_item_id = $1 AND user_id = $2
`

type GetReadingProgressParams struct {
	MediaItemID pgtype.UUID `db:"media_item_id" json:"media_item_id"`
	UserID      pgtype.UUID `db:"user_id" json:"user_id"`
}

func (q *Queries) GetReadingProgress(ctx context.Context, arg GetReadingProgressParams) (ReadingProgress, error) {
	row := q.db.QueryRow(ctx, GetReadingProgress, arg.MediaItemID, arg.UserID)
	var i ReadingProgress
	err := row.Scan(
		&i.ID,
		&i.MediaItemID,
		&i.UserID,
		&i.CurrentPage,
		&i.TotalPages,
		&i.LastReadAt,
	)
	return i, err
}

const GetRefreshToken = `-- name: GetRefreshToken :one
SELECT rt.id, rt.user_id, rt.token, rt.expires_at, rt.created_at, rt.revoked_at, u.email, u.username, u.role
FROM refresh_tokens rt
JOIN users u ON rt.user_id = u.id
WHERE rt.token = $1 AND rt.revoked_at IS NULL AND rt.expires_at > NOW()
`

type GetRefreshTokenRow struct {
	ID        pgtype.UUID        `db:"id" json:"id"`
	UserID    pgtype.UUID        `db:"user_id" json:"user_id"`
	Token     string             `db:"token" json:"token"`
	ExpiresAt pgtype.Timestamptz `db:"expires_at" json:"expires_at"`
	CreatedAt pgtype.Timestamptz `db:"created_at" json:"created_at"`
	RevokedAt pgtype.Timestamptz `db:"revoked_at" json:"revoked_at"`
	Email     string             `db:"email" json:"email"`
	Username  string             `db:"username" json:"username"`
	Role      string             `db:"role" json:"role"`
}

func (q *Queries) GetRefreshToken(ctx context.Context, token string) (GetRefreshTokenRow, error) {
	row := q.db.QueryRow(ctx, GetRefreshToken, token)
	var i GetRefreshTokenRow
	err := row.Scan(
		&i.ID,
		&i.UserID,
		&i.Token,
		&i.ExpiresAt,
		&i.CreatedAt,
		&i.RevokedAt,
		&i.Email,
		&i.Username,
		&i.Role,
	)
	return i, err
}

const GetScanSettings = `-- name: GetScanSettings :one
SELECT scan_frequency_minutes, auto_scan_enabled FROM users WHERE id = $1
`

type GetScanSettingsRow struct {
	ScanFrequencyMinutes pgtype.Int4 `db:"scan_frequency_minutes" json:"scan_frequency_minutes"`
	AutoScanEnabled      pgtype.Bool `db:"auto_scan_enabled" json:"auto_scan_enabled"`
}

func (q *Queries) GetScanSettings(ctx context.Context, id pgtype.UUID) (GetScanSettingsRow, error) {
	row := q.db.QueryRow(ctx, GetScanSettings, id)
	var i GetScanSettingsRow
	err := row.Scan(&i.ScanFrequencyMinutes, &i.AutoScanEnabled)
	return i, err
}

const GetUser = `-- name: GetUser :one
SELECT id, email, username, theme, first_name, last_name, role, created_at, updated_at FROM users WHERE id = $1
`

type GetUserRow struct {
	ID        pgtype.UUID        `db:"id" json:"id"`
	Email     string             `db:"email" json:"email"`
	Username  string             `db:"username" json:"username"`
	Theme     pgtype.Text        `db:"theme" json:"theme"`
	FirstName pgtype.Text        `db:"first_name" json:"first_name"`
	LastName  pgtype.Text        `db:"last_name" json:"last_name"`
	Role      string             `db:"role" json:"role"`
	CreatedAt pgtype.Timestamptz `db:"created_at" json:"created_at"`
	UpdatedAt pgtype.Timestamptz `db:"updated_at" json:"updated_at"`
}

func (q *Queries) GetUser(ctx context.Context, id pgtype.UUID) (GetUserRow, error) {
	row := q.db.QueryRow(ctx, GetUser, id)
	var i GetUserRow
	err := row.Scan(
		&i.ID,
		&i.Email,
		&i.Username,
		&i.Theme,
		&i.FirstName,
		&i.LastName,
		&i.Role,
		&i.CreatedAt,
		&i.UpdatedAt,
	)
	return i, err
}

const GetUserByEmail = `-- name: GetUserByEmail :one
SELECT id, email, username, theme, first_name, last_name, role, created_at, updated_at FROM users WHERE email = $1
`

type GetUserByEmailRow struct {
	ID        pgtype.UUID        `db:"id" json:"id"`
	Email     string             `db:"email" json:"email"`
	Username  string             `db:"username" json:"username"`
	Theme     pgtype.Text        `db:"theme" json:"theme"`
	FirstName pgtype.Text        `db:"first_name" json:"first_name"`
	LastName  pgtype.Text        `db:"last_name" json:"last_name"`
	Role      string             `db:"role" json:"role"`
	CreatedAt pgtype.Timestamptz `db:"created_at" json:"created_at"`
	UpdatedAt pgtype.Timestamptz `db:"updated_at" json:"updated_at"`
}

func (q *Queries) GetUserByEmail(ctx context.Context, email string) (GetUserByEmailRow, error) {
	row := q.db.QueryRow(ctx, GetUserByEmail, email)
	var i GetUserByEmailRow
	err := row.Scan(
		&i.ID,
		&i.Email,
		&i.Username,
		&i.Theme,
		&i.FirstName,
		&i.LastName,
		&i.Role,
		&i.CreatedAt,
		&i.UpdatedAt,
	)
	return i, err
}

const GetUserByEmailOrUsername = `-- name: GetUserByEmailOrUsername :one
SELECT id, email, username, theme, first_name, last_name, role, created_at, updated_at FROM users WHERE email = $1 OR username = $1
`

type GetUserByEmailOrUsernameRow struct {
	ID        pgtype.UUID        `db:"id" json:"id"`
	Email     string             `db:"email" json:"email"`
	Username  string             `db:"username" json:"username"`
	Theme     pgtype.Text        `db:"theme" json:"theme"`
	FirstName pgtype.Text        `db:"first_name" json:"first_name"`
	LastName  pgtype.Text        `db:"last_name" json:"last_name"`
	Role      string             `db:"role" json:"role"`
	CreatedAt pgtype.Timestamptz `db:"created_at" json:"created_at"`
	UpdatedAt pgtype.Timestamptz `db:"updated_at" json:"updated_at"`
}

func (q *Queries) GetUserByEmailOrUsername(ctx context.Context, email string) (GetUserByEmailOrUsernameRow, error) {
	row := q.db.QueryRow(ctx, GetUserByEmailOrUsername, email)
	var i GetUserByEmailOrUsernameRow
	err := row.Scan(
		&i.ID,
		&i.Email,
		&i.Username,
		&i.Theme,
		&i.FirstName,
		&i.LastName,
		&i.Role,
		&i.CreatedAt,
		&i.UpdatedAt,
	)
	return i, err
}

const GetUserByUsername = `-- name: GetUserByUsername :one
SELECT id, email, username, theme, first_name, last_name, role, created_at, updated_at FROM users WHERE username = $1
`

type GetUserByUsernameRow struct {
	ID        pgtype.UUID        `db:"id" json:"id"`
	Email     string             `db:"email" json:"email"`
	Username  string             `db:"username" json:"username"`
	Theme     pgtype.Text        `db:"theme" json:"theme"`
	FirstName pgtype.Text        `db:"first_name" json:"first_name"`
	LastName  pgtype.Text        `db:"last_name" json:"last_name"`
	Role      string             `db:"role" json:"role"`
	CreatedAt pgtype.Timestamptz `db:"created_at" json:"created_at"`
	UpdatedAt pgtype.Timestamptz `db:"updated_at" json:"updated_at"`
}

func (q *Queries) GetUserByUsername(ctx context.Context, username string) (GetUserByUsernameRow, error) {
	row := q.db.QueryRow(ctx, GetUserByUsername, username)
	var i GetUserByUsernameRow
	err := row.Scan(
		&i.ID,
		&i.Email,
		&i.Username,
		&i.Theme,
		&i.FirstName,
		&i.LastName,
		&i.Role,
		&i.CreatedAt,
		&i.UpdatedAt,
	)
	return i, err
}

const GetUserForLogin = `-- name: GetUserForLogin :one
SELECT id, email, username, password_hash, theme, first_name, last_name, role, created_at, updated_at FROM users WHERE email = $1 OR username = $1
`

type GetUserForLoginRow struct {
	ID           pgtype.UUID        `db:"id" json:"id"`
	Email        string             `db:"email" json:"email"`
	Username     string             `db:"username" json:"username"`
	PasswordHash string             `db:"password_hash" json:"password_hash"`
	Theme        pgtype.Text        `db:"theme" json:"theme"`
	FirstName    pgtype.Text        `db:"first_name" json:"first_name"`
	LastName     pgtype.Text        `db:"last_name" json:"last_name"`
	Role         string             `db:"role" json:"role"`
	CreatedAt    pgtype.Timestamptz `db:"created_at" json:"created_at"`
	UpdatedAt    pgtype.Timestamptz `db:"updated_at" json:"updated_at"`
}

func (q *Queries) GetUserForLogin(ctx context.Context, email string) (GetUserForLoginRow, error) {
	row := q.db.QueryRow(ctx, GetUserForLogin, email)
	var i GetUserForLoginRow
	err := row.Scan(
		&i.ID,
		&i.Email,
		&i.Username,
		&i.PasswordHash,
		&i.Theme,
		&i.FirstName,
		&i.LastName,
		&i.Role,
		&i.CreatedAt,
		&i.UpdatedAt,
	)
	return i, err
}

const GetUserPasswordHash = `-- name: GetUserPasswordHash :one
SELECT password_hash FROM users WHERE id = $1
`

func (q *Queries) GetUserPasswordHash(ctx context.Context, id pgtype.UUID) (string, error) {
	row := q.db.QueryRow(ctx, GetUserPasswordHash, id)
	var password_hash string
	err := row.Scan(&password_hash)
	return password_hash, err
}

const GetUserVisibleLibraries = `-- name: GetUserVisibleLibraries :many
SELECT l.id, l.name, l.description, l.library_type_id, l.created_by_admin_id, l.created_at, l.updated_at, lt.name as type_name, lt.description as type_description,
       COALESCE(lv.is_visible, true) as is_visible
FROM libraries l
JOIN library_types lt ON l.library_type_id = lt.id
LEFT JOIN library_visibility lv ON l.id = lv.library_id AND lv.user_id = $1
WHERE COALESCE(lv.is_visible, true) = true
ORDER BY l.created_at DESC
`

type GetUserVisibleLibrariesRow struct {
	ID               pgtype.UUID        `db:"id" json:"id"`
	Name             string             `db:"name" json:"name"`
	Description      pgtype.Text        `db:"description" json:"description"`
	LibraryTypeID    pgtype.UUID        `db:"library_type_id" json:"library_type_id"`
	CreatedByAdminID pgtype.UUID        `db:"created_by_admin_id" json:"created_by_admin_id"`
	CreatedAt        pgtype.Timestamptz `db:"created_at" json:"created_at"`
	UpdatedAt        pgtype.Timestamptz `db:"updated_at" json:"updated_at"`
	TypeName         string             `db:"type_name" json:"type_name"`
	TypeDescription  pgtype.Text        `db:"type_description" json:"type_description"`
	IsVisible        bool               `db:"is_visible" json:"is_visible"`
}

func (q *Queries) GetUserVisibleLibraries(ctx context.Context, userID pgtype.UUID) ([]GetUserVisibleLibrariesRow, error) {
	rows, err := q.db.Query(ctx, GetUserVisibleLibraries, userID)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	items := []GetUserVisibleLibrariesRow{}
	for rows.Next() {
		var i GetUserVisibleLibrariesRow
		if err := rows.Scan(
			&i.ID,
			&i.Name,
			&i.Description,
			&i.LibraryTypeID,
			&i.CreatedByAdminID,
			&i.CreatedAt,
			&i.UpdatedAt,
			&i.TypeName,
			&i.TypeDescription,
			&i.IsVisible,
		); err != nil {
			return nil, err
		}
		items = append(items, i)
	}
	if err := rows.Err(); err != nil {
		return nil, err
	}
	return items, nil
}

const ListEbooks = `-- name: ListEbooks :many
SELECT id, library_id, title, author, isbn, description, file_path, file_size, mime_type, cover_image_path, series, series_number, tags, asin, date_published, publisher, contributors, added_by_admin_id, created_at, updated_at FROM ebooks ORDER BY created_at DESC LIMIT $1 OFFSET $2
`

type ListEbooksParams struct {
	Limit  int32 `db:"limit" json:"limit"`
	Offset int32 `db:"offset" json:"offset"`
}

func (q *Queries) ListEbooks(ctx context.Context, arg ListEbooksParams) ([]Ebooks, error) {
	rows, err := q.db.Query(ctx, ListEbooks, arg.Limit, arg.Offset)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	items := []Ebooks{}
	for rows.Next() {
		var i Ebooks
		if err := rows.Scan(
			&i.ID,
			&i.LibraryID,
			&i.Title,
			&i.Author,
			&i.Isbn,
			&i.Description,
			&i.FilePath,
			&i.FileSize,
			&i.MimeType,
			&i.CoverImagePath,
			&i.Series,
			&i.SeriesNumber,
			&i.Tags,
			&i.Asin,
			&i.DatePublished,
			&i.Publisher,
			&i.Contributors,
			&i.AddedByAdminID,
			&i.CreatedAt,
			&i.UpdatedAt,
		); err != nil {
			return nil, err
		}
		items = append(items, i)
	}
	if err := rows.Err(); err != nil {
		return nil, err
	}
	return items, nil
}

const ListLibraries = `-- name: ListLibraries :many
SELECT l.id, l.name, l.description, l.library_type_id, l.created_by_admin_id, l.created_at, l.updated_at, lt.name as type_name, lt.description as type_description
FROM libraries l
JOIN library_types lt ON l.library_type_id = lt.id
ORDER BY l.created_at DESC
`

type ListLibrariesRow struct {
	ID               pgtype.UUID        `db:"id" json:"id"`
	Name             string             `db:"name" json:"name"`
	Description      pgtype.Text        `db:"description" json:"description"`
	LibraryTypeID    pgtype.UUID        `db:"library_type_id" json:"library_type_id"`
	CreatedByAdminID pgtype.UUID        `db:"created_by_admin_id" json:"created_by_admin_id"`
	CreatedAt        pgtype.Timestamptz `db:"created_at" json:"created_at"`
	UpdatedAt        pgtype.Timestamptz `db:"updated_at" json:"updated_at"`
	TypeName         string             `db:"type_name" json:"type_name"`
	TypeDescription  pgtype.Text        `db:"type_description" json:"type_description"`
}

func (q *Queries) ListLibraries(ctx context.Context) ([]ListLibrariesRow, error) {
	rows, err := q.db.Query(ctx, ListLibraries)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	items := []ListLibrariesRow{}
	for rows.Next() {
		var i ListLibrariesRow
		if err := rows.Scan(
			&i.ID,
			&i.Name,
			&i.Description,
			&i.LibraryTypeID,
			&i.CreatedByAdminID,
			&i.CreatedAt,
			&i.UpdatedAt,
			&i.TypeName,
			&i.TypeDescription,
		); err != nil {
			return nil, err
		}
		items = append(items, i)
	}
	if err := rows.Err(); err != nil {
		return nil, err
	}
	return items, nil
}

const ListMediaItems = `-- name: ListMediaItems :many
SELECT mi.id, mi.library_id, mi.title, mi.author, mi.isbn, mi.description, mi.file_path, mi.file_size, mi.mime_type, mi.cover_image_path, mi.series, mi.series_number, mi.tags, mi.asin, mi.date_published, mi.publisher, mi.contributors, mi.added_by_admin_id, mi.created_at, mi.updated_at, l.name as library_name, lt.name as library_type_name
FROM media_items mi
JOIN libraries l ON mi.library_id = l.id
JOIN library_types lt ON l.library_type_id = lt.id
ORDER BY mi.created_at DESC LIMIT $1 OFFSET $2
`

type ListMediaItemsParams struct {
	Limit  int32 `db:"limit" json:"limit"`
	Offset int32 `db:"offset" json:"offset"`
}

type ListMediaItemsRow struct {
	ID              pgtype.UUID        `db:"id" json:"id"`
	LibraryID       pgtype.UUID        `db:"library_id" json:"library_id"`
	Title           string             `db:"title" json:"title"`
	Author          pgtype.Text        `db:"author" json:"author"`
	Isbn            pgtype.Text        `db:"isbn" json:"isbn"`
	Description     pgtype.Text        `db:"description" json:"description"`
	FilePath        string             `db:"file_path" json:"file_path"`
	FileSize        pgtype.Int8        `db:"file_size" json:"file_size"`
	MimeType        pgtype.Text        `db:"mime_type" json:"mime_type"`
	CoverImagePath  pgtype.Text        `db:"cover_image_path" json:"cover_image_path"`
	Series          pgtype.Text        `db:"series" json:"series"`
	SeriesNumber    pgtype.Int4        `db:"series_number" json:"series_number"`
	Tags            pgtype.Text        `db:"tags" json:"tags"`
	Asin            pgtype.Text        `db:"asin" json:"asin"`
	DatePublished   pgtype.Date        `db:"date_published" json:"date_published"`
	Publisher       pgtype.Text        `db:"publisher" json:"publisher"`
	Contributors    pgtype.Text        `db:"contributors" json:"contributors"`
	AddedByAdminID  pgtype.UUID        `db:"added_by_admin_id" json:"added_by_admin_id"`
	CreatedAt       pgtype.Timestamptz `db:"created_at" json:"created_at"`
	UpdatedAt       pgtype.Timestamptz `db:"updated_at" json:"updated_at"`
	LibraryName     string             `db:"library_name" json:"library_name"`
	LibraryTypeName string             `db:"library_type_name" json:"library_type_name"`
}

func (q *Queries) ListMediaItems(ctx context.Context, arg ListMediaItemsParams) ([]ListMediaItemsRow, error) {
	rows, err := q.db.Query(ctx, ListMediaItems, arg.Limit, arg.Offset)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	items := []ListMediaItemsRow{}
	for rows.Next() {
		var i ListMediaItemsRow
		if err := rows.Scan(
			&i.ID,
			&i.LibraryID,
			&i.Title,
			&i.Author,
			&i.Isbn,
			&i.Description,
			&i.FilePath,
			&i.FileSize,
			&i.MimeType,
			&i.CoverImagePath,
			&i.Series,
			&i.SeriesNumber,
			&i.Tags,
			&i.Asin,
			&i.DatePublished,
			&i.Publisher,
			&i.Contributors,
			&i.AddedByAdminID,
			&i.CreatedAt,
			&i.UpdatedAt,
			&i.LibraryName,
			&i.LibraryTypeName,
		); err != nil {
			return nil, err
		}
		items = append(items, i)
	}
	if err := rows.Err(); err != nil {
		return nil, err
	}
	return items, nil
}

const ListMediaItemsByLibrary = `-- name: ListMediaItemsByLibrary :many
SELECT mi.id, mi.library_id, mi.title, mi.author, mi.isbn, mi.description, mi.file_path, mi.file_size, mi.mime_type, mi.cover_image_path, mi.series, mi.series_number, mi.tags, mi.asin, mi.date_published, mi.publisher, mi.contributors, mi.added_by_admin_id, mi.created_at, mi.updated_at, l.name as library_name, lt.name as library_type_name
FROM media_items mi
JOIN libraries l ON mi.library_id = l.id
JOIN library_types lt ON l.library_type_id = lt.id
WHERE mi.library_id = $1
ORDER BY mi.created_at DESC
`

type ListMediaItemsByLibraryRow struct {
	ID              pgtype.UUID        `db:"id" json:"id"`
	LibraryID       pgtype.UUID        `db:"library_id" json:"library_id"`
	Title           string             `db:"title" json:"title"`
	Author          pgtype.Text        `db:"author" json:"author"`
	Isbn            pgtype.Text        `db:"isbn" json:"isbn"`
	Description     pgtype.Text        `db:"description" json:"description"`
	FilePath        string             `db:"file_path" json:"file_path"`
	FileSize        pgtype.Int8        `db:"file_size" json:"file_size"`
	MimeType        pgtype.Text        `db:"mime_type" json:"mime_type"`
	CoverImagePath  pgtype.Text        `db:"cover_image_path" json:"cover_image_path"`
	Series          pgtype.Text        `db:"series" json:"series"`
	SeriesNumber    pgtype.Int4        `db:"series_number" json:"series_number"`
	Tags            pgtype.Text        `db:"tags" json:"tags"`
	Asin            pgtype.Text        `db:"asin" json:"asin"`
	DatePublished   pgtype.Date        `db:"date_published" json:"date_published"`
	Publisher       pgtype.Text        `db:"publisher" json:"publisher"`
	Contributors    pgtype.Text        `db:"contributors" json:"contributors"`
	AddedByAdminID  pgtype.UUID        `db:"added_by_admin_id" json:"added_by_admin_id"`
	CreatedAt       pgtype.Timestamptz `db:"created_at" json:"created_at"`
	UpdatedAt       pgtype.Timestamptz `db:"updated_at" json:"updated_at"`
	LibraryName     string             `db:"library_name" json:"library_name"`
	LibraryTypeName string             `db:"library_type_name" json:"library_type_name"`
}

func (q *Queries) ListMediaItemsByLibrary(ctx context.Context, libraryID pgtype.UUID) ([]ListMediaItemsByLibraryRow, error) {
	rows, err := q.db.Query(ctx, ListMediaItemsByLibrary, libraryID)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	items := []ListMediaItemsByLibraryRow{}
	for rows.Next() {
		var i ListMediaItemsByLibraryRow
		if err := rows.Scan(
			&i.ID,
			&i.LibraryID,
			&i.Title,
			&i.Author,
			&i.Isbn,
			&i.Description,
			&i.FilePath,
			&i.FileSize,
			&i.MimeType,
			&i.CoverImagePath,
			&i.Series,
			&i.SeriesNumber,
			&i.Tags,
			&i.Asin,
			&i.DatePublished,
			&i.Publisher,
			&i.Contributors,
			&i.AddedByAdminID,
			&i.CreatedAt,
			&i.UpdatedAt,
			&i.LibraryName,
			&i.LibraryTypeName,
		); err != nil {
			return nil, err
		}
		items = append(items, i)
	}
	if err := rows.Err(); err != nil {
		return nil, err
	}
	return items, nil
}

const ListUsers = `-- name: ListUsers :many
SELECT id, email, username, theme, first_name, last_name, role, created_at, updated_at FROM users ORDER BY created_at DESC
`

type ListUsersRow struct {
	ID        pgtype.UUID        `db:"id" json:"id"`
	Email     string             `db:"email" json:"email"`
	Username  string             `db:"username" json:"username"`
	Theme     pgtype.Text        `db:"theme" json:"theme"`
	FirstName pgtype.Text        `db:"first_name" json:"first_name"`
	LastName  pgtype.Text        `db:"last_name" json:"last_name"`
	Role      string             `db:"role" json:"role"`
	CreatedAt pgtype.Timestamptz `db:"created_at" json:"created_at"`
	UpdatedAt pgtype.Timestamptz `db:"updated_at" json:"updated_at"`
}

func (q *Queries) ListUsers(ctx context.Context) ([]ListUsersRow, error) {
	rows, err := q.db.Query(ctx, ListUsers)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	items := []ListUsersRow{}
	for rows.Next() {
		var i ListUsersRow
		if err := rows.Scan(
			&i.ID,
			&i.Email,
			&i.Username,
			&i.Theme,
			&i.FirstName,
			&i.LastName,
			&i.Role,
			&i.CreatedAt,
			&i.UpdatedAt,
		); err != nil {
			return nil, err
		}
		items = append(items, i)
	}
	if err := rows.Err(); err != nil {
		return nil, err
	}
	return items, nil
}

const RevokeAllUserRefreshTokens = `-- name: RevokeAllUserRefreshTokens :exec
UPDATE refresh_tokens SET revoked_at = NOW() WHERE user_id = $1 AND revoked_at IS NULL
`

func (q *Queries) RevokeAllUserRefreshTokens(ctx context.Context, userID pgtype.UUID) error {
	_, err := q.db.Exec(ctx, RevokeAllUserRefreshTokens, userID)
	return err
}

const RevokeRefreshToken = `-- name: RevokeRefreshToken :exec
UPDATE refresh_tokens SET revoked_at = NOW() WHERE token = $1
`

func (q *Queries) RevokeRefreshToken(ctx context.Context, token string) error {
	_, err := q.db.Exec(ctx, RevokeRefreshToken, token)
	return err
}

const SetLibraryVisibility = `-- name: SetLibraryVisibility :one
INSERT INTO library_visibility (user_id, library_id, is_visible)
VALUES ($1, $2, $3)
ON CONFLICT (user_id, library_id)
DO UPDATE SET
    is_visible = EXCLUDED.is_visible,
    updated_at = NOW()
RETURNING id, user_id, library_id, is_visible, created_at, updated_at
`

type SetLibraryVisibilityParams struct {
	UserID    pgtype.UUID `db:"user_id" json:"user_id"`
	LibraryID pgtype.UUID `db:"library_id" json:"library_id"`
	IsVisible bool        `db:"is_visible" json:"is_visible"`
}

// Library Visibility queries
func (q *Queries) SetLibraryVisibility(ctx context.Context, arg SetLibraryVisibilityParams) (LibraryVisibility, error) {
	row := q.db.QueryRow(ctx, SetLibraryVisibility, arg.UserID, arg.LibraryID, arg.IsVisible)
	var i LibraryVisibility
	err := row.Scan(
		&i.ID,
		&i.UserID,
		&i.LibraryID,
		&i.IsVisible,
		&i.CreatedAt,
		&i.UpdatedAt,
	)
	return i, err
}

const UpdateEbook = `-- name: UpdateEbook :one
UPDATE media_items SET
    title = $2,
    author = $3,
    isbn = $4,
    description = $5,
    cover_image_path = $6,
    series = $7,
    series_number = $8,
    tags = $9,
    asin = $10,
    date_published = $11,
    publisher = $12,
    contributors = $13,
    updated_at = NOW()
WHERE id = $1
RETURNING id, library_id, title, author, isbn, description, file_path, file_size, mime_type, cover_image_path, series, series_number, tags, asin, date_published, publisher, contributors, added_by_admin_id, created_at, updated_at
`

type UpdateEbookParams struct {
	ID             pgtype.UUID `db:"id" json:"id"`
	Title          string      `db:"title" json:"title"`
	Author         pgtype.Text `db:"author" json:"author"`
	Isbn           pgtype.Text `db:"isbn" json:"isbn"`
	Description    pgtype.Text `db:"description" json:"description"`
	CoverImagePath pgtype.Text `db:"cover_image_path" json:"cover_image_path"`
	Series         pgtype.Text `db:"series" json:"series"`
	SeriesNumber   pgtype.Int4 `db:"series_number" json:"series_number"`
	Tags           pgtype.Text `db:"tags" json:"tags"`
	Asin           pgtype.Text `db:"asin" json:"asin"`
	DatePublished  pgtype.Date `db:"date_published" json:"date_published"`
	Publisher      pgtype.Text `db:"publisher" json:"publisher"`
	Contributors   pgtype.Text `db:"contributors" json:"contributors"`
}

func (q *Queries) UpdateEbook(ctx context.Context, arg UpdateEbookParams) (MediaItems, error) {
	row := q.db.QueryRow(ctx, UpdateEbook,
		arg.ID,
		arg.Title,
		arg.Author,
		arg.Isbn,
		arg.Description,
		arg.CoverImagePath,
		arg.Series,
		arg.SeriesNumber,
		arg.Tags,
		arg.Asin,
		arg.DatePublished,
		arg.Publisher,
		arg.Contributors,
	)
	var i MediaItems
	err := row.Scan(
		&i.ID,
		&i.LibraryID,
		&i.Title,
		&i.Author,
		&i.Isbn,
		&i.Description,
		&i.FilePath,
		&i.FileSize,
		&i.MimeType,
		&i.CoverImagePath,
		&i.Series,
		&i.SeriesNumber,
		&i.Tags,
		&i.Asin,
		&i.DatePublished,
		&i.Publisher,
		&i.Contributors,
		&i.AddedByAdminID,
		&i.CreatedAt,
		&i.UpdatedAt,
	)
	return i, err
}

const UpdateEbookHighlight = `-- name: UpdateEbookHighlight :one
UPDATE media_highlights SET
    selection_text = $2,
    start_position = $3,
    end_position = $4,
    color = $5,
    note_id = $6,
    updated_at = NOW()
WHERE id = $1
RETURNING id, media_item_id, user_id, selection_text, start_position, end_position, color, note_id, created_at, updated_at
`

type UpdateEbookHighlightParams struct {
	ID            pgtype.UUID `db:"id" json:"id"`
	SelectionText string      `db:"selection_text" json:"selection_text"`
	StartPosition pgtype.Text `db:"start_position" json:"start_position"`
	EndPosition   pgtype.Text `db:"end_position" json:"end_position"`
	Color         pgtype.Text `db:"color" json:"color"`
	NoteID        pgtype.UUID `db:"note_id" json:"note_id"`
}

func (q *Queries) UpdateEbookHighlight(ctx context.Context, arg UpdateEbookHighlightParams) (MediaHighlights, error) {
	row := q.db.QueryRow(ctx, UpdateEbookHighlight,
		arg.ID,
		arg.SelectionText,
		arg.StartPosition,
		arg.EndPosition,
		arg.Color,
		arg.NoteID,
	)
	var i MediaHighlights
	err := row.Scan(
		&i.ID,
		&i.MediaItemID,
		&i.UserID,
		&i.SelectionText,
		&i.StartPosition,
		&i.EndPosition,
		&i.Color,
		&i.NoteID,
		&i.CreatedAt,
		&i.UpdatedAt,
	)
	return i, err
}

const UpdateEbookNote = `-- name: UpdateEbookNote :one
UPDATE media_notes SET
    content = $2,
    position = $3,
    updated_at = NOW()
WHERE id = $1
RETURNING id, media_item_id, user_id, content, position, created_at, updated_at
`

type UpdateEbookNoteParams struct {
	ID       pgtype.UUID `db:"id" json:"id"`
	Content  string      `db:"content" json:"content"`
	Position pgtype.Text `db:"position" json:"position"`
}

func (q *Queries) UpdateEbookNote(ctx context.Context, arg UpdateEbookNoteParams) (MediaNotes, error) {
	row := q.db.QueryRow(ctx, UpdateEbookNote, arg.ID, arg.Content, arg.Position)
	var i MediaNotes
	err := row.Scan(
		&i.ID,
		&i.MediaItemID,
		&i.UserID,
		&i.Content,
		&i.Position,
		&i.CreatedAt,
		&i.UpdatedAt,
	)
	return i, err
}

const UpdateEbookRating = `-- name: UpdateEbookRating :one
UPDATE media_ratings SET
    rating = $3,
    updated_at = NOW()
WHERE media_item_id = $1 AND user_id = $2
RETURNING id, media_item_id, user_id, rating, created_at, updated_at
`

type UpdateEbookRatingParams struct {
	MediaItemID pgtype.UUID `db:"media_item_id" json:"media_item_id"`
	UserID      pgtype.UUID `db:"user_id" json:"user_id"`
	Rating      int32       `db:"rating" json:"rating"`
}

func (q *Queries) UpdateEbookRating(ctx context.Context, arg UpdateEbookRatingParams) (MediaRatings, error) {
	row := q.db.QueryRow(ctx, UpdateEbookRating, arg.MediaItemID, arg.UserID, arg.Rating)
	var i MediaRatings
	err := row.Scan(
		&i.ID,
		&i.MediaItemID,
		&i.UserID,
		&i.Rating,
		&i.CreatedAt,
		&i.UpdatedAt,
	)
	return i, err
}

const UpdateEmail = `-- name: UpdateEmail :exec
UPDATE users SET email = $2, updated_at = NOW() WHERE id = $1
`

type UpdateEmailParams struct {
	ID    pgtype.UUID `db:"id" json:"id"`
	Email string      `db:"email" json:"email"`
}

func (q *Queries) UpdateEmail(ctx context.Context, arg UpdateEmailParams) error {
	_, err := q.db.Exec(ctx, UpdateEmail, arg.ID, arg.Email)
	return err
}

const UpdateLibrary = `-- name: UpdateLibrary :one
UPDATE libraries SET
    name = $2,
    description = $3,
    updated_at = NOW()
WHERE id = $1
RETURNING id, name, description, library_type_id, created_by_admin_id, created_at, updated_at
`

type UpdateLibraryParams struct {
	ID          pgtype.UUID `db:"id" json:"id"`
	Name        string      `db:"name" json:"name"`
	Description pgtype.Text `db:"description" json:"description"`
}

func (q *Queries) UpdateLibrary(ctx context.Context, arg UpdateLibraryParams) (Libraries, error) {
	row := q.db.QueryRow(ctx, UpdateLibrary, arg.ID, arg.Name, arg.Description)
	var i Libraries
	err := row.Scan(
		&i.ID,
		&i.Name,
		&i.Description,
		&i.LibraryTypeID,
		&i.CreatedByAdminID,
		&i.CreatedAt,
		&i.UpdatedAt,
	)
	return i, err
}

const UpdateMediaHighlight = `-- name: UpdateMediaHighlight :one
UPDATE media_highlights SET
    selection_text = $2,
    start_position = $3,
    end_position = $4,
    color = $5,
    note_id = $6,
    updated_at = NOW()
WHERE id = $1
RETURNING id, media_item_id, user_id, selection_text, start_position, end_position, color, note_id, created_at, updated_at
`

type UpdateMediaHighlightParams struct {
	ID            pgtype.UUID `db:"id" json:"id"`
	SelectionText string      `db:"selection_text" json:"selection_text"`
	StartPosition pgtype.Text `db:"start_position" json:"start_position"`
	EndPosition   pgtype.Text `db:"end_position" json:"end_position"`
	Color         pgtype.Text `db:"color" json:"color"`
	NoteID        pgtype.UUID `db:"note_id" json:"note_id"`
}

func (q *Queries) UpdateMediaHighlight(ctx context.Context, arg UpdateMediaHighlightParams) (MediaHighlights, error) {
	row := q.db.QueryRow(ctx, UpdateMediaHighlight,
		arg.ID,
		arg.SelectionText,
		arg.StartPosition,
		arg.EndPosition,
		arg.Color,
		arg.NoteID,
	)
	var i MediaHighlights
	err := row.Scan(
		&i.ID,
		&i.MediaItemID,
		&i.UserID,
		&i.SelectionText,
		&i.StartPosition,
		&i.EndPosition,
		&i.Color,
		&i.NoteID,
		&i.CreatedAt,
		&i.UpdatedAt,
	)
	return i, err
}

const UpdateMediaItem = `-- name: UpdateMediaItem :one
UPDATE media_items SET
    title = $2,
    author = $3,
    isbn = $4,
    description = $5,
    cover_image_path = $6,
    series = $7,
    series_number = $8,
    tags = $9,
    asin = $10,
    date_published = $11,
    publisher = $12,
    contributors = $13,
    updated_at = NOW()
WHERE id = $1
RETURNING id, library_id, title, author, isbn, description, file_path, file_size, mime_type, cover_image_path, series, series_number, tags, asin, date_published, publisher, contributors, added_by_admin_id, created_at, updated_at
`

type UpdateMediaItemParams struct {
	ID             pgtype.UUID `db:"id" json:"id"`
	Title          string      `db:"title" json:"title"`
	Author         pgtype.Text `db:"author" json:"author"`
	Isbn           pgtype.Text `db:"isbn" json:"isbn"`
	Description    pgtype.Text `db:"description" json:"description"`
	CoverImagePath pgtype.Text `db:"cover_image_path" json:"cover_image_path"`
	Series         pgtype.Text `db:"series" json:"series"`
	SeriesNumber   pgtype.Int4 `db:"series_number" json:"series_number"`
	Tags           pgtype.Text `db:"tags" json:"tags"`
	Asin           pgtype.Text `db:"asin" json:"asin"`
	DatePublished  pgtype.Date `db:"date_published" json:"date_published"`
	Publisher      pgtype.Text `db:"publisher" json:"publisher"`
	Contributors   pgtype.Text `db:"contributors" json:"contributors"`
}

func (q *Queries) UpdateMediaItem(ctx context.Context, arg UpdateMediaItemParams) (MediaItems, error) {
	row := q.db.QueryRow(ctx, UpdateMediaItem,
		arg.ID,
		arg.Title,
		arg.Author,
		arg.Isbn,
		arg.Description,
		arg.CoverImagePath,
		arg.Series,
		arg.SeriesNumber,
		arg.Tags,
		arg.Asin,
		arg.DatePublished,
		arg.Publisher,
		arg.Contributors,
	)
	var i MediaItems
	err := row.Scan(
		&i.ID,
		&i.LibraryID,
		&i.Title,
		&i.Author,
		&i.Isbn,
		&i.Description,
		&i.FilePath,
		&i.FileSize,
		&i.MimeType,
		&i.CoverImagePath,
		&i.Series,
		&i.SeriesNumber,
		&i.Tags,
		&i.Asin,
		&i.DatePublished,
		&i.Publisher,
		&i.Contributors,
		&i.AddedByAdminID,
		&i.CreatedAt,
		&i.UpdatedAt,
	)
	return i, err
}

const UpdateMediaNote = `-- name: UpdateMediaNote :one
UPDATE media_notes SET
    content = $2,
    position = $3,
    updated_at = NOW()
WHERE id = $1
RETURNING id, media_item_id, user_id, content, position, created_at, updated_at
`

type UpdateMediaNoteParams struct {
	ID       pgtype.UUID `db:"id" json:"id"`
	Content  string      `db:"content" json:"content"`
	Position pgtype.Text `db:"position" json:"position"`
}

func (q *Queries) UpdateMediaNote(ctx context.Context, arg UpdateMediaNoteParams) (MediaNotes, error) {
	row := q.db.QueryRow(ctx, UpdateMediaNote, arg.ID, arg.Content, arg.Position)
	var i MediaNotes
	err := row.Scan(
		&i.ID,
		&i.MediaItemID,
		&i.UserID,
		&i.Content,
		&i.Position,
		&i.CreatedAt,
		&i.UpdatedAt,
	)
	return i, err
}

const UpdateMediaRating = `-- name: UpdateMediaRating :one
UPDATE media_ratings SET
    rating = $3,
    updated_at = NOW()
WHERE media_item_id = $1 AND user_id = $2
RETURNING id, media_item_id, user_id, rating, created_at, updated_at
`

type UpdateMediaRatingParams struct {
	MediaItemID pgtype.UUID `db:"media_item_id" json:"media_item_id"`
	UserID      pgtype.UUID `db:"user_id" json:"user_id"`
	Rating      int32       `db:"rating" json:"rating"`
}

func (q *Queries) UpdateMediaRating(ctx context.Context, arg UpdateMediaRatingParams) (MediaRatings, error) {
	row := q.db.QueryRow(ctx, UpdateMediaRating, arg.MediaItemID, arg.UserID, arg.Rating)
	var i MediaRatings
	err := row.Scan(
		&i.ID,
		&i.MediaItemID,
		&i.UserID,
		&i.Rating,
		&i.CreatedAt,
		&i.UpdatedAt,
	)
	return i, err
}

const UpdatePassword = `-- name: UpdatePassword :exec
UPDATE users SET password_hash = $2, updated_at = NOW() WHERE id = $1
`

type UpdatePasswordParams struct {
	ID           pgtype.UUID `db:"id" json:"id"`
	PasswordHash string      `db:"password_hash" json:"password_hash"`
}

func (q *Queries) UpdatePassword(ctx context.Context, arg UpdatePasswordParams) error {
	_, err := q.db.Exec(ctx, UpdatePassword, arg.ID, arg.PasswordHash)
	return err
}

const UpdateReadingProgress = `-- name: UpdateReadingProgress :one
INSERT INTO reading_progress (media_item_id, user_id, current_page, total_pages, last_read_at)
VALUES ($1, $2, $3, $4, NOW())
ON CONFLICT (media_item_id, user_id)
DO UPDATE SET
    current_page = EXCLUDED.current_page,
    total_pages = EXCLUDED.total_pages,
    last_read_at = NOW()
RETURNING id, media_item_id, user_id, current_page, total_pages, last_read_at
`

type UpdateReadingProgressParams struct {
	MediaItemID pgtype.UUID `db:"media_item_id" json:"media_item_id"`
	UserID      pgtype.UUID `db:"user_id" json:"user_id"`
	CurrentPage pgtype.Int4 `db:"current_page" json:"current_page"`
	TotalPages  pgtype.Int4 `db:"total_pages" json:"total_pages"`
}

func (q *Queries) UpdateReadingProgress(ctx context.Context, arg UpdateReadingProgressParams) (ReadingProgress, error) {
	row := q.db.QueryRow(ctx, UpdateReadingProgress,
		arg.MediaItemID,
		arg.UserID,
		arg.CurrentPage,
		arg.TotalPages,
	)
	var i ReadingProgress
	err := row.Scan(
		&i.ID,
		&i.MediaItemID,
		&i.UserID,
		&i.CurrentPage,
		&i.TotalPages,
		&i.LastReadAt,
	)
	return i, err
}

const UpdateScanSettings = `-- name: UpdateScanSettings :exec
UPDATE users SET scan_frequency_minutes = $2, auto_scan_enabled = $3, updated_at = NOW() WHERE id = $1
`

type UpdateScanSettingsParams struct {
	ID                   pgtype.UUID `db:"id" json:"id"`
	ScanFrequencyMinutes pgtype.Int4 `db:"scan_frequency_minutes" json:"scan_frequency_minutes"`
	AutoScanEnabled      pgtype.Bool `db:"auto_scan_enabled" json:"auto_scan_enabled"`
}

func (q *Queries) UpdateScanSettings(ctx context.Context, arg UpdateScanSettingsParams) error {
	_, err := q.db.Exec(ctx, UpdateScanSettings, arg.ID, arg.ScanFrequencyMinutes, arg.AutoScanEnabled)
	return err
}

const UpdateUserProfile = `-- name: UpdateUserProfile :exec
UPDATE users SET first_name = $2, last_name = $3, updated_at = NOW() WHERE id = $1
`

type UpdateUserProfileParams struct {
	ID        pgtype.UUID `db:"id" json:"id"`
	FirstName pgtype.Text `db:"first_name" json:"first_name"`
	LastName  pgtype.Text `db:"last_name" json:"last_name"`
}

func (q *Queries) UpdateUserProfile(ctx context.Context, arg UpdateUserProfileParams) error {
	_, err := q.db.Exec(ctx, UpdateUserProfile, arg.ID, arg.FirstName, arg.LastName)
	return err
}

const UpdateUserTheme = `-- name: UpdateUserTheme :exec
UPDATE users SET theme = $2, updated_at = NOW() WHERE id = $1
`

type UpdateUserThemeParams struct {
	ID    pgtype.UUID `db:"id" json:"id"`
	Theme pgtype.Text `db:"theme" json:"theme"`
}

func (q *Queries) UpdateUserTheme(ctx context.Context, arg UpdateUserThemeParams) error {
	_, err := q.db.Exec(ctx, UpdateUserTheme, arg.ID, arg.Theme)
	return err
}

const UpdateUsername = `-- name: UpdateUsername :exec
UPDATE users SET username = $2, updated_at = NOW() WHERE id = $1
`

type UpdateUsernameParams struct {
	ID       pgtype.UUID `db:"id" json:"id"`
	Username string      `db:"username" json:"username"`
}

func (q *Queries) UpdateUsername(ctx context.Context, arg UpdateUsernameParams) error {
	_, err := q.db.Exec(ctx, UpdateUsername, arg.ID, arg.Username)
	return err
}