Class Manga

constructor

• new Manga(schem: MangaSchema): Manga

  Parameters

  • schem: MangaSchema

  Returns Manga

altTitles

artists

authors

availableTranslatedLanguages

chapterNumbersResetOnNewVolume

contentRating

createdAt

creator

description

id

isLocked

lastChapter

lastVolume

latestUploadedChapter

links

mainCover

originalLanguage

publicationDemographic

relatedManga

state

status

tags

title

updatedAt

version

year

localAltTitles

• get localAltTitles(): string[]

  List of alternate titles for manga according to the global locale.

  Returns string[]

  See

  LocalizedString.localString

localDescription

• get localDescription(): string

  The description of this manga according to the global locale.

  Returns string

  See

  LocalizedString.localString

localTitle

• get localTitle(): string

  The title of this manga according to the global locale.

  Returns string

  See

  LocalizedString.localString

addRelation

• addRelation(
      targetId: string,
      relationType:
          | "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",
  ): Promise<void>

  Creates a relation (eg sequel/prequel, monochrome/colored, spin-off, etc) between this manga and another

  Parameters

  • targetId: string

    The target manga for the relation (eg the sequel, spin-off, etc)

  • relationType:
        | "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"

  Returns Promise<void>

changeFollowship

• changeFollowship(follow?: boolean): Promise<void>

  Makes the user follow or unfollow this manga

  Parameters

  • follow: boolean = true

  Returns Promise<void>

delete

• delete(): Promise<void>

  Deletes this manga

  Returns Promise<void>

getAggregate

• getAggregate(
      groups?: string[] | Group[],
      languages?: string[],
  ): Promise<
      Required<
          {
              [key: string]: Required<
                  {
                      chapters: Record<
                          string,
                          { chapter?: string; count?: number; id?: string; others?: string[] },
                      >;
                      count: number;
                      volume: string;
                  },
              >;
          },
      >,
  >

  Returns an abridged list of chapter ids for this manga separated by their volumes

  Parameters

  • Optionalgroups: string[] | Group[]
  • Optionallanguages: string[]

  Returns Promise<
      Required<
          {
              [key: string]: Required<
                  {
                      chapters: Record<
                          string,
                          { chapter?: string; count?: number; id?: string; others?: string[] },
                      >;
                      count: number;
                      volume: string;
                  },
              >;
          },
      >,
  >

getCovers

• getCovers(): Promise<Cover[]>

  Gets all covers for this manga

  Returns Promise<Cover[]>

getFeed

• getFeed(
      params?: Partial<
          Merge<
              GetChapterParamsSchema,
              { groups: Group[]; ids: Chapter[]; uploader: User
              | User[] },
          >,
      >,
  ): Promise<Chapter[]>

  Returns an array of this manga's chapters

  Parameters

  • Optionalparams: Partial<
        Merge<
            GetChapterParamsSchema,
            { groups: Group[]; ids: Chapter[]; uploader: User
            | User[] },
        >,
    >

  Returns Promise<Chapter[]>

getReadChapters

• getReadChapters(): Promise<Chapter[]>

  Returns an array of read chapters for this manga

  Returns Promise<Chapter[]>

getReadingStatus

• getReadingStatus(): Promise<
      | "completed"
      | "reading"
      | "on_hold"
      | "plan_to_read"
      | "dropped"
      | "re_reading",
  >

  Gets the reading status (eg completed, reading, dropped, etc) for this manga for the currently authenticated user

  Returns Promise<
      | "completed"
      | "reading"
      | "on_hold"
      | "plan_to_read"
      | "dropped"
      | "re_reading",
  >

getRelations

• getRelations(expandTypes?: boolean): Promise<RelatedManga>

  Gets all of this manga's relations to other manga.

  Parameters

  • expandTypes: boolean = false

  Returns Promise<RelatedManga>

getStatistics

• getStatistics(): Promise<
      Required<
          {
              comments: StatisticsDetailsCommentsSchema;
              follows: number;
              rating: Required<{ average: number | null; bayesian: number }>;
          },
      >,
  >

  Gets the statistics about this manga including its rating distribution, comment count, and follow count

  Returns Promise<
      Required<
          {
              comments: StatisticsDetailsCommentsSchema;
              follows: number;
              rating: Required<{ average: number | null; bayesian: number }>;
          },
      >,
  >

getUserRating

• getUserRating(): Promise<number | null>

  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.

  Returns Promise<number | null>

giveRating

• giveRating(rating: number): Promise<void>

  Makes the currently authenticated user give this manga a rating between 1-10 (inclusive).

  Parameters

  • rating: number

  Returns Promise<void>

removeRating

• removeRating(): Promise<void>

  Removes the currently authenticated user's rating for this manga

  Returns Promise<void>

removeRelation

• removeRelation(relationId: string): Promise<void>

  Removes a relation from this manga by the relation's id

  Parameters

  • relationId: string

  Returns Promise<void>

setReadingStatus

• setReadingStatus(
      status:
          | "completed"
          | "reading"
          | "on_hold"
          | "plan_to_read"
          | "dropped"
          | "re_reading"
          | null,
  ): Promise<void>

  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.

  Parameters

  • status:
        | "completed"
        | "reading"
        | "on_hold"
        | "plan_to_read"
        | "dropped"
        | "re_reading"
        | null

  Returns Promise<void>

update

• update(data: Omit<MangaCreateSchema, "version">): Promise<Manga>

  Updates this manga's information.

  Parameters

  • data: Omit<MangaCreateSchema, "version">

  Returns Promise<Manga>

updateReadChapters

• updateReadChapters(
      chapters: { read?: (string | Chapter)[]; unread?: (string | Chapter)[] },
      updateHistory?: boolean,
  ): Promise<never[] | undefined>

  Marks lists of chapters read or unread for this manga

  Parameters

  • chapters: { read?: (string | Chapter)[]; unread?: (string | Chapter)[] }
  • updateHistory: boolean = false

  Returns Promise<never[] | undefined>

StaticaddRelation

• addRelation(
      id: string,
      targetId: string,
      relationType:
          | "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",
  ): Promise<void>

  Creates a relation between two manga (eg sequel/prequel, monochrome/colored, spin-off, etc)

  Parameters

  • id: string

    The origin manga

  • targetId: string

    The target manga for the relation (eg the sequel, spin-off, etc)

  • relationType:
        | "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"

  Returns Promise<void>

StaticchangeFollowship

• changeFollowship(id: string, follow?: boolean): Promise<void>

  Makes the logged in user follow or unfollow a manga

  Parameters

  • id: string
  • follow: boolean = true

  Returns Promise<void>

StaticcommitDraft

• commitDraft(
      draftId: string,
      manga: Partial<MangaAttributesSchema>,
  ): Promise<Manga>

  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.

  Parameters

  • draftId: string
  • manga: Partial<MangaAttributesSchema>

  Returns Promise<Manga>

StaticconvertLegacyId

• convertLegacyId(
      type: "group" | "manga" | "chapter" | "tag",
      ids: number[],
  ): Promise<Record<number, string>>

  Converts legacy pre-V5 MangaDex ids to modern UUIDs. Returns a record with legacy ids as the keys and new ids as the values.

  Parameters

  • type: "group" | "manga" | "chapter" | "tag"
  • ids: number[]

  Returns Promise<Record<number, string>>

Staticcreate

• create(data: MangaRequestSchema): Promise<Manga>

  Create a new manga. MangaDex only allows admins to use this endpoint. Use the a manga draft instead

  Parameters

  • data: MangaRequestSchema

  Returns Promise<Manga>

Staticdelete

• delete(id: string): Promise<void>

  Deletes a manga by its id

  Parameters

  • id: string

  Returns Promise<void>

Staticget

• get(id: string, expandedTypes?: ReferenceExpansionMangaSchema): Promise<Manga>

  Retrieves a manga object by its UUID

  Parameters

  • id: string
  • OptionalexpandedTypes: ReferenceExpansionMangaSchema

  Returns Promise<Manga>

StaticgetAggregate

• getAggregate(
      id: string,
      groups?: string[] | Group[],
      languages?: string[],
  ): Promise<
      Required<
          {
              [key: string]: Required<
                  {
                      chapters: Record<
                          string,
                          { chapter?: string; count?: number; id?: string; others?: string[] },
                      >;
                      count: number;
                      volume: string;
                  },
              >;
          },
      >,
  >

  Returns an abridged list of chapter ids for a manga separated by their volumes

  Parameters

  • id: string
  • Optionalgroups: string[] | Group[]
  • Optionallanguages: string[]

  Returns Promise<
      Required<
          {
              [key: string]: Required<
                  {
                      chapters: Record<
                          string,
                          { chapter?: string; count?: number; id?: string; others?: string[] },
                      >;
                      count: number;
                      volume: string;
                  },
              >;
          },
      >,
  >

StaticgetAllReadingStatus

• getAllReadingStatus(
      filter?:
          | "completed"
          | "reading"
          | "on_hold"
          | "plan_to_read"
          | "dropped"
          | "re_reading",
  ): Promise<
      Record<
          string,
          | "completed"
          | "reading"
          | "on_hold"
          | "plan_to_read"
          | "dropped"
          | "re_reading",
      >,
  >

  Get every reading status (eg completed, reading, dropped, etc) for every manga marked by the currently authenticated user.

  Parameters

  • Optionalfilter: "completed" | "reading" | "on_hold" | "plan_to_read" | "dropped" | "re_reading"

    If specified, only manga with this status will be returned

  Returns Promise<
      Record<
          string,
          | "completed"
          | "reading"
          | "on_hold"
          | "plan_to_read"
          | "dropped"
          | "re_reading",
      >,
  >

StaticgetByQuery

• getByQuery(
      query?: Partial<Merge<GetSearchMangaParamsSchema, MangaSearchHelpers>>,
  ): Promise<Manga | null>

  Performs a search for a manga and returns the first one found. If no results are found, null is returned

  Parameters

  • Optionalquery: Partial<Merge<GetSearchMangaParamsSchema, MangaSearchHelpers>>

  Returns Promise<Manga | null>

StaticgetDraft

• getDraft(
      id: string,
      expandedTypes?: ReferenceExpansionMangaSchema,
  ): Promise<Manga>

  Retrieves a manga draft by its UUID

  Parameters

  • id: string
  • OptionalexpandedTypes: ReferenceExpansionMangaSchema

  Returns Promise<Manga>

StaticgetFeed

• getFeed(
      id: string,
      params?: Partial<
          Merge<
              GetChapterParamsSchema,
              { groups: Group[]; ids: Chapter[]; uploader: User
              | User[] },
          >,
      >,
  ): Promise<Chapter[]>

  Returns an array of a manga's chapters

  Parameters

  • id: string
  • Optionalparams: Partial<
        Merge<
            GetChapterParamsSchema,
            { groups: Group[]; ids: Chapter[]; uploader: User
            | User[] },
        >,
    >

  Returns Promise<Chapter[]>

StaticgetFollowedFeed

• getFollowedFeed(
      query?: Partial<
          Merge<
              GetChapterParamsSchema,
              { groups: Group[]; ids: Chapter[]; uploader: User
              | User[] },
          >,
      >,
  ): Promise<Chapter[]>

  Gets the combined feed of every manga followed by the logged in user

  Parameters

  • Optionalquery: Partial<
        Merge<
            GetChapterParamsSchema,
            { groups: Group[]; ids: Chapter[]; uploader: User
            | User[] },
        >,
    >

  Returns Promise<Chapter[]>

StaticgetFollowedManga

• getFollowedManga(query?: RequestQuery): Promise<Manga[]>

  Returns all manga followed by the currently authenticated user

  Parameters

  • query: RequestQuery = ...

  Returns Promise<Manga[]>

StaticgetMultiple

• getMultiple(
      ids: string[],
      extraParams?: Omit<
          Partial<Merge<GetSearchMangaParamsSchema, MangaSearchHelpers>>,
          "ids",
      >,
  ): Promise<Manga[]>

  Retrieves an array of manga by an array of their ids

  Parameters

  • ids: string[]
  • OptionalextraParams: Omit<Partial<Merge<GetSearchMangaParamsSchema, MangaSearchHelpers>>, "ids">

  Returns Promise<Manga[]>

StaticgetRandom

• getRandom(
      query?: Pick<
          Partial<Merge<GetSearchMangaParamsSchema, MangaSearchHelpers>>,
          keyof GetMangaRandomParamsSchema,
      >,
  ): Promise<Manga>

  Retrieves a random manga

  Parameters

  • Optionalquery: Pick<
        Partial<Merge<GetSearchMangaParamsSchema, MangaSearchHelpers>>,
        keyof GetMangaRandomParamsSchema,
    >

  Returns Promise<Manga>

StaticgetReadChapters

• getReadChapters(ids: string[] | Manga[]): Promise<Record<string, Chapter[]>>

  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.

  Parameters

  • ids: string[] | Manga[]

  Returns Promise<Record<string, Chapter[]>>

StaticgetReadingStatus

• getReadingStatus(
      id: string,
  ): Promise<
      | "completed"
      | "reading"
      | "on_hold"
      | "plan_to_read"
      | "dropped"
      | "re_reading",
  >

  Gets the reading status (eg completed, reading, dropped, etc) for a manga for the currently authenticated user

  Parameters

  • id: string

  Returns Promise<
      | "completed"
      | "reading"
      | "on_hold"
      | "plan_to_read"
      | "dropped"
      | "re_reading",
  >

StaticgetRelations

• getRelations(id: string, expandTypes?: boolean): Promise<RelatedManga>

  Gets all of a manga's relations to other manga.

  Parameters

  • id: string
  • expandTypes: boolean = false

  Returns Promise<RelatedManga>

StaticgetStatistics

• getStatistics(
      ids: string[] | Manga[],
  ): Promise<
      Record<
          string,
          Required<
              {
                  comments: StatisticsDetailsCommentsSchema;
                  follows: number;
                  rating: Required<{ average: number | null; bayesian: number }>;
              },
          >,
      >,
  >

  Gets the statistics about manga including their rating distribution, comment count, and follow count

  Parameters

  • ids: string[] | Manga[]

  Returns Promise<
      Record<
          string,
          Required<
              {
                  comments: StatisticsDetailsCommentsSchema;
                  follows: number;
                  rating: Required<{ average: number | null; bayesian: number }>;
              },
          >,
      >,
  >

StaticgetTotalSearchResults

• getTotalSearchResults(
      query?: Omit<
          Partial<Merge<GetSearchMangaParamsSchema, MangaSearchHelpers>>,
          "offset" | "limit",
      >,
  ): Promise<number>

  Returns how many manga there are total for a search query

  Parameters

  • Optionalquery: Omit<
        Partial<Merge<GetSearchMangaParamsSchema, MangaSearchHelpers>>,
        "offset" | "limit",
    >

  Returns Promise<number>

StaticgetUserRatings

• getUserRatings(
      ids: string[] | Manga[],
  ): Promise<Record<string, { createdAt: Date; rating: number } | null>>

  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.

  Parameters

  • ids: string[] | Manga[]

  Returns Promise<Record<string, { createdAt: Date; rating: number } | null>>

StaticgiveRating

• giveRating(mangaId: string, rating: number): Promise<void>

  Makes the currently authenticated user give a manga a rating between 1-10 (inclusive).

  Parameters

  • mangaId: string
  • rating: number

  Returns Promise<void>

StaticremoveRating

• removeRating(mangaId: string): Promise<void>

  Removes the currently authenticated user's rating for a manga

  Parameters

  • mangaId: string

  Returns Promise<void>

StaticremoveRelation

• removeRelation(mangaId: string, relationId: string): Promise<void>

  Removes a relation from a manga by the relation's id

  Parameters

  • mangaId: string
  • relationId: string

  Returns Promise<void>

Staticsearch

• search(
      query?: Partial<Merge<GetSearchMangaParamsSchema, MangaSearchHelpers>>,
  ): Promise<Manga[]>

  Retrieves a list of manga according to the specified search parameters

  Parameters

  • Optionalquery: Partial<Merge<GetSearchMangaParamsSchema, MangaSearchHelpers>>

  Returns Promise<Manga[]>

  See

  Relationship.cached for information on how to automatically resolve Relationships

StaticsearchDrafts

• searchDrafts(query?: Partial<GetMangaDraftsParamsSchema>): Promise<Manga[]>

  Retrieves a list of manga drafts according to the specified search parameters

  Parameters

  • Optionalquery: Partial<GetMangaDraftsParamsSchema>

  Returns Promise<Manga[]>

  See

  Relationship.cached for information on how to automatically resolve Relationships

StaticsetReadingStatus

• setReadingStatus(
      id: string,
      status:
          | "completed"
          | "reading"
          | "on_hold"
          | "plan_to_read"
          | "dropped"
          | "re_reading"
          | null,
  ): Promise<void>

  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.

  Parameters

  • id: string
  • status:
        | "completed"
        | "reading"
        | "on_hold"
        | "plan_to_read"
        | "dropped"
        | "re_reading"
        | null

  Returns Promise<void>

StaticupdateReadChapters

• updateReadChapters(
      manga: string,
      chapters: { read?: (string | Chapter)[]; unread?: (string | Chapter)[] },
      updateHistory?: boolean,
  ): Promise<never[] | undefined>

  Marks lists of chapters read or unread for a single manga

  Parameters

  • manga: string
  • chapters: { read?: (string | Chapter)[]; unread?: (string | Chapter)[] }
  • updateHistory: boolean = false

  Returns Promise<never[] | undefined>