{
    "openapi": "3.0.2",
    "info": {
        "title": "TachiWeb-Api",
        "version": "3.2.8",
        "description": "**Security:**\n\nAuthentication is currently not supported. Clients should use the *No Security* option until authentication is implemented.",
        "contact": {
            "url": "https://github.com/TachiWeb/TachiWeb-Server"
        },
        "license": {
            "name": "Apache 2.0",
            "url": "https://www.apache.org/licenses/LICENSE-2.0"
        }
    },
    "servers": [
        {
            "url": "{protocol}://{host}:{port}",
            "description": "",
            "variables": {
                "protocol": {
                    "default": "http",
                    "description": ""
                },
                "host": {
                    "default": "localhost"
                },
                "port": {
                    "default": "4567"
                }
            }
        }
    ],
    "paths": {
        "/api/v3/manga": {
            "summary": "Path used to manage the list of manga.",
            "description": "The REST endpoint/path used to list `manga` entities.  This path contains a `GET` operation to perform the list task.",
            "get": {
                "responses": {
                    "200": {
                        "content": {
                            "application/json": {
                                "schema": {
                                    "type": "array",
                                    "items": {
                                        "$ref": "#/components/schemas/manga"
                                    }
                                }
                            }
                        },
                        "description": "Successful response - returns an array of `manga` entities."
                    }
                },
                "operationId": "getMangas",
                "summary": "List all manga",
                "description": "Gets a list of all `manga` entities.\n\nThis operation can be slow and return large amounts of data.\nIt is recommended to be used sparingly."
            }
        },
        "/api/v3/manga/{mangaId}": {
            "summary": "Path used to get and update a single manga.",
            "description": "The REST endpoint/path used to get and update single instances of a `manga`.  This path contains `GET` and `PATCH` operations used to perform the get and update tasks respectively.",
            "get": {
                "responses": {
                    "200": {
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/manga"
                                }
                            }
                        },
                        "description": "Successful response - returns a single `manga`."
                    },
                    "404": {
                        "description": "The manga could not be found."
                    }
                },
                "operationId": "getManga",
                "summary": "Get a manga",
                "description": "Gets the details of a single instance of a `manga`."
            },
            "parameters": [
                {
                    "name": "mangaId",
                    "description": "The `manga`'s `id`.",
                    "schema": {
                        "format": "int64",
                        "type": "integer"
                    },
                    "in": "path",
                    "required": true
                }
            ]
        },
        "/api/v3/manga/{mangaId}/cover": {
            "summary": "Get the cover/thumbnail of a manga.",
            "get": {
                "parameters": [
                    {
                        "name": "use-placeholder",
                        "description": "If the manga with the supplied `mangaId` exists but has no cover, supply a placeholder image in place of the `404 Not Found` response.\n\nIf the manga does not exist, a `404 Not Found` response will still be returned.\n\nDefaults to: `false`",
                        "schema": {
                            "type": "boolean"
                        },
                        "in": "query"
                    }
                ],
                "responses": {
                    "200": {
                        "content": {
                            "image/jpeg": {

                            },
                            "image/png": {

                            },
                            "image/webp": {

                            }
                        },
                        "description": "The manga has a cover and it has been returned."
                    },
                    "404": {
                        "content": {
                            "application/json": {
                                "schema": {
                                    "enum": [
                                        "NO_MANGA",
                                        "NO_COVER"
                                    ]
                                }
                            }
                        },
                        "description": "The manga with the supplied `mangaId` does not exist or has no cover.\n\nThe reason for the failure is supplied in the response body."
                    },
                    "500": {
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/error"
                                }
                            }
                        },
                        "description": "An error occured while loading the cover.\n\nThe exact failure reason is provided in the response body."
                    }
                },
                "operationId": "getMangaCover",
                "summary": "Get a manga's cover/thumbnail."
            },
            "parameters": [
                {
                    "name": "mangaId",
                    "description": "The `manga`'s `id`.",
                    "schema": {
                        "format": "int64",
                        "type": "integer"
                    },
                    "in": "path",
                    "required": true
                }
            ]
        },
        "/api/v3/manga/{mangaId}/flags": {
            "summary": "Path used to manage a single manga's flags.",
            "description": "",
            "get": {
                "responses": {
                    "200": {
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/manga-flags"
                                }
                            }
                        },
                        "description": "Successful response - returns a single manga's flags."
                    },
                    "404": {
                        "description": "No manga with the supplied `mangaId` exists."
                    }
                },
                "operationId": "getMangaFlags",
                "summary": "Get a manga's flags",
                "description": "Gets the details of a single instance of a manga's flags."
            },
            "put": {
                "requestBody": {
                    "description": "The new flags to replace the existing flags with.",
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/manga-flags"
                            }
                        }
                    },
                    "required": true
                },
                "responses": {
                    "200": {
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/manga-flags"
                                }
                            }
                        },
                        "description": "Successful response. Returns the new manga flags."
                    },
                    "404": {
                        "description": "No manga with the supplied `mangaId` exists."
                    }
                },
                "operationId": "setMangaFlags",
                "summary": "Replace all of a manga's flags",
                "description": "Replaces all a manga's flags with the supplied flags."
            },
            "parameters": [
                {
                    "name": "mangaId",
                    "description": "The `manga`'s `id`.",
                    "schema": {
                        "format": "int64",
                        "type": "integer"
                    },
                    "in": "path",
                    "required": true
                }
            ]
        },
        "/api/v3/manga/{mangaId}/favorite": {
            "summary": "Path used to manage a single manga's favorite status.",
            "description": "",
            "put": {
                "requestBody": {
                    "description": "The new favorite status of the manga.",
                    "content": {
                        "application/json": {
                            "schema": {
                                "type": "boolean"
                            }
                        }
                    },
                    "required": true
                },
                "responses": {
                    "200": {
                        "content": {
                            "application/json": {
                                "schema": {
                                    "type": "boolean"
                                }
                            }
                        },
                        "description": "Successful response.\n\nThe new favorite status of the manga is returned."
                    },
                    "404": {
                        "description": "No manga with the supplied `mangaId` exists."
                    }
                },
                "operationId": "setMangaFavorited",
                "summary": "Set a manga's favorite status.",
                "description": ""
            },
            "parameters": [
                {
                    "name": "mangaId",
                    "description": "The `manga`'s `id`.",
                    "schema": {
                        "format": "int64",
                        "type": "integer"
                    },
                    "in": "path",
                    "required": true
                }
            ]
        },
        "/api/v3/manga/{mangaId}/viewer": {
            "summary": "Path used to manage a single manga's viewer.",
            "description": "",
            "put": {
                "requestBody": {
                    "description": "The new manga viewer.",
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/manga-viewer"
                            }
                        }
                    },
                    "required": true
                },
                "responses": {
                    "200": {
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/manga-viewer"
                                }
                            }
                        },
                        "description": "Successful response.\n\nThe new viewer of the manga is returned."
                    },
                    "404": {
                        "description": "No manga with the supplied `mangaId` exists."
                    }
                },
                "operationId": "setMangaViewer",
                "summary": "Set a manga's viewer.",
                "description": ""
            },
            "parameters": [
                {
                    "name": "mangaId",
                    "description": "The `manga`'s `id`.",
                    "schema": {
                        "format": "int64",
                        "type": "integer"
                    },
                    "in": "path",
                    "required": true
                }
            ]
        },
        "/api/v3/categories": {
            "summary": "Path used to manage the list of categories.",
            "description": "",
            "get": {
                "responses": {
                    "200": {
                        "content": {
                            "application/json": {
                                "schema": {
                                    "type": "array",
                                    "items": {
                                        "$ref": "#/components/schemas/category"
                                    }
                                }
                            }
                        },
                        "description": "Successful response - returns an array of `category` entities."
                    }
                },
                "operationId": "getCategories",
                "summary": "List all categories",
                "description": "Gets a list of all `category` entities sorted ascending by the `order` field."
            },
            "post": {
                "requestBody": {
                    "description": "A new `category` to be created.",
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/mutate-category-request"
                            }
                        }
                    },
                    "required": true
                },
                "responses": {
                    "200": {
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/category"
                                }
                            }
                        },
                        "description": "Successful response.\n\nThe newly created category is returned."
                    },
                    "409": {
                        "content": {
                            "application/json": {
                                "schema": {
                                    "enum": [
                                        "NAME_CONFLICT",
                                        "ORDER_CONFLICT"
                                    ]
                                }
                            }
                        },
                        "description": "Category creation failed due to a conflict.\n\nThe exact reason for the failure is supplied in the response body."
                    }
                },
                "operationId": "createCategory",
                "summary": "Create a category",
                "description": "Creates a new instance of a `category`."
            }
        },
        "/api/v3/categories/{categoryId}": {
            "summary": "Path used to manage a single category.",
            "description": "The REST endpoint/path used to get, update, and delete single instances of an `category`.  This path contains `GET`, `PUT`, and `DELETE` operations used to perform the get, update, and delete tasks, respectively.",
            "get": {
                "responses": {
                    "200": {
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/category"
                                }
                            }
                        },
                        "description": "Successful response - returns a single `category`."
                    },
                    "404": {
                        "description": "No category with the supplied `id` could be found."
                    }
                },
                "operationId": "getCategory",
                "summary": "Get a category",
                "description": "Gets the details of a single instance of a `category`."
            },
            "put": {
                "requestBody": {
                    "description": "Updated `category` information.",
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/mutate-category-request"
                            }
                        }
                    },
                    "required": true
                },
                "responses": {
                    "200": {
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/category"
                                }
                            }
                        },
                        "description": "Successful response.\n\nThe updated category is returned."
                    },
                    "404": {
                        "description": "No category with the supplied `id` could be found."
                    },
                    "409": {
                        "content": {
                            "application/json": {
                                "schema": {
                                    "enum": [
                                        "NAME_CONFLICT",
                                        "ORDER_CONFLICT"
                                    ],
                                    "type": "string"
                                }
                            }
                        },
                        "description": "Category edit failed due to a conflict.\n\nThe exact reason for the failure is supplied in the response body."
                    }
                },
                "operationId": "editCategory",
                "summary": "Update a category",
                "description": "Updates an existing `category`."
            },
            "delete": {
                "responses": {
                    "204": {
                        "description": "Successful response."
                    },
                    "404": {
                        "description": "No category with the supplied `id` could be found."
                    }
                },
                "operationId": "deleteCategory",
                "summary": "Delete a category",
                "description": "Deletes an existing `category`."
            },
            "parameters": [
                {
                    "name": "categoryId",
                    "description": "The category's `id`.",
                    "schema": {
                        "format": "int32",
                        "type": "integer"
                    },
                    "in": "path",
                    "required": true
                }
            ]
        },
        "/api/v3/manga/{mangaId}/chapters": {
            "summary": "Get a list of all chapter associated with this manga.",
            "get": {
                "parameters": [
                    {
                        "name": "apply-filters",
                        "description": "Whether or not to apply the filters specified in the manga flags.\n\nDefaults to: `false`",
                        "schema": {
                            "type": "boolean"
                        },
                        "in": "query",
                        "required": false
                    }
                ],
                "responses": {
                    "200": {
                        "content": {
                            "application/json": {
                                "schema": {
                                    "type": "array",
                                    "items": {
                                        "$ref": "#/components/schemas/chapter"
                                    }
                                }
                            }
                        },
                        "description": "Successful response."
                    },
                    "404": {
                        "description": "No manga with the supplied `mangaId` exists."
                    }
                },
                "operationId": "getMangaChapters",
                "summary": "Get a list of all chapter associated with this manga sorted by the manga's flags.",
                "description": ""
            },
            "parameters": [
                {
                    "name": "mangaId",
                    "description": "The `manga`'s `id`.",
                    "schema": {
                        "format": "int64",
                        "type": "integer"
                    },
                    "in": "path",
                    "required": true
                }
            ]
        },
        "/api/v3/manga/{mangaId}/update": {
            "summary": "Update a manga's info.",
            "description": "Does not update a manga's chapters.",
            "post": {
                "responses": {
                    "200": {
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/manga"
                                }
                            }
                        },
                        "description": "Metadata/info update successful.\n\nThe new manga metadata is returned."
                    },
                    "404": {
                        "description": "No manga with the supplied `mangaId` exists."
                    },
                    "500": {
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/error"
                                }
                            }
                        },
                        "description": "The metadata/info update failed.\n\nThe exact reason is supplied in the responsed body."
                    }
                },
                "operationId": "updateMangaInfo",
                "summary": "Update a manga's metadata/info.",
                "description": "It is recommended for UIs to call this when the initialized field of the manga is `false`.\n\nCalling this will update the initialized field of the manga to `true` if the request succeeds."
            },
            "parameters": [
                {
                    "name": "mangaId",
                    "description": "The `manga`'s `id`.",
                    "schema": {
                        "format": "int64",
                        "type": "integer"
                    },
                    "in": "path",
                    "required": true
                }
            ]
        },
        "/api/v3/manga/{mangaId}/chapters/update": {
            "summary": "Update a manga's chapters.",
            "description": "Does not update a manga's info.",
            "post": {
                "responses": {
                    "200": {
                        "content": {
                            "application/json": {
                                "schema": {
                                    "type": "array",
                                    "items": {
                                        "$ref": "#/components/schemas/chapter"
                                    }
                                }
                            }
                        },
                        "description": "Manga chapters update successful.\n\nThe new chapter list will be returned."
                    },
                    "404": {
                        "description": "No manga with the supplied `mangaId` exists."
                    },
                    "500": {
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/error"
                                }
                            }
                        },
                        "description": "The manga chapter update failed.\n\nThe exact reason is supplied in the responsed body."
                    }
                },
                "operationId": "updateMangaChapters",
                "summary": "Update a manga's chapters.",
                "description": "It is recommended for UIs to call this when the user transitions from the catalogue screen to the manga screen."
            },
            "parameters": [
                {
                    "name": "mangaId",
                    "description": "The `manga`'s `id`.",
                    "schema": {
                        "format": "int64",
                        "type": "integer"
                    },
                    "in": "path",
                    "required": true
                }
            ]
        },
        "/api/v3/chapters": {
            "summary": "Path used to manage chapters.",
            "get": {
                "responses": {
                    "200": {
                        "content": {
                            "application/json": {
                                "schema": {
                                    "type": "array",
                                    "items": {
                                        "$ref": "#/components/schemas/chapter"
                                    }
                                }
                            }
                        },
                        "description": "Successful response."
                    }
                },
                "operationId": "getChapters",
                "summary": "List all chapters across all manga.",
                "description": "This operation can be slow and return large amounts of data.\nIt is recommended to be used sparingly."
            }
        },
        "/api/v3/chapters/{chapterId}": {
            "summary": "Path used to manage a single chapter.",
            "get": {
                "responses": {
                    "200": {
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/chapter"
                                }
                            }
                        },
                        "description": "Successful response."
                    },
                    "404": {
                        "description": "No chapter exists with the supplied `chapterId`."
                    }
                },
                "operationId": "getChapter",
                "summary": "Get a single chapter by it's id."
            },
            "parameters": [
                {
                    "name": "chapterId",
                    "description": "The chapter id.",
                    "schema": {
                        "format": "int64",
                        "type": "integer"
                    },
                    "in": "path",
                    "required": true
                }
            ]
        },
        "/api/v3/chapters/{chapterId}/page-count": {
            "summary": "Manage a chapter's page count.",
            "post": {
                "responses": {
                    "200": {
                        "content": {
                            "application/json": {
                                "schema": {
                                    "format": "int64",
                                    "type": "integer"
                                }
                            }
                        },
                        "description": "Successful response."
                    },
                    "404": {
                        "description": "No chapter exists with the supplied `chapterId`."
                    },
                    "500": {
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/error"
                                }
                            }
                        },
                        "description": "Failed to calculate the number of pages in the chapter.\n\nThe exact reason is supplied in the responsed body."
                    }
                },
                "operationId": "getChapterPageCount",
                "summary": "Get a chapter's page count.",
                "description": "This is POST request for technical reasons."
            },
            "parameters": [
                {
                    "name": "chapterId",
                    "description": "The chapter id.",
                    "schema": {
                        "format": "int64",
                        "type": "integer"
                    },
                    "in": "path",
                    "required": true
                }
            ]
        },
        "/api/v3/chapters/{chapterId}/reading-status": {
            "summary": "Updates the time this chapter was last read",
            "get": {
                "responses": {
                    "200": {
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/chapter-reading-status"
                                }
                            }
                        },
                        "description": "Successful response."
                    },
                    "404": {
                        "description": "No chapter exists with the supplied `chapterId`."
                    }
                },
                "operationId": "getChapterReadingStatus",
                "summary": "Get the reading status of a chapter."
            },
            "put": {
                "requestBody": {
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/chapter-reading-status"
                            }
                        }
                    },
                    "required": true
                },
                "responses": {
                    "200": {
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/chapter-reading-status"
                                }
                            }
                        },
                        "description": "Successful response.\n\nThe new reading status of the chapter is returned."
                    },
                    "404": {
                        "description": "No chapter exists with the supplied `chapterId`."
                    }
                },
                "operationId": "setChapterReadingStatus",
                "summary": "Replace the reading status of a chapter.",
                "description": "Will also update the tracking information associated with this manga."
            },
            "parameters": [
                {
                    "name": "chapterId",
                    "description": "The chapter id.",
                    "schema": {
                        "format": "int64",
                        "type": "integer"
                    },
                    "in": "path",
                    "required": true
                }
            ]
        },
        "/api/v3/chapters/{chapterId}/download": {
            "summary": "Path used to manage the download associated with this chapter",
            "get": {
                "responses": {
                    "200": {
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/download"
                                }
                            }
                        },
                        "description": "Success response."
                    },
                    "404": {
                        "content": {
                            "application/json": {
                                "schema": {
                                    "enum": [
                                        "NO_CHAPTER",
                                        "NO_DOWNLOAD"
                                    ]
                                }
                            }
                        },
                        "description": "No chapter exists with the supplied `chapterId` or this chapter is not associated with a download.\n\nThe specific error is supplied in the response body."
                    }
                },
                "operationId": "getChapterDownload",
                "summary": "Get the download associated with this chapter."
            },
            "post": {
                "responses": {
                    "200": {
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/download"
                                }
                            }
                        },
                        "description": "Success response.\n\nThe newly created download is returned."
                    },
                    "404": {
                        "description": "No chapter exists with the supplied `chapterId`."
                    },
                    "409": {
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/download"
                                }
                            }
                        },
                        "description": "Failed to begin downloading this chapter as this chapter is already associated with a download.\n\nThe associated download is supplied in the response body."
                    }
                },
                "operationId": "beginChapterDownload",
                "summary": "Begin downloading a chapter"
            },
            "delete": {
                "responses": {
                    "204": {
                        "description": "The download was successfully deleted."
                    },
                    "404": {
                        "content": {
                            "application/json": {
                                "schema": {
                                    "enum": [
                                        "NO_CHAPTER",
                                        "NO_DOWNLOAD"
                                    ]
                                }
                            }
                        },
                        "description": "No chapter exists with the supplied `chapterId` or this chapter is not associated with a download.\n\nThe specific error is supplied in the response body."
                    },
                    "423": {
                        "description": "Could not delete the download as the status of the download is not: `DOWNLOADED`."
                    }
                },
                "operationId": "deleteChapterDownload",
                "summary": "Delete the download associated with this chapter.",
                "description": "Note that only fully downloaded downloads can be deleted."
            },
            "parameters": [
                {
                    "name": "chapterId",
                    "description": "The chapter id.",
                    "schema": {
                        "format": "int64",
                        "type": "integer"
                    },
                    "in": "path",
                    "required": true
                }
            ]
        },
        "/api/v3/downloader": {
            "summary": "Path to manage the chapter downloader.",
            "get": {
                "responses": {
                    "200": {
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/downloader"
                                }
                            }
                        },
                        "description": "Success response."
                    }
                },
                "operationId": "getDownloader",
                "summary": "Gets the chapter downloader.",
                "description": ""
            }
        },
        "/api/v3/downloader/paused": {
            "summary": "Path to manage the pause state of the chapter downloader.",
            "get": {
                "responses": {
                    "200": {
                        "content": {
                            "application/json": {
                                "schema": {
                                    "type": "boolean"
                                }
                            }
                        },
                        "description": "Success response, returns whether or not the downloader is paused."
                    }
                },
                "operationId": "isDownloaderPaused",
                "summary": "Gets whether or not the downloader is paused."
            },
            "put": {
                "requestBody": {
                    "content": {
                        "application/json": {
                            "schema": {
                                "type": "boolean"
                            }
                        }
                    },
                    "required": true
                },
                "responses": {
                    "200": {
                        "content": {
                            "application/json": {
                                "schema": {
                                    "type": "boolean"
                                }
                            }
                        },
                        "description": "Success response. The new pause state of the downloader is returned."
                    }
                },
                "operationId": "setDownloaderPaused",
                "summary": "Updates the pause state of the downloader."
            }
        },
        "/api/v3/downloader/clear": {
            "summary": "Path used to clear the downloader's queue.",
            "post": {
                "responses": {
                    "200": {
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/downloader"
                                }
                            }
                        },
                        "description": "Success response, the new downloader is returned."
                    }
                },
                "operationId": "clearDownloader",
                "summary": "Clear the downloader's queue."
            }
        },
        "/api/v3/chapters/{chapterId}/page/{pageIndex}/image": {
            "summary": "Manage the image associated with a chapter page.",
            "get": {
                "responses": {
                    "200": {
                        "content": {
                            "image/jpeg": {

                            },
                            "image/png": {

                            },
                            "image/webp": {

                            },
                            "image/gif": {

                            }
                        },
                        "description": "Success response. The page's image is returned."
                    },
                    "404": {
                        "content": {
                            "application/json": {
                                "schema": {
                                    "enum": [
                                        "NO_CHAPTER",
                                        "NO_PAGE"
                                    ]
                                }
                            }
                        },
                        "description": "No chapter with the specified `chapterId` was found or no page was found at the supplied `pageIndex`.\n\nThe exact failure reason is supplied in the response body."
                    },
                    "500": {
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/error"
                                }
                            }
                        },
                        "description": "The server failed to fetch the page's image.\n\nThe exact failure reason is supplied in the response body."
                    }
                },
                "operationId": "getChapterPageImage",
                "summary": "Get the image associated with a chapter page.",
                "description": "Note that the page image may be animated."
            },
            "parameters": [
                {
                    "name": "chapterId",
                    "description": "The chapter id.",
                    "schema": {
                        "format": "int64",
                        "type": "integer"
                    },
                    "in": "path",
                    "required": true
                },
                {
                    "name": "pageIndex",
                    "description": "The index of the page (0-indexed).",
                    "schema": {
                        "format": "int64",
                        "type": "integer"
                    },
                    "in": "path",
                    "required": true
                }
            ]
        },
        "/api/v3/tasks": {
            "summary": "List all uncompleted tasks",
            "get": {
                "responses": {
                    "200": {
                        "content": {
                            "application/json": {
                                "schema": {
                                    "type": "array",
                                    "items": {
                                        "$ref": "#/components/schemas/task"
                                    }
                                }
                            }
                        },
                        "description": "Success response."
                    }
                },
                "operationId": "getTasks",
                "summary": "Get a list of all uncompleted tasks."
            }
        },
        "/api/v3/tasks/{taskUuid}": {
            "summary": "Path used to manage a single task.",
            "get": {
                "responses": {
                    "200": {
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/task"
                                }
                            }
                        },
                        "description": "Success response."
                    },
                    "404": {
                        "description": "No task exists with the supplied `taskUuid`."
                    }
                },
                "operationId": "getTask",
                "summary": "Get a task."
            },
            "parameters": [
                {
                    "name": "taskUuid",
                    "description": "The UUID of the task.",
                    "schema": {
                        "type": "string"
                    },
                    "in": "path",
                    "required": true
                }
            ]
        },
        "/api/v3/sources": {
            "summary": "Path used to manage the list of sources.",
            "description": "",
            "get": {
                "responses": {
                    "200": {
                        "content": {
                            "application/json": {
                                "schema": {
                                    "type": "array",
                                    "items": {
                                        "$ref": "#/components/schemas/source"
                                    }
                                }
                            }
                        },
                        "description": "Successful response - returns an array of `source` entities."
                    }
                },
                "operationId": "getSources",
                "summary": "List all sources.",
                "description": "Gets a list of all `source` entities."
            }
        },
        "/api/v3/sources/{sourceId}": {
            "summary": "Path used to manage a single source.",
            "description": "",
            "get": {
                "responses": {
                    "200": {
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/source"
                                }
                            }
                        },
                        "description": "Successful response - returns a single `source`."
                    },
                    "404": {
                        "description": "No source exists with the provided `id`."
                    }
                },
                "operationId": "getSource",
                "summary": "Get a source",
                "description": "Gets the details of a single instance of a `source`."
            },
            "parameters": [
                {
                    "name": "sourceId",
                    "description": "The `id` of the source.",
                    "schema": {
                        "type": "string"
                    },
                    "in": "path",
                    "required": true
                }
            ]
        },
        "/api/v3/sources/{sourceId}/login": {
            "summary": "Path used to login to a source.",
            "post": {
                "requestBody": {
                    "description": "The login credentials.",
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/login-request"
                            }
                        }
                    },
                    "required": true
                },
                "responses": {
                    "204": {
                        "description": "The login succeeded."
                    },
                    "400": {
                        "content": {
                            "application/json": {
                                "schema": {
                                    "enum": [
                                        "AUTH_UNSUPPORTED",
                                        "ALREADY_LOGGED_IN"
                                    ]
                                }
                            }
                        },
                        "description": "The source does not require authentication or the user is already logged in.\n\nThe exact failure reason is provided in the response body."
                    },
                    "401": {
                        "description": "The login failed (usually this means the credentials are invalid)."
                    },
                    "404": {
                        "description": "No source exists with the provided `id`."
                    }
                },
                "operationId": "loginToSource",
                "summary": "Login to a source.",
                "description": ""
            },
            "parameters": [
                {
                    "name": "sourceId",
                    "description": "The `id` of the source.",
                    "schema": {
                        "type": "string"
                    },
                    "in": "path",
                    "required": true
                }
            ]
        },
        "/api/v3/sources/{sourceId}/filters": {
            "summary": "Manage the filters for a source",
            "get": {
                "responses": {
                    "200": {
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/catalogue-filters"
                                }
                            }
                        },
                        "description": "Success response."
                    },
                    "404": {
                        "description": "No source exists with the provided `id`."
                    }
                },
                "operationId": "getSourceFilters",
                "summary": "Get the filters for a source."
            },
            "parameters": [
                {
                    "name": "sourceId",
                    "description": "The `id` of the source.",
                    "schema": {
                        "type": "string"
                    },
                    "in": "path",
                    "required": true
                }
            ]
        },
        "/api/v3/sources/{sourceId}/catalogue": {
            "summary": "Manage a catalogue page.",
            "post": {
                "requestBody": {
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/catalogue-page-request"
                            }
                        }
                    },
                    "required": true
                },
                "responses": {
                    "200": {
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/catalogue-page"
                                }
                            }
                        },
                        "description": "Success response."
                    },
                    "404": {
                        "description": "No source exists with the provided `id`."
                    },
                    "500": {
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/error"
                                }
                            }
                        },
                        "description": "Failed to get catalogue page.\n\nThe exact failure reason is supplied in the response body."
                    }
                },
                "operationId": "getSourceCatalogue",
                "summary": "Request a catalogue page."
            },
            "parameters": [
                {
                    "name": "sourceId",
                    "description": "The `id` of the source.",
                    "schema": {
                        "type": "string"
                    },
                    "in": "path",
                    "required": true
                }
            ]
        },
        "/api/v3/sources/{sourceId}/latest-updates": {
            "summary": "Manage a latest-updates catalogue page.",
            "post": {
                "requestBody": {
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/latest-updates-request"
                            }
                        }
                    },
                    "required": true
                },
                "responses": {
                    "200": {
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/catalogue-page"
                                }
                            }
                        },
                        "description": "Success response."
                    },
                    "404": {
                        "description": "No source exists with the provided `id`."
                    },
                    "500": {
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/error"
                                }
                            }
                        },
                        "description": "Failed to get latest-updates catalogue page.\n\nThe exact failure reason is supplied in the response body."
                    }
                },
                "operationId": "getSourceLatestUpdates",
                "summary": "Request a latest-updates catalogue page."
            },
            "parameters": [
                {
                    "name": "sourceId",
                    "description": "The `id` of the source.",
                    "schema": {
                        "type": "string"
                    },
                    "in": "path",
                    "required": true
                }
            ]
        },
        "/api/v3/preferences": {
            "summary": "Path used to manage the list of preferences.",
            "description": "",
            "get": {
                "responses": {
                    "200": {
                        "content": {
                            "application/json": {
                                "schema": {
                                    "type": "array",
                                    "items": {
                                        "$ref": "#/components/schemas/preference"
                                    }
                                }
                            }
                        },
                        "description": "Successful response - returns an array of `preference` entities."
                    }
                },
                "operationId": "getPreferences",
                "summary": "List all preferences",
                "description": "Gets a list of all `preference` entities."
            }
        },
        "/api/v3/preferences/schema": {
            "summary": "Get the preference schema (used to render preferences).",
            "get": {
                "responses": {
                    "200": {
                        "content": {
                            "application/json": {

                            }
                        },
                        "description": "Success response."
                    }
                },
                "operationId": "getPreferencesSchema",
                "summary": "Get the preference schema."
            }
        },
        "/api/v3/manga/recently-read": {
            "get": {
                "parameters": [
                    {
                        "name": "range-size-ms",
                        "description": "How far back to look (in milliseconds) while finding the recently read manga.\n\nRecommended: `2592000000` ms = 1 month",
                        "schema": {
                            "format": "int64",
                            "type": "integer"
                        },
                        "in": "query",
                        "required": true
                    }
                ],
                "responses": {
                    "200": {
                        "content": {
                            "application/json": {
                                "schema": {
                                    "type": "array",
                                    "items": {
                                        "$ref": "#/components/schemas/recently-read"
                                    }
                                }
                            }
                        },
                        "description": "Successful response - returns an array of `recently-read` entities sorted by most to least recent."
                    }
                },
                "operationId": "getRecentlyReadManga",
                "summary": "List recently read manga",
                "description": "Hardcoded to return a maximum of 25 entries. Includes the chapter that was last read in each manga."
            }
        },
        "/api/v3/chapters/{chapterId}/reading-status/last-read": {
            "summary": "Manage information on when this chapter was last read",
            "delete": {
                "responses": {
                    "200": {
                        "description": "Success response."
                    },
                    "404": {
                        "description": "No chapter exists with the supplied `chapterId`."
                    }
                },
                "operationId": "deleteChapterLastRead",
                "summary": "Deletes the information on when this chapter was last read"
            },
            "parameters": [
                {
                    "name": "chapterId",
                    "description": "The chapter id.",
                    "schema": {
                        "format": "int64",
                        "type": "integer"
                    },
                    "in": "path",
                    "required": true
                }
            ]
        },
        "/api/v3/categories/{categoryId}/manga": {
            "summary": "Path to manage a category's manga.",
            "patch": {
                "requestBody": {
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/mutate-category-manga-request"
                            }
                        }
                    },
                    "required": true
                },
                "responses": {
                    "200": {
                        "content": {
                            "application/json": {
                                "schema": {
                                    "type": "array",
                                    "items": {
                                        "format": "int64",
                                        "type": "integer"
                                    }
                                }
                            }
                        },
                        "description": "Successful response - the specified manga were added/removed from the category, returns a list of the ids of the manga in the category."
                    },
                    "400": {
                        "description": "The supplied mutation request contains a manga id that is in both the `add` list and the `remove` list."
                    },
                    "404": {
                        "content": {
                            "application/json": {
                                "schema": {
                                    "enum": [
                                        "NO_CATEGORY",
                                        "NO_MANGA"
                                    ]
                                }
                            }
                        },
                        "description": "No category with the specified `categoryId` was found or a manga `id` specified in the request body array did not have an associated manga.\n\nNo manga were added/removed from the `category`.\n\nThe exact failure reason is supplied in the response body."
                    }
                },
                "operationId": "editCategoryManga",
                "summary": "Add/remove manga from a category."
            },
            "parameters": [
                {
                    "name": "categoryId",
                    "description": "The category's `id`.",
                    "schema": {
                        "format": "int32",
                        "type": "integer"
                    },
                    "in": "path",
                    "required": true
                }
            ]
        },
        "/api/v3/extensions/{extensionPackage}": {
            "summary": "Path to manage a single extension",
            "get": {
                "responses": {
                    "200": {
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/extension"
                                }
                            }
                        },
                        "description": "Successful response."
                    },
                    "404": {
                        "description": "No extension exists with the specified `extensionPackage`."
                    }
                },
                "operationId": "getExtension",
                "summary": "Get information about a specific extension"
            },
            "delete": {
                "responses": {
                    "200": {
                        "description": "The extension was successfully deleted."
                    },
                    "404": {
                        "description": "No extension exists with the specified `extensionPackage`."
                    }
                },
                "operationId": "deleteExtension",
                "summary": "Delete an extension.",
                "description": "Extensions that are present in the central repository will not be deleted. Instead, their `status`' will be changed to `AVAILABLE`."
            },
            "parameters": [
                {
                    "name": "extensionPackage",
                    "description": "The `pkgName` of the extension.",
                    "schema": {
                        "type": "string"
                    },
                    "in": "path",
                    "required": true
                }
            ]
        },
        "/api/v3/extensions/{extensionPackage}/install": {
            "description": "",
            "post": {
                "responses": {
                    "200": {
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/extension"
                                }
                            }
                        },
                        "description": "The extension was successfully installed/updated."
                    },
                    "400": {
                        "description": "The extension's status is not `AVAILABLE` and it's `hasUpdate` field is `false`."
                    },
                    "404": {
                        "description": "No extension exists with the specified `extensionPackage`."
                    },
                    "500": {
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/error"
                                }
                            }
                        },
                        "description": "The extension could not be installed/updated.\n\nThe exact failure reason is provided in the response body."
                    }
                },
                "operationId": "installExtension",
                "summary": "Installs or updates an extension from the central repository.",
                "description": "The extension must either have a `status` of `AVAILABLE` or it's `hasUpdate` field is `true`."
            },
            "parameters": [
                {
                    "name": "extensionPackage",
                    "description": "The `pkgName` of the extension.",
                    "schema": {
                        "type": "string"
                    },
                    "in": "path",
                    "required": true
                }
            ]
        },
        "/api/v3/extensions/trust": {
            "post": {
                "requestBody": {
                    "description": "The signature hash.",
                    "content": {
                        "application/json": {
                            "schema": {
                                "type": "string"
                            }
                        }
                    },
                    "required": true
                },
                "responses": {
                    "200": {
                        "description": "Successful response. The provided signature hash is now trusted."
                    },
                    "400": {
                        "description": "The provided signature hash is invalid."
                    }
                },
                "operationId": "trustExtensionSignatureHash",
                "summary": "Trust a signature hash.",
                "description": "Multiple extensions may have the same signature hash.\n\nTrusting a signature hash will also cause future extensions that have the same signature hash to be trusted."
            }
        },
        "/api/v3/extensions/{extensionPackage}/icon": {
            "get": {
                "responses": {
                    "200": {
                        "content": {
                            "image/png": {

                            },
                            "image/webp": {

                            }
                        },
                        "description": "Successful response."
                    },
                    "404": {
                        "description": "No extension exists with the specified `extensionPackage`."
                    }
                },
                "operationId": "getExtensionIcon",
                "summary": "Get the icon of an extension."
            },
            "parameters": [
                {
                    "name": "extensionPackage",
                    "description": "The `pkgName` of the extension.",
                    "schema": {
                        "type": "string"
                    },
                    "in": "path",
                    "required": true
                }
            ]
        },
        "/api/v3/extensions/reload-available": {
            "post": {
                "responses": {
                    "200": {
                        "content": {
                            "application/json": {
                                "schema": {
                                    "type": "array",
                                    "items": {
                                        "$ref": "#/components/schemas/extension"
                                    }
                                }
                            }
                        },
                        "description": "Successful response. The new extension list is returned (including extensions of any `status`)."
                    }
                },
                "operationId": "reloadAvailableExtensions",
                "summary": "Fetch available extension list from central repository.",
                "description": "Also checks for extension updates."
            }
        },
        "/api/v3/tracking/services": {
            "get": {
                "responses": {
                    "200": {
                        "content": {
                            "application/json": {
                                "schema": {
                                    "type": "array",
                                    "items": {
                                        "$ref": "#/components/schemas/tracking-service"
                                    }
                                }
                            }
                        },
                        "description": "Returns a list of all tracking services."
                    }
                },
                "operationId": "getTrackingServices",
                "summary": "List all tracking services."
            }
        },
        "/api/v3/tracking/services/{trackingServiceId}": {
            "get": {
                "responses": {
                    "200": {
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/tracking-service"
                                }
                            }
                        },
                        "description": "Successful response."
                    },
                    "404": {
                        "description": "No tracking service with the supplied `trackingServiceId` could be found."
                    }
                },
                "operationId": "getTrackingService",
                "summary": "Get information about a single tracking service."
            },
            "parameters": [
                {
                    "name": "trackingServiceId",
                    "description": "The `id` of the tracking service.",
                    "schema": {
                        "type": "integer"
                    },
                    "in": "path",
                    "required": true
                }
            ]
        },
        "/api/v3/tracking/services/{trackingServiceId}/logout": {
            "post": {
                "responses": {
                    "200": {
                        "description": "Successfully logged out of the tracking service."
                    },
                    "400": {
                        "description": "The user is not logged into the specified tracking service (`loggedIn` field of the tracking service is `false`)."
                    },
                    "404": {
                        "description": "No tracking service with the supplied `trackingServiceId` could be found."
                    }
                },
                "operationId": "logoutOfTrackingService",
                "summary": "Logout of a tracking service.",
                "description": "Can only be performed if the user is logged into the tracking service (`loggedIn` field of the tracking service is `true`)."
            },
            "parameters": [
                {
                    "name": "trackingServiceId",
                    "description": "The `id` of the tracking service.",
                    "schema": {
                        "type": "integer"
                    },
                    "in": "path",
                    "required": true
                }
            ]
        },
        "/api/v3/tracking/services/{trackingServiceId}/login": {
            "post": {
                "requestBody": {
                    "description": "The login credentials.",
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/login-request"
                            }
                        }
                    },
                    "required": true
                },
                "responses": {
                    "200": {
                        "description": "Successfully logged into the tracking service."
                    },
                    "400": {
                        "content": {
                            "application/json": {
                                "schema": {
                                    "enum": [
                                        "OAUTH_ONLY",
                                        "ALREADY_LOGGED_IN"
                                    ]
                                }
                            }
                        },
                        "description": "The user is already logged into the specified tracking service (`loggedIn` field of the tracking service is `true`) or the tracking service is an OAuth based service.\n\nThe exact failure reason is provided in the response body."
                    },
                    "404": {
                        "description": "No tracking service with the supplied `trackingServiceId` could be found."
                    }
                },
                "operationId": "loginToTrackingService",
                "summary": "Logout of a tracking service.",
                "description": "Can only be performed if the user is logged out of the tracking service (`loggedIn` field of the tracking service is `false`) and the tracking service is not an OAuth based service."
            },
            "parameters": [
                {
                    "name": "trackingServiceId",
                    "description": "The `id` of the tracking service.",
                    "schema": {
                        "type": "integer"
                    },
                    "in": "path",
                    "required": true
                }
            ]
        },
        "/api/v3/handle-url": {
            "post": {
                "requestBody": {
                    "description": "The entire URL (including the scheme, path and query parameters).",
                    "content": {
                        "application/json": {
                            "schema": {
                                "type": "string"
                            }
                        }
                    },
                    "required": true
                },
                "responses": {
                    "200": {
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/url-handle-result"
                                }
                            }
                        },
                        "description": "Indicates that the URL has been processed."
                    },
                    "400": {
                        "description": "Indicates that the provided URL is not valid."
                    }
                },
                "operationId": "handleUrl",
                "summary": "Handle an application URL",
                "description": "This endpoint is used to handle `tachiyomi://` URLs.\n\nClients should intercept all URLs that have the `tachiyomi` scheme and POST these URLs to the server via this endpoint."
            }
        },
        "/api/v3/tracking/services/{trackingServiceId}/search": {
            "post": {
                "requestBody": {
                    "description": "The search query. Should usually be the title of the manga to search for.",
                    "content": {
                        "application/json": {
                            "schema": {
                                "type": "string"
                            }
                        }
                    },
                    "required": true
                },
                "responses": {
                    "200": {
                        "content": {
                            "application/json": {
                                "schema": {
                                    "type": "array",
                                    "items": {
                                        "$ref": "#/components/schemas/tracking-search-result"
                                    }
                                }
                            }
                        },
                        "description": "Successful response - search results are returned."
                    },
                    "400": {
                        "description": "The user is not logged into the specified tracking service (`loggedIn` field of the tracking service is `false`)."
                    },
                    "404": {
                        "description": "No tracking service with the supplied `trackingServiceId` could be found."
                    },
                    "500": {
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/error"
                                }
                            }
                        },
                        "description": "The search failed.\n\nThe exact failure reason is provided in the response body."
                    }
                },
                "operationId": "searchTrackingService",
                "summary": "Search for manga in a tracking service",
                "description": "Can only be performed if the user is logged into the tracking service (`loggedIn` field of the tracking service is `true`)."
            },
            "parameters": [
                {
                    "name": "trackingServiceId",
                    "description": "The `id` of the tracking service.",
                    "schema": {
                        "type": "integer"
                    },
                    "in": "path",
                    "required": true
                }
            ]
        },
        "/api/v3/manga/{mangaId}/tracks": {
            "get": {
                "responses": {
                    "200": {
                        "content": {
                            "application/json": {
                                "schema": {
                                    "type": "array",
                                    "items": {
                                        "$ref": "#/components/schemas/track"
                                    }
                                }
                            }
                        },
                        "description": "Returns a list of all tracking information associated with this manga."
                    },
                    "404": {
                        "description": "No manga with the supplied `mangaId` exists."
                    }
                },
                "operationId": "getMangaTracks",
                "summary": "List all tracking information associated with this manga."
            },
            "post": {
                "requestBody": {
                    "description": "A tracking search result.",
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/tracking-search-result"
                            }
                        }
                    },
                    "required": true
                },
                "responses": {
                    "200": {
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/track"
                                }
                            }
                        },
                        "description": "Tracking information was bound successfully. The new tracking information is returned."
                    },
                    "404": {
                        "description": "No manga with the supplied `mangaId` exists."
                    },
                    "500": {
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/error"
                                }
                            }
                        },
                        "description": "An error occurred while binding the tracking information.\n\nThe exact failure reason is provided in the repsonse body."
                    }
                },
                "operationId": "bindMangaTrack",
                "summary": "Bind a manga to tracking information"
            },
            "parameters": [
                {
                    "name": "mangaId",
                    "description": "The `manga`'s `id`.",
                    "schema": {
                        "format": "int64",
                        "type": "integer"
                    },
                    "in": "path",
                    "required": true
                }
            ]
        },
        "/api/v3/manga/{mangaId}/tracks/{trackingServiceId}": {
            "get": {
                "responses": {
                    "200": {
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/track"
                                }
                            }
                        },
                        "description": "Returns tracking information on the specified tracking service associated with this manga."
                    },
                    "404": {
                        "content": {
                            "application/json": {
                                "schema": {
                                    "enum": [
                                        "NO_MANGA",
                                        "NO_TRACKING_SERVICE",
                                        "NO_TRACK"
                                    ]
                                }
                            }
                        },
                        "description": "No manga with the supplied `mangaId` exists, no tracking service is associated with the specified `trackingServiceId` or no track associated with the tracking service with the specified `trackingServiceId` is bound to this manga.\n\nThe exact failure reason is provided in the response body."
                    }
                },
                "operationId": "getMangaTrack",
                "summary": "Get tracking information on the specified tracking service associated with this manga."
            },
            "put": {
                "requestBody": {
                    "description": "The new tracking information. It will overwrite the old tracking information.",
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/mutate-track-request"
                            }
                        }
                    },
                    "required": true
                },
                "responses": {
                    "200": {
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/track"
                                }
                            }
                        },
                        "description": "Tracking information changed successfully on the specified service, the updated tracking information is returned."
                    },
                    "404": {
                        "content": {
                            "application/json": {
                                "schema": {
                                    "enum": [
                                        "NO_MANGA",
                                        "NO_TRACKING_SERVICE",
                                        "NO_TRACK"
                                    ]
                                }
                            }
                        },
                        "description": "No manga with the supplied `mangaId` exists, no tracking service is associated with the specified `trackingServiceId` or no track associated with the tracking service with the specified `trackingServiceId` is bound to this manga.\n\nThe exact failure reason is provided in the response body."
                    },
                    "500": {
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/error"
                                }
                            }
                        },
                        "description": "An error occurred while changing the tracking information.\n\nThe exact failure reason is provided in the repsonse body."
                    }
                },
                "operationId": "editMangaTrack",
                "summary": "Change the tracking information manually."
            },
            "delete": {
                "responses": {
                    "200": {
                        "description": "Manga successfully unbound from it's tracking information on the specified tracking service."
                    },
                    "404": {
                        "content": {
                            "application/json": {
                                "schema": {
                                    "enum": [
                                        "NO_MANGA",
                                        "NO_TRACKING_SERVICE",
                                        "NO_TRACK"
                                    ]
                                }
                            }
                        },
                        "description": "No manga with the supplied `mangaId` exists, no tracking service is associated with the specified `trackingServiceId` or no track associated with the tracking service with the specified `trackingServiceId` is bound to this manga.\n\nThe exact failure reason is provided in the response body."
                    }
                },
                "operationId": "unbindMangaTrack",
                "summary": "Unbind a manga from it's tracking information."
            },
            "parameters": [
                {
                    "name": "mangaId",
                    "description": "The `manga`'s `id`.",
                    "schema": {
                        "format": "int64",
                        "type": "integer"
                    },
                    "in": "path",
                    "required": true
                },
                {
                    "name": "trackingServiceId",
                    "description": "The `id` of the tracking service.",
                    "schema": {
                        "type": "integer"
                    },
                    "in": "path",
                    "required": true
                }
            ]
        },
        "/api/v3/manga/{mangaId}/tracks/{trackingServiceId}/update": {
            "post": {
                "responses": {
                    "200": {
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/track"
                                }
                            }
                        },
                        "description": "Tracking information refreshed successfully, the new information is returned."
                    },
                    "404": {
                        "content": {
                            "application/json": {
                                "schema": {
                                    "enum": [
                                        "NO_MANGA",
                                        "NO_TRACKING_SERVICE",
                                        "NO_TRACK"
                                    ]
                                }
                            }
                        },
                        "description": "No manga with the supplied `mangaId` exists, no tracking service is associated with the specified `trackingServiceId` or no track associated with the tracking service with the specified `trackingServiceId` is bound to this manga.\n\nThe exact failure reason is provided in the response body."
                    },
                    "500": {
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/error"
                                }
                            }
                        },
                        "description": "An error occurred while updating the tracking information.\n\nThe exact failure reason is provided in the repsonse body."
                    }
                },
                "operationId": "updateMangaTrack",
                "summary": "Re-fetch tracking information from the specified tracking service associated with this manga."
            },
            "parameters": [
                {
                    "name": "mangaId",
                    "description": "The `manga`'s `id`.",
                    "schema": {
                        "format": "int64",
                        "type": "integer"
                    },
                    "in": "path",
                    "required": true
                },
                {
                    "name": "trackingServiceId",
                    "description": "The `id` of the tracking service.",
                    "schema": {
                        "type": "integer"
                    },
                    "in": "path",
                    "required": true
                }
            ]
        },
        "/api/v3/server/stop": {
            "post": {
                "responses": {
                    "200": {
                        "description": "Successful response, indicates that the server shutdown process has started."
                    }
                },
                "operationId": "stopServer",
                "summary": "Stop/shutdown the server."
            }
        },
        "/api/v3": {
            "summary": "The API root.",
            "get": {
                "responses": {
                    "200": {
                        "content": {
                            "application/json": {

                            }
                        },
                        "description": "An OpenAPI specification in JSON format."
                    }
                },
                "security": [
                    {

                    }
                ],
                "operationId": "getApiSpec",
                "summary": "Returns the OpenAPI specification for this API"
            }
        },
        "/api/v3/sources/{sourceId}/logout": {
            "summary": "Path used to logout of a source.",
            "post": {
                "responses": {
                    "204": {
                        "description": "The logout succeeded."
                    },
                    "400": {
                        "content": {
                            "application/json": {
                                "schema": {
                                    "enum": [
                                        "AUTH_UNSUPPORTED",
                                        "NOT_LOGGED_IN"
                                    ]
                                }
                            }
                        },
                        "description": "The source does not require authentication or the user is not logged in.\n\nThe exact failure reason is provided in the response body."
                    },
                    "404": {
                        "description": "No source exists with the provided `id`."
                    }
                },
                "operationId": "logoutOfSource",
                "summary": "Logout of a source",
                "description": ""
            },
            "parameters": [
                {
                    "name": "sourceId",
                    "description": "The `id` of the source.",
                    "schema": {
                        "type": "string"
                    },
                    "in": "path",
                    "required": true
                }
            ]
        },
        "/api/v3/backups/backup": {
            "summary": "Create a backup",
            "post": {
                "responses": {
                    "200": {
                        "content": {
                            "application/octet-stream": {
                                "schema": {
                                    "format": "binary",
                                    "type": "string"
                                }
                            }
                        },
                        "description": "The backup was created successfully."
                    }
                },
                "operationId": "backupAll",
                "summary": "Create a backup"
            }
        },
        "/api/v3/backups/restore": {
            "summary": "Restore a backup.",
            "post": {
                "requestBody": {
                    "content": {
                        "application/octet-stream": {
                            "schema": {
                                "format": "binary",
                                "type": "string"
                            }
                        }
                    },
                    "required": true
                },
                "responses": {
                    "202": {
                        "content": {
                            "application/json": {
                                "schema": {
                                    "format": "binary",
                                    "type": "string"
                                }
                            }
                        },
                        "description": "Restore started. The UUID of the task where the restore is running in is supplied in the response body.\n\nThe data field of the task will be of the `restore-task-data` datatype once the restore is completed."
                    }
                },
                "operationId": "restoreAll",
                "summary": "Restore a backup."
            }
        },
        "/api/v3/sync": {
            "summary": "Sync endpoint",
            "post": {
                "requestBody": {
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/sync-request"
                            }
                        }
                    },
                    "required": true
                },
                "responses": {
                    "200": {
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/sync-response"
                                }
                            }
                        },
                        "description": "The sync completed successfully."
                    },
                    "426": {
                        "content": {
                            "application/json": {
                                "schema": {
                                    "type": "integer"
                                }
                            }
                        },
                        "description": "The client's sync specification version does not match the server's sync specification version.\n\nThe server's sync specification version is returned."
                    },
                    "500": {
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/error"
                                }
                            }
                        },
                        "description": "An error occured during the syncing process and the sync was not performed.\n\nThe exact failure reason is provided in the repsonse body."
                    }
                },
                "security": [
                    {
                        "auth-token-header": [
                        ]
                    },
                    {
                        "auth-token-cookie": [
                        ]
                    }
                ],
                "operationId": "sync",
                "summary": "Sync endpoint."
            }
        },
        "/api/v3/preferences/{preferenceKey}": {
            "summary": "Path used to manage a single preference.",
            "description": "",
            "get": {
                "responses": {
                    "200": {
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/preference"
                                }
                            }
                        },
                        "description": "Successful response - returns a single `preference`."
                    },
                    "404": {
                        "description": "No preference exists with the supplied `preferenceKey`."
                    }
                },
                "operationId": "getPreference",
                "summary": "Get a preference",
                "description": "Gets the details of a single instance of a `preference`."
            },
            "put": {
                "requestBody": {
                    "description": "Updated `preference` value",
                    "content": {
                        "application/json": {
                            "schema": {
                                "anyOf": [
                                    {
                                        "type": "string"
                                    },
                                    {
                                        "type": "integer"
                                    },
                                    {
                                        "type": "number"
                                    },
                                    {
                                        "type": "boolean"
                                    },
                                    {
                                        "type": "array",
                                        "items": {
                                            "type": "string"
                                        }
                                    }
                                ],
                                "$ref": "#/components/schemas/mutate-preference-request"
                            }
                        }
                    },
                    "required": true
                },
                "responses": {
                    "200": {
                        "description": "Successful response."
                    },
                    "404": {
                        "description": "No preference exists with the supplied `preferenceKey`."
                    }
                },
                "operationId": "setPreference",
                "summary": "Update a preference",
                "description": "Updates an existing `preference`."
            },
            "parameters": [
                {
                    "name": "preferenceKey",
                    "description": "The key of the preference.",
                    "schema": {
                        "type": "string"
                    },
                    "in": "path",
                    "required": true
                }
            ]
        },
        "/api/v3/extensions": {
            "summary": "Path to manage extensions.",
            "get": {
                "responses": {
                    "200": {
                        "content": {
                            "application/json": {
                                "schema": {
                                    "type": "array",
                                    "items": {
                                        "$ref": "#/components/schemas/extension"
                                    }
                                }
                            }
                        },
                        "description": "Successful response."
                    }
                },
                "operationId": "getExtensions",
                "summary": "List all extensions.",
                "description": "Includes all extensions, regardless of their `status`."
            },
            "post": {
                "requestBody": {
                    "description": "The extension APK.",
                    "content": {
                        "application/vnd.android.package-archive": {
                            "schema": {
                                "format": "binary",
                                "type": "string"
                            }
                        }
                    },
                    "required": true
                },
                "responses": {
                    "200": {
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/extension"
                                }
                            }
                        },
                        "description": "Successful response. The extension was successfully imported."
                    },
                    "400": {
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/error"
                                }
                            }
                        },
                        "description": "The request body did not contain a valid extension or the extension could not be imported.\n\nThe exact failure reason is supplied in the response body."
                    }
                },
                "operationId": "createExtensionFromAPK",
                "summary": "Imports an extension from an APK file."
            }
        },
        "/api/v3/manga/library": {
            "get": {
                "parameters": [
                    {
                        "name": "include-total-downloaded",
                        "description": "Set to `true` to include the `totalDownloaded` field in the response. Defaults to `false`.\n\n**This will incur a performance penalty.**",
                        "schema": {
                            "type": "boolean"
                        },
                        "in": "query",
                        "required": false
                    },
                    {
                        "name": "include-last-read-index",
                        "description": "Set to `true` to include the `lastReadIndex` field in the response. Defaults to `false`.\n\n**This will incur a performance penalty.**",
                        "schema": {
                            "type": "boolean"
                        },
                        "in": "query",
                        "required": false
                    },
                    {
                        "name": "include-total-chapters-index",
                        "description": "Set to `true` to include the `totalChaptersIndex` field in the response. Defaults to `false`.\n\n**This will incur a performance penalty.**",
                        "schema": {
                            "type": "boolean"
                        },
                        "in": "query",
                        "required": false
                    }
                ],
                "responses": {
                    "200": {
                        "content": {
                            "application/json": {
                                "schema": {
                                    "type": "array",
                                    "items": {
                                        "$ref": "#/components/schemas/library-manga"
                                    }
                                }
                            }
                        },
                        "description": "Successful response."
                    }
                },
                "operationId": "getLibraryMangas",
                "summary": "Get all favorited manga along with some extra information about each manga."
            }
        },
        "/api/v3/chapters/{chapterId}/bookmark": {
            "summary": "Path used to manage a single chapter's bookmarked status.",
            "description": "",
            "put": {
                "requestBody": {
                    "description": "The new bookmarked status of the chapter.",
                    "content": {
                        "application/json": {
                            "schema": {
                                "type": "boolean"
                            }
                        }
                    },
                    "required": true
                },
                "responses": {
                    "200": {
                        "content": {
                            "application/json": {
                                "schema": {
                                    "type": "boolean"
                                }
                            }
                        },
                        "description": "Successful response.\n\nThe new bookmarked status of the chapter is returned."
                    },
                    "404": {
                        "description": "No chapter exists with the supplied `chapterId`."
                    }
                },
                "operationId": "setChapterBookmarked",
                "summary": "Set a chapter's bookmarked status.",
                "description": ""
            },
            "parameters": [
                {
                    "name": "chapterId",
                    "description": "The chapter id.",
                    "schema": {
                        "format": "int64",
                        "type": "integer"
                    },
                    "in": "path",
                    "required": true
                }
            ]
        },
        "/api/v3/auth/validate": {
            "get": {
                "responses": {
                    "200": {
                        "description": "Successful response - the client's authentication is valid."
                    },
                    "401": {
                        "description": "The client's authentication is invalid."
                    }
                },
                "operationId": "getAuthValid",
                "summary": "Validate that the client is authenticated"
            }
        },
        "/api/v3/auth/tokens": {
            "summary": "Endpoint for managing auth tokens",
            "get": {
                "responses": {
                    "200": {
                        "content": {
                            "application/json": {
                                "schema": {
                                    "type": "array",
                                    "items": {
                                        "$ref": "#/components/schemas/auth-token"
                                    }
                                }
                            }
                        },
                        "description": "Successful response.\n\nThe auth tokens are returned (without their secrets)."
                    }
                },
                "operationId": "getAuthTokens",
                "summary": "List all auth tokens created by this user."
            },
            "post": {
                "requestBody": {
                    "description": "",
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/create-auth-token-request"
                            }
                        }
                    },
                    "required": true
                },
                "responses": {
                    "200": {
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/auth-token"
                                }
                            }
                        },
                        "description": "Successful response.\n\nThe new authentication token is returned (including the secret)."
                    }
                },
                "operationId": "createAuthToken",
                "summary": "Create an auth token."
            }
        },
        "/api/v3/auth/tokens/{tokenId}": {
            "summary": "Endpoint used to manage a single auth token.",
            "delete": {
                "responses": {
                    "200": {
                        "description": "Successful response - the token was successfully deleted."
                    },
                    "404": {
                        "description": "No auth token exists with the specified identifier."
                    }
                },
                "operationId": "deleteAuthToken",
                "summary": "Delete the auth token."
            },
            "parameters": [
                {
                    "name": "tokenId",
                    "description": "The auth token's identifier.",
                    "schema": {
                        "type": "string"
                    },
                    "in": "path",
                    "required": true
                }
            ]
        },
        "/api/v3/categories/batch": {
            "summary": "Endpoint to perform batch operations on categories",
            "put": {
                "requestBody": {
                    "description": "Updated `category` information.",
                    "content": {
                        "application/json": {
                            "schema": {
                                "type": "array",
                                "items": {
                                    "$ref": "#/components/schemas/batch-mutate-category-request"
                                }
                            }
                        }
                    },
                    "required": true
                },
                "responses": {
                    "200": {
                        "content": {
                            "application/json": {
                                "schema": {
                                    "type": "array",
                                    "items": {
                                        "$ref": "#/components/schemas/category"
                                    }
                                }
                            }
                        },
                        "description": "Successful response - returns the edited `categories`."
                    },
                    "404": {
                        "content": {
                            "application/json": {
                                "schema": {
                                    "format": "int32",
                                    "type": "integer"
                                }
                            }
                        },
                        "description": "No category with the supplied `id` could be found.\n\nIf any of the categories being edited cannot be found in the database by their ids, none of the categories will be edited.\n\nWill return the id of the first category edit request which could not be found in the database."
                    },
                    "409": {
                        "content": {
                            "application/json": {
                                "schema": {
                                    "enum": [
                                        "NAME_CONFLICT",
                                        "ORDER_CONFLICT"
                                    ],
                                    "type": "string"
                                }
                            }
                        },
                        "description": "Category edit failed due to a conflict.\n\nThe exact reason for the failure is supplied in the response body.\n\nThe category that the edit failed on is **not** provided.\n\nIf an error occurs while performing any of the requested edits, none of the categories will be edited.\n"
                    }
                },
                "operationId": "editCategories",
                "summary": "Update categories",
                "description": "Updates existing `categories`."
            }
        }
    },
    "components": {
        "schemas": {
            "manga": {
                "title": "Root Type for manga",
                "description": "A single manga.",
                "required": [
                    "id",
                    "favorite",
                    "sourceId",
                    "lastUpdate",
                    "status",
                    "title",
                    "viewer",
                    "flags",
                    "categories",
                    "initialized",
                    "tracks"
                ],
                "type": "object",
                "properties": {
                    "id": {
                        "format": "int64",
                        "description": "The unique identifier for this manga.",
                        "type": "integer"
                    },
                    "sourceId": {
                        "description": "The id of the source this manga belongs to.",
                        "type": "string"
                    },
                    "favorite": {
                        "description": "Whether or not the manga is favorited.",
                        "type": "boolean"
                    },
                    "lastUpdate": {
                        "format": "int64",
                        "description": "The time this manga was last updated in milliseconds since epoch.",
                        "type": "integer"
                    },
                    "viewer": {
                        "$ref": "#/components/schemas/manga-viewer",
                        "description": "The viewer for this manga."
                    },
                    "flags": {
                        "$ref": "#/components/schemas/manga-flags",
                        "description": "The manga's flags.",
                        "properties": {
                            "sortDirection": {
                                "type": "string"
                            },
                            "displayMode": {
                                "type": "string"
                            },
                            "readFilter": {
                                "type": "string"
                            },
                            "downloadedFilter": {
                                "type": "string"
                            },
                            "sortType": {
                                "type": "string"
                            }
                        }
                    },
                    "url": {
                        "description": "The URL of this manga on the source. Will not be present for mangas in the local source.",
                        "type": "string"
                    },
                    "title": {
                        "description": "The title of this manga.",
                        "type": "string"
                    },
                    "artist": {
                        "description": "The artist of the manga.",
                        "type": "string"
                    },
                    "author": {
                        "description": "The author of the manga.",
                        "type": "string"
                    },
                    "description": {
                        "description": "The description of the manga. Will be rather large and may contain multiple lines/paragraphs.",
                        "type": "string"
                    },
                    "genre": {
                        "description": "The genre(s) of a manga. If the manga has multiple genres, the genres are often (but not always) split by comma.",
                        "type": "string"
                    },
                    "status": {
                        "description": "The status of this manga.",
                        "enum": [
                            "UNKNOWN",
                            "ONGOING",
                            "COMPLETED",
                            "LICENSED"
                        ]
                    },
                    "categories": {
                        "description": "The `id`s of the categories that this manga belong to.",
                        "type": "array",
                        "items": {
                            "format": "int64",
                            "type": "integer"
                        }
                    },
                    "initialized": {
                        "description": "Whether or not this manga has had it's metadata (not chapters) updated for the first time yet.",
                        "type": "boolean"
                    },
                    "tracks": {
                        "description": "An array of the tracking information associated with this manga.\n\nA single manga may be tracked on multiple services which is why this field is an array.",
                        "type": "array",
                        "items": {
                            "$ref": "#/components/schemas/track"
                        }
                    }
                },
                "example": {
                    "id": 1,
                    "sourceId": 123,
                    "favorite": true,
                    "lastUpdate": 1544920787968,
                    "viewer": "DEFAULT",
                    "flags": {
                        "sortDirection": "DESCENDING",
                        "displayMode": "NAME",
                        "readFilter": "ALL",
                        "downloadedFilter": "ALL",
                        "sortType": "SOURCE"
                    },
                    "url": "https://mangadex.org/title/17709/kumo-desu-ga-nani-ka",
                    "title": "Kumo Desu ga, Nani ka?",
                    "artist": "Kakashi Asahiro",
                    "author": "Baba Okina",
                    "description": "When a mysterious explosion killed an entire class full of high school students, the souls of everyone in class were transported into a fantasy world and reincarnated. While some students were reincarnated as princes or prodigies, others were not as blessed.\n\nOur heroine, who was the lowest in the class, discovered that she was reincarnated as a spider! Now at the bottom of the food chain, she needs to adapt to the current situation with willpower in order to live. Stuck in a dangerous labyrinth filled with monsters, it's eat or be eaten!\n\nThis is the story of a spider doing whatever she can in order to survive!",
                    "genre": "Action, Adventure, Comedy, Drama, Fantasy, Isekai",
                    "status": "ONGOING",
                    "categories": [
                        2,
                        4
                    ],
                    "initialized": true
                }
            },
            "manga-viewer": {
                "description": "An enum representing a manga's viewer:\n\n- `DEFAULT`: The user's default viewer (stored in the user preferences)\n- `LEFT_TO_RIGHT`: A paged left-to-right viewer.\n- `RIGHT_TO_LEFT`: A paged right-to-left viewer.\n- `VERTICAL`: A paged top-to-bottom viewer.\n- `WEBTOON`: A continous top-to-bottom viewer.",
                "enum": [
                    "DEFAULT",
                    "LEFT_TO_RIGHT",
                    "RIGHT_TO_LEFT",
                    "VERTICAL",
                    "WEBTOON"
                ]
            },
            "mutate-category-request": {
                "title": "Root Type for category",
                "description": "A request to create/edit a category.",
                "required": [
                ],
                "type": "object",
                "properties": {
                    "name": {
                        "description": "The name of the category.\n\nMust be unique across all categories (case-insensitive, two categories are considered the same if their only difference is different casing).",
                        "type": "string"
                    },
                    "order": {
                        "format": "int32",
                        "description": "Categories are sorted ascending by this number.\n\nMust be unique across all categories.\n\nDefaults to the `maximum order of all existing categories + 1`.",
                        "type": "integer"
                    }
                },
                "example": {
                    "name": "Dropped",
                    "order": 1
                }
            },
            "chapter": {
                "title": "Root Type for chapter",
                "description": "A single chapter of a manga.",
                "required": [
                    "bookmarked",
                    "dateFetch",
                    "id",
                    "mangaId",
                    "name",
                    "readingStatus"
                ],
                "type": "object",
                "properties": {
                    "url": {
                        "description": "The url of this chapter on the source website.\n\nWill be `null` if this chapter belongs to a manga in the local source.",
                        "type": "string"
                    },
                    "name": {
                        "description": "The name of this chapter.",
                        "type": "string"
                    },
                    "dateUpload": {
                        "format": "int64",
                        "description": "The date in milliseconds since epoch representing when this chapter was uploaded to the source.",
                        "type": "integer"
                    },
                    "chapterNumber": {
                        "format": "float",
                        "description": "The chapter number of this chapter (usually parsed from the chapter name).\n\nWill be `null` if unknown.",
                        "type": "number"
                    },
                    "scanlator": {
                        "description": "The name of the scanlator for this chapter.",
                        "type": "string"
                    },
                    "id": {
                        "format": "int64",
                        "description": "A unique identifier for this chapter. Will be unique across all chapters and all manga.",
                        "type": "integer"
                    },
                    "mangaId": {
                        "format": "int64",
                        "description": "The id of the `manga` this chapter belongs to.",
                        "type": "integer"
                    },
                    "dateFetch": {
                        "format": "int64",
                        "description": "The date in milliseconds since epoch representing when the metadata for this chapter was downloaded from the source URL.",
                        "type": "integer"
                    },
                    "sourceOrder": {
                        "format": "int64",
                        "description": "The index that this chapter appears in on the source website.",
                        "type": "integer"
                    },
                    "readingStatus": {
                        "$ref": "#/components/schemas/chapter-reading-status",
                        "description": "The reading status of this chapter."
                    },
                    "bookmarked": {
                        "description": "Whether or not the chapter is bookmarked.",
                        "type": "boolean"
                    }
                },
                "example": {
                    "url": "https://mangadex.org/chapter/415934",
                    "name": "Ch. 29.2",
                    "dateUpload": 1544928692640,
                    "chapterNumber": 29.2,
                    "scanlator": "aumakua",
                    "id": 35,
                    "mangaId": 1,
                    "bookmark": false,
                    "dateFetch": 1544928692640,
                    "sourceOrder": 0,
                    "readingStatus": {
                        "read": false,
                        "lastPageRead": 0
                    }
                }
            },
            "chapter-reading-status": {
                "title": "Root Type for chapter-reading-status",
                "description": "The reading status of a chapter.",
                "required": [
                    "read",
                    "lastPageRead"
                ],
                "type": "object",
                "properties": {
                    "read": {
                        "description": "Whether or not this chapter is fully read.",
                        "type": "boolean"
                    },
                    "lastPageRead": {
                        "format": "int64",
                        "description": "The last page read in this chapter.",
                        "type": "integer"
                    },
                    "lastRead": {
                        "format": "int64",
                        "description": "The time this chapter was last read in milliseconds since epoch. Not present if unknown.",
                        "type": "integer"
                    }
                },
                "example": {
                    "read": false,
                    "lastPageRead": 0,
                    "lastRead": 1551218464314
                }
            },
            "download": {
                "title": "Root Type for download",
                "description": "A chapter download. May represent a complete or partial download.",
                "required": [
                    "mangaId",
                    "chapterId",
                    "chapterName",
                    "downloadedPages",
                    "progress",
                    "mangaTitle",
                    "status"
                ],
                "type": "object",
                "properties": {
                    "mangaTitle": {
                        "description": "The title of the manga of the chapter associated with this download.",
                        "type": "string"
                    },
                    "chapterName": {
                        "description": "The name of the chapter associated with this download.\n\nDepends on the `displayMode` field of the manga the chapter belongs to.",
                        "type": "string"
                    },
                    "progress": {
                        "format": "float",
                        "description": "The progress of this download between (0 and 1).\n\nNote that this number is not equal to the `downloadedPages` divided by `totalPages` since this number also includes the download progress on any currently downloading pages.",
                        "type": "number"
                    },
                    "downloadedPages": {
                        "format": "int64",
                        "description": "The number of pages fully downloaded so far.",
                        "type": "integer"
                    },
                    "totalPages": {
                        "format": "int64",
                        "description": "The total number of pages in the chapter associated with this download.\n\nWill be `null` if currently unknown.",
                        "type": "integer"
                    },
                    "mangaId": {
                        "format": "int64",
                        "description": "The id of the manga of the chapter associated with this download.",
                        "type": "integer"
                    },
                    "chapterId": {
                        "format": "int64",
                        "description": "The id of the chapter associated with this download.",
                        "type": "integer"
                    },
                    "status": {
                        "description": "The status of this download.",
                        "enum": [
                            "QUEUED",
                            "DOWNLOADING",
                            "DOWNLOADED",
                            "ERROR"
                        ]
                    }
                },
                "example": {
                    "mangaTitle": "Kumo Desu ga, Nani ka?",
                    "chapterName": "Ch. 29.2",
                    "mangaId": 1,
                    "chapterId": 2,
                    "progress": 0.51,
                    "downloadedPages": 10,
                    "totalPages": 20,
                    "status": "DOWNLOADING"
                }
            },
            "downloader": {
                "description": "The chapter downloader on the server.",
                "required": [
                    "paused",
                    "downloads"
                ],
                "type": "object",
                "properties": {
                    "paused": {
                        "description": "Whether or not the downloader is paused.",
                        "type": "boolean"
                    },
                    "downloads": {
                        "description": "A list of all currently **unfinished** downloads.\n\nIncludes only downloads in the `QUEUED`, `DOWNLOADING` and `ERROR` states.",
                        "type": "array",
                        "items": {
                            "$ref": "#/components/schemas/download"
                        }
                    }
                }
            },
            "task": {
                "description": "A long-running task.",
                "required": [
                    "type",
                    "completed",
                    "startedAt",
                    "uuid"
                ],
                "type": "object",
                "properties": {
                    "type": {
                        "description": "The type of the task.",
                        "enum": [
                            "RESTORE_BACKUP",
                            "UPDATE_LIBRARY"
                        ]
                    },
                    "completed": {
                        "description": "Whether or not the task is completed.",
                        "type": "boolean"
                    },
                    "progress": {
                        "format": "float",
                        "description": "The progress on the task (between 0 and 1).\n\nCan be `null` if unknown.",
                        "type": "number"
                    },
                    "startedAt": {
                        "format": "int64",
                        "description": "The time when this task was started in milliseconds since epoch.",
                        "type": "integer"
                    },
                    "progressText": {
                        "description": "The progress of the current task in textual form.\n\nMay represent the currently processing subtask in this task.",
                        "type": "string"
                    },
                    "data": {
                        "description": "The data associated with the task.\n\nUsually only existant when the task is completed.",
                        "type": "string"
                    },
                    "uuid": {
                        "description": "The UUID of the task.\n\nNote that the value of this field is opaque, clients should not attempt to parse it. It will always be URL safe.",
                        "type": "string"
                    }
                },
                "example": {
                    "type": "RESTORE_BACKUP",
                    "completed": true,
                    "progress": 1,
                    "startedAt": 1551594603012,
                    "progressText": "Restored 10082 manga",
                    "data": "[100, 2, 4, 5]",
                    "uuid": "01ARZ3NDEKTSV4RRFFQ69G5FAV"
                }
            },
            "restore-task-data": {
                "title": "Root Type for restore-task-data",
                "description": "The data of a restore task.",
                "required": [
                    "errors",
                    "log",
                    "result"
                ],
                "type": "object",
                "properties": {
                    "result": {
                        "description": "The resulting status of the restore.",
                        "enum": [
                            "SUCCESSFUL",
                            "SUCCESSFUL_WITH_ERRORS",
                            "FAILED"
                        ]
                    },
                    "errors": {
                        "description": "A list of errors that occured during the restore process.",
                        "type": "array",
                        "items": {
                            "type": "string"
                        }
                    },
                    "log": {
                        "description": "A log of the restore process.",
                        "type": "string"
                    }
                },
                "example": {
                    "result": "SUCCESSFUL_WITH_ERRORS",
                    "errors": [
                        "An error",
                        "Another error"
                    ],
                    "log": "A very long log..."
                }
            },
            "source": {
                "title": "Root Type for source",
                "description": "A manga source.",
                "required": [
                    "requiresLogin",
                    "id",
                    "name",
                    "supportsLatest"
                ],
                "type": "object",
                "properties": {
                    "id": {
                        "description": "The id of the source, unique across all sources.",
                        "type": "string"
                    },
                    "name": {
                        "description": "The name of this source.",
                        "type": "string"
                    },
                    "lang": {
                        "description": "The ISO 639-1 compliant language code of the source (two letters in lower case).",
                        "type": "string"
                    },
                    "langName": {
                        "description": "The full name of the language of this source in English.",
                        "type": "string"
                    },
                    "langDisplayName": {
                        "description": "The full name of the language of this source in the language itself.",
                        "type": "string"
                    },
                    "supportsLatest": {
                        "description": "Whether or not this source supports the latest updates screen.",
                        "type": "boolean"
                    },
                    "requiresLogin": {
                        "description": "Whether or not the source requires login.",
                        "type": "boolean"
                    },
                    "loggedIn": {
                        "description": "Whether or not the user is logged into the source.\n\nWill be `null` if the source does not require login.",
                        "type": "boolean"
                    }
                },
                "example": {
                    "id": "3",
                    "name": "MangaDex",
                    "lang": "fr",
                    "langName": "French",
                    "langDisplayName": "Français",
                    "supportsLatest": true,
                    "requiresLogin": true,
                    "loggedIn": false
                }
            },
            "catalogue-page": {
                "description": "A catalogue/latest-updates page.",
                "required": [
                    "mangas",
                    "hasNextPage"
                ],
                "type": "object",
                "properties": {
                    "mangas": {
                        "description": "The mangas on the current page of the catalogue.",
                        "type": "array",
                        "items": {
                            "$ref": "#/components/schemas/manga"
                        }
                    },
                    "hasNextPage": {
                        "description": "Whether or not there is another page after this catalogue page.",
                        "type": "boolean"
                    }
                }
            },
            "catalogue-page-request": {
                "description": "A request for a catalogue page.",
                "required": [
                    "page"
                ],
                "type": "object",
                "properties": {
                    "page": {
                        "description": "The 1-indexed page number of the catalogue to obtain.",
                        "type": "integer"
                    },
                    "query": {
                        "description": "The search string.",
                        "type": "string"
                    },
                    "filters": {
                        "$ref": "#/components/schemas/catalogue-filters",
                        "description": "The filters to apply."
                    }
                }
            },
            "latest-updates-request": {
                "description": "A request for the latest updates catalogue page.",
                "required": [
                    "page"
                ],
                "type": "object",
                "properties": {
                    "page": {
                        "description": "The page number of the catalogue to obtain.",
                        "type": "integer"
                    }
                },
                "example": {
                    "page": 86
                }
            },
            "category": {
                "title": "Root Type for category",
                "description": "A manga category.",
                "required": [
                    "id",
                    "name",
                    "manga",
                    "order"
                ],
                "type": "object",
                "properties": {
                    "id": {
                        "format": "int32",
                        "description": "The id of the category.",
                        "type": "integer"
                    },
                    "name": {
                        "description": "The name of the category.",
                        "type": "string"
                    },
                    "order": {
                        "format": "int32",
                        "description": "Categories are sorted ascending by this number.\n\nMust be unique across all categories.\n\n",
                        "type": "integer"
                    },
                    "manga": {
                        "description": "An array of the `id`s of the manga present in this category.",
                        "type": "array",
                        "items": {
                            "format": "int64",
                            "type": "integer"
                        }
                    }
                },
                "example": {
                    "id": 321,
                    "name": "Dropped",
                    "order": 1,
                    "manga": [
                        2,
                        5,
                        19,
                        26
                    ]
                }
            },
            "recently-read": {
                "description": "A recently read manga + chapter combination.",
                "required": [
                    "manga",
                    "chapter"
                ],
                "type": "object",
                "properties": {
                    "manga": {
                        "$ref": "#/components/schemas/manga",
                        "description": "The manga that was recently read."
                    },
                    "chapter": {
                        "$ref": "#/components/schemas/chapter",
                        "description": "The chapter that was recently read in the manga."
                    }
                }
            },
            "manga-flags": {
                "title": "Root Type for manga-flags",
                "description": "Flags specific to manga objects. Often describe sorting and filtering.",
                "required": [
                    "displayMode",
                    "downloadedFilter",
                    "readFilter",
                    "sortDirection",
                    "sortType",
                    "bookmarkedFilter"
                ],
                "type": "object",
                "properties": {
                    "sortDirection": {
                        "$ref": "#/components/schemas/sort-direction",
                        "description": "The sort direction of a manga's chapters."
                    },
                    "displayMode": {
                        "description": "Option to display chapters by their name or chapter number.",
                        "enum": [
                            "NAME",
                            "NUMBER"
                        ]
                    },
                    "readFilter": {
                        "description": "Whether or not to show only read/unread chapters.",
                        "enum": [
                            "SHOW_READ",
                            "SHOW_UNREAD",
                            "SHOW_ALL"
                        ]
                    },
                    "downloadedFilter": {
                        "description": "Whether or not to show only downloaded/not downloaded chapters.",
                        "enum": [
                            "SHOW_DOWNLOADED",
                            "SHOW_NOT_DOWNLOADED",
                            "SHOW_ALL"
                        ]
                    },
                    "sortType": {
                        "description": "The method used to sort chapters:\n- by the order they appear in the **source** website\n- by their chapter **number**",
                        "enum": [
                            "SOURCE",
                            "NUMBER"
                        ]
                    },
                    "bookmarkedFilter": {
                        "description": "Whether or not to show only read/non-bookmarked chapters.",
                        "enum": [
                            "SHOW_BOOKMARKED",
                            "SHOW_NOT_BOOKMARKED",
                            "SHOW_ALL"
                        ]
                    }
                },
                "example": {
                    "sortDirection": "DESCENDING",
                    "displayMode": "NAME",
                    "readFilter": "ALL",
                    "downloadedFilter": "ALL",
                    "sortType": "SOURCE"
                }
            },
            "mutate-category-manga-request": {
                "description": "A request to add/remove manga from a category.",
                "type": "object",
                "properties": {
                    "add": {
                        "description": "A list of the `id`s of the manga to add to this category.\n\n`id`s of manga already present in the category will be ignored.",
                        "type": "array",
                        "items": {
                            "format": "int64",
                            "type": "integer"
                        }
                    },
                    "remove": {
                        "description": "A list of the `id`s of the manga to remove from this category.\n\n`id`s of manga not present in the category will be ignored.",
                        "type": "array",
                        "items": {
                            "format": "int64",
                            "type": "integer"
                        }
                    }
                }
            },
            "extension": {
                "description": "A binary package of sources that can be downloaded from a central repository or uploaded manually by the user.",
                "required": [
                    "pkgName",
                    "name",
                    "status",
                    "versionName",
                    "versionCode",
                    "lang"
                ],
                "type": "object",
                "properties": {
                    "pkgName": {
                        "description": "The package name of the extension. Unique across all extensions.",
                        "type": "string"
                    },
                    "name": {
                        "description": "The display name of the extension.",
                        "type": "string"
                    },
                    "status": {
                        "description": "The status of the extension.\n\n- `INSTALLED`: Extension is installed and trusted\n- `UNTRUSTED`: Extension is installed but not trusted. Sources inside this extension cannot be used until the extension is trusted.\n- `AVAILABLE`: Extension is available in the central repository and is not downloaded/installed",
                        "enum": [
                            "INSTALLED",
                            "UNTRUSTED",
                            "AVAILABLE"
                        ]
                    },
                    "versionName": {
                        "description": "Version name of the extension.",
                        "type": "string"
                    },
                    "versionCode": {
                        "description": "Computer-readable version code of extension.",
                        "type": "integer"
                    },
                    "signatureHash": {
                        "description": "Signature hash of extension. Only present when extension status is `UNTRUSTED`.\n\nMultiple extensions may have the same signature hash.\n\nThe signature hash is used to trust extensions.",
                        "type": "string"
                    },
                    "lang": {
                        "description": "Language of extension represented in ISO 639-1 format. Can also be set to `all` when the extension includes sources of multiple languages.",
                        "type": "string"
                    },
                    "sources": {
                        "description": "A list of the `id`s of all the sources included in the extension. Extensions may include multiple sources. Only present when the extension status is `INSTALLED`.",
                        "type": "array",
                        "items": {
                            "type": "string"
                        }
                    },
                    "hasUpdate": {
                        "description": "Whether or not an update is available for this extension in the central repository. Only present when the extension status is `UNTRUSTED` or `INSTALLED`.",
                        "type": "boolean"
                    }
                },
                "example": {
                    "pkgName": "eu.kanade.tachiyomi.extension.en.dynasty",
                    "name": "Dynasty",
                    "status": "INSTALLED",
                    "versionName": "1.2.6",
                    "versionCode": 6,
                    "lang": "en",
                    "sources": [
                        "738706855355689486"
                    ],
                    "hasUpdate": true
                }
            },
            "error": {
                "description": "An error.",
                "required": [
                    "type",
                    "message"
                ],
                "type": "object",
                "properties": {
                    "type": {
                        "description": "The type of the error, not human readable.\n\nWill be `UNKNOWN` if the type is unknown.",
                        "type": "string"
                    },
                    "stackTrace": {
                        "description": "Stack trace of the error to be used for debugging purposes.\n\nMay not be present if no stack trace could be generated.",
                        "type": "string"
                    },
                    "message": {
                        "description": "A human readable message representing this error.",
                        "type": "string"
                    }
                },
                "example": {
                    "type": "UNKNOWN",
                    "stackTrace": "java.lang.IllegalStateException: Not enough cheese!\r\n\tat Line_3.<init>(Unknown Source)\r\n\tat sun.reflect.NativeConstructorAccessorImpl.newInstance0(Native Method)\r\n\tat sun.reflect.NativeConstructorAccessorImpl.newInstance(NativeConstructorAccessorImpl.java:62)\r\n\tat sun.reflect.DelegatingConstructorAccessorImpl.newInstance(DelegatingConstructorAccessorImpl.ja\r\n\tat java.lang.reflect.Constructor.newInstance(Constructor.java:423)\r\n\tat org.jetbrains.kotlin.cli.common.repl.GenericReplEvaluator$eval$1$scriptInstance$1.invoke(Gener\r\n\tat org.jetbrains.kotlin.cli.jvm.repl.configuration.SnippetExecutionInterceptor$Plain.execute(Snip\r\n\tat org.jetbrains.kotlin.cli.jvm.repl.ReplInterpreter$eval$evalRes$1.invoke(ReplInterpreter.kt:101\r\n\tat org.jetbrains.kotlin.cli.common.repl.GenericReplEvaluator.eval(GenericReplEvaluator.kt:94)\r\n\tat org.jetbrains.kotlin.cli.common.repl.GenericReplCompilingEvaluator.eval(GenericReplCompilingEv\r\n\tat org.jetbrains.kotlin.cli.common.repl.GenericReplCompilingEvaluator.compileAndEval(GenericReplC\r\n\tat org.jetbrains.kotlin.cli.jvm.repl.ReplInterpreter.eval(ReplInterpreter.kt:96)\r\n\tat org.jetbrains.kotlin.cli.jvm.repl.ReplFromTerminal.eval(ReplFromTerminal.kt:115)\r\n\tat org.jetbrains.kotlin.cli.jvm.repl.ReplFromTerminal.one(ReplFromTerminal.kt:106)\r\n\tat org.jetbrains.kotlin.cli.jvm.repl.ReplFromTerminal.doRun(ReplFromTerminal.kt:71)\r\n\tat org.jetbrains.kotlin.cli.jvm.repl.ReplFromTerminal.access$doRun(ReplFromTerminal.kt:38)\r\n\tat org.jetbrains.kotlin.cli.jvm.repl.ReplFromTerminal$Companion.run(ReplFromTerminal.kt:171)\r\n\tat org.jetbrains.kotlin.cli.jvm.K2JVMCompiler.doExecute(K2JVMCompiler.kt:104)\r\n\tat org.jetbrains.kotlin.cli.jvm.K2JVMCompiler.doExecute(K2JVMCompiler.kt:57)\r\n\tat org.jetbrains.kotlin.cli.common.CLICompiler.execImpl(CLICompiler.java:96)\r\n\tat org.jetbrains.kotlin.cli.common.CLICompiler.execImpl(CLICompiler.java:52)\r\n\tat org.jetbrains.kotlin.cli.common.CLITool.exec(CLITool.kt:93)\r\n\tat org.jetbrains.kotlin.cli.common.CLITool.exec(CLITool.kt:71)\r\n\tat org.jetbrains.kotlin.cli.common.CLITool.exec(CLITool.kt:39)\r\n\tat org.jetbrains.kotlin.cli.common.CLITool$Companion.doMainNoExit(CLITool.kt:204)\r\n\tat org.jetbrains.kotlin.cli.common.CLITool$Companion.doMain(CLITool.kt:196)\r\n\tat org.jetbrains.kotlin.cli.jvm.K2JVMCompiler$Companion.main(K2JVMCompiler.kt:348)\r\n\tat org.jetbrains.kotlin.cli.jvm.K2JVMCompiler.main(K2JVMCompiler.kt)\r\n\tat sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)\r\n\tat sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:62)\r\n\tat sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43)\r\n\tat java.lang.reflect.Method.invoke(Method.java:498)\r\n\tat org.jetbrains.kotlin.preloading.Preloader.run(Preloader.java:81)\r\n\tat org.jetbrains.kotlin.preloading.Preloader.main(Preloader.java:43)",
                    "message": "The operation failed"
                }
            },
            "login-request": {
                "title": "Root Type for source-login-request",
                "description": "A login request.",
                "required": [
                    "password",
                    "username"
                ],
                "type": "object",
                "properties": {
                    "username": {
                        "description": "The username to login with.",
                        "type": "string"
                    },
                    "password": {
                        "format": "password",
                        "description": "The password to login with.",
                        "type": "string"
                    }
                },
                "example": {
                    "username": "nulldev",
                    "password": "hunter7"
                }
            },
            "tracking-service": {
                "description": "A tracking service.",
                "required": [
                    "id",
                    "possibleStatuses",
                    "possibleScores",
                    "loggedIn",
                    "name",
                    "themeColor"
                ],
                "type": "object",
                "properties": {
                    "id": {
                        "description": "The `id` of the tracking service",
                        "type": "integer"
                    },
                    "possibleStatuses": {
                        "description": "The list of the possible statuses a user can assign to a manga.",
                        "type": "array",
                        "items": {
                            "$ref": "#/components/schemas/tracking-status"
                        }
                    },
                    "possibleScores": {
                        "description": "The list of possible scores a user can assign to a manga.",
                        "type": "array",
                        "items": {
                            "$ref": "#/components/schemas/tracking-score"
                        }
                    },
                    "loggedIn": {
                        "description": "Whether or not the user is logged into this tracking service.",
                        "type": "boolean"
                    },
                    "name": {
                        "description": "The display name of this tracking service",
                        "type": "string"
                    },
                    "themeColor": {
                        "description": "The background color of this tracking service's logo.\n\nFormatted in hexidecimal format: `#RRGGBB`",
                        "type": "string"
                    },
                    "username": {
                        "description": "The username the user is logged in as in this tracking service. Only present if `loggedIn` is `true`.",
                        "type": "string"
                    },
                    "oauthUrl": {
                        "description": "Some sources use OAuth authentication. The presence of this field indicates the client uses OAuth authentication.\n\nTo log a user into an OAuth based source, the client must:\n1. Open the `oauthUrl` in a browser window. The client should **not** show the normal username/password dialog.\n2. When authentication is complete, the browser will redirect the user to a URL with the `tachiyomi` scheme (e.g. `tachiyomi://anilist-auth`).\n3. The client should intercept URLs with the `tachiyomi` scheme and use the `/api/v3/handle-url` API to transmit the URL back to the server.",
                        "type": "string"
                    }
                },
                "example": {
                    "id": 0,
                    "possibleStatuses": [
                        {
                            "id": 0,
                            "displayName": "Plan to read"
                        },
                        {
                            "id": 1,
                            "displayName": "Reading"
                        },
                        {
                            "id": 2,
                            "displayName": "Completed"
                        }
                    ],
                    "possibleScores": [
                        {
                            "id": 0,
                            "score": 1
                        },
                        {
                            "id": 1,
                            "score": 2
                        },
                        {
                            "id": 2,
                            "score": 3
                        },
                        {
                            "id": 3,
                            "score": 4
                        },
                        {
                            "id": 4,
                            "score": 5
                        }
                    ],
                    "loggedIn": true,
                    "name": "MyAnimeList",
                    "themeColor": "#2E51A2",
                    "username": "nulldev"
                }
            },
            "tracking-status": {
                "description": "The status of a manga in a tracking service.",
                "required": [
                    "id",
                    "displayName"
                ],
                "type": "object",
                "properties": {
                    "id": {
                        "description": "The `id` of the status, unique to a single tracking service.\n\n**WARNING:** Different tracking services may use the same `id` to represent different statuses.",
                        "type": "integer"
                    },
                    "displayName": {
                        "description": "The display name of this tracking status.",
                        "type": "string"
                    }
                },
                "example": {
                    "id": 5,
                    "displayName": "Plan to read"
                }
            },
            "tracking-score": {
                "description": "A score the user can assign to a manga in a tracking service.",
                "required": [
                    "id",
                    "score"
                ],
                "type": "object",
                "properties": {
                    "id": {
                        "description": "The `id` of the score, unique to a single tracking service.\n\n**WARNING:** Different tracking services may use the same `id` to represent different scores.",
                        "type": "integer"
                    },
                    "score": {
                        "format": "float",
                        "description": "How much *stars* or *points* this score actually represents. This is the value that should be used when displaying a score in the UI.\n\nWhen displaying a score chooser, the client should sort the scores by this value. A higher score represents a more *positive* rating.",
                        "type": "number"
                    }
                },
                "example": {
                    "id": 2,
                    "score": 1.5
                }
            },
            "url-handle-result": {
                "description": "The result of handling a URL with a `tachiyomi` scheme.\n\nThe `data` field will hold:\n- A JSON object of type `tracking-oauth-login` if the value of the `type` field is `TRACKING_LOGIN`",
                "required": [
                    "type"
                ],
                "type": "object",
                "properties": {
                    "type": {
                        "description": "The type of the URL.",
                        "enum": [
                            "TRACKING_LOGIN"
                        ]
                    },
                    "data": {
                        "description": "Additional information about the URL.",
                        "type": "string"
                    }
                }
            },
            "tracking-oauth-login": {
                "description": "The result of an OAuth login into a tracking service.",
                "required": [
                    "status",
                    "service"
                ],
                "type": "object",
                "properties": {
                    "service": {
                        "description": "The `id` of the service that was logged into.",
                        "type": "integer"
                    },
                    "status": {
                        "description": "The status of this login.",
                        "enum": [
                            "SUCCESSFUL",
                            "FAILED_UNKNOWN",
                            "FAILED_ALREADY_LOGGED_IN"
                        ]
                    }
                }
            },
            "tracking-search-result": {
                "description": "A single manga result when the user searches for manga in a tracking service. The client should never modify this object as it may need to be passed back to the server.",
                "required": [
                    "service",
                    "title"
                ],
                "type": "object",
                "properties": {
                    "service": {
                        "description": "The `id` of the service providing this search result.",
                        "type": "integer"
                    },
                    "extra": {
                        "description": "Information used by the server when this object is passed back to the server. Assume the values of this field to be opaque (the client should not attempt to parse it).\n\n*Notes for server used only (ignore if you are building a client):*\n\nContains the following `TrackSearch.kt` fields:\n- `media_id` - id of manga on tracker\n- `library_id` - id of manga in user library in tracker",
                        "type": "string"
                    },
                    "title": {
                        "description": "The title of the manga represented by this search result.",
                        "type": "string"
                    },
                    "chapters": {
                        "description": "The total amount of chapters in this manga.",
                        "type": "integer"
                    },
                    "trackingUrl": {
                        "description": "The url of this manga on the tracking service.",
                        "type": "string"
                    },
                    "coverUrl": {
                        "description": "The image URL of the cover of this manga on the tracking service.",
                        "type": "string"
                    },
                    "summary": {
                        "description": "A description of this manga on the tracking service.",
                        "type": "string"
                    },
                    "status": {
                        "description": "The publishing status of this manga (e.g. `Publishing` or `Completed`).",
                        "type": "string"
                    },
                    "type": {
                        "description": "The type of this manga. (e.g. `Manga` or `Webtoon`)",
                        "type": "string"
                    },
                    "startDate": {
                        "description": "The date this manga started publishing. Clients should not attempt to parse this date, it should be displayed directly in the UI.",
                        "type": "string"
                    }
                },
                "example": {
                    "service": 1,
                    "extra": "{media_id: 1923, library_id: 8}",
                    "title": "Danberu nan kiro moteru?",
                    "chapters": 58,
                    "trackingUrl": "https://kitsu.io/manga/dumbbell-nan-kilo-moteru",
                    "coverUrl": "https://media.kitsu.io/manga/poster_images/38750/large.jpg",
                    "summary": "Sakura Hibiki is your average high school girl, with a voracious appetite. Noticing her clothes tightening in lieu of her slowly expanding waistline she decides to look into enrolling in the nearby gym. There she runs into a girl from her grade named Souryuuin Akemi.\r\n\r\nAkemi, who has a muscle fetish tries to get Hibiki to enroll in the gym despite its high ratio of macho men. Thankfully a beautiful trainer, Machio, appears and unknowingly convinces her to enroll and start her quest to a great body.\r\n\r\n(Source: MU)",
                    "status": "Publishing",
                    "type": "Manga",
                    "startDate": "Aug 5, 2016"
                }
            },
            "track": {
                "description": "Tracking information associated with a manga.",
                "required": [
                    "lastChapterRead",
                    "totalChapters",
                    "status",
                    "service"
                ],
                "type": "object",
                "properties": {
                    "lastChapterRead": {
                        "description": "The last read chapter. `0` indicates that the user has not read any chapters yet.",
                        "type": "integer"
                    },
                    "totalChapters": {
                        "description": "The total number of chapters in this manga. `0` or any negative number indicates that it is unknown.",
                        "type": "integer"
                    },
                    "score": {
                        "description": "The id of the score the user has assigned to this manga.\n\nThe possible scores are provided in the `possibleScores` field of the tracking service.\n\nWhen not present, indicates the user has not yet assigned a score to this manga.",
                        "type": "integer"
                    },
                    "displayScore": {
                        "description": "The string the score the user assigned to this manga as should be displayed as on the UI.\n\nFor example, some sources display scores as happy/sad.\n\nWhen not present, indicates the user has not yet assigned a score to this manga.",
                        "type": "string"
                    },
                    "status": {
                        "description": "The id of the status the user has assigned to this manga.\n\nThe possible statuses are available in the `possibleStatuses` field in the tracking service.",
                        "type": "integer"
                    },
                    "trackingUrl": {
                        "description": "The url of this manga on the tracking service.",
                        "type": "string"
                    },
                    "service": {
                        "description": "The `id` of the tracking service that this track is connected to.",
                        "type": "integer"
                    }
                },
                "example": {
                    "lastChapterRead": 3,
                    "totalChapters": 58,
                    "score": 2,
                    "displayScore": "😊",
                    "status": 0,
                    "trackingUrl": "https://anilist.co/manga/97626/Dumbbell-Nan-Kilo-Moteru"
                }
            },
            "mutate-track-request": {
                "description": "A request to change tracking data.",
                "required": [
                    "lastChapterRead",
                    "status"
                ],
                "type": "object",
                "properties": {
                    "lastChapterRead": {
                        "description": "The last chapter read.\n\n`0` indicates that the user has not read any chapters yet.",
                        "type": "integer"
                    },
                    "score": {
                        "description": "The `id` of the score the user wishes to assign to this manga.\n\nThe possible scores are provided in the `possibleScores` field of the tracking service.\n\nLeave as `null` to assign no score to this manga.",
                        "type": "integer"
                    },
                    "status": {
                        "description": "The `id` of the status the user wishes to assign to this manga.\n\nThe possible statuses are available in the `possibleStatuses` field in the tracking service.",
                        "type": "integer"
                    }
                },
                "example": {
                    "lastChapterRead": 5,
                    "score": 3,
                    "status": 0
                }
            },
            "catalogue-filters": {
                "format": "binary",
                "description": "The filters for a source.\n\nThere are no OpenAPI docs for this data type as it is too difficult to express.",
                "type": "string",
                "example": "[  // List of filters (MUST be rendered in order on the page)\n\t{\n\t\t\"_cmaps\": {                     // Data on what Java types each JSON field is for internal use. \n                                           // DO NOT USE THIS as it can be removed/changed at any time\n                                           // without warning.\n                                           // This data MUST NOT be modified and MUST be retained when calling the search API with the filters JSON.\n\t\t\t\"name\": \"java.lang.String\"  // Example: The 'name' field is a Java String type\n\t\t},\n\t\t\"name\": \"Lorem ipsum\",          // The name of the header\n\t\t\"_type\": \"HEADER\"               // The type of the filter\n                                           // The HEADER filter is a single line of non-editable text used to provide information to the user\n\t},\n\t{\n\t\t\"_cmaps\": {\n\t\t\t\"name\": \"java.lang.String\"\n\t\t},\n\t\t\"name\": \"\",                     // Should be ignored in separator filters\n\t\t\"_type\": \"SEPARATOR\"            // The SEPARATOR filter is a horizontal line used to divide two sections of filters\n\t},\n\t{\n\t\t\"_cmaps\": {\n\t\t\t\"name\": \"java.lang.String\",\n\t\t\t\"state\": \"java.lang.Boolean\"\n\t\t},\n\t\t\"name\": \"Show R-18\",            // The name of the filter\n\t\t\"state\": true,                  // The initial state of the filter\n\t\t\"_type\": \"CHECKBOX\"             // The CHECKBOX filter is a two-state, toggleable filter\n\t},\n\t{\n\t\t\"_cmaps\": {\n\t\t\t\"name\": \"java.lang.String\",\n\t\t\t\"state\": \"java.lang.String\"\n\t\t},\n\t\t\"name\": \"Author\",               // The name of the filter\n\t\t\"state\": \"\",                    // The initial state of the filter\n\t\t\"_type\": \"TEXT\"                 // The TEXT filter is a single-line, editable text filter\n\t},\n\t{\n\t\t\"values\": [                     // All possible values of the filter\n\t\t\t\"All\",\n\t\t\t\"Japanese Manga\",\n\t\t\t\"Korean Manhwa\",\n\t\t\t\"Chinese Manhua\"\n\t\t],\n\t\t\"_cmaps\": {\n\t\t\t\"name\": \"java.lang.String\",\n\t\t\t\"state\": \"java.lang.Integer\"\n\t\t},\n\t\t\"name\": \"Type\",                 // The name of the filter\n\t\t\"state\": 0,                     // The initial state of the filter\n\t\t\"_type\": \"SELECT\"               // The SELECT filter is a drop-down, single-selection filter\n                                           // One (no more, no less) item can be selected at a time\n                                           // It's state is the index of the selected item (0-indexed)\n\t},\n\t{\n\t\t\"_cmaps\": {\n\t\t\t\"name\": \"java.lang.String\",\n\t\t\t\"state\": \"java.lang.Integer\"\n\t\t},\n\t\t\"name\": \"Completed\",            // The name of the filter\n\t\t\"state\": 0,                     // The initial state of the filter\n\t\t\"_type\": \"TRISTATE\"             // The TRISTATE filter is a triple-state filter\n                                           // Users can cycle through the three states:\n                                           // +-------+---------+\n                                           // | Index | State   |\n                                           // +-------+---------+\n                                           // | 0     | IGNORE  |\n                                           // | 1     | INCLUDE |\n                                           // | 2     | EXCLUDE |\n                                           // +-------+---------+\n\t},\n\t{\n\t\t\"state\": [\n\t\t\t{\n\t\t\t\t\"_cmaps\": {\n\t\t\t\t\t\"name\": \"java.lang.String\",\n\t\t\t\t\t\"state\": \"java.lang.Integer\"\n\t\t\t\t},\n\t\t\t\t\"name\": \"Action\",\n\t\t\t\t\"state\": 0,\n\t\t\t\t\"_type\": \"TRISTATE\"\n\t\t\t}\n\t\t],\n\t\t\"_cmaps\": {\n\t\t\t\"name\": \"java.lang.String\"\n\t\t},\n\t\t\"name\": \"Genres\",               // The name of the group\n\t\t\"_type\": \"GROUP\"                // The GROUP filter is used to group multiple filters together\n                                           // Although nested groups are currently not used, they may be supported in the future\n\t},\n\t{\n\t\t\"values\": [                     // All the different attributes we can sort by\n\t\t\t\"Series name\",\n\t\t\t\"Rating\",\n\t\t\t\"Views\",\n\t\t\t\"Total chapters\",\n\t\t\t\"Last chapter\"\n\t\t],\n\t\t\"state\": {                      // The initial state of the filter\n\t\t\t\"index\": 2,                 // The current attribute we are sorting by\n\t\t\t\"ascending\": false          // Are we sorting the attribute ascending or descending?\n\t\t},\n\t\t\"_cmaps\": {\n\t\t\t\"name\": \"java.lang.String\"\n\t\t},\n\t\t\"name\": \"Order by\",             // The name of the filters\n\t\t\"_type\": \"SORT\"                 // The SORT filters allows the user to sort by one (no more, no less) specific attribute\n                                           // The attribute can be sorted ascending or descending\n\t}\n]"
            },
            "preference": {
                "title": "Root Type for preference",
                "description": "A single preference.",
                "required": [
                    "key",
                    "value"
                ],
                "type": "object",
                "properties": {
                    "key": {
                        "description": "A unique key for the preference.",
                        "type": "string"
                    },
                    "value": {
                        "anyOf": [
                            {
                                "type": "string"
                            },
                            {
                                "type": "integer"
                            },
                            {
                                "type": "number"
                            },
                            {
                                "type": "boolean"
                            },
                            {
                                "type": "array",
                                "items": {
                                    "type": "string"
                                }
                            }
                        ]
                    }
                },
                "example": {
                    "key": "pref_reader_theme_key",
                    "value": "white"
                }
            },
            "mutate-preference-request": {
                "description": "A request to mutate a preference.",
                "required": [
                ],
                "type": "object",
                "properties": {
                    "value": {
                        "anyOf": [
                            {
                                "type": "string"
                            },
                            {
                                "type": "integer"
                            },
                            {
                                "type": "number"
                            },
                            {
                                "type": "boolean"
                            },
                            {
                                "type": "array",
                                "items": {
                                    "type": "string"
                                }
                            }
                        ],
                        "description": "The new value of the preference."
                    }
                }
            },
            "library-manga": {
                "description": "A wrapper around `manga` containing more useful information.",
                "required": [
                    "totalUnread",
                    "manga"
                ],
                "type": "object",
                "properties": {
                    "manga": {
                        "$ref": "#/components/schemas/manga"
                    },
                    "totalUnread": {
                        "description": "The amount of unread chapters in this manga.",
                        "type": "integer"
                    },
                    "totalDownloaded": {
                        "description": "The amount of downloaded chapters in this manga.\n\nWill only be present in some cases. Refer to the specific endpoint for more information.",
                        "type": "integer"
                    },
                    "lastReadIndex": {
                        "description": "The index this manga would have if it was in a list of all the library manga sorted by the time the manga was last read (most recent to least recent).\n\nWill only be present in some cases. Refer to the specific endpoint for more information. May also not be present if the manga was never read.",
                        "type": "integer"
                    },
                    "totalChaptersIndex": {
                        "description": "The index this manga would have if it was in a list of all the library manga sorted by the total amount of chapters the manga had (least chapters to most chapters).\n\nWill only be present in some cases. Refer to the specific endpoint for more information. Can also be `null` if the amount of chapters a manga has is unknown.",
                        "type": "integer"
                    }
                }
            },
            "sort-direction": {
                "description": "An enum representing sort direction.",
                "enum": [
                    "ASC",
                    "DESC"
                ]
            },
            "auth-token": {
                "description": "An authentication token.",
                "required": [
                    "id",
                    "deviceName",
                    "deviceId",
                    "platform"
                ],
                "type": "object",
                "properties": {
                    "id": {
                        "description": "The identifier of the auth token. \nNo two auth tokens will have the same authentication (even across multiple users).\n\nIdentifiers follow the ULID specification: https://github.com/ulid/spec.\nThis means that you can extract the time this token was generated out of the identifer as ULIDs contain a timestamp.",
                        "type": "string"
                    },
                    "secret": {
                        "description": "The authentication secret.\n\nWill only be present when the auth token is generated (and not when listing auth tokens).\n\nThis value is opaque, clients should not attempt to parse this value.",
                        "type": "string"
                    },
                    "deviceName": {
                        "description": "The name of the device that generated this auth token.",
                        "type": "string"
                    },
                    "deviceId": {
                        "description": "A unique identifier for this device.\n\nCan be opaque, the server will not parse this value.",
                        "type": "string"
                    },
                    "platform": {
                        "description": "The platform of the device that is generating this auth token.",
                        "enum": [
                            "ANDROID",
                            "IOS",
                            "WEB",
                            "WINDOWS",
                            "LINUX",
                            "MAC_OS"
                        ]
                    }
                },
                "example": {
                    "deviceId": "ba050454-c7aa-491a-8bf6-cddef657c03f",
                    "deviceName": "Joe Schmoe's Samsung Galaxy S10",
                    "id": "0123456789ABCDEFGHJKMNPQRSTVWXYZ",
                    "platform": "ANDROID",
                    "secret": "96ca77e9412cc7c5a6bef55133ed4345e03fb3f1a13933a0e5b61804595ff61b8dba7d15418d26b897aecc54d02b99c039f985749a929f0d84cef82fe5696c15"
                }
            },
            "sync-request": {
                "description": "A sync request.",
                "required": [
                    "version",
                    "events"
                ],
                "type": "object",
                "properties": {
                    "version": {
                        "description": "The sync specification version the client implements.\n\nNote that this number is different from the API version.",
                        "type": "integer"
                    },
                    "events": {
                        "description": "The sync events, in order from most recent to least recent.\n\nThe ordering of the events is used to order events that occur in the same millisecond (should rarely be needed).",
                        "type": "array",
                        "items": {
                            "$ref": "#/components/schemas/sync-event"
                        }
                    }
                },
                "example": {
                    "version": 1,
                    "events": [
                        {
                            "t": "EDIT_CATEGORY",
                            "r": 1554194924789,
                            "name": "completed",
                            "order": 2
                        },
                        {
                            "t": "EDIT_CATEGORY",
                            "r": 1554194924789,
                            "name": "dropped",
                            "order": 1
                        },
                        {
                            "t": "CREATE_CATEGORY",
                            "r": 1554194103643,
                            "name": "dropped",
                            "order": 2,
                            "updateInterval": 1176
                        }
                    ]
                }
            },
            "sync-event": {
                "description": "A sync event.\n\nSync events may have more fields that just the ones specified here.",
                "required": [
                    "r",
                    "t"
                ],
                "type": "object",
                "properties": {
                    "t": {
                        "description": "The type of this event.",
                        "type": "string"
                    },
                    "r": {
                        "format": "int64",
                        "description": "The time in milliseconds since epoch this sync event was recorded.",
                        "type": "integer"
                    }
                },
                "example": {
                    "t": "CREATE_CATEGORY",
                    "r": 1554194103643,
                    "name": "dropped",
                    "order": 2,
                    "updateInterval": 1176
                }
            },
            "sync-response": {
                "description": "A sync response.",
                "required": [
                    "events"
                ],
                "type": "object",
                "properties": {
                    "events": {
                        "description": "The events the client should apply.",
                        "type": "array",
                        "items": {
                            "$ref": "#/components/schemas/sync-event"
                        }
                    }
                },
                "example": {
                    "events": [
                        {
                            "t": "CREATE_MANGA",
                            "r": 1554195011312,
                            "sourceId": 1207429308912,
                            "key": "/title/17709/kumo-desu-ga-nani-ka",
                            "title": "Kumo Desu ga, Nani ka?",
                            "cover": "https://mangadex.org/images/manga/17709.jpg?1547694253"
                        }
                    ]
                }
            },
            "create-auth-token-request": {
                "description": "A request to create an authentication token.",
                "required": [
                    "deviceId",
                    "deviceName",
                    "platform"
                ],
                "type": "object",
                "properties": {
                    "deviceId": {
                        "description": "A unique identifier for this device.\n\nCan be opaque, the server will not parse this value.",
                        "type": "string"
                    },
                    "deviceName": {
                        "description": "The name of the device that generated this auth token.",
                        "type": "string"
                    },
                    "platform": {
                        "description": "The platform of the device that is generating this auth token.",
                        "enum": [
                            "ANDROID",
                            "IOS",
                            "WEB",
                            "WINDOWS",
                            "LINUX",
                            "MAC_OS"
                        ]
                    }
                },
                "example": {
                    "deviceId": "ba050454-c7aa-491a-8bf6-cddef657c03f",
                    "deviceName": "Joe Schmoe's Samsung Galaxy S10",
                    "platform": "ANDROID"
                }
            },
            "batch-mutate-category-request": {
                "description": "A request to create/edit a category, used in the category batch endpoints.",
                "required": [
                    "id"
                ],
                "type": "object",
                "properties": {
                    "name": {
                        "description": "The name of the category.\n\nMust be unique across all categories (case-insensitive, two categories are considered the same if their only difference is different casing).",
                        "type": "string"
                    },
                    "order": {
                        "format": "int32",
                        "description": "Categories are sorted ascending by this number.\n\nMust be unique across all categories.\n\nDefaults to the `maximum order of all existing categories + 1`.",
                        "type": "integer"
                    },
                    "id": {
                        "format": "int32",
                        "description": "The id of the category to edit.",
                        "type": "integer"
                    }
                },
                "example": {
                    "id": 1,
                    "name": "Dropped",
                    "order": 1
                }
            }
        },
        "securitySchemes": {
            "account": {
                "scheme": "basic",
                "type": "http",
                "description": "Username/password authentication using HTTP BASIC."
            },
            "account-cookie": {
                "type": "apiKey",
                "description": "Provide the credentials in the following format: `{USERNAME} {BASE64 ENCODED PASSWORD}`.",
                "name": "TW-Auth-Account",
                "in": "cookie"
            },
            "auth-token-header": {
                "type": "apiKey",
                "description": "Authenticate using an auth token secret obtained from `POST /api/v3/auth/tokens` in a request header.",
                "name": "TW-Auth-Token",
                "in": "header"
            },
            "auth-token-cookie": {
                "type": "apiKey",
                "description": "Authenticate using an auth token secret obtained from `POST /api/v3/auth/tokens` in a cookie.",
                "name": "TW-Auth-Token",
                "in": "cookie"
            }
        }
    },
    "security": [
        {
            "account": [
            ]
        },
        {
            "account-cookie": [
            ]
        },
        {
            "auth-token-header": [
            ]
        },
        {
            "auth-token-cookie": [
            ]
        }
    ]
}