anixartjs 0.0.1

package/dist/classes/Channel.d.ts

@@ -0,0 +1,47 @@
+import { Anixart } from "../client";
+import { IChannel, IChannelBlockInfo, IChannelBlockManageRequest, IChannelCreateRequest, ResponseCode } from "../types";
+import { ArticleBuilder } from "../utils/ArticleBuilder";
+import { SuggestionArticle } from "./SuggestionArticle";
+import { Article } from "./Article";
+import { BaseProfile } from "./BaseProfile";
+import { FullProfile } from "./FullProfile";
+export declare class Channel {
+    private readonly client;
+    readonly id: number;
+    readonly title: string;
+    readonly description: string;
+    readonly channelAvatar: string;
+    readonly channelCover: string;
+    readonly clientPermission: number;
+    readonly articleCount: number;
+    readonly subscriberCount: number;
+    readonly creationDate: Date;
+    readonly lastUpdateDate: Date;
+    readonly isBlog: boolean;
+    readonly isCommentingEnabled: boolean;
+    readonly isArticleSuggestionEnabled: boolean;
+    readonly isVerified: boolean;
+    readonly isDeleted: boolean;
+    readonly blogProfileId: number;
+    readonly isSubscribed: boolean;
+    readonly isBlocked: boolean;
+    readonly blockReason: string;
+    readonly blockExpiredDate: Date;
+    readonly isPermBlocked: boolean;
+    readonly isAdministratorOrHigher: boolean;
+    constructor(client: Anixart, channelResponce: IChannel);
+    private writeProperties;
+    getArticles(page: number, date?: number): Promise<(Article | undefined)[]>;
+    getArticleById(id: number): Promise<Article | null>;
+    createArticle(data: ArticleBuilder): Promise<Article | null>;
+    subscribe(): Promise<ResponseCode>;
+    unsubscribe(): Promise<ResponseCode>;
+    setAvatar(file: Buffer): Promise<this>;
+    setCover(file: Buffer): Promise<this>;
+    getMediaToken(isSuggestionMode?: boolean, isEditMode?: boolean): Promise<string | null>;
+    edit(data: IChannelCreateRequest): Promise<Channel | null>;
+    getArticleSuggestions(page: number): Promise<(SuggestionArticle[] | null)>;
+    createArticleSuggestion(data: ArticleBuilder): Promise<SuggestionArticle | null>;
+    manageBlocklist(profile: BaseProfile | FullProfile | number, data: Omit<IChannelBlockManageRequest, "target_profile_id">): Promise<ResponseCode>;
+    getBlocklist(profile: BaseProfile | FullProfile | number): Promise<IChannelBlockInfo | null>;
+}

package/dist/classes/Channel.js

@@ -0,0 +1,103 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Channel = void 0;
+const SuggestionArticle_1 = require("./SuggestionArticle");
+const Article_1 = require("./Article");
+class Channel {
+    constructor(client, channelResponce) {
+        this.client = client;
+        this.id = channelResponce.id;
+        this.title = channelResponce.title;
+        this.description = channelResponce.description;
+        this.channelAvatar = channelResponce.avatar;
+        this.channelCover = channelResponce.cover;
+        this.clientPermission = channelResponce.permission;
+        this.articleCount = channelResponce.article_count;
+        this.subscriberCount = channelResponce.subscriber_count;
+        this.creationDate = new Date(channelResponce.creation_date * 1000);
+        this.lastUpdateDate = new Date(channelResponce.last_update_date * 1000);
+        this.isBlog = channelResponce.is_blog;
+        this.isCommentingEnabled = channelResponce.is_commenting_enabled;
+        this.isArticleSuggestionEnabled = channelResponce.is_article_suggestion_enabled;
+        this.isVerified = channelResponce.is_verified;
+        this.isDeleted = channelResponce.is_deleted;
+        this.blogProfileId = channelResponce.blog_profile_id;
+        this.isSubscribed = channelResponce.is_subscribed;
+        this.isBlocked = channelResponce.is_blocked;
+        this.blockReason = channelResponce.block_reason;
+        this.blockExpiredDate = new Date(channelResponce.block_expire_date * 1000);
+        this.isPermBlocked = channelResponce.is_perm_blocked;
+        this.isAdministratorOrHigher = channelResponce.is_administrator_or_higher;
+    }
+    writeProperties(prop, value) {
+        this[prop] = value;
+    }
+    async getArticles(page, date) {
+        const request = await this.client.endpoints.channel.getArticles(this.id, page, date !== null && date !== void 0 ? date : 0);
+        return request.content.map(article => new Article_1.Article(this.client, article, this));
+    }
+    async getArticleById(id) {
+        const request = await this.client.endpoints.channel.getArticle(id);
+        return request.article ? new Article_1.Article(this.client, request.article) : null;
+    }
+    async createArticle(data) {
+        const request = await this.client.endpoints.channel.createArticle(this.id, data.returnBuildAricle());
+        return request.article ? new Article_1.Article(this.client, request.article) : null;
+    }
+    async subscribe() {
+        const request = await this.client.endpoints.channel.subscribe(this.id);
+        if (request.code == 0) {
+            this.writeProperties("isSubscribed", true);
+        }
+        return request.code;
+    }
+    async unsubscribe() {
+        const request = await this.client.endpoints.channel.unsubscribe(this.id);
+        if (request.code == 0) {
+            this.writeProperties("isSubscribed", false);
+        }
+        return request.code;
+    }
+    async setAvatar(file) {
+        const request = await this.client.endpoints.channel.uploadChannelAvatar(this.id, file);
+        if (request.code == 0) {
+            this.writeProperties("channelAvatar", request.url);
+        }
+        return this;
+    }
+    async setCover(file) {
+        const request = await this.client.endpoints.channel.uploadChannelCover(this.id, file);
+        if (request.code == 0) {
+            this.writeProperties("channelCover", request.url);
+        }
+        return this;
+    }
+    async getMediaToken(isSuggestionMode = false, isEditMode = false) {
+        const request = await this.client.endpoints.channel.getAvaliableEditor(this.id, isSuggestionMode, isEditMode);
+        return request.media_upload_token;
+    }
+    async edit(data) {
+        const request = await this.client.endpoints.channel.editChannel(this.id, data);
+        return (request === null || request === void 0 ? void 0 : request.channel) ? new Channel(this.client, request.channel) : null;
+    }
+    async getArticleSuggestions(page) {
+        const request = await this.client.endpoints.channel.getArticleSuggestions(this.id, page);
+        return request.content ? request.content.map(article => new SuggestionArticle_1.SuggestionArticle(this.client, article, this)) : null;
+    }
+    async createArticleSuggestion(data) {
+        const request = await this.client.endpoints.channel.createArticleSuggestion(this.id, data.returnBuildAricle());
+        return request.code == 0 ? new SuggestionArticle_1.SuggestionArticle(this.client, request.article, this) : null;
+    }
+    async manageBlocklist(profile, data) {
+        const request = await this.client.endpoints.channel.manageChannelBlocklist(this.id, {
+            target_profile_id: typeof (profile) == "number" ? profile : profile.id,
+            ...data
+        });
+        return request.code;
+    }
+    async getBlocklist(profile) {
+        const request = await this.client.endpoints.channel.getChannelBlock(this.id, typeof (profile) == "number" ? profile : profile.id);
+        return request.channel_block;
+    }
+}
+exports.Channel = Channel;

package/dist/classes/Dubber.d.ts

@@ -0,0 +1,19 @@
+import { Release } from "./Release";
+import { Anixart } from "../client";
+import { IDubber } from "../types";
+import { Source } from "./Source";
+export declare class Dubber {
+    private readonly client;
+    readonly release: Release;
+    readonly localId: number;
+    readonly id: number;
+    readonly episodeCount: number;
+    readonly icon: string | null;
+    readonly name: string;
+    readonly isSub: boolean;
+    readonly pinned: boolean;
+    readonly viewCount: number;
+    readonly workers: string;
+    constructor(client: Anixart, dubberResponce: IDubber, release: Release);
+    getSources(): Promise<Source[]>;
+}

package/dist/classes/Dubber.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Dubber = void 0;
+const Source_1 = require("./Source");
+class Dubber {
+    constructor(client, dubberResponce, release) {
+        this.client = client;
+        this.release = release;
+        this.localId = dubberResponce["@id"];
+        this.id = dubberResponce.id;
+        this.episodeCount = dubberResponce.episode_count;
+        this.icon = dubberResponce.icon;
+        this.name = dubberResponce.name;
+        this.isSub = dubberResponce.is_sub;
+        this.pinned = dubberResponce.pinned,
+            this.viewCount = dubberResponce.view_count;
+        this.workers = dubberResponce.workers;
+    }
+    async getSources() {
+        const request = await this.client.endpoints.release.getDubberSources(this.release.id, this.id);
+        return request.sources.map(source => new Source_1.Source(this.client, source, this));
+    }
+}
+exports.Dubber = Dubber;

package/dist/classes/Episode.d.ts

@@ -0,0 +1,20 @@
+import { Anixart } from '../client';
+import { IEpisode, IRelease, ISource, ResponseCode } from '../types';
+import { Source } from './Source';
+export declare class Episode {
+    private readonly client;
+    readonly source: Source;
+    readonly localId: number;
+    readonly position: number;
+    readonly release: IRelease | number;
+    readonly sourceRaw: ISource | number;
+    readonly name: string;
+    readonly url: string;
+    readonly iframe: boolean;
+    readonly addedDate: Date;
+    readonly isFilter: boolean;
+    readonly isWatched: boolean;
+    constructor(client: Anixart, episode: IEpisode, source: Source);
+    setWatched(isWatched: boolean): Promise<ResponseCode>;
+    addToHistory(): Promise<ResponseCode>;
+}

package/dist/classes/Episode.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Episode = void 0;
+class Episode {
+    constructor(client, episode, source) {
+        this.client = client;
+        this.source = source;
+        this.localId = episode["@id"];
+        this.position = episode.position;
+        this.release = episode.release;
+        this.sourceRaw = episode.source;
+        this.name = episode.name;
+        this.url = episode.url;
+        this.iframe = episode.iframe;
+        this.addedDate = new Date(episode.addedDate * 1000);
+        this.isFilter = episode.is_filter;
+        this.isWatched = episode.is_watched;
+    }
+    async setWatched(isWatched) {
+        const request = isWatched ?
+            await this.client.endpoints.release.markEpisodeAsWatched(this.source.dubber.release.id, this.source.id, this.position)
+            : await this.client.endpoints.release.unmarkEpisodeAsWatched(this.source.dubber.release.id, this.source.id, this.position);
+        return request.code;
+    }
+    async addToHistory() {
+        const request = await this.client.endpoints.release.addToHistory(this.source.dubber.release.id, this.source.id, this.position);
+        return request.code;
+    }
+}
+exports.Episode = Episode;

package/dist/classes/FullProfile.d.ts

@@ -0,0 +1,53 @@
+import { Anixart } from "../client";
+import { BaseProfile } from "./BaseProfile";
+import { IProfile, IRole } from "../types";
+import { Release } from "./Release";
+export declare class FullProfile extends BaseProfile {
+    readonly client: Anixart;
+    readonly status: string;
+    readonly sponsorshipExpires: number;
+    readonly history: Release[];
+    readonly votes: Release[];
+    readonly lastActivityTime: number;
+    readonly registerDate: number;
+    readonly vkPage: string;
+    readonly tgPage: string;
+    readonly instPage: string;
+    readonly ttPage: string;
+    readonly discordPage: string;
+    readonly banNote: unknown;
+    readonly watchingCount: number;
+    readonly planCount: number;
+    readonly completedCount: number;
+    readonly holdOnCount: number;
+    readonly droppedCount: number;
+    readonly favoriteCount: number;
+    readonly commentCount: number;
+    readonly collectionCount: number;
+    readonly videoCount: number;
+    readonly watchedEpisodeCount: number;
+    readonly watchedTime: number;
+    readonly isPrivate: boolean;
+    readonly isSponsorTransferred: boolean;
+    readonly isBookmarksTransferred: boolean;
+    readonly isVkBound: boolean;
+    readonly isGoogleBound: boolean;
+    readonly isReleaseTypeNotificationsEnabled: boolean;
+    readonly isEpisodeNotificationsEnabled: boolean;
+    readonly isFirstEpisodeNotificationEnabled: boolean;
+    readonly isRelatedReleaseNotificationsEnabled: boolean;
+    readonly isReportProcessNotificationsEnabled: boolean;
+    readonly isCommentNotificationsEnabled: boolean;
+    readonly isMyCollectionCommentNotificationsEnabled: boolean;
+    readonly watchDynamics: any[];
+    readonly ratingScore: number;
+    readonly isPermBanned: boolean;
+    readonly isBlocked: boolean;
+    readonly isMeBlocked: boolean;
+    readonly isStatsHidden: boolean;
+    readonly isCountsHidden: boolean;
+    readonly isSocialHidden: boolean;
+    readonly isFriendRequestsDisallowed: boolean;
+    readonly roles: IRole[];
+    constructor(client: Anixart, profile: IProfile);
+}

package/dist/classes/FullProfile.js

@@ -0,0 +1,75 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FullProfile = void 0;
+const BaseProfile_1 = require("./BaseProfile");
+const Release_1 = require("./Release");
+class FullProfile extends BaseProfile_1.BaseProfile {
+    constructor(client, profile) {
+        var _a, _b, _c, _d, _e, _f, _g, _h;
+        super(client, {
+            id: profile.id,
+            login: profile.login,
+            avatar: profile.avatar,
+            ban_expires: profile.ban_expires,
+            ban_reason: profile.ban_reason,
+            privilege_level: profile.privilege_level,
+            badge_id: (_b = (_a = profile === null || profile === void 0 ? void 0 : profile.badge) === null || _a === void 0 ? void 0 : _a.id) !== null && _b !== void 0 ? _b : null,
+            badge_name: (_d = (_c = profile === null || profile === void 0 ? void 0 : profile.badge) === null || _c === void 0 ? void 0 : _c.name) !== null && _d !== void 0 ? _d : null,
+            badge_type: (_f = (_e = profile === null || profile === void 0 ? void 0 : profile.badge) === null || _e === void 0 ? void 0 : _e.type) !== null && _f !== void 0 ? _f : null,
+            badge_url: (_h = (_g = profile === null || profile === void 0 ? void 0 : profile.badge) === null || _g === void 0 ? void 0 : _g.image_url) !== null && _h !== void 0 ? _h : null,
+            is_banned: profile.is_banned,
+            is_sponsor: profile.is_sponsor,
+            is_verified: profile.is_verified,
+            is_online: profile.is_online,
+            friend_count: profile.friend_count,
+            friend_status: profile.friend_status
+        });
+        this.client = client;
+        this.status = profile.status;
+        this.sponsorshipExpires = profile.sponsorshipExpires;
+        this.history = profile.history.map(release => new Release_1.Release(this.client, release));
+        this.votes = profile.votes.map(release => new Release_1.Release(this.client, release));
+        this.lastActivityTime = profile.last_activity_time;
+        this.registerDate = profile.register_date;
+        this.vkPage = profile.vk_page;
+        this.tgPage = profile.tg_page;
+        this.instPage = profile.inst_page;
+        this.ttPage = profile.tt_page;
+        this.discordPage = profile.discord_page;
+        this.banNote = profile.ban_note;
+        this.watchingCount = profile.watching_count;
+        this.planCount = profile.plan_count;
+        this.completedCount = profile.completed_count;
+        this.holdOnCount = profile.hold_on_count;
+        this.droppedCount = profile.dropped_count;
+        this.favoriteCount = profile.favorite_count;
+        this.commentCount = profile.comment_count;
+        this.collectionCount = profile.collection_count;
+        this.videoCount = profile.video_count;
+        this.watchedEpisodeCount = profile.watched_episode_count;
+        this.watchedTime = profile.watched_time;
+        this.isPrivate = profile.is_private;
+        this.isSponsorTransferred = profile.is_sponsor_transferred;
+        this.isBookmarksTransferred = profile.is_bookmarks_transferred;
+        this.isVkBound = profile.is_vk_bound;
+        this.isGoogleBound = profile.is_google_bound;
+        this.isReleaseTypeNotificationsEnabled = profile.is_release_type_notifications_enabled;
+        this.isEpisodeNotificationsEnabled = profile.is_episode_notifications_enabled;
+        this.isFirstEpisodeNotificationEnabled = profile.is_first_episode_notification_enabled;
+        this.isRelatedReleaseNotificationsEnabled = profile.is_related_release_notifications_enabled;
+        this.isReportProcessNotificationsEnabled = profile.is_report_process_notifications_enabled;
+        this.isCommentNotificationsEnabled = profile.is_comment_notifications_enabled;
+        this.isMyCollectionCommentNotificationsEnabled = profile.is_my_collection_comment_notifications_enabled;
+        this.watchDynamics = profile.watch_dynamics;
+        this.ratingScore = profile.rating_score;
+        this.isBlocked = profile.is_blocked;
+        this.isMeBlocked = profile.is_me_blocked;
+        this.isStatsHidden = profile.is_stats_hidden;
+        this.isCountsHidden = profile.is_counts_hidden;
+        this.isSocialHidden = profile.is_social_hidden;
+        this.isFriendRequestsDisallowed = profile.is_friend_requests_disallowed;
+        this.roles = profile.roles;
+        this.isPermBanned = profile.is_perm_banned;
+    }
+}
+exports.FullProfile = FullProfile;

package/dist/classes/Release.d.ts

@@ -0,0 +1,88 @@
+import { Anixart } from "../client";
+import { BookmarkType, IBaseCommentAddRequest, IEpisodeLastUpdate, IRelated, IRelease, IReleaseCategory, IReleaseStatus, ResponseCode } from "../types";
+import { Dubber } from "./Dubber";
+import { ReleaseComment } from "./ReleaseComment";
+export declare class Release {
+    private readonly client;
+    readonly id: number;
+    readonly poster: string;
+    readonly image: string;
+    readonly year: string;
+    readonly genres: string;
+    readonly country: string;
+    readonly director: string;
+    readonly author: string;
+    readonly translators: string;
+    readonly studio: string;
+    readonly description: string;
+    readonly note: null;
+    readonly related: IRelated;
+    readonly category: IReleaseCategory;
+    readonly rating: number;
+    readonly grade: number;
+    readonly status: IReleaseStatus;
+    readonly duration: number;
+    readonly season: number;
+    readonly broadcast: number;
+    readonly screenshots: any[];
+    readonly comments: any[];
+    readonly titleOriginal: string;
+    readonly titleRu: string;
+    readonly titleAlt: null;
+    readonly episodesReleased: number;
+    readonly episodesTotal: number;
+    readonly releaseDate: string;
+    readonly vote1Count: number;
+    readonly vote2Count: number;
+    readonly vote3Count: number;
+    readonly vote4Count: number;
+    readonly vote5Count: number;
+    readonly voteCount: number;
+    readonly creationDate: Date;
+    readonly lastUpdateDate: Date;
+    readonly airedOnDate: number;
+    readonly favoritesCount: number;
+    readonly watchingCount: number;
+    readonly planCount: number;
+    readonly completedCount: number;
+    readonly holdOnCount: number;
+    readonly droppedCount: number;
+    readonly isAdult: boolean;
+    readonly isPlayDisabled: boolean;
+    readonly isTppDisabled: boolean;
+    readonly canVideoAppeal: boolean;
+    readonly canTorlookSearch: boolean;
+    readonly isDeleted: boolean;
+    readonly ageRating: number;
+    readonly yourVote: number;
+    readonly relatedCount: number;
+    readonly commentCount: number;
+    readonly commentsCount: number;
+    readonly collectionCount: number;
+    readonly profileListStatus: number;
+    readonly statusId: number;
+    readonly lastViewTimestamp: number;
+    readonly lastViewEpisode: null;
+    readonly isViewed: boolean;
+    readonly isFavorite: boolean;
+    readonly isViewBlocked: boolean;
+    readonly screenshotImages: any[];
+    readonly relatedReleases: Release[] | null;
+    readonly recommendedReleases: Release[];
+    readonly episodeLastUpdate: IEpisodeLastUpdate;
+    readonly commentPerDayCount: number;
+    readonly videoBanners: any[];
+    readonly profileReleaseTypeNotificationPreferenceCount: number;
+    readonly isReleaseTypeNotificationsEnabled: boolean;
+    constructor(client: Anixart, releaseResponse: IRelease);
+    private writeProperties;
+    getDubbers(): Promise<Dubber[]>;
+    removeFromHistory(): Promise<ResponseCode>;
+    setFavorite(favorite: boolean): Promise<ResponseCode>;
+    addToList(type: BookmarkType): Promise<ResponseCode>;
+    removeFromList(type?: BookmarkType): Promise<ResponseCode>;
+    getRelatedReleases(page?: number): Promise<Release[] | null>;
+    getComments(page?: number, sort?: number): Promise<ReleaseComment[] | null>;
+    addComment(data: IBaseCommentAddRequest): Promise<ReleaseComment | null>;
+    addVote(vote: 1 | 2 | 3 | 4 | 5): Promise<ResponseCode>;
+}

package/dist/classes/Release.js

@@ -0,0 +1,140 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Release = void 0;
+const Dubber_1 = require("./Dubber");
+const ReleaseComment_1 = require("./ReleaseComment");
+class Release {
+    constructor(client, releaseResponse) {
+        var _a, _b;
+        this.client = client;
+        this.id = releaseResponse.id;
+        this.poster = releaseResponse.poster;
+        this.image = releaseResponse.image;
+        this.year = releaseResponse.year;
+        this.genres = releaseResponse.genres;
+        this.country = releaseResponse.country;
+        this.director = releaseResponse.director;
+        this.author = releaseResponse.author;
+        this.translators = releaseResponse.translators;
+        this.studio = releaseResponse.studio;
+        this.description = releaseResponse.description;
+        this.note = releaseResponse.note;
+        this.related = releaseResponse.related;
+        this.category = releaseResponse.category;
+        this.rating = releaseResponse.rating;
+        this.grade = releaseResponse.grade;
+        this.status = releaseResponse.status;
+        this.duration = releaseResponse.duration;
+        this.season = releaseResponse.season;
+        this.broadcast = releaseResponse.broadcast;
+        this.screenshots = releaseResponse.screenshots;
+        this.comments = releaseResponse.comments;
+        this.titleOriginal = releaseResponse.title_original;
+        this.titleRu = releaseResponse.title_ru;
+        this.titleAlt = releaseResponse.title_alt;
+        this.episodesReleased = releaseResponse.episodes_released;
+        this.episodesTotal = releaseResponse.episodes_total;
+        this.releaseDate = releaseResponse.release_date;
+        this.vote1Count = releaseResponse.vote_1_count;
+        this.vote2Count = releaseResponse.vote_2_count;
+        this.vote3Count = releaseResponse.vote_3_count;
+        this.vote4Count = releaseResponse.vote_4_count;
+        this.vote5Count = releaseResponse.vote_5_count;
+        this.voteCount = releaseResponse.vote_count;
+        this.creationDate = new Date(releaseResponse.creation_date * 1000);
+        this.lastUpdateDate = new Date(releaseResponse.last_update_date * 1000);
+        this.airedOnDate = releaseResponse.aired_on_date;
+        this.favoritesCount = releaseResponse.favorites_count;
+        this.watchingCount = releaseResponse.watching_count;
+        this.planCount = releaseResponse.plan_count;
+        this.completedCount = releaseResponse.completed_count;
+        this.holdOnCount = releaseResponse.hold_on_count;
+        this.droppedCount = releaseResponse.dropped_count;
+        this.isAdult = releaseResponse.is_adult;
+        this.isPlayDisabled = releaseResponse.is_play_disabled;
+        this.isTppDisabled = releaseResponse.is_tpp_disabled;
+        this.canVideoAppeal = releaseResponse.can_video_appeal;
+        this.canTorlookSearch = releaseResponse.can_torlook_search;
+        this.isDeleted = releaseResponse.is_deleted;
+        this.ageRating = releaseResponse.age_rating;
+        this.yourVote = releaseResponse.your_vote;
+        this.relatedCount = releaseResponse.related_count;
+        this.commentCount = releaseResponse.comment_count;
+        this.commentsCount = releaseResponse.comments_count;
+        this.collectionCount = releaseResponse.collection_count;
+        this.profileListStatus = releaseResponse.profile_list_status;
+        this.statusId = releaseResponse.status_id;
+        this.lastViewTimestamp = releaseResponse.last_view_timestamp;
+        this.lastViewEpisode = releaseResponse.last_view_episode;
+        this.isViewed = releaseResponse.is_viewed;
+        this.isFavorite = releaseResponse.is_favorite;
+        this.isViewBlocked = releaseResponse.is_view_blocked;
+        this.screenshotImages = releaseResponse.screenshot_images;
+        this.relatedReleases = (_a = releaseResponse.related_releases) === null || _a === void 0 ? void 0 : _a.map(release => new Release(this.client, release));
+        this.recommendedReleases = (_b = releaseResponse.recommended_releases) === null || _b === void 0 ? void 0 : _b.map(release => new Release(this.client, release));
+        this.episodeLastUpdate = releaseResponse.episode_last_update;
+        this.commentPerDayCount = releaseResponse.comment_per_day_count;
+        this.videoBanners = releaseResponse.video_banners;
+        this.profileReleaseTypeNotificationPreferenceCount = releaseResponse.profile_release_type_notification_preference_count;
+        this.isReleaseTypeNotificationsEnabled = releaseResponse.is_release_type_notifications_enabled;
+    }
+    writeProperties(prop, value) {
+        this[prop] = value;
+    }
+    async getDubbers() {
+        const request = await this.client.endpoints.release.getDubbers(this.id);
+        return request.types.map(dubber => new Dubber_1.Dubber(this.client, dubber, this));
+    }
+    async removeFromHistory() {
+        const request = await this.client.endpoints.release.removeFromHistory(this.id);
+        return request.code;
+    }
+    async setFavorite(favorite) {
+        const request = favorite ?
+            await this.client.endpoints.release.addFavorite(this.id) :
+            await this.client.endpoints.release.removeFavorite(this.id);
+        if (request.code == 0) {
+            this.writeProperties("isFavorite", favorite);
+        }
+        return request.code;
+    }
+    async addToList(type) {
+        const request = await this.client.endpoints.release.addToProfileList(this.id, type);
+        if (request.code == 0) {
+            this.writeProperties("profileListStatus", type);
+        }
+        return request.code;
+    }
+    async removeFromList(type) {
+        const request = await this.client.endpoints.release.removeFromProfileList(this.id, type ? type : this.profileListStatus);
+        if (request.code == 0) {
+            this.writeProperties("profileListStatus", null);
+        }
+        return request.code;
+    }
+    async getRelatedReleases(page = 0) {
+        const request = await this.client.endpoints.release.getRelatedReleases(this.related.id, page);
+        return request.code == 0 ? request.content.map(release => new Release(this.client, release)) : null;
+    }
+    async getComments(page = 0, sort = 0) {
+        const request = await this.client.endpoints.release.getComments({ page, sort, id: this.id });
+        return request.code == 0 ? request.content.map(comment => new ReleaseComment_1.ReleaseComment(this.client, comment, this)) : null;
+    }
+    async addComment(data) {
+        const request = await this.client.endpoints.release.addComment(this.id, data);
+        if (request.code == 0) {
+            this.writeProperties("commentCount", this.commentCount + 1);
+            this.writeProperties("commentsCount", this.commentsCount + 1);
+        }
+        return request.code == 0 ? new ReleaseComment_1.ReleaseComment(this.client, request.comment, this) : null;
+    }
+    async addVote(vote) {
+        const request = await this.client.endpoints.release.addVote(this.id, vote);
+        if (request.code == 0) {
+            this.writeProperties("voteCount", this.voteCount + 1);
+            this.writeProperties("yourVote", vote);
+        }
+        return request.code;
+    }
+}
+exports.Release = Release;

package/dist/classes/ReleaseComment.d.ts

@@ -0,0 +1,16 @@
+import { Anixart } from '../client';
+import { ICommentRelease, ResponseCode, VoteType } from '../types';
+import { BaseComment } from './BaseComment';
+import { BaseProfile } from './BaseProfile';
+import { Release } from './Release';
+export declare class ReleaseComment extends BaseComment {
+    readonly client: Anixart;
+    readonly release: Release;
+    constructor(client: Anixart, releaseComment: ICommentRelease, releaseClass?: Release);
+    private writeProperties;
+    getVotes(page?: number, sort?: number): Promise<BaseProfile[]>;
+    getReplies(page?: number, sort?: number): Promise<ReleaseComment[]>;
+    delete(): Promise<ResponseCode>;
+    setVote(type: VoteType): Promise<ResponseCode>;
+    edit(content: string, isSpoiler: boolean): Promise<ResponseCode>;
+}

package/dist/classes/ReleaseComment.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ReleaseComment = void 0;
+const BaseComment_1 = require("./BaseComment");
+const BaseProfile_1 = require("./BaseProfile");
+const Release_1 = require("./Release");
+class ReleaseComment extends BaseComment_1.BaseComment {
+    constructor(client, releaseComment, releaseClass) {
+        super(client, releaseComment);
+        this.client = client;
+        this.release = releaseClass !== null && releaseClass !== void 0 ? releaseClass : new Release_1.Release(this.client, releaseComment.release);
+    }
+    writeProperties(prop, value) {
+        this[prop] = value;
+    }
+    async getVotes(page, sort) {
+        const request = await this.client.endpoints.channel.getVotes(this.id, page !== null && page !== void 0 ? page : 0, sort !== null && sort !== void 0 ? sort : 2);
+        return request.content.map(profile => new BaseProfile_1.BaseProfile(this.client, profile));
+    }
+    async getReplies(page, sort) {
+        const request = await this.client.endpoints.release.getCommentReplies({ id: this.id, page: page !== null && page !== void 0 ? page : 0, sort: sort !== null && sort !== void 0 ? sort : 2 });
+        return request.content.map(comment => new ReleaseComment(this.client, comment));
+    }
+    async delete() {
+        const request = await this.client.endpoints.release.removeComment(this.id);
+        return request.code;
+    }
+    async setVote(type) {
+        const request = await this.client.endpoints.release.voteComment(this.id, type);
+        if (request.code == 0) {
+            this.writeProperties("vote", type == this.vote ? 0 : type);
+        }
+        return request.code;
+    }
+    async edit(content, isSpoiler) {
+        const request = await this.client.endpoints.release.editComment(this.id, content, isSpoiler);
+        if (request.code == 0) {
+            this.writeProperties("message", content);
+            this.writeProperties("isSpoiler", isSpoiler);
+        }
+        return request.code;
+    }
+}
+exports.ReleaseComment = ReleaseComment;