anixartjs 0.0.1

package/dist/api/profile.d.ts

@@ -0,0 +1,26 @@
+import { Anixart } from "../client";
+import { IProfileResponse, IBookmarkRequest, IFriendsRequest, IProfileShort, IFriendRequestResponse, IBaseApiParams, IBaseSearchRequest, IPageableResponse, IRelease, IProfile, IResponse, ISubsciptionCountResponse } from "../types";
+/**
+ * Класс профиля
+ *
+ * TODO: changeAvatar
+ */
+export declare class Profile {
+    private readonly client;
+    constructor(client: Anixart);
+    info(id: number, options?: IBaseApiParams): Promise<IProfileResponse>;
+    getBookmarks(data: IBookmarkRequest, options?: IBaseApiParams): Promise<IPageableResponse<IRelease>>;
+    addBookmark(id: number, type: number, options?: IBaseApiParams): Promise<IResponse>;
+    removeBookmark(id: number, type: number, options?: IBaseApiParams): Promise<IResponse>;
+    search(data: IBaseSearchRequest, options?: IBaseApiParams): Promise<IPageableResponse<IProfile>>;
+    getFriends(data: IFriendsRequest, options?: IBaseApiParams): Promise<IPageableResponse<IProfileShort>>;
+    getFriendRecomendation(options?: IBaseApiParams): Promise<IPageableResponse<IProfileShort>>;
+    getFriendRequests(type: "in" | "out", count: number, options?: IBaseApiParams): Promise<IPageableResponse<IProfileShort>>;
+    sendFriendRequest(id: number, options?: IBaseApiParams): Promise<IFriendRequestResponse>;
+    removeFriendRequest(id: number, options?: IBaseApiParams): Promise<IFriendRequestResponse>;
+    getAchivement(id: number, options?: IBaseApiParams): Promise<IResponse>;
+    getFavorites(data: IBookmarkRequest, options?: IBaseApiParams): Promise<IPageableResponse<IRelease>>;
+    getSubsciptions(page: number, options?: IBaseApiParams): Promise<IPageableResponse<any>>;
+    getSubscriptionCount(options?: IBaseApiParams): Promise<ISubsciptionCountResponse>;
+    getVotesReleases(id: number, page: number, sort?: number, options?: IBaseApiParams): Promise<IPageableResponse<IProfileShort>>;
+}

package/dist/api/profile.js

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Profile = void 0;
+/**
+ * Класс профиля
+ *
+ * TODO: changeAvatar
+ */
+class Profile {
+    constructor(client) {
+        this.client = client;
+    }
+    async info(id, options) {
+        return this.client.call({ path: `/profile/${id}`, ...options });
+    }
+    async getBookmarks(data, options) {
+        return this.client.call({ path: `/profile/list/all/${data.id ? `${data.id}/` : ""}${data.type}/${data.page}`, queryParams: { sort: data.sort, filter: data.filter, filter_announce: data.filter_announce }, ...options });
+    }
+    async addBookmark(id, type, options) {
+        return this.client.call({ path: `/profile/list/add/${type}/${id}`, ...options });
+    }
+    async removeBookmark(id, type, options) {
+        return this.client.call({ path: `/profile/list/delete/${type}/${id}`, ...options });
+    }
+    async search(data, options) {
+        return this.client.call({ path: `/search/profiles/${data.page}`, json: { query: data.query, page: data.page }, ...options });
+    }
+    async getFriends(data, options) {
+        return await this.client.call({ path: `/profile/friend/all/${data.id}/${data.page}`, ...options });
+    }
+    async getFriendRecomendation(options) {
+        return await this.client.call({ path: `/profile/friend/recomendations`, ...options });
+    }
+    async getFriendRequests(type, count, options) {
+        return await this.client.call({ path: `/profile/friend/requests/${type}/last`, queryParams: { count }, ...options });
+    }
+    async sendFriendRequest(id, options) {
+        return await this.client.call({ path: `/profile/friend/request/send/${id}`, ...options });
+    }
+    async removeFriendRequest(id, options) {
+        return await this.client.call({ path: `/profile/friend/request/remove/${id}`, ...options });
+    }
+    async getAchivement(id, options) {
+        return await this.client.call({ path: `/achivement/get/${id}`, ...options });
+    }
+    async getFavorites(data, options) {
+        return await this.client.call({ path: `/favorite/all/${data.page}`, queryParams: { sort: data.sort, filter: data.filter, filter_announce: data.filter_announce }, ...options });
+    }
+    async getSubsciptions(page, options) {
+        return await this.client.call({ path: `/channel/subscription/all/${page}`, ...options });
+    }
+    async getSubscriptionCount(options) {
+        return await this.client.call({ path: `/channel/subscription/count`, ...options });
+    }
+    async getVotesReleases(id, page, sort = 1, options) {
+        return await this.client.call({ path: `/profile/vote/release/voted/${id}/${page}`, queryParams: { sort }, ...options });
+    }
+}
+exports.Profile = Profile;

package/dist/api/release.d.ts

@@ -0,0 +1,40 @@
+import { Anixart } from "../client";
+import { ICommentRelease, ICommentReleaseRequest, ICommentReleaseResponse, ICommentRepliesRequest, IDubbersResponse, IRelease, IReleaseResponse, ISourcesResponse, IVideo, IVideoReleaseInCategoryRequest, IVideoResponse, IEpisodesResponse, VoteType, IEpisodeResponse, IBaseApiParams, IBaseCommentAddRequest, IBaseSearchRequest, IPageableResponse, IResponse, IReleaseFilterRequest, IProfileShort } from "../types";
+/**
+ * Класс релиза
+ *
+ * TODO: notification
+ */
+export declare class Release {
+    private readonly client;
+    constructor(client: Anixart);
+    info(id: number, extended?: boolean, options?: IBaseApiParams): Promise<IReleaseResponse>;
+    addVote(id: number, vote: 1 | 2 | 3 | 4 | 5, options?: IBaseApiParams): Promise<IResponse>;
+    removeVote(id: number, options?: IBaseApiParams): Promise<IResponse>;
+    getComments(data: ICommentReleaseRequest, options?: IBaseApiParams): Promise<IPageableResponse<ICommentRelease>>;
+    addComment(id: number, data: IBaseCommentAddRequest, options?: IBaseApiParams): Promise<ICommentReleaseResponse>;
+    voteComment(id: number, vote: VoteType, options?: IBaseApiParams): Promise<IResponse>;
+    removeComment(id: number, options?: IBaseApiParams): Promise<IResponse>;
+    editComment(id: number, message: string, spoiler: boolean, options?: IBaseApiParams): Promise<IResponse>;
+    getCommentReplies(data: ICommentRepliesRequest, options?: IBaseApiParams): Promise<IPageableResponse<ICommentRelease>>;
+    getRelatedReleases(id: number, page: number, options?: IBaseApiParams): Promise<IPageableResponse<IRelease>>;
+    getVideos(id: number, options?: IBaseApiParams): Promise<IVideoResponse>;
+    getVideoInCategory(data: IVideoReleaseInCategoryRequest, options?: IBaseApiParams): Promise<IPageableResponse<IVideo>>;
+    search(data: IBaseSearchRequest, options?: IBaseApiParams): Promise<IPageableResponse<IRelease>>;
+    getDubbers(id: number, options?: IBaseApiParams): Promise<IDubbersResponse>;
+    getDubberSources(id: number, dubberId: number, options?: IBaseApiParams): Promise<ISourcesResponse>;
+    getEpisodes(id: number, dubberId: number, sourceId: number, sort?: number, options?: IBaseApiParams): Promise<IEpisodesResponse>;
+    getEpisode(id: number, sourceId: number, episodePosition: number, options?: IBaseApiParams): Promise<IEpisodeResponse>;
+    getRandomRelease(extended?: boolean, options?: IBaseApiParams): Promise<IReleaseResponse>;
+    markEpisodeAsWatched(id: number, sourceId: number, episodePosition: number, options?: IBaseApiParams): Promise<IResponse>;
+    unmarkEpisodeAsWatched(id: number, sourceId: number, episodePosition: number, options?: IBaseApiParams): Promise<IResponse>;
+    addToHistory(id: number, sourceId: number, episodePosition: number, options?: IBaseApiParams): Promise<IResponse>;
+    removeFromHistory(id: number, options?: IBaseApiParams): Promise<IResponse>;
+    getHistory(page: number, options?: IBaseApiParams): Promise<IPageableResponse<IRelease>>;
+    filter(page: number, data: IReleaseFilterRequest, extended?: boolean, options?: IBaseApiParams): Promise<IPageableResponse<IRelease>>;
+    addFavorite(id: number, options?: IBaseApiParams): Promise<IResponse>;
+    removeFavorite(id: number, options?: IBaseApiParams): Promise<IResponse>;
+    addToProfileList(id: number, type: number, options?: IBaseApiParams): Promise<IResponse>;
+    removeFromProfileList(id: number, type: number, options?: IBaseApiParams): Promise<IResponse>;
+    getCommentVotes(id: number, page: number, options?: IBaseApiParams): Promise<IPageableResponse<IProfileShort>>;
+}

package/dist/api/release.js

@@ -0,0 +1,101 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Release = void 0;
+/**
+ * Класс релиза
+ *
+ * TODO: notification
+ */
+class Release {
+    constructor(client) {
+        this.client = client;
+    }
+    async info(id, extended = true, options) {
+        return await this.client.call({ path: `/release/${id}`, queryParams: { extended_mode: extended }, ...options });
+    }
+    async addVote(id, vote, options) {
+        return await this.client.call({ path: `/release/vote/add/${id}/${vote}`, ...options });
+    }
+    async removeVote(id, options) {
+        return await this.client.call({ path: `/release/vote/delete/${id}`, ...options });
+    }
+    async getComments(data, options) {
+        return this.client.call({ path: `/release/comment/all/${data.id}/${data.page}`, queryParams: { sort: data.sort }, ...options });
+    }
+    async addComment(id, data, options) {
+        return await this.client.call({ path: `/release/comment/add/${id}`, json: data, ...options });
+    }
+    async voteComment(id, vote, options) {
+        return await this.client.call({ path: `/release/comment/vote/${id}/${vote}`, ...options });
+    }
+    async removeComment(id, options) {
+        return await this.client.call({ path: `/release/comment/delete/${id}`, ...options });
+    }
+    async editComment(id, message, spoiler, options) {
+        return await this.client.call({ path: `/release/comment/edit/${id}`, json: { message, spoiler }, ...options });
+    }
+    async getCommentReplies(data, options) {
+        return await this.client.call({ path: `/release/comment/replies/${data.id}/${data.page}`, queryParams: { sort: data.sort }, ...options });
+    }
+    async getRelatedReleases(id, page, options) {
+        return await this.client.call({ path: `/related/${id}/${page}`, apiV2: true, ...options });
+    }
+    async getVideos(id, options) {
+        return await this.client.call({ path: `/video/release/${id}`, ...options });
+    }
+    async getVideoInCategory(data, options) {
+        return await this.client.call({ path: `/video/release/${data.id}/category/${data.categoryId}/${data.page}`, ...options });
+    }
+    async search(data, options) {
+        return await this.client.call({ path: `/search/releases/${data.page}`, json: { query: data.query, page: data.page }, apiV2: true, ...options });
+    }
+    async getDubbers(id, options) {
+        return await this.client.call({ path: `/episode/${id}`, ...options });
+    }
+    async getDubberSources(id, dubberId, options) {
+        return await this.client.call({ path: `/episode/${id}/${dubberId}`, ...options });
+    }
+    async getEpisodes(id, dubberId, sourceId, sort = 1, options) {
+        return await this.client.call({ path: `/episode/${id}/${dubberId}/${sourceId}`, queryParams: { sort }, ...options });
+    }
+    async getEpisode(id, sourceId, episodePosition, options) {
+        return await this.client.call({ path: `/episode/target/${id}/${sourceId}/${episodePosition}`, ...options });
+    }
+    async getRandomRelease(extended, options) {
+        return await this.client.call({ path: `/release/random`, queryParams: { extended_mode: extended !== null && extended !== void 0 ? extended : true }, ...options });
+    }
+    async markEpisodeAsWatched(id, sourceId, episodePosition, options) {
+        return await this.client.call({ path: `/episode/watch/${id}/${sourceId}/${episodePosition}`, ...options });
+    }
+    async unmarkEpisodeAsWatched(id, sourceId, episodePosition, options) {
+        return await this.client.call({ path: `/episode/unwatch/${id}/${sourceId}/${episodePosition}`, ...options });
+    }
+    async addToHistory(id, sourceId, episodePosition, options) {
+        return await this.client.call({ path: `/history/add/${id}/${sourceId}/${episodePosition}`, ...options });
+    }
+    async removeFromHistory(id, options) {
+        return await this.client.call({ path: `/history/delete/${id}`, ...options });
+    }
+    async getHistory(page, options) {
+        return await this.client.call({ path: `/history/${page}`, ...options });
+    }
+    async filter(page, data, extended, options) {
+        return await this.client.call({ path: `/filter/${page}`, queryParams: { extended_mode: extended !== null && extended !== void 0 ? extended : true }, json: data, ...options });
+    }
+    async addFavorite(id, options) {
+        return await this.client.call({ path: `/favorite/add/${id}`, ...options });
+    }
+    async removeFavorite(id, options) {
+        return await this.client.call({ path: `/favorite/delete/${id}`, ...options });
+    }
+    async addToProfileList(id, type, options) {
+        return await this.client.call({ path: `/profile/list/add/${type}/${id}`, ...options });
+    }
+    async removeFromProfileList(id, type, options) {
+        return await this.client.call({ path: `/profile/list/delete/${type}/${id}`, ...options });
+    }
+    async getCommentVotes(id, page, options) {
+        return await this.client.call({ path: `/release/comment/votes/${id}/${page}`, ...options });
+    }
+}
+exports.Release = Release;

package/dist/api/settings.d.ts

@@ -0,0 +1,30 @@
+import { Anixart } from "../client";
+import { IBadgesResponse, IEmailChangeConfirmResponse, IEmailChangeRequest, ILoginInfoResponse, INewLogin, IProfileSettingsResponse, PrivacyFriendRequestState, PrivacyState, IProfileShort, ISocialResponse, IBaseApiParams, IPageableResponse, IResponse, IPasswordChangeResponse } from "../types";
+export declare class Settings {
+    private readonly client;
+    constructor(client: Anixart);
+    getCurrentProfileSettings(options?: IBaseApiParams): Promise<IProfileSettingsResponse>;
+    getBadges(page: number, options?: IBaseApiParams): Promise<IBadgesResponse>;
+    setStatus(status: string, options?: IBaseApiParams): Promise<IResponse>;
+    getBlocklist(page: number, options?: IBaseApiParams): Promise<IPageableResponse<IProfileShort>>;
+    getSocial(options?: IBaseApiParams): Promise<ISocialResponse>;
+    setSocial(data: ISocialResponse, options?: IBaseApiParams): Promise<IResponse>;
+    confirmChangeEmail(currentPassword: string, options?: IBaseApiParams): Promise<IEmailChangeConfirmResponse>;
+    changeEmail(data: IEmailChangeRequest, options?: IBaseApiParams): Promise<IResponse>;
+    changePassword(currentPassword: string, newPassword: string, options?: IBaseApiParams): Promise<IPasswordChangeResponse>;
+    addBlocklist(id: number, options?: IBaseApiParams): Promise<IResponse>;
+    removeBlocklist(id: number, options?: IBaseApiParams): Promise<IResponse>;
+    getLoginInfo(options?: IBaseApiParams): Promise<ILoginInfoResponse>;
+    getLoginHistory(id: number, page: number, options?: IBaseApiParams): Promise<IPageableResponse<INewLogin>>;
+    changeLogin(newLogin: string, options?: IBaseApiParams): Promise<IResponse>;
+    setCommentNotification(options?: IBaseApiParams): Promise<IResponse>;
+    setCollectionCommentNotification(options?: IBaseApiParams): Promise<IResponse>;
+    setReportProgressNotification(options?: IBaseApiParams): Promise<IResponse>;
+    setRelatedReleaseNotification(options?: IBaseApiParams): Promise<IResponse>;
+    setEpisodeNotification(options?: IBaseApiParams): Promise<IResponse>;
+    setStatusNotification(options?: IBaseApiParams): Promise<IResponse>;
+    setPrivacyStats(state: PrivacyState, options?: IBaseApiParams): Promise<IResponse>;
+    setPrivacyCounts(state: PrivacyState, options?: IBaseApiParams): Promise<IResponse>;
+    setPrivacySocial(state: PrivacyState, options?: IBaseApiParams): Promise<IResponse>;
+    setPrivacyFriendRequests(state: PrivacyFriendRequestState, options?: IBaseApiParams): Promise<IResponse>;
+}

package/dist/api/settings.js

@@ -0,0 +1,81 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Settings = void 0;
+class Settings {
+    constructor(client) {
+        this.client = client;
+    }
+    async getCurrentProfileSettings(options) {
+        return await this.client.call({ path: `/profile/preference/my`, ...options });
+    }
+    async getBadges(page, options) {
+        return await this.client.call({ path: `/profile/preference/badges/${page}`, ...options });
+    }
+    async setStatus(status, options) {
+        return await this.client.call({ path: `/profile/preference/status/edit`, json: { status }, ...options });
+    }
+    async getBlocklist(page, options) {
+        return await this.client.call({ path: `/profile/preference/blocklist/${page}`, ...options });
+    }
+    async getSocial(options) {
+        return await this.client.call({ path: `/profile/preference/social`, ...options });
+    }
+    async setSocial(data, options) {
+        return await this.client.call({ path: `/profile/preference/social/edit`, json: { vkPage: data.vk_page, tgPage: data.tg_page, instPage: data.inst_page, ttPage: data.tt_page, discordPage: data.discord_page }, ...options });
+    }
+    async confirmChangeEmail(currentPassword, options) {
+        return await this.client.call({ path: `/profile/preference/email/confirm`, queryParams: { current: currentPassword }, ...options });
+    }
+    changeEmail(data, options) {
+        return this.client.call({ path: `/profile/preference/email/edit`, queryParams: { current_password: data.password, current: data.oldEmail, new: data.newEmail }, ...options });
+    }
+    async changePassword(currentPassword, newPassword, options) {
+        return await this.client.call({ path: `/profile/preference/password/edit`, queryParams: { current: currentPassword, new: newPassword }, ...options });
+    }
+    async addBlocklist(id, options) {
+        return await this.client.call({ path: `/profile/blocklist/add/${id}`, ...options });
+    }
+    async removeBlocklist(id, options) {
+        return await this.client.call({ path: `/profile/blocklist/remove/${id}`, ...options });
+    }
+    async getLoginInfo(options) {
+        return await this.client.call({ path: `/profile/preference/login/info`, ...options });
+    }
+    async getLoginHistory(id, page, options) {
+        return await this.client.call({ path: `/profile/login/history/all/${id}/${page}`, ...options });
+    }
+    async changeLogin(newLogin, options) {
+        return await this.client.call({ path: `/profile/preference/login/change`, queryParams: { login: newLogin }, ...options });
+    }
+    async setCommentNotification(options) {
+        return await this.client.call({ path: `/profile/preference/notification/comment/edit`, ...options });
+    }
+    async setCollectionCommentNotification(options) {
+        return await this.client.call({ path: `/profile/preference/notification/my/collection/comment/edit`, ...options });
+    }
+    async setReportProgressNotification(options) {
+        return await this.client.call({ path: `/profile/preference/notification/report/process/edit`, ...options });
+    }
+    async setRelatedReleaseNotification(options) {
+        return await this.client.call({ path: `/profile/preference/notification/related/release/edit`, ...options });
+    }
+    async setEpisodeNotification(options) {
+        return await this.client.call({ path: `/profile/preference/notification/episode/edit`, ...options });
+    }
+    async setStatusNotification(options) {
+        return await this.client.call({ path: `/profile/preference/notification/status/edit`, ...options });
+    }
+    async setPrivacyStats(state, options) {
+        return await this.client.call({ path: `/profile/preference/privacy/stats/edit`, json: { permission: state }, ...options });
+    }
+    async setPrivacyCounts(state, options) {
+        return await this.client.call({ path: `/profile/preference/privacy/counts/edit`, json: { permission: state }, ...options });
+    }
+    async setPrivacySocial(state, options) {
+        return await this.client.call({ path: `/profile/preference/privacy/social/edit`, json: { permission: state }, ...options });
+    }
+    async setPrivacyFriendRequests(state, options) {
+        return await this.client.call({ path: `/profile/preference/privacy/friendRequests/edit`, json: { permission: state }, ...options });
+    }
+}
+exports.Settings = Settings;

package/dist/classes/Article.d.ts

@@ -0,0 +1,18 @@
+import { Channel } from "./Channel";
+import { Anixart } from "../client";
+import { IArticle, ResponseCode, IBaseCommentAddRequest, VoteType } from "../types";
+import { ArticleComment } from "./ArticleComment";
+import { ArticleBuilder } from "../utils/ArticleBuilder";
+import { BaseArticle } from "./BaseArticle";
+export declare class Article extends BaseArticle {
+    readonly client: Anixart;
+    readonly repostArticle: Article | null;
+    readonly channel: Channel;
+    constructor(client: Anixart, articleResponce: IArticle, channel?: Channel);
+    private writeProperties;
+    getComments(page?: number, sort?: number): Promise<ArticleComment[]>;
+    addComment(data: IBaseCommentAddRequest): Promise<ArticleComment | null>;
+    setVote(type: VoteType): Promise<ResponseCode>;
+    edit(data: ArticleBuilder): Promise<Article>;
+    delete(): Promise<ResponseCode>;
+}

package/dist/classes/Article.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Article = void 0;
+const Channel_1 = require("./Channel");
+const ArticleComment_1 = require("./ArticleComment");
+const BaseArticle_1 = require("./BaseArticle");
+class Article extends BaseArticle_1.BaseArticle {
+    constructor(client, articleResponce, channel) {
+        super(client, articleResponce, channel);
+        this.client = client;
+        this.channel = channel !== null && channel !== void 0 ? channel : new Channel_1.Channel(this.client, articleResponce.channel);
+        this.repostArticle = articleResponce.repost_article
+            ? new Article(client, articleResponce.repost_article, channel)
+            : null;
+    }
+    writeProperties(prop, value) {
+        this[prop] = value;
+    }
+    async getComments(page, sort) {
+        const request = await this.client.endpoints.channel.getComments(this.id, page !== null && page !== void 0 ? page : 0, sort !== null && sort !== void 0 ? sort : 2);
+        return request.content.map(comment => new ArticleComment_1.ArticleComment(this.client, comment));
+    }
+    async addComment(data) {
+        const request = await this.client.endpoints.channel.addArticleComment(this.id, data);
+        return request.code == 0 && request.comment ? new ArticleComment_1.ArticleComment(this.client, request === null || request === void 0 ? void 0 : request.comment) : null;
+    }
+    async setVote(type) {
+        const request = await this.client.endpoints.channel.voteArticle(this.id, type);
+        if (request.code == 0) {
+            this.writeProperties("vote", type == this.vote ? 0 : type);
+        }
+        return request.code;
+    }
+    async edit(data) {
+        const request = await this.client.endpoints.channel.editArticle(this.id, data.returnBuildAricle());
+        return new Article(this.client, request.article, this.channel);
+    }
+    async delete() {
+        const request = await this.client.endpoints.channel.removeArticle(this.id);
+        return request.code;
+    }
+}
+exports.Article = Article;

package/dist/classes/ArticleComment.d.ts

@@ -0,0 +1,15 @@
+import { Anixart } from "../client";
+import { BaseComment } from "./BaseComment";
+import { IArticleComment, ResponseCode, VoteType } from "../types";
+import { Article } from "./Article";
+import { BaseProfile } from "./BaseProfile";
+export declare class ArticleComment extends BaseComment {
+    readonly client: Anixart;
+    readonly article: Article;
+    constructor(client: Anixart, comment: IArticleComment);
+    private writeProperties;
+    getVotes(page?: number, sort?: number): Promise<BaseProfile[]>;
+    getReplies(page?: number, sort?: number): Promise<ArticleComment[]>;
+    delete(): Promise<ResponseCode>;
+    setVote(type: VoteType): Promise<ResponseCode>;
+}

package/dist/classes/ArticleComment.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ArticleComment = void 0;
+const BaseComment_1 = require("./BaseComment");
+const Article_1 = require("./Article");
+const BaseProfile_1 = require("./BaseProfile");
+class ArticleComment extends BaseComment_1.BaseComment {
+    constructor(client, comment) {
+        super(client, comment);
+        this.client = client;
+        this.article = new Article_1.Article(client, comment.article);
+    }
+    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.channel.getCommentReplies(this.id, page !== null && page !== void 0 ? page : 0, sort !== null && sort !== void 0 ? sort : 2);
+        return request.content.map(comment => new ArticleComment(this.client, comment));
+    }
+    async delete() {
+        const request = await this.client.endpoints.channel.removeArticleComment(this.id);
+        return request.code;
+    }
+    async setVote(type) {
+        const request = await this.client.endpoints.channel.voteCommentArticle(this.id, type);
+        if (request.code == 0) {
+            this.writeProperties("vote", type == this.vote ? 0 : type);
+        }
+        return request.code;
+    }
+}
+exports.ArticleComment = ArticleComment;

package/dist/classes/BaseArticle.d.ts

@@ -0,0 +1,21 @@
+import { Channel } from "./Channel";
+import { Anixart } from "../client";
+import { IArticle, IArticlePayloadBlock } from "../types";
+import { FullProfile } from "./FullProfile";
+export declare class BaseArticle {
+    readonly client: Anixart;
+    readonly id: number;
+    readonly payloadTime: Date;
+    readonly payloadBlocks: IArticlePayloadBlock[];
+    readonly vote: number;
+    readonly isDeleted: boolean;
+    readonly commentCount: number;
+    readonly repostCount: number;
+    readonly voteCount: number;
+    readonly creationDate: Date;
+    readonly lastUpdateDate: Date;
+    readonly underModerationReason: string;
+    readonly isUnderModeration: boolean;
+    readonly author: FullProfile | null;
+    constructor(client: Anixart, articleResponce: IArticle, channel?: Channel);
+}

package/dist/classes/BaseArticle.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseArticle = void 0;
+const FullProfile_1 = require("./FullProfile");
+class BaseArticle {
+    constructor(client, articleResponce, channel) {
+        this.client = client;
+        this.id = articleResponce.id;
+        this.payloadTime = new Date(articleResponce.payload.time);
+        this.author = articleResponce.author ? new FullProfile_1.FullProfile(this.client, articleResponce.author) : null;
+        this.payloadBlocks = articleResponce.payload.blocks;
+        this.vote = articleResponce.vote;
+        this.commentCount = articleResponce.comment_count;
+        this.repostCount = articleResponce.repost_count;
+        this.voteCount = articleResponce.vote_count;
+        this.creationDate = new Date(articleResponce.creation_date * 1000);
+        this.lastUpdateDate = new Date(articleResponce.last_update_date * 1000);
+        this.underModerationReason = articleResponce.under_moderation_reason;
+        this.isUnderModeration = articleResponce.is_under_moderation;
+        this.isDeleted = articleResponce.is_deleted;
+    }
+}
+exports.BaseArticle = BaseArticle;

package/dist/classes/BaseComment.d.ts

@@ -0,0 +1,22 @@
+import { Anixart } from "../client";
+import { IBaseComment } from "../types";
+import { BaseProfile } from "./BaseProfile";
+export declare class BaseComment {
+    protected readonly client: Anixart;
+    readonly id: number;
+    readonly profile: BaseProfile;
+    readonly message: string;
+    readonly timestamp: Date;
+    readonly type: number;
+    readonly vote: number;
+    readonly parentCommentId: number;
+    readonly voteCount: number;
+    readonly likesCount: number;
+    readonly isSpoiler: boolean;
+    readonly isEdited: boolean;
+    readonly isDeleted: boolean;
+    readonly isReply: boolean;
+    readonly replyCount: number;
+    readonly canLike: boolean;
+    constructor(client: Anixart, comment: IBaseComment);
+}

package/dist/classes/BaseComment.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseComment = void 0;
+const BaseProfile_1 = require("./BaseProfile");
+class BaseComment {
+    constructor(client, comment) {
+        this.client = client;
+        this.id = comment.id;
+        this.profile = new BaseProfile_1.BaseProfile(this.client, comment.profile);
+        this.message = comment.message;
+        this.timestamp = new Date(comment.timestamp * 1000);
+        this.type = comment.type;
+        this.vote = comment.vote;
+        this.parentCommentId = comment.parent_comment_id;
+        this.voteCount = comment.vote_count;
+        this.likesCount = comment.likes_count;
+        this.isSpoiler = comment.is_spoiler;
+        this.isEdited = comment.is_edited;
+        this.isDeleted = comment.is_deleted;
+        this.isReply = comment.is_reply;
+        this.replyCount = comment.reply_count;
+        this.canLike = comment.can_like;
+    }
+}
+exports.BaseComment = BaseComment;

package/dist/classes/BaseProfile.d.ts

@@ -0,0 +1,25 @@
+import { Anixart } from "../client";
+import { IFriendRequestResponse, IProfileShort } from "../types";
+export declare class BaseProfile {
+    protected readonly client: Anixart;
+    readonly id: number;
+    readonly login: string;
+    readonly avatar: string;
+    readonly banExpires: Date;
+    readonly banReason: string;
+    readonly privilegeLevel: number;
+    readonly badgeId: number | null;
+    readonly badgeName: string | null;
+    readonly badgeType: number | null;
+    readonly badgeUrl: string | null;
+    readonly isBanned: boolean;
+    readonly isSponsor: boolean;
+    readonly isVerified: boolean;
+    readonly isOnline: boolean;
+    readonly friendStatus: number;
+    readonly friendCount: number;
+    constructor(client: Anixart, profile: IProfileShort);
+    getFriends(page?: number): Promise<BaseProfile[]>;
+    sendFriendRequest(): Promise<IFriendRequestResponse>;
+    removeFriendRequest(): Promise<IFriendRequestResponse>;
+}

package/dist/classes/BaseProfile.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseProfile = void 0;
+class BaseProfile {
+    constructor(client, profile) {
+        this.client = client;
+        this.id = profile.id;
+        this.login = profile.login;
+        this.avatar = profile.avatar;
+        this.banExpires = new Date(profile.ban_expires * 1000);
+        this.banReason = profile.ban_reason;
+        this.privilegeLevel = profile.privilege_level;
+        this.badgeId = profile.badge_id;
+        this.badgeName = profile.badge_name;
+        this.badgeType = profile.badge_type;
+        this.badgeUrl = profile.badge_url;
+        this.isBanned = profile.is_banned;
+        this.isSponsor = profile.is_sponsor;
+        this.isVerified = profile.is_verified;
+        this.isOnline = profile.is_online;
+        this.friendStatus = profile.friend_status;
+        this.friendCount = profile.friend_count;
+    }
+    async getFriends(page) {
+        const request = await this.client.endpoints.profile.getFriends({ id: this.id, page: page !== null && page !== void 0 ? page : 0 });
+        return request.content.map(profile => new BaseProfile(this.client, profile));
+    }
+    async sendFriendRequest() {
+        const request = await this.client.endpoints.profile.sendFriendRequest(this.id);
+        return request;
+    }
+    async removeFriendRequest() {
+        const request = await this.client.endpoints.profile.removeFriendRequest(this.id);
+        return request;
+    }
+}
+exports.BaseProfile = BaseProfile;