# Kavita

This recipe generates the `kavita` CLI and agent Skill for
[Kavita](https://github.com/Kareadita/Kavita) reading libraries, series,
collections, and users.

## API and authentication

Create an authentication key in Kavita and store it in the `x-api-key` header:

```sh
kavita auth login --hostname <host> --auth-type apikey
kavita auth status --hostname <host>
```

The default API-key header is case-insensitively equivalent to `x-api-key`.

## Install the Skill

```sh
kavita skill install --scope user --agent codex --yes
```

## Agent workflow

```sh
kavita commands --json
kavita search "get user libraries" --json
```

Use the returned command path with `kavita commands show` before execution.
Bump the pin in `specs/sources.yaml` when upgrading the Kavita API.

cli:
  name: kavita
  short: "Command-line tool for Kavita reading libraries"

skill:
  bundle: true

auth:
  validate:
    method: GET
    path: /api/Account
    display:
      username_field: username
      fallback_field: email

name: kavita
display_name: Kavita
cli_name: kavita
category: media-library
homepage: https://github.com/Kareadita/Kavita
description: Generated Kavita CLI and agent Skill for self-hosted reading libraries and users.
maintainers:
  - github: samzong
auth:
  type: custom
  notes: >-
    Requires a Kavita authentication key in the x-api-key header. Run
    `kavita auth login --hostname <host> --auth-type apikey` and verify it
    with `kavita auth status --hostname <host>`.
smoke:
  intent: get user libraries
  expect: get-api-library-user-libraries

sources:
  kavita:
    default_hostname: localhost:5000
    repo_url: https://github.com/Kareadita/Kavita
    # pinned to develop HEAD as of 2026-07-26; bump when upgrading
    pinned_tag: e9192acc73aead074d75447470dfe8debe7b848c
    backend: openapi3
    openapi3:
      files:
        - openapi.json

generated by lathe codegen; safe to remove and regenerate

---
name: kavita
description: >
  Use when operating the kavita generated CLI. Discover commands, inspect parameters,
  check auth state, and execute API operations safely.
---

# kavita CLI

Use this skill when a user asks you to operate `kavita`, inspect its API commands, or find the right generated command for an API task.

## Workflow

1. Search for candidates with `kavita search "<intent>" --json`; use `--limit` when needed. Search is only candidate discovery.
2. Inspect the exact command with `kavita commands show <path...> --json` before executing an unfamiliar command.
3. If the command detail has `auth.required=true`, run `kavita auth status --hostname <host>` before execution. Use `http.default_hostname` when present unless the user provides `--hostname` or `$KAVITA_HOST`.
4. Execute only after flags, body, auth, HTTP path, and output hints are clear from `commands show`.

## General Commands

- `kavita commands --json`: full generated command catalog.
- `kavita commands --include-hidden --json`: include hidden generated commands.
- `kavita commands show <path...> --json`: source of truth for one command.
- `kavita commands schema --json`: catalog schema version for parser compatibility.
- `kavita search "<intent>" --json`: ranked candidate commands.

## Maintenance Commands

- `kavita --version` or `kavita -v`: print CLI build version.

## References

- Read `references/catalog.md` for the command discovery protocol and catalog field meanings.
- Read `references/modules/kavita.md` for the `kavita` module command index.

## Rules

- Do not guess flags or request body shape from command names.
- Do not execute directly from search results; confirm with `commands show` first.
- Prefer `-o json` for machine-readable command output unless the user asks for human-readable output.
- Use `--file`, `--set`, or `--set-str` for JSON request bodies according to `commands show` body requirements.
- For sensitive flags, prefer safe modes from `flags[].input_modes`: `--<flag>-env`, `--<flag>-file`, or `--<flag>-stdin`.

interface:
  display_name: "kavita CLI"
  short_description: "Use the kavita generated CLI"
  default_prompt: "Use $kavita to find and run the right kavita command."

# Catalog Protocol

Use the runtime catalog as the source of truth. Generated references are a fast index; command execution details come from the CLI itself.

## Search

Run `kavita search "<intent>" --json` to find candidate commands. Use `--limit` to control result count. Treat search output as candidates only.

## Full Catalog

Run `kavita commands --json` to inspect the generated command catalog. Use `--include-hidden` only when hidden commands are relevant.

Key fields:

- `path`: command path to pass to `commands show` or execute after the CLI name.
- `shortcuts`: root-level commands that execute the same operation with preset flag values.
- `http`: HTTP method and path template.
- `http.default_hostname`: optional source-level host selected after explicit `--hostname` and `$KAVITA_HOST`; when present it is used before the single-host fallback from `hosts.yml`.
- `flags`: CLI flags, parameter location, type, required state, defaults, enum values, format, input modes, and help.
- `body`: request body requirement and media type.
- `auth`: whether auth is required and which scopes are declared.
- `examples`: runnable examples with optional body shape, output hints, and follow-up commands.
- `output`: list path, default columns, response media type, pagination, and streaming hints.
- `notes`, `prerequisites`, and `known_errors`: overlay-provided operation context that is not inferred from the API spec.

## Command Detail

Run `kavita commands show <path...> --json` before executing an unfamiliar command. This is the source of truth for flags, body, auth, HTTP path, and output hints.

## Schema

Run `kavita commands schema --json` to read the catalog schema version before parsing catalog JSON with durable tooling.

## Sensitive Flags

When a flag entry has `input_modes`, prefer safe modes over putting secrets directly in shell arguments.

- `flag`: pass the direct `--<flag>` value; keep this for compatibility or non-secret values.
- `env`: pass `--<flag>-env NAME` to read the value from an environment variable.
- `file`: pass `--<flag>-file path` to read the value from a file.
- `stdin`: pass `--<flag>-stdin` to read the value from stdin.
- Use only one input mode for the same flag.

## Request Bodies

- `--file path`: read a JSON body from a file.
- `--file -`: read a JSON body from stdin.
- `--set key.path=value`: build JSON with type inference for booleans, null, integers, and floats.
- `--set-str key.path=value`: build JSON while forcing the value to remain a string.

## Output

Use `-o json` for machine-readable command output. Other supported formats are `table`, `yaml`, and `raw`.

## Auth

If command detail returns `auth.required=true`, run `kavita auth status --hostname <host>` before execution. Use `http.default_hostname` when present unless the user provides `--hostname` or `$KAVITA_HOST`; if no matching host is logged in, stop and ask the user to authenticate.

# Module `kavita`

## Source

- Backend: `openapi3`
- Default hostname: `localhost:5000`
- Repository: https://github.com/Kareadita/Kavita
- Pinned tag: `e9192acc73aead074d75447470dfe8debe7b848c`
- Files: `openapi.json`
- Resolved SHA: `e9192acc73aead074d75447470dfe8debe7b848c`

## Account

### `kavita kavita account delete-api-account-auth-key`

- Summary: Delete the Auth Key
- HTTP: `DELETE /api/Account/auth-key`
- Auth: required
- Body: none
- Flags:
  - `--auth-key-id` (query, int32): authKeyId

### `kavita kavita account get-api-account`

- Summary: Returns the current user, as it would from login
- HTTP: `GET /api/Account`
- Auth: required
- Body: none
- Flags: none
- Output: list path `authKeys`; columns `name`, `id`, `createdAtUtc`, `expiresAtUtc`, `key`, `lastAccessedAtUtc`; response media `application/json`

### `kavita kavita account get-api-account-auth-keys`

- Summary: Returns all Auth Keys with the account
- HTTP: `GET /api/Account/auth-keys`
- Auth: required
- Body: none
- Flags: none
- Output: columns `name`, `id`, `createdAtUtc`, `expiresAtUtc`, `key`, `lastAccessedAtUtc`; response media `application/json`

### `kavita kavita account get-api-account-email-confirmed`

- HTTP: `GET /api/Account/email-confirmed`
- Auth: required
- Body: none
- Flags: none
- Output: response media `application/json`

### `kavita kavita account get-api-account-invite-url`

- Summary: Requests the Invite Url for the AppUserId. Will return error if user is already validated.
- HTTP: `GET /api/Account/invite-url`
- Auth: required
- Body: none
- Flags:
  - `--user-id` (query, int32): userId
  - `--with-base-url` (query): Include the "https://ip:port/" in the generated link
- Output: response media `application/json`

### `kavita kavita account get-api-account-is-email-valid`

- Summary: Is the user's current email valid or not
- HTTP: `GET /api/Account/is-email-valid`
- Auth: required
- Body: none
- Flags: none
- Output: response media `application/json`

### `kavita kavita account get-api-account-oidc-authenticated`

- Summary: Returns true if OIDC authentication cookies are present and the Kavita.Server.Extensions.IdentityServiceExtensions.OpenIdConnect
- HTTP: `GET /api/Account/oidc-authenticated`
- Auth: required
- Body: none
- Flags: none
- Output: response media `application/json`

### `kavita kavita account get-api-account-opds-url`

- Summary: Returns the OPDS url for this user
- HTTP: `GET /api/Account/opds-url`
- Auth: required
- Body: none
- Flags:
  - `--auth-key-name` (query): authKeyName
- Output: response media `application/json`

### `kavita kavita account get-api-account-refresh-account`

- Summary: Returns an up-to-date user account
- HTTP: `GET /api/Account/refresh-account`
- Auth: required
- Body: none
- Flags: none
- Output: list path `authKeys`; columns `name`, `id`, `createdAtUtc`, `expiresAtUtc`, `key`, `lastAccessedAtUtc`; response media `application/json`

### `kavita kavita account post-api-account-clear-oidc-link`

- Summary: Remove the OIDC link for the authenticated user. This action will also remove the authentication cookie.
- HTTP: `POST /api/Account/clear-oidc-link`
- Auth: required
- Body: none
- Flags: none

### `kavita kavita account post-api-account-confirm-email`

- Summary: Last step in authentication flow, confirms the email token for email
- HTTP: `POST /api/Account/confirm-email`
- Auth: required
- Body: optional; media type `application/json`
- Flags: none
- Output: list path `authKeys`; columns `name`, `id`, `createdAtUtc`, `expiresAtUtc`, `key`, `lastAccessedAtUtc`; response media `application/json`

### `kavita kavita account post-api-account-confirm-email-update`

- Summary: Final step in email update change. Given a confirmation token and the email, this will finish the email change.
- HTTP: `POST /api/Account/confirm-email-update`
- Auth: required
- Body: optional; media type `application/json`
- Flags: none

### `kavita kavita account post-api-account-confirm-migration-email`

- HTTP: `POST /api/Account/confirm-migration-email`
- Auth: required
- Body: optional; media type `application/json`
- Flags: none
- Output: list path `authKeys`; columns `name`, `id`, `createdAtUtc`, `expiresAtUtc`, `key`, `lastAccessedAtUtc`; response media `application/json`

### `kavita kavita account post-api-account-confirm-password-reset`

- HTTP: `POST /api/Account/confirm-password-reset`
- Auth: required
- Body: optional; media type `application/json`
- Flags: none
- Output: response media `application/json`

### `kavita kavita account post-api-account-create-auth-key`

- Summary: Creates a new Auth Key for a user.
- HTTP: `POST /api/Account/create-auth-key`
- Auth: required
- Body: optional; media type `application/json`
- Flags: none
- Output: response media `application/json`

### `kavita kavita account post-api-account-forgot-password`

- Summary: Will send user a link to update their password to their email or prompt them if not accessible
- HTTP: `POST /api/Account/forgot-password`
- Auth: required
- Body: none
- Flags:
  - `--email` (query): email
- Output: response media `application/json`

### `kavita kavita account post-api-account-invite`

- Summary: Invites a user to the server. Will generate a setup link for continuing setup. If email is not setup, a link will be presented to user to continue setup.
- HTTP: `POST /api/Account/invite`
- Auth: required
- Body: optional; media type `application/json`
- Flags: none
- Output: response media `application/json`

### `kavita kavita account post-api-account-login`

- Summary: Perform a login. Will send JWT Token of the logged in user back.
- HTTP: `POST /api/Account/login`
- Auth: required
- Body: optional; media type `application/json`
- Flags: none
- Output: list path `authKeys`; columns `name`, `id`, `createdAtUtc`, `expiresAtUtc`, `key`, `lastAccessedAtUtc`; response media `application/json`

### `kavita kavita account post-api-account-refresh-token`

- Summary: Refreshes the user's JWT token
- HTTP: `POST /api/Account/refresh-token`
- Auth: required
- Body: optional; media type `application/json`
- Flags: none
- Output: response media `application/json`

### `kavita kavita account post-api-account-register`

- Summary: Register the first user (admin) on the server. Will not do anything if an admin is already confirmed
- HTTP: `POST /api/Account/register`
- Auth: required
- Body: optional; media type `application/json`
- Flags: none
- Output: list path `authKeys`; columns `name`, `id`, `createdAtUtc`, `expiresAtUtc`, `key`, `lastAccessedAtUtc`; response media `application/json`

### `kavita kavita account post-api-account-resend-confirmation-email`

- Summary: Resend an invite to a user already invited
- HTTP: `POST /api/Account/resend-confirmation-email`
- Auth: required
- Body: none
- Flags:
  - `--user-id` (query, int32): userId
- Output: response media `application/json`

### `kavita kavita account post-api-account-reset-password`

- Summary: Update a user's password
- HTTP: `POST /api/Account/reset-password`
- Auth: required
- Body: optional; media type `application/json`
- Flags: none

### `kavita kavita account post-api-account-rotate-auth-key`

- Summary: Rotate the Auth Key
- HTTP: `POST /api/Account/rotate-auth-key`
- Auth: required
- Body: optional; media type `application/json`
- Flags:
  - `--auth-key-id` (query, int32): authKeyId
- Output: response media `application/json`

### `kavita kavita account post-api-account-update`

- Summary: Update the user account. This can only affect Username, Email (will require confirming), Roles, and Library access.
- HTTP: `POST /api/Account/update`
- Auth: required
- Body: optional; media type `application/json`
- Flags: none

### `kavita kavita account post-api-account-update-age-restriction`

- Summary: Change the Age Rating restriction for the user
- HTTP: `POST /api/Account/update/age-restriction`
- Auth: required
- Body: optional; media type `application/json`
- Flags: none

### `kavita kavita account post-api-account-update-email`

- Summary: Initiates the flow to update a user's email address.
- HTTP: `POST /api/Account/update/email`
- Auth: required
- Body: optional; media type `application/json`
- Flags: none
- Output: response media `application/json`

### `kavita kavita account post-api-account-update-username`

- Summary: Initiates the flow to update a user's username.
- HTTP: `POST /api/Account/update/username`
- Auth: required
- Body: optional; media type `application/json`
- Flags: none
- Output: response media `application/json`

## Activity

### `kavita kavita activity get-api-activity-current`

- Summary: Returns active reading sessions on the Server
- HTTP: `GET /api/Activity/current`
- Auth: required
- Body: none
- Flags: none
- Output: columns `id`, `endTimeUtc`, `isActive`, `startTimeUtc`, `userId`, `username`; response media `application/json`

## Admin

### `kavita kavita admin get-api-admin-exists`

- Summary: Checks if an admin exists on the system. This is essentially a check to validate if the system has been set up.
- HTTP: `GET /api/Admin/exists`
- Auth: required
- Body: none
- Flags: none
- Output: response media `application/json`

## Annotation

### `kavita kavita annotation delete-api-annotation`

- Summary: Delete the annotation for the user
- HTTP: `DELETE /api/Annotation`
- Auth: required
- Body: none
- Flags:
  - `--annotation-id` (query, int32): annotationId

### `kavita kavita annotation get-api-annotation-all`

- Summary: Returns the annotations for the given chapter
- HTTP: `GET /api/Annotation/all`
- Auth: required
- Body: none
- Flags:
  - `--chapter-id` (query, int32): chapterId
- Output: columns `id`, `ageRating`, `chapterId`, `chapterTitle`, `comment`, `commentHtml`; response media `application/json`

### `kavita kavita annotation get-api-annotation-all-for-series`

- Summary: Returns all annotations by Series
- HTTP: `GET /api/Annotation/all-for-series`
- Auth: required
- Body: none
- Flags:
  - `--series-id` (query, int32): seriesId
- Output: list path `likes`; response media `application/json`

### `kavita kavita annotation get-api-annotation-annotation-id`

- Summary: Returns the Annotation by Id. User must have access to annotation.
- HTTP: `GET /api/Annotation/{annotationId}`
- Auth: required
- Body: none
- Flags:
  - `--annotation-id` (path, required, int32): annotationId
- Output: list path `likes`; response media `application/json`

### `kavita kavita annotation post-api-annotation-all-filtered`

- Summary: Returns a list of annotations for browsing
- HTTP: `POST /api/Annotation/all-filtered`
- Auth: required
- Body: optional; media type `application/json`
- Flags:
  - `--page-number` (query, int32): PageNumber
  - `--page-size` (query, int32): PageSize
- Output: columns `id`, `ageRating`, `chapterId`, `chapterTitle`, `comment`, `commentHtml`; response media `application/json`

### `kavita kavita annotation post-api-annotation-bulk-delete`

- Summary: Removes annotations in bulk. Requires every annotation to be owned by the authenticated user
- HTTP: `POST /api/Annotation/bulk-delete`
- Auth: required
- Body: optional; media type `application/json`
- Flags: none

### `kavita kavita annotation post-api-annotation-create`

- Summary: Create a new Annotation for the user against a Chapter
- HTTP: `POST /api/Annotation/create`
- Auth: required
- Body: optional; media type `application/json`
- Flags: none
- Output: list path `likes`; response media `application/json`

### `kavita kavita annotation post-api-annotation-export`

- Summary: Exports Annotations for the User
- HTTP: `POST /api/Annotation/export`
- Auth: required
- Body: optional; media type `application/json`
- Flags: none

### `kavita kavita annotation post-api-annotation-export-filter`

- Summary: Exports annotations for the given users
- HTTP: `POST /api/Annotation/export-filter`
- Auth: required
- Body: optional; media type `application/json`
- Flags:
  - `--page-number` (query, int32): PageNumber
  - `--page-size` (query, int32): PageSize

### `kavita kavita annotation post-api-annotation-like`

- Summary: Adds a like for the currently authenticated user if not already from the annotations with given ids
- HTTP: `POST /api/Annotation/like`
- Auth: required
- Body: optional; media type `application/json`
- Flags: none

### `kavita kavita annotation post-api-annotation-unlike`

- Summary: Removes likes for the currently authenticated user if present from the annotations with given ids
- HTTP: `POST /api/Annotation/unlike`
- Auth: required
- Body: optional; media type `application/json`
- Flags: none

### `kavita kavita annotation post-api-annotation-update`

- Summary: Update the modifiable fields (Spoiler, highlight slot, and comment) for an annotation
- HTTP: `POST /api/Annotation/update`
- Auth: required
- Body: optional; media type `application/json`
- Flags: none
- Output: list path `likes`; response media `application/json`

## Book

### `kavita kavita book get-api-book-chapter-id-book-info`

- Summary: Retrieves information for the PDF and Epub reader. This will cache the file.
- HTTP: `GET /api/Book/{chapterId}/book-info`
- Auth: required
- Body: none
- Flags:
  - `--chapter-id` (path, required, int32): chapterId
- Output: response media `application/json`

### `kavita kavita book get-api-book-chapter-id-book-page`

- Summary: This returns a single page within the epub book. All html will be rewritten to be scoped within our reader,
- HTTP: `GET /api/Book/{chapterId}/book-page`
- Auth: required
- Body: none
- Flags:
  - `--chapter-id` (path, required, int32): chapterId
  - `--page` (query, int32): page
- Output: response media `application/json`; pagination `offset`

### `kavita kavita book get-api-book-chapter-id-book-resources`

- Summary: This is an entry point to fetch resources from within an epub chapter/book.
- HTTP: `GET /api/Book/{chapterId}/book-resources`
- Auth: required
- Body: none
- Flags:
  - `--chapter-id` (path, required, int32): chapterId
  - `--file` (query): file

### `kavita kavita book get-api-book-chapter-id-chapters`

- Summary: This will return a list of mappings from ID -> page num. ID will be the xhtml key and page num will be the reading order
- HTTP: `GET /api/Book/{chapterId}/chapters`
- Auth: required
- Body: none
- Flags:
  - `--chapter-id` (path, required, int32): chapterId
- Output: columns `page`, `part`, `title`; response media `application/json`

## Cbl

### `kavita kavita cbl delete-api-cbl-remap-rules-id`

- Summary: Deletes a remap rule. Users can only delete their own rules.
- HTTP: `DELETE /api/Cbl/remap-rules/{id}`
- Auth: required
- Body: none
- Flags:
  - `--id` (path, required, int32): id

### `kavita kavita cbl get-api-cbl-browse`

- Summary: Provides the browse CBL Repo interface. Requires Download role.
- HTTP: `GET /api/Cbl/browse`
- Auth: required
- Body: none
- Flags:
  - `--path` (query): path
- Output: list path `items`; columns `name`, `alreadySynced`, `downloadUrl`, `existingReadingListId`, `isDirectory`, `path`; response media `application/json`

### `kavita kavita cbl get-api-cbl-remap-rules`

- Summary: Returns all remap rules accessible to the current user (own rules + global/admin rules).
- HTTP: `GET /api/Cbl/remap-rules`
- Auth: required
- Body: none
- Flags: none
- Output: columns `kind`, `id`, `appUserId`, `cblNumber`, `cblSeriesName`, `cblVolume`; response media `application/json`

### `kavita kavita cbl get-api-cbl-remap-rules-all`

- Summary: Returns all rules across all users
- HTTP: `GET /api/Cbl/remap-rules/all`
- Auth: required
- Body: none
- Flags: none
- Output: columns `kind`, `id`, `appUserId`, `cblNumber`, `cblSeriesName`, `cblVolume`; response media `application/json`

### `kavita kavita cbl post-api-cbl-file-import`

- Summary: Saves an uploaded CBL file to disk without importing. Returns the saved file info.
- HTTP: `POST /api/Cbl/file-import`
- Auth: required
- Body: optional; media type `multipart/form-data`
- Flags: none
- Output: response media `application/json`

### `kavita kavita cbl post-api-cbl-finalize-import`

- Summary: Finalizes the import of a saved CBL file with user decisions
- HTTP: `POST /api/Cbl/finalize-import`
- Auth: required
- Body: optional; media type `application/json`
- Flags: none
- Output: list path `results`; columns `chapterId`, `chapterNumber`, `chapterTitle`, `libraryId`, `libraryType`, `matchTier`; response media `application/json`

### `kavita kavita cbl post-api-cbl-re-validate`

- Summary: Validates an already-saved CBL file on disk. Called by the import modal after remap rule changes.
- HTTP: `POST /api/Cbl/re-validate`
- Auth: required
- Body: optional; media type `application/json`
- Flags: none
- Output: list path `results`; columns `chapterId`, `chapterNumber`, `chapterTitle`, `libraryId`, `libraryType`, `matchTier`; response media `application/json`

### `kavita kavita cbl post-api-cbl-remap-rules`

- Summary: Creates a new remap rule, or updates an existing one if a rule with the same
- HTTP: `POST /api/Cbl/remap-rules`
- Auth: required
- Body: optional; media type `application/json`
- Flags: none
- Output: response media `application/json`

### `kavita kavita cbl post-api-cbl-remap-rules-id`

- Summary: Updates a remap rule with issue-level detail (volume/chapter).
- HTTP: `POST /api/Cbl/remap-rules/{id}`
- Auth: required
- Body: optional; media type `application/json`
- Flags:
  - `--id` (path, required, int32): id
- Output: response media `application/json`

### `kavita kavita cbl post-api-cbl-remap-rules-id-demote`

- Summary: Demotes a global remap rule back to user-scoped. Admin-only.
- HTTP: `POST /api/Cbl/remap-rules/{id}/demote`
- Auth: required
- Body: none
- Flags:
  - `--id` (path, required, int32): id
- Output: response media `application/json`

### `kavita kavita cbl post-api-cbl-remap-rules-id-promote`

- Summary: Promotes a remap rule to global scope. Admin-only.
- HTTP: `POST /api/Cbl/remap-rules/{id}/promote`
- Auth: required
- Body: none
- Flags:
  - `--id` (path, required, int32): id
- Output: response media `application/json`

### `kavita kavita cbl post-api-cbl-repo-import`

- Summary: Downloads selected CBL files from the GitHub repo and saves them to disk without importing.
- HTTP: `POST /api/Cbl/repo-import`
- Auth: required
- Body: optional; media type `application/json`
- Flags: none
- Output: columns `name`, `downloadUrl`, `fileName`, `provider`, `repoPath`, `sha`; response media `application/json`

### `kavita kavita cbl post-api-cbl-sync`

- Summary: Enqueues the Reading List to be synced on a background thread. UI will be informed from Kavita.Models.DTOs.SignalR.MessageFactory.ReadingListUpdated event
- HTTP: `POST /api/Cbl/sync`
- Auth: required
- Body: none
- Flags:
  - `--reading-list-id` (query, int32): readingListId
  - `--force` (query, default `false`): Ignore Hash and force sync flow

### `kavita kavita cbl post-api-cbl-upload-cbl-file`

- Summary: Downloads a CBL file from a URL and saves it to disk without importing.
- HTTP: `POST /api/Cbl/upload-cbl-file`
- Auth: required
- Body: optional; media type `application/json`
- Flags: none
- Output: response media `application/json`

## Chapter

### `kavita kavita chapter delete-api-chapter`

- Summary: Removes a Chapter
- HTTP: `DELETE /api/Chapter`
- Auth: required
- Body: none
- Flags:
  - `--chapter-id` (query, int32): chapterId
- Output: response media `application/json`

### `kavita kavita chapter get-api-chapter`

- Summary: Gets a single chapter
- HTTP: `GET /api/Chapter`
- Auth: required
- Body: none
- Flags:
  - `--chapter-id` (query, int32): chapterId
- Output: list path `characters`; columns `name`, `id`, `aniListId`, `asin`, `coverImage`, `coverImageLocked`; response media `application/json`

### `kavita kavita chapter get-api-chapter-chapter-detail-plus`

- Summary: Returns Ratings and Reviews for an individual Chapter
- HTTP: `GET /api/Chapter/chapter-detail-plus`
- Auth: required
- Body: none
- Flags:
  - `--chapter-id` (query, int32): chapterId
- Output: list path `ratings`; columns `authority`, `averageScore`, `favoriteCount`, `provider`, `providerUrl`; response media `application/json`

### `kavita kavita chapter post-api-chapter-delete-multiple`

- Summary: Deletes multiple chapters and any volumes with no leftover chapters
- HTTP: `POST /api/Chapter/delete-multiple`
- Auth: required
- Body: optional; media type `application/json`
- Flags:
  - `--series-id` (query, int32): The ID of the series
- Output: response media `application/json`

### `kavita kavita chapter post-api-chapter-update`

- Summary: Update chapter metadata
- HTTP: `POST /api/Chapter/update`
- Auth: required
- Body: optional; media type `application/json`
- Flags: none

## Collection

### `kavita kavita collection delete-api-collection`

- Summary: Removes the collection tag from the user
- HTTP: `DELETE /api/Collection`
- Auth: required
- Body: none
- Flags:
  - `--tag-id` (query, int32): tagId

### `kavita kavita collection get-api-collection`

- Summary: Returns all Collection tags for a given User
- HTTP: `GET /api/Collection`
- Auth: required
- Body: none
- Flags:
  - `--owned-only` (query, default `false`): Exclude Promoted
  - `--sort-by-last-modified` (query, default `false`): Order by Last Modified rather than on Title
- Output: columns `id`, `ageRating`, `coverImage`, `coverImageLocked`, `itemCount`, `lastSyncUtc`; response media `application/json`

### `kavita kavita collection get-api-collection-all-series`

- Summary: Returns all collections that contain the Series for the user with the option to allow for promoted collections (non-user owned)
- HTTP: `GET /api/Collection/all-series`
- Auth: required
- Body: none
- Flags:
  - `--series-id` (query, int32): seriesId
  - `--owned-only` (query, default `false`): ownedOnly
- Output: columns `id`, `ageRating`, `coverImage`, `coverImageLocked`, `itemCount`, `lastSyncUtc`; response media `application/json`

### `kavita kavita collection get-api-collection-mal-stacks`

- Summary: For the authenticated user, if they have an active Kavita+ subscription and a MAL username on record,
- HTTP: `GET /api/Collection/mal-stacks`
- Auth: required
- Body: none
- Flags: none
- Output: columns `author`, `existingId`, `restackCount`, `seriesCount`, `stackId`, `title`; response media `application/json`

### `kavita kavita collection get-api-collection-name-exists`

- Summary: Checks if a collection exists with the name
- HTTP: `GET /api/Collection/name-exists`
- Auth: required
- Body: none
- Flags:
  - `--name` (query): If empty or null, will return true as that is invalid
- Output: response media `application/json`

### `kavita kavita collection get-api-collection-single`

- Summary: Returns a single Collection tag by Id for a given user
- HTTP: `GET /api/Collection/single`
- Auth: required
- Body: none
- Flags:
  - `--collection-id` (query, int32): collectionId
- Output: response media `application/json`

### `kavita kavita collection post-api-collection-delete-multiple`

- Summary: Delete multiple collections in one go
- HTTP: `POST /api/Collection/delete-multiple`
- Auth: required
- Body: optional; media type `application/json`
- Flags: none

### `kavita kavita collection post-api-collection-import-stack`

- Summary: Imports a MAL Stack into Kavita
- HTTP: `POST /api/Collection/import-stack`
- Auth: required
- Body: optional; media type `application/json`
- Flags: none

### `kavita kavita collection post-api-collection-promote-multiple`

- Summary: Promote/UnPromote multiple collections in one go. Will only update the authenticated user's collections and will only work if the user has promotion role
- HTTP: `POST /api/Collection/promote-multiple`
- Auth: required
- Body: optional; media type `application/json`
- Flags: none

### `kavita kavita collection post-api-collection-update`

- Summary: Updates an existing tag with a new title, promotion status, and summary.
- HTTP: `POST /api/Collection/update`
- Auth: required
- Body: optional; media type `application/json`
- Flags: none
- Output: response media `application/json`

### `kavita kavita collection post-api-collection-update-for-series`

- Summary: Adds multiple series to a collection. If tag id is 0, this will create a new tag.
- HTTP: `POST /api/Collection/update-for-series`
- Auth: required
- Body: optional; media type `application/json`
- Flags: none

### `kavita kavita collection post-api-collection-update-series`

- Summary: For a given tag, update the summary if summary has changed and remove a set of series from the tag.
- HTTP: `POST /api/Collection/update-series`
- Auth: required
- Body: optional; media type `application/json`
- Flags: none

## ColorScape

### `kavita kavita colorscape get-api-color-scape-chapter`

- Summary: Returns the color scape for a chapter
- HTTP: `GET /api/ColorScape/chapter`
- Auth: required
- Body: none
- Flags:
  - `--id` (query, int32): id
- Output: response media `application/json`

### `kavita kavita colorscape get-api-color-scape-series`

- Summary: Returns the color scape for a series
- HTTP: `GET /api/ColorScape/series`
- Auth: required
- Body: none
- Flags:
  - `--id` (query, int32): id
- Output: response media `application/json`

### `kavita kavita colorscape get-api-color-scape-volume`

- Summary: Returns the color scape for a volume
- HTTP: `GET /api/ColorScape/volume`
- Auth: required
- Body: none
- Flags:
  - `--id` (query, int32): id
- Output: response media `application/json`

## Device

### `kavita kavita device delete-api-device`

- Summary: Deletes the device from the user
- HTTP: `DELETE /api/Device`
- Auth: required
- Body: none
- Flags:
  - `--device-id` (query, int32): deviceId

### `kavita kavita device delete-api-device-client-device`

- Summary: Removes the client device from DB
- HTTP: `DELETE /api/Device/client/device`
- Auth: required
- Body: none
- Flags:
  - `--client-device-id` (query, int32): clientDeviceId
- Output: response media `application/json`

### `kavita kavita device get-api-device`

- HTTP: `GET /api/Device`
- Auth: required
- Body: none
- Flags: none
- Output: columns `name`, `id`, `emailAddress`, `platform`; response media `application/json`

### `kavita kavita device get-api-device-client-all-devices`

- Summary: Get All user client devices
- HTTP: `GET /api/Device/client/all-devices`
- Auth: required
- Body: none
- Flags:
  - `--include-inactive` (query, default `false`): includeInactive
- Output: columns `id`, `firstSeenUtc`, `friendlyName`, `lastSeenUtc`, `ownerUserId`, `ownerUsername`; response media `application/json`

### `kavita kavita device get-api-device-client-devices`

- Summary: Get my client devices
- HTTP: `GET /api/Device/client/devices`
- Auth: required
- Body: none
- Flags:
  - `--include-inactive` (query, default `false`): includeInactive
- Output: columns `id`, `firstSeenUtc`, `friendlyName`, `lastSeenUtc`, `ownerUserId`, `ownerUsername`; response media `application/json`

### `kavita kavita device post-api-device-client-update-name`

- Summary: Update the friendly name of the Device
- HTTP: `POST /api/Device/client/update-name`
- Auth: required
- Body: optional; media type `application/json`
- Flags: none

### `kavita kavita device post-api-device-create`

- Summary: Creates a new Device
- HTTP: `POST /api/Device/create`
- Auth: required
- Body: optional; media type `application/json`
- Flags: none
- Output: response media `application/json`

### `kavita kavita device post-api-device-send-series-to`

- Summary: Attempts to send a whole series to a device.
- HTTP: `POST /api/Device/send-series-to`
- Auth: required
- Body: optional; media type `application/json`
- Flags: none

### `kavita kavita device post-api-device-send-to`

- Summary: Sends a collection of chapters to the user's device
- HTTP: `POST /api/Device/send-to`
- Auth: required
- Body: optional; media type `application/json`
- Flags: none

### `kavita kavita device post-api-device-update`

- Summary: Updates an existing Device
- HTTP: `POST /api/Device/update`
- Auth: required
- Body: optional; media type `application/json`
- Flags: none
- Output: response media `application/json`

## Download

### `kavita kavita download get-api-download-chapter`

- Summary: Returns the zip for a single chapter. If the chapter contains multiple files, they will be zipped.
- HTTP: `GET /api/Download/chapter`
- Auth: required
- Body: none
- Flags:
  - `--chapter-id` (query, int32): chapterId
  - `--correlation-id` (query): correlationId

### `kavita kavita download get-api-download-chapter-size`

- Summary: For a given chapter, return the size in bytes
- HTTP: `GET /api/Download/chapter-size`
- Auth: required
- Body: none
- Flags:
  - `--chapter-id` (query, int32): chapterId
- Output: response media `application/json`

### `kavita kavita download get-api-download-readinglist-size`

- Summary: Returns the filesize for all items of a reading list that the requesting user has access to
- HTTP: `GET /api/Download/readinglist-size`
- Auth: required
- Body: none
- Flags:
  - `--reading-list-id` (query, int32): readingListId
- Output: response media `application/json`

### `kavita kavita download get-api-download-series`

- HTTP: `GET /api/Download/series`
- Auth: required
- Body: none
- Flags:
  - `--series-id` (query, int32): seriesId
  - `--correlation-id` (query): correlationId

### `kavita kavita download get-api-download-series-size`

- Summary: For a series, return the size in bytes
- HTTP: `GET /api/Download/series-size`
- Auth: required
- Body: none
- Flags:
  - `--series-id` (query, int32): seriesId
- Output: response media `application/json`

### `kavita kavita download get-api-download-volume`

- Summary: Downloads all chapters within a volume. If the chapters are multiple zips, they will all be zipped up.
- HTTP: `GET /api/Download/volume`
- Auth: required
- Body: none
- Flags:
  - `--volume-id` (query, int32): volumeId
  - `--correlation-id` (query): Only for UI

### `kavita kavita download get-api-download-volume-size`

- Summary: For a given volume, return the size in bytes
- HTTP: `GET /api/Download/volume-size`
- Auth: required
- Body: none
- Flags:
  - `--volume-id` (query, int32): volumeId
- Output: response media `application/json`

### `kavita kavita download post-api-download-bookmarks`

- Summary: Downloads all bookmarks in a zip for
- HTTP: `POST /api/Download/bookmarks`
- Auth: required
- Body: optional; media type `application/json`
- Flags: none

### `kavita kavita download post-api-download-bulk-chapter-size`

- Summary: For a set of chapters, return the size in bytes
- HTTP: `POST /api/Download/bulk-chapter-size`
- Auth: required
- Body: optional; media type `application/json`
- Flags: none
- Output: response media `application/json`

### `kavita kavita download post-api-download-bulk-readinglist-size`

- Summary: Returns the mapping of readinglist -> size
- HTTP: `POST /api/Download/bulk-readinglist-size`
- Auth: required
- Body: optional; media type `application/json`
- Flags: none
- Output: response media `application/json`

### `kavita kavita download post-api-download-bulk-series-size`

- Summary: For a set of series, return the size in bytes
- HTTP: `POST /api/Download/bulk-series-size`
- Auth: required
- Body: optional; media type `application/json`
- Flags: none
- Output: response media `application/json`

### `kavita kavita download post-api-download-bulk-volume-size`

- Summary: For a set of volumes, return the size in bytes
- HTTP: `POST /api/Download/bulk-volume-size`
- Auth: required
- Body: optional; media type `application/json`
- Flags: none
- Output: response media `application/json`

## Email

### `kavita kavita email get-api-email-all`

- HTTP: `GET /api/Email/all`
- Auth: required
- Body: none
- Flags: none
- Output: columns `id`, `emailTemplate`, `errorMessage`, `sendDate`, `sent`, `toUserName`; response media `application/json`

## Filter

### `kavita kavita filter delete-api-filter`

- Summary: Delete the smart filter for the authenticated user
- HTTP: `DELETE /api/Filter`
- Auth: required
- Body: none
- Flags:
  - `--filter-id` (query, int32): filterId

### `kavita kavita filter get-api-filter`

- Summary: All Smart Filters for the authenticated user
- HTTP: `GET /api/Filter`
- Auth: required
- Body: none
- Flags: none
- Output: columns `name`, `id`, `entityType`, `filter`; response media `application/json`

### `kavita kavita filter post-api-filter-decode`

- Summary: Decodes the Filter
- HTTP: `POST /api/Filter/decode`
- Auth: required
- Body: optional; media type `application/json`
- Flags: none
- Output: response media `application/json`

### `kavita kavita filter post-api-filter-encode-annotation`

- Summary: Encode an Annotation Filter
- HTTP: `POST /api/Filter/encode/annotation`
- Auth: required
- Body: optional; media type `application/json`
- Flags: none
- Output: response media `application/json`

### `kavita kavita filter post-api-filter-encode-person`

- Summary: Encode a Person Filter
- HTTP: `POST /api/Filter/encode/person`
- Auth: required
- Body: optional; media type `application/json`
- Flags: none
- Output: response media `application/json`

### `kavita kavita filter post-api-filter-encode-reading-list`

- Summary: Encode a Reading List filter
- HTTP: `POST /api/Filter/encode/reading-list`
- Auth: required
- Body: optional; media type `application/json`
- Flags: none
- Output: response media `application/json`

### `kavita kavita filter post-api-filter-encode-series`

- Summary: Encode a Series filter
- HTTP: `POST /api/Filter/encode/series`
- Auth: required
- Body: optional; media type `application/json`
- Flags: none
- Output: response media `application/json`

### `kavita kavita filter post-api-filter-rename`

- Summary: Rename a Smart Filter given the filterId and new name
- HTTP: `POST /api/Filter/rename`
- Auth: required
- Body: none
- Flags:
  - `--filter-id` (query, int32): filterId
  - `--name` (query, required): name

### `kavita kavita filter post-api-filter-update-annotation`

- Summary: Creates or Updates the Reading List filter
- HTTP: `POST /api/Filter/update/annotation`
- Auth: required
- Body: optional; media type `application/json`
- Flags: none

### `kavita kavita filter post-api-filter-update-person`

- Summary: Creates or Updates the Person filter
- HTTP: `POST /api/Filter/update/person`
- Auth: required
- Body: optional; media type `application/json`
- Flags: none

### `kavita kavita filter post-api-filter-update-reading-list`

- Summary: Creates or Updates the Reading List filter
- HTTP: `POST /api/Filter/update/reading-list`
- Auth: required
- Body: optional; media type `application/json`
- Flags: none

### `kavita kavita filter post-api-filter-update-series`

- Summary: Creates or Updates the Series filter
- HTTP: `POST /api/Filter/update/series`
- Auth: required
- Body: optional; media type `application/json`
- Flags: none

## Font

### `kavita kavita font delete-api-font`

- Summary: Removes a font family from the system. The family is validated for in-use server side and only removed when
- HTTP: `DELETE /api/Font`
- Auth: required
- Body: none
- Flags:
  - `--font-id` (query, int32): Any file within the family to delete
  - `--force` (query, default `false`): If the family is in use and an admin wants it deleted, they must confirm to force delete it. This is prompted in the UI.
- Output: response media `application/json`

### `kavita kavita font get-api-font`

- Summary: Returns a font file
- HTTP: `GET /api/Font`
- Auth: required
- Body: none
- Flags:
  - `--font-id` (query, int32): fontId

### `kavita kavita font get-api-font-all`

- Summary: List out the fonts
- HTTP: `GET /api/Font/all`
- Auth: required
- Body: none
- Flags: none
- Output: columns `name`, `id`, `family`, `fileName`, `provider`, `style`; response media `application/json`

### `kavita kavita font post-api-font-upload`

- Summary: Manual upload
- HTTP: `POST /api/Font/upload`
- Auth: required
- Body: optional; media type `multipart/form-data`
- Flags: none
- Output: response media `application/json`

### `kavita kavita font post-api-font-upload-by-url`

- HTTP: `POST /api/Font/upload-by-url`
- Auth: required
- Body: none
- Flags:
  - `--url` (query): url
- Output: columns `name`, `id`, `family`, `fileName`, `provider`, `style`; response media `application/json`

## Health

### `kavita kavita health get-api-health`

- Summary: No-op method that just returns Ok. Used for health checks in Docker containers.
- HTTP: `GET /api/Health`
- Auth: required
- Body: none
- Flags: none
- Output: response media `application/json`

## Image

### `kavita kavita image get-api-image-bookmark`

- Summary: Returns image for a given bookmark page
- HTTP: `GET /api/Image/bookmark`
- Auth: required
- Body: none
- Flags:
  - `--chapter-id` (query, int32): chapterId
  - `--page-num` (query, int32): Starts at 0
  - `--api-key` (query): API Key for user. Needed to authenticate request
  - `--image-offset` (query, default `0`, int32): Only applicable for Epubs - handles multiple images on one page

### `kavita kavita image get-api-image-chapter-cover`

- Summary: Returns cover image for Chapter
- HTTP: `GET /api/Image/chapter-cover`
- Auth: required
- Body: none
- Flags:
  - `--chapter-id` (query, int32): chapterId
  - `--api-key` (query): apiKey

### `kavita kavita image get-api-image-collection-cover`

- Summary: Returns cover image for Collection
- HTTP: `GET /api/Image/collection-cover`
- Auth: required
- Body: none
- Flags:
  - `--collection-tag-id` (query, int32): collectionTagId
  - `--api-key` (query): apiKey

### `kavita kavita image get-api-image-cover-upload`

- Summary: Returns a temp coverupload image
- HTTP: `GET /api/Image/cover-upload`
- Auth: required
- Body: none
- Flags:
  - `--filename` (query): Filename of file. This is used with upload/upload-by-url
  - `--api-key` (query): apiKey

### `kavita kavita image get-api-image-external-chapter`

- HTTP: `GET /api/Image/external/chapter`
- Auth: required
- Body: none
- Flags:
  - `--series-id` (query, int32): seriesId
  - `--chapter-id` (query, int32): chapterId
- Output: columns `type`, `language`, `number`, `url`; response media `application/json`

### `kavita kavita image get-api-image-external-series`

- HTTP: `GET /api/Image/external/series`
- Auth: required
- Body: none
- Flags:
  - `--series-id` (query, int32): seriesId
- Output: columns `type`, `language`, `number`, `url`; response media `application/json`

### `kavita kavita image get-api-image-external-volume`

- HTTP: `GET /api/Image/external/volume`
- Auth: required
- Body: none
- Flags:
  - `--series-id` (query, int32): seriesId
  - `--volume-id` (query, int32): volumeId
- Output: columns `type`, `language`, `number`, `url`; response media `application/json`

### `kavita kavita image get-api-image-library-cover`

- Summary: Returns cover image for Library
- HTTP: `GET /api/Image/library-cover`
- Auth: required
- Body: none
- Flags:
  - `--library-id` (query, int32): libraryId
  - `--api-key` (query): apiKey

### `kavita kavita image get-api-image-person-cover`

- Summary: Returns cover image for Person
- HTTP: `GET /api/Image/person-cover`
- Auth: required
- Body: none
- Flags:
  - `--person-id` (query, int32): personId
  - `--api-key` (query): apiKey

### `kavita kavita image get-api-image-publisher`

- Summary: Returns the image associated with a publisher
- HTTP: `GET /api/Image/publisher`
- Auth: required
- Body: none
- Flags:
  - `--publisher-name` (query): publisherName
  - `--api-key` (query): apiKey

### `kavita kavita image get-api-image-readinglist-cover`

- Summary: Returns cover image for a Reading List
- HTTP: `GET /api/Image/readinglist-cover`
- Auth: required
- Body: none
- Flags:
  - `--reading-list-id` (query, int32): readingListId
  - `--api-key` (query): apiKey

### `kavita kavita image get-api-image-series-cover`

- Summary: Returns cover image for Series
- HTTP: `GET /api/Image/series-cover`
- Auth: required
- Body: none
- Flags:
  - `--series-id` (query, int32): Id of Series
  - `--api-key` (query): apiKey

### `kavita kavita image get-api-image-user-cover`

- Summary: Returns cover image for User
- HTTP: `GET /api/Image/user-cover`
- Auth: required
- Body: none
- Flags:
  - `--user-id` (query, int32): userId
  - `--api-key` (query): apiKey

### `kavita kavita image get-api-image-volume-cover`

- Summary: Returns cover image for Volume
- HTTP: `GET /api/Image/volume-cover`
- Auth: required
- Body: none
- Flags:
  - `--volume-id` (query, int32): volumeId
  - `--api-key` (query): apiKey

### `kavita kavita image get-api-image-web-link`

- Summary: Returns the image associated with a web-link
- HTTP: `GET /api/Image/web-link`
- Auth: required
- Body: none
- Flags:
  - `--url` (query): url
  - `--api-key` (query): apiKey

## KavitaPlusAudit

### `kavita kavita kavitaplusaudit get-api-kavita-plus-audit-entries-series-series-id`

- Summary: Returns Kavita+ audit info scoped to a single series, for the popover.
- HTTP: `GET /api/kavita-plus-audit/entries/series/{seriesId}`
- Auth: required
- Body: none
- Flags:
  - `--series-id` (path, required, int32): seriesId
- Output: list path `recentEvents`; columns `id`, `canRetry`, `category`, `createdUtc`, `errorMessage`, `eventType`; response media `application/json`

### `kavita kavita kavitaplusaudit get-api-kavita-plus-audit-failed-scrobble-events`

- HTTP: `GET /api/kavita-plus-audit/failed-scrobble-events`
- Auth: required
- Body: none
- Flags: none
- Output: response media `application/json`

### `kavita kavita kavitaplusaudit get-api-kavita-plus-audit-stats`

- Summary: Returns aggregate stats for the admin audit feed header strip.
- HTTP: `GET /api/kavita-plus-audit/stats`
- Auth: required
- Body: none
- Flags: none
- Output: response media `application/json`

### `kavita kavita kavitaplusaudit post-api-kavita-plus-audit-entries`

- Summary: Returns a paged, filtered list of all Kavita+ audit events. Admin only.
- HTTP: `POST /api/kavita-plus-audit/entries`
- Auth: required
- Body: optional; media type `application/json`
- Flags:
  - `--page-number` (query, int32): PageNumber
  - `--page-size` (query, int32): PageSize
- Output: columns `id`, `canRetry`, `category`, `createdUtc`, `errorMessage`, `eventType`; response media `application/json`

### `kavita kavita kavitaplusaudit post-api-kavita-plus-audit-my-activity`

- Summary: Returns the calling user's own Kavita+ activity, paged and filtered.
- HTTP: `POST /api/kavita-plus-audit/my-activity`
- Auth: required
- Body: optional; media type `application/json`
- Flags:
  - `--page-number` (query, int32): PageNumber
  - `--page-size` (query, int32): PageSize
- Output: columns `id`, `canRetry`, `category`, `createdUtc`, `errorMessage`, `eventType`; response media `application/json`

## Koreader

### `kavita kavita koreader get-api-koreader-api-key-syncs-progress-ebook-hash`

- Summary: Gets book progress from Kavita, if not found will return a 400
- HTTP: `GET /api/Koreader/{apiKey}/syncs/progress/{ebookHash}`
- Auth: required
- Body: none
- Flags:
  - `--api-key` (path, required): apiKey
  - `--ebook-hash` (path, required): ebookHash

### `kavita kavita koreader get-api-koreader-api-key-users-auth`

- HTTP: `GET /api/Koreader/{apiKey}/users/auth`
- Auth: required
- Body: none
- Flags:
  - `--api-key` (path, required): apiKey

### `kavita kavita koreader put-api-koreader-api-key-syncs-progress`

- Summary: Syncs book progress with Kavita. Will attempt to save the underlying reader position if possible.
- HTTP: `PUT /api/Koreader/{apiKey}/syncs/progress`
- Auth: required
- Body: optional; media type `application/json`
- Flags:
  - `--api-key` (path, required): apiKey
- Output: response media `application/json`

## Library

### `kavita kavita library delete-api-library-delete`

- Summary: Deletes the library and all series within it.
- HTTP: `DELETE /api/Library/delete`
- Auth: required
- Body: none
- Flags:
  - `--library-id` (query, int32): libraryId
- Output: response media `application/json`

### `kavita kavita library delete-api-library-delete-multiple`

- Summary: Deletes multiple libraries and all series within it.
- HTTP: `DELETE /api/Library/delete-multiple`
- Auth: required
- Body: optional; media type `application/json`
- Flags: none
- Output: response media `application/json`

### `kavita kavita library get-api-library`

- Summary: Return a specific library
- HTTP: `GET /api/Library`
- Auth: required
- Body: none
- Flags:
  - `--library-id` (query, int32): libraryId
- Output: list path `excludePatterns`; response media `application/json`

### `kavita kavita library get-api-library-jump-bar`

- Summary: For a given library, generate the jump bar information
- HTTP: `GET /api/Library/jump-bar`
- Auth: required
- Body: none
- Flags:
  - `--library-id` (query, int32): libraryId
- Output: columns `key`, `size`, `title`; response media `application/json`

### `kavita kavita library get-api-library-libraries`

- Summary: Return all libraries in the Server
- HTTP: `GET /api/Library/libraries`
- Auth: required
- Body: none
- Flags: none
- Output: columns `name`, `type`, `id`, `allowMetadataMatching`, `allowScrobbling`, `collapseSeriesRelationships`; response media `application/json`

### `kavita kavita library get-api-library-list`

- Summary: Returns a list of directories for a given path. If path is empty, returns root drives.
- HTTP: `GET /api/Library/list`
- Auth: required
- Body: none
- Flags:
  - `--path` (query): path
- Output: columns `name`, `fullPath`; response media `application/json`

### `kavita kavita library get-api-library-metadata-enabled-libraries`

- Summary: Kavita.Models.Entities.Enums.LibraryType with KavitaPlus metadata support
- HTTP: `GET /api/Library/metadata-enabled-libraries`
- Auth: required
- Body: none
- Flags: none
- Output: response media `application/json`

### `kavita kavita library get-api-library-metadata-providers`

- Summary: Return all Kavita.Models.Entities.Enums.MetadataProviders that are supported by the given Kavita.Models.Entities.Enums.LibraryType"/>
- HTTP: `GET /api/Library/metadata-providers`
- Auth: required
- Body: none
- Flags:
  - `--library-type` (query): libraryType
- Output: response media `application/json`

### `kavita kavita library get-api-library-name-exists`

- Summary: Checks if the library name exists or not
- HTTP: `GET /api/Library/name-exists`
- Auth: required
- Body: none
- Flags:
  - `--name` (query): If empty or null, will return true as that is invalid
- Output: response media `application/json`

### `kavita kavita library get-api-library-scrobble-enabled-libraries`

- Summary: Kavita.Models.Entities.Enums.LibraryType with KavitaPlus scrobble support
- HTTP: `GET /api/Library/scrobble-enabled-libraries`
- Auth: required
- Body: none
- Flags: none
- Output: response media `application/json`

### `kavita kavita library get-api-library-type`

- Summary: Returns the type of the underlying library
- HTTP: `GET /api/Library/type`
- Auth: required
- Body: none
- Flags:
  - `--library-id` (query, int32): libraryId
- Output: response media `application/json`

### `kavita kavita library get-api-library-user-libraries`

- Summary: Gets libraries for the given user that you also have access to
- HTTP: `GET /api/Library/user-libraries`
- Auth: required
- Body: none
- Flags:
  - `--user-id` (query, int32): userId
- Output: columns `name`, `type`, `id`, `allowMetadataMatching`, `allowScrobbling`, `collapseSeriesRelationships`; response media `application/json`

### `kavita kavita library post-api-library-copy-settings-from`

- Summary: Copy the library settings (adv tab + optional type) to a set of other libraries.
- HTTP: `POST /api/Library/copy-settings-from`
- Auth: required
- Body: optional; media type `application/json`
- Flags: none

### `kavita kavita library post-api-library-create`

- Summary: Creates a new Library. Upon library creation, adds new library to all Admin accounts.
- HTTP: `POST /api/Library/create`
- Auth: required
- Body: optional; media type `application/json`
- Flags: none
- Output: list path `excludePatterns`; response media `application/json`

### `kavita kavita library post-api-library-grant-access`

- Summary: Grants a user account access to a Library
- HTTP: `POST /api/Library/grant-access`
- Auth: required
- Body: optional; media type `application/json`
- Flags: none
- Output: list path `libraries`; columns `name`, `type`, `id`, `allowMetadataMatching`, `allowScrobbling`, `collapseSeriesRelationships`; response media `application/json`

### `kavita kavita library post-api-library-has-files-at-root`

- Summary: For each root, checks if there are any supported files at root to warn the user during library creation about an invalid setup
- HTTP: `POST /api/Library/has-files-at-root`
- Auth: required
- Body: optional; media type `application/json`
- Flags: none
- Output: response media `application/json`

### `kavita kavita library post-api-library-refresh-metadata`

- HTTP: `POST /api/Library/refresh-metadata`
- Auth: required
- Body: none
- Flags:
  - `--library-id` (query, int32): libraryId
  - `--force` (query, default `true`): force
  - `--force-colorscape` (query, default `true`): forceColorscape

### `kavita kavita library post-api-library-refresh-metadata-multiple`

- HTTP: `POST /api/Library/refresh-metadata-multiple`
- Auth: required
- Body: optional; media type `application/json`
- Flags:
  - `--force-colorscape` (query, default `true`): forceColorscape

### `kavita kavita library post-api-library-scan`

- Summary: Scans a given library for file changes.
- HTTP: `POST /api/Library/scan`
- Auth: required
- Body: none
- Flags:
  - `--library-id` (query, int32): libraryId
  - `--force` (query, default `false`): If true, will ignore any optimizations to avoid file I/O and will treat similar to a first scan

### `kavita kavita library post-api-library-scan-all`

- Summary: Scans a given library for file changes. If another scan task is in progress, will reschedule the invocation for 3 hours in future.
- HTTP: `POST /api/Library/scan-all`
- Auth: required
- Body: none
- Flags:
  - `--force` (query, default `false`): If true, will ignore any optimizations to avoid file I/O and will treat similar to a first scan

### `kavita kavita library post-api-library-scan-folder`

- Summary: Given a valid path, will invoke either a Scan Series or Scan Library. If the folder does not exist within Kavita, the request will be ignored
- HTTP: `POST /api/Library/scan-folder`
- Auth: required
- Body: optional; media type `application/json`
- Flags: none

### `kavita kavita library post-api-library-scan-multiple`

- Summary: Enqueues a bunch of library scans
- HTTP: `POST /api/Library/scan-multiple`
- Auth: required
- Body: optional; media type `application/json`
- Flags: none

### `kavita kavita library post-api-library-update`

- Summary: Updates an existing Library with new name, folders, and/or type.
- HTTP: `POST /api/Library/update`
- Auth: required
- Body: optional; media type `application/json`
- Flags: none

## License

### `kavita kavita license delete-api-license`

- Summary: Remove the Kavita+ License on the Server
- HTTP: `DELETE /api/License`
- Auth: required
- Body: none
- Flags: none

### `kavita kavita license delete-api-license-cancel`

- Summary: Cancels the active Kavita+ Subscription tied to this server. License will elapse at end of billing period.
- HTTP: `DELETE /api/License/cancel`
- Auth: required
- Body: optional; media type `application/json`
- Flags: none

### `kavita kavita license get-api-license-has-license`

- Summary: Has any license registered with the instance. Does not validate against Kavita+ API
- HTTP: `GET /api/License/has-license`
- Auth: required
- Body: none
- Flags: none
- Output: response media `application/json`

### `kavita kavita license get-api-license-info`

- Summary: Asks Kavita+ for the latest license info
- HTTP: `GET /api/License/info`
- Auth: required
- Body: none
- Flags:
  - `--force-check` (query, default `false`): Force checking the API and skip the 8-hour cache
- Output: response media `application/json`

### `kavita kavita license get-api-license-products`

- Summary: Returns the available Kavita+ products (billing interval and list price) the renew flow can select.
- HTTP: `GET /api/License/products`
- Auth: required
- Body: none
- Flags: none
- Output: columns `billingInterval`, `priceAmount`, `priceCurrency`, `productName`; response media `application/json`

### `kavita kavita license get-api-license-provider-health`

- Summary: Provides a 15 min snapshot of Kavita+ Providers (Hardcover, AniList, MangaBaka, etc.) API health.
- HTTP: `GET /api/License/provider-health`
- Auth: required
- Body: none
- Flags:
  - `--force-check` (query, default `false`): Bypass cache and force a reload from Kavita+ server
- Output: columns `avgLatencyMs`, `provider`, `status`; response media `application/json`

### `kavita kavita license get-api-license-stats`

- Summary: Providers how many interactions this license has had with Kavita+ over a lifetime
- HTTP: `GET /api/License/stats`
- Auth: required
- Body: none
- Flags: none
- Output: list path `stats`; columns `apiName`, `last30DaysCount`, `lifetimeCount`; response media `application/json`

### `kavita kavita license get-api-license-valid-license`

- Summary: Checks if the user's license is valid or not
- HTTP: `GET /api/License/valid-license`
- Auth: required
- Body: none
- Flags:
  - `--force-check` (query, default `false`): forceCheck
- Output: response media `application/json`

### `kavita kavita license post-api-license`

- Summary: Updates server license
- HTTP: `POST /api/License`
- Auth: required
- Body: optional; media type `application/json`
- Flags: none
- Output: response media `application/json`

### `kavita kavita license post-api-license-change-email`

- Summary: Change email on Kavita+ License/Stripe - Sends a confirmation email on Kavita+ side. No-op for server.
- HTTP: `POST /api/License/change-email`
- Auth: required
- Body: optional; media type `application/json`
- Flags: none
- Output: response media `application/json`

### `kavita kavita license post-api-license-renew`

- Summary: Renews the subscription on the given billing interval and returns the Stripe Checkout (Pay Now) URL the customer visits to pay.
- HTTP: `POST /api/License/renew`
- Auth: required
- Body: optional; media type `application/json`
- Flags: none
- Output: response media `application/json`

### `kavita kavita license post-api-license-resend-license`

- Summary: Resend the welcome email to the user
- HTTP: `POST /api/License/resend-license`
- Auth: required
- Body: none
- Flags: none
- Output: response media `application/json`

### `kavita kavita license post-api-license-reset`

- Summary: Break the registration between Kavita+ and this instance
- HTTP: `POST /api/License/reset`
- Auth: required
- Body: optional; media type `application/json`
- Flags: none

## Locale

### `kavita kavita locale get-api-locale`

- Summary: Returns all applicable locales on the server
- HTTP: `GET /api/Locale`
- Auth: required
- Body: none
- Flags: none
- Output: columns `fileName`, `hash`, `isRtL`, `renderName`, `translationCompletion`; response media `application/json`

## Manage

### `kavita kavita manage post-api-manage-series-metadata`

- Summary: Returns a list of all Series that is Kavita+ applicable to metadata match and the status of it
- HTTP: `POST /api/Manage/series-metadata`
- Auth: required
- Body: optional; media type `application/json`
- Flags:
  - `--page-number` (query, int32): PageNumber
  - `--page-size` (query, int32): PageSize
- Output: columns `isMatched`, `validUntilUtc`; response media `application/json`

## Metadata

### `kavita kavita metadata get-api-metadata-age-ratings`

- Summary: Fetches all age ratings from the instance
- HTTP: `GET /api/Metadata/age-ratings`
- Auth: required
- Body: none
- Flags:
  - `--library-ids` (query): String separated libraryIds or null for all ratings
- Output: columns `title`, `value`; response media `application/json`

### `kavita kavita metadata get-api-metadata-all-languages`

- Summary: Returns all languages Kavita can accept
- HTTP: `GET /api/Metadata/all-languages`
- Auth: required
- Body: none
- Flags: none
- Output: columns `isoCode`, `title`; response media `application/json`

### `kavita kavita metadata get-api-metadata-genres`

- Summary: Fetches genres from the instance
- HTTP: `GET /api/Metadata/genres`
- Auth: required
- Body: none
- Flags:
  - `--library-ids` (query): String separated libraryIds or null for all genres
  - `--context` (query): Context from which this API was invoked
- Output: columns `id`, `title`; response media `application/json`

### `kavita kavita metadata get-api-metadata-language-title`

- Summary: Given a language code returns the display name
- HTTP: `GET /api/Metadata/language-title`
- Auth: required
- Body: none
- Flags:
  - `--code` (query): code
- Output: response media `application/json`

### `kavita kavita metadata get-api-metadata-languages`

- Summary: Fetches all age languages from the libraries passed (or if none passed, all in the server)
- HTTP: `GET /api/Metadata/languages`
- Auth: required
- Body: none
- Flags:
  - `--library-ids` (query): String separated libraryIds or null for all ratings
- Output: columns `isoCode`, `title`; response media `application/json`

### `kavita kavita metadata get-api-metadata-people`

- Summary: Fetches people from the instance
- HTTP: `GET /api/Metadata/people`
- Auth: required
- Body: none
- Flags:
  - `--library-ids` (query): String separated libraryIds or null for all people
- Output: columns `name`, `id`, `aniListId`, `asin`, `coverImage`, `coverImageLocked`; response media `application/json`

### `kavita kavita metadata get-api-metadata-people-by-role`

- Summary: Fetches people from the instance by role
- HTTP: `GET /api/Metadata/people-by-role`
- Auth: required
- Body: none
- Flags:
  - `--role` (query): role
- Output: columns `name`, `id`, `aniListId`, `asin`, `coverImage`, `coverImageLocked`; response media `application/json`

### `kavita kavita metadata get-api-metadata-publication-status`

- Summary: Fetches all publication status' from the instance
- HTTP: `GET /api/Metadata/publication-status`
- Auth: required
- Body: none
- Flags:
  - `--library-ids` (query): String separated libraryIds or null for all publication status
- Output: columns `title`, `value`; response media `application/json`

### `kavita kavita metadata get-api-metadata-readinglist-tags`

- Summary: Fetches Reading List Tags from the instance
- HTTP: `GET /api/Metadata/readinglist-tags`
- Auth: required
- Body: none
- Flags: none
- Output: columns `id`, `normalizedTitle`, `title`; response media `application/json`

### `kavita kavita metadata get-api-metadata-series-detail-plus`

- Summary: Fetches the details needed from Kavita+ for Series Detail page
- HTTP: `GET /api/Metadata/series-detail-plus`
- Auth: required
- Body: none
- Flags:
  - `--series-id` (query, int32): Series Id
  - `--library-type` (query): Library Type
- Output: list path `ratings`; columns `authority`, `averageScore`, `favoriteCount`, `provider`, `providerUrl`; response media `application/json`

### `kavita kavita metadata get-api-metadata-tags`

- Summary: Fetches all tags from the instance
- HTTP: `GET /api/Metadata/tags`
- Auth: required
- Body: none
- Flags:
  - `--library-ids` (query): String separated libraryIds or null for all tags
- Output: columns `id`, `title`; response media `application/json`

### `kavita kavita metadata post-api-metadata-genres-with-counts`

- Summary: Returns a list of Genres with counts for counts when Genre is on Series/Chapter
- HTTP: `POST /api/Metadata/genres-with-counts`
- Auth: required
- Body: optional; media type `application/json`
- Flags: none
- Output: columns `id`, `chapterCount`, `seriesCount`, `title`; response media `application/json`

### `kavita kavita metadata post-api-metadata-tags-with-counts`

- Summary: Returns a list of Tags with counts for counts when Tag is on Series/Chapter
- HTTP: `POST /api/Metadata/tags-with-counts`
- Auth: required
- Body: optional; media type `application/json`
- Flags: none
- Output: columns `id`, `chapterCount`, `seriesCount`, `title`; response media `application/json`

## OAuth

### `kavita kavita oauth get-api-o-auth-callback`

- Summary: Callback from KavitaPlus.
- HTTP: `GET /api/OAuth/callback`
- Auth: required
- Body: none
- Flags:
  - `--upstream` (query): upstream
  - `--token` (query): token
  - `--api-key` (query): Encrypted ApiKey
  - `--refresh-token` (query): refreshToken

### `kavita kavita oauth get-api-o-auth-start`

- Summary: Start the OAuth flow for the given upstream, redirect (302!) to KavitaPlus
- HTTP: `GET /api/OAuth/start`
- Auth: required
- Body: none
- Flags:
  - `--upstream` (query): upstream

## Oidc

### `kavita kavita oidc get-oidc-login`

- HTTP: `GET /Oidc/login`
- Auth: required
- Body: none
- Flags:
  - `--return-url` (query, default `/`): returnUrl

### `kavita kavita oidc get-oidc-logout`

- HTTP: `GET /Oidc/logout`
- Auth: required
- Body: none
- Flags: none

## Opds

### `kavita kavita opds get-api-opds-api-key`

- Summary: Returns the Catalogue for Kavita's OPDS Service
- HTTP: `GET /api/Opds/{apiKey}`
- Auth: required
- Body: none
- Flags:
  - `--api-key` (path, required): apiKey

### `kavita kavita opds get-api-opds-api-key-collections`

- Summary: Get all Collections - Supports Pagination
- HTTP: `GET /api/Opds/{apiKey}/collections`
- Auth: required
- Body: none
- Flags:
  - `--api-key` (path, required): apiKey
  - `--page-number` (query, default `1`, int32): pageNumber

### `kavita kavita opds get-api-opds-api-key-collections-collection-id`

- Summary: Get Series for a given Collection - Supports Pagination
- HTTP: `GET /api/Opds/{apiKey}/collections/{collectionId}`
- Auth: required
- Body: none
- Flags:
  - `--collection-id` (path, required, int32): collectionId
  - `--api-key` (path, required): apiKey
  - `--page-number` (query, default `1`, int32): pageNumber

### `kavita kavita opds get-api-opds-api-key-favicon`

- HTTP: `GET /api/Opds/{apiKey}/favicon`
- Auth: required
- Body: none
- Flags:
  - `--api-key` (path, required): apiKey

### `kavita kavita opds get-api-opds-api-key-image`

- Summary: This returns a streamed image following OPDS-PS v1.2
- HTTP: `GET /api/Opds/{apiKey}/image`
- Auth: required
- Body: none
- Flags:
  - `--api-key` (path, required): apiKey
  - `--library-id` (query, int32): libraryId
  - `--series-id` (query, int32): seriesId
  - `--volume-id` (query, int32): volumeId
  - `--chapter-id` (query, int32): chapterId
  - `--page-number` (query, int32): pageNumber
  - `--save-progress` (query, default `true`): Optional parameter. Can pass false and progress saving will be suppressed

### `kavita kavita opds get-api-opds-api-key-libraries`

- Summary: Get the User's Libraries - No Pagination Support
- HTTP: `GET /api/Opds/{apiKey}/libraries`
- Auth: required
- Body: none
- Flags:
  - `--api-key` (path, required): apiKey
  - `--page-number` (query, default `1`, int32): pageNumber

### `kavita kavita opds get-api-opds-api-key-libraries-library-id`

- Summary: Returns Series from the Library - Supports Pagination
- HTTP: `GET /api/Opds/{apiKey}/libraries/{libraryId}`
- Auth: required
- Body: none
- Flags:
  - `--library-id` (path, required, int32): libraryId
  - `--api-key` (path, required): apiKey
  - `--page-number` (query, default `1`, int32): pageNumber

### `kavita kavita opds get-api-opds-api-key-on-deck`

- Summary: Get the On Deck (Dashboard) - Supports Pagination
- HTTP: `GET /api/Opds/{apiKey}/on-deck`
- Auth: required
- Body: none
- Flags:
  - `--api-key` (path, required): apiKey
  - `--page-number` (query, default `1`, int32): pageNumber

### `kavita kavita opds get-api-opds-api-key-reading-list`

- Summary: Get a User's Reading Lists - Supports Pagination
- HTTP: `GET /api/Opds/{apiKey}/reading-list`
- Auth: required
- Body: none
- Flags:
  - `--api-key` (path, required): apiKey
  - `--page-number` (query, default `1`, int32): pageNumber

### `kavita kavita opds get-api-opds-api-key-reading-list-reading-list-id`

- Summary: Returns individual items (chapters) from Reading List by ID - Supports Pagination
- HTTP: `GET /api/Opds/{apiKey}/reading-list/{readingListId}`
- Auth: required
- Body: none
- Flags:
  - `--reading-list-id` (path, required, int32): readingListId
  - `--api-key` (path, required): apiKey
  - `--page-number` (query, default `1`, int32): pageNumber

### `kavita kavita opds get-api-opds-api-key-recently-added`

- Summary: Returns Recently Added (Dashboard Feed) - Supports Pagination
- HTTP: `GET /api/Opds/{apiKey}/recently-added`
- Auth: required
- Body: none
- Flags:
  - `--api-key` (path, required): apiKey
  - `--page-number` (query, default `1`, int32): pageNumber

### `kavita kavita opds get-api-opds-api-key-recently-updated`

- Summary: Get the Recently Updated Series (Dashboard) - Pagination available, total pages will not be filled due to underlying implementation
- HTTP: `GET /api/Opds/{apiKey}/recently-updated`
- Auth: required
- Body: none
- Flags:
  - `--api-key` (path, required): apiKey
  - `--page-number` (query, default `1`, int32): pageNumber

### `kavita kavita opds get-api-opds-api-key-search`

- HTTP: `GET /api/Opds/{apiKey}/search`
- Auth: required
- Body: none
- Flags:
  - `--api-key` (path, required): apiKey

### `kavita kavita opds get-api-opds-api-key-series`

- Summary: OPDS Search endpoint
- HTTP: `GET /api/Opds/{apiKey}/series`
- Auth: required
- Body: none
- Flags:
  - `--api-key` (path, required): apiKey
  - `--query` (query): query

### `kavita kavita opds get-api-opds-api-key-series-series-id`

- Summary: Returns the items within a Series (Series Detail)
- HTTP: `GET /api/Opds/{apiKey}/series/{seriesId}`
- Auth: required
- Body: none
- Flags:
  - `--api-key` (path, required): apiKey
  - `--series-id` (path, required, int32): seriesId

### `kavita kavita opds get-api-opds-api-key-series-series-id-volume-volume-id`

- Summary: Returns items for a given Volume
- HTTP: `GET /api/Opds/{apiKey}/series/{seriesId}/volume/{volumeId}`
- Auth: required
- Body: none
- Flags:
  - `--api-key` (path, required): apiKey
  - `--series-id` (path, required, int32): seriesId
  - `--volume-id` (path, required, int32): volumeId

### `kavita kavita opds get-api-opds-api-key-series-series-id-volume-volume-id-chapter-chapter-id`

- Summary: Gets items for a given Chapter
- HTTP: `GET /api/Opds/{apiKey}/series/{seriesId}/volume/{volumeId}/chapter/{chapterId}`
- Auth: required
- Body: none
- Flags:
  - `--api-key` (path, required): apiKey
  - `--series-id` (path, required, int32): seriesId
  - `--volume-id` (path, required, int32): volumeId
  - `--chapter-id` (path, required, int32): chapterId

### `kavita kavita opds get-api-opds-api-key-series-series-id-volume-volume-id-chapter-chapter-id-download-filename`

- Summary: Downloads a file (user must have download permission)
- HTTP: `GET /api/Opds/{apiKey}/series/{seriesId}/volume/{volumeId}/chapter/{chapterId}/download/{filename}`
- Auth: required
- Body: none
- Flags:
  - `--api-key` (path, required): User's API Key
  - `--series-id` (path, required, int32): seriesId
  - `--volume-id` (path, required, int32): volumeId
  - `--chapter-id` (path, required, int32): chapterId
  - `--filename` (path, required): Not used. Only for Chunky to allow download links

### `kavita kavita opds get-api-opds-api-key-smart-filters`

- Summary: Get the User's Smart Filters (Dashboard Context) - Supports Pagination
- HTTP: `GET /api/Opds/{apiKey}/smart-filters`
- Auth: required
- Body: none
- Flags:
  - `--api-key` (path, required): apiKey
  - `--page-number` (query, default `1`, int32): pageNumber

### `kavita kavita opds get-api-opds-api-key-smart-filters-filter-id`

- Summary: Get the User's Smart Filter - Supports Pagination
- HTTP: `GET /api/Opds/{apiKey}/smart-filters/{filterId}`
- Auth: required
- Body: none
- Flags:
  - `--api-key` (path, required): apiKey
  - `--filter-id` (path, required, int32): filterId
  - `--page-number` (query, default `1`, int32): pageNumber

### `kavita kavita opds get-api-opds-api-key-want-to-read`

- Summary: Get the User's Want to Read list - Supports Pagination
- HTTP: `GET /api/Opds/{apiKey}/want-to-read`
- Auth: required
- Body: none
- Flags:
  - `--api-key` (path, required): apiKey
  - `--page-number` (query, default `1`, int32): pageNumber

### `kavita kavita opds post-api-opds-api-key`

- Summary: Returns the Catalogue for Kavita's OPDS Service
- HTTP: `POST /api/Opds/{apiKey}`
- Auth: required
- Body: none
- Flags:
  - `--api-key` (path, required): apiKey

## Panels

### `kavita kavita panels get-api-panels-get-progress`

- Summary: Gets the Progress of a given chapter
- HTTP: `GET /api/Panels/get-progress`
- Auth: required
- Body: none
- Flags:
  - `--chapter-id` (query, int32): chapterId
  - `--api-key` (query): apiKey
- Output: response media `application/json`

### `kavita kavita panels post-api-panels-save-progress`

- Summary: Saves the progress of a given chapter. This will generate a reading session with the estimated time from the
- HTTP: `POST /api/Panels/save-progress`
- Auth: required
- Body: optional; media type `application/json`
- Flags:
  - `--api-key` (query): apiKey

## Person

### `kavita kavita person get-api-person`

- HTTP: `GET /api/Person`
- Auth: required
- Body: none
- Flags:
  - `--name` (query): name
- Output: list path `aliases`; response media `application/json`

### `kavita kavita person get-api-person-chapters-by-role`

- Summary: Returns all individual chapters by role. Limited to 20 results.
- HTTP: `GET /api/Person/chapters-by-role`
- Auth: required
- Body: none
- Flags:
  - `--person-id` (query, int32): personId
  - `--role` (query): role
- Output: columns `id`, `ageRating`, `ageRatingLocked`, `aniListId`, `avgHoursToRead`, `cbrId`; response media `application/json`

### `kavita kavita person get-api-person-roles`

- Summary: Returns all roles for a Person
- HTTP: `GET /api/Person/roles`
- Auth: required
- Body: none
- Flags:
  - `--person-id` (query, int32): personId
- Output: response media `application/json`

### `kavita kavita person get-api-person-search`

- Summary: Find a person by name or alias against a query string
- HTTP: `GET /api/Person/search`
- Auth: required
- Body: none
- Flags:
  - `--query-string` (query): queryString
- Output: columns `name`, `id`, `aniListId`, `asin`, `coverImage`, `coverImageLocked`; response media `application/json`

### `kavita kavita person get-api-person-series-known-for`

- Summary: Returns the top 20 series that the "person" is known for. This will use Average Rating when applicable (Kavita+ field), else it's a random sort
- HTTP: `GET /api/Person/series-known-for`
- Auth: required
- Body: none
- Flags:
  - `--person-id` (query, int32): personId
- Output: columns `name`, `id`, `aniListId`, `avgHoursToRead`, `cbrId`, `comicVineId`; response media `application/json`

### `kavita kavita person post-api-person-all`

- Summary: Returns a list of authors and artists for browsing
- HTTP: `POST /api/Person/all`
- Auth: required
- Body: optional; media type `application/json`
- Flags:
  - `--page-number` (query, int32): PageNumber
  - `--page-size` (query, int32): PageSize
- Output: columns `name`, `id`, `aniListId`, `asin`, `chapterCount`, `coverImage`; response media `application/json`

### `kavita kavita person post-api-person-fetch-cover`

- Summary: Attempts to download the cover from CoversDB (Note: Not yet release in Kavita)
- HTTP: `POST /api/Person/fetch-cover`
- Auth: required
- Body: none
- Flags:
  - `--person-id` (query, int32): personId
- Output: response media `application/json`

### `kavita kavita person post-api-person-merge`

- Summary: Merges Persons into one, this action is irreversible
- HTTP: `POST /api/Person/merge`
- Auth: required
- Body: optional; media type `application/json`
- Flags: none
- Output: list path `aliases`; response media `application/json`

### `kavita kavita person post-api-person-update`

- Summary: Updates the Person
- HTTP: `POST /api/Person/update`
- Auth: required
- Body: optional; media type `application/json`
- Flags: none
- Output: list path `aliases`; response media `application/json`

### `kavita kavita person post-api-person-valid-alias`

- Summary: Ensure the alias is valid to be added. For example, the alias cannot be on another person or be the same as the current person name/alias.
- HTTP: `POST /api/Person/valid-alias`
- Auth: required
- Body: optional; media type `application/json`
- Flags: none
- Output: response media `application/json`

## Plugin

### `kavita kavita plugin get-api-plugin-authkey-expires`

- Summary: Returns the expiration (UTC) of the authenticated Auth key (or null if none set)
- HTTP: `GET /api/Plugin/authkey-expires`
- Auth: required
- Body: none
- Flags: none
- Output: response media `application/json`

### `kavita kavita plugin get-api-plugin-parse`

- Summary: Parse a string and return Parsed information from it. Does not support any directory fallback parsing
- HTTP: `GET /api/Plugin/parse`
- Auth: required
- Body: none
- Flags:
  - `--name` (query): String to parse
  - `--library-type` (query): Determines the set of pattern matching to use
- Output: response media `application/json`

### `kavita kavita plugin get-api-plugin-version`

- Summary: Returns the version of the Kavita install
- HTTP: `GET /api/Plugin/version`
- Auth: required
- Body: none
- Flags:
  - `--api-key` (query, required): Required for authenticating to get result
- Output: response media `application/json`

### `kavita kavita plugin post-api-plugin-authenticate`

- Summary: Authenticate with the Server given an auth key. This will log you in by returning the user object and the JWT token.
- HTTP: `POST /api/Plugin/authenticate`
- Auth: required
- Body: none
- Flags:
  - `--api-key` (query, required): Auth key which will be used to authenticate and return a valid user token back
  - `--plugin-name` (query, required): Name of the Plugin
- Output: list path `authKeys`; columns `name`, `id`, `createdAtUtc`, `expiresAtUtc`, `key`, `lastAccessedAtUtc`; response media `application/json`

### `kavita kavita plugin post-api-plugin-parse-bulk`

- HTTP: `POST /api/Plugin/parse-bulk`
- Auth: required
- Body: optional; media type `application/json`
- Flags: none
- Output: response media `application/json`

## Rating

### `kavita kavita rating get-api-rating-overall-chapter`

- Summary: Overall rating from all Kavita users for a given Chapter
- HTTP: `GET /api/Rating/overall-chapter`
- Auth: required
- Body: none
- Flags:
  - `--chapter-id` (query, int32): chapterId
- Output: response media `application/json`

### `kavita kavita rating get-api-rating-overall-series`

- Summary: Overall rating from all Kavita users for a given Series
- HTTP: `GET /api/Rating/overall-series`
- Auth: required
- Body: none
- Flags:
  - `--series-id` (query, int32): seriesId
- Output: response media `application/json`

### `kavita kavita rating post-api-rating-chapter`

- Summary: Update the users' rating of the given chapter
- HTTP: `POST /api/Rating/chapter`
- Auth: required
- Body: optional; media type `application/json`
- Flags: none

### `kavita kavita rating post-api-rating-series`

- Summary: Update the users' rating of the given series
- HTTP: `POST /api/Rating/series`
- Auth: required
- Body: optional; media type `application/json`
- Flags: none

## Reader

### `kavita kavita reader delete-api-reader-ptoc`

- Summary: Deletes the user's personal table of content for the given chapter
- HTTP: `DELETE /api/Reader/ptoc`
- Auth: required
- Body: none
- Flags:
  - `--chapter-id` (query, int32): chapterId
  - `--page-num` (query, int32): pageNum
  - `--title` (query): title

### `kavita kavita reader get-api-reader-bookmark-image`

- Summary: Returns an image for a given bookmark series. Side effect: This will cache the bookmark images for reading.
- HTTP: `GET /api/Reader/bookmark-image`
- Auth: required
- Body: none
- Flags:
  - `--series-id` (query, int32): seriesId
  - `--api-key` (query): Api key for the user the bookmarks are on
  - `--page` (query, int32): page
- Output: pagination `offset`

### `kavita kavita reader get-api-reader-bookmark-info`

- Summary: Returns various information about all bookmark files for a Series. Side effect: This will cache the bookmark images for reading.
- HTTP: `GET /api/Reader/bookmark-info`
- Auth: required
- Body: none
- Flags:
  - `--series-id` (query, int32): Series Id for all bookmarks
  - `--include-dimensions` (query, default `true`): Include file dimensions (extra I/O). Defaults to true.
- Output: list path `pageDimensions`; columns `fileName`, `height`, `isWide`, `pageNumber`, `width`; response media `application/json`

### `kavita kavita reader get-api-reader-chapter-bookmarks`

- Summary: Returns a list of bookmarked pages for a given Chapter
- HTTP: `GET /api/Reader/chapter-bookmarks`
- Auth: required
- Body: none
- Flags:
  - `--chapter-id` (query, int32): chapterId
- Output: columns `id`, `chapterId`, `chapterTitle`, `imageOffset`, `page`, `seriesId`; response media `application/json`

### `kavita kavita reader get-api-reader-chapter-info`

- Summary: Returns various information about a Chapter. Side effect: This will cache the chapter images for reading.
- HTTP: `GET /api/Reader/chapter-info`
- Auth: required
- Body: none
- Flags:
  - `--chapter-id` (query, int32): chapterId
  - `--extract-pdf` (query, default `false`): Should Kavita extract pdf into images. Defaults to false.
  - `--include-dimensions` (query, default `false`): Include file dimensions. Only useful for image-based reading
- Output: list path `pageDimensions`; columns `fileName`, `height`, `isWide`, `pageNumber`, `width`; response media `application/json`

### `kavita kavita reader get-api-reader-continue-point`

- Summary: Continue point is the chapter which you should start reading again from. If there is no progress on a series, then the first chapter will be returned (non-special unless only specials).
- HTTP: `GET /api/Reader/continue-point`
- Auth: required
- Body: none
- Flags:
  - `--series-id` (query, int32): seriesId
- Output: list path `characters`; columns `name`, `id`, `aniListId`, `asin`, `coverImage`, `coverImageLocked`; response media `application/json`

### `kavita kavita reader get-api-reader-file-dimensions`

- Summary: Returns the file dimensions for all pages in a chapter. If the underlying chapter is PDF, use extractPDF to unpack as images.
- HTTP: `GET /api/Reader/file-dimensions`
- Auth: required
- Body: none
- Flags:
  - `--chapter-id` (query, int32): chapterId
  - `--extract-pdf` (query, default `false`): extractPdf
- Output: columns `fileName`, `height`, `isWide`, `pageNumber`, `width`; response media `application/json`

### `kavita kavita reader get-api-reader-first-progress-date`

- HTTP: `GET /api/Reader/first-progress-date`
- Auth: required
- Body: none
- Flags:
  - `--user-id` (query, int32): userId
- Output: response media `application/json`

### `kavita kavita reader get-api-reader-get-progress`

- Summary: Returns Progress (page number) for a chapter for the logged in user
- HTTP: `GET /api/Reader/get-progress`
- Auth: required
- Body: none
- Flags:
  - `--chapter-id` (query, int32): chapterId
- Output: response media `application/json`

### `kavita kavita reader get-api-reader-has-progress`

- Summary: Returns if the user has reading progress on the Series
- HTTP: `GET /api/Reader/has-progress`
- Auth: required
- Body: none
- Flags:
  - `--series-id` (query, int32): seriesId
- Output: response media `application/json`

### `kavita kavita reader get-api-reader-image`

- Summary: Returns an image for a given chapter. Will perform bounding checks
- HTTP: `GET /api/Reader/image`
- Auth: required
- Body: none
- Flags:
  - `--chapter-id` (query, int32): Chapter Id
  - `--page` (query, int32): Page in question
  - `--api-key` (query): User's API Key for authentication
  - `--extract-pdf` (query, default `false`): Should Kavita extract pdf into images. Defaults to false.
- Output: pagination `offset`

### `kavita kavita reader get-api-reader-next-chapter`

- Summary: Returns the next logical chapter from the series.
- HTTP: `GET /api/Reader/next-chapter`
- Auth: required
- Body: none
- Flags:
  - `--series-id` (query, int32): seriesId
  - `--volume-id` (query, int32): volumeId
  - `--current-chapter-id` (query, int32): currentChapterId
- Output: response media `application/json`

### `kavita kavita reader get-api-reader-pdf`

- Summary: Returns the PDF for the chapterId.
- HTTP: `GET /api/Reader/pdf`
- Auth: required
- Body: none
- Flags:
  - `--chapter-id` (query, int32): chapterId
  - `--api-key` (query): Auth Key for authentication
  - `--extract-pdf` (query, default `false`): Converts PDF into images per-page - Used for Mihon mainly

### `kavita kavita reader get-api-reader-prev-chapter`

- Summary: Returns the previous logical chapter from the series.
- HTTP: `GET /api/Reader/prev-chapter`
- Auth: required
- Body: none
- Flags:
  - `--series-id` (query, int32): seriesId
  - `--volume-id` (query, int32): volumeId
  - `--current-chapter-id` (query, int32): currentChapterId
- Output: response media `application/json`

### `kavita kavita reader get-api-reader-prompt-reread-chapter`

- Summary: Check if we should prompt the user for rereads for the given chapter
- HTTP: `GET /api/Reader/prompt-reread/chapter`
- Auth: required
- Body: none
- Flags:
  - `--library-id` (query, int32): libraryId
  - `--series-id` (query, int32): seriesId
  - `--chapter-id` (query, int32): chapterId
- Output: response media `application/json`

### `kavita kavita reader get-api-reader-prompt-reread-series`

- Summary: Check if we should prompt the user for rereads for the given series
- HTTP: `GET /api/Reader/prompt-reread/series`
- Auth: required
- Body: none
- Flags:
  - `--series-id` (query, int32): seriesId
  - `--library-id` (query, int32): libraryId
- Output: response media `application/json`

### `kavita kavita reader get-api-reader-prompt-reread-volume`

- Summary: Check if we should prompt the user for rereads for the given volume
- HTTP: `GET /api/Reader/prompt-reread/volume`
- Auth: required
- Body: none
- Flags:
  - `--library-id` (query, int32): libraryId
  - `--series-id` (query, int32): seriesId
  - `--volume-id` (query, int32): volumeId
- Output: response media `application/json`

### `kavita kavita reader get-api-reader-ptoc`

- Summary: Returns the user's personal table of contents for the given chapter
- HTTP: `GET /api/Reader/ptoc`
- Auth: required
- Body: none
- Flags:
  - `--chapter-id` (query, int32): chapterId
- Output: columns `id`, `bookScrollId`, `chapterId`, `chapterTitle`, `pageNumber`, `selectedText`; response media `application/json`

### `kavita kavita reader get-api-reader-series-bookmarks`

- Summary: Returns all bookmarked pages for a given series
- HTTP: `GET /api/Reader/series-bookmarks`
- Auth: required
- Body: none
- Flags:
  - `--series-id` (query, int32): seriesId
- Output: columns `id`, `chapterId`, `chapterTitle`, `imageOffset`, `page`, `seriesId`; response media `application/json`

### `kavita kavita reader get-api-reader-thumbnail`

- Summary: Returns a thumbnail for the given page number
- HTTP: `GET /api/Reader/thumbnail`
- Auth: required
- Body: none
- Flags:
  - `--chapter-id` (query, int32): chapterId
  - `--page-num` (query, int32): pageNum
  - `--api-key` (query): apiKey

### `kavita kavita reader get-api-reader-time-left`

- Summary: For the current user, returns an estimate on how long it would take to finish reading the series.
- HTTP: `GET /api/Reader/time-left`
- Auth: required
- Body: none
- Flags:
  - `--series-id` (query, int32): seriesId
- Output: response media `application/json`

### `kavita kavita reader get-api-reader-time-left-for-chapter`

- Summary: For the current user, returns an estimate on how long it would take to finish reading the chapter.
- HTTP: `GET /api/Reader/time-left-for-chapter`
- Auth: required
- Body: none
- Flags:
  - `--series-id` (query, int32): seriesId
  - `--chapter-id` (query, int32): chapterId
- Output: response media `application/json`

### `kavita kavita reader get-api-reader-volume-bookmarks`

- Summary: Returns all bookmarked pages for a given volume
- HTTP: `GET /api/Reader/volume-bookmarks`
- Auth: required
- Body: none
- Flags:
  - `--volume-id` (query, int32): volumeId
- Output: columns `id`, `chapterId`, `chapterTitle`, `imageOffset`, `page`, `seriesId`; response media `application/json`

### `kavita kavita reader post-api-reader-all-bookmarks`

- Summary: Returns a list of all bookmarked pages for a User
- HTTP: `POST /api/Reader/all-bookmarks`
- Auth: required
- Body: optional; media type `application/json`
- Flags: none
- Output: columns `id`, `chapterId`, `chapterTitle`, `imageOffset`, `page`, `seriesId`; response media `application/json`

### `kavita kavita reader post-api-reader-bookmark`

- Summary: Bookmarks a page against a Chapter
- HTTP: `POST /api/Reader/bookmark`
- Auth: required
- Body: optional; media type `application/json`
- Flags: none

### `kavita kavita reader post-api-reader-bulk-remove-bookmarks`

- Summary: Removes all bookmarks for all chapters linked to a Series
- HTTP: `POST /api/Reader/bulk-remove-bookmarks`
- Auth: required
- Body: optional; media type `application/json`
- Flags: none

### `kavita kavita reader post-api-reader-create-ptoc`

- Summary: Create a new personal table of content entry for a given chapter
- HTTP: `POST /api/Reader/create-ptoc`
- Auth: required
- Body: optional; media type `application/json`
- Flags: none

### `kavita kavita reader post-api-reader-mark-chapter-read`

- Summary: Mark a single chapter as read
- HTTP: `POST /api/Reader/mark-chapter-read`
- Auth: required
- Body: optional; media type `application/json`
- Flags: none

### `kavita kavita reader post-api-reader-mark-multiple-read`

- Summary: Marks all chapters within a list of volumes as Read. All volumes must belong to the same Series.
- HTTP: `POST /api/Reader/mark-multiple-read`
- Auth: required
- Body: optional; media type `application/json`
- Flags: none

### `kavita kavita reader post-api-reader-mark-multiple-series-read`

- Summary: Marks all chapters within a list of series as Read.
- HTTP: `POST /api/Reader/mark-multiple-series-read`
- Auth: required
- Body: optional; media type `application/json`
- Flags: none

### `kavita kavita reader post-api-reader-mark-multiple-series-unread`

- Summary: Marks all chapters within a list of series as Unread.
- HTTP: `POST /api/Reader/mark-multiple-series-unread`
- Auth: required
- Body: optional; media type `application/json`
- Flags: none

### `kavita kavita reader post-api-reader-mark-multiple-unread`

- Summary: Marks all chapters within a list of volumes as Unread. All volumes must belong to the same Series.
- HTTP: `POST /api/Reader/mark-multiple-unread`
- Auth: required
- Body: optional; media type `application/json`
- Flags: none

### `kavita kavita reader post-api-reader-mark-read`

- Summary: Marks a Series as read. All volumes and chapters will be marked as read during this process.
- HTTP: `POST /api/Reader/mark-read`
- Auth: required
- Body: optional; media type `application/json`
- Flags: none

### `kavita kavita reader post-api-reader-mark-unread`

- Summary: Marks a Series as Unread. All volumes and chapters will be marked as unread during this process.
- HTTP: `POST /api/Reader/mark-unread`
- Auth: required
- Body: optional; media type `application/json`
- Flags: none

### `kavita kavita reader post-api-reader-mark-volume-read`

- Summary: Marks all chapters within a volume as Read
- HTTP: `POST /api/Reader/mark-volume-read`
- Auth: required
- Body: optional; media type `application/json`
- Flags: none

### `kavita kavita reader post-api-reader-mark-volume-unread`

- Summary: Marks all chapters within a volume as unread
- HTTP: `POST /api/Reader/mark-volume-unread`
- Auth: required
- Body: optional; media type `application/json`
- Flags: none

### `kavita kavita reader post-api-reader-progress`

- Summary: Save page against Chapter for authenticated user
- HTTP: `POST /api/Reader/progress`
- Auth: required
- Body: optional; media type `application/json`
- Flags: none

### `kavita kavita reader post-api-reader-remove-bookmarks`

- Summary: Removes all bookmarks for all chapters linked to a Series
- HTTP: `POST /api/Reader/remove-bookmarks`
- Auth: required
- Body: optional; media type `application/json`
- Flags: none

### `kavita kavita reader post-api-reader-unbookmark`

- Summary: Removes a bookmarked page for a Chapter
- HTTP: `POST /api/Reader/unbookmark`
- Auth: required
- Body: optional; media type `application/json`
- Flags: none

## ReadingList

### `kavita kavita readinglist delete-api-reading-list`

- Summary: Deletes a reading list
- HTTP: `DELETE /api/ReadingList`
- Auth: required
- Body: none
- Flags:
  - `--reading-list-id` (query, int32): readingListId

### `kavita kavita readinglist get-api-reading-list`

- Summary: Fetches a single Reading List
- HTTP: `GET /api/ReadingList`
- Auth: required
- Body: none
- Flags:
  - `--reading-list-id` (query, int32): readingListId
- Output: list path `tags`; columns `id`, `normalizedTitle`, `title`; response media `application/json`

### `kavita kavita readinglist get-api-reading-list-all-people`

- Summary: Returns all people in given roles for a reading list
- HTTP: `GET /api/ReadingList/all-people`
- Auth: required
- Body: none
- Flags:
  - `--reading-list-id` (query, int32): readingListId
- Output: columns `name`, `id`, `aniListId`, `asin`, `coverImage`, `coverImageLocked`; response media `application/json`

### `kavita kavita readinglist get-api-reading-list-info`

- Summary: Returns random information about a Reading List
- HTTP: `GET /api/ReadingList/info`
- Auth: required
- Body: none
- Flags:
  - `--reading-list-id` (query, int32): readingListId
- Output: response media `application/json`

### `kavita kavita readinglist get-api-reading-list-items`

- Summary: Fetches all reading list items for a given list including rich metadata around series, volume, chapters, and progress
- HTTP: `GET /api/ReadingList/items`
- Auth: required
- Body: none
- Flags:
  - `--reading-list-id` (query, int32): readingListId
- Output: columns `id`, `chapterId`, `chapterNumber`, `chapterTitleName`, `fileSize`, `isSpecial`; response media `application/json`

### `kavita kavita readinglist get-api-reading-list-lists-for-chapter`

- Summary: Returns all Reading Lists the user has access to that has the given chapter within it.
- HTTP: `GET /api/ReadingList/lists-for-chapter`
- Auth: required
- Body: none
- Flags:
  - `--chapter-id` (query, int32): chapterId
- Output: columns `id`, `ageRating`, `canSync`, `coverImage`, `coverImageLocked`, `downloadUrl`; response media `application/json`

### `kavita kavita readinglist get-api-reading-list-lists-for-series`

- Summary: Returns all Reading Lists the user has access to that the given series within it.
- HTTP: `GET /api/ReadingList/lists-for-series`
- Auth: required
- Body: none
- Flags:
  - `--series-id` (query, int32): seriesId
- Output: columns `id`, `ageRating`, `canSync`, `coverImage`, `coverImageLocked`, `downloadUrl`; response media `application/json`

### `kavita kavita readinglist get-api-reading-list-name-exists`

- Summary: Checks if a reading list exists with the name
- HTTP: `GET /api/ReadingList/name-exists`
- Auth: required
- Body: none
- Flags:
  - `--name` (query): If empty or null, will return true as that is invalid
- Output: response media `application/json`

### `kavita kavita readinglist get-api-reading-list-next-chapter`

- Summary: Returns the next chapter within the reading list
- HTTP: `GET /api/ReadingList/next-chapter`
- Auth: required
- Body: none
- Flags:
  - `--current-chapter-id` (query, int32): currentChapterId
  - `--reading-list-id` (query, int32): readingListId
- Output: response media `application/json`

### `kavita kavita readinglist get-api-reading-list-people`

- Summary: Returns a list of a given role associated with the reading list
- HTTP: `GET /api/ReadingList/people`
- Auth: required
- Body: none
- Flags:
  - `--reading-list-id` (query, int32): readingListId
  - `--role` (query): PersonRole
- Output: columns `name`, `id`, `aniListId`, `asin`, `coverImage`, `coverImageLocked`; response media `application/json`

### `kavita kavita readinglist get-api-reading-list-prev-chapter`

- Summary: Returns the prev chapter within the reading list
- HTTP: `GET /api/ReadingList/prev-chapter`
- Auth: required
- Body: none
- Flags:
  - `--current-chapter-id` (query, int32): currentChapterId
  - `--reading-list-id` (query, int32): readingListId
- Output: response media `application/json`

### `kavita kavita readinglist post-api-reading-list-all`

- Summary: Returns reading lists (paginated) for a given user.
- HTTP: `POST /api/ReadingList/all`
- Auth: required
- Body: optional; media type `application/json`
- Flags:
  - `--page-number` (query, int32): PageNumber
  - `--page-size` (query, int32): PageSize
- Output: columns `id`, `ageRating`, `canSync`, `coverImage`, `coverImageLocked`, `downloadUrl`; response media `application/json`

### `kavita kavita readinglist post-api-reading-list-create`

- Summary: Creates a new List with a unique title. Returns the new ReadingList back
- HTTP: `POST /api/ReadingList/create`
- Auth: required
- Body: optional; media type `application/json`
- Flags: none
- Output: list path `tags`; columns `id`, `normalizedTitle`, `title`; response media `application/json`

### `kavita kavita readinglist post-api-reading-list-delete-item`

- Summary: Deletes a list item from the list. Item orders will update as a result.
- HTTP: `POST /api/ReadingList/delete-item`
- Auth: required
- Body: optional; media type `application/json`
- Flags: none

### `kavita kavita readinglist post-api-reading-list-delete-multiple`

- Summary: Delete multiple reading lists in one go
- HTTP: `POST /api/ReadingList/delete-multiple`
- Auth: required
- Body: optional; media type `application/json`
- Flags: none

### `kavita kavita readinglist post-api-reading-list-export-as-cbl`

- Summary: Export a Reading List to CBL format
- HTTP: `POST /api/ReadingList/export-as-cbl`
- Auth: required
- Body: none
- Flags:
  - `--reading-list-id` (query, int32): readingListId
  - `--as-v2` (query, default `false`): asV2

### `kavita kavita readinglist post-api-reading-list-lists`

- Summary: Returns reading lists (paginated) for a given user.
- HTTP: `POST /api/ReadingList/lists`
- Auth: required
- Body: none
- Flags:
  - `--page-number` (query, int32): PageNumber
  - `--page-size` (query, int32): PageSize
  - `--include-promoted` (query, default `true`): Include Promoted Reading Lists along with user's Reading Lists. Defaults to true
  - `--sort-by-last-modified` (query, default `false`): Sort by last modified (most recent first) or by title (alphabetical)
- Output: columns `id`, `ageRating`, `canSync`, `coverImage`, `coverImageLocked`, `downloadUrl`; response media `application/json`

### `kavita kavita readinglist post-api-reading-list-promote-multiple`

- Summary: Promote/UnPromote multiple reading lists in one go. Will only update the authenticated user's reading lists and will only work if the user has promotion role
- HTTP: `POST /api/ReadingList/promote-multiple`
- Auth: required
- Body: optional; media type `application/json`
- Flags: none

### `kavita kavita readinglist post-api-reading-list-regenerate-cover`

- Summary: Regenerates the cover image for a reading list, you must own the given reading list to do this
- HTTP: `POST /api/ReadingList/regenerate-cover`
- Auth: required
- Body: none
- Flags:
  - `--reading-list-id` (query, int32): readingListId

### `kavita kavita readinglist post-api-reading-list-remove-read`

- Summary: Removes all entries that are fully read from the reading list
- HTTP: `POST /api/ReadingList/remove-read`
- Auth: required
- Body: none
- Flags:
  - `--reading-list-id` (query, int32): readingListId

### `kavita kavita readinglist post-api-reading-list-update`

- Summary: Update the properties (title, summary) of a reading list
- HTTP: `POST /api/ReadingList/update`
- Auth: required
- Body: optional; media type `application/json`
- Flags: none
- Output: list path `tags`; columns `id`, `normalizedTitle`, `title`; response media `application/json`

### `kavita kavita readinglist post-api-reading-list-update-by-chapter`

- HTTP: `POST /api/ReadingList/update-by-chapter`
- Auth: required
- Body: optional; media type `application/json`
- Flags: none

### `kavita kavita readinglist post-api-reading-list-update-by-multiple`

- Summary: Adds all chapters from a list of volumes and chapters to a reading list
- HTTP: `POST /api/ReadingList/update-by-multiple`
- Auth: required
- Body: optional; media type `application/json`
- Flags: none

### `kavita kavita readinglist post-api-reading-list-update-by-multiple-series`

- Summary: Adds all chapters from a list of series to a reading list
- HTTP: `POST /api/ReadingList/update-by-multiple-series`
- Auth: required
- Body: optional; media type `application/json`
- Flags: none

### `kavita kavita readinglist post-api-reading-list-update-by-series`

- Summary: Adds all chapters from a Series to a reading list
- HTTP: `POST /api/ReadingList/update-by-series`
- Auth: required
- Body: optional; media type `application/json`
- Flags: none

### `kavita kavita readinglist post-api-reading-list-update-by-volume`

- HTTP: `POST /api/ReadingList/update-by-volume`
- Auth: required
- Body: optional; media type `application/json`
- Flags: none

### `kavita kavita readinglist post-api-reading-list-update-position`

- Summary: Updates an items position
- HTTP: `POST /api/ReadingList/update-position`
- Auth: required
- Body: optional; media type `application/json`
- Flags: none

## ReadingProfile

### `kavita kavita readingprofile delete-api-reading-profile`

- Summary: Deletes the given profile, requires the profile to belong to the logged-in user
- HTTP: `DELETE /api/reading-profile`
- Auth: required
- Body: none
- Flags:
  - `--profile-id` (query, int32): profileId

### `kavita kavita readingprofile delete-api-reading-profile-library-library-id`

- Summary: Clears the reading profile for the given library for the currently logged-in user
- HTTP: `DELETE /api/reading-profile/library/{libraryId}`
- Auth: required
- Body: none
- Flags:
  - `--library-id` (path, required, int32): libraryId

### `kavita kavita readingprofile delete-api-reading-profile-series-series-id`

- Summary: Clears the reading profile for the given series for the currently logged-in user
- HTTP: `DELETE /api/reading-profile/series/{seriesId}`
- Auth: required
- Body: none
- Flags:
  - `--series-id` (path, required, int32): seriesId

### `kavita kavita readingprofile get-api-reading-profile-all`

- Summary: Gets all non-implicit reading profiles for a user
- HTTP: `GET /api/reading-profile/all`
- Auth: required
- Body: none
- Flags: none
- Output: columns `name`, `kind`, `id`, `allowAutomaticWebtoonReaderDetection`, `autoCloseMenu`, `backgroundColor`; response media `application/json`

### `kavita kavita readingprofile get-api-reading-profile-library`

- Summary: Returns all the Reading rofiles bound to the library
- HTTP: `GET /api/reading-profile/library`
- Auth: required
- Body: none
- Flags:
  - `--library-id` (query, int32): libraryId
- Output: columns `name`, `kind`, `id`, `allowAutomaticWebtoonReaderDetection`, `autoCloseMenu`, `backgroundColor`; response media `application/json`

### `kavita kavita readingprofile get-api-reading-profile-library-id-series-id`

- Summary: Returns the ReadingProfile that should be applied to the given series, walks up the tree.
- HTTP: `GET /api/reading-profile/{libraryId}/{seriesId}`
- Auth: required
- Body: none
- Flags:
  - `--library-id` (path, required, int32): libraryId
  - `--series-id` (path, required, int32): seriesId
  - `--skip-implicit` (query): skipImplicit
  - `--device-id` (query, int32): Defaults to currently active device
- Output: list path `deviceIds`; response media `application/json`

### `kavita kavita readingprofile get-api-reading-profile-series`

- Summary: Returns all Reading Profiles bound to a series
- HTTP: `GET /api/reading-profile/series`
- Auth: required
- Body: none
- Flags:
  - `--series-id` (query, int32): seriesId
- Output: columns `name`, `kind`, `id`, `allowAutomaticWebtoonReaderDetection`, `autoCloseMenu`, `backgroundColor`; response media `application/json`

### `kavita kavita readingprofile post-api-reading-profile`

- Summary: Updates the given reading profile, must belong to the current user
- HTTP: `POST /api/reading-profile`
- Auth: required
- Body: optional; media type `application/json`
- Flags: none
- Output: list path `deviceIds`; response media `application/json`

### `kavita kavita readingprofile post-api-reading-profile-bulk`

- Summary: Assigns the reading profile to all passes series, and deletes their implicit profiles
- HTTP: `POST /api/reading-profile/bulk`
- Auth: required
- Body: optional; media type `application/json`
- Flags: none

### `kavita kavita readingprofile post-api-reading-profile-create`

- Summary: Creates a new reading profile for the current user
- HTTP: `POST /api/reading-profile/create`
- Auth: required
- Body: optional; media type `application/json`
- Flags: none
- Output: list path `deviceIds`; response media `application/json`

### `kavita kavita readingprofile post-api-reading-profile-library-library-id`

- Summary: Sets the reading profile for a given library, removes the old one
- HTTP: `POST /api/reading-profile/library/{libraryId}`
- Auth: required
- Body: optional; media type `application/json`
- Flags:
  - `--library-id` (path, required, int32): libraryId

### `kavita kavita readingprofile post-api-reading-profile-promote`

- Summary: Promotes the implicit profile to a user profile. Removes the series from other profiles
- HTTP: `POST /api/reading-profile/promote`
- Auth: required
- Body: none
- Flags:
  - `--profile-id` (query, int32): profileId
  - `--device-id` (query, int32): Defaults to the currently active device
- Output: list path `deviceIds`; response media `application/json`

### `kavita kavita readingprofile post-api-reading-profile-series`

- Summary: Update the implicit reading profile for a series, creates one if none exists
- HTTP: `POST /api/reading-profile/series`
- Auth: required
- Body: optional; media type `application/json`
- Flags:
  - `--library-id` (query, int32): libraryId
  - `--series-id` (query, int32): seriesId
  - `--device-id` (query, int32): Defaults to the currently active device
- Output: list path `deviceIds`; response media `application/json`

### `kavita kavita readingprofile post-api-reading-profile-series-series-id`

- Summary: Sets the reading profile for a given series, removes the old one
- HTTP: `POST /api/reading-profile/series/{seriesId}`
- Auth: required
- Body: optional; media type `application/json`
- Flags:
  - `--series-id` (path, required, int32): seriesId

### `kavita kavita readingprofile post-api-reading-profile-set-devices`

- Summary: Set the assigned devices for a reading profile
- HTTP: `POST /api/reading-profile/set-devices`
- Auth: required
- Body: optional; media type `application/json`
- Flags:
  - `--profile-id` (query, int32): profileId

### `kavita kavita readingprofile post-api-reading-profile-update-parent`

- Summary: Updates the non-implicit reading profile for the given series, and removes implicit profiles
- HTTP: `POST /api/reading-profile/update-parent`
- Auth: required
- Body: optional; media type `application/json`
- Flags:
  - `--library-id` (query, int32): libraryId
  - `--series-id` (query, int32): seriesId
  - `--device-id` (query, int32): Defaults to currently active device
- Output: list path `deviceIds`; response media `application/json`

## Review

### `kavita kavita review delete-api-review-chapter`

- Summary: Deletes the user's review for the given chapter
- HTTP: `DELETE /api/Review/chapter`
- Auth: required
- Body: none
- Flags:
  - `--chapter-id` (query, int32): chapterId

### `kavita kavita review delete-api-review-series`

- Summary: Deletes the user's review for the given series
- HTTP: `DELETE /api/Review/series`
- Auth: required
- Body: none
- Flags:
  - `--series-id` (query, int32): seriesId

### `kavita kavita review get-api-review-all`

- Summary: Returns all reviews for the user. If you are authenticated as the user, will always return data, regardless of ShareReviews setting
- HTTP: `GET /api/Review/all`
- Auth: required
- Body: none
- Flags:
  - `--user-id` (query, int32): User to load, if your own, will bypass RBS and ShareReviews restrictions
  - `--rating` (query, float): Null to ignore filtering. >= rating
  - `--filter-query` (query): Null to ignore filtering on Series name
- Output: columns `id`, `body`, `chapterId`, `createdUtc`, `libraryId`, `rating`; response media `application/json`

### `kavita kavita review post-api-review-chapter`

- Summary: Update the user's review for a given chapter
- HTTP: `POST /api/Review/chapter`
- Auth: required
- Body: optional; media type `application/json`
- Flags: none
- Output: response media `application/json`

### `kavita kavita review post-api-review-series`

- Summary: Updates the user's review for a given series
- HTTP: `POST /api/Review/series`
- Auth: required
- Body: optional; media type `application/json`
- Flags: none
- Output: response media `application/json`

## Scrobbling

### `kavita kavita scrobbling delete-api-scrobbling-remove-hold`

- Summary: Remove a hold against the Series for user's scrobbling
- HTTP: `DELETE /api/Scrobbling/remove-hold`
- Auth: required
- Body: none
- Flags:
  - `--series-id` (query, int32): seriesId

### `kavita kavita scrobbling get-api-scrobbling-expired-tokens`

- Summary: Returns all expired tokens for the current user
- HTTP: `GET /api/Scrobbling/expired-tokens`
- Auth: required
- Body: none
- Flags: none
- Output: response media `application/json`

### `kavita kavita scrobbling get-api-scrobbling-has-hold`

- Summary: If there is an active hold on the series
- HTTP: `GET /api/Scrobbling/has-hold`
- Auth: required
- Body: none
- Flags:
  - `--series-id` (query, int32): seriesId
- Output: response media `application/json`

### `kavita kavita scrobbling get-api-scrobbling-holds`

- Summary: Returns all scrobble holds for the current user
- HTTP: `GET /api/Scrobbling/holds`
- Auth: required
- Body: none
- Flags: none
- Output: columns `created`, `createdUtc`, `libraryId`, `seriesId`, `seriesName`; response media `application/json`

### `kavita kavita scrobbling get-api-scrobbling-library-allows-scrobbling`

- Summary: Does the library the series is in allow scrobbling?
- HTTP: `GET /api/Scrobbling/library-allows-scrobbling`
- Auth: required
- Body: none
- Flags:
  - `--series-id` (query, int32): seriesId
- Output: response media `application/json`

### `kavita kavita scrobbling get-api-scrobbling-next-scrobble-time`

- Summary: Returns when Scrobbling upload will next execute
- HTTP: `GET /api/Scrobbling/next-scrobble-time`
- Auth: required
- Body: none
- Flags: none
- Output: response media `application/json`

### `kavita kavita scrobbling get-api-scrobbling-scrobble-errors`

- Summary: Returns all scrobbling errors for the instance
- HTTP: `GET /api/Scrobbling/scrobble-errors`
- Auth: required
- Body: none
- Flags: none
- Output: columns `comment`, `created`, `details`, `libraryId`, `seriesId`; response media `application/json`

### `kavita kavita scrobbling get-api-scrobbling-scrobble-settings`

- Summary: Returns all scrobble providers for a user. This list is guaranteed to contain an entry for each currently
- HTTP: `GET /api/Scrobbling/scrobble-settings`
- Auth: required
- Body: none
- Flags: none
- Output: columns `authenticationToken`, `hasRunScrobbleEventGeneration`, `lastSyncedUtc`, `provider`, `refreshToken`, `scrobbleEventGenerationRan`; response media `application/json`

### `kavita kavita scrobbling get-api-scrobbling-token-expired`

- Summary: Checks if the current Scrobbling token for the given Provider has expired for the current user
- HTTP: `GET /api/Scrobbling/token-expired`
- Auth: required
- Body: none
- Flags:
  - `--provider` (query): provider
- Output: response media `application/json`

### `kavita kavita scrobbling post-api-scrobbling-add-hold`

- Summary: Adds a hold against the Series for user's scrobbling
- HTTP: `POST /api/Scrobbling/add-hold`
- Auth: required
- Body: none
- Flags:
  - `--series-id` (query, int32): seriesId

### `kavita kavita scrobbling post-api-scrobbling-bulk-remove-events`

- Summary: Delete the given scrobble events if they belong to that user
- HTTP: `POST /api/Scrobbling/bulk-remove-events`
- Auth: required
- Body: optional; media type `application/json`
- Flags: none

### `kavita kavita scrobbling post-api-scrobbling-clear-errors`

- Summary: Clears the scrobbling errors table
- HTTP: `POST /api/Scrobbling/clear-errors`
- Auth: required
- Body: none
- Flags: none

### `kavita kavita scrobbling post-api-scrobbling-generate-scrobble-events`

- Summary: Generate scrobble events from history. Should only be ran once per user.
- HTTP: `POST /api/Scrobbling/generate-scrobble-events`
- Auth: required
- Body: none
- Flags:
  - `--scrobble-provider` (query): Members:

### `kavita kavita scrobbling post-api-scrobbling-generate-scrobble-events-all`

- Summary: Generate scrobble events from history for all valid providers.
- HTTP: `POST /api/Scrobbling/generate-scrobble-events-all`
- Auth: required
- Body: none
- Flags: none
- Output: response media `application/json`

### `kavita kavita scrobbling post-api-scrobbling-retry-scrobble`

- Summary: Attempts to retry Scrobble Events for the current authenticated user (or admin-allowed).
- HTTP: `POST /api/Scrobbling/retry-scrobble`
- Auth: required
- Body: optional; media type `application/json`
- Flags: none
- Output: response media `application/json`

### `kavita kavita scrobbling post-api-scrobbling-scrobble-events`

- Summary: Returns the scrobbling history for the user
- HTTP: `POST /api/Scrobbling/scrobble-events`
- Auth: required
- Body: optional; media type `application/json`
- Flags:
  - `--page-number` (query, int32): PageNumber
  - `--page-size` (query, int32): PageSize
- Output: columns `id`, `chapterNumber`, `createdUtc`, `errorDetails`, `isErrored`, `isProcessed`; response media `application/json`

### `kavita kavita scrobbling post-api-scrobbling-update-scrobble-settings`

- Summary: Updates the scrobble settings for a given provider. Libraries are filtered on supported types
- HTTP: `POST /api/Scrobbling/update-scrobble-settings`
- Auth: required
- Body: optional; media type `application/json`
- Flags:
  - `--provider` (query): provider

### `kavita kavita scrobbling post-api-scrobbling-update-user-scrobble-provider`

- Summary: Update authentication details for the given provider
- HTTP: `POST /api/Scrobbling/update-user-scrobble-provider`
- Auth: required
- Body: optional; media type `application/json`
- Flags: none

## Search

### `kavita kavita search get-api-search-chapters-by-series`

- Summary: Returns all chapters for a given series with localized titles. Used for CBL chapter-level matching.
- HTTP: `GET /api/Search/chapters-by-series`
- Auth: required
- Body: none
- Flags:
  - `--series-id` (query, int32): seriesId
- Output: columns `id`, `ageRating`, `ageRatingLocked`, `aniListId`, `avgHoursToRead`, `cbrId`; response media `application/json`

### `kavita kavita search get-api-search-search`

- Summary: Searches against different entities in the system against a query string
- HTTP: `GET /api/Search/search`
- Auth: required
- Body: none
- Flags:
  - `--query-string` (query): queryString
  - `--include-chapter-and-files` (query, default `true`): Include Chapter and Filenames in the entities. This can slow down the search on larger systems
- Output: list path `annotations`; columns `id`, `ageRating`, `chapterId`, `chapterTitle`, `comment`, `commentHtml`; response media `application/json`

### `kavita kavita search get-api-search-series-for-chapter`

- Summary: Returns the series for the Chapter id. If the user does not have access (shouldn't happen by the UI),
- HTTP: `GET /api/Search/series-for-chapter`
- Auth: required
- Body: none
- Flags:
  - `--chapter-id` (query, int32): chapterId
- Output: response media `application/json`

### `kavita kavita search get-api-search-series-for-mangafile`

- Summary: Returns the series for the MangaFile id. If the user does not have access (shouldn't happen by the UI),
- HTTP: `GET /api/Search/series-for-mangafile`
- Auth: required
- Body: none
- Flags:
  - `--manga-file-id` (query, int32): mangaFileId
- Output: response media `application/json`

## Series

### `kavita kavita series delete-api-series-series-id`

- Summary: Deletes a series from Kavita
- HTTP: `DELETE /api/Series/{seriesId}`
- Auth: required
- Body: none
- Flags:
  - `--series-id` (path, required, int32): seriesId
- Output: response media `application/json`

### `kavita kavita series get-api-series-age-rating`

- Summary: Get the age rating for the Kavita.Models.Entities.Enums.AgeRating enum value
- HTTP: `GET /api/Series/age-rating`
- Auth: required
- Body: none
- Flags:
  - `--age-rating` (query, int32): ageRating
- Output: response media `application/json`

### `kavita kavita series get-api-series-all-related`

- Summary: Returns all related series against the passed series Id
- HTTP: `GET /api/Series/all-related`
- Auth: required
- Body: none
- Flags:
  - `--series-id` (query, int32): seriesId
- Output: list path `adaptations`; columns `name`, `id`, `aniListId`, `avgHoursToRead`, `cbrId`, `comicVineId`; response media `application/json`

### `kavita kavita series get-api-series-chapter`

- Summary: Returns a single Chapter with progress information
- HTTP: `GET /api/Series/chapter`
- Auth: required
- Body: none
- Flags:
  - `--chapter-id` (query, int32): chapterId
- Output: list path `characters`; columns `name`, `id`, `aniListId`, `asin`, `coverImage`, `coverImageLocked`; response media `application/json`

### `kavita kavita series get-api-series-currently-reading`

- Summary: Get series a user is currently reading, requires the user to share their profile
- HTTP: `GET /api/Series/currently-reading`
- Auth: required
- Body: none
- Flags:
  - `--page-number` (query, int32): PageNumber
  - `--page-size` (query, int32): PageSize
  - `--user-id` (query, int32): userId
- Output: columns `name`, `id`, `aniListId`, `avgHoursToRead`, `cbrId`, `comicVineId`; response media `application/json`

### `kavita kavita series get-api-series-external-series-detail`

- Summary: Returns external series metadata around a Given External Series
- HTTP: `GET /api/Series/external-series-detail`
- Auth: required
- Body: none
- Flags:
  - `--ani-list-id` (query, int32): aniListId
  - `--mal-id` (query, int64): malId
  - `--manga-baka-id` (query, int32): mangaBakaId
  - `--series-id` (query, int32): seriesId
- Output: list path `chapterDtos`; columns `coverImageUrl`, `criticRating`, `hardcoverId`, `issueNumber`, `issueUrl`, `mangaBakaWorkId`; response media `application/json`

### `kavita kavita series get-api-series-match-info`

- Summary: Returns extra information around an existing match (and series) to display on the Match Screen.
- HTTP: `GET /api/Series/match-info`
- Auth: required
- Body: none
- Flags:
  - `--series-id` (query, int32): seriesId
- Output: response media `application/json`

### `kavita kavita series get-api-series-metadata`

- Summary: Returns metadata for a given series
- HTTP: `GET /api/Series/metadata`
- Auth: required
- Body: none
- Flags:
  - `--series-id` (query, int32): seriesId
- Output: list path `characters`; columns `name`, `id`, `aniListId`, `asin`, `coverImage`, `coverImageLocked`; response media `application/json`

### `kavita kavita series get-api-series-next-expected`

- Summary: Based on the delta times between when chapters are added, for series that are not Completed/Cancelled/Hiatus, forecast the next
- HTTP: `GET /api/Series/next-expected`
- Auth: required
- Body: none
- Flags:
  - `--series-id` (query, int32): seriesId
- Output: response media `application/json`

### `kavita kavita series get-api-series-related`

- Summary: Fetches the related series for a given series
- HTTP: `GET /api/Series/related`
- Auth: required
- Body: none
- Flags:
  - `--series-id` (query, int32): seriesId
  - `--relation` (query): Type of Relationship to pull back
- Output: columns `name`, `id`, `aniListId`, `avgHoursToRead`, `cbrId`, `comicVineId`; response media `application/json`

### `kavita kavita series get-api-series-series-by-collection`

- Summary: Returns all Series grouped by the passed Collection Id with Pagination.
- HTTP: `GET /api/Series/series-by-collection`
- Auth: required
- Body: none
- Flags:
  - `--collection-id` (query, int32): Collection Id to pull series from
  - `--page-number` (query, int32): PageNumber
  - `--page-size` (query, int32): PageSize
- Output: columns `name`, `id`, `aniListId`, `avgHoursToRead`, `cbrId`, `comicVineId`; response media `application/json`

### `kavita kavita series get-api-series-series-detail`

- Summary: Get a special DTO for Series Detail page.
- HTTP: `GET /api/Series/series-detail`
- Auth: required
- Body: none
- Flags:
  - `--series-id` (query, int32): seriesId
- Output: list path `chapters`; columns `id`, `ageRating`, `ageRatingLocked`, `aniListId`, `avgHoursToRead`, `cbrId`; response media `application/json`

### `kavita kavita series get-api-series-series-id`

- Summary: Fetches a Series for a given Id
- HTTP: `GET /api/Series/{seriesId}`
- Auth: required
- Body: none
- Flags:
  - `--series-id` (path, required, int32): Series Id to fetch details for
- Output: response media `application/json`

### `kavita kavita series get-api-series-series-with-annotations`

- Summary: Returns all Series that a user has access to
- HTTP: `GET /api/Series/series-with-annotations`
- Auth: required
- Body: none
- Flags: none
- Output: columns `name`, `id`, `aniListId`, `avgHoursToRead`, `cbrId`, `comicVineId`; response media `application/json`

### `kavita kavita series get-api-series-volume`

- Summary: Returns a single Volume with progress information and Chapters
- HTTP: `GET /api/Series/volume`
- Auth: required
- Body: none
- Flags:
  - `--volume-id` (query, int32): volumeId
- Output: list path `chapters`; columns `id`, `ageRating`, `ageRatingLocked`, `aniListId`, `avgHoursToRead`, `cbrId`; response media `application/json`

### `kavita kavita series get-api-series-volumes`

- Summary: Returns All volumes for a series with progress information and Chapters
- HTTP: `GET /api/Series/volumes`
- Auth: required
- Body: none
- Flags:
  - `--series-id` (query, int32): seriesId
- Output: columns `name`, `id`, `aniListId`, `avgHoursToRead`, `cbrId`, `comicVineId`; response media `application/json`

### `kavita kavita series post-api-series-all-v2`

- Summary: Returns all series for the library
- HTTP: `POST /api/Series/all-v2`
- Auth: required
- Body: optional; media type `application/json`
- Flags:
  - `--page-number` (query, int32): PageNumber
  - `--page-size` (query, int32): PageSize
  - `--user-id` (query, int32): Optional user id to request the OnDeck for someone else. They must have profile sharing enabled when doing so
  - `--context` (query): context
- Output: columns `name`, `id`, `aniListId`, `avgHoursToRead`, `cbrId`, `comicVineId`; response media `application/json`

### `kavita kavita series post-api-series-analyze`

- Summary: Run a file analysis on the series.
- HTTP: `POST /api/Series/analyze`
- Auth: required
- Body: optional; media type `application/json`
- Flags: none

### `kavita kavita series post-api-series-delete-multiple`

- Summary: Deletes multiple series from Kavita at once
- HTTP: `POST /api/Series/delete-multiple`
- Auth: required
- Body: optional; media type `application/json`
- Flags: none

### `kavita kavita series post-api-series-dont-match`

- Summary: When true, will not perform a match and will prevent Kavita from attempting to match/scrobble against this series
- HTTP: `POST /api/Series/dont-match`
- Auth: required
- Body: none
- Flags:
  - `--series-id` (query, int32): seriesId
  - `--dont-match` (query): dontMatch

### `kavita kavita series post-api-series-match`

- Summary: Sends a request to Kavita+ API for all potential matches, sorted by relevance
- HTTP: `POST /api/Series/match`
- Auth: required
- Body: optional; media type `application/json`
- Flags: none
- Output: columns `matchRating`; response media `application/json`

### `kavita kavita series post-api-series-metadata`

- Summary: Update series metadata
- HTTP: `POST /api/Series/metadata`
- Auth: required
- Body: optional; media type `application/json`
- Flags: none

### `kavita kavita series post-api-series-on-deck`

- Summary: Fetches series that are on deck aka have progress on them.
- HTTP: `POST /api/Series/on-deck`
- Auth: required
- Body: none
- Flags:
  - `--page-number` (query, int32): PageNumber
  - `--page-size` (query, int32): PageSize
  - `--library-id` (query, default `0`, int32): Default of 0 meaning all libraries
- Output: columns `name`, `id`, `aniListId`, `avgHoursToRead`, `cbrId`, `comicVineId`; response media `application/json`

### `kavita kavita series post-api-series-recently-added-v2`

- Summary: Gets all recently added series
- HTTP: `POST /api/Series/recently-added-v2`
- Auth: required
- Body: optional; media type `application/json`
- Flags:
  - `--page-number` (query, int32): PageNumber
  - `--page-size` (query, int32): PageSize
- Output: columns `name`, `id`, `aniListId`, `avgHoursToRead`, `cbrId`, `comicVineId`; response media `application/json`

### `kavita kavita series post-api-series-recently-updated-series`

- Summary: Returns series that were recently updated, like adding or removing a chapter
- HTTP: `POST /api/Series/recently-updated-series`
- Auth: required
- Body: none
- Flags:
  - `--page-number` (query, int32): PageNumber
  - `--page-size` (query, int32): PageSize
- Output: columns `id`, `chapterId`, `count`, `created`, `format`, `libraryId`; response media `application/json`

### `kavita kavita series post-api-series-refresh-metadata`

- Summary: Runs a Cover Image Generation task
- HTTP: `POST /api/Series/refresh-metadata`
- Auth: required
- Body: optional; media type `application/json`
- Flags: none

### `kavita kavita series post-api-series-remove-from-on-deck`

- Summary: Removes a series from displaying on deck until the next read event on that series
- HTTP: `POST /api/Series/remove-from-on-deck`
- Auth: required
- Body: none
- Flags:
  - `--series-id` (query, int32): seriesId

### `kavita kavita series post-api-series-scan`

- Summary: Scan a series and force each file to be updated. This should be invoked via the User, hence why we force.
- HTTP: `POST /api/Series/scan`
- Auth: required
- Body: optional; media type `application/json`
- Flags: none

### `kavita kavita series post-api-series-series-by-ids`

- Summary: Fetches Series for a set of Ids. This will check User for permission access and filter out any Ids that don't exist or
- HTTP: `POST /api/Series/series-by-ids`
- Auth: required
- Body: optional; media type `application/json`
- Flags: none
- Output: columns `name`, `id`, `aniListId`, `avgHoursToRead`, `cbrId`, `comicVineId`; response media `application/json`

### `kavita kavita series post-api-series-update`

- Summary: Updates the Series
- HTTP: `POST /api/Series/update`
- Auth: required
- Body: optional; media type `application/json`
- Flags: none
- Output: response media `application/json`

### `kavita kavita series post-api-series-update-match`

- Summary: This will perform the fix match
- HTTP: `POST /api/Series/update-match`
- Auth: required
- Body: optional; media type `application/json`
- Flags:
  - `--series-id` (query, int32): seriesId

### `kavita kavita series post-api-series-update-related`

- Summary: Update the relations attached to the Series. Does not generate associated Sequel/Prequel pairs on target series.
- HTTP: `POST /api/Series/update-related`
- Auth: required
- Body: optional; media type `application/json`
- Flags: none

### `kavita kavita series post-api-series-v2`

- Summary: Gets series with the applied Filter
- HTTP: `POST /api/Series/v2`
- Auth: required
- Body: optional; media type `application/json`
- Flags:
  - `--page-number` (query, int32): PageNumber
  - `--page-size` (query, int32): PageSize
- Output: columns `name`, `id`, `aniListId`, `avgHoursToRead`, `cbrId`, `comicVineId`; response media `application/json`

## Server

### `kavita kavita server get-api-server-changelog`

- Summary: Pull the Changelog for Kavita from Github and display
- HTTP: `GET /api/Server/changelog`
- Auth: required
- Body: none
- Flags:
  - `--count` (query, default `0`, int32): How many releases from the latest to return
- Output: columns `blogPart`, `currentVersion`, `isDocker`, `isOnNightlyInRelease`, `isPrerelease`, `isReleaseEqual`; response media `application/json`

### `kavita kavita server get-api-server-check-for-updates`

- Summary: Checks for updates and pushes an event to the UI
- HTTP: `GET /api/Server/check-for-updates`
- Auth: required
- Body: none
- Flags: none

### `kavita kavita server get-api-server-check-out-of-date`

- Summary: Returns how many versions out of date this install is
- HTTP: `GET /api/Server/check-out-of-date`
- Auth: required
- Body: none
- Flags:
  - `--stable-only` (query, default `true`): Only count Stable releases
- Output: response media `application/json`

### `kavita kavita server get-api-server-check-update`

- Summary: Checks for updates, if no updates that are > current version installed, returns null
- HTTP: `GET /api/Server/check-update`
- Auth: required
- Body: none
- Flags: none
- Output: list path `added`; response media `application/json`

### `kavita kavita server get-api-server-jobs`

- Summary: Returns a list of reoccurring jobs. Scheduled ad-hoc jobs will not be returned.
- HTTP: `GET /api/Server/jobs`
- Auth: required
- Body: none
- Flags: none
- Output: columns `id`, `createdAtUtc`, `cron`, `lastExecutionUtc`, `title`; response media `application/json`

### `kavita kavita server get-api-server-logs`

- Summary: Downloads all the log files via a zip
- HTTP: `GET /api/Server/logs`
- Auth: required
- Body: none
- Flags: none

### `kavita kavita server get-api-server-media-errors`

- Summary: Returns a list of issues found during scanning or reading in which files may have corruption or bad metadata (structural metadata)
- HTTP: `GET /api/Server/media-errors`
- Auth: required
- Body: none
- Flags: none
- Output: columns `comment`, `createdUtc`, `details`, `extension`, `filePath`; response media `application/json`

### `kavita kavita server get-api-server-server-info-slim`

- Summary: Returns non-sensitive information about the current system
- HTTP: `GET /api/Server/server-info-slim`
- Auth: required
- Body: none
- Flags: none
- Output: response media `application/json`

### `kavita kavita server post-api-server-analyze-files`

- Summary: This is a one time task that needs to be ran for v0.7 statistics to work
- HTTP: `POST /api/Server/analyze-files`
- Auth: required
- Body: none
- Flags: none

### `kavita kavita server post-api-server-backup-db`

- Summary: Performs an ad-hoc backup of the Database
- HTTP: `POST /api/Server/backup-db`
- Auth: required
- Body: none
- Flags: none

### `kavita kavita server post-api-server-bust-kavitaplus-cache`

- Summary: Bust Kavita+ Cache
- HTTP: `POST /api/Server/bust-kavitaplus-cache`
- Auth: required
- Body: none
- Flags: none

### `kavita kavita server post-api-server-cleanup`

- Summary: Performs the nightly maintenance work on the Server. Can be heavy.
- HTTP: `POST /api/Server/cleanup`
- Auth: required
- Body: none
- Flags: none

### `kavita kavita server post-api-server-cleanup-want-to-read`

- Summary: Performs an ad-hoc cleanup of Want To Read, by removing want to read series for users, where the series are fully read and in Completed publication status.
- HTTP: `POST /api/Server/cleanup-want-to-read`
- Auth: required
- Body: none
- Flags: none

### `kavita kavita server post-api-server-clear-cache`

- Summary: Performs an ad-hoc cleanup of Cache
- HTTP: `POST /api/Server/clear-cache`
- Auth: required
- Body: none
- Flags: none

### `kavita kavita server post-api-server-clear-media-alerts`

- Summary: Deletes all media errors
- HTTP: `POST /api/Server/clear-media-alerts`
- Auth: required
- Body: none
- Flags: none

### `kavita kavita server post-api-server-convert-media`

- Summary: Triggers the scheduling of the convert media job. This will convert all media to the target encoding (except for PNG). Only one job will run at a time.
- HTTP: `POST /api/Server/convert-media`
- Auth: required
- Body: none
- Flags: none

### `kavita kavita server post-api-server-sync-themes`

- Summary: Runs the Sync Themes task
- HTTP: `POST /api/Server/sync-themes`
- Auth: required
- Body: none
- Flags: none

## Settings

### `kavita kavita settings get-api-settings`

- Summary: Returns the server settings
- HTTP: `GET /api/Settings`
- Auth: required
- Body: none
- Flags: none
- Output: response media `application/json`

### `kavita kavita settings get-api-settings-base-url`

- Summary: Returns the base url for this instance (if set)
- HTTP: `GET /api/Settings/base-url`
- Auth: required
- Body: none
- Flags: none
- Output: response media `application/json`

### `kavita kavita settings get-api-settings-is-email-setup`

- Summary: Is the minimum information setup for Email to work
- HTTP: `GET /api/Settings/is-email-setup`
- Auth: required
- Body: none
- Flags: none
- Output: response media `application/json`

### `kavita kavita settings get-api-settings-is-valid-cron`

- Summary: Is the cron expression valid for Kavita's scheduler
- HTTP: `GET /api/Settings/is-valid-cron`
- Auth: required
- Body: none
- Flags:
  - `--cron-expression` (query): cronExpression
- Output: response media `application/json`

### `kavita kavita settings get-api-settings-library-types`

- HTTP: `GET /api/Settings/library-types`
- Auth: required
- Body: none
- Flags: none
- Output: response media `application/json`

### `kavita kavita settings get-api-settings-log-levels`

- HTTP: `GET /api/Settings/log-levels`
- Auth: required
- Body: none
- Flags: none
- Output: response media `application/json`

### `kavita kavita settings get-api-settings-metadata-settings`

- Summary: Get the metadata settings for Kavita+ users.
- HTTP: `GET /api/Settings/metadata-settings`
- Auth: required
- Body: none
- Flags: none
- Output: list path `blacklist`; response media `application/json`

### `kavita kavita settings get-api-settings-oidc`

- Summary: Retrieve publicly required configuration regarding Oidc
- HTTP: `GET /api/Settings/oidc`
- Auth: required
- Body: none
- Flags: none
- Output: response media `application/json`

### `kavita kavita settings get-api-settings-opds-enabled`

- HTTP: `GET /api/Settings/opds-enabled`
- Auth: required
- Body: none
- Flags: none
- Output: response media `application/json`

### `kavita kavita settings get-api-settings-task-frequencies`

- Summary: All values allowed for Task Scheduling APIs. A custom cron job is not included. Disabled is not applicable for Cleanup.
- HTTP: `GET /api/Settings/task-frequencies`
- Auth: required
- Body: none
- Flags: none
- Output: response media `application/json`

### `kavita kavita settings post-api-settings`

- Summary: Update Server settings
- HTTP: `POST /api/Settings`
- Auth: required
- Body: optional; media type `application/json`
- Flags: none
- Output: response media `application/json`

### `kavita kavita settings post-api-settings-import-field-mappings`

- Summary: Import field mappings
- HTTP: `POST /api/Settings/import-field-mappings`
- Auth: required
- Body: optional; media type `application/json`
- Flags: none
- Output: list path `ageRatingConflicts`; response media `application/json`

### `kavita kavita settings post-api-settings-is-valid-authority`

- Summary: Validate if the given authority is reachable from the server
- HTTP: `POST /api/Settings/is-valid-authority`
- Auth: required
- Body: optional; media type `application/json`
- Flags: none
- Output: response media `application/json`

### `kavita kavita settings post-api-settings-metadata-settings`

- Summary: Update the metadata settings for Kavita+ Metadata feature
- HTTP: `POST /api/Settings/metadata-settings`
- Auth: required
- Body: optional; media type `application/json`
- Flags: none
- Output: list path `blacklist`; response media `application/json`

### `kavita kavita settings post-api-settings-reset`

- HTTP: `POST /api/Settings/reset`
- Auth: required
- Body: none
- Flags: none
- Output: response media `application/json`

### `kavita kavita settings post-api-settings-reset-base-url`

- Summary: Resets the Base url
- HTTP: `POST /api/Settings/reset-base-url`
- Auth: required
- Body: none
- Flags: none
- Output: response media `application/json`

### `kavita kavita settings post-api-settings-reset-external-ids`

- HTTP: `POST /api/Settings/reset-external-ids`
- Auth: required
- Body: none
- Flags: none

### `kavita kavita settings post-api-settings-reset-ip-addresses`

- Summary: Resets the IP Addresses
- HTTP: `POST /api/Settings/reset-ip-addresses`
- Auth: required
- Body: none
- Flags: none
- Output: response media `application/json`

### `kavita kavita settings post-api-settings-test-email-url`

- Summary: Sends a test email to see if email settings are hooked up correctly
- HTTP: `POST /api/Settings/test-email-url`
- Auth: required
- Body: none
- Flags: none
- Output: response media `application/json`

## Stats

### `kavita kavita stats get-api-stats-avg-time-by-hour`

- Summary: Returns the avg time read by hour in the given filter
- HTTP: `GET /api/Stats/avg-time-by-hour`
- Auth: required
- Body: none
- Flags:
  - `--start-date` (query, date-time): StartDate
  - `--time-zone-id` (query): TimeZoneId
  - `--end-date` (query, date-time): EndDate
  - `--libraries` (query): Libraries
  - `--user-id` (query, int32): userId
- Output: list path `stats`; columns `count`, `value`; response media `application/json`

### `kavita kavita stats get-api-stats-day-breakdown`

- HTTP: `GET /api/Stats/day-breakdown`
- Auth: required
- Body: none
- Flags:
  - `--user-id` (query, default `0`, int32): userId
- Output: columns `count`, `value`; response media `application/json`

### `kavita kavita stats get-api-stats-device-client-type`

- Summary: Returns client type breakdown for the current month
- HTTP: `GET /api/Stats/device/client-type`
- Auth: required
- Body: none
- Flags: none
- Output: list path `records`; columns `count`, `value`; response media `application/json`

### `kavita kavita stats get-api-stats-device-device-type`

- Summary: Desktop vs Mobile spread over this month
- HTTP: `GET /api/Stats/device/device-type`
- Auth: required
- Body: none
- Flags: none
- Output: response media `application/json`

### `kavita kavita stats get-api-stats-favorite-authors`

- HTTP: `GET /api/Stats/favorite-authors`
- Auth: required
- Body: none
- Flags:
  - `--start-date` (query, date-time): StartDate
  - `--time-zone-id` (query): TimeZoneId
  - `--end-date` (query, date-time): EndDate
  - `--libraries` (query): Libraries
  - `--user-id` (query, int32): userId
- Output: list path `chapters`; columns `chapterId`, `libraryId`, `seriesId`, `title`; response media `application/json`

### `kavita kavita stats get-api-stats-files-added-over-time`

- HTTP: `GET /api/Stats/files-added-over-time`
- Auth: required
- Body: none
- Flags: none
- Output: columns `count`, `format`, `value`; response media `application/json`

### `kavita kavita stats get-api-stats-genre-breakdown`

- Summary: Returns the top 10 genres that the user likes reading
- HTTP: `GET /api/Stats/genre-breakdown`
- Auth: required
- Body: none
- Flags:
  - `--start-date` (query, date-time): StartDate
  - `--time-zone-id` (query): TimeZoneId
  - `--end-date` (query, date-time): EndDate
  - `--libraries` (query): Libraries
  - `--user-id` (query, int32): userId
- Output: list path `data`; columns `count`, `value`; response media `application/json`

### `kavita kavita stats get-api-stats-most-active-users`

- Summary: Top 5 most active readers for the given timeframe
- HTTP: `GET /api/Stats/most-active-users`
- Auth: required
- Body: none
- Flags:
  - `--start-date` (query, date-time): StartDate
  - `--time-zone-id` (query): TimeZoneId
  - `--end-date` (query, date-time): EndDate
  - `--libraries` (query): Libraries
- Output: columns `booksTime`, `comicsTime`, `mangaTime`, `userId`, `username`; response media `application/json`

### `kavita kavita stats get-api-stats-page-spread`

- HTTP: `GET /api/Stats/page-spread`
- Auth: required
- Body: none
- Flags:
  - `--start-date` (query, date-time): StartDate
  - `--time-zone-id` (query): TimeZoneId
  - `--end-date` (query, date-time): EndDate
  - `--libraries` (query): Libraries
  - `--user-id` (query, int32): userId
- Output: list path `buckets`; columns `count`, `percentage`, `rangeEnd`, `rangeStart`; response media `application/json`

### `kavita kavita stats get-api-stats-pages-per-year`

- Summary: Returns a count of pages read per year for a given userId.
- HTTP: `GET /api/Stats/pages-per-year`
- Auth: required
- Body: none
- Flags:
  - `--user-id` (query, int32): userId
- Output: columns `count`, `value`; response media `application/json`

### `kavita kavita stats get-api-stats-popular-decades`

- HTTP: `GET /api/Stats/popular-decades`
- Auth: required
- Body: none
- Flags: none
- Output: columns `count`, `percentage`, `rangeEnd`, `rangeStart`; response media `application/json`

### `kavita kavita stats get-api-stats-popular-genres`

- HTTP: `GET /api/Stats/popular-genres`
- Auth: required
- Body: none
- Flags: none
- Output: columns `count`; response media `application/json`

### `kavita kavita stats get-api-stats-popular-libraries`

- HTTP: `GET /api/Stats/popular-libraries`
- Auth: required
- Body: none
- Flags: none
- Output: columns `count`; response media `application/json`

### `kavita kavita stats get-api-stats-popular-people`

- HTTP: `GET /api/Stats/popular-people`
- Auth: required
- Body: none
- Flags:
  - `--role` (query): Members:
- Output: columns `count`; response media `application/json`

### `kavita kavita stats get-api-stats-popular-reading-list`

- Summary: Gets the top 5 most popular reading lists. Counts a reading list as active if a user has read at least some
- HTTP: `GET /api/Stats/popular-reading-list`
- Auth: required
- Body: none
- Flags: none
- Output: columns `count`; response media `application/json`

### `kavita kavita stats get-api-stats-popular-series`

- HTTP: `GET /api/Stats/popular-series`
- Auth: required
- Body: none
- Flags: none
- Output: columns `count`; response media `application/json`

### `kavita kavita stats get-api-stats-popular-tags`

- HTTP: `GET /api/Stats/popular-tags`
- Auth: required
- Body: none
- Flags: none
- Output: columns `count`; response media `application/json`

### `kavita kavita stats get-api-stats-reading-activity`

- HTTP: `GET /api/Stats/reading-activity`
- Auth: required
- Body: none
- Flags:
  - `--start-date` (query, date-time): StartDate
  - `--time-zone-id` (query): TimeZoneId
  - `--end-date` (query, date-time): EndDate
  - `--libraries` (query): Libraries
  - `--user-id` (query, int32): userId
  - `--year` (query, int32): year
- Output: response media `application/json`

### `kavita kavita stats get-api-stats-reading-counts`

- Summary: Returns reading history events for a give or all users, broken up by day, and format
- HTTP: `GET /api/Stats/reading-counts`
- Auth: required
- Body: none
- Flags:
  - `--start-date` (query, date-time): StartDate
  - `--time-zone-id` (query): TimeZoneId
  - `--end-date` (query, date-time): EndDate
  - `--libraries` (query): Libraries
  - `--user-id` (query, int32): If 0, defaults to all users, else just userId
- Output: columns `count`, `format`, `value`; response media `application/json`

### `kavita kavita stats get-api-stats-reading-history`

- Summary: Return a user's reading session history
- HTTP: `GET /api/Stats/reading-history`
- Auth: required
- Body: none
- Flags:
  - `--start-date` (query, date-time): StartDate
  - `--time-zone-id` (query): TimeZoneId
  - `--end-date` (query, date-time): EndDate
  - `--libraries` (query): Libraries
  - `--page-number` (query, int32): PageNumber
  - `--page-size` (query, int32): PageSize
- Output: columns `durationSeconds`, `endTimeUtc`, `isGeneratedSession`, `libraryId`, `libraryName`, `localDate`; response media `application/json`

### `kavita kavita stats get-api-stats-reading-history-series-series-id`

- Summary: Return the authenticated users reading session history for a given series
- HTTP: `GET /api/Stats/reading-history/series/{seriesId}`
- Auth: required
- Body: none
- Flags:
  - `--series-id` (path, required, int32): seriesId
  - `--tz-id` (query): tzId
  - `--page-number` (query, int32): PageNumber
  - `--page-size` (query, int32): PageSize
- Output: columns `durationSeconds`, `endTimeUtc`, `isGeneratedSession`, `libraryId`, `libraryName`, `localDate`; response media `application/json`

### `kavita kavita stats get-api-stats-reading-pace`

- HTTP: `GET /api/Stats/reading-pace`
- Auth: required
- Body: none
- Flags:
  - `--start-date` (query, date-time): StartDate
  - `--time-zone-id` (query): TimeZoneId
  - `--end-date` (query, date-time): EndDate
  - `--libraries` (query): Libraries
  - `--user-id` (query, int32): userId
  - `--year` (query, int32): year
  - `--books-only` (query): This API only returns for Books (epub/pdf) and Comics (Image/Archive) regardless of Library type
- Output: response media `application/json`

### `kavita kavita stats get-api-stats-reads-by-month`

- HTTP: `GET /api/Stats/reads-by-month`
- Auth: required
- Body: none
- Flags:
  - `--start-date` (query, date-time): StartDate
  - `--time-zone-id` (query): TimeZoneId
  - `--end-date` (query, date-time): EndDate
  - `--libraries` (query): Libraries
  - `--user-id` (query, int32): userId
- Output: columns `count`; response media `application/json`

### `kavita kavita stats get-api-stats-server-count-manga-format`

- HTTP: `GET /api/Stats/server/count/manga-format`
- Auth: required
- Body: none
- Flags: none
- Output: columns `count`, `value`; response media `application/json`

### `kavita kavita stats get-api-stats-server-count-publication-status`

- HTTP: `GET /api/Stats/server/count/publication-status`
- Auth: required
- Body: none
- Flags: none
- Output: columns `count`, `value`; response media `application/json`

### `kavita kavita stats get-api-stats-server-file-breakdown`

- Summary: A breakdown of different files, their size, and format
- HTTP: `GET /api/Stats/server/file-breakdown`
- Auth: required
- Body: none
- Flags: none
- Output: columns `totalFileSize`; response media `application/json`

### `kavita kavita stats get-api-stats-server-file-extension`

- Summary: Generates a csv of all file paths for a given extension
- HTTP: `GET /api/Stats/server/file-extension`
- Auth: required
- Body: none
- Flags:
  - `--file-extension` (query): fileExtension

### `kavita kavita stats get-api-stats-server-stats`

- HTTP: `GET /api/Stats/server/stats`
- Auth: required
- Body: none
- Flags: none
- Output: response media `application/json`

### `kavita kavita stats get-api-stats-tag-breakdown`

- Summary: Returns top 10 tags that user likes reading
- HTTP: `GET /api/Stats/tag-breakdown`
- Auth: required
- Body: none
- Flags:
  - `--start-date` (query, date-time): StartDate
  - `--time-zone-id` (query): TimeZoneId
  - `--end-date` (query, date-time): EndDate
  - `--libraries` (query): Libraries
  - `--user-id` (query, int32): userId
- Output: list path `data`; columns `count`, `value`; response media `application/json`

### `kavita kavita stats get-api-stats-total-reads`

- Summary: Returns the total amount reads in the given filter
- HTTP: `GET /api/Stats/total-reads`
- Auth: required
- Body: none
- Flags:
  - `--user-id` (query, int32): userId
- Output: response media `application/json`

### `kavita kavita stats get-api-stats-user-read`

- HTTP: `GET /api/Stats/user-read`
- Auth: required
- Body: none
- Flags:
  - `--user-id` (query, int32): userId
- Output: response media `application/json`

### `kavita kavita stats get-api-stats-user-stats`

- HTTP: `GET /api/Stats/user-stats`
- Auth: required
- Body: none
- Flags:
  - `--start-date` (query, date-time): StartDate
  - `--time-zone-id` (query): TimeZoneId
  - `--end-date` (query, date-time): EndDate
  - `--libraries` (query): Libraries
  - `--user-id` (query, int32): userId
- Output: response media `application/json`

### `kavita kavita stats get-api-stats-word-spread`

- HTTP: `GET /api/Stats/word-spread`
- Auth: required
- Body: none
- Flags:
  - `--start-date` (query, date-time): StartDate
  - `--time-zone-id` (query): TimeZoneId
  - `--end-date` (query, date-time): EndDate
  - `--libraries` (query): Libraries
  - `--user-id` (query, int32): userId
- Output: list path `buckets`; columns `count`, `percentage`, `rangeEnd`, `rangeStart`; response media `application/json`

### `kavita kavita stats get-api-stats-words-per-year`

- Summary: Returns a count of words read per year for a given userId.
- HTTP: `GET /api/Stats/words-per-year`
- Auth: required
- Body: none
- Flags:
  - `--user-id` (query, int32): userId
- Output: columns `count`, `value`; response media `application/json`

## Stream

### `kavita kavita stream delete-api-stream-delete-external-source`

- Summary: Delete's the external source
- HTTP: `DELETE /api/Stream/delete-external-source`
- Auth: required
- Body: none
- Flags:
  - `--external-source-id` (query, int32): externalSourceId

### `kavita kavita stream delete-api-stream-smart-filter-dashboard-stream`

- Summary: Removes a Smart Filter from a user's Dashboard Streams
- HTTP: `DELETE /api/Stream/smart-filter-dashboard-stream`
- Auth: required
- Body: none
- Flags:
  - `--dashboard-stream-id` (query, int32): dashboardStreamId

### `kavita kavita stream delete-api-stream-smart-filter-side-nav-stream`

- Summary: Removes a Smart Filter from a user's SideNav Streams
- HTTP: `DELETE /api/Stream/smart-filter-side-nav-stream`
- Auth: required
- Body: none
- Flags:
  - `--side-nav-stream-id` (query, int32): sideNavStreamId

### `kavita kavita stream get-api-stream-dashboard`

- Summary: Returns the layout of the user's dashboard
- HTTP: `GET /api/Stream/dashboard`
- Auth: required
- Body: none
- Flags:
  - `--visible-only` (query, default `true`): visibleOnly
- Output: columns `name`, `id`, `entityType`, `isProvided`, `order`, `smartFilterEncoded`; response media `application/json`

### `kavita kavita stream get-api-stream-external-sources`

- Summary: Return's the user's external sources
- HTTP: `GET /api/Stream/external-sources`
- Auth: required
- Body: none
- Flags: none
- Output: columns `name`, `id`, `apiKey`, `host`; response media `application/json`

### `kavita kavita stream get-api-stream-sidenav`

- Summary: Return's the user's side nav
- HTTP: `GET /api/Stream/sidenav`
- Auth: required
- Body: none
- Flags:
  - `--visible-only` (query, default `true`): visibleOnly
- Output: columns `name`, `id`, `entityType`, `externalSourceId`, `isProvided`, `libraryId`; response media `application/json`

### `kavita kavita stream post-api-stream-add-dashboard-stream`

- Summary: Creates a Dashboard Stream from a SmartFilter and adds it to the user's dashboard as visible
- HTTP: `POST /api/Stream/add-dashboard-stream`
- Auth: required
- Body: none
- Flags:
  - `--smart-filter-id` (query, int32): smartFilterId
- Output: response media `application/json`

### `kavita kavita stream post-api-stream-add-sidenav-stream`

- Summary: Creates a SideNav Stream from a SmartFilter and adds it to the user's sidenav as visible
- HTTP: `POST /api/Stream/add-sidenav-stream`
- Auth: required
- Body: none
- Flags:
  - `--smart-filter-id` (query, int32): smartFilterId
- Output: response media `application/json`

### `kavita kavita stream post-api-stream-add-sidenav-stream-from-external-source`

- Summary: Creates a SideNav Stream from a SmartFilter and adds it to the user's sidenav as visible
- HTTP: `POST /api/Stream/add-sidenav-stream-from-external-source`
- Auth: required
- Body: none
- Flags:
  - `--external-source-id` (query, int32): externalSourceId
- Output: response media `application/json`

### `kavita kavita stream post-api-stream-bulk-sidenav-stream-visibility`

- HTTP: `POST /api/Stream/bulk-sidenav-stream-visibility`
- Auth: required
- Body: optional; media type `application/json`
- Flags: none

### `kavita kavita stream post-api-stream-create-external-source`

- Summary: Create an external Source
- HTTP: `POST /api/Stream/create-external-source`
- Auth: required
- Body: optional; media type `application/json`
- Flags: none
- Output: response media `application/json`

### `kavita kavita stream post-api-stream-external-source-exists`

- Summary: Validates the external source by host is unique (for this user)
- HTTP: `POST /api/Stream/external-source-exists`
- Auth: required
- Body: optional; media type `application/json`
- Flags: none
- Output: response media `application/json`

### `kavita kavita stream post-api-stream-update-dashboard-position`

- Summary: Updates the position of a dashboard stream
- HTTP: `POST /api/Stream/update-dashboard-position`
- Auth: required
- Body: optional; media type `application/json`
- Flags: none

### `kavita kavita stream post-api-stream-update-dashboard-stream`

- Summary: Updates the visibility of a dashboard stream
- HTTP: `POST /api/Stream/update-dashboard-stream`
- Auth: required
- Body: optional; media type `application/json`
- Flags: none

### `kavita kavita stream post-api-stream-update-external-source`

- Summary: Updates an existing external source
- HTTP: `POST /api/Stream/update-external-source`
- Auth: required
- Body: optional; media type `application/json`
- Flags: none
- Output: response media `application/json`

### `kavita kavita stream post-api-stream-update-sidenav-position`

- Summary: Updates the position of a dashboard stream
- HTTP: `POST /api/Stream/update-sidenav-position`
- Auth: required
- Body: optional; media type `application/json`
- Flags: none

### `kavita kavita stream post-api-stream-update-sidenav-stream`

- Summary: Updates the visibility of a dashboard stream
- HTTP: `POST /api/Stream/update-sidenav-stream`
- Auth: required
- Body: optional; media type `application/json`
- Flags: none

## Tachiyomi

### `kavita kavita tachiyomi get-api-tachiyomi-latest-chapter`

- Summary: Given the series Id, this should return the latest chapter that has been fully read.
- HTTP: `GET /api/Tachiyomi/latest-chapter`
- Auth: required
- Body: none
- Flags:
  - `--series-id` (query, int32): seriesId
- Output: list path `characters`; columns `name`, `id`, `aniListId`, `asin`, `coverImage`, `coverImageLocked`; response media `application/json`

### `kavita kavita tachiyomi post-api-tachiyomi-mark-chapter-until-as-read`

- Summary: Marks every chapter that is sorted below the passed number as Read. This will not mark any specials as read.
- HTTP: `POST /api/Tachiyomi/mark-chapter-until-as-read`
- Auth: required
- Body: none
- Flags:
  - `--series-id` (query, int32): seriesId
  - `--chapter-number` (query, float): chapterNumber
  - `--generate-reading-sessions` (query, default `true`): generateReadingSessions
- Output: response media `application/json`

## Theme

### `kavita kavita theme delete-api-theme`

- Summary: Attempts to delete a theme. If already in use by users, will not allow
- HTTP: `DELETE /api/Theme`
- Auth: required
- Body: none
- Flags:
  - `--theme-id` (query, int32): themeId
- Output: columns `name`, `alreadyDownloaded`, `author`, `cssFile`, `cssUrl`, `description`; response media `application/json`

### `kavita kavita theme get-api-theme`

- HTTP: `GET /api/Theme`
- Auth: required
- Body: none
- Flags: none
- Output: columns `name`, `id`, `author`, `compatibleVersion`, `description`, `fileName`; response media `application/json`

### `kavita kavita theme get-api-theme-browse`

- Summary: Browse themes that can be used on this server
- HTTP: `GET /api/Theme/browse`
- Auth: required
- Body: none
- Flags: none
- Output: columns `name`, `alreadyDownloaded`, `author`, `cssFile`, `cssUrl`, `description`; response media `application/json`

### `kavita kavita theme get-api-theme-download-content`

- Summary: Returns css content to the UI. UI is expected to escape the content
- HTTP: `GET /api/Theme/download-content`
- Auth: required
- Body: none
- Flags:
  - `--theme-id` (query, int32): themeId
- Output: response media `application/json`

### `kavita kavita theme post-api-theme-download-theme`

- Summary: Downloads a SiteTheme from upstream
- HTTP: `POST /api/Theme/download-theme`
- Auth: required
- Body: optional; media type `application/json`
- Flags: none
- Output: list path `previewUrls`; response media `application/json`

### `kavita kavita theme post-api-theme-update-default`

- HTTP: `POST /api/Theme/update-default`
- Auth: required
- Body: optional; media type `application/json`
- Flags: none

### `kavita kavita theme post-api-theme-upload-theme`

- Summary: Uploads a new theme file
- HTTP: `POST /api/Theme/upload-theme`
- Auth: required
- Body: optional; media type `multipart/form-data`
- Flags: none
- Output: list path `previewUrls`; response media `application/json`

## Upload

### `kavita kavita upload post-api-upload-chapter`

- Summary: Replaces chapter cover image and locks it with a base64 encoded image. This will update the parent volume's cover image.
- HTTP: `POST /api/Upload/chapter`
- Auth: required
- Body: optional; media type `application/json`
- Flags: none

### `kavita kavita upload post-api-upload-collection`

- Summary: Replaces collection tag cover image and locks it with a base64 encoded image
- HTTP: `POST /api/Upload/collection`
- Auth: required
- Body: optional; media type `application/json`
- Flags: none

### `kavita kavita upload post-api-upload-library`

- Summary: Replaces library cover image with a base64 encoded image. If empty string passed, will reset to null.
- HTTP: `POST /api/Upload/library`
- Auth: required
- Body: optional; media type `application/json`
- Flags: none

### `kavita kavita upload post-api-upload-person`

- Summary: Replaces person tag cover image and locks it with a base64 encoded image
- HTTP: `POST /api/Upload/person`
- Auth: required
- Body: optional; media type `application/json`
- Flags: none

### `kavita kavita upload post-api-upload-reading-list`

- Summary: Replaces reading list cover image and locks it with a base64 encoded image
- HTTP: `POST /api/Upload/reading-list`
- Auth: required
- Body: optional; media type `application/json`
- Flags: none

### `kavita kavita upload post-api-upload-series`

- Summary: Replaces series cover image and locks it with a base64 encoded image
- HTTP: `POST /api/Upload/series`
- Auth: required
- Body: optional; media type `application/json`
- Flags: none

### `kavita kavita upload post-api-upload-upload-by-file`

- Summary: Stages an uploaded image file in the temp directory for use in a cover image replacement flow.
- HTTP: `POST /api/Upload/upload-by-file`
- Auth: required
- Body: optional; media type `multipart/form-data`
- Flags: none
- Output: response media `application/json`

### `kavita kavita upload post-api-upload-upload-by-url`

- Summary: This stores a file (image) in temp directory for use in a cover image replacement flow.
- HTTP: `POST /api/Upload/upload-by-url`
- Auth: required
- Body: optional; media type `application/json`
- Flags: none
- Output: response media `application/json`

### `kavita kavita upload post-api-upload-user`

- Summary: Replaces user cover image and locks it with a base64 encoded image
- HTTP: `POST /api/Upload/user`
- Auth: required
- Body: optional; media type `application/json`
- Flags: none

### `kavita kavita upload post-api-upload-volume`

- Summary: Replaces volume cover image and locks it with a base64 encoded image.
- HTTP: `POST /api/Upload/volume`
- Auth: required
- Body: optional; media type `application/json`
- Flags: none

## Users

### `kavita kavita users delete-api-users-delete-user`

- HTTP: `DELETE /api/Users/delete-user`
- Auth: required
- Body: none
- Flags:
  - `--username` (query): username

### `kavita kavita users get-api-users`

- Summary: Returns all users of this server
- HTTP: `GET /api/Users`
- Auth: required
- Body: none
- Flags:
  - `--include-pending` (query, default `false`): This will include pending members
- Output: columns `id`, `created`, `createdUtc`, `email`, `identityProvider`, `isPending`; response media `application/json`

### `kavita kavita users get-api-users-get-preferences`

- Summary: Returns the preferences of the user
- HTTP: `GET /api/Users/get-preferences`
- Auth: required
- Body: none
- Flags: none
- Output: list path `bookReaderHighlightSlots`; columns `id`, `slotNumber`; response media `application/json`

### `kavita kavita users get-api-users-has-library-access`

- Summary: Does the user have access to this library
- HTTP: `GET /api/Users/has-library-access`
- Auth: required
- Body: none
- Flags:
  - `--library-id` (query, int32): libraryId
- Output: response media `application/json`

### `kavita kavita users get-api-users-has-profile-shared`

- Summary: Does the requested user have their profile sharing on
- HTTP: `GET /api/Users/has-profile-shared`
- Auth: required
- Body: none
- Flags:
  - `--user-id` (query, int32): userId
- Output: response media `application/json`

### `kavita kavita users get-api-users-has-reading-progress`

- Summary: Is there any reading progress on this library
- HTTP: `GET /api/Users/has-reading-progress`
- Auth: required
- Body: none
- Flags:
  - `--library-id` (query, int32): libraryId
- Output: response media `application/json`

### `kavita kavita users get-api-users-names`

- Summary: Returns a list of the user names within the system
- HTTP: `GET /api/Users/names`
- Auth: required
- Body: none
- Flags: none
- Output: response media `application/json`

### `kavita kavita users get-api-users-profile-info`

- Summary: Get Information about a given user
- HTTP: `GET /api/Users/profile-info`
- Auth: required
- Body: none
- Flags:
  - `--user-id` (query, int32): userId
- Output: response media `application/json`

### `kavita kavita users get-api-users-tokens`

- Summary: Returns all users with tokens registered and their token information. Does not send the tokens.
- HTTP: `GET /api/Users/tokens`
- Auth: required
- Body: none
- Flags: none
- Output: columns `userId`, `username`; response media `application/json`

### `kavita kavita users post-api-users-update-preferences`

- Summary: Update the user preferences
- HTTP: `POST /api/Users/update-preferences`
- Auth: required
- Body: optional; media type `application/json`
- Flags: none
- Output: list path `bookReaderHighlightSlots`; columns `id`, `slotNumber`; response media `application/json`

## Volume

### `kavita kavita volume delete-api-volume`

- Summary: Delete the Volume from the DB
- HTTP: `DELETE /api/Volume`
- Auth: required
- Body: none
- Flags:
  - `--volume-id` (query, int32): volumeId
- Output: response media `application/json`

### `kavita kavita volume get-api-volume`

- Summary: Returns the appropriate Volume
- HTTP: `GET /api/Volume`
- Auth: required
- Body: none
- Flags:
  - `--volume-id` (query, int32): volumeId
- Output: list path `chapters`; columns `id`, `ageRating`, `ageRatingLocked`, `aniListId`, `avgHoursToRead`, `cbrId`; response media `application/json`

### `kavita kavita volume post-api-volume-multiple`

- Summary: Delete multiple Volumes from the DB
- HTTP: `POST /api/Volume/multiple`
- Auth: required
- Body: optional; media type `application/json`
- Flags: none
- Output: response media `application/json`

### `kavita kavita volume post-api-volume-update`

- Summary: Updates the information on the Volume
- HTTP: `POST /api/Volume/update`
- Auth: required
- Body: optional; media type `application/json`
- Flags: none
- Output: list path `chapters`; columns `id`, `ageRating`, `ageRatingLocked`, `aniListId`, `avgHoursToRead`, `cbrId`; response media `application/json`

## WantToRead

### `kavita kavita wanttoread get-api-want-to-read`

- HTTP: `GET /api/want-to-read`
- Auth: required
- Body: none
- Flags:
  - `--series-id` (query, int32): seriesId
- Output: response media `application/json`

### `kavita kavita wanttoread post-api-want-to-read-add-series`

- Summary: Given a list of Series Ids, add them to the current logged in user's Want To Read list
- HTTP: `POST /api/want-to-read/add-series`
- Auth: required
- Body: optional; media type `application/json`
- Flags: none

### `kavita kavita wanttoread post-api-want-to-read-remove-series`

- Summary: Given a list of Series Ids, remove them from the current logged in user's Want To Read list
- HTTP: `POST /api/want-to-read/remove-series`
- Auth: required
- Body: optional; media type `application/json`
- Flags: none

### `kavita kavita wanttoread post-api-want-to-read-v2`

- Summary: Return all Series that are in the current logged in user's Want to Read list, filtered
- HTTP: `POST /api/want-to-read/v2`
- Auth: required
- Body: optional; media type `application/json`
- Flags:
  - `--page-number` (query, int32): PageNumber
  - `--page-size` (query, int32): PageSize
  - `--user-id` (query, int32): Optional user id to request the OnDeck for someone else. They must have profile sharing enabled when doing so
- Output: columns `name`, `id`, `aniListId`, `avgHoursToRead`, `cbrId`, `comicVineId`; response media `application/json`