### Manage Anime Downloads with AnimeDownloadManager

Source: https://context7.com/aniyomiorg/aniyomi/llms.txt

This controller demonstrates how to interact with the AnimeDownloadManager to start, pause, and monitor episode downloads. It includes methods for queue reordering, checking download status, and handling file deletion.

```kotlin
import eu.kanade.tachiyomi.data.download.anime.AnimeDownloadManager
import eu.kanade.tachiyomi.data.download.anime.model.AnimeDownload
import tachiyomi.domain.entries.anime.model.Anime
import tachiyomi.domain.items.episode.model.Episode

class DownloadController(
    private val downloadManager: AnimeDownloadManager
) {
    fun startDownloads() = downloadManager.startDownloads()
    fun pauseDownloads() = downloadManager.pauseDownloads()
    fun clearQueue() = downloadManager.clearQueue()

    val isRunning: Boolean get() = downloadManager.isRunning

    fun downloadEpisodes(anime: Anime, episodes: List<Episode>) {
        downloadManager.downloadEpisodes(anime = anime, episodes = episodes, autoStart = true, alt = false)
    }

    fun downloadNow(episodeId: Long) {
        downloadManager.startDownloadNow(episodeId)
    }

    fun isDownloaded(episodeName: String, scanlator: String?, animeTitle: String, sourceId: Long): Boolean {
        return downloadManager.isEpisodeDownloaded(episodeName, scanlator, animeTitle, sourceId)
    }

    fun deleteEpisodes(episodes: List<Episode>, anime: Anime, source: AnimeSource) {
        downloadManager.deleteEpisodes(episodes, anime, source)
    }

    fun observeDownloadStatus() {
        viewModelScope.launch {
            downloadManager.statusFlow().collect { download ->
                when (download.status) {
                    AnimeDownload.State.DOWNLOADING -> updateProgress(download)
                    AnimeDownload.State.DOWNLOADED -> markComplete(download)
                    AnimeDownload.State.ERROR -> handleError(download)
                    else -> {}
                }
            }
        }
    }
}
```

--------------------------------

### Create Library Backups with BackupCreator in Kotlin

Source: https://context7.com/aniyomiorg/aniyomi/llms.txt

This Kotlin code demonstrates how to create full and minimal backups of library data using the BackupCreator class. It allows specifying various backup options and generates a backup file at a given URI. The BackupCreator also provides a utility to get a standardized backup filename.

```kotlin
import eu.kanade.tachiyomi.data.backup.create.BackupCreator
import eu.kanade.tachiyomi.data.backup.create.BackupOptions
import android.net.Uri

class BackupController(context: Context) {
    private val backupCreator = BackupCreator(context, isAutoBackup = false)

    // Create full backup
    suspend fun createFullBackup(uri: Uri): String {
        val options = BackupOptions(
            libraryEntries = true,
            categories = true,
            chapters = true,
            tracking = true,
            history = true,
            appSettings = true,
            sourceSettings = true,
            privateSettings = false,
            extensions = true,
            extensionRepoSettings = true,
            customButton = true,
            readEntries = true  // Include read/watched but not favorited
        )
        return backupCreator.backup(uri, options)
    }

    // Create minimal backup (library only)
    suspend fun createLibraryBackup(uri: Uri): String {
        val options = BackupOptions(
            libraryEntries = true,
            categories = true,
            chapters = true,
            tracking = true,
            history = false,
            appSettings = false,
            sourceSettings = false,
            privateSettings = false,
            extensions = false,
            extensionRepoSettings = false,
            customButton = false,
            readEntries = false
        )
        return backupCreator.backup(uri, options)
    }

    // Get backup filename
    fun getBackupFilename(): String {
        return BackupCreator.getFilename()
        // Returns: "app.aniyomi_2024-01-15_14-30.tachibk"
    }
}
```

--------------------------------

### Initialize Episode Domain Model

Source: https://context7.com/aniyomiorg/aniyomi/llms.txt

Demonstrates the creation of an Episode object, tracking playback progress, filler status, and metadata for specific anime episodes.

```kotlin
import tachiyomi.domain.items.episode.model.Episode

val episode = Episode(
    id = 1L,
    animeId = 1L,
    seen = false,
    bookmark = false,
    fillermark = false,
    lastSecondSeen = 0L,
    totalSeconds = 1440L,
    dateFetch = System.currentTimeMillis(),
    sourceOrder = 1L,
    url = "/episode/1",
    name = "Episode 1: The Beginning",
    dateUpload = System.currentTimeMillis(),
    episodeNumber = 1.0,
    scanlator = "SubGroup",
    summary = "Our hero begins their journey...",
    previewUrl = "https://example.com/preview1.jpg",
    lastModifiedAt = System.currentTimeMillis(),
    version = 1L
)
```

--------------------------------

### Manage Anime Library with AnimeLibraryScreenModel

Source: https://context7.com/aniyomiorg/aniyomi/llms.txt

Demonstrates how to observe library state, perform search queries, manage selection modes, and execute batch operations like downloading or marking episodes as seen.

```kotlin
import eu.kanade.tachiyomi.ui.library.anime.AnimeLibraryScreenModel
import eu.kanade.presentation.entries.DownloadAction

class LibraryUsageExample {
    private val screenModel: AnimeLibraryScreenModel

    fun observeLibrary() {
        screenModel.state.collect { state ->
            val isLoading = state.isLoading
            val categories = state.categories
            val hasFilters = state.hasActiveFilters
            val isSelectionMode = state.selectionMode
            val items = state.getAnimelibItemsByCategoryId(categoryId)
            val pageItems = state.getAnimelibItemsByPage(pageIndex)
            val count = state.getAnimeCountForCategory(category)
        }
    }

    fun search(query: String?) {
        screenModel.search(query)
    }

    fun toggleSelection(anime: LibraryAnime) {
        screenModel.toggleSelection(anime)
    }

    fun downloadSelected(action: DownloadAction) {
        screenModel.runDownloadActionSelection(action)
    }

    fun markSelectedAsSeen(seen: Boolean) {
        screenModel.markSeenSelection(seen)
    }

    suspend fun getNextUnseen(anime: Anime): Episode? {
        return screenModel.getNextUnseenEpisode(anime)
    }
}
```

--------------------------------

### Initialize Anime Domain Model

Source: https://context7.com/aniyomiorg/aniyomi/llms.txt

Demonstrates how to instantiate an Anime data class with metadata, sorting flags, and update strategies. This model serves as the primary entity for anime entries within the library.

```kotlin
import tachiyomi.domain.entries.anime.model.Anime
import eu.kanade.tachiyomi.animesource.model.AnimeUpdateStrategy
import eu.kanade.tachiyomi.animesource.model.FetchType

val anime = Anime(
    id = 1L,
    source = 123456789L,
    favorite = true,
    lastUpdate = System.currentTimeMillis(),
    nextUpdate = System.currentTimeMillis() + 86400000,
    fetchInterval = 7,
    dateAdded = System.currentTimeMillis(),
    viewerFlags = 0L,
    episodeFlags = Anime.EPISODE_SORT_DESC or Anime.EPISODE_SHOW_UNSEEN,
    coverLastModified = 0L,
    backgroundLastModified = 0L,
    url = "/anime/my-anime",
    title = "My Anime Title",
    artist = "Studio Name",
    author = "Director Name",
    description = "An exciting anime about...",
    genre = listOf("Action", "Adventure", "Fantasy"),
    status = 1L,
    thumbnailUrl = "https://example.com/cover.jpg",
    backgroundUrl = null,
    updateStrategy = AnimeUpdateStrategy.ALWAYS_UPDATE,
    initialized = true,
    lastModifiedAt = System.currentTimeMillis(),
    favoriteModifiedAt = System.currentTimeMillis(),
    version = 1L,
    fetchType = FetchType.Episodes,
    parentId = null,
    seasonFlags = 0L,
    seasonNumber = -1.0,
    seasonSourceOrder = 0L
)
```

--------------------------------

### Manage Tracker Integrations

Source: https://context7.com/aniyomiorg/aniyomi/llms.txt

Demonstrates how to interact with the TrackerManager to access, observe, and manage external tracking services like MyAnimeList, AniList, Kitsu, and Simkl.

```kotlin
import eu.kanade.tachiyomi.data.track.TrackerManager
import eu.kanade.tachiyomi.data.track.Tracker

class TrackingController(private val trackerManager: TrackerManager) {
    val myAnimeList = trackerManager.myAnimeList
    val aniList = trackerManager.aniList
    val kitsu = trackerManager.kitsu
    val simkl = trackerManager.simkl

    fun getLoggedInTrackers(): List<Tracker> = trackerManager.loggedInTrackers()

    fun observeTrackerLogins() {
        viewModelScope.launch {
            trackerManager.loggedInTrackersFlow().collect { trackers ->
                updateAvailableTrackers(trackers)
            }
        }
    }

    fun getTracker(trackerId: Long): Tracker? = trackerManager.get(trackerId)

    companion object {
        const val ANILIST_ID = TrackerManager.ANILIST
        const val KITSU_ID = TrackerManager.KITSU
        const val SIMKL_ID = TrackerManager.SIMKL
    }
}
```

--------------------------------

### Initialize Manga Domain Model

Source: https://context7.com/aniyomiorg/aniyomi/llms.txt

Shows the instantiation of a Manga data class, which includes properties for reading progress, chapter filtering, and display preferences.

```kotlin
import tachiyomi.domain.entries.manga.model.Manga
import eu.kanade.tachiyomi.source.model.UpdateStrategy

val manga = Manga(
    id = 1L,
    source = 987654321L,
    favorite = true,
    lastUpdate = System.currentTimeMillis(),
    nextUpdate = System.currentTimeMillis() + 86400000,
    fetchInterval = 7,
    dateAdded = System.currentTimeMillis(),
    viewerFlags = 0L,
    chapterFlags = Manga.CHAPTER_SORT_DESC or Manga.CHAPTER_SHOW_UNREAD,
    coverLastModified = 0L,
    url = "/manga/my-manga",
    title = "My Manga Title",
    artist = "Artist Name",
    author = "Author Name",
    description = "A captivating manga about...",
    genre = listOf("Romance", "Drama", "Slice of Life"),
    status = 2L,
    thumbnailUrl = "https://example.com/manga-cover.jpg",
    updateStrategy = UpdateStrategy.ALWAYS_UPDATE,
    initialized = true,
    lastModifiedAt = System.currentTimeMillis(),
    favoriteModifiedAt = System.currentTimeMillis(),
    version = 1L
)
```

--------------------------------

### Implementing a Custom AnimeSource in Kotlin

Source: https://context7.com/aniyomiorg/aniyomi/llms.txt

This snippet demonstrates how to implement the AnimeSource interface. It covers the mandatory overrides for metadata, episodes, seasons, hosters, and video resolution retrieval.

```kotlin
import eu.kanade.tachiyomi.animesource.AnimeSource
import eu.kanade.tachiyomi.animesource.model.SAnime
import eu.kanade.tachiyomi.animesource.model.SEpisode
import eu.kanade.tachiyomi.animesource.model.Video
import eu.kanade.tachiyomi.animesource.model.Hoster

class MyAnimeSource : AnimeSource {
    override val id: Long = 1234567890L
    override val name: String = "My Anime Source"
    override val lang: String = "en"

    override suspend fun getAnimeDetails(anime: SAnime): SAnime {
        return anime.apply {
            title = "Fetched Title"
            description = "Updated description"
            genre = "Action, Adventure"
            status = SAnime.ONGOING
            thumbnail_url = "https://example.com/thumb.jpg"
        }
    }

    override suspend fun getEpisodeList(anime: SAnime): List<SEpisode> {
        return listOf(
            SEpisode.create().apply {
                url = "/episode/1"
                name = "Episode 1"
                episode_number = 1f
                date_upload = System.currentTimeMillis()
            },
            SEpisode.create().apply {
                url = "/episode/2"
                name = "Episode 2"
                episode_number = 2f
            }
        )
    }

    override suspend fun getSeasonList(anime: SAnime): List<SAnime> {
        return listOf(
            SAnime.create().apply {
                url = "/anime/show/season-1"
                title = "Season 1"
            },
            SAnime.create().apply {
                url = "/anime/show/season-2"
                title = "Season 2"
            }
        )
    }

    override suspend fun getHosterList(episode: SEpisode): List<Hoster> {
        return listOf(
            Hoster("StreamServer1", "https://stream1.example.com/ep1"),
            Hoster("StreamServer2", "https://stream2.example.com/ep1")
        )
    }

    override suspend fun getVideoList(hoster: Hoster): List<Video> {
        return listOf(
            Video("https://cdn.example.com/1080p.mp4", "1080p"),
            Video("https://cdn.example.com/720p.mp4", "720p"),
            Video("https://cdn.example.com/480p.mp4", "480p")
        )
    }
}
```

--------------------------------

### Implement Custom AnimeHttpSource

Source: https://context7.com/aniyomiorg/aniyomi/llms.txt

Provides a template for creating a new anime source by extending AnimeHttpSource. It handles requests and parsing for popular anime, search, latest updates, details, episodes, and video hosters.

```kotlin
import eu.kanade.tachiyomi.animesource.online.AnimeHttpSource
import eu.kanade.tachiyomi.animesource.model.AnimesPage
import eu.kanade.tachiyomi.animesource.model.AnimeFilterList
import okhttp3.Request
import okhttp3.Response

abstract class MyHttpAnimeSource : AnimeHttpSource() {
    override val baseUrl = "https://example.com"
    override val name = "Example Source"
    override val lang = "en"

    override fun popularAnimeRequest(page: Int): Request = GET("$baseUrl/popular?page=$page", headers)

    override fun popularAnimeParse(response: Response): AnimesPage {
        val animeList = parseAnimeListFromHtml(response.body.string())
        val hasNextPage = animeList.size >= 20
        return AnimesPage(animeList, hasNextPage)
    }

    override fun searchAnimeRequest(page: Int, query: String, filters: AnimeFilterList): Request = GET("$baseUrl/search?q=$query&page=$page", headers)

    override fun searchAnimeParse(response: Response): AnimesPage = popularAnimeParse(response)

    override fun latestUpdatesRequest(page: Int): Request = GET("$baseUrl/latest?page=$page", headers)

    override fun latestUpdatesParse(response: Response): AnimesPage = popularAnimeParse(response)

    override fun animeDetailsParse(response: Response): SAnime = SAnime.create().apply {
        title = parseTitle(response)
        description = parseDescription(response)
    }

    override fun episodeListParse(response: Response): List<SEpisode> = parseEpisodes(response)

    override fun seasonListParse(response: Response): List<SAnime> = parseSeasons(response)

    override fun hosterListParse(response: Response): List<Hoster> = parseHosters(response)

    override fun videoListParse(response: Response, hoster: Hoster): List<Video> = parseVideos(response)

    override fun List<Video>.sortVideos(): List<Video> = sortedByDescending {
        when {
            "1080p" in it.quality -> 3
            "720p" in it.quality -> 2
            "480p" in it.quality -> 1
            else -> 0
        }
    }
}
```

--------------------------------

### AnimeSource Interface Methods

Source: https://context7.com/aniyomiorg/aniyomi/llms.txt

Defines the core methods required to implement a custom anime source, including metadata fetching, episode listing, and video stream retrieval.

```APIDOC
## GET /anime/details

### Description
Fetches detailed metadata for a specific anime object.

### Method
GET

### Endpoint
/anime/details

### Parameters
#### Request Body
- **anime** (SAnime) - Required - The anime object to populate with metadata.

### Response
#### Success Response (200)
- **SAnime** (Object) - The updated anime object containing title, description, genre, status, and thumbnail_url.

## GET /anime/episodes

### Description
Retrieves a list of episodes available for a given anime.

### Method
GET

### Endpoint
/anime/episodes

### Parameters
#### Request Body
- **anime** (SAnime) - Required - The parent anime object.

### Response
#### Success Response (200)
- **List<SEpisode>** (Array) - A list of episode objects containing URL, name, episode number, and upload date.

## GET /episode/hosters

### Description
Fetches available streaming hosters for a specific episode.

### Method
GET

### Endpoint
/episode/hosters

### Parameters
#### Request Body
- **episode** (SEpisode) - Required - The episode object to fetch hosters for.

### Response
#### Success Response (200)
- **List<Hoster>** (Array) - A list of hoster objects containing server name and stream URL.

## GET /hoster/videos

### Description
Retrieves a list of video quality options from a specific hoster.

### Method
GET

### Endpoint
/hoster/videos

### Parameters
#### Request Body
- **hoster** (Hoster) - Required - The hoster object.

### Response
#### Success Response (200)
- **List<Video>** (Array) - A list of video objects containing stream URL and quality label.
```

--------------------------------

### Implement AnimeRepository Data Operations in Kotlin

Source: https://context7.com/aniyomiorg/aniyomi/llms.txt

Demonstrates how to utilize the AnimeRepository to perform CRUD operations, manage library favorites, and observe reactive data streams. This implementation uses Kotlin coroutines for asynchronous execution and Flow for reactive updates.

```kotlin
import tachiyomi.domain.entries.anime.repository.AnimeRepository
import tachiyomi.domain.entries.anime.model.AnimeUpdate
import tachiyomi.domain.library.anime.LibraryAnime

class AnimeRepositoryUsage(
    private val animeRepository: AnimeRepository
) {
    suspend fun getAnimeById(id: Long): Anime = animeRepository.getAnimeById(id)

    suspend fun getByUrlAndSource(url: String, sourceId: Long): Anime? {
        return animeRepository.getAnimeByUrlAndSourceId(url, sourceId)
    }

    suspend fun getFavorites(): List<Anime> = animeRepository.getAnimeFavorites()

    suspend fun getLibraryAnime(): List<LibraryAnime> = animeRepository.getLibraryAnime()

    fun observeLibrary() {
        viewModelScope.launch {
            animeRepository.getLibraryAnimeAsFlow().collect { libraryItems ->
                processLibraryItems(libraryItems)
            }
        }
    }

    suspend fun findDuplicates(id: Long, title: String): List<Anime> {
        return animeRepository.getDuplicateLibraryAnime(id, title)
    }

    suspend fun updateAnime(animeId: Long, newTitle: String) {
        val update = AnimeUpdate(
            id = animeId,
            title = newTitle,
            lastUpdate = System.currentTimeMillis()
        )
        animeRepository.updateAnime(update)
    }

    suspend fun markMultipleFavorite(animeIds: List<Long>) {
        val updates = animeIds.map { id ->
            AnimeUpdate(id = id, favorite = true)
        }
        animeRepository.updateAllAnime(updates)
    }

    suspend fun insertAnime(anime: Anime): Long? {
        return animeRepository.insertAnime(anime)
    }

    suspend fun setCategories(animeId: Long, categoryIds: List<Long>) {
        animeRepository.setAnimeCategories(animeId, categoryIds)
    }

    suspend fun getUpcoming(statuses: Set<Long>) {
        animeRepository.getUpcomingAnime(statuses).collect { upcomingList ->
            displayUpcoming(upcomingList)
        }
    }
}
```

--------------------------------

### GetAnime Interactor for Anime Data Retrieval in Kotlin

Source: https://context7.com/aniyomiorg/aniyomi/llms.txt

The `GetAnime` interactor provides methods to retrieve anime entries from the repository. It supports both one-time fetching using `await` and reactive observation using `subscribe` with Kotlin Coroutines and Flows. This is essential for displaying anime details and updates.

```kotlin
import tachiyomi.domain.entries.anime.interactor.GetAnime
import kotlinx.coroutines.flow.collect

class AnimeDetailViewModel(
    private val getAnime: GetAnime
) {
    // One-time fetch by ID
    suspend fun loadAnime(animeId: Long): Anime? {
        return getAnime.await(animeId)
    }

    // Reactive subscription by ID
    fun observeAnime(animeId: Long) {
        viewModelScope.launch {
            getAnime.subscribe(animeId).collect {
                // Update UI with anime changes
                updateState(it)
            }
        }
    }

    // Subscribe by URL and source
    fun observeAnimeByUrl(url: String, sourceId: Long) {
        viewModelScope.launch {
            getAnime.subscribe(url, sourceId).collect {
                it?.let { updateState(it) }
            }
        }
    }
}
```

--------------------------------

### Episode Model API

Source: https://context7.com/aniyomiorg/aniyomi/llms.txt

Details the Aniyomi Episode data model, including properties for viewing progress and episode metadata.

```APIDOC
## Episode Model

### Description
The `Episode` data class represents a single anime episode with viewing progress and metadata.

### Method
N/A (Data Model)

### Endpoint
N/A (Data Model)

### Parameters
N/A (Data Model)

### Request Example
```kotlin
import tachiyomi.domain.items.episode.model.Episode

val episode = Episode(
    id = 1L,
    animeId = 1L,
    seen = false,
    bookmark = false,
    fillermark = false,  // Mark as filler episode
    lastSecondSeen = 0L,  // Playback position in seconds
    totalSeconds = 1440L,  // Total duration (24 minutes)
    dateFetch = System.currentTimeMillis(),
    sourceOrder = 1L,
    url = "/episode/1",
    name = "Episode 1: The Beginning",
    dateUpload = System.currentTimeMillis(),
    episodeNumber = 1.0,
    scanlator = "SubGroup",
    summary = "Our hero begins their journey...",
    previewUrl = "https://example.com/preview1.jpg",
    lastModifiedAt = System.currentTimeMillis(),
    version = 1L
)

// Check if episode number is recognized
val hasValidNumber = episode.isRecognizedNumber  // true if >= 0
```

### Response
N/A (Data Model)
```

--------------------------------

### GetManga Interactor for Manga Data Retrieval in Kotlin

Source: https://context7.com/aniyomiorg/aniyomi/llms.txt

Similar to `GetAnime`, the `GetManga` interactor facilitates fetching and observing manga entries. It utilizes `await` for single fetches and `subscribe` for reactive updates, following the same API pattern as `GetAnime` for consistency in data access.

```kotlin
import tachiyomi.domain.entries.manga.interactor.GetManga

class MangaDetailViewModel(
    private val getManga: GetManga
) {
    suspend fun loadManga(mangaId: Long): Manga? {
        return getManga.await(mangaId)
    }

    fun observeManga(mangaId: Long) {
        viewModelScope.launch {
            getManga.subscribe(mangaId).collect {
                updateState(it)
            }
        }
    }
}
```

--------------------------------

### Manage Library Preferences with LibraryPreferences in Kotlin

Source: https://context7.com/aniyomiorg/aniyomi/llms.txt

This Kotlin code defines a class to manage various library preferences using the LibraryPreferences service. It allows setting display modes, sorting options, auto-update intervals, filters, badge visibility, default categories, episode display settings, column layouts, and swipe actions for library items.

```kotlin
import tachiyomi.domain.library.service.LibraryPreferences
import tachiyomi.core.common.preference.TriState

class LibrarySettings(
    private val libraryPreferences: LibraryPreferences
) {
    // Display mode
    fun setDisplayMode(mode: LibraryDisplayMode) {
        libraryPreferences.displayMode().set(mode)
    }

    // Sorting
    fun setAnimeSorting(sort: AnimeLibrarySort) {
        libraryPreferences.animeSortingMode().set(sort)
    }

    // Auto-update settings
    fun setAutoUpdateInterval(hours: Int) {
        libraryPreferences.autoUpdateInterval().set(hours)
    }

    // Filter settings
    fun setDownloadedFilter(state: TriState) {
        libraryPreferences.filterDownloadedAnime().set(state)
    }

    fun setUnseenFilter(state: TriState) {
        libraryPreferences.filterUnseen().set(state)
    }

    // Badge display
    fun setShowDownloadBadge(show: Boolean) {
        libraryPreferences.downloadBadge().set(show)
    }

    fun setShowUnreadBadge(show: Boolean) {
        libraryPreferences.unreadBadge().set(show)
    }

    // Category settings
    fun setDefaultAnimeCategory(categoryId: Int) {
        libraryPreferences.defaultAnimeCategory().set(categoryId)
    }

    // Episode display defaults
    fun setEpisodeDefaults(anime: Anime) {
        libraryPreferences.setEpisodeSettingsDefault(anime)
    }

    // Column settings
    fun setPortraitColumns(columns: Int) {
        libraryPreferences.animePortraitColumns().set(columns)
    }

    fun setLandscapeColumns(columns: Int) {
        libraryPreferences.animeLandscapeColumns().set(columns)
    }

    // Swipe actions
    fun setEpisodeSwipeStartAction(action: LibraryPreferences.EpisodeSwipeAction) {
        libraryPreferences.swipeEpisodeStartAction().set(action)
    }
}
```

--------------------------------

### Define Chapter Data Model in Kotlin

Source: https://context7.com/aniyomiorg/aniyomi/llms.txt

The `Chapter` data class models a manga chapter, including its ID, associated manga ID, reading progress (read status, last page read), dates (fetch, upload, last modified), URL, name, chapter number, scanlator, and version. It's a core component for tracking chapter information.

```kotlin
import tachiyomi.domain.items.chapter.model.Chapter

val chapter = Chapter(
    id = 1L,
    mangaId = 1L,
    read = false,
    bookmark = false,
    lastPageRead = 0L,
    dateFetch = System.currentTimeMillis(),
    sourceOrder = 1L,
    url = "/chapter/1",
    name = "Chapter 1: Prologue",
    dateUpload = System.currentTimeMillis(),
    chapterNumber = 1.0,
    scanlator = "ScanGroup",
    lastModifiedAt = System.currentTimeMillis(),
    version = 1L
)
```

--------------------------------

### Anime Model API

Source: https://context7.com/aniyomiorg/aniyomi/llms.txt

Details the Aniyomi Anime data model, including its properties for metadata, viewing state, and filtering options.

```APIDOC
## Anime Model

### Description
The `Anime` data class represents an anime entry in the library with comprehensive metadata, viewing state, filtering options, and season management capabilities.

### Method
N/A (Data Model)

### Endpoint
N/A (Data Model)

### Parameters
N/A (Data Model)

### Request Example
```kotlin
import tachiyomi.domain.entries.anime.model.Anime
import eu.kanade.tachiyomi.animesource.model.AnimeUpdateStrategy
import eu.kanade.tachiyomi.animesource.model.FetchType

val anime = Anime(
    id = 1L,
    source = 123456789L,  // Source identifier
    favorite = true,
    lastUpdate = System.currentTimeMillis(),
    nextUpdate = System.currentTimeMillis() + 86400000,
    fetchInterval = 7,
    dateAdded = System.currentTimeMillis(),
    viewerFlags = 0L,
    episodeFlags = Anime.EPISODE_SORT_DESC or Anime.EPISODE_SHOW_UNSEEN,
    coverLastModified = 0L,
    backgroundLastModified = 0L,
    url = "/anime/my-anime",
    title = "My Anime Title",
    artist = "Studio Name",
    author = "Director Name",
    description = "An exciting anime about...",
    genre = listOf("Action", "Adventure", "Fantasy"),
    status = 1L,  // 1 = Ongoing, 2 = Completed
    thumbnailUrl = "https://example.com/cover.jpg",
    backgroundUrl = null,
    updateStrategy = AnimeUpdateStrategy.ALWAYS_UPDATE,
    initialized = true,
    lastModifiedAt = System.currentTimeMillis(),
    favoriteModifiedAt = System.currentTimeMillis(),
    version = 1L,
    fetchType = FetchType.Episodes,
    parentId = null,
    seasonFlags = 0L,
    seasonNumber = -1.0,
    seasonSourceOrder = 0L
)

// Access computed properties
val isAscending = !anime.sortDescending()
val unseenFilter = anime.unseenFilter  // TriState: DISABLED, ENABLED_IS, ENABLED_NOT
val skipIntro = anime.skipIntroLength  // Skip intro duration in seconds
val nextEpisode = anime.nextEpisodeToAir
```

### Response
N/A (Data Model)
```

--------------------------------

### GetAnimeHistory Interactor for Viewing History in Kotlin

Source: https://context7.com/aniyomiorg/aniyomi/llms.txt

The `GetAnimeHistory` interactor is used to access and search viewing history for anime. It allows fetching history for a specific anime using `await` and subscribing to history updates based on a search query using `subscribe` with Kotlin Coroutines.

```kotlin
import tachiyomi.domain.history.anime.interactor.GetAnimeHistory
import tachiyomi.domain.history.anime.model.AnimeHistoryWithRelations

class HistoryViewModel(
    private val getAnimeHistory: GetAnimeHistory
) {
    // Get history for specific anime
    suspend fun getHistoryForAnime(animeId: Long) {
        val history = getAnimeHistory.await(animeId)
        // Process history entries
    }

    // Search history with query
    fun searchHistory(query: String) {
        viewModelScope.launch {
            getAnimeHistory.subscribe(query).collect {
                updateHistoryList(it)
            }
        }
    }
}
```

--------------------------------

### Manga Model API

Source: https://context7.com/aniyomiorg/aniyomi/llms.txt

Details the Aniyomi Manga data model, including properties for reading progress, chapter filtering, and display preferences.

```APIDOC
## Manga Model

### Description
The `Manga` data class represents a manga entry with reading progress tracking, chapter filtering, and display preferences.

### Method
N/A (Data Model)

### Endpoint
N/A (Data Model)

### Parameters
N/A (Data Model)

### Request Example
```kotlin
import tachiyomi.domain.entries.manga.model.Manga
import eu.kanade.tachiyomi.source.model.UpdateStrategy

val manga = Manga(
    id = 1L,
    source = 987654321L,
    favorite = true,
    lastUpdate = System.currentTimeMillis(),
    nextUpdate = System.currentTimeMillis() + 86400000,
    fetchInterval = 7,
    dateAdded = System.currentTimeMillis(),
    viewerFlags = 0L,
    chapterFlags = Manga.CHAPTER_SORT_DESC or Manga.CHAPTER_SHOW_UNREAD,
    coverLastModified = 0L,
    url = "/manga/my-manga",
    title = "My Manga Title",
    artist = "Artist Name",
    author = "Author Name",
    description = "A captivating manga about...",
    genre = listOf("Romance", "Drama", "Slice of Life"),
    status = 2L,  // Completed
    thumbnailUrl = "https://example.com/manga-cover.jpg",
    updateStrategy = UpdateStrategy.ALWAYS_UPDATE,
    initialized = true,
    lastModifiedAt = System.currentTimeMillis(),
    favoriteModifiedAt = System.currentTimeMillis(),
    version = 1L
)

// Filter and sort configurations
val unreadFilter = manga.unreadFilter
val bookmarkedFilter = manga.bookmarkedFilter
val sortingMode = manga.sorting  // CHAPTER_SORTING_SOURCE, NUMBER, UPLOAD_DATE, ALPHABET
```

### Response
N/A (Data Model)
```

--------------------------------

### GetAnimeCategories Interactor for Category Management in Kotlin

Source: https://context7.com/aniyomiorg/aniyomi/llms.txt

The `GetAnimeCategories` interactor handles the retrieval and observation of categories for organizing anime. It provides methods to fetch all categories, categories for a specific anime, and reactive subscriptions for real-time updates to the category list.

```kotlin
import tachiyomi.domain.category.anime.interactor.GetAnimeCategories
import tachiyomi.domain.category.model.Category

class CategoryManager(
    private val getAnimeCategories: GetAnimeCategories
) {
    // Get all categories
    suspend fun getAllCategories(): List<Category> {
        return getAnimeCategories.await()
    }

    // Get categories for specific anime
    suspend fun getCategoriesForAnime(animeId: Long): List<Category> {
        return getAnimeCategories.await(animeId)
    }

    // Observe all categories reactively
    fun observeCategories() {
        viewModelScope.launch {
            getAnimeCategories.subscribe().collect {
                updateCategoryList(it)
            }
        }
    }

    // Observe categories for specific anime
    fun observeAnimeCategories(animeId: Long) {
        viewModelScope.launch {
            getAnimeCategories.subscribe(animeId).collect {
                updateAnimeCategories(it)
            }
        }
    }
}
```

=== COMPLETE CONTENT === This response contains all available snippets from this library. No additional content exists. Do not make further requests.