/** MangaRequest */ interface MangaRequestSchema { title: LocalizedStringSchema; altTitles: LocalizedStringSchema[]; description: LocalizedStringSchema; authors: string[]; artists: string[]; links: Record; /** @pattern ^[a-z]{2}(-[a-z]{2})?$ */ originalLanguage: string; lastVolume: string | null; lastChapter: string | null; publicationDemographic: "shounen" | "shoujo" | "josei" | "seinen" | null; status: "completed" | "ongoing" | "cancelled" | "hiatus"; /** * Year of release * @min 1 * @max 9999 */ year: number | null; contentRating: "safe" | "suggestive" | "erotica" | "pornographic"; chapterNumbersResetOnNewVolume: boolean; tags: string[]; /** @format uuid */ primaryCover: string | null; /** @min 1 */ version: number; } /** LocalizedString */ type LocalizedStringSchema = Record; /** MangaResponse */ interface MangaResponseSchema { result: "ok" | "error"; /** @default "entity" */ response: string; data: MangaSchema; } /** Relationship */ interface RelationshipSchema { /** @format uuid */ id: string; type: string; /** Related Manga type, only present if you are on a Manga entity and a Manga relationship */ related: "monochrome" | "main_story" | "adapted_from" | "based_on" | "prequel" | "side_story" | "doujinshi" | "same_franchise" | "shared_universe" | "sequel" | "spin_off" | "alternate_story" | "alternate_version" | "preserialization" | "colored" | "serialization"; /** If Reference Expansion is applied, contains objects attributes */ attributes: object | null; } /** Chapter */ interface ChapterSchema { /** @format uuid */ id: string; type: "chapter"; attributes: ChapterAttributesSchema; relationships: RelationshipSchema[]; } /** Manga */ interface MangaSchema { /** @format uuid */ id: string; type: "manga"; attributes: MangaAttributesSchema; relationships: RelationshipSchema[]; } /** ChapterAttributes */ interface ChapterAttributesSchema { /** @maxLength 255 */ title: string | null; volume: string | null; /** @maxLength 8 */ chapter: string | null; /** Count of readable images for this chapter */ pages: number; /** @pattern ^[a-z]{2}(-[a-z]{2})?$ */ translatedLanguage: string; /** @format uuid */ uploader: string; /** * Denotes a chapter that links to an external source. * @maxLength 512 * @pattern ^https?:// */ externalUrl: string | null; /** @min 1 */ version: number; /** @format date-time */ createdAt: Date; /** @format date-time */ updatedAt: Date; /** @format date-time */ publishAt: Date; /** @format date-time */ readableAt: Date; isUnavailable: boolean; } /** MangaAttributes */ interface MangaAttributesSchema { title: LocalizedStringSchema; altTitles: LocalizedStringSchema[]; description: LocalizedStringSchema; isLocked: boolean; links: Record; originalLanguage: string; lastVolume: string | null; lastChapter: string | null; publicationDemographic: "shounen" | "shoujo" | "josei" | "seinen" | null; status: "completed" | "ongoing" | "cancelled" | "hiatus"; /** Year of release */ year: number | null; contentRating: "safe" | "suggestive" | "erotica" | "pornographic"; chapterNumbersResetOnNewVolume: boolean; availableTranslatedLanguages: string[]; /** @format uuid */ latestUploadedChapter: string; tags: TagSchema[]; state: "draft" | "submitted" | "published" | "rejected"; /** @min 1 */ version: number; /** @format date-time */ createdAt: Date; /** @format date-time */ updatedAt: Date; } type MangaCreateSchema = MangaRequestSchema; type MangaEditSchema = MangaRequestSchema; type ChapterEditSchema = ChapterRequestSchema; /** Response */ interface ResponseSchema { result: "ok" | "error"; } /** ScanlationGroup */ interface ScanlationGroupSchema { /** @format uuid */ id: string; type: "scanlation_group"; attributes: ScanlationGroupAttributesSchema; relationships: RelationshipSchema[]; } /** ScanlationGroupAttributes */ interface ScanlationGroupAttributesSchema { name: string; altNames: LocalizedStringSchema[]; website: string | null; ircServer: string | null; ircChannel: string | null; discord: string | null; contactEmail: string | null; description: string | null; /** * @format uri * @pattern ^https?:// */ twitter: string | null; /** * @format uri * @maxLength 128 * @pattern ^https:\/\/www\.mangaupdates\.com\/(group|publisher)(s\.html\?id=\d+|\/[\w-]+\/?([\w-]+)?(\/)?)$ */ mangaUpdates: string | null; focusedLanguage: string[] | null; locked: boolean; official: boolean; verified: boolean; inactive: boolean; exLicensed: boolean; /** * Should respected ISO 8601 duration specification: https://en.wikipedia.org/wiki/ISO_8601#Durations * @pattern ^(P([1-9]|[1-9][0-9])D)?(P?([1-9])W)?(P?T(([1-9]|1[0-9]|2[0-4])H)?(([1-9]|[1-5][0-9]|60)M)?(([1-9]|[1-5][0-9]|60)S)?)?$ * @example "P4D" */ publishDelay: string; /** @min 1 */ version: number; /** @format date-time */ createdAt: Date; /** @format date-time */ updatedAt: Date; } /** User */ interface UserSchema { /** @format uuid */ id: string; type: "user"; attributes: UserAttributesSchema; relationships: RelationshipSchema[]; } /** UserAttributes */ interface UserAttributesSchema { username: string; roles: string[]; /** @min 1 */ version: number; } /** CreateScanlationGroup */ interface CreateScanlationGroupSchema { name: string; website?: string | null; ircServer?: string | null; ircChannel?: string | null; discord?: string | null; contactEmail?: string | null; description?: string | null; /** * @format uri * @pattern ^https?://twitter\.com */ twitter?: string | null; /** * @maxLength 128 * @pattern ^https:\/\/www\.mangaupdates\.com\/(group|publisher)(s\.html\?id=\d+|\/[\w-]+\/?([\w-]+)?(\/)?)$ */ mangaUpdates?: string | null; inactive?: boolean; /** @pattern ^P(([1-9]|[1-9][0-9])D)?(([1-9])W)?(T(([1-9]|1[0-9]|2[0-4])H)?(([1-9]|[1-5][0-9]|60)M)?(([1-9]|[1-5][0-9]|60)S)?)?$ */ publishDelay?: string | null; } /** CustomListCreate */ interface CustomListCreateSchema { name: string; visibility?: "public" | "private"; manga?: string[]; /** @min 1 */ version?: number; } /** CustomList */ interface CustomListSchema { /** @format uuid */ id: string; type: "custom_list"; attributes: CustomListAttributesSchema; relationships: RelationshipSchema[]; } /** CustomListAttributes */ interface CustomListAttributesSchema { name: string; visibility: "private" | "public"; /** @min 1 */ version: number; } /** CoverResponse */ interface CoverResponseSchema { result: string; /** @default "entity" */ response: string; data: CoverSchema; } /** Cover */ interface CoverSchema { /** @format uuid */ id: string; type: "cover_art"; attributes: CoverAttributesSchema; relationships: RelationshipSchema[]; } /** CoverAttributes */ interface CoverAttributesSchema { volume: string | null; fileName: string; description: string | null; locale: string | null; /** @min 1 */ version: number; /** @format date-time */ createdAt: Date; /** @format date-time */ updatedAt: Date; } /** CoverEdit */ interface CoverEditSchema { volume: CoverVolumeSchema; /** * @minLength 0 * @maxLength 512 */ description?: string | null; /** @pattern ^[a-z]{2}(-[a-z]{2})?$ */ locale?: string | null; /** @min 1 */ version: number; } /** * CoverVolume * @maxLength 8 * @pattern ^(0|[1-9]\d*)(\.\d+)?([a-z]+)?$ */ type CoverVolumeSchema = string | null; /** * ChapterVolume * @maxLength 8 * @pattern ^((0|[1-9]\d*)(\.\d+)?[a-z]?)?$ */ type ChapterVolumeSchema = string | null; /** Author */ interface AuthorSchema { /** @format uuid */ id: string; type: "author"; attributes: AuthorAttributesSchema; relationships: RelationshipSchema[]; } /** AuthorAttributes */ interface AuthorAttributesSchema { name: string; imageUrl: string | null; biography: LocalizedStringSchema; /** * @format uri * @pattern ^https?://twitter\.com(/|$) */ twitter: string | null; /** * @format uri * @pattern ^https?://([\w-]+\.)?pixiv\.net(/|$) */ pixiv: string | null; /** * @format uri * @pattern ^https?://([\w-]+\.)?melonbooks\.co\.jp(/|$) */ melonBook: string | null; /** * @format uri * @pattern ^https?://([\w-]+\.)?fanbox\.cc(/|$) */ fanBox: string | null; /** * @format uri * @pattern ^https?://([\w-]+\.)?booth\.pm(/|$) */ booth: string | null; /** * @format uri * @pattern ^https?://([\w-]+\.)?nicovideo\.jp(/|$) */ nicoVideo: string | null; /** * @format uri * @pattern ^https?://([\w-]+\.)?skeb\.jp(/|$) */ skeb: string | null; /** * @format uri * @pattern ^https?://([\w-]+\.)?fantia\.jp(/|$) */ fantia: string | null; /** * @format uri * @pattern ^https?://([\w-]+\.)?tumblr\.com(/|$) */ tumblr: string | null; /** * @format uri * @pattern ^https?://www\.youtube\.com(/|$) */ youtube: string | null; /** * @format uri * @pattern ^https?://([\w-]+\.)?weibo\.(cn|com)(/|$) */ weibo: string | null; /** * @format uri * @pattern ^https?://([\w-]+\.)?naver\.com(/|$) */ naver: string | null; /** * @format uri * @pattern ^https?://([\w-]+\.)?namicomi\.com(/|$) */ namicomi: string | null; /** * @format uri * @pattern ^https?:// */ website: string | null; /** @min 1 */ version: number; /** @format date-time */ createdAt: Date; /** @format date-time */ updatedAt: Date; } /** AuthorCreate */ interface AuthorCreateSchema { name: string; biography?: LocalizedStringSchema; /** * @format uri * @pattern ^https?://twitter\.com(/|$) */ twitter?: string | null; /** * @format uri * @pattern ^https?://([\w-]+\.)?pixiv\.net(/|$) */ pixiv?: string | null; /** * @format uri * @pattern ^https?://([\w-]+\.)?melonbooks\.co\.jp(/|$) */ melonBook?: string | null; /** * @format uri * @pattern ^https?://([\w-]+\.)?fanbox\.cc(/|$) */ fanBox?: string | null; /** * @format uri * @pattern ^https?://([\w-]+\.)?booth\.pm(/|$) */ booth?: string | null; /** * @format uri * @pattern ^https?://([\w-]+\.)?nicovideo\.jp(/|$) */ nicoVideo?: string | null; /** * @format uri * @pattern ^https?://([\w-]+\.)?skeb\.jp(/|$) */ skeb?: string | null; /** * @format uri * @pattern ^https?://([\w-]+\.)?fantia\.jp(/|$) */ fantia?: string | null; /** * @format uri * @pattern ^https?://([\w-]+\.)?tumblr\.com(/|$) */ tumblr?: string | null; /** * @format uri * @pattern ^https?://www\.youtube\.com(/|$) */ youtube?: string | null; /** * @format uri * @pattern ^https?://([\w-]+\.)?weibo\.(cn|com)(/|$) */ weibo?: string | null; /** * @format uri * @pattern ^https?://([\w-]+\.)?naver\.com(/|$) */ naver?: string | null; /** * @format uri * @pattern ^https?:// */ website?: string | null; } /** MappingIdBody */ interface MappingIdBodySchema { type: "group" | "manga" | "chapter" | "tag"; ids: number[]; } /** TagResponse */ interface TagResponseSchema { /** @default "ok" */ result: string; /** @default "collection" */ response: string; data: TagSchema[]; limit: number; offset: number; total: number; } /** Tag */ interface TagSchema { /** @format uuid */ id: string; type: "tag"; attributes: TagAttributesSchema; relationships: RelationshipSchema[]; } /** TagAttributes */ interface TagAttributesSchema { name: LocalizedStringSchema; description: LocalizedStringSchema; group: "content" | "format" | "genre" | "theme"; /** @min 1 */ version: number; } /** UserResponse */ interface UserResponseSchema { result: "ok"; /** @default "entity" */ response: string; data: UserSchema; } /** UpdateMangaStatus */ interface UpdateMangaStatusSchema { status: "reading" | "on_hold" | "plan_to_read" | "dropped" | "re_reading" | "completed" | null; } /** ChapterRequest */ interface ChapterRequestSchema { /** @maxLength 255 */ title: string | null; volume: ChapterVolumeSchema; chapter: ChapterVolumeSchema; /** @pattern ^[a-z]{2}(-[a-z]{2})?$ */ translatedLanguage: string; /** @maxItems 10 */ groups: string[]; /** @min 1 */ version: number; } /** CoverList */ interface CoverListSchema { /** @default "ok" */ result: string; /** @default "collection" */ response: string; data: CoverSchema[]; limit: number; offset: number; total: number; } /** ChapterList */ interface ChapterListSchema { /** @default "ok" */ result: string; /** @default "collection" */ response: string; data: ChapterSchema[]; limit: number; offset: number; total: number; } /** ScanlationGroupList */ interface ScanlationGroupListSchema { /** @default "ok" */ result: string; /** @default "collection" */ response: string; data: ScanlationGroupSchema[]; limit: number; offset: number; total: number; } type MangaRelationCreateSchema = MangaRelationRequestSchema; /** MangaRelationRequest */ interface MangaRelationRequestSchema { /** @format uuid */ targetManga: string; relation: "monochrome" | "main_story" | "adapted_from" | "based_on" | "prequel" | "side_story" | "doujinshi" | "same_franchise" | "shared_universe" | "sequel" | "spin_off" | "alternate_story" | "alternate_version" | "preserialization" | "colored" | "serialization"; } /** MangaRelationList */ interface MangaRelationListSchema { /** @default "ok" */ result: string; /** @default "collection" */ response: string; data: MangaRelationSchema[]; limit: number; offset: number; total: number; } /** MangaRelationResponse */ interface MangaRelationResponseSchema { result: "ok" | "error"; /** @default "entity" */ response: string; data: MangaRelationSchema; } /** MangaRelation */ interface MangaRelationSchema { /** @format uuid */ id: string; type: "manga_relation"; attributes: MangaRelationAttributesSchema; relationships: RelationshipSchema[]; } /** MangaRelationAttributes */ interface MangaRelationAttributesSchema { relation: "monochrome" | "main_story" | "adapted_from" | "based_on" | "prequel" | "side_story" | "doujinshi" | "same_franchise" | "shared_universe" | "sequel" | "spin_off" | "alternate_story" | "alternate_version" | "preserialization" | "colored" | "serialization"; /** @min 1 */ version: number; } /** MangaList */ interface MangaListSchema { /** @default "ok" */ result: string; /** @default "collection" */ response: string; data: MangaSchema[]; limit: number; offset: number; total: number; } /** CustomListList */ interface CustomListListSchema { /** @default "ok" */ result: string; /** @default "collection" */ response: string; data: CustomListSchema[]; limit: number; offset: number; total: number; } /** UserList */ interface UserListSchema { /** @default "ok" */ result: string; /** @default "collection" */ response: string; data: UserSchema[]; limit: number; offset: number; total: number; } /** UploadSession */ interface UploadSessionSchema { /** @format uuid */ id: string; type: "upload_session"; attributes: UploadSessionAttributesSchema; } /** UploadSessionAttributes */ interface UploadSessionAttributesSchema { isCommitted: boolean; isProcessed: boolean; isDeleted: boolean; /** @min 1 */ version: number; /** @format date-time */ createdAt: Date; /** @format date-time */ updatedAt: Date; } /** UploadSessionFile */ interface UploadSessionFileSchema { /** @format uuid */ id: string; type: "upload_session_file"; attributes: UploadSessionFileAttributesSchema; } /** UploadSessionFileAttributes */ interface UploadSessionFileAttributesSchema { originalFileName: string; fileHash: string; fileSize: number; mimeType: string; source: "local" | "remote"; /** @min 1 */ version: number; } /** ChapterReadMarkersBatch */ type ChapterReadMarkerBatchSchema = { chapterIdsRead: string[]; chapterIdsUnread: string[]; }; interface ChapterDraftSchema { volume: ChapterVolumeSchema; chapter: ChapterVolumeSchema; /** @maxLength 255 */ title: string | null; /** @pattern ^[a-z]{2}(-[a-z]{2})?$ */ translatedLanguage: string; /** * @maxLength 512 * @pattern ^https?:// */ externalUrl?: string | null; /** * @format date-time * @pattern ^\d{4}-[0-1]\d-([0-2]\d|3[0-1])T([0-1]\d|2[0-3]):[0-5]\d:[0-5]\d$ */ publishAt?: Date; } /** * ReferenceExpansionAuthor * Reference expansion options for author/artist entities or lists */ type ReferenceExpansionAuthorSchema = "manga"[]; /** * ReferenceExpansionChapter * Reference expansion options for chapter entities or lists */ type ReferenceExpansionChapterSchema = ("manga" | "scanlation_group" | "user")[]; /** * ReferenceExpansionCoverArt * Reference expansion options for cover art entities or lists */ type ReferenceExpansionCoverArtSchema = ("manga" | "user")[]; /** * ReferenceExpansionManga * Reference expansion options for manga entities or lists */ type ReferenceExpansionMangaSchema = ("manga" | "cover_art" | "author" | "artist" | "tag" | "creator")[]; /** * ReferenceExpansionMangaRelation * Reference expansion options for manga relation entities or lists */ type ReferenceExpansionMangaRelationSchema = "manga"[]; /** * ReferenceExpansionScanlationGroup * Reference expansion options for scanlation group entities or lists */ type ReferenceExpansionScanlationGroupSchema = ("leader" | "member")[]; /** * StatisticsDetailsComments * Comments-related statistics of an entity. * If it is `null`, the entity doesn't have a backing comments thread, and therefore has no comments yet. */ type StatisticsDetailsCommentsSchema = { /** * The id of the thread backing the comments for that entity on the MangaDex Forums. * @min 1 */ threadId: number; /** * The number of replies on the MangaDex Forums thread backing this entity's comments. This excludes the initial comment that opens the thread, which is created by our systems. * @min 0 */ repliesCount: number; } | null; interface GetSearchMangaParamsSchema { /** * @min 0 * @max 100 * @default 10 * @pattern ^\d+$ */ limit: number; /** * @min 0 * @pattern ^\d+$ */ offset: number; title: string; /** @format uuid */ authorOrArtist: string; authors: string[]; artists: string[]; /** Year of release or none */ year: number | "none"; includedTags: string[]; /** @default "AND" */ includedTagsMode: "AND" | "OR"; excludedTags: string[]; /** @default "OR" */ excludedTagsMode: "AND" | "OR"; status: ("ongoing" | "completed" | "hiatus" | "cancelled")[]; originalLanguage: string[]; excludedOriginalLanguage: string[]; availableTranslatedLanguage: string[]; publicationDemographic: ("shounen" | "shoujo" | "josei" | "seinen" | "none")[]; /** Manga ids (limited to 100 per request) */ ids: string[]; /** @default ["safe","suggestive","erotica"] */ contentRating: ("safe" | "suggestive" | "erotica" | "pornographic")[]; /** * DateTime string with following format: YYYY-MM-DDTHH:MM:SS in timezone UTC+0 * @pattern ^\d{4}-[0-1]\d-([0-2]\d|3[0-1])T([0-1]\d|2[0-3]):[0-5]\d:[0-5]\d$ */ createdAtSince: string; /** * DateTime string with following format: YYYY-MM-DDTHH:MM:SS in timezone UTC+0 * @pattern ^\d{4}-[0-1]\d-([0-2]\d|3[0-1])T([0-1]\d|2[0-3]):[0-5]\d:[0-5]\d$ */ updatedAtSince: string; /** @default {"latestUploadedChapter":"desc"} */ order: { title?: "asc" | "desc"; year?: "asc" | "desc"; createdAt?: "asc" | "desc"; updatedAt?: "asc" | "desc"; latestUploadedChapter?: "asc" | "desc"; followedCount?: "asc" | "desc"; relevance?: "asc" | "desc"; rating?: "asc" | "desc"; }; /** Reference expansion options for manga entities or lists */ includes: ReferenceExpansionMangaSchema; hasAvailableChapters: boolean; hasUnavailableChapters: "0" | "1"; /** @format uuid */ group: string; } interface GetSearchGroupParamsSchema { /** * @min 0 * @max 100 * @default 10 */ limit: number; /** @min 0 */ offset: number; /** ScanlationGroup ids (limited to 100 per request) */ ids: string[]; name: string; focusedLanguage: string; /** Reference expansion options for scanlation group entities or lists */ includes: ReferenceExpansionScanlationGroupSchema; /** @default {"latestUploadedChapter":"desc"} */ order: { name?: "asc" | "desc"; createdAt?: "asc" | "desc"; updatedAt?: "asc" | "desc"; followedCount?: "asc" | "desc"; relevance?: "asc" | "desc"; }; } interface GetUserParamsSchema { /** * @min 0 * @max 100 * @default 10 */ limit: number; /** @min 0 */ offset: number; /** User ids (limited to 100 per request) */ ids: string[]; username: string; order: { username?: "asc" | "desc"; }; } interface GetChapterParamsSchema { /** * @min 0 * @max 100 * @default 10 */ limit: number; /** @min 0 */ offset: number; /** Chapter ids (limited to 100 per request) */ ids: string[]; title: string; groups: string[]; uploader: string | string[]; /** @format uuid */ manga: string; volume: string | string[]; chapter: string | string[]; translatedLanguage: string[]; originalLanguage: string[]; excludedOriginalLanguage: string[]; /** @default ["safe","suggestive","erotica"] */ contentRating: ("safe" | "suggestive" | "erotica" | "pornographic")[]; excludedGroups: string[]; excludedUploaders: string[]; /** @default "1" */ includeFutureUpdates: "0" | "1"; includeEmptyPages: 0 | 1; includeFuturePublishAt: 0 | 1; includeExternalUrl: 0 | 1; /** @default "0" */ includeUnavailable: "0" | "1"; /** * DateTime string with following format: YYYY-MM-DDTHH:MM:SS in timezone UTC+0 * @pattern ^\d{4}-[0-1]\d-([0-2]\d|3[0-1])T([0-1]\d|2[0-3]):[0-5]\d:[0-5]\d$ */ createdAtSince: string; /** * DateTime string with following format: YYYY-MM-DDTHH:MM:SS in timezone UTC+0 * @pattern ^\d{4}-[0-1]\d-([0-2]\d|3[0-1])T([0-1]\d|2[0-3]):[0-5]\d:[0-5]\d$ */ updatedAtSince: string; /** * DateTime string with following format: YYYY-MM-DDTHH:MM:SS in timezone UTC+0 * @pattern ^\d{4}-[0-1]\d-([0-2]\d|3[0-1])T([0-1]\d|2[0-3]):[0-5]\d:[0-5]\d$ */ publishAtSince: string; order: { createdAt?: "asc" | "desc"; updatedAt?: "asc" | "desc"; publishAt?: "asc" | "desc"; readableAt?: "asc" | "desc"; volume?: "asc" | "desc"; chapter?: "asc" | "desc"; }; includes: ("manga" | "scanlation_group" | "user")[]; } interface GetListIdFeedParamsSchema { /** * @min 1 * @max 500 * @default 100 */ limit: number; /** @min 0 */ offset: number; translatedLanguage: string[]; originalLanguage: string[]; excludedOriginalLanguage: string[]; /** @default ["safe","suggestive","erotica"] */ contentRating: ("safe" | "suggestive" | "erotica" | "pornographic")[]; excludedGroups: string[]; excludedUploaders: string[]; /** @default "1" */ includeFutureUpdates: "0" | "1"; /** * DateTime string with following format: YYYY-MM-DDTHH:MM:SS in timezone UTC+0 * @pattern ^\d{4}-[0-1]\d-([0-2]\d|3[0-1])T([0-1]\d|2[0-3]):[0-5]\d:[0-5]\d$ */ createdAtSince: string; /** * DateTime string with following format: YYYY-MM-DDTHH:MM:SS in timezone UTC+0 * @pattern ^\d{4}-[0-1]\d-([0-2]\d|3[0-1])T([0-1]\d|2[0-3]):[0-5]\d:[0-5]\d$ */ updatedAtSince: string; /** * DateTime string with following format: YYYY-MM-DDTHH:MM:SS in timezone UTC+0 * @pattern ^\d{4}-[0-1]\d-([0-2]\d|3[0-1])T([0-1]\d|2[0-3]):[0-5]\d:[0-5]\d$ */ publishAtSince: string; order: { createdAt?: "asc" | "desc"; updatedAt?: "asc" | "desc"; publishAt?: "asc" | "desc"; readableAt?: "asc" | "desc"; volume?: "asc" | "desc"; chapter?: "asc" | "desc"; }; /** Reference expansion options for chapter entities or lists */ includes: ReferenceExpansionChapterSchema; includeEmptyPages: 0 | 1; includeFuturePublishAt: 0 | 1; includeExternalUrl: 0 | 1; /** @default "0" */ includeUnavailable: "0" | "1"; /** @format uuid */ id: string; } interface GetCoverParamsSchema { /** * @min 0 * @max 100 * @default 10 */ limit: number; /** @min 0 */ offset: number; /** Manga ids (limited to 100 per request) */ manga: string[]; /** Covers ids (limited to 100 per request) */ ids: string[]; /** User ids (limited to 100 per request) */ uploaders: string[]; /** Locales of cover art (limited to 100 per request) */ locales: string[]; order: { createdAt?: "asc" | "desc"; updatedAt?: "asc" | "desc"; volume?: "asc" | "desc"; }; /** Reference expansion options for cover art entities or lists */ includes: ReferenceExpansionCoverArtSchema; } interface GetAuthorParamsSchema { /** * @min 0 * @max 100 * @default 10 */ limit: number; /** @min 0 */ offset: number; /** Author ids (limited to 100 per request) */ ids: string[]; name: string; order: { name?: "asc" | "desc"; }; /** Reference expansion options for author/artist entities or lists */ includes: ReferenceExpansionAuthorSchema; } interface GetMangaRandomParamsSchema { /** Reference expansion options for manga entities or lists */ includes: ReferenceExpansionMangaSchema; /** @default ["safe","suggestive","erotica"] */ contentRating: ("safe" | "suggestive" | "erotica" | "pornographic")[]; includedTags: string[]; /** @default "AND" */ includedTagsMode: "AND" | "OR"; excludedTags: string[]; /** @default "OR" */ excludedTagsMode: "AND" | "OR"; } interface GetMangaDraftsParamsSchema { /** * @min 1 * @max 100 * @default 10 */ limit: number; /** @min 0 */ offset: number; state: "draft" | "submitted" | "rejected"; /** @default {"createdAt":"desc"} */ order: { title?: "asc" | "desc"; year?: "asc" | "desc"; createdAt?: "asc" | "desc"; updatedAt?: "asc" | "desc"; }; /** Reference expansion options for manga entities or lists */ includes: ReferenceExpansionMangaSchema; } declare namespace Manga$1 { /** * @description Search a list of Manga. * @tags Manga * @name GetSearchManga * @summary Manga list * @request GET:/manga */ namespace GetSearchManga { type RequestParams = {}; type RequestQuery = { /** * @min 0 * @max 100 * @default 10 * @pattern ^\d+$ */ limit?: number; /** * @min 0 * @pattern ^\d+$ */ offset?: number; title?: string; /** @format uuid */ authorOrArtist?: string; authors?: string[]; artists?: string[]; /** Year of release or none */ year?: number | "none"; includedTags?: string[]; /** @default "AND" */ includedTagsMode?: "AND" | "OR"; excludedTags?: string[]; /** @default "OR" */ excludedTagsMode?: "AND" | "OR"; status?: ("ongoing" | "completed" | "hiatus" | "cancelled")[]; originalLanguage?: string[]; excludedOriginalLanguage?: string[]; availableTranslatedLanguage?: string[]; publicationDemographic?: ("shounen" | "shoujo" | "josei" | "seinen" | "none")[]; /** Manga ids (limited to 100 per request) */ ids?: string[]; /** @default ["safe","suggestive","erotica"] */ contentRating?: ("safe" | "suggestive" | "erotica" | "pornographic")[]; /** * DateTime string with following format: YYYY-MM-DDTHH:MM:SS in timezone UTC+0 * @pattern ^\d{4}-[0-1]\d-([0-2]\d|3[0-1])T([0-1]\d|2[0-3]):[0-5]\d:[0-5]\d$ */ createdAtSince?: string; /** * DateTime string with following format: YYYY-MM-DDTHH:MM:SS in timezone UTC+0 * @pattern ^\d{4}-[0-1]\d-([0-2]\d|3[0-1])T([0-1]\d|2[0-3]):[0-5]\d:[0-5]\d$ */ updatedAtSince?: string; /** @default {"latestUploadedChapter":"desc"} */ order?: { title?: "asc" | "desc"; year?: "asc" | "desc"; createdAt?: "asc" | "desc"; updatedAt?: "asc" | "desc"; latestUploadedChapter?: "asc" | "desc"; followedCount?: "asc" | "desc"; relevance?: "asc" | "desc"; rating?: "asc" | "desc"; }; /** Reference expansion options for manga entities or lists */ includes?: ReferenceExpansionMangaSchema; hasAvailableChapters?: "0" | "1" | "true" | "false"; hasUnavailableChapters?: "0" | "1"; /** @format uuid */ group?: string; }; type RequestBody = never; type RequestHeaders = {}; type ResponseBody = MangaListSchema; } /** * @description Create a new Manga. * @tags Manga * @name PostManga * @summary Create Manga * @request POST:/manga * @secure */ namespace PostManga { type RequestParams = {}; type RequestQuery = {}; type RequestBody = MangaCreateSchema; type RequestHeaders = { /** @default "application/json" */ "Content-Type": string; }; type ResponseBody = MangaResponseSchema; } /** * No description * @tags Manga * @name GetMangaAggregate * @summary Get Manga volumes & chapters * @request GET:/manga/{id}/aggregate */ namespace GetMangaAggregate { type RequestParams = { /** * Manga ID * @format uuid */ id: string; }; type RequestQuery = { translatedLanguage?: string[]; groups?: string[]; }; type RequestBody = never; type RequestHeaders = {}; type ResponseBody = { /** @default "ok" */ result?: string; volumes?: Record; }>; }; } /** * @description Get Manga. * @tags Manga * @name GetMangaId * @summary Get Manga * @request GET:/manga/{id} */ namespace GetMangaId { type RequestParams = { /** * Manga ID * @format uuid */ id: string; }; type RequestQuery = { /** Reference expansion options for manga entities or lists */ includes?: ReferenceExpansionMangaSchema; }; type RequestBody = never; type RequestHeaders = {}; type ResponseBody = MangaResponseSchema; } /** * No description * @tags Manga * @name PutMangaId * @summary Update Manga * @request PUT:/manga/{id} * @secure */ namespace PutMangaId { type RequestParams = { /** * Manga ID * @format uuid */ id: string; }; type RequestQuery = {}; type RequestBody = MangaEditSchema & { artists?: string[]; authors?: string[]; }; type RequestHeaders = { /** @default "application/json" */ "Content-Type": string; }; type ResponseBody = MangaResponseSchema; } /** * No description * @tags Manga * @name DeleteMangaId * @summary Delete Manga * @request DELETE:/manga/{id} * @secure */ namespace DeleteMangaId { type RequestParams = { /** * Manga ID * @format uuid */ id: string; }; type RequestQuery = {}; type RequestBody = never; type RequestHeaders = {}; type ResponseBody = ResponseSchema; } /** * No description * @tags CustomList * @name PostMangaIdListListId * @summary Add Manga in CustomList * @request POST:/manga/{id}/list/{listId} * @secure */ namespace PostMangaIdListListId { type RequestParams = { /** * Manga ID * @format uuid */ id: string; /** * CustomList ID * @format uuid */ listId: string; }; type RequestQuery = {}; type RequestBody = never; type RequestHeaders = {}; type ResponseBody = ResponseSchema; } /** * No description * @tags CustomList * @name DeleteMangaIdListListId * @summary Remove Manga in CustomList * @request DELETE:/manga/{id}/list/{listId} * @secure */ namespace DeleteMangaIdListListId { type RequestParams = { /** * Manga ID * @format uuid */ id: string; /** * CustomList ID * @format uuid */ listId: string; }; type RequestQuery = {}; type RequestBody = never; type RequestHeaders = {}; type ResponseBody = ResponseSchema; } /** * No description * @tags Manga * @name DeleteMangaIdFollow * @summary Unfollow Manga * @request DELETE:/manga/{id}/follow * @secure */ namespace DeleteMangaIdFollow { type RequestParams = { /** @format uuid */ id: string; }; type RequestQuery = {}; type RequestBody = never; type RequestHeaders = {}; type ResponseBody = ResponseSchema; } /** * No description * @tags Manga * @name PostMangaIdFollow * @summary Follow Manga * @request POST:/manga/{id}/follow * @secure */ namespace PostMangaIdFollow { type RequestParams = { /** @format uuid */ id: string; }; type RequestQuery = {}; type RequestBody = never; type RequestHeaders = {}; type ResponseBody = ResponseSchema; } /** * No description * @tags Manga * @name GetMangaIdFeed * @summary Manga feed * @request GET:/manga/{id}/feed */ namespace GetMangaIdFeed { type RequestParams = { /** * Manga ID * @format uuid */ id: string; }; type RequestQuery = { /** * @min 1 * @max 500 * @default 100 */ limit?: number; /** @min 0 */ offset?: number; translatedLanguage?: string[]; originalLanguage?: string[]; excludedOriginalLanguage?: string[]; /** @default ["safe","suggestive","erotica"] */ contentRating?: ("safe" | "suggestive" | "erotica" | "pornographic")[]; excludedGroups?: string[]; excludedUploaders?: string[]; /** @default "1" */ includeFutureUpdates?: "0" | "1"; /** * DateTime string with following format: YYYY-MM-DDTHH:MM:SS in timezone UTC+0 * @pattern ^\d{4}-[0-1]\d-([0-2]\d|3[0-1])T([0-1]\d|2[0-3]):[0-5]\d:[0-5]\d$ */ createdAtSince?: string; /** * DateTime string with following format: YYYY-MM-DDTHH:MM:SS in timezone UTC+0 * @pattern ^\d{4}-[0-1]\d-([0-2]\d|3[0-1])T([0-1]\d|2[0-3]):[0-5]\d:[0-5]\d$ */ updatedAtSince?: string; /** * DateTime string with following format: YYYY-MM-DDTHH:MM:SS in timezone UTC+0 * @pattern ^\d{4}-[0-1]\d-([0-2]\d|3[0-1])T([0-1]\d|2[0-3]):[0-5]\d:[0-5]\d$ */ publishAtSince?: string; order?: { createdAt?: "asc" | "desc"; updatedAt?: "asc" | "desc"; publishAt?: "asc" | "desc"; readableAt?: "asc" | "desc"; volume?: "asc" | "desc"; chapter?: "asc" | "desc"; }; /** Reference expansion options for chapter entities or lists */ includes?: ReferenceExpansionChapterSchema; includeEmptyPages?: 0 | 1; includeFuturePublishAt?: 0 | 1; includeExternalUrl?: 0 | 1; /** @default "0" */ includeUnavailable?: "0" | "1"; }; type RequestBody = never; type RequestHeaders = {}; type ResponseBody = ChapterListSchema; } /** * @description A list of chapter ids that are marked as read for the specified manga * @tags ReadMarker * @name GetMangaChapterReadmarkers * @summary Manga read markers * @request GET:/manga/{id}/read * @secure */ namespace GetMangaChapterReadmarkers { type RequestParams = { /** @format uuid */ id: string; }; type RequestQuery = {}; type RequestBody = never; type RequestHeaders = {}; type ResponseBody = { result?: "ok"; data?: string[]; }; } /** * @description Send a lot of chapter ids for one manga to mark as read and/or unread * @tags ReadMarker * @name PostMangaChapterReadmarkers * @summary Manga read markers batch * @request POST:/manga/{id}/read * @secure */ namespace PostMangaChapterReadmarkers { type RequestParams = { /** @format uuid */ id: string; }; type RequestQuery = { /** Adding this will cause the chapter to be stored in the user's reading history */ updateHistory?: boolean; }; type RequestBody = ChapterReadMarkerBatchSchema; type RequestHeaders = {}; type ResponseBody = { result?: "ok"; }; } /** * @description A list of chapter ids that are marked as read for the given manga ids * @tags ReadMarker * @name GetMangaChapterReadmarkers2 * @summary Manga read markers * @request GET:/manga/read * @secure */ namespace GetMangaChapterReadmarkers2 { type RequestParams = {}; type RequestQuery = { /** Manga ids */ ids: string[]; /** Group results by manga ids */ grouped?: boolean; }; type RequestBody = never; type RequestHeaders = {}; type ResponseBody = { result?: "ok"; data?: string[] | Record; }; } /** * No description * @tags Manga * @name GetMangaRandom * @summary Get a random Manga * @request GET:/manga/random */ namespace GetMangaRandom { type RequestParams = {}; type RequestQuery = { /** Reference expansion options for manga entities or lists */ includes?: ReferenceExpansionMangaSchema; /** @default ["safe","suggestive","erotica"] */ contentRating?: ("safe" | "suggestive" | "erotica" | "pornographic")[]; includedTags?: string[]; /** @default "AND" */ includedTagsMode?: "AND" | "OR"; excludedTags?: string[]; /** @default "OR" */ excludedTagsMode?: "AND" | "OR"; }; type RequestBody = never; type RequestHeaders = {}; type ResponseBody = MangaResponseSchema; } /** * No description * @tags Manga * @name GetMangaTag * @summary Tag list * @request GET:/manga/tag */ namespace GetMangaTag { type RequestParams = {}; type RequestQuery = {}; type RequestBody = never; type RequestHeaders = {}; type ResponseBody = TagResponseSchema; } /** * No description * @tags Manga * @name GetMangaStatus * @summary Get all Manga reading status for logged User * @request GET:/manga/status * @secure */ namespace GetMangaStatus { type RequestParams = {}; type RequestQuery = { /** Used to filter the list by given status */ status?: "reading" | "on_hold" | "plan_to_read" | "dropped" | "re_reading" | "completed"; }; type RequestBody = never; type RequestHeaders = {}; type ResponseBody = { /** @default "ok" */ result?: string; statuses?: Record; }; } /** * No description * @tags Manga * @name GetMangaIdStatus * @summary Get a Manga reading status * @request GET:/manga/{id}/status * @secure */ namespace GetMangaIdStatus { type RequestParams = { /** @format uuid */ id: string; }; type RequestQuery = {}; type RequestBody = never; type RequestHeaders = {}; type ResponseBody = { /** @default "ok" */ result?: string; status?: "reading" | "on_hold" | "plan_to_read" | "dropped" | "re_reading" | "completed"; }; } /** * No description * @tags Manga * @name PostMangaIdStatus * @summary Update Manga reading status * @request POST:/manga/{id}/status * @secure */ namespace PostMangaIdStatus { type RequestParams = { /** @format uuid */ id: string; }; type RequestQuery = {}; type RequestBody = UpdateMangaStatusSchema; type RequestHeaders = { /** @default "application/json" */ "Content-Type": string; }; type ResponseBody = ResponseSchema; } /** * No description * @tags Manga * @name GetMangaIdDraft * @summary Get a specific Manga Draft * @request GET:/manga/draft/{id} * @secure */ namespace GetMangaIdDraft { type RequestParams = { /** @format uuid */ id: string; }; type RequestQuery = { /** Reference expansion options for manga entities or lists */ includes?: ReferenceExpansionMangaSchema; }; type RequestBody = never; type RequestHeaders = {}; type ResponseBody = MangaResponseSchema; } /** * No description * @tags Manga * @name CommitMangaDraft * @summary Submit a Manga Draft * @request POST:/manga/draft/{id}/commit * @secure */ namespace CommitMangaDraft { type RequestParams = { /** @format uuid */ id: string; }; type RequestQuery = {}; type RequestBody = { /** @min 1 */ version?: number; }; type RequestHeaders = {}; type ResponseBody = MangaResponseSchema; } /** * No description * @tags Manga * @name GetMangaDrafts * @summary Get a list of Manga Drafts * @request GET:/manga/draft * @secure */ namespace GetMangaDrafts { type RequestParams = {}; type RequestQuery = { /** * @min 1 * @max 100 * @default 10 */ limit?: number; /** @min 0 */ offset?: number; state?: "draft" | "submitted" | "rejected"; /** @default {"createdAt":"desc"} */ order?: { title?: "asc" | "desc"; year?: "asc" | "desc"; createdAt?: "asc" | "desc"; updatedAt?: "asc" | "desc"; }; /** Reference expansion options for manga entities or lists */ includes?: ReferenceExpansionMangaSchema; }; type RequestBody = never; type RequestHeaders = {}; type ResponseBody = MangaResponseSchema; } /** * No description * @tags Manga * @name GetMangaRelation * @summary Manga relation list * @request GET:/manga/{mangaId}/relation */ namespace GetMangaRelation { type RequestParams = { /** @format uuid */ mangaId: string; }; type RequestQuery = { /** Reference expansion options for manga relation entities or lists */ includes?: ReferenceExpansionMangaRelationSchema; }; type RequestBody = never; type RequestHeaders = {}; type ResponseBody = MangaRelationListSchema; } /** * @description Create a new Manga relation. * @tags Manga * @name PostMangaRelation * @summary Create Manga relation * @request POST:/manga/{mangaId}/relation * @secure */ namespace PostMangaRelation { type RequestParams = { /** @format uuid */ mangaId: string; }; type RequestQuery = {}; type RequestBody = MangaRelationCreateSchema; type RequestHeaders = { /** @default "application/json" */ "Content-Type": string; }; type ResponseBody = MangaRelationResponseSchema; } /** * No description * @tags Manga * @name DeleteMangaRelationId * @summary Delete Manga relation * @request DELETE:/manga/{mangaId}/relation/{id} * @secure */ namespace DeleteMangaRelationId { type RequestParams = { /** @format uuid */ mangaId: string; /** @format uuid */ id: string; }; type RequestQuery = {}; type RequestBody = never; type RequestHeaders = {}; type ResponseBody = ResponseSchema; } } declare namespace User$1 { /** * @description This will list public and private CustomList * @tags CustomList * @name GetUserList * @summary Get logged User CustomList list * @request GET:/user/list * @secure */ namespace GetUserList { type RequestParams = {}; type RequestQuery = { /** * @min 0 * @max 100 * @default 10 */ limit?: number; /** @min 0 */ offset?: number; }; type RequestBody = never; type RequestHeaders = {}; type ResponseBody = CustomListListSchema; } /** * @description This will list only public CustomList * @tags CustomList * @name GetUserIdList * @summary Get User's CustomList list * @request GET:/user/{id}/list */ namespace GetUserIdList { type RequestParams = { /** * User ID * @format uuid */ id: string; }; type RequestQuery = { /** * @min 0 * @max 100 * @default 10 */ limit?: number; /** @min 0 */ offset?: number; }; type RequestBody = never; type RequestHeaders = {}; type ResponseBody = CustomListListSchema; } /** * No description * @tags User * @name GetUser * @summary User list * @request GET:/user * @secure */ namespace GetUser { type RequestParams = {}; type RequestQuery = { /** * @min 0 * @max 100 * @default 10 */ limit?: number; /** @min 0 */ offset?: number; /** User ids (limited to 100 per request) */ ids?: string[]; username?: string; order?: { username?: "asc" | "desc"; }; }; type RequestBody = never; type RequestHeaders = {}; type ResponseBody = UserListSchema; } /** * No description * @tags User * @name GetUserId * @summary Get User * @request GET:/user/{id} */ namespace GetUserId { type RequestParams = { /** * User ID * @format uuid */ id: string; }; type RequestQuery = {}; type RequestBody = never; type RequestHeaders = {}; type ResponseBody = UserResponseSchema; } /** * No description * @tags User * @name DeleteUserId * @summary Delete User * @request DELETE:/user/{id} * @deprecated * @secure */ namespace DeleteUserId { type RequestParams = { /** * User ID * @format uuid */ id: string; }; type RequestQuery = {}; type RequestBody = never; type RequestHeaders = {}; type ResponseBody = ResponseSchema; } /** * No description * @tags User * @name PostUserDeleteCode * @summary Approve User deletion * @request POST:/user/delete/{code} * @deprecated */ namespace PostUserDeleteCode { type RequestParams = { /** * User delete code * @format uuid */ code: string; }; type RequestQuery = {}; type RequestBody = never; type RequestHeaders = {}; type ResponseBody = ResponseSchema; } /** * No description * @tags Feed * @name GetUserFollowsMangaFeed * @summary Get logged User followed Manga feed (Chapter list) * @request GET:/user/follows/manga/feed * @secure */ namespace GetUserFollowsMangaFeed { type RequestParams = {}; type RequestQuery = { /** * @min 1 * @max 500 * @default 100 */ limit?: number; /** @min 0 */ offset?: number; translatedLanguage?: string[]; originalLanguage?: string[]; excludedOriginalLanguage?: string[]; /** @default ["safe","suggestive","erotica"] */ contentRating?: ("safe" | "suggestive" | "erotica" | "pornographic")[]; excludedGroups?: string[]; excludedUploaders?: string[]; /** @default "1" */ includeFutureUpdates?: "0" | "1"; /** * DateTime string with following format: YYYY-MM-DDTHH:MM:SS in timezone UTC+0 * @pattern ^\d{4}-[0-1]\d-([0-2]\d|3[0-1])T([0-1]\d|2[0-3]):[0-5]\d:[0-5]\d$ */ createdAtSince?: string; /** * DateTime string with following format: YYYY-MM-DDTHH:MM:SS in timezone UTC+0 * @pattern ^\d{4}-[0-1]\d-([0-2]\d|3[0-1])T([0-1]\d|2[0-3]):[0-5]\d:[0-5]\d$ */ updatedAtSince?: string; /** * DateTime string with following format: YYYY-MM-DDTHH:MM:SS in timezone UTC+0 * @pattern ^\d{4}-[0-1]\d-([0-2]\d|3[0-1])T([0-1]\d|2[0-3]):[0-5]\d:[0-5]\d$ */ publishAtSince?: string; order?: { createdAt?: "asc" | "desc"; updatedAt?: "asc" | "desc"; publishAt?: "asc" | "desc"; readableAt?: "asc" | "desc"; volume?: "asc" | "desc"; chapter?: "asc" | "desc"; }; /** Reference expansion options for chapter entities or lists */ includes?: ReferenceExpansionChapterSchema; includeEmptyPages?: 0 | 1; includeFuturePublishAt?: 0 | 1; includeExternalUrl?: 0 | 1; /** @default "0" */ includeUnavailable?: "0" | "1"; }; type RequestBody = never; type RequestHeaders = {}; type ResponseBody = ChapterListSchema; } /** * No description * @tags User * @name GetUserMe * @summary Logged User details * @request GET:/user/me * @secure */ namespace GetUserMe { type RequestParams = {}; type RequestQuery = {}; type RequestBody = never; type RequestHeaders = {}; type ResponseBody = UserResponseSchema; } /** * No description * @tags Follows * @name GetUserFollowsGroup * @summary Get logged User followed Groups * @request GET:/user/follows/group * @secure */ namespace GetUserFollowsGroup { type RequestParams = {}; type RequestQuery = { /** * @min 1 * @max 100 * @default 10 */ limit?: number; /** @min 0 */ offset?: number; /** Reference expansion options for scanlation group entities or lists */ includes?: ReferenceExpansionScanlationGroupSchema; }; type RequestBody = never; type RequestHeaders = {}; type ResponseBody = ScanlationGroupListSchema; } /** * No description * @tags Follows * @name GetUserFollowsGroupId * @summary Check if logged User follows a Group * @request GET:/user/follows/group/{id} * @secure */ namespace GetUserFollowsGroupId { type RequestParams = { /** * Scanlation Group id * @format uuid */ id: string; }; type RequestQuery = {}; type RequestBody = never; type RequestHeaders = {}; type ResponseBody = ResponseSchema; } /** * No description * @tags Follows * @name GetUserFollowsUser * @summary Get logged User followed User list * @request GET:/user/follows/user * @secure */ namespace GetUserFollowsUser { type RequestParams = {}; type RequestQuery = { /** * @min 1 * @max 100 * @default 10 */ limit?: number; /** @min 0 */ offset?: number; }; type RequestBody = never; type RequestHeaders = {}; type ResponseBody = UserListSchema; } /** * No description * @tags Follows * @name GetUserFollowsUserId * @summary Check if logged User follows a User * @request GET:/user/follows/user/{id} * @secure */ namespace GetUserFollowsUserId { type RequestParams = { /** * User id * @format uuid */ id: string; }; type RequestQuery = {}; type RequestBody = never; type RequestHeaders = {}; type ResponseBody = ResponseSchema; } /** * No description * @tags Follows * @name GetUserFollowsManga * @summary Get logged User followed Manga list * @request GET:/user/follows/manga * @secure */ namespace GetUserFollowsManga { type RequestParams = {}; type RequestQuery = { /** * @min 1 * @max 100 * @default 10 */ limit?: number; /** @min 0 */ offset?: number; /** Reference expansion options for manga entities or lists */ includes?: ReferenceExpansionMangaSchema; }; type RequestBody = never; type RequestHeaders = {}; type ResponseBody = MangaListSchema; } /** * No description * @tags Follows * @name GetUserFollowsMangaId * @summary Check if logged User follows a Manga * @request GET:/user/follows/manga/{id} * @secure */ namespace GetUserFollowsMangaId { type RequestParams = { /** * Manga id * @format uuid */ id: string; }; type RequestQuery = {}; type RequestBody = never; type RequestHeaders = {}; type ResponseBody = ResponseSchema; } /** * No description * @tags Follows * @name GetUserFollowsList * @summary Get logged User followed CustomList list * @request GET:/user/follows/list * @secure */ namespace GetUserFollowsList { type RequestParams = {}; type RequestQuery = { /** * @min 1 * @max 100 * @default 10 */ limit?: number; /** @min 0 */ offset?: number; }; type RequestBody = never; type RequestHeaders = {}; type ResponseBody = CustomListListSchema; } /** * No description * @tags Follows * @name GetUserFollowsListId * @summary Check if logged User follows a CustomList * @request GET:/user/follows/list/{id} * @secure */ namespace GetUserFollowsListId { type RequestParams = { /** * CustomList id * @format uuid */ id: string; }; type RequestQuery = {}; type RequestBody = never; type RequestHeaders = {}; type ResponseBody = ResponseSchema; } /** * No description * @tags ReadMarker * @name GetReadingHistory * @summary Get users reading history * @request GET:/user/history * @secure */ namespace GetReadingHistory { type RequestParams = {}; type RequestQuery = {}; type RequestBody = never; type RequestHeaders = {}; type ResponseBody = { /** @default "ok" */ result?: string; ratings?: { chapterId?: string; /** @format date-time */ readDate?: Date; }[]; }; } } declare namespace Cover$1 { /** * No description * @tags Cover * @name GetCover * @summary CoverArt list * @request GET:/cover */ namespace GetCover { type RequestParams = {}; type RequestQuery = { /** * @min 0 * @max 100 * @default 10 */ limit?: number; /** @min 0 */ offset?: number; /** Manga ids (limited to 100 per request) */ manga?: string[]; /** Covers ids (limited to 100 per request) */ ids?: string[]; /** User ids (limited to 100 per request) */ uploaders?: string[]; /** Locales of cover art (limited to 100 per request) */ locales?: string[]; order?: { createdAt?: "asc" | "desc"; updatedAt?: "asc" | "desc"; volume?: "asc" | "desc"; }; /** Reference expansion options for cover art entities or lists */ includes?: ReferenceExpansionCoverArtSchema; }; type RequestBody = never; type RequestHeaders = {}; type ResponseBody = CoverListSchema; } /** * No description * @tags Cover * @name UploadCover * @summary Upload Cover * @request POST:/cover/{mangaOrCoverId} * @secure */ namespace UploadCover { type RequestParams = { /** * Is Manga UUID on POST * @format uuid */ mangaOrCoverId: string; }; type RequestQuery = {}; type RequestBody = { /** @format binary */ file?: File; volume?: CoverVolumeSchema; description?: string; /** @pattern ^[a-z]{2}(-[a-z]{2})?$ */ locale?: string; }; type RequestHeaders = { /** @default "multipart/form-data" */ "Content-Type": string; }; type ResponseBody = CoverResponseSchema; } /** * No description * @tags Cover * @name GetCoverId * @summary Get Cover * @request GET:/cover/{mangaOrCoverId} */ namespace GetCoverId { type RequestParams = { /** * Is Manga UUID on POST * @format uuid */ mangaOrCoverId: string; }; type RequestQuery = { /** Reference expansion options for cover art entities or lists */ includes?: ReferenceExpansionCoverArtSchema; }; type RequestBody = never; type RequestHeaders = {}; type ResponseBody = CoverResponseSchema; } /** * No description * @tags Cover * @name EditCover * @summary Edit Cover * @request PUT:/cover/{mangaOrCoverId} * @secure */ namespace EditCover { type RequestParams = { /** * Is Manga UUID on POST * @format uuid */ mangaOrCoverId: string; }; type RequestQuery = {}; type RequestBody = CoverEditSchema; type RequestHeaders = { /** @default "application/json" */ "Content-Type": string; }; type ResponseBody = CoverResponseSchema; } /** * No description * @tags Cover * @name DeleteCover * @summary Delete Cover * @request DELETE:/cover/{mangaOrCoverId} * @secure */ namespace DeleteCover { type RequestParams = { /** * Is Manga UUID on POST * @format uuid */ mangaOrCoverId: string; }; type RequestQuery = {}; type RequestBody = never; type RequestHeaders = {}; type ResponseBody = ResponseSchema; } } declare namespace Statistics { /** * No description * @tags Statistics * @name GetStatisticsChapterUuid * @summary Get statistics about given chapter * @request GET:/statistics/chapter/{uuid} * @secure */ namespace GetStatisticsChapterUuid { type RequestParams = { /** @format uuid */ uuid: string; }; type RequestQuery = {}; type RequestBody = never; type RequestHeaders = {}; type ResponseBody = { /** @default "ok" */ result?: string; statistics?: Record; }; } /** * No description * @tags Statistics * @name GetStatisticsChapters * @summary Get statistics about given chapters * @request GET:/statistics/chapter * @secure */ namespace GetStatisticsChapters { type RequestParams = {}; type RequestQuery = { chapter: string[]; }; type RequestBody = never; type RequestHeaders = {}; type ResponseBody = { /** @default "ok" */ result?: string; statistics?: Record; }; } /** * No description * @tags Statistics * @name GetStatisticsGroupUuid * @summary Get statistics about given scanlation group * @request GET:/statistics/group/{uuid} * @secure */ namespace GetStatisticsGroupUuid { type RequestParams = { /** @format uuid */ uuid: string; }; type RequestQuery = {}; type RequestBody = never; type RequestHeaders = {}; type ResponseBody = { /** @default "ok" */ result?: string; statistics?: Record; }; } /** * No description * @tags Statistics * @name GetStatisticsGroups * @summary Get statistics about given groups * @request GET:/statistics/group * @secure */ namespace GetStatisticsGroups { type RequestParams = {}; type RequestQuery = { group: string[]; }; type RequestBody = never; type RequestHeaders = {}; type ResponseBody = { /** @default "ok" */ result?: string; statistics?: Record; }; } /** * No description * @tags Statistics * @name GetStatisticsMangaUuid * @summary Get statistics about given Manga * @request GET:/statistics/manga/{uuid} * @secure */ namespace GetStatisticsMangaUuid { type RequestParams = { /** @format uuid */ uuid: string; }; type RequestQuery = {}; type RequestBody = never; type RequestHeaders = {}; type ResponseBody = { /** @default "ok" */ result?: string; statistics?: Record; }; } /** * No description * @tags Statistics * @name GetStatisticsManga * @summary Find statistics about given Manga * @request GET:/statistics/manga * @secure */ namespace GetStatisticsManga { type RequestParams = {}; type RequestQuery = { manga: string[]; }; type RequestBody = never; type RequestHeaders = {}; type ResponseBody = { /** @default "ok" */ result?: string; statistics?: Record; }; } } /** * This class represents the most abstract version of a MangaDex object, containing * only the ID of the object. This is mostly used for instanceOf checks. * @internal */ declare abstract class IDObject { abstract id: string; } type GettableClass = Function & { get: (id: string) => Promise; getMultiple?: (ids: string[]) => Promise; }; type MFARelationshipSchema = Pick & Partial> & { relationships?: Relationship[]; }; /** * Represents a relationship from one MangaDex object to another such as a manga, author, etc via its id. */ declare class Relationship extends IDObject { /** * The MangaDex UUID of the object this relationship refers to */ id: string; /** * What type of object is this a relationship to */ type: string; /** * If the relationship is between two manga, how are they related? */ related?: RelationshipSchema['related']; /** * Cached relationships are created by using the 'includes' parameter on search requests or * other functions that support it. For every type included in the parameter, relationships of * that type will be replaced by the actual object. The object will still be represented * by a Relationship object, but the {@link resolve} method will return instantly with the cached data. * Each resulting object will have no further relationships of its own. */ cached: boolean; private cachedData?; private static typeMap; private static typeMapLocked; constructor(data: MFARelationshipSchema); /** * Returns the cached related object, or undefined if nothing is cached. * Unlike resolve(), this does not fetch data or perform any I/O. */ peek(): T | undefined; /** * This will automatically fetch the associated object that this relationship refers to. * In other words, it wil call Manga.get(id), Chapter.get(id), etc with the information * stored in this relationship instance. If this relationship is cached, then the resulting * object will be missing relationships. */ resolve(): Promise; /** * This will {@link Relationship.resolve} an array of relationships, returning another array * in the same order. * @param relationshipArray - An array of relationships of the same type */ static resolveAll(relationshipArray: Relationship[]): Promise; /** * This will search through a relationship response from MangaDex and convert any * relationships of a specific type into relationship objects. * @internal */ static convertType(type: string, arr: RelationshipSchema[], parent?: Relationship): Relationship[]; /** * Create a reference to an object's self * @internal */ static createSelfRelationship(type: string, self: T): Relationship; /** * This function is used to resolved circular references, and should only be used in base.ts. * Specifically, it pairs a relationship type to its associated class. * @internal */ static registerTypes(types: string[], classObj: GettableClass): void; /** * Lock the type map so that no more types can be registered. * @internal */ static lockTypeMap(): void; /** * Returns an array of all registered Relationship types * @internal */ static getRegisteredTypes(): string[]; } /** * This class represents a map of locales and their associated strings. * Each string can be accessed by using the locale as the key (e.g. 'en', 'jp'). * {@link localString} and {@link setGlobalLocale} can be used to * automatically access a preferred locale. * @example * var locStr; * locStr['en']; // English String * LocalizedString.setGlobalLocale('jp'); * locStr.localString; // Japanese String */ declare class LocalizedString implements LocalizedStringSchema { private static globalLocale; [x: string]: string; constructor(strings: LocalizedStringSchema); /** * The string associated with the current global locale (set with setGlobalLocale()). * If the global locale is not available for this string, the English string is returned. * If that is also unavailable, the next available locale is returned. If no locales are * available, an empty string is returned. */ get localString(): string; /** * This function sets the default locale used by {@link LocalizedString.localString}. */ static setGlobalLocale(locale: string): void; } /** * This class represents a genre tag for a manga */ declare class Tag extends IDObject implements TagAttributesSchema { private static allTagCache; /** * MangaDex UUID of this tag */ id: string; /** * Localized names for this tag */ name: LocalizedString; /** * Localized descriptions for this tag */ description: LocalizedString; /** * The tag group this tag belongs to */ group: 'content' | 'format' | 'genre' | 'theme'; /** * The version of this tag (incremented whenever the tag's data is updated) */ version: number; constructor(data: TagSchema); /** * Get the localString from the name {@link LocalizedString} object */ get localName(): string; /** * Get the localString from the description {@link LocalizedString} object */ get localDescription(): string; /** * Retrieves every tag used on MangaDex. The result is cached so any promise * after the first will resolve instantly. */ static getAllTags(): Promise; /** * Return the first tag that contains the specified name */ static getByName(name: string): Promise; /** * Return tags with the associated names */ static getByNames(names: string[]): Promise; } /** * A simple record object representing links to manga on different websites. * Websites are the keys, and the values are full urls (when available). */ declare class Links { /** * Anilist (https://anilist.co) link to manga */ anilist?: string; /** * AnimePlanet (https://anime-planet.com) link to manga */ animePlanet?: string; /** * Bookwalker (https://bookwalker.jp/) link to manga */ bookWalker?: string; /** * Mangaupdates (https://mangaupdates.com) link to manga */ mangaUpdates?: string; /** * Novelupdates (https://novelupdates.com) link to manga */ novelUpdates?: string; /** * MyAnimeList (https://myanimelist.net) link to manga */ myAnimeList?: string; /** * Kitsu (https://kitsu.io) link to manga */ kitsu?: string; /** * Amazon (https://amazon.com) link to manga */ amazon?: string; /** * EBookJapan (https://ebookjapan.yahoo.co.jp) link to manga */ eBookJapan?: string; /** * Link to manga raws */ raw?: string; /** * Link to offical english manga translation */ officialEnglishTranslation?: string; /** * CDJapan (https://www.cdjapan.co.jp/) link to manga */ cdJapan?: string; constructor(linksObject?: Record); } type CommonKeys = keyof T1 & keyof T2; type IntersectingProps = { [x in CommonKeys]: T1[x] | T2[x]; }; /** * Merges two types, creating a union at every shared property. */ type Merge = Omit> & IntersectingProps & Omit>; type DeepRequire = Required<{ [P in keyof T]: T[P] extends object | undefined ? DeepRequire> : T[P]; }>; interface IAuthClient { getSessionToken: () => Promise; } type GroupSearchParams = Partial>; type GroupStatsResponse = DeepRequire; type GroupStats = GroupStatsResponse['statistics'][string]; type FollowedGroupsParams = User$1.GetUserFollowsGroup.RequestQuery; declare class Group extends IDObject implements ScanlationGroupAttributesSchema { /** * The MangaDex UUID of this group */ id: string; /** * The name of this group */ name: string; /** * Alternate names for this group, including localized names */ altNames: LocalizedString[]; /** * Url to this group's website */ website: string | null; /** * IRC server of this group */ ircServer: string | null; /** * IRC channel of this group */ ircChannel: string | null; /** * Discord server of this group */ discord: string | null; /** * Email of this group */ contactEmail: string | null; /** * Description of this group (not localized) */ description: string | null; /** * Twitter profile of this group */ twitter: string | null; /** * MangaUpdates profile of this group */ mangaUpdates: string | null; /** * Languages this group focusses on translating */ focusedLanguage: string[] | null; /** * Is this group locked from uploading? */ locked: boolean; /** * Is this an official scanlation group? */ official: boolean; /** * Is this group inactive? */ inactive: boolean; /** * The delay between when this group uploads a chapter and when that chapter becomes readable */ publishDelay: string; /** * The version of this group (incremented by updating the group data) */ version: number; /** * When this group was created */ createdAt: Date; /** * When this group was last updated */ updatedAt: Date; /** * Relationship to the user profile of the user */ leader: Relationship | null; /** * Array of relationships to the member users of this group */ members: Relationship[]; /** * Is this group ex-licensed? */ exLicensed: boolean; /** * Is this group verified? */ verified: boolean; constructor(schem: ScanlationGroupSchema); /** * Retrieves a group by their id */ static get(id: string): Promise; /** * Retrieves a list of groups according to the specified search parameters */ static search(query?: GroupSearchParams): Promise; /** * Retrieves an array of groups by an array of ids */ static getMultiple(ids: string[]): Promise; /** * Performs a search for a group and returns the first one found. If no results are * found, null is returned */ static getByQuery(query?: GroupSearchParams): Promise; /** * Create a new group */ static create(data: CreateScanlationGroupSchema): Promise; /** * Deletes a group by their id */ static delete(id: string): Promise; /** * Deletes this group */ delete(): Promise; /** * Updates a group's information. */ update(data: Omit): Promise; /** * Makes the logged in user follow or unfollow a group */ static changeFollowship(id: string, follow?: boolean): Promise; /** * Makes the user follow or unfollow this group */ changeFollowship(follow?: boolean): Promise; /** * Gets the statistics about a list of groups */ static getStatistics(ids: string[] | Group[]): Promise>; /** * Gets the statistics about this group */ getStatistics(): Promise; /** * Gets an array of groups that the current user follows */ static getFollowedGroups(query?: FollowedGroupsParams): Promise; } type UserSearchParams = Partial>; type FollowedUserParams = User$1.GetUserFollowsUser.RequestQuery; /** * This class represents a MangaDex user such as a chapter uploader */ declare class User extends IDObject implements UserAttributesSchema { id: string; username: string; roles: string[]; version: number; groups: Relationship[]; constructor(schem: UserSchema); /** * Retrieves a user by their id */ static get(id: string): Promise; /** * Retrieves a list of users according to the specified search parameters */ static search(query?: UserSearchParams): Promise; /** * Retrieves an array of users by an array of ids */ static getMultiple(ids: string[]): Promise; /** * Performs a search for a user and returns the first one found. If no results are * found, null is returned */ static getByQuery(query?: UserSearchParams): Promise; /** * Returns a user object for the currently authenticated user. */ static getLoggedInUser(): Promise; /** * Returns all users followed by the currently authenticated user. */ static getFollowedUsers(query?: FollowedUserParams): Promise; } type ChapterSearchParams = Partial>; type OtherChapterAttributes = Omit; type ChapterStatsResponse = DeepRequire; type ChapterStats = ChapterStatsResponse['statistics'][string]; declare class Chapter extends IDObject implements OtherChapterAttributes { /** * The MangaDex UUID of this chapter */ id: string; /** * The title of this chapter */ title: string | null; /** * The manga volume this chapter belongs to */ volume: string | null; /** * The chapter number for this chapter */ chapter: string | null; /** * The number of pages in this chapter */ pages: number; /** * The language of this chapter */ translatedLanguage: string; /** * Relationship to the user who uploaded this chapter */ uploader: Relationship; /** * Url to this chapter if it's an external chapter */ externalUrl: string | null; /** * The version of this chapter (incremented by updating chapter data) */ version: number; /** * When this chapter was created */ createdAt: Date; /** * When this chapter was last updated */ updatedAt: Date; /** * When this chapter was originally published */ publishAt: Date; /** * When was / when will this chapter be readable? */ readableAt: Date; /** * Is this chapter an external chapter? If it is, this chapter will have an externalUrl */ isExternal: boolean; /** * A relationship to the manga this chapter belongs to */ manga: Relationship; /** * Array of relationships to the groups that translated this chapter */ groups: Relationship[]; /** * Is this chapter unavailable? */ isUnavailable: boolean; constructor(schem: ChapterSchema); /** * Retrieves a chapter object by its UUID */ static get(id: string, expandedTypes?: ChapterSearchParams['includes']): Promise; /** * Retrieves an array of chapters by an array of their ids */ static getMultiple(ids: string[]): Promise; /** * Retrieves a list of chapters according to the specified search parameters */ static search(query?: ChapterSearchParams): Promise; /** * Performs a search for a chapter and returns the first one found. If no results are * found, null is returned */ static getByQuery(query?: ChapterSearchParams): Promise; /** * Update this chapter's information */ update(data: Omit): Promise; /** * Delete this chapter */ static delete(id: string): Promise; /** * Delete a chapter by its UUID */ delete(): Promise; /** * Returns an array of image URLs for this chapter's pages. Once an image is requested, * if the host is from MangaDex(at)Home, please report if it succeeds or fails by using {@link reportPageURL}. * @param saver - If true, the URLs will be for the compressed data-saver images (if available). * @param forcePort - If true, the URLs will be forced to be on port 443. */ getReadablePages(saver?: boolean, forcePort?: boolean): Promise; /** * Sends a report to MangaDex about the success/failure of a MangaDex(at)Home server. * Read more information: {@link https://api.mangadex.org/docs/04-chapter/retrieving-chapter/#mangadexhome-load-successes-failures-and-retries} */ static reportPageURL(report: { url: string; success: boolean; bytes: number; duration: number; cached: boolean; }): Promise; /** * Gets the statistics about a list of chapters */ static getStatistics(ids: string[] | Chapter[]): Promise>; /** * Gets the statistics about this chapter */ getStatistics(): Promise; } type CoverSearchParams = Partial>; type CoverExpandedTypes = CoverSearchParams['includes']; type CoverUploadBody = Omit & { file: Blob; }; declare class Cover extends IDObject implements CoverAttributesSchema { /** * MangaDex UUID for this object */ id: string; /** * What volume is this cover for, if any */ volume: string | null; /** * The file name of this cover's image */ fileName: string; /** * Description of this cover. May be an empty string */ description: string | null; /** * What language is this cover in */ locale: string | null; /** * The version of this cover (incremented by updating the cover) */ version: number; /** * The date this cover was uploaded */ createdAt: Date; /** * The date this cover was last updated */ updatedAt: Date; /** * Url to this cover's image */ url: string; /** * Relationship to the manga this cover belongs to */ manga: Relationship; /** * Relationship to the user who uploaded this cover */ uploader: Relationship | null; constructor(schem: CoverSchema); /** * Retrieves a cover by its id */ static get(id: string | Manga, expandedTypes?: CoverExpandedTypes): Promise; /** * Retrieves a list of covers according to the specified search parameters */ static search(query?: CoverSearchParams): Promise; /** * Performs a search for a cover and returns the first one found. If no results are * found, null is returned */ static getByQuery(query?: CoverSearchParams): Promise; /** * Retrieves an array of covers by an array of ids */ static getMultiple(ids: string[]): Promise; /** * Returns an array of covers from an array of manga ids or a single manga */ static getMangaCovers(manga: Manga | string | Manga[] | string[], expandedTypes?: CoverExpandedTypes): Promise; /** * Deletes a cover by their id */ static delete(id: string): Promise; /** * Deletes this cover */ delete(): Promise; /** * Updates a cover's information. */ update(data: Omit): Promise; /** * Uploads a new cover */ static create(manga: string | Manga, data: CoverUploadBody): Promise; } type AuthorSearchParams = Partial>; /** * This represents an author or artist of a manga */ declare class Author extends IDObject implements AuthorAttributesSchema { /** * The MangaDex UUID for the author/artist */ id: string; /** * The name of the author/artist */ name: string; /** * A url to an image of the author/artist */ imageUrl: string | null; /** * The biography of the author/artist */ biography: LocalizedString; /** * URL to the author/artist's twitter */ twitter: string | null; /** * URL to the author/artist's pixiv */ pixiv: string | null; /** * URL to the author/artist's melon book */ melonBook: string | null; /** * URL to the author/artist's fanbox */ fanBox: string | null; /** * URL to the author/artist's booth */ booth: string | null; /** * URL to the author/artist's nico video */ nicoVideo: string | null; /** * URL to the author/artist's skeb */ skeb: string | null; /** * URL to the author/artist's fantia */ fantia: string | null; /** * URL to the author/artist's tumblr */ tumblr: string | null; /** * URL to the author/artist's youtube */ youtube: string | null; /** * URL to the author/artist's weibo */ weibo: string | null; /** * URL to the author/artist's naver */ naver: string | null; /** * URL to the author/artist's namicomi */ namicomi: string | null; /** * URL to the author/artist's website */ website: string | null; /** * The version of this author/artist's entry (incremented by updating author data) */ version: number; /** * When the author/artist's entry was added */ createdAt: Date; /** * The last time the author/artist's entry was updated */ updatedAt: Date; /** * The manga the author/artist has worked on */ manga: Relationship[]; constructor(schem: AuthorSchema); /** * Retrieve a chapter object by its id */ static get(id: string, expandedTypes?: AuthorSearchParams['includes']): Promise; /** * Retrieves a list of authors/artists according to the specified search parameters */ static search(query?: AuthorSearchParams): Promise; /** * Performs a search for an author/artist and returns the first one found. If no results are * found, null is returned */ static getByQuery(query?: AuthorSearchParams): Promise; /** * Retrieves an array of authors/artists by an array of ids */ static getMultiple(ids: string[]): Promise; /** * Create a new Author */ static create(data: AuthorCreateSchema): Promise; /** * Deletes an author by their id */ static delete(id: string): Promise; /** * Deletes this author */ delete(): Promise; /** * Updates an author's information. */ update(data: Omit): Promise; } type MangaSearchHelpers = { group: Group; includedTags: Tag[]; excludedTags: Tag[]; authors: Author[]; artists: Author[]; authorOrArtist: Author; ids: IDObject[]; }; type MangaSearchParams = Partial>; type OtherMangaAttributes = Omit; type RelatedManga = { [x in RelationshipSchema['related']]: Relationship[]; }; type MangaReadingStatus = Required['status']; type MangaRelation = MangaRelationAttributesSchema['relation']; type MangaStatsResponse = DeepRequire; type MangaStats = MangaStatsResponse['statistics'][string]; type MangaDraftSearchParams = Partial; type MangaAggregateResponse = DeepRequire; type MangaAggregate = MangaAggregateResponse['volumes']; type FollowedMangaParams = User$1.GetUserFollowsManga.RequestQuery; /** * This class represents a specific manga series. * There are many static methods for requesting manga from MangaDex. */ declare class Manga extends IDObject implements OtherMangaAttributes { /** * The MangaDex UUID of this manga */ id: string; /** * The manga's main title with different localization options */ title: LocalizedString; /** * List of alternate titles with different localization options */ altTitles: LocalizedString[]; /** * Description with different localization options */ description: LocalizedString; /** * Is this manga locked? */ isLocked: boolean; /** * Link object representing links to other websites about this manga */ links: Links; /** * 2 (or more) letter code for the original language of this manga */ originalLanguage: string; /** * This manga's last volume based on the default feed order */ lastVolume: string | null; /** * This manga's last chapter based on the default feed order */ lastChapter: string | null; /** * Publication demographic of this manga */ publicationDemographic: 'shounen' | 'shoujo' | 'josei' | 'seinen' | null; /** * Publication/Scanlation status of this manga */ status: 'completed' | 'ongoing' | 'cancelled' | 'hiatus'; /** * Year of this manga's publication */ year: number | null; /** * The content rating of this manga */ contentRating: 'safe' | 'suggestive' | 'erotica' | 'pornographic'; /** * Does the chapter count reset whenever a new volume is added? */ chapterNumbersResetOnNewVolume: boolean; /** * List of language codes that this manga has translated chapters for */ availableTranslatedLanguages: string[]; /** * Relationship to the latest chapter. Null if there is no latest chapter. */ latestUploadedChapter: Relationship | null; /** * List of this manga's genre tags */ tags: Tag[]; /** * Status of this manga as a manga submission */ state: 'draft' | 'submitted' | 'published' | 'rejected'; /** * The version of this manga (incremented by updating manga data) */ version: number; /** * Date the manga was added to the site */ createdAt: Date; /** * Date the manga was last updated */ updatedAt: Date; /** * An object containing all other manga entries related to this one. * This includes spin-offs, colorization, etc. */ relatedManga: RelatedManga; /** * List of relationships to authors attributed to this manga */ authors: Relationship[]; /** * List of relationships to artists attributed to this manga */ artists: Relationship[]; /** * A relationship to the current main cover of this series */ mainCover: Relationship; /** * The user that created this manga, if known. */ creator: Relationship | null; constructor(schem: MangaSchema); private static getRelatedManga; /** * The title of this manga according to the global locale. * @see {@link LocalizedString.localString} */ get localTitle(): string; /** * List of alternate titles for manga according to the global locale. * @see {@link LocalizedString.localString} */ get localAltTitles(): string[]; /** * The description of this manga according to the global locale. * @see {@link LocalizedString.localString} */ get localDescription(): string; /** * Retrieves a manga object by its UUID */ static get(id: string, expandedTypes?: MangaSearchParams['includes']): Promise; /** * Retrieves a list of manga according to the specified search parameters * @see {@link Relationship.cached} for information on how to automatically resolve Relationships */ static search(query?: MangaSearchParams): Promise; /** * Retrieves an array of manga by an array of their ids */ static getMultiple(ids: string[], extraParams?: Omit): Promise; /** * Returns how many manga there are total for a search query */ static getTotalSearchResults(query?: Omit): Promise; /** * Returns an array of a manga's chapters */ static getFeed(id: string, params?: ChapterSearchParams): Promise; /** * Returns an array of this manga's chapters */ getFeed(params?: ChapterSearchParams): Promise; /** * Marks lists of chapters read or unread for a single manga */ static updateReadChapters(manga: string, chapters: { read?: (string | Chapter)[]; unread?: (string | Chapter)[]; }, updateHistory?: boolean): Promise; /** * Marks lists of chapters read or unread for this manga */ updateReadChapters(chapters: Parameters[1], updateHistory?: boolean): Promise; /** * Returns an array of read chapters for a list of manga. The response is a record with the manga ids * as the keys and chapter arrays as the values. */ static getReadChapters(ids: string[] | Manga[]): Promise>; /** * Returns an array of read chapters for this manga */ getReadChapters(): Promise; /** * Retrieves a random manga */ static getRandom(query?: Pick): Promise; /** * Performs a search for a manga and returns the first one found. If no results are * found, null is returned */ static getByQuery(query?: MangaSearchParams): Promise; /** * Gets all covers for this manga */ getCovers(): Promise; /** * Returns all manga followed by the currently authenticated user */ static getFollowedManga(query?: FollowedMangaParams): Promise; /** * Returns a record of all ratings given by the currently authenticated user. The object is indexed by the manga * ids and each value contains the numerical rating and when that rating was given. If a manga has no rating, * 'null' is used as the value. */ static getUserRatings(ids: string[] | Manga[]): Promise>; /** * Returns the rating that the currently authenticated user gave to this manga on a scale of 1-10, * or returns null if there is no rating. */ getUserRating(): Promise; /** * Makes the currently authenticated user give a manga a rating between 1-10 (inclusive). */ static giveRating(mangaId: string, rating: number): Promise; /** * Makes the currently authenticated user give this manga a rating between 1-10 (inclusive). */ giveRating(rating: number): Promise; /** * Removes the currently authenticated user's rating for a manga */ static removeRating(mangaId: string): Promise; /** * Removes the currently authenticated user's rating for this manga */ removeRating(): Promise; /** * Gets the combined feed of every manga followed by the logged in user */ static getFollowedFeed(query?: ChapterSearchParams): Promise; /** * Converts legacy pre-V5 MangaDex ids to modern UUIDs. Returns a record with legacy ids as the keys * and new ids as the values. */ static convertLegacyId(type: MappingIdBodySchema['type'], ids: number[]): Promise>; /** * Get every reading status (eg completed, reading, dropped, etc) for every manga marked by * the currently authenticated user. * @param filter - If specified, only manga with this status will be returned */ static getAllReadingStatus(filter?: MangaReadingStatus): Promise>; /** * Gets the reading status (eg completed, reading, dropped, etc) for a manga for the currently * authenticated user */ static getReadingStatus(id: string): Promise; /** * Gets the reading status (eg completed, reading, dropped, etc) for this manga for the currently * authenticated user */ getReadingStatus(): Promise; /** * Sets a manga's reading status (eg completed, reading, dropped, etc) for the currently authenticated user. * If the status is null, the current reading status will be removed. */ static setReadingStatus(id: string, status: MangaReadingStatus | null): Promise; /** * Sets this manga's reading status (eg completed, reading, dropped, etc) for the currently authenticated user. * If the status is null, the current reading status will be removed. */ setReadingStatus(status: MangaReadingStatus | null): Promise; /** * Gets all of a manga's relations to other manga. */ static getRelations(id: string, expandTypes?: boolean): Promise; /** * Gets all of this manga's relations to other manga. */ getRelations(expandTypes?: boolean): Promise; /** * Creates a relation between two manga (eg sequel/prequel, monochrome/colored, spin-off, etc) * @param id - The origin manga * @param targetId - The target manga for the relation (eg the sequel, spin-off, etc) */ static addRelation(id: string, targetId: string, relationType: MangaRelation): Promise; /** * Creates a relation (eg sequel/prequel, monochrome/colored, spin-off, etc) between this manga and another * @param id - The origin manga * @param targetId - The target manga for the relation (eg the sequel, spin-off, etc) */ addRelation(targetId: string, relationType: MangaRelation): Promise; /** * Removes a relation from a manga by the relation's id */ static removeRelation(mangaId: string, relationId: string): Promise; /** * Removes a relation from this manga by the relation's id */ removeRelation(relationId: string): Promise; /** * Gets the statistics about manga including their rating distribution, comment count, and follow count */ static getStatistics(ids: string[] | Manga[]): Promise>; /** * Gets the statistics about this manga including its rating distribution, comment count, and follow count */ getStatistics(): Promise; /** * Retrieves a manga draft by its UUID */ static getDraft(id: string, expandedTypes?: MangaDraftSearchParams['includes']): Promise; /** * Retrieves a list of manga drafts according to the specified search parameters * @see {@link Relationship.cached} for information on how to automatically resolve Relationships */ static searchDrafts(query?: MangaDraftSearchParams): Promise; /** * Commits a manga object as a draft. A Manga draft that is to be submitted must have at least one cover in * the original language, must be in the "draft" state, and must be passed the correct version in the request body. */ static commitDraft(draftId: string, manga: Partial): Promise; /** * Create a new manga. MangaDex only allows admins to use this endpoint. Use the a manga draft instead */ static create(data: MangaCreateSchema): Promise; /** * Deletes a manga by its id */ static delete(id: string): Promise; /** * Deletes this manga */ delete(): Promise; /** * Updates this manga's information. */ update(data: Omit): Promise; /** * Returns an abridged list of chapter ids for a manga separated by their volumes */ static getAggregate(id: string, groups?: string[] | Group[], languages?: string[]): Promise; /** * Returns an abridged list of chapter ids for this manga separated by their volumes */ getAggregate(groups?: string[] | Group[], languages?: string[]): Promise; /** * Makes the logged in user follow or unfollow a manga */ static changeFollowship(id: string, follow?: boolean): Promise; /** * Makes the user follow or unfollow this manga */ changeFollowship(follow?: boolean): Promise; } type FullUploadSession = UploadSessionSchema & { relationships: RelationshipSchema[]; }; type FixedFullUploadSession = FullUploadSession | { data: FullUploadSession; }; /** * This class represents an in-progress manga upload session including the uploaded pages. */ declare class UploadSession extends IDObject implements UploadSessionAttributesSchema { /** * The MangaDex UUID of this upload session */ id: string; /** * Has this session been committed (pages published) */ isCommitted: boolean; /** * Has this session still been processed by MangaDex? */ isProcessed: boolean; /** * Has this session been deleted/aborted? */ isDeleted: boolean; /** * The version of this session (incremented by updating data) */ version: number; /** * When this upload session was started */ createdAt: Date; /** * When this upload session was last updated */ updatedAt: Date; /** * A relationship to who started this upload session */ uploader: Relationship; /** * A relationship to the manga this upload session is for */ manga: Relationship; /** * An array of relationships to the groups involved with the chapter for this session */ groups: Relationship[]; /** * An array of uploaded page image files */ pages: UploadSessionFile[]; constructor(schem: FixedFullUploadSession); private updateData; /** * Begin a new upload session for a specified manga. At least one group must be specified * @param cancelCurrentSession - Stop any current upload session before creating this one */ static begin(manga: string | Manga, groups?: string[] | Group[], cancelCurrentSession?: boolean): Promise; /** * Start a new upload session for editing an existing chapter. The upload session will * act the same as one for new chapter. * @param cancelCurrentSession - Stop any current upload session before creating this one */ static beginChapterEdit(chapter: Chapter, cancelCurrentSession?: boolean): Promise; /** * Get the current upload session owned by the currently authenticated user */ static getCurrentSession(): Promise; /** * Cancel the current user's current upload session if it exists */ static cancelCurrentSession(): Promise; /** * Closes this upload session and removes all associated uploaded files */ close(): Promise; /** * Commit and publish this chapter to MangaDex. * @param pageOrder - By default, the page order is decided by the 'pages' array of this upload session object. * If this parameter is supplied an array, the order of elements in that array is used instead. */ commit(chapterData: ChapterDraftSchema, pageOrder?: string[] | UploadSessionFile[]): Promise; /** * Upload new page image files as blobs. The blobs should contain the binary image data, and although not necessary, * it is recommended that the image MIME type is included as well. The resulting uploaded file data will be appended * to this object's 'pages' property. */ uploadPages(files: Blob[]): Promise; /** * Delete previously uploaded page image files by their ids */ deletePages(pages: string[] | UploadSessionFileSchema[]): Promise; } declare class UploadSessionFile extends IDObject implements UploadSessionFileAttributesSchema { /** * The MangaDex UUID of this uploaded file */ id: string; /** * The original filename of the file. May be an empty string */ originalFileName: string; /** * The hash of this file. May be an empty string */ fileHash: string; /** * The file size in bytes of this file */ fileSize: number; /** * The MIME image type of this file */ mimeType: string; /** * Is this file stored on MangaDex's server or elsewhere */ source: 'local' | 'remote'; /** * The version number of this file (incremented by updating the file's data) */ version: number; /** * A number assigned to this file. It is usually from the order it was uploaded, but it can also * be the file hash or another number. */ num: number; constructor(schem: UploadSessionFileSchema); } type PersonalClientInfo = { username: string; password: string; clientId: string; clientSecret: string; }; type ClientData = PersonalClientInfo & { accessToken: string; accessExpiration: number; refreshToken: string; refreshExpiration: number; }; /** * This class is used to authenticate with the MangaDex API using a personal client. * {@link https://api.mangadex.org/docs/02-authentication/personal-clients/} */ declare class PersonalAuthClient implements IAuthClient { data: ClientData; constructor(data: ClientData); /** * Returns the client's access token and refreshes it if necessary. */ getSessionToken(): Promise; /** * Refreshes the client's access token and refresh token. */ refreshTokens(): Promise; /** * Creates a new PersonalAuthClient and optionally sets it as the active client. */ static login(info: PersonalClientInfo, activate?: boolean): Promise; } type LoginData = { session: string; refresh: string; timestamp: number; }; /** * This class represents a the legacy (username and password) auth client. * This login method is being deprecated in favor of OAuth which is implemented through {@link PersonalAuthClient} instead. * * @deprecated - This login method is being replaced by OAuth */ declare class LegacyAuthClient implements IAuthClient { data: LoginData; constructor(data: LoginData); getSessionToken(): Promise; /** * Set this auth instance to be the one used by all API calls */ setActive(): void; /** * Login with a legacy username and password, and activate this client for all API calls */ static login(username: string, password: string): Promise; /** * Refresh the access token and update the token data for this client */ refreshTokens(): Promise; /** * Check if the current session token is valid by asking MangaDex */ checkSessionToken(): Promise; } declare class List extends IDObject implements CustomListAttributesSchema { /** * The MangaDex UUID of this custom list */ id: string; /** * The display name of this custom list */ name: string; /** * Is this list public or private? */ visibility: 'private' | 'public'; /** * The version of this custom list (incremented by updating data) */ version: number; /** * A relationship to the user who created and owns this list */ creator: Relationship; /** * An array of relationships to the manga in this custom list */ manga: Relationship[]; constructor(schem: CustomListSchema); /** * Retrieves a list by its id */ static get(id: string): Promise; /** * Create a new list */ static create(data: CustomListCreateSchema): Promise; /** * Deletes a list by its id */ static delete(id: string): Promise; /** * Deletes this list */ delete(): Promise; /** * Updates a list's information. */ update(data: Partial>): Promise; /** * Make the currently authenticated user follow a list */ static follow(id: string): Promise; /** * Make the currently authenticated user follow this list */ follow(): Promise; /** * Make the currently authenticated user unfollow a list */ static unfollow(id: string): Promise; /** * Make the currently authenticated user unfollow this list */ unfollow(): Promise; /** * Add a manga to a list */ static addManga(listId: string, manga: Manga | string): Promise; /** * Add a manga to this list */ addManga(manga: Manga | string): Promise; /** * Remove a manga from a list */ static removeManga(listId: string, manga: Manga | string): Promise; /** * Remove a manga from this list */ removeManga(manga: Manga | string): Promise; /** * Returns all of the currently authenticated user's custom manga lists */ static getLoggedInUserLists(limit?: number, offset?: number): Promise; /** * Returns all of a user's custom manga lists */ static getUserLists(user: string | User, limit?: number, offset?: number): Promise; /** * Returns an array of chapters from the manga in a list */ static getFeed(listId: string, query?: Partial): Promise; /** * Returns an array of chapters from the manga in this list */ getFeed(query?: Partial): Promise; /** * Returns all lists followed by the currently authenticated user */ static getFollowedLists(limit?: number, offset?: number): Promise; /** * Changes the visibility of this custom list */ changeVisibility(newVis: 'public' | 'private'): Promise; /** * Renames this custom list */ rename(name: string): Promise; /** * */ updateMangaList(newList: Manga[] | string[]): Promise; } /** * If true the debug (sandbox) MangaDex domain will be used as the domain override. * {@link https://sandbox.mangadex.dev} */ declare function useDebugServer(val: boolean): void; /** * Changes the origin used by api calls to a custom one, or clears it if the passed value is undefined. * @param domain - The new domain (e.g. https://example.com) */ declare function overrideApiOrigin(domain: string | undefined): void; /** * Changes the origin used by authentication calls to a custom one, or clears it if the passed value is undefined. * @param domain - The new domain (e.g. https://example.com) */ declare function overrideAuthOrigin(domain: string | undefined): void; /** * Removes the current active AuthClient so no further API calls are done with user authorization */ declare function clearActiveAuthClient(): void; /** * Returns the current auth client or null if there is none */ declare function getActiveAuthClient(): IAuthClient | null; /** * Sets the global language locale to be used by LocalString objects. */ declare const setGlobalLocale: typeof LocalizedString.setGlobalLocale; /** * This will {@link Relationship.resolve} an array of relationships, returning another array * in the same order. * @param relationshipArray - An array of relationships of the same type */ declare const resolveArray: typeof Relationship.resolveAll; /** * Converts old (pre v5, numeric ids) Mangadex ids to v5 ids. Any invalid legacy ids will be * skipped by Mangadex when remapping, so call this function for each individual id if this is an issue. */ declare const convertLegacyId: typeof Manga.convertLegacyId; /** * Login with a legacy username and password * * @deprecated - This login method is being replaced by OAuth * * @param username - Username of the account * @param password - Password of the account */ declare const login: typeof LegacyAuthClient.login; /** * Login with a personal client. This method is recommended for smaller, private applications. * {@link https://api.mangadex.org/docs/02-authentication/personal-clients/} * @param clientInfo - Personal client info including client secret/id, username, and password * @param activate - By default, this client will be set as the active client for all API calls. Set this to false to disable this behavior. */ declare const loginPersonal: typeof PersonalAuthClient.login; /** * This will clear the active auth client, effectively logging out. */ declare const logout: typeof clearActiveAuthClient; /** * This will return the current active auth client, if any. */ declare const getCurrentAuthClient: typeof getActiveAuthClient; export { Author, Chapter, Cover, Group, LegacyAuthClient, List, Manga, PersonalAuthClient, Tag, UploadSession, User, convertLegacyId, getCurrentAuthClient, login, loginPersonal, logout, overrideApiOrigin, overrideAuthOrigin, resolveArray, setGlobalLocale, useDebugServer };