Seanime Extensions

https://seanime.gitbook.io/seanime-extensions
Admin
Seanime Extensions is a comprehensive documentation and development guide for creating...
Tokens:73,387
Snippets:785
Trust Score:9.8
Update:2 months ago
Show doc for...
Tokens:
Raw
### Plugin storage implementation example

Source: https://seanime.gitbook.io/seanime-extensions/plugins/apis/storage.md

A complete example showing how to store scan duration history and register a UI callback to update storage.

```typescript
// A simple plugin that stores the history of scan durations
function init() {
    $app.onScanCompleted((e) => {
        // Store the scanning duration (in ms)
        $store.set("scan-completed", e.duration)
        
        e.next()
    })
    
    $ui.register((ctx) => {
    
        // Callback is triggered when the value is updated
        $store.watch<number>("scan-completed", (value) => {
            const date = new Date()
            const now = date.toISOString().replaceall(".", "_")
            
            // Add the value to the history
            $storage.set("scan-duration-history."+now, {
                duration: value,
                durationInSeconds: value/1000,
                addedAt: date,
            })
            
            ctx.toast.info(`Scanning took ${value/1000} seconds!`)
        })
        
        function deleteHistory() {
            $storage.remove("scan-duration-history")
        }
    })
}
```

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

### ctx.cron.start

Source: https://seanime.gitbook.io/seanime-extensions/plugins/ui/cron.md

Starts the cron scheduler.

```APIDOC
## ctx.cron.start()

### Description
Starts the scheduler. If called while already running, it restarts the scheduler.
```

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

### Query documentation via HTTP GET

Source: https://seanime.gitbook.io/seanime-extensions/llms.txt

Perform an HTTP GET request to the documentation index with an ask parameter and an optional goal parameter to receive tailored answers.

```http
GET https://seanime.gitbook.io/seanime-extensions/plugins/apis/system.md?ask=<question>&goal=<end_goal>
```

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

### getPreviousStreamOptions

Source: https://seanime.gitbook.io/seanime-extensions/plugins/ui/anime-library/torrentstream.md

Returns the previous torrentstream start options, or undefined if no stream has been started yet.

```APIDOC
## getPreviousStreamOptions()

### Description
Returns the previous torrentstream start options, or undefined if no stream has been started yet.
```

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

### Implement Webview with Preact

Source: https://seanime.gitbook.io/seanime-extensions/plugins/ui/user-interface/webview.md

A comprehensive example demonstrating state management, webview creation, and event handling using Preact.

```typescript
function init() {
    $ui.register((ctx) => {
        // In a real plugin, you'd likely load this from whatever resource
        const currentMedia = ctx.state({
            id: 101,
            title: "Frieren: Beyond Journey's End",
            cover: "https://s4.anilist.co/file/anilistcdn/media/anime/cover/large/bx154587-qQTzQnEJJ3oB.jpg"
        })

        const notes = ctx.state<Array<{ id: string, text: string, checked: boolean }>>([
            { id: "2", text: "Check discussion for latest episode", checked: true },
            { id: "1", text: "Watch the next season", checked: false },
        ])

        // Create the Webview
        const panel = ctx.newWebview({
            slot: "screen",
            fullWidth: true,
            autoHeight: true,
            sidebar: {
                label: "Notepad",
                icon: `<svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><path d="M16 4h2a2 2 0 0 1 2 2v14a2 2 0 0 1-2 2H6a2 2 0 0 1-2-2V6a2 2 0 0 1 2-2h2"/><rect x="8" y="2" width="8" height="4" rx="1" ry="1"/></svg>`,
            },
        })

        // Setup Communication
        // Automatically keep 'notes' and 'currentMedia' variables in sync with the webview
        panel.channel.sync("notes", notes)
        panel.channel.sync("media", currentMedia)

        // Handle events sent from the webview
        panel.channel.on("add-note", (text) => {
            console.log("Received note:", text)
            const newNote = { id: Date.now().toString(), text, checked: false }
            // Updating this state automatically sends the new value to the webview thanks to .sync()
            notes.set([...notes.get(), newNote])
            ctx.toast.success("Note added")
        })

        panel.channel.on("toggle-note", (id) => {
            notes.set(prev => prev.map(n => n.id === id ? { ...n, checked: !n.checked } : n))
        })

        panel.channel.on("delete-note", (id) => {
            notes.set(prev => prev.filter(n => n.id !== id))
        })
```

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

### ctx.playback.startManualTracking(opts)

Source: https://seanime.gitbook.io/seanime-extensions/plugins/ui/anime-library/playback-external.md

Starts manual progress tracking for media not launched through Seanime's integrated playback APIs.

```APIDOC
## startManualTracking(opts)

### Description
Starts manual progress tracking for media that is not being launched through Seanime's integrated playback APIs. If clientId is omitted, Seanime broadcasts it to all clients.

### Parameters
- **opts** (PlaybackManualTrackingOptions) - Required
  - **mediaId** (Number) - Required - AniList media ID to track
  - **episodeNumber** (Number) - Required - Episode number to sync
  - **clientId** (String) - Optional - Client ID override

### Example
```typescript
await ctx.playback.startManualTracking({
  mediaId: 21,
  episodeNumber: 1,
})
```

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

### Start manual tracking

Source: https://seanime.gitbook.io/seanime-extensions/plugins/ui/anime-library/playback-external.md

Initiates progress tracking for media not launched via integrated APIs.

```typescript
await ctx.playback.startManualTracking({
  mediaId: 21,
  episodeNumber: 1,
})
```

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

### Open External Player Example

Source: https://seanime.gitbook.io/seanime-extensions/plugins/ui/anime-library/external-player-link.md

Demonstrates how to open a specific video URL while providing tracking information for AniList.

```javascript
// Open a video in an external player with tracking
ctx.externalPlayerLink.open(
  "https://example.com/videos/one-piece-1015.mkv",
  21,  // One Piece media ID
  1015 // Episode number
)
```

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

### startStream

Source: https://seanime.gitbook.io/seanime-extensions/plugins/ui/anime-library/torrentstream.md

Starts a torrent stream. Requires playback permission.

```APIDOC
## startStream(options)

### Description
Starts a torrent stream. If playbackType is "nativeplayer" or "externalPlayerLink", clientId is required.

### Parameters
- **options.mediaId** (Number) - Required
- **options.episodeNumber** (Number) - Required - Relative episode number
- **options.aniDbEpisode** (String) - Required - AniDB episode identifier
- **options.playbackType** (String) - Required - "default" | "externalPlayerLink" | "nativeplayer" | "none" | "noneAndAwait"
- **options.autoSelect** (Boolean) - Optional
- **options.torrent** (Object) - Optional - $app.HibikeTorrent_AnimeTorrent
- **options.fileIndex** (Number) - Optional
- **options.userAgent** (String) - Optional
- **options.clientId** (String) - Optional
- **options.batchEpisodeFiles** (Object) - Optional - TorrentstreamBatchEpisodeFiles
```

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

### Handling Navigation and Data Fetching

Source: https://seanime.gitbook.io/seanime-extensions/plugins/ui/basics.md

This example demonstrates tracking navigation events to fetch data dynamically based on URL parameters.

```typescript
const currentMediaId = ctx.state<number | null>(null)
const fetchedData = ctx.state([])

// When the user navigates to an anime, get the media ID
ctx.screen.onNavigate((e) => {
    if (e.pathname === "/entry" && !!e.searchParams.id) {
        const id = parseInt(e.searchParams.id);
        currentMediaId.set(id);
    } else {
        currentMediaId.set(null);
    }
});

// Trigger 'ctx.screen.onNavigate' when the plugin loads 
ctx.screen.loadCurrent()

// Fetch data each time the media ID changes.
ctx.effect(async () => {
    if (!currentMediaId.get()) return
    
    const res = ctx.fetch(`https://example.com/anilistId?=${currentMediaId.get()}`)
    // Store the results
    fetchedData.set(res.json())
}, [currentMediaId])
```

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

### startStream(options)

Source: https://seanime.gitbook.io/seanime-extensions/plugins/ui/anime-library/debridstream.md

Starts a new debrid stream with the provided configuration options.

```APIDOC
## startStream(options)

### Description
Starts a debrid stream. If playbackType is "nativeplayer" or "externalPlayerLink", clientId is required.

### Parameters
- **options.mediaId** (Number) - Required
- **options.episodeNumber** (Number) - Required - Relative episode number
- **options.aniDBEpisode** (String) - Required - AniDB episode identifier
- **options.playbackType** (String) - Required - "default" | "externalPlayerLink" | "nativeplayer" | "none" | "noneAndAwait"
- **options.torrent** ($app.HibikeTorrent_AnimeTorrent) - Optional
- **options.fileId** (String) - Optional - Provider file ID
- **options.fileIndex** (Number) - Optional - Manual file index
- **options.userAgent** (String) - Optional
- **options.clientId** (String) - Optional - Required if playback type is nativeplayer or externalPlayerLink
- **options.autoSelect** (Boolean) - Optional
- **options.batchEpisodeFiles** (TorrentstreamBatchEpisodeFiles) - Optional

### Request Example
await ctx.debridstream.startStream({
  mediaId: 21,
  episodeNumber: 1,
  aniDBEpisode: "1",
  playbackType: "default",
  autoSelect: true,
})
```

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

### Manage extensions via UI tray

Source: https://seanime.gitbook.io/seanime-extensions/plugins/ui/other/extensions.md

Example demonstrating how to register event handlers to enable or disable extensions based on user input in a tray.

```typescript
$ui.register((ctx) => {
    const tray = ctx.newTray({
        tooltipText: "Extension manager",
        withContent: true,
    })

    const extensionIdRef = ctx.fieldRef("my-other-plugin")

    ctx.registerEventHandler("disable-extension", async () => {
        try {
            await ctx.extensions.disable(extensionIdRef.current ?? "")
            ctx.toast.warning("Extension disabled")
        } catch (error) {
            ctx.toast.alert(`Disable failed: ${error.message}`)
        }
    })

    ctx.registerEventHandler("enable-extension", async () => {
        try {
            await ctx.extensions.enable(extensionIdRef.current ?? "")
            ctx.toast.success("Extension enabled")
        } catch (error) {
            ctx.toast.alert(`Enable failed: ${error.message}`)
        }
    })

    tray.render(() => tray.stack([
        tray.input("Extension ID", { fieldRef: extensionIdRef }),
        tray.button("Disable", { onClick: "disable-extension" }),
        tray.button("Enable", { onClick: "enable-extension" }),
    ]))
})
```

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

### Manage app settings via UI plugin

Source: https://seanime.gitbook.io/seanime-extensions/plugins/ui/other/app-settings.md

Demonstrates reading settings with get and updating them with patch within a UI plugin context.

```typescript
$ui.register((ctx) => {
    const tray = ctx.newTray({
        tooltipText: "Library settings",
        withContent: true,
    })

    const autoScanState = ctx.state<boolean | null>(null)

    async function loadAutoScan() {
        const enabled = await ctx.appSettings.get(
            "library.autoScan",
            false,
        )
        autoScanState.set(Boolean(enabled))
    }

    ctx.registerEventHandler("refresh-auto-scan", async () => {
        try {
            await loadAutoScan()
            ctx.toast.info("Loaded app settings")
        } catch (error) {
            ctx.toast.alert(`Could not read settings: ${error.message}`)
        }
    })

    ctx.registerEventHandler("toggle-auto-scan", async () => {
        try {
            const nextValue = !autoScanState.get()
            await ctx.appSettings.patch({
                library: {
                    autoScan: nextValue,
                },
            })
            autoScanState.set(nextValue)
            ctx.toast.success(`Auto Scan: ${nextValue ? "on" : "off"}`)
        } catch (error) {
            ctx.toast.alert(`Could not update settings: ${error.message}`)
        }
    })

    tray.render(() => tray.stack([
        tray.text(`Auto Scan: ${autoScanState.get() === null ? "unknown" : autoScanState.get() ? "enabled" : "disabled"}`),
        tray.button("Refresh", { onClick: "refresh-auto-scan" }),
        tray.button("Toggle", { onClick: "toggle-auto-scan" }),
    ]))

    loadAutoScan()
})
```

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

### getTorrentFilePreviews

Source: https://seanime.gitbook.io/seanime-extensions/plugins/ui/downloading/debrid.md

Gets file previews for a torrent.

```APIDOC
## getTorrentFilePreviews(options)

### Description
Returns parsed file previews for a torrent before manual selection.

### Returns
Promise<DebridFilePreview[]>
```

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

### Store Usage Example

Source: https://seanime.gitbook.io/seanime-extensions/plugins/apis/store.md

Demonstrates storing scan duration data and watching for updates to trigger UI notifications.

```typescript
// A simple plugin that stores the history of scan durations
function init() {
    $app.onScanCompleted((e) => {
        // Store the scanning duration (in ms)
        $store.set("scan-completed", e.duration)
        
        e.next()
    })
    
    $ui.register((ctx) => {
    
        // Callback is triggered when the value is updated
        $store.watch<number>("scan-completed", (value) => {
            const now = new Date().toISOString().replaceall(".", "_")
            $storage.set("scan-duration-history."+now, value)
            ctx.toast.info(`Scanning took ${value/1000} seconds!`)
        })
    })
}
```

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

### Register and Start Cron Job

Source: https://seanime.gitbook.io/seanime-extensions/plugins/ui/cron.md

Use ctx.cron.add to define a job with a cron expression and callback, then call ctx.cron.start to initiate the scheduler.

```typescript
$ui.register((ctx) => {
    ctx.cron.add("refresh-anime-cache", "*/15 * * * *", () => {
        console.log("refreshing anime cache")
    })

    ctx.cron.start()
})
```

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

### playStream

Source: https://seanime.gitbook.io/seanime-extensions/plugins/ui/anime-library/videocore.md

Starts playback of a URL in the built-in Denshi player with progress tracking.

```APIDOC
### playStream(streamUrl, anidbEpisode, media)

Starts playback of a URL in the built-in Denshi player with progress tracking.

#### Parameters
- **streamUrl** (String) - The URL to stream
- **anidbEpisode** (String) - AniDB episode identifier used for progress tracking
- **media** (AL_BaseAnime) - AniList anime object used for progress tracking
```

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

### playLocalFile

Source: https://seanime.gitbook.io/seanime-extensions/plugins/ui/anime-library/videocore.md

Starts playback of a scanned local file in the built-in Denshi player with progress tracking.

```APIDOC
### playLocalFile(path)

Starts playback of a scanned local file in the built-in Denshi player with progress tracking.

#### Parameters
- **path** (String) - Absolute path to the local file
```

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

### Start a Torrent Stream

Source: https://seanime.gitbook.io/seanime-extensions/plugins/ui/anime-library/torrentstream.md

Initiates a torrent stream with the specified media and playback options.

```typescript
await ctx.torrentstream.startStream({
  mediaId: 21,
  episodeNumber: 1,
  aniDbEpisode: "1",
  playbackType: "default",
  autoSelect: true,
})
```

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

### Play local file

Source: https://seanime.gitbook.io/seanime-extensions/plugins/ui/anime-library/videocore.md

Starts playback of a local file that has already been scanned into the library.

```typescript
await ctx.videoCore.playLocalFile("/anime/One Piece/One Piece - 1015.mkv")
```

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

### Get auto-downloader settings

Source: https://seanime.gitbook.io/seanime-extensions/plugins/ui/anime-library/auto-downloader.md

Retrieves the current configuration settings, returning undefined if not configured.

```typescript
const settings = ctx.autoDownloader.getSettings()
console.log(settings)
```

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

### Bootstrap a new provider project

Source: https://seanime.gitbook.io/seanime-extensions/content-providers/online-streaming-provider.md

Use this command to quickly initialize a new provider folder locally.

```bash
npx seanime-tool g-template
```

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

### cmd.open

Source: https://seanime.gitbook.io/seanime-extensions/plugins/ui/user-interface/command-palette.md

Opens the command palette UI.

```APIDOC
## cmd.open()

### Description
Displays the command palette to the user.
```

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

### getStyle(property?)

Source: https://seanime.gitbook.io/seanime-extensions/plugins/ui/user-interface/dom.md

Gets the style of the element.

```APIDOC
## getStyle(property?)

### Description
Gets the style of the element.

### Parameters
- **property** (string) - Optional - The CSS property name.

### Returns
- **Promise<string | Record<string, string>>** - The style value or all styles.
```

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

### Initialize Tray Base Components

Source: https://seanime.gitbook.io/seanime-extensions/plugins/ui/user-interface/tray.md

List of available base UI components for building tray layouts.

```typescript
tray.div([], { style: {} })
tray.stack([], { style: {} })
tray.flex([], { style: {} })
tray.text(...)
tray.anchor(...)
tray.a(...)
tray.p(...)
tray.span(...)
tray.css(...)
tray.badge(...)
tray.alert(...)
tray.img(...)
```

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

### getTorrentInfo

Source: https://seanime.gitbook.io/seanime-extensions/plugins/ui/downloading/debrid.md

Gets info for a specific torrent.

```APIDOC
## getTorrentInfo(options)

### Description
Gets torrent info from the configured debrid provider.

### Parameters
- **options.magnetLink** (String) - Optional
- **options.infoHash** (String) - Optional
```

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

### getComputedStyle(property)

Source: https://seanime.gitbook.io/seanime-extensions/plugins/ui/user-interface/dom.md

Gets the computed style of the element.

```APIDOC
## getComputedStyle(property)

### Description
Gets the computed style of the element.

### Parameters
- **property** (string) - Required - The CSS property name.

### Returns
- **Promise** - The computed style value.
```

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

### Get entry download info

Source: https://seanime.gitbook.io/seanime-extensions/plugins/ui/anime-library/anime.md

Builds download information for an anime entry based on local files and collection progress.

```typescript
const info = await ctx.anime.getEntryDownloadInfo(21)
console.log(info)
```

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

### Get all element attributes

Source: https://seanime.gitbook.io/seanime-extensions/plugins/ui/user-interface/dom.md

Retrieves all attributes of an element as a record.

```typescript
const image = await ctx.dom.queryOne("img.poster")
const attributes = await image.getAttributes()
console.log(`Image src: ${attributes.src}`)
console.log(`Image alt: ${attributes.alt}`)
```

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

### ctx.playback.getNextEpisode()

Source: https://seanime.gitbook.io/seanime-extensions/plugins/ui/anime-library/playback-external.md

Gets the next episode to play after the current one.

```APIDOC
## getNextEpisode()

### Description
Gets the next episode to play after the current one.

### Example
```typescript
try {
  const nextEpisode = await ctx.playback.getNextEpisode()
  if (nextEpisode) {
    console.log(`Next episode: ${nextEpisode.name}`)
  } else {
    console.log("No next episode available")
  }
} catch (error) {
  console.error("Error getting next episode:", error)
}
```

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

### ctx.settings.define(name, defaults)

Source: https://seanime.gitbook.io/seanime-extensions/plugins/ui/helpers.md

Creates a settings helper scoped to a specific namespace.

```APIDOC
## ctx.settings.define(name, defaults)

### Description
Creates a settings helper scoped to one namespace. Returns a settings object that exposes methods for managing the defined settings.

### Parameters
- **name** (string) - Required - The namespace for the settings.
- **defaults** (object) - Required - The default values for the settings.

### Example
```typescript
const settings = ctx.settings.define("banner-images", {
    enabled: true,
    opacity: 0.8,
})
```
```

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

### ctx.newCommandPalette

Source: https://seanime.gitbook.io/seanime-extensions/plugins/ui/user-interface/command-palette.md

Initializes a new command palette instance for the plugin.

```APIDOC
## ctx.newCommandPalette(options)

### Description
Creates a new command palette instance. Only one command palette can be created per plugin.

### Parameters
- **options** (object) - Required
  - **placeholder** (string) - Optional - The text displayed in the input field.
  - **keyboardShortcut** (string) - Optional - The key binding to trigger the palette (e.g., "t").
```

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

### Get next episode

Source: https://seanime.gitbook.io/seanime-extensions/plugins/ui/anime-library/playback-external.md

Retrieves information about the subsequent episode.

```typescript
// Check if there's a next episode
try {
  const nextEpisode = await ctx.playback.getNextEpisode()
  if (nextEpisode) {
    console.log(`Next episode: ${nextEpisode.name}`)
  } else {
    console.log("No next episode available")
  }
} catch (error) {
  console.error("Error getting next episode:", error)
}
```

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

### Cancel a Prepared Stream

Source: https://seanime.gitbook.io/seanime-extensions/plugins/ui/anime-library/torrentstream.md

Cancels a stream that has been prepared but not yet started.

```typescript
ctx.torrentstream.cancelPreparedStream()
```

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

### Get parent element

Source: https://seanime.gitbook.io/seanime-extensions/plugins/ui/user-interface/dom.md

Retrieves the parent of the current element as a promise.

```typescript
const listItem = await ctx.dom.queryOne("li.active")
const list = await listItem.getParent()
console.log(`Parent element tag: ${list.tagName}`)
```

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

### Get element attribute

Source: https://seanime.gitbook.io/seanime-extensions/plugins/ui/user-interface/dom.md

Retrieves the value of a specific attribute from an element.

```typescript
const link = await ctx.dom.queryOne("a.resource-link")
const href = await link.getAttribute("href")
console.log(`Resource URL: ${href}`)
```

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

### Using UI Cache Helpers

Source: https://seanime.gitbook.io/seanime-extensions/plugins/ui/helpers.md

Demonstrates using ctx.cache methods like getOrSet, remove, set, and size within a plugin registration context.

```typescript
$ui.register((ctx) => {
    const currentMediaId = ctx.state<number | null>(null)
    const currentTitle = ctx.state("Open an anime entry")

    ctx.screen.onNavigate((event) => {
        if (event.pathname === "/entry" && event.searchParams.id) {
            currentMediaId.set(parseInt(event.searchParams.id))
            return
        }

        currentMediaId.set(null)
        currentTitle.set("Open an anime entry")
        ctx.cache.remove("current-entry")
    })

    ctx.effect(async () => {
        const mediaId = currentMediaId.get()
        if (!mediaId) {
            return
        }

        const animeEntry = await ctx.cache.getOrSet(
            `anime-entry:${mediaId}`,
            () => ctx.anime.getAnimeEntry(mediaId),
            { ttl: 60_000 },
        )

        currentTitle.set(animeEntry?.media?.title?.userPreferred ?? "Unknown title")

        ctx.cache.set("current-entry", {
            mediaId,
            loadedAt: Date.now(),
        }, 5_000)

        console.log("cache size", ctx.cache.size())
    }, [currentMediaId])

    ctx.screen.loadCurrent()
})
```

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

### Get episode collection

Source: https://seanime.gitbook.io/seanime-extensions/plugins/ui/anime-library/anime.md

Returns the normalized episode collection for an anime.

```typescript
const episodeCollection = await ctx.anime.getEpisodeCollection(21)
console.log(episodeCollection.episodes)
```

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

### Create a Webview Panel

Source: https://seanime.gitbook.io/seanime-extensions/plugins/ui/user-interface/webview.md

Initializes a new webview panel in a specified slot. Only one webview is permitted per slot.

```typescript
// Create a panel that appears below the home screen toolbar
const panel = ctx.newWebview({
    slot: "after-home-screen-toolbar",
    fullWidth: true,
    autoHeight: true,
})
```

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

### getSettings()

Source: https://seanime.gitbook.io/seanime-extensions/plugins/ui/anime-library/auto-downloader.md

Returns the current auto-downloader settings.

```APIDOC
## getSettings()

### Description
Returns the current auto-downloader settings, or undefined if the feature is not configured.

### Returns
- **$app.Models_AutoDownloaderSettings | undefined**

### Example
```typescript
const settings = ctx.autoDownloader.getSettings()
```
```

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

### ctx.appSettings.get(path?, fallback?)

Source: https://seanime.gitbook.io/seanime-extensions/plugins/ui/other/app-settings.md

Reads the full settings object or a specific value at a dot-path. If the path is missing and a fallback is provided, it returns the fallback value.

```APIDOC
## ctx.appSettings.get(path?, fallback?)

### Description
Reads the full settings object or a dot-path inside it. If the path is missing and a fallback is provided, Seanime resolves with that fallback.

### Parameters
- **path** (string) - Optional - The dot-path to the specific setting.
- **fallback** (any) - Optional - The value to return if the path is not found.
```

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

### Get child elements

Source: https://seanime.gitbook.io/seanime-extensions/plugins/ui/user-interface/dom.md

Retrieves an array of child elements for the current element.

```typescript
const list = await ctx.dom.queryOne("ul.menu")
const listItems = await list.getChildren()
console.log(`Menu has ${listItems.length} items`)
```

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

### Provider.getSettings()

Source: https://seanime.gitbook.io/seanime-extensions/content-providers/online-streaming-provider.md

Retrieves the configuration settings for the streaming provider, including available servers and dubbing support.

```APIDOC
## getSettings()

### Description
Returns the provider's settings object containing supported episode servers and dubbing capabilities.

### Returns
- **Settings** (object) - An object containing `episodeServers` (string[]) and `supportsDub` (boolean).
```

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

### Implement settings management in a UI tray

Source: https://seanime.gitbook.io/seanime-extensions/plugins/ui/helpers.md

Demonstrates using settings, field references, and watchers within a UI tray registration.

```typescript
$ui.register((ctx) => {
    const tray = ctx.newTray({
        tooltipText: "DX settings example",
        withContent: true,
    })

    const settings = ctx.settings.define("entry-filters", {
        query: "",
        onlyUnwatched: false,
        sort: "title",
    })

    const queryRef = settings.fieldRef("query")

    queryRef.onValueChange((value) => {
        settings.set("query", value)
    })

    const stopWatching = settings.watch((nextSettings) => {
        console.log("filters updated", nextSettings)
    })

    ctx.registerEventHandler("toggle-unwatched", () => {
        settings.set("onlyUnwatched", !settings.get("onlyUnwatched", false))
    })

    ctx.registerEventHandler("reset-filters", () => {
        settings.reset()
        queryRef.setValue(settings.get("query", ""))
        ctx.toast.success("Filters reset")
    })

    ctx.registerEventHandler("stop-filter-watch", () => {
        stopWatching()
        ctx.toast.info("Stopped watching settings changes")
    })

    tray.render(() => tray.stack([
        tray.text(`Sort: ${settings.get("sort", "title")}`),
        tray.text(`Only unwatched: ${settings.get("onlyUnwatched", false) ? "yes" : "no"}`),
        tray.input("Search", { fieldRef: queryRef }),
        tray.button("Toggle unwatched", { onClick: "toggle-unwatched" }),
        tray.button("Reset filters", { onClick: "reset-filters" }),
        tray.button("Stop watch", { onClick: "stop-filter-watch" }),
    ]))
})
```

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

### Get element computed style

Source: https://seanime.gitbook.io/seanime-extensions/plugins/ui/user-interface/dom.md

Retrieves the computed value of a CSS property.

```typescript
const box = await ctx.dom.queryOne(".box")
const actualWidth = await box.getComputedStyle("width")
console.log(`Box actual width: ${actualWidth}`)
```

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

### Retrieve playback type with getCurrentPlaybackType

Source: https://seanime.gitbook.io/seanime-extensions/plugins/ui/anime-library/videocore.md

Gets the type of playback currently being performed.

```typescript
const type = ctx.videoCore.getCurrentPlaybackType()
```

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

### runNow()

Source: https://seanime.gitbook.io/seanime-extensions/plugins/ui/anime-library/auto-downloader.md

Runs the auto-downloader immediately with real downloads enabled.

```APIDOC
## runNow()

### Description
Runs the auto-downloader immediately with real downloads enabled. This call is non-blocking.

### Example
```typescript
ctx.autoDownloader.runNow()
```
```

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

### Retrieve player type with getCurrentPlayerType

Source: https://seanime.gitbook.io/seanime-extensions/plugins/ui/anime-library/videocore.md

Gets the type of the currently active player.

```typescript
const type = ctx.videoCore.getCurrentPlayerType()
```

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

### Define plugin entry point

Source: https://seanime.gitbook.io/seanime-extensions/plugins/write-test-share.md

The init function serves as the entry point for the plugin when it is loaded by the system.

```typescript
function init() {
    // This function is called when the plugin is loaded
    // There is no guarantee as to when exactly the plugin will be loaded at startup
}
```

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

### Retrieve client ID with getCurrentClientId

Source: https://seanime.gitbook.io/seanime-extensions/plugins/ui/anime-library/videocore.md

Gets the unique identifier of the connected player.

```typescript
const clientId = ctx.videoCore.getCurrentClientId()
```

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

### ctx.newWebview(options)

Source: https://seanime.gitbook.io/seanime-extensions/plugins/ui/user-interface/webview.md

Creates a new webview instance within a specified slot. Only one webview is allowed per slot.

```APIDOC
## ctx.newWebview(options)

### Description
Creates a new webview panel or screen. The webview is configured via the `WebviewOptions` object.

### Parameters
- **options** (WebviewOptions) - Required - Configuration object for the webview.

### WebviewOptions
- **slot** (string) - Required - The target location for the webview (e.g., "screen", "fixed", "after-home-screen-toolbar", etc.).
- **className** (string) - Optional - CSS class name for the iframe.
- **style** (string) - Optional - Inline CSS styles for the iframe.
- **width** (string) - Optional - Width of the iframe.
- **height** (string) - Optional - Height of the iframe.
- **maxWidth** (string) - Optional - Maximum width of the iframe.
- **maxHeight** (string) - Optional - Maximum height of the iframe.
- **zIndex** (number) - Optional - Z-index of the iframe.
- **autoHeight** (boolean) - Optional - Automatically adjust height to fit content.
- **fullWidth** (boolean) - Optional - Force iframe to take full available width.
- **hidden** (boolean) - Optional - Initial visibility state.
- **sidebar** (object) - Optional - Configuration for 'screen' slot (label, icon).
- **window** (object) - Optional - Configuration for 'fixed' slot (draggable, defaultX, defaultY, defaultPosition, frameless).
```

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

### Retrieve playback info with getCurrentPlaybackInfo

Source: https://seanime.gitbook.io/seanime-extensions/plugins/ui/anime-library/videocore.md

Gets the current playback information synchronously.

```typescript
const info = ctx.videoCore.getCurrentPlaybackInfo()
```

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

### Initialize a Seanime plugin with UI and storage hooks

Source: https://seanime.gitbook.io/seanime-extensions/plugins/example.md

Uses the $ui, $storage, and $anilist APIs to manage custom banner image URLs for specific anime entries. Requires the plugin.d.ts and hooks.d.ts reference files.

```typescript
/// <reference path="./plugin.d.ts" />
/// <reference path="./hooks.d.ts" />

function init() {
    $ui.register((ctx) => {
        // Create the tray icon
        const tray = ctx.newTray({
            tooltipText: "Anime banner image",
            iconUrl: "https://seanime.rahim.app/logo_2.png",
            withContent: true,
        })
        
        // Keep track of the current media ID
        const currentMediaId = ctx.state(0)

        // Create a field ref for the URL input
        const inputRef = ctx.fieldRef()

        // When the plugin loads, fetch the current screen and set the badge to 0
        ctx.screen.loadCurrent() // Triggers onNavigate
        tray.updateBadge({ number: 0 })
        // Also fetch current screen when tray is open
        tray.onOpen(() => {
            ctx.screen.loadCurrent()
        })

        // Updates the field's value and badge based on the current anime page
        function updateState() {
            // Reset the badge and input if the user currently isn't on an anime page
            if (!currentMediaId.get()) {
                inputRef.setValue("")
                tray.updateBadge({ number: 0 })
            }
            // Get the stored banner image URL for this anime
            const url = $storage.get<string>("bannerImages." + currentMediaId.get())
            if (url) {
                // If there's a URL, set the value of the input 
                inputRef.setValue(url)
                // Add a badge
                tray.updateBadge({ number: 1, intent: "info" })
            } else {
                inputRef.setValue("")
                tray.updateBadge({ number: 0 })
            }
        }
        
        // Run the function when the plugin loads
        updateState()

        // Update currentMediaId when the user navigates
        ctx.screen.onNavigate((e) => {
            // If the user navigates to an anime page
            if (e.pathname === "/entry" && !!e.searchParams.id) {
                // Get the ID from the URL
                const id = parseInt(e.searchParams.id)
                currentMediaId.set(id)
            } else {
                currentMediaId.set(0)
            }
        })

        // This effect will update the state each time currentMediaId changes
        ctx.effect(() => {
            updateState()
        }, [currentMediaId])

        // Create a handler to store the custom banner image URL
        ctx.registerEventHandler("save", () => {
            if (!!inputRef.current) {
                $storage.set(`bannerImages.${currentMediaId.get()}`, inputRef.current)
            } else {
                $storage.remove(`bannerImages.${currentMediaId.get()}`)
            }
            ctx.toast.success("Banner image saved")
            updateState() // Update the state
            
            // Updates the data on the client
            // This is better than calling ctx.screen.reload()
            $anilist.refreshAnimeCollection()
        });
        
        // Tray content
        tray.render(() => {
            return tray.stack([
                currentMediaId.get() === 0 
                    ? tray.text("Open an anime") 
                    : tray.stack([
                        tray.text(`Current media ID: ${currentMediaId.get()}`),
                        tray.input({ fieldRef: inputRef }),
                        tray.button({ label: "Save", onClick: "save" }),
                    ])
            ])
        })
    })
```

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

### Retrieve current media with getCurrentMedia

Source: https://seanime.gitbook.io/seanime-extensions/plugins/ui/anime-library/videocore.md

Gets information about the media currently being played.

```typescript
const media = ctx.videoCore.getCurrentMedia()
console.log(media.id)
```

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

### Retrieve playback state with getPlaybackState

Source: https://seanime.gitbook.io/seanime-extensions/plugins/ui/anime-library/videocore.md

Gets the comprehensive state object of the player.

```typescript
const state = ctx.videoCore.getPlaybackState()
console.log(state.clientId, state.playerType, state.playbackInfo)
```

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

### Get anime metadata

Source: https://seanime.gitbook.io/seanime-extensions/plugins/ui/anime-library/anime.md

Retrieves raw anime metadata from a specified provider.

```typescript
const metadata = await ctx.anime.getAnimeMetadata("anilist", 21)
```

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

### $app Helper Methods

Source: https://seanime.gitbook.io/seanime-extensions/plugins/apis/helpers.md

Demonstrates basic usage of $app methods for version retrieval and client query invalidation within the UI context.

```typescript
$ui.register((ctx) => {

    $app.getVersion() // "3.7.0"
    $app.getVersionName() // "Gold"
    
    // Invalidate certain queries to cause the client to refetch them automatically
    // Find the query keys here: https://github.com/5rahim/seanime/blob/main/internal/events/endpoints.go
    $app.invalidateClientQuery([])
    
    $app.getClientIds() // Returns the client IDs
    $app.getClientPlatform("id") // Returns the platform, "web", "denshi"

})
```

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

### Get anime entry

Source: https://seanime.gitbook.io/seanime-extensions/plugins/ui/anime-library/anime.md

Retrieves an anime entry using the cache if available.

```typescript
const animeEntry = await ctx.anime.getAnimeEntry(21)
```

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

### webview.show

Source: https://seanime.gitbook.io/seanime-extensions/plugins/ui/user-interface/webview.md

Shows the webview.

```APIDOC
## webview.show()

### Description
Shows the webview.
```

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

### ctx.screen.navigateTo

Source: https://seanime.gitbook.io/seanime-extensions/plugins/ui/user-interface/screen.md

Programmatically navigates the application to a specified path with optional search parameters.

```APIDOC
## ctx.screen.navigateTo(path, params)

### Description
Navigates the webapp or desktop client to the provided path.

### Parameters
- **path** (string) - Required - The target path to navigate to.
- **params** (object) - Optional - An object containing search parameters.
```

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

### Initialize Command Palette

Source: https://seanime.gitbook.io/seanime-extensions/plugins/ui/user-interface/command-palette.md

Creates a new command palette instance with a placeholder and optional keyboard shortcut. Only one command palette can be created per plugin.

```typescript
// ...

const cmd = ctx.newCommandPalette({
    placeholder: "Search for something",
    // The command palette will open when the user presses 't'
    // You can choose to not have a keyboard shortcut
    keyboardShortcut: "t",
})

// Open the command palette when the tray icon is clicked
tray.onClick(() => {
    cmd.open()
})
```

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

### getPreviousStreamOptions()

Source: https://seanime.gitbook.io/seanime-extensions/plugins/ui/anime-library/debridstream.md

Retrieves the previous debrid stream options, returning undefined if no stream has been started.

```APIDOC
## getPreviousStreamOptions()

### Description
Returns the previous debrid stream options, or undefined if no stream has been started yet.
```

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

### Manage Downloads with Downloader API

Source: https://seanime.gitbook.io/seanime-extensions/plugins/ui/downloading/downloader.md

Demonstrates how to initiate a download, monitor progress via a watcher, and cancel an active download task.

```typescript
//...

// Destination file
// Note that $DOWNLOAD is in the allow list
const filePath = $filepath.Join($osExtra.downloadDir(), "file.zip")
const downloadUrl = "http://example.com/download/file.zip"

// Start a download
const downloadID = ctx.downloader.download(downloadUrl, filePath);

// Track progress
const cancelWatch = ctx.downloader.watch(downloadID, (progress) => {
	console.log("Download progress:", 
		progress.percentage.toFixed(2), "%, ", 
		"Speed:", (progress.speed / 1024).toFixed(2), "KB/s, ",
		"Downloaded:", (progress.totalBytes / 1024).toFixed(2), "KB"
	);
	
	if (progress.status === "completed") {
		// download completed
	} else if (progress.status === "error") {
		// something went wrong
	}
});

// Cancel at any time
ctx.downloader.cancel(downloadID)
```

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

### Start a Debrid Stream

Source: https://seanime.gitbook.io/seanime-extensions/plugins/ui/anime-library/debridstream.md

Initiates a stream using the specified media and playback options.

```typescript
await ctx.debridstream.startStream({
  mediaId: 21,
  episodeNumber: 1,
  aniDBEpisode: "1",
  playbackType: "default",
  autoSelect: true,
})
```

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

### $database.mediaFillers

Source: https://seanime.gitbook.io/seanime-extensions/plugins/apis/database.md

Methods for managing media filler data.

```APIDOC
## $database.mediaFillers.getAll()

### Description
Retrieves all media filler entries.

## $database.mediaFillers.get(mediaId)

### Description
Retrieves filler data for a specific media ID.

## $database.mediaFillers.insert(provider, mediaId, slug, episodes)

### Description
Inserts new filler data.

## $database.mediaFillers.remove(mediaId)

### Description
Removes filler data for a specific media ID.
```

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

### Get element style

Source: https://seanime.gitbook.io/seanime-extensions/plugins/ui/user-interface/dom.md

Retrieves either a specific style property or all styles of an element.

```typescript
const element = await ctx.dom.queryOne(".styled-element")
// Get single property
const color = await element.getStyle("color")
// Get all styles
const allStyles = await element.getStyle()
```

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

### Get element text content

Source: https://seanime.gitbook.io/seanime-extensions/plugins/ui/user-interface/dom.md

Retrieves the text content of a selected DOM element.

```typescript
const titleElement = await ctx.dom.queryOne(".title")
const titleText = await titleElement.getText()
console.log(`Title: ${titleText}`)
```

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

### Get Torrent Files

Source: https://seanime.gitbook.io/seanime-extensions/plugins/ui/downloading/torrent-client.md

Retrieve a list of all files contained within a specific torrent.

```javascript
// Get all files in a torrent
try {
  const files = await ctx.torrentClient.getFiles("abc123def456")
  console.log("Torrent files:", files)
} catch (error) {
  console.error("Error getting files:", error)
}
```

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

### Apply CSS and Tooltips in Tray

Source: https://seanime.gitbook.io/seanime-extensions/plugins/ui/user-interface/tray.md

Demonstrates how to inject custom CSS styles and wrap elements in tooltips within a tray layout.

```javascript
tray.div([
    tray.stack([
        tray.css(`
        .red { background-color: red; }
        `),
        // Red square
        tray.tooltip(tray.div([], { className: "square red relative" }), { text: "Test tooltip" }),
    ]),
    tray.stack([
        // No red
        tray.tooltip(tray.div([], { className: "square red relative" }), { text: "Test tooltip" }),
    ]),
])
```

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

### Get auto-scanner wait time

Source: https://seanime.gitbook.io/seanime-extensions/plugins/ui/anime-library/auto-scanner.md

Retrieves the configured debounce wait time in milliseconds.

```typescript
const waitTimeMs = ctx.autoScanner.getWaitTimeMs()
console.log(`Auto scanner wait time: ${waitTimeMs}ms`)
```

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

### scan(options?)

Source: https://seanime.gitbook.io/seanime-extensions/plugins/ui/anime-library/scanner.md

Runs a library scan immediately and returns the scanned local files.

```APIDOC
## scan(options?)

### Description
Runs a library scan immediately and persists the result to Seanime's database. Resolves to the scanned local files, or an empty array if no files are found.

### Parameters
- **options** (ScannerScanOptions) - Optional
  - **enhanced** (Boolean) - Optional
  - **enhanceWithOfflineDatabase** (Boolean) - Optional
  - **skipLockedFiles** (Boolean) - Optional
  - **skipIgnoredFiles** (Boolean) - Optional

### Returns
- **Promise<$app.Anime_LocalFile[]>** - A promise that resolves to an array of local files.

### Example
```typescript
const localFiles = await ctx.scanner.scan({
  enhanced: true,
  enhanceWithOfflineDatabase: true,
  skipLockedFiles: true,
  skipIgnoredFiles: true,
})

console.log(`Scanned ${localFiles.length} files`)
```
```

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

### $app.getClientPlatform

Source: https://seanime.gitbook.io/seanime-extensions/plugins/apis/helpers.md

Returns the platform for a connected client.

```APIDOC
## $app.getClientPlatform(clientId)

### Description
Returns the platform for a connected client, such as "web" or "denshi".

### Parameters
- **clientId** (string) - A client ID returned by $app.getClientIds().

### Returns
- **platform** (string) - The platform name, or an empty string if the client is unknown.
```

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

### Get Anime/Manga Data

Source: https://seanime.gitbook.io/seanime-extensions/plugins/apis/anilist.md

Retrieves specific anime, manga, or studio details by ID.

```typescript
/**
* Get anime by ID
*/
$anilist.getAnime(id: number): $app.AL_BaseAnime

/**
* Get manga by ID
*/
$anilist.getManga(id: number): $app.AL_BaseManga

/**
* Get detailed anime info by ID
*/
$anilist.getAnimeDetails(id: number): $app.AL_AnimeDetailsById_Media

/**
* Get detailed manga info by ID
*/
$anilist.getMangaDetails(id: number): $app.AL_MangaDetailsById_Media

/**
* Get studio details
*/
$anilist.getStudioDetails(studioId: number): $app.AL_StudioDetails
```

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

### ctx.newTray

Source: https://seanime.gitbook.io/seanime-extensions/plugins/ui/user-interface/tray.md

Initializes a new tray icon for the plugin. Only one tray icon can be created per plugin.

```APIDOC
## ctx.newTray(options)

### Description
Creates a new tray icon with specified configuration.

### Parameters
- **tooltipText** (string) - The text displayed on hover.
- **iconUrl** (string) - The URL of the icon image.
- **withContent** (boolean) - Whether the tray supports rendering content.
- **isDrawer** (boolean) - Whether the tray contents are displayed in a drawer.
```

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

### ChromeDP

Source: https://seanime.gitbook.io/seanime-extensions/seanime/core-apis.md

Provides headless browser automation capabilities using the installed Chrome/Chromium binary.

```APIDOC
## ChromeDP

### Description
An experimental interface for controlling a headless browser. Users must call `close()` to release resources.

### Methods
- **newBrowser()**: Initializes a new browser instance.
- **navigate(url)**: Navigates to the specified URL.
- **waitVisible(selector)**: Waits for an element to become visible.
- **text(selector)**: Retrieves the text content of an element.
- **close()**: Closes the browser instance.
```

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

### Configuring Plugin Type Definitions

Source: https://seanime.gitbook.io/seanime-extensions/plugins/write-test-share.md

Shows how to reference required type definition files to enable IDE autocompletion and type checking.

```typescript
/// <reference path="./plugin.d.ts" />
/// <reference path="./system.d.ts" />
/// <reference path="./app.d.ts" />
/// <reference path="./core.d.ts" />

function init() {
    // Everything is magically typed!
    
    $ui.register((ctx) => {
    
      ctx.dom.onReady(() => {
          console.log("Page loaded!")
      })
      
   })
}
```

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

### Retrieve System Information

Source: https://seanime.gitbook.io/seanime-extensions/plugins/apis/system/os.md

Access platform and architecture details using the $os object.

```typescript
console.log("Platform:", $os.platform); // darwin
console.log("Arch:", $os.arch); // arm64
```

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

### Get all manga providers

Source: https://seanime.gitbook.io/seanime-extensions/plugins/ui/other/manga.md

Retrieves all available provider extensions and iterates through them to log their IDs and names.

```typescript
const providers = ctx.manga.getProviders()

for (const providerId in providers) {
    console.log("ID:", providerId, "Name:", providers[providerId]) 
}
```

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

### run(isSimulation?)

Source: https://seanime.gitbook.io/seanime-extensions/plugins/ui/anime-library/auto-downloader.md

Schedules a non-blocking auto-downloader run.

```APIDOC
## run(isSimulation?)

### Description
Schedules a non-blocking auto-downloader run.

### Parameters
- **isSimulation** (Boolean) - Optional - When true, Seanime runs the auto-downloader in simulation mode.

### Example
```typescript
ctx.autoDownloader.run(true)
```
```

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

### Store API Methods

Source: https://seanime.gitbook.io/seanime-extensions/plugins/apis/store.md

Basic operations for setting, getting, watching, and removing values in the store.

```typescript
$store.set("foo", "bar")
$store.get("foo")
$store.watch("foo", (value) => {})
$store.getAll() // { "foo": "bar" }
$store.remove("foo")
$store.removeAll()
$store.has("foo") // false
$store.getOrSet("foo", () => { return "bar" })
$store.values() // ["bar"]
```

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

### Access Additional System Directories

Source: https://seanime.gitbook.io/seanime-extensions/plugins/apis/system/os.md

Retrieve paths for desktop, documents, and downloads folders via $osExtra.

```typescript
$osExtra.desktopDir() // $DESKTOP must be in the allow list
$osExtra.documentDir() // $DOCUMENT must be in the allow list
$osExtra.downloadDir() // $DOWNLOAD must be in the allow list
```

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

### Tray Lifecycle and Control Methods

Source: https://seanime.gitbook.io/seanime-extensions/plugins/ui/user-interface/tray.md

Methods to manage the tray state and respond to user interactions.

```APIDOC
## tray.onOpen(callback)
Registers a callback triggered when the tray content is opened.

## tray.onClose(callback)
Registers a callback triggered when the tray content is closed.

## tray.onClick(callback)
Registers a callback triggered when the tray icon is clicked.

## tray.open()
Opens the tray. Note: This may not function on initial page load or if the plugin is not pinned.

## tray.close()
Closes the tray.

## tray.update()
Forces the tray content to refresh.
```

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

### Get Collections

Source: https://seanime.gitbook.io/seanime-extensions/plugins/apis/anilist.md

Methods to retrieve user anime and manga collections with various filtering options.

```APIDOC
## $anilist.getAnimeCollection(bypassCache: boolean): $app.AL_AnimeCollection
## $anilist.getRawAnimeCollection(bypassCache: boolean): $app.AL_AnimeCollection
## $anilist.getMangaCollection(bypassCache: boolean): $app.AL_MangaCollection
## $anilist.getRawMangaCollection(bypassCache: boolean): $app.AL_MangaCollection
## $anilist.getAnimeCollectionWithRelations(): $app.AL_AnimeCollectionWithRelations
```

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

### Get Collections

Source: https://seanime.gitbook.io/seanime-extensions/plugins/apis/anilist.md

Retrieves anime or manga collection data, with options for raw data or relations.

```typescript
/**
* Get the user's anime collection.
* This collection does not include lists with no status.
*/
$anilist.getAnimeCollection(bypassCache: boolean): $app.AL_AnimeCollection

/**
* Get the raw anime collection data.
* This collection includes lists with no status.
*/
$anilist.getRawAnimeCollection(bypassCache: boolean): $app.AL_AnimeCollection

/**
* Get the user's manga collection.
* This collection does not include lists with no status.
*/
$anilist.getMangaCollection(bypassCache: boolean): $app.AL_MangaCollection

/**
* Get the raw manga collection data.
* This collection includes lists with no status.
*/
$anilist.getRawMangaCollection(bypassCache: boolean): $app.AL_MangaCollection

/**
* Get anime collection with relations
*/
$anilist.getAnimeCollectionWithRelations(): $app.AL_AnimeCollectionWithRelations
```
Tokens:
Raw