@zennomi/mangadex-full-api/dist/index.d.ts

A MangaDex api based around the official API.

/** MangaRequest */
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 */
type LocalizedStringSchema = Record<string, string>;
/** 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;
}
/** MangaAttributes */
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;
}
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;
    /** @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;
    /**
     * 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;
    /** @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';
            /** @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<string, {
                volume?: string;
                count?: number;
                chapters?: Record<string, {
                    chapter?: string;
                    /** @format uuid */
                    id?: string;
                    others?: string[];
                    count?: number;
                }>;
            }>;
        };
    }
    /**
     * @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;
        };
        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<string, string[]>;
        };
    }
    /**
     * 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<string, 'reading' | 'on_hold' | 'plan_to_read' | 'dropped' | 're_reading' | 'completed'>;
        };
    }
    /**
     * 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 = Use