@notidotbot/noti-api-client 1.4.0

package/dist/classes/guildPlatform.d.ts

@@ -0,0 +1,163 @@
+import { AllPlatforms, KickStreamer, KickStreamerZod, RumbleStreamer, RumbleStreamerZod, TikTokStreamer, TikTokStreamerZod, TwitchStreamer, TwitchStreamerZod, YouTubeStreamerZod } from '../other/prisma';
+import { LeaderBoardTypesEnum, StreamerMessageTypeEnum } from '@prisma/client';
+import { CancelOutWebResponses, DeepPartial } from '../types';
+import { WebDataManager } from '../core/manager';
+export declare class APIGuildPlatform {
+    private web;
+    constructor(web: WebDataManager);
+    getGuildStreamers<T extends boolean, P extends AllPlatforms>({ auth, guildId, shortView, platform }: GuildPlatformFunctionsInput<T, P>['getGuildStreamers']): Promise<import("../types").WebResponse<Platformstreamers<T, P>>>;
+    getGuildStreamer<P extends AllPlatforms>({ auth, guildId, streamer, platform, rumbleType }: GuildPlatformFunctionsInput<never, P>['getGuildStreamer']): Promise<import("../types").WebResponse<GuildSingleStreamerWithFormatedRole<P>>>;
+    createGuildStreamer<P extends AllPlatforms>({ auth, guildId, streamer, body, platform, rumbleType }: GuildPlatformFunctionsInput<never, P>['createGuildStreamer']): Promise<import("../types").WebResponse<GuildSingleStreamer<P>>>;
+    updateGuildStreamer<P extends AllPlatforms>({ auth, guildId, streamer, body, platform, rumbleType }: GuildPlatformFunctionsInput<never, P>['updateGuildStreamer']): Promise<import("../types").WebResponse<string>>;
+    deleteGuildStreamer<P extends AllPlatforms>({ auth, guildId, streamer, platform, rumbleType }: GuildPlatformFunctionsInput<never, P>['updateGuildStreamer']): Promise<import("../types").WebResponse<string>>;
+    sendTestNotification({ auth, guildId, streamer, platform, rumbleType, subType }: GuildPlatformFunctionsInput['sendTestNotification']): Promise<import("../types").WebResponse<string>>;
+    createOrUpdateStreamerMessage({ auth, guildId, streamer, platform, type, subTypeOrId, data, rumbleType }: GuildPlatformFunctionsInput['createOrUpdateStreamerMessage']): Promise<import("../types").WebResponse<string>>;
+    createOrUpdateKickStreamerRoles<T extends KickRolesType>({ auth, guildId, streamer, platform, type, subTypeOrId, data }: GuildPlatformFunctionsInput<never, never, T>['createOrUpdateKickStreamerRoles']): Promise<import("../types").WebResponse<string>>;
+    deleteStreamerMessage({ auth, guildId, streamer, platform, type, subTypeOrId, rumbleType }: GuildPlatformFunctionsInput['deleteStreamerMessage']): Promise<import("../types").WebResponse<string>>;
+    deleteKickStreamerRoles<T extends KickRolesType>({ auth, guildId, streamer, platform, type, subTypeOrId }: GuildPlatformFunctionsInput<never, never, T>['deleteKickStreamerRoles']): Promise<import("../types").WebResponse<string>>;
+}
+export type GuildPlatformFunctionsInput<T extends boolean = never, P extends AllPlatforms = never, RT extends KickRolesType = never> = {
+    'getGuildStreamers': {
+        auth: string;
+        guildId: string;
+        shortView: T;
+        platform: P;
+    };
+    'getGuildStreamer': {
+        auth: string;
+        guildId: string;
+        streamer: string;
+        platform: P;
+        rumbleType?: RumbleType;
+    };
+    'createGuildStreamer': {
+        auth: string;
+        guildId: string;
+        streamer: string;
+        body: GuildSingleStreamer<P>;
+        platform: P;
+        rumbleType?: RumbleType;
+    };
+    'updateGuildStreamer': {
+        auth: string;
+        guildId: string;
+        streamer: string;
+        body: DeepPartial<GuildSingleStreamer<P>>;
+        platform: P;
+        rumbleType?: RumbleType;
+    };
+    'deleteGuildStreamer': {
+        auth: string;
+        guildId: string;
+        streamer: string;
+        platform: P;
+        rumbleType?: RumbleType;
+    };
+    'sendTestNotification': {
+        auth: string;
+        guildId: string;
+        streamer: string;
+        platform: P;
+        rumbleType?: RumbleType;
+        subType?: SubType;
+    };
+    'createOrUpdateStreamerMessage': {
+        auth: string;
+        guildId: string;
+        streamer: string;
+        platform: P;
+        type: 'customMessages';
+        subTypeOrId: StreamerMessageTypeEnum;
+        data: StreamerUpdateMessage;
+        rumbleType?: RumbleType;
+    };
+    'deleteStreamerMessage': {
+        auth: string;
+        guildId: string;
+        streamer: string;
+        platform: P;
+        type: 'customMessages';
+        subTypeOrId: StreamerMessageTypeEnum;
+        rumbleType?: RumbleType;
+    };
+    'createOrUpdateKickStreamerRoles': {
+        auth: string;
+        guildId: string;
+        streamer: string;
+        platform: 'kick';
+        type: RT;
+        subTypeOrId: KickRolesSubType<RT>;
+        data: KickRolesData<RT>;
+    };
+    'deleteKickStreamerRoles': {
+        auth: string;
+        guildId: string;
+        streamer: string;
+        platform: 'kick';
+        type: RT;
+        subTypeOrId: KickRolesSubType<RT>;
+    };
+};
+export type GuildPlatformReturnTypes = {
+    'getGuildStreamersRaw': Awaited<ReturnType<APIGuildPlatform['getGuildStreamers']>>;
+    'getGuildStreamersSuccess': CancelOutWebResponses<Awaited<ReturnType<APIGuildPlatform['getGuildStreamers']>>>;
+    'getGuildStreamerRaw': Awaited<ReturnType<APIGuildPlatform['getGuildStreamer']>>;
+    'getGuildStreamerSuccess': CancelOutWebResponses<Awaited<ReturnType<APIGuildPlatform['getGuildStreamer']>>>;
+    'createGuildStreamerRaw': Awaited<ReturnType<APIGuildPlatform['createGuildStreamer']>>;
+    'createGuildStreamerSuccess': CancelOutWebResponses<Awaited<ReturnType<APIGuildPlatform['createGuildStreamer']>>>;
+    'updateGuildStreamerRaw': Awaited<ReturnType<APIGuildPlatform['updateGuildStreamer']>>;
+    'updateGuildStreamerSuccess': CancelOutWebResponses<Awaited<ReturnType<APIGuildPlatform['updateGuildStreamer']>>>;
+    'deleteGuildStreamerRaw': Awaited<ReturnType<APIGuildPlatform['deleteGuildStreamer']>>;
+    'deleteGuildStreamerSuccess': CancelOutWebResponses<Awaited<ReturnType<APIGuildPlatform['deleteGuildStreamer']>>>;
+    'sendTestNotificationRaw': Awaited<ReturnType<APIGuildPlatform['sendTestNotification']>>;
+    'sendTestNotificationSuccess': CancelOutWebResponses<Awaited<ReturnType<APIGuildPlatform['sendTestNotification']>>>;
+    'createOrUpdateStreamerMessageRaw': Awaited<ReturnType<APIGuildPlatform['createOrUpdateStreamerMessage']>>;
+    'createOrUpdateStreamerMessageSuccess': CancelOutWebResponses<Awaited<ReturnType<APIGuildPlatform['createOrUpdateStreamerMessage']>>>;
+    'deleteStreamerMessageRaw': Awaited<ReturnType<APIGuildPlatform['deleteStreamerMessage']>>;
+    'deleteStreamerMessageSuccess': CancelOutWebResponses<Awaited<ReturnType<APIGuildPlatform['deleteStreamerMessage']>>>;
+    'createOrUpdateKickStreamerRolesRaw': Awaited<ReturnType<APIGuildPlatform['createOrUpdateKickStreamerRoles']>>;
+    'createOrUpdateKickStreamerRolesSuccess': CancelOutWebResponses<Awaited<ReturnType<APIGuildPlatform['createOrUpdateKickStreamerRoles']>>>;
+    'deleteKickStreamerRolesRaw': Awaited<ReturnType<APIGuildPlatform['deleteKickStreamerRoles']>>;
+    'deleteKickStreamerRolesSuccess': CancelOutWebResponses<Awaited<ReturnType<APIGuildPlatform['deleteKickStreamerRoles']>>>;
+};
+export type SubType = 'live' | 'video';
+export type RumbleType = 'user' | 'channel';
+export type UsersForLiveRole = {
+    id: string;
+    name: string;
+}[];
+export type GuildSingleStreamer<T extends AllPlatforms> = T extends 'kick' ? KickStreamerZod : T extends 'twitch' ? TwitchStreamerZod : T extends 'rumble' ? RumbleStreamerZod : T extends 'tiktok' ? TikTokStreamerZod : T extends 'youtube' ? YouTubeStreamerZod : never;
+export type GuildSingleStreamerWithFormatedRole<T extends AllPlatforms> = T extends 'kick' ? KickStreamer & UsersForLiveRole : T extends 'twitch' ? TwitchStreamer & UsersForLiveRole : T extends 'rumble' ? RumbleStreamer & UsersForLiveRole : T extends 'tiktok' ? TikTokStreamer & UsersForLiveRole : T extends 'youtube' ? YouTubeStreamerZod & UsersForLiveRole : never;
+export type StreamerUpdateMessage = (KickStreamerZod | TwitchStreamerZod | RumbleStreamerZod | TikTokStreamerZod | YouTubeStreamerZod)['customMessages'][number];
+export type KickRolesType = 'leaderboardSyncRoles' | 'giftedSubRoles';
+export type KickRolesSubType<T extends KickRolesType> = T extends 'leaderboardSyncRoles' ? LeaderBoardTypesEnum : T extends 'giftedSubRoles' ? string : never;
+export type KickRolesData<T extends KickRolesType> = T extends 'leaderboardSyncRoles' ? KickStreamerZod['leaderBoardSyncRoles'][number] : T extends 'giftedSubRoles' ? KickStreamerZod['giftedSubRoles'][number] : never;
+export type Platformstreamers<T extends boolean, P extends AllPlatforms> = {
+    streamers: T extends true ? P extends 'kick' ? {
+        streamerUserName: string;
+        streamerId: string | null;
+        chatRoomId: string;
+        guildId: string;
+    }[] : P extends 'twitch' ? {
+        streamerUserName: string;
+        streamerId: string | null;
+        guildId: string;
+    }[] : P extends 'rumble' ? {
+        streamerUserName: string;
+        type: string;
+        guildId: string;
+    }[] : P extends 'tiktok' ? {
+        streamerUserName: string;
+        guildId: string;
+    }[] : P extends 'youtube' ? {
+        streamerUserName: string;
+        streamerId: string;
+        guildId: string | null;
+    }[] : never : P extends 'kick' ? KickStreamer[] : P extends 'twitch' ? TwitchStreamer[] : P extends 'rumble' ? RumbleStreamer[] : P extends 'tiktok' ? TikTokStreamer[] : never;
+    currentTotal: number;
+    maxLimit: number;
+    premium: {
+        tierId: string;
+        tierName: string;
+    };
+};

package/dist/classes/guildPlatform.js

@@ -0,0 +1,99 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.APIGuildPlatform = void 0;
+// Data.
+class APIGuildPlatform {
+    web;
+    constructor(web) {
+        this.web = web;
+    }
+    // Methods.
+    async getGuildStreamers({ auth, guildId, shortView, platform }) {
+        return await this.web.request({
+            method: 'GET', auth,
+            endpoint: this.web.qp('/data/guild/' + guildId + '/' + platform, {
+                short: shortView || false,
+            }),
+        });
+    }
+    async getGuildStreamer({ auth, guildId, streamer, platform, rumbleType }) {
+        return await this.web.request({
+            method: 'GET', auth,
+            endpoint: this.web.qp('/data/guild/' + guildId + '/' + platform + '/' + streamer, {
+                rumbleType: (platform === 'rumble' ? rumbleType : undefined),
+            }),
+        });
+    }
+    async createGuildStreamer({ auth, guildId, streamer, body, platform, rumbleType }) {
+        return await this.web.request({
+            method: 'POST', auth, body,
+            endpoint: this.web.qp('/data/guild/' + guildId + '/' + platform + '/' + streamer, {
+                rumbleType: (platform === 'rumble' ? rumbleType : undefined),
+            }),
+        });
+    }
+    async updateGuildStreamer({ auth, guildId, streamer, body, platform, rumbleType }) {
+        return await this.web.request({
+            method: 'PATCH', auth, body,
+            endpoint: this.web.qp('/data/guild/' + guildId + '/' + platform + '/' + streamer, {
+                rumbleType: (platform === 'rumble' ? rumbleType : undefined),
+            }),
+        });
+    }
+    async deleteGuildStreamer({ auth, guildId, streamer, platform, rumbleType }) {
+        return await this.web.request({
+            method: 'DELETE', auth,
+            endpoint: this.web.qp('/data/guild/' + guildId + '/' + platform + '/' + streamer, {
+                rumbleType: (platform === 'rumble' ? rumbleType : undefined),
+            }),
+        });
+    }
+    async sendTestNotification({ auth, guildId, streamer, platform, rumbleType, subType }) {
+        return await this.web.request({
+            method: 'PUT', auth,
+            endpoint: this.web.qp('/data/guild/' + guildId + '/' + platform + '/' + streamer, {
+                rumbleType: (platform === 'rumble' ? rumbleType : undefined),
+                subType: (subType || undefined),
+            }),
+        });
+    }
+    async createOrUpdateStreamerMessage({ auth, guildId, streamer, platform, type, subTypeOrId, data, rumbleType }) {
+        return await this.web.request({
+            method: 'PATCH', auth, body: data,
+            endpoint: this.web.qp(`/data/guild/${guildId}/${platform}/${streamer}/updateArray`, {
+                type: type,
+                subTypeOrId: subTypeOrId,
+                rumbleType: (platform === 'rumble' ? rumbleType : undefined),
+            }),
+        });
+    }
+    async createOrUpdateKickStreamerRoles({ auth, guildId, streamer, platform, type, subTypeOrId, data }) {
+        return await this.web.request({
+            method: 'PATCH', auth, body: data,
+            endpoint: this.web.qp(`/data/guild/${guildId}/${platform}/${streamer}/updateArray`, {
+                type: type,
+                subTypeOrId: subTypeOrId,
+            }),
+        });
+    }
+    async deleteStreamerMessage({ auth, guildId, streamer, platform, type, subTypeOrId, rumbleType }) {
+        return await this.web.request({
+            method: 'DELETE', auth,
+            endpoint: this.web.qp(`/data/guild/${guildId}/${platform}/${streamer}/deleteArray`, {
+                type: type,
+                subTypeOrId: subTypeOrId,
+                rumbleType: (platform === 'rumble' ? rumbleType : undefined),
+            }),
+        });
+    }
+    async deleteKickStreamerRoles({ auth, guildId, streamer, platform, type, subTypeOrId }) {
+        return await this.web.request({
+            method: 'DELETE', auth,
+            endpoint: this.web.qp(`/data/guild/${guildId}/${platform}/${streamer}/deleteArray`, {
+                type: type,
+                subTypeOrId: subTypeOrId,
+            }),
+        });
+    }
+}
+exports.APIGuildPlatform = APIGuildPlatform;

package/dist/classes/guildPlatformAction.d.ts

@@ -0,0 +1,67 @@
+import { CancelOutWebResponses } from '../types';
+import { WebDataManager } from '../core/manager';
+export declare class APIPlatformAction {
+    private web;
+    constructor(web: WebDataManager);
+    getStreamerEmojisInfo<P extends 'kick'>({ auth, guildId, platform, username, getEmojis }: PlatformActionFunctionsInput<P>['getStreamerEmojisInfo']): Promise<import("../types").WebResponse<StreamerEmojis>>;
+    addStreamerEmojis<P extends 'kick'>({ auth, guildId, platform, username, emojis, lockToSubIfSet }: PlatformActionFunctionsInput<P>['addStreamerEmojis']): Promise<import("../types").WebResponse<AddEmojisInfo>>;
+}
+export type PlatformActionFunctionsInput<P extends 'kick' = never> = {
+    'getStreamerEmojisInfo': {
+        auth: string;
+        guildId: string;
+        platform: P;
+        username: string;
+        getEmojis: boolean;
+    };
+    'addStreamerEmojis': {
+        auth: string;
+        guildId: string;
+        platform: P;
+        username: string;
+        emojis: EmojiAddSchema['emojis'];
+        lockToSubIfSet: boolean;
+    };
+};
+export type PlatformActionReturnTypes = {
+    'getStreamerEmojisInfoRaw': Awaited<ReturnType<APIPlatformAction['getStreamerEmojisInfo']>>;
+    'getStreamerEmojisInfoSuccess': CancelOutWebResponses<Awaited<ReturnType<APIPlatformAction['getStreamerEmojisInfo']>>>;
+};
+export type StreamerEmojis = {
+    subRole?: string;
+    kickEmojis: KickEmojisParsed | null;
+    canAdd: {
+        normal: number;
+        animated: number;
+    };
+};
+export type KickEmojisParsed = {
+    id: string;
+    name: string;
+    subOnly: boolean;
+}[];
+export type EmojiSchema = {
+    name: string;
+    url: `https://files.kick.com/emotes/${string}/fullsize`;
+}[];
+export type EmojiAddSchema = {
+    emojis: {
+        normal: EmojiSchema[];
+        animated: EmojiSchema[];
+    };
+    lockToSubIfSet: boolean;
+};
+export type AddEmojisInfo = {
+    succeded: {
+        normal: string[];
+        animated: string[];
+    };
+    failed: {
+        normal: string[];
+        animated: string[];
+    };
+    canAdd: {
+        normal: number;
+        animated: number;
+    };
+};

package/dist/classes/guildPlatformAction.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.APIPlatformAction = void 0;
+// Data.
+class APIPlatformAction {
+    web;
+    constructor(web) {
+        this.web = web;
+    }
+    // Methods.
+    async getStreamerEmojisInfo({ auth, guildId, platform, username, getEmojis }) {
+        return await this.web.request({
+            method: 'GET', auth,
+            endpoint: this.web.qp(`/data/guild/${guildId}/${platform}/${username}/emojis`, {
+                kickEmojis: getEmojis || false,
+            }),
+        });
+    }
+    async addStreamerEmojis({ auth, guildId, platform, username, emojis, lockToSubIfSet }) {
+        return await this.web.request({
+            method: 'POST', auth, body: { emojis, lockToSubIfSet },
+            endpoint: this.web.qp(`/data/guild/${guildId}/${platform}/${username}/emojis`),
+        });
+    }
+}
+exports.APIPlatformAction = APIPlatformAction;

package/dist/classes/guildStarboard.d.ts

@@ -0,0 +1,66 @@
+import { GuildStarboardZod } from '../other/prisma';
+import { CancelOutWebResponses, DeepPartial } from '../types';
+import { WebDataManager } from '../core/manager';
+export declare class APIGuildStarboard {
+    private web;
+    constructor(web: WebDataManager);
+    getGuildStarboards({ auth, guildId }: GuildStarboardFunctionsInput['getGuildStarboards']): Promise<import("../types").WebResponse<({
+        filter: {
+            dbId: string;
+            guildStarboardId: string;
+            roles: string[];
+            roleMode: import("@prisma/client").$Enums.FilterEnum | null;
+            channelMode: import("@prisma/client").$Enums.FilterEnum | null;
+            channels: string[];
+        } | null;
+    } & {
+        dbId: string;
+        guildId: string;
+        channelId: string;
+        enabled: boolean | null;
+        threshold: number | null;
+        emojiId: string | null;
+        emojiName: string | null;
+        allowNsfw: boolean | null;
+        allowSelfStar: boolean | null;
+        allowBotMessages: boolean | null;
+        deleteIfLost: boolean | null;
+        rewardRole: string | null;
+        openThreadOnStar: boolean | null;
+    })[]>>;
+    createStarboard({ auth, guildId, body }: GuildStarboardFunctionsInput['createStarboard']): Promise<import("../types").WebResponse<string>>;
+    updateStarboard({ auth, guildId, channelId, body }: GuildStarboardFunctionsInput['updateStarboard']): Promise<import("../types").WebResponse<string>>;
+    deleteStarboard({ auth, guildId, channelId }: GuildStarboardFunctionsInput['deleteStarboard']): Promise<import("../types").WebResponse<string>>;
+}
+export type GuildStarboardFunctionsInput = {
+    'getGuildStarboards': {
+        auth: string;
+        guildId: string;
+    };
+    'createStarboard': {
+        auth: string;
+        guildId: string;
+        body: GuildStarboardZod;
+    };
+    'updateStarboard': {
+        auth: string;
+        guildId: string;
+        channelId: string;
+        body: DeepPartial<GuildStarboardZod>;
+    };
+    'deleteStarboard': {
+        auth: string;
+        guildId: string;
+        channelId: string;
+    };
+};
+export type GuildStarboardReturnTypes = {
+    'getGuildStreamersRaw': Awaited<ReturnType<APIGuildStarboard['getGuildStarboards']>>;
+    'getGuildStreamersSuccess': CancelOutWebResponses<Awaited<ReturnType<APIGuildStarboard['getGuildStarboards']>>>;
+    'createStarboardRaw': Awaited<ReturnType<APIGuildStarboard['createStarboard']>>;
+    'createStarboardSuccess': CancelOutWebResponses<Awaited<ReturnType<APIGuildStarboard['createStarboard']>>>;
+    'updateStarboardRaw': Awaited<ReturnType<APIGuildStarboard['updateStarboard']>>;
+    'updateStarboardSuccess': CancelOutWebResponses<Awaited<ReturnType<APIGuildStarboard['updateStarboard']>>>;
+    'deleteStarboardRaw': Awaited<ReturnType<APIGuildStarboard['deleteStarboard']>>;
+    'deleteStarboardSuccess': CancelOutWebResponses<Awaited<ReturnType<APIGuildStarboard['deleteStarboard']>>>;
+};

package/dist/classes/guildStarboard.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.APIGuildStarboard = void 0;
+// Data.
+class APIGuildStarboard {
+    web;
+    constructor(web) {
+        this.web = web;
+    }
+    // Methods.
+    async getGuildStarboards({ auth, guildId }) {
+        return await this.web.request({
+            method: 'GET', auth,
+            endpoint: this.web.qp('/data/starboards/' + guildId),
+        });
+    }
+    async createStarboard({ auth, guildId, body }) {
+        return await this.web.request({
+            method: 'POST', auth, body,
+            endpoint: this.web.qp('/data/starboards/' + guildId),
+        });
+    }
+    async updateStarboard({ auth, guildId, channelId, body }) {
+        return await this.web.request({
+            method: 'PATCH', auth, body,
+            endpoint: this.web.qp('/data/starboards/' + guildId + '/' + channelId),
+        });
+    }
+    async deleteStarboard({ auth, guildId, channelId }) {
+        return await this.web.request({
+            method: 'DELETE', auth,
+            endpoint: this.web.qp('/data/starboards/' + guildId + '/' + channelId),
+        });
+    }
+}
+exports.APIGuildStarboard = APIGuildStarboard;

package/dist/classes/linked.d.ts

@@ -0,0 +1,26 @@
+import { WebDataManager } from '../core/manager';
+import { CancelOutWebResponses } from '../types';
+export declare class APILinked {
+    private web;
+    constructor(web: WebDataManager);
+    getLinkedRolesUrl(): Promise<import("../types").WebResponse<string>>;
+    authorizeLinkedRoles({ code }: {
+        code: string;
+    }): Promise<import("../types").WebResponse<true>>;
+    unlinkRoles(): Promise<import("../types").WebResponse<true>>;
+}
+export type LinkedFunctionsInput = {
+    'getLinkedRolesUrl': never;
+    'authorizeLinkedRoles': {
+        code: string;
+    };
+    'unlinkRoles': never;
+};
+export type LinkedReturnTypes = {
+    'getLinkedRolesUrlRaw': Awaited<ReturnType<APILinked['getLinkedRolesUrl']>>;
+    'getLinkedRolesUrlSuccess': CancelOutWebResponses<Awaited<ReturnType<APILinked['getLinkedRolesUrl']>>>;
+    'authorizeLinkedRolesRaw': Awaited<ReturnType<APILinked['authorizeLinkedRoles']>>;
+    'authorizeLinkedRolesSuccess': CancelOutWebResponses<Awaited<ReturnType<APILinked['authorizeLinkedRoles']>>>;
+    'unlinkRolesRaw': Awaited<ReturnType<APILinked['unlinkRoles']>>;
+    'unlinkRolesSuccess': CancelOutWebResponses<Awaited<ReturnType<APILinked['unlinkRoles']>>>;
+};

package/dist/classes/linked.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.APILinked = void 0;
+// Data.
+class APILinked {
+    web;
+    constructor(web) {
+        this.web = web;
+    }
+    // Methods.
+    async getLinkedRolesUrl() {
+        return await this.web.request({
+            method: 'GET',
+            endpoint: this.web.qp('/linked'),
+        });
+    }
+    async authorizeLinkedRoles({ code }) {
+        return await this.web.request({
+            method: 'POST',
+            endpoint: this.web.qp('/linked', {
+                code,
+            }),
+        });
+    }
+    async unlinkRoles() {
+        return await this.web.request({
+            method: 'DELETE',
+            endpoint: this.web.qp('/linked'),
+        });
+    }
+}
+exports.APILinked = APILinked;

package/dist/classes/other.d.ts

@@ -0,0 +1,83 @@
+import { CancelOutWebResponses } from '../types';
+import { WebDataManager } from '../core/manager';
+export declare class APIOther {
+    private web;
+    constructor(web: WebDataManager);
+    status<T extends boolean>({ withTopServers }?: {
+        withTopServers?: T;
+    }): Promise<import("../types").WebResponse<StatusType<T>>>;
+    recentActivity(): Promise<import("../types").WebResponse<RecentActivityType>>;
+    checkRateLimit({ auth }: OtherFunctionsInput['checkRateLimit']): Promise<import("../types").WebResponse<string>>;
+    getAllLanguages(): Promise<import("../types").WebResponse<LanguageList>>;
+    oAuth2({ guildId }: OtherFunctionsInput['oAuth2']): Promise<import("../types").WebResponse<OAuth2Type>>;
+    isDown(): Promise<boolean>;
+}
+export type OtherFunctionsInput = {
+    'checkRateLimit': {
+        auth: string;
+    };
+    'getAllLanguages': never;
+    'oAuth2': {
+        guildId?: string;
+    };
+};
+export type OtherReturnTypes = {
+    'checkRateLimitRaw': Awaited<ReturnType<APIOther['checkRateLimit']>>;
+    'checkRateLimitSuccess': CancelOutWebResponses<Awaited<ReturnType<APIOther['checkRateLimit']>>>;
+    'getAllLanguagesRaw': Awaited<ReturnType<APIOther['getAllLanguages']>>;
+    'getAllLanguagesSuccess': CancelOutWebResponses<Awaited<ReturnType<APIOther['getAllLanguages']>>>;
+    'oAuth2Raw': Awaited<ReturnType<APIOther['oAuth2']>>;
+    'oAuth2Success': CancelOutWebResponses<Awaited<ReturnType<APIOther['oAuth2']>>>;
+};
+export type LanguageList = {
+    name: string;
+    value: string;
+}[];
+export type RecentActivityType = {
+    type: 'premium' | 'live' | 'vod' | 'clip' | 'overlay' | 'link' | 'vote';
+    message: string;
+    createdAt: number;
+}[];
+export type OAuth2Type = {
+    login: string;
+    invite: string;
+};
+export type StatusType<T extends boolean = false> = {
+    devMode: boolean;
+    shardsPerClusters: number;
+    totalStreamers: number;
+    totalNotifications: number;
+    totalStatChannels: number;
+    totalStatusRoles: number;
+    totalClips: number;
+    totalVods: number;
+    totalClusters: number;
+    totalShards: number;
+    database: string;
+    clusters: {
+        clusterId: number;
+        online: boolean;
+        uptime: number;
+        ping: number;
+        stats: {
+            cpuUsage: string;
+            coreUsage: string;
+            memoryUsage: string;
+        };
+        totalGuilds: number;
+        totalMembers: number;
+        shards: {
+            shardId: number;
+            shardPing: number;
+            status: string;
+            totalMembers: number;
+            totalGuilds: number;
+        }[];
+    }[];
+    topServers: T extends true ? {
+        id: string;
+        name: string;
+        members: number;
+        icon: string | null;
+    }[] : never;
+};

package/dist/classes/other.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.APIOther = void 0;
+// Data.
+class APIOther {
+    web;
+    constructor(web) {
+        this.web = web;
+    }
+    // Methods.
+    async status({ withTopServers } = {}) {
+        return await this.web.request({
+            method: 'GET',
+            endpoint: this.web.qp('/status', {
+                topServers: withTopServers || false,
+            }),
+        });
+    }
+    async recentActivity() {
+        return await this.web.request({
+            method: 'GET',
+            endpoint: this.web.qp('/recent'),
+        });
+    }
+    async checkRateLimit({ auth }) {
+        return await this.web.request({
+            method: 'GET', auth,
+            endpoint: this.web.qp('/ratelimit'),
+        });
+    }
+    async getAllLanguages() {
+        return await this.web.request({
+            method: 'GET',
+            endpoint: this.web.qp('/data/languages'),
+        });
+    }
+    async oAuth2({ guildId }) {
+        return await this.web.request({
+            method: 'GET',
+            endpoint: this.web.qp('/oauth2', {
+                guildId,
+            }),
+        });
+    }
+    async isDown() {
+        const response = await this.web.request({
+            method: 'GET',
+            endpoint: this.web.qp('/'),
+        });
+        return 'error' in response || response?.status !== 200;
+    }
+}
+exports.APIOther = APIOther;