@zennomi/mangadex-full-api/src/types/schema.ts

A MangaDex api based around the official API.

/* eslint-disable */
/* tslint:disable */
/*
 * ---------------------------------------------------------------
 * ## THIS FILE WAS GENERATED VIA SWAGGER-TYPESCRIPT-API        ##
 * ##                                                           ##
 * ## AUTHOR: acacode                                           ##
 * ## SOURCE: https://github.com/acacode/swagger-typescript-api ##
 * ---------------------------------------------------------------
 */

/** MangaRequest */
export interface MangaRequestSchema {
    title: LocalizedStringSchema;
    altTitles: LocalizedStringSchema[];
    description: LocalizedStringSchema;
    authors: string[];
    artists: string[];
    links: Record<string, string>;
    /** @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 */
export type LocalizedStringSchema = Record<string, string>;

/** MangaResponse */
export interface MangaResponseSchema {
    result: 'ok' | 'error';
    /** @default "entity" */
    response: string;
    data: MangaSchema;
}

/** ChapterResponse */
export interface ChapterResponseSchema {
    result: 'ok' | 'error';
    /** @default "entity" */
    response: string;
    data: ChapterSchema;
}

/** Relationship */
export 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 */
export interface ChapterSchema {
    /** @format uuid */
    id: string;
    type: 'chapter';
    attributes: ChapterAttributesSchema;
    relationships: RelationshipSchema[];
}

/** Manga */
export interface MangaSchema {
    /** @format uuid */
    id: string;
    type: 'manga';
    attributes: MangaAttributesSchema;
    relationships: RelationshipSchema[];
}

/** ErrorResponse */
export interface ErrorResponseSchema {
    /** @default "error" */
    result: string;
    errors: ErrorSchema[];
}

/** Error */
export interface ErrorSchema {
    id: string;
    status: number;
    title: string;
    detail: string | null;
    context: string | null;
}

/** ChapterAttributes */
export 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;
}

/** MangaAttributes */
export interface MangaAttributesSchema {
    title: LocalizedStringSchema;
    altTitles: LocalizedStringSchema[];
    description: LocalizedStringSchema;
    isLocked: boolean;
    links: Record<string, string>;
    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;
}

export type MangaCreateSchema = MangaRequestSchema;

export type MangaEditSchema = MangaRequestSchema;

export type ChapterEditSchema = ChapterRequestSchema;

/** Response */
export interface ResponseSchema {
    result: 'ok' | 'error';
}

/** Login */
export interface LoginSchema {
    /**
     * @minLength 1
     * @maxLength 64
     */
    username?: string;
    email?: string;
    /**
     * @minLength 8
     * @maxLength 1024
     */
    password: string;
}

/** LoginResponse */
export interface LoginResponseSchema {
    result: 'ok' | 'error';
    token: {
        session?: string;
        refresh?: string;
    };
}

/** CheckResponse */
export interface CheckResponseSchema {
    /** @default "ok" */
    result: string;
    isAuthenticated: boolean;
    roles: string[];
    permissions: string[];
}

/** LogoutResponse */
export interface LogoutResponseSchema {
    result: 'ok' | 'error';
}

/** RefreshToken */
export interface RefreshTokenSchema {
    /** @minLength 1 */
    token: string;
}

/** RefreshResponse */
export interface RefreshResponseSchema {
    result: 'ok' | 'error';
    token?: {
        session?: string;
        refresh?: string;
    };
    message?: string;
}

/** AccountActivateResponse */
export interface AccountActivateResponseSchema {
    result: 'ok';
}

/** CreateAccount */
export interface CreateAccountSchema {
    /**
     * @minLength 1
     * @maxLength 64
     */
    username: string;
    /**
     * @minLength 8
     * @maxLength 1024
     */
    password: string;
    /** @format email */
    email: string;
}

/** ScanlationGroupResponse */
export interface ScanlationGroupResponseSchema {
    result: 'ok';
    /** @default "entity" */
    response: string;
    data: ScanlationGroupSchema;
}

/** ScanlationGroup */
export interface ScanlationGroupSchema {
    /** @format uuid */
    id: string;
    type: 'scanlation_group';
    attributes: ScanlationGroupAttributesSchema;
    relationships: RelationshipSchema[];
}

/** ScanlationGroupAttributes */
export 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 */
export interface UserSchema {
    /** @format uuid */
    id: string;
    type: 'user';
    attributes: UserAttributesSchema;
    relationships: RelationshipSchema[];
}

/** UserAttributes */
export interface UserAttributesSchema {
    username: string;
    roles: string[];
    /** @min 1 */
    version: number;
}

/** CreateScanlationGroup */
export 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;
}

/** ScanlationGroupEdit */
export interface ScanlationGroupEditSchema {
    name?: string;
    /** @format uuid */
    leader?: string;
    members?: string[];
    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;
    focusedLanguages?: string[] | null;
    inactive?: boolean;
    locked?: boolean;
    publishDelay?: string;
    /** @min 1 */
    version: number;
}

/** CustomListCreate */
export interface CustomListCreateSchema {
    name: string;
    visibility?: 'public' | 'private';
    manga?: string[];
    /** @min 1 */
    version?: number;
}

/** CustomListEdit */
export interface CustomListEditSchema {
    name?: string;
    visibility?: 'public' | 'private';
    manga?: string[];
    /** @min 1 */
    version: number;
}

/** CustomListResponse */
export interface CustomListResponseSchema {
    result: 'ok' | 'error';
    /** @default "entity" */
    response: string;
    data: CustomListSchema;
}

/** CustomList */
export interface CustomListSchema {
    /** @format uuid */
    id: string;
    type: 'custom_list';
    attributes: CustomListAttributesSchema;
    relationships: RelationshipSchema[];
}

/** CustomListAttributes */
export interface CustomListAttributesSchema {
    name: string;
    visibility: 'private' | 'public';
    /** @min 1 */
    version: number;
}

/** CoverResponse */
export interface CoverResponseSchema {
    result: string;
    /** @default "entity" */
    response: string;
    data: CoverSchema;
}

/** Cover */
export interface CoverSchema {
    /** @format uuid */
    id: string;
    type: 'cover_art';
    attributes: CoverAttributesSchema;
    relationships: RelationshipSchema[];
}

/** CoverAttributes */
export 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 */
export 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]+)?$
 */
export type CoverVolumeSchema = string | null;

/**
 * ChapterVolume
 * @maxLength 8
 * @pattern ^((0|[1-9]\d*)(\.\d+)?[a-z]?)?$
 */
export type ChapterVolumeSchema = string | null;

/** AuthorResponse */
export interface AuthorResponseSchema {
    result: string;
    /** @default "entity" */
    response: string;
    data: AuthorSchema;
}

/** Author */
export interface AuthorSchema {
    /** @format uuid */
    id: string;
    type: 'author';
    attributes: AuthorAttributesSchema;
    relationships: RelationshipSchema[];
}

/** AuthorAttributes */
export 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;
}

/** AuthorEdit */
export interface AuthorEditSchema {
    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;
    /** @min 1 */
    version: number;
}

/** AuthorCreate */
export 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;
}

/** ApiClientResponse */
export interface ApiClientResponseSchema {
    result: string;
    /** @default "entity" */
    response: string;
    data: ApiClientSchema;
}

/** ApiClient */
export interface ApiClientSchema {
    /** @format uuid */
    id: string;
    type: 'api_client';
    attributes: ApiClientAttributesSchema;
    relationships: RelationshipSchema[];
}

/** ApiClientAttributes */
export interface ApiClientAttributesSchema {
    name: string;
    /** @maxLength 256 */
    description: string | null;
    profile: string;
    externalClientId: string | null;
    isActive: boolean;
    state: 'requested' | 'approved' | 'rejected' | 'autoapproved';
    /** @format date-time */
    createdAt: Date;
    /** @format date-time */
    updatedAt: Date;
    /** @min 1 */
    version: number;
}

/** ApiClient */
export interface ApiClientEditSchema {
    description?: string | null;
    /** @min 1 */
    version: number;
}

/** ApiClientCreate */
export interface ApiClientCreateSchema {
    /**
     * @minLength 5
     * @maxLength 32
     */
    name: string;
    /** @maxLength 256 */
    description?: string | null;
    profile: 'personal';
    /** @min 1 */
    version?: number;
}

/** MappingIdBody */
export interface MappingIdBodySchema {
    type: 'group' | 'manga' | 'chapter' | 'tag';
    ids: number[];
}

/** MappingIdResponse */
export interface MappingIdResponseSchema {
    /** @default "ok" */
    result: string;
    /** @default "collection" */
    response: string;
    data: MappingIdSchema[];
    limit: number;
    offset: number;
    total: number;
}

/** MappingId */
export interface MappingIdSchema {
    /** @format uuid */
    id: string;
    type: 'mapping_id';
    attributes: MappingIdAttributesSchema;
    relationships: RelationshipSchema[];
}

/** MappingIdAttributes */
export interface MappingIdAttributesSchema {
    type: 'manga' | 'chapter' | 'group' | 'tag';
    legacyId: number;
    /** @format uuid */
    newId: string;
}

/** TagResponse */
export interface TagResponseSchema {
    /** @default "ok" */
    result: string;
    /** @default "collection" */
    response: string;
    data: TagSchema[];
    limit: number;
    offset: number;
    total: number;
}

/** Tag */
export interface TagSchema {
    /** @format uuid */
    id: string;
    type: 'tag';
    attributes: TagAttributesSchema;
    relationships: RelationshipSchema[];
}

/** TagAttributes */
export interface TagAttributesSchema {
    name: LocalizedStringSchema;
    description: LocalizedStringSchema;
    group: 'content' | 'format' | 'genre' | 'theme';
    /** @min 1 */
    version: number;
}

/** UserResponse */
export interface UserResponseSchema {
    result: 'ok';
    /** @default "entity" */
    response: string;
    data: UserSchema;
}

/** SendAccountActivationCode */
export interface SendAccountActivationCodeSchema {
    /** @format email */
    email: string;
}

/** RecoverCompleteBody */
export interface RecoverCompleteBodySchema {
    /**
     * @minLength 8
     * @maxLength 1024
     */
    newPassword: string;
}

/** UpdateMangaStatus */
export interface UpdateMangaStatusSchema {
    status: 'reading' | 'on_hold' | 'plan_to_read' | 'dropped' | 're_reading' | 'completed' | null;
}

/** ChapterRequest */
export 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 */
export interface CoverListSchema {
    /** @default "ok" */
    result: string;
    /** @default "collection" */
    response: string;
    data: CoverSchema[];
    limit: number;
    offset: number;
    total: number;
}

/** AuthorList */
export interface AuthorListSchema {
    /** @default "ok" */
    result: string;
    /** @default "collection" */
    response: string;
    data: AuthorSchema[];
    limit: number;
    offset: number;
    total: number;
}

/** ApiClientList */
export interface ApiClientListSchema {
    /** @default "ok" */
    result: string;
    /** @default "collection" */
    response: string;
    data: ApiClientSchema[];
    limit: number;
    offset: number;
    total: number;
}

/** ChapterList */
export interface ChapterListSchema {
    /** @default "ok" */
    result: string;
    /** @default "collection" */
    response: string;
    data: ChapterSchema[];
    limit: number;
    offset: number;
    total: number;
}

/** ScanlationGroupList */
export interface ScanlationGroupListSchema {
    /** @default "ok" */
    result: string;
    /** @default "collection" */
    response: string;
    data: ScanlationGroupSchema[];
    limit: number;
    offset: number;
    total: number;
}

export type MangaRelationCreateSchema = MangaRelationRequestSchema;

/** MangaRelationRequest */
export 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 */
export interface MangaRelationListSchema {
    /** @default "ok" */
    result: string;
    /** @default "collection" */
    response: string;
    data: MangaRelationSchema[];
    limit: number;
    offset: number;
    total: number;
}

/** MangaRelationResponse */
export interface MangaRelationResponseSchema {
    result: 'ok' | 'error';
    /** @default "entity" */
    response: string;
    data: MangaRelationSchema;
}

/** MangaRelation */
export interface MangaRelationSchema {
    /** @format uuid */
    id: string;
    type: 'manga_relation';
    attributes: MangaRelationAttributesSchema;
    relationships: RelationshipSchema[];
}

/** MangaRelationAttributes */
export 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 */
export interface MangaListSchema {
    /** @default "ok" */
    result: string;
    /** @default "collection" */
    response: string;
    data: MangaSchema[];
    limit: number;
    offset: number;
    total: number;
}

/** CustomListList */
export interface CustomListListSchema {
    /** @default "ok" */
    result: string;
    /** @default "collection" */
    response: string;
    data: CustomListSchema[];
    limit: number;
    offset: number;
    total: number;
}

/** UserList */
export interface UserListSchema {
    /** @default "ok" */
    result: string;
    /** @default "collection" */
    response: string;
    data: UserSchema[];
    limit: number;
    offset: number;
    total: number;
}

/** UploadSession */
export interface UploadSessionSchema {
    /** @format uuid */
    id: string;
    type: 'upload_session';
    attributes: UploadSessionAttributesSchema;
}

/** UploadSessionAttributes */
export interface UploadSessionAttributesSchema {
    isCommitted: boolean;
    isProcessed: boolean;
    isDeleted: boolean;
    /** @min 1 */
    version: number;
    /** @format date-time */
    createdAt: Date;
    /** @format date-time */
    updatedAt: Date;
}

/** UploadSessionFile */
export interface UploadSessionFileSchema {
    /** @format uuid */
    id: string;
    type: 'upload_session_file';
    attributes: UploadSessionFileAttributesSchema;
}

/** UploadSessionFileAttributes */
export interface UploadSessionFileAttributesSchema {
    originalFileName: string;
    fileHash: string;
    fileSize: number;
    mimeType: string;
    source: 'local' | 'remote';
    /** @min 1 */
    version: number;
}

/** ChapterReadMarkersBatch */
export type ChapterReadMarkerBatchSchema = {
    chapterIdsRead: string[];
    chapterIdsUnread: string[];
};

/** BeginUploadSession */
export interface BeginUploadSessionSchema {
    /** @maxItems 10 */
    groups: string[];
    /**
     * @format uuid
     * @minLength 36
     * @maxLength 36
     */
    manga: string;
}

/** BeginEditSession */
export interface BeginEditSessionSchema {
    /** @min 1 */
    version: number;
}

/** BeginUploadSession */
export interface CommitUploadSessionSchema {
    chapterDraft: ChapterDraftSchema;
    /**
     * ordered list of Upload Session File ids
     * @maxItems 500
     * @minItems 1
     */
    pageOrder: string[];
}

export 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;
}

/** ReportListResponse */
export interface ReportListResponseSchema {
    result: 'ok' | 'error';
    /** @default "collection" */
    response: string;
    data: ReportSchema[];
    limit: number;
    offset: number;
    total: number;
}

/** Report */
export interface ReportSchema {
    /** @format uuid */
    id: string;
    type: 'report';
    attributes: ReportAttributesSchema;
    relationships: RelationshipSchema[];
}

/** ReportAttributes */
export interface ReportAttributesSchema {
    details: string;
    objectId: string;
    status: 'waiting' | 'accepted' | 'refused' | 'autoresolved';
    /** @format date-time */
    createdAt: Date;
}

/** ForumsThreadResponse */
export interface ForumsThreadResponseSchema {
    /** @default "ok" */
    result: string;
    /** @default "entity" */
    response: string;
    data: {
        /** @default "thread" */
        type?: string;
        /** The id for the thread on the forums, accessible at `https://forums.mangadex.org/threads/:id` */
        id?: number;
        attributes?: {
            /** The number of replies so far in the forums thread returned */
            repliesCount?: number;
        };
    };
}

/**
 * ReferenceExpansionAuthor
 * Reference expansion options for author/artist entities or lists
 */
export type ReferenceExpansionAuthorSchema = 'manga'[];

/**
 * ReferenceExpansionApiClient
 * Reference expansion options for api_client entities or lists
 */
export type ReferenceExpansionApiClientSchema = 'creator'[];

/**
 * ReferenceExpansionChapter
 * Reference expansion options for chapter entities or lists
 */
export type ReferenceExpansionChapterSchema = ('manga' | 'scanlation_group' | 'user')[];

/**
 * ReferenceExpansionCoverArt
 * Reference expansion options for cover art entities or lists
 */
export type ReferenceExpansionCoverArtSchema = ('manga' | 'user')[];

/**
 * ReferenceExpansionManga
 * Reference expansion options for manga entities or lists
 */
export type ReferenceExpansionMangaSchema = ('manga' | 'cover_art' | 'author' | 'artist' | 'tag' | 'creator')[];

/**
 * ReferenceExpansionMangaRelation
 * Reference expansion options for manga relation entities or lists
 */
export type ReferenceExpansionMangaRelationSchema = 'manga'[];

/**
 * ReferenceExpansionReport
 * Reference expansion options for user report entities or lists
 */
export type ReferenceExpansionReportSchema = ('user' | 'reason')[];

/**
 * ReferenceExpansionScanlationGroup
 * Reference expansion options for scanlation group entities or lists
 */
export 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.
 */
export 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;

export 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;
    /** @format uuid */
    group: string;
}

export interface GetMangaAggregateParamsSchema {
    translatedLanguage: string[];
    groups: string[];
    /**
     * Manga ID
     * @format uuid
     */
    id: string;
}

export interface GetMangaIdParamsSchema {
    /** Reference expansion options for manga entities or lists */
    includes: ReferenceExpansionMangaSchema;
    /**
     * Manga ID
     * @format uuid
     */
    id: string;
}

export interface GetListApiclientsParamsSchema {
    /**
     * @min 0
     * @max 100
     * @default 10
     */
    limit: number;
    /** @min 0 */
    offset: number;
    state: 'requested' | 'approved' | 'rejected' | 'autoapproved';
    name: string;
    /** Reference expansion options for api_client entities or lists */
    includes: ReferenceExpansionApiClientSchema;
    /** @default {"createdAt":"desc"} */
    order: {
        name?: 'asc' | 'desc';
        createdAt?: 'asc' | 'desc';
        updatedAt?: 'asc' | 'desc';
    };
}

export interface GetApiclientParamsSchema {
    /** Reference expansion options for api_client entities or lists */
    includes: ReferenceExpansionApiClientSchema;
    /**
     * ApiClient ID
     * @format uuid
     */
    id: string;
}

export interface DeleteApiclientParamsSchema {
    /** @pattern ^\d+$ */
    version: string;
    /**
     * ApiClient ID
     * @format uuid
     */
    id: string;
}

export 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';
    };
}

export interface GetGroupIdParamsSchema {
    /** Reference expansion options for scanlation group entities or lists */
    includes: ReferenceExpansionScanlationGroupSchema;
    /**
     * Scanlation Group ID
     * @format uuid
     */
    id: string;
}

export interface GetUserListParamsSchema {
    /**
     * @min 0
     * @max 100
     * @default 10
     */
    limit: number;
    /** @min 0 */
    offset: number;
}

export interface GetUserIdListParamsSchema {
    /**
     * @min 0
     * @max 100
     * @default 10
     */
    limit: number;
    /** @min 0 */
    offset: number;
    /**
     * User ID
     * @format uuid
     */
    id: string;
}

export 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';
    };
}

export 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;
    /**
     * 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')[];
}

export interface GetChapterIdParamsSchema {
    /** Reference expansion options for chapter entities or lists */
    includes: ReferenceExpansionChapterSchema;
    /**
     * Chapter ID
     * @format uuid
     */
    id: string;
}

export interface GetUserFollowsMangaFeedParamsSchema {
    /**
     * @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;
}

export 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;
    /** @format uuid */
    id: string;
}

export 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;
}

export interface GetCoverIdParamsSchema {
    /** Reference expansion options for cover art entities or lists */
    includes: ReferenceExpansionCoverArtSchema;
    /**
     * Is Manga UUID on POST
     * @format uuid
     */
    mangaOrCoverId: string;
}

export 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;
}

export interface GetAuthorIdParamsSchema {
    /** Reference expansion options for author/artist entities or lists */
    includes: ReferenceExpansionAuthorSchema;
    /**
     * Author ID
     * @format uuid
     */
    id: string;
}

export interface GetMangaIdFeedParamsSchema {
    /**
     * @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;
    /**
     * Manga ID
     * @format uuid
     */
    id: string;
}

export interface PostMangaChapterReadmarkersParamsSchema {
    /** Adding this will cause the chapter to be stored in the user's reading history */
    updateHistory?: boolean;
    /** @format uuid */
    id: string;
}

export interface GetMangaChapterReadmarkers2ParamsSchema {
    /** Manga ids */
    ids: string[];
    /** Group results by manga ids */
    grouped?: boolean;
}

export 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';
}

export interface GetAtHomeServerChapterIdParamsSchema {
    /**
     * Force selecting from MangaDex@Home servers that use the standard HTTPS port 443.
     *
     * While the conventional port for HTTPS traffic is 443 and servers are encouraged to use it, it is not a hard requirement as it technically isn't
     * anything special.
     *
     * However, some misbehaving school/office network will at time block traffic to non-standard ports, and setting this flag to `true` will ensure
     * selection of a server that uses these.
     * @default false
     */
    forcePort443: boolean;
    /**
     * Chapter ID
     * @format uuid
     */
    chapterId: string;
}

export interface GetUserFollowsGroupParamsSchema {
    /**
     * @min 1
     * @max 100
     * @default 10
     */
    limit: number;
    /** @min 0 */
    offset: number;
    /** Reference expansion options for scanlation group entities or lists */
    includes: ReferenceExpansionScanlationGroupSchema;
}

export interface GetUserFollowsUserParamsSchema {
    /**
     * @min 1
     * @max 100
     * @default 10
     */
    limit: number;
    /** @min 0 */
    offset: number;
}

export interface GetUserFollowsMangaParamsSchema {
    /**
     * @min 1
     * @max 100
     * @default 10
     */
    limit: number;
    /** @min 0 */
    offset: number;
    /** Reference expansion options for manga entities or lists */
    includes: ReferenceExpansionMangaSchema;
}

export interface GetUserFollowsListParamsSchema {
    /**
     * @min 1
     * @max 100
     * @default 10
     */
    limit: number;
    /** @min 0 */
    offset: number;
}

export interface GetMangaStatusParamsSchema {
    /** Used to filter the list by given status */
    status: 'reading' | 'on_hold' | 'plan_to_read' | 'dropped' | 're_reading' | 'completed';
}

export interface GetMangaIdDraftParamsSchema {
    /** Reference expansion options for manga entities or lists */
    includes: ReferenceExpansionMangaSchema;
    /** @format uuid */
    id: string;
}

export 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;
}

export interface GetReportsParamsSchema {
    /**
     * @min 1
     * @max 100
     * @default 10
     */
    limit: number;
    /** @min 0 */
    offset: number;
    category: 'manga' | 'chapter' | 'scanlation_group' | 'user' | 'author';
    /**
     * @format uuid
     * @minLength 36
     * @maxLength 36
     */
    reasonId: string;
    /**
     * @format uuid
     * @minLength 36
     * @maxLength 36
     */
    objectId: string;
    status: 'waiting' | 'accepted' | 'refused' | 'autoresolved';
    /** @default {"createdAt":"desc"} */
    order: {
        createdAt?: 'asc' | 'desc';
    };
    /** Reference expansion options for user report entities or lists */
    includes: ReferenceExpansionReportSchema;
}

export interface GetMangaRelationParamsSchema {
    /** Referenc