@duque.edits/sdk 0.0.4 → 0.0.6

package/dist/managers/groupedchannel/GroupedChannelManager.js

@@ -0,0 +1,92 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GroupedChannelManager = void 0;
+const Routes_1 = require("../../rest/Routes");
+const GroupedChannel_1 = require("../../structures/groupedchannel/GroupedChannel");
+const Collection_1 = require("../../structures/Collection");
+const Assertion_1 = require("../../utils/Assertion");
+class GroupedChannelManager {
+    /** A cache of channels */
+    cache;
+    /** Key */
+    key;
+    baseUrl;
+    /** The rest client */
+    rest;
+    /** GroupedChannel groupedChannel guild */
+    guild;
+    /**
+     * Manage channels with the given client
+     * @param channels An array of channels
+     * @param rest The rest client
+     */
+    constructor(guild, key, rest) {
+        this.key = key;
+        this.baseUrl = Routes_1.Routes.fields(Routes_1.Routes.guilds.get(guild?.id), key);
+        this.cache = new Collection_1.Collection("groupedChannels");
+        this.guild = guild;
+        this.rest = rest;
+    }
+    async delete(type) {
+        const route = Routes_1.Routes.fields(this.baseUrl, type);
+        const response = await this.rest.request({
+            method: "delete",
+            url: route,
+        });
+        this.cache.delete(type);
+        return response;
+    }
+    async create(payload) {
+        Assertion_1.Assertion.assertObject(payload);
+        const route = this.baseUrl;
+        const response = await this.rest.request({
+            method: "POST",
+            url: route,
+            payload,
+        });
+        const groupedChannel = this.set(response);
+        return groupedChannel;
+    }
+    /**
+     * Fetch a groupedChannel
+     * @param id Id of the groupedChannel to fetch
+     * @returns APIgroupedChannelUser
+     */
+    async fetch(type) {
+        const route = Routes_1.Routes.fields(this.baseUrl, type);
+        const response = await this.rest.request({
+            method: "get",
+            url: route,
+        });
+        const channel = this.set(response);
+        this.cache.set(channel.type, channel);
+        return channel;
+    }
+    async fetchAll() {
+        const route = this.baseUrl;
+        const response = await this.rest.request({
+            method: "get",
+            url: route,
+        });
+        for (let groupedChannelData of response) {
+            const groupedChannel = new GroupedChannel_1.GroupedChannel(groupedChannelData, this.guild, this, this.rest);
+            this.cache.set(groupedChannel.type, groupedChannel);
+        }
+        return this.cache;
+    }
+    setAll(data) {
+        if (!data)
+            return this.cache;
+        for (let groupedChannel of data)
+            this.set(groupedChannel);
+        return this.cache;
+    }
+    set(data) {
+        if (!data?.type)
+            return;
+        const groupedChannel = new GroupedChannel_1.GroupedChannel(data, this.guild, this, this.rest);
+        this.cache.set(data.type, groupedChannel);
+        return groupedChannel;
+    }
+}
+exports.GroupedChannelManager = GroupedChannelManager;

package/dist/managers/guild/GuildManager.d.ts

@@ -0,0 +1,24 @@
+import { REST } from "../../rest/REST";
+import { Collection } from "../../structures/Collection";
+import { Guild } from "../../structures/guild/Guild";
+export declare class GuildManager {
+    /** A cache of guilds */
+    cache: Collection<string, Guild>;
+    /** The rest client */
+    rest: REST;
+    /**
+     * Manage guilds with the given client
+     * @param guilds An array of guilds
+     * @param rest The rest client
+     */
+    constructor(rest: REST);
+    /**
+     * Fetch a guild
+     * @param id Id of the guild to fetch
+     * @returns APIGuild
+     */
+    fetch(id: string): Promise<Guild>;
+    fetchAll(): Promise<Collection<string, Guild>>;
+    delete(id: string): Promise<Collection<string, Guild>>;
+    deleteAll(): Promise<boolean>;
+}

package/dist/managers/guild/GuildManager.js

@@ -0,0 +1,75 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GuildManager = void 0;
+const Routes_1 = require("../../rest/Routes");
+const Collection_1 = require("../../structures/Collection");
+const Guild_1 = require("../../structures/guild/Guild");
+const Assertion_1 = require("../../utils/Assertion");
+class GuildManager {
+    /** A cache of guilds */
+    cache;
+    /** The rest client */
+    rest;
+    /**
+     * Manage guilds with the given client
+     * @param guilds An array of guilds
+     * @param rest The rest client
+     */
+    constructor(rest) {
+        this.cache = new Collection_1.Collection("guilds");
+        this.rest = rest;
+    }
+    /**
+     * Fetch a guild
+     * @param id Id of the guild to fetch
+     * @returns APIGuild
+     */
+    async fetch(id) {
+        const route = Routes_1.Routes.guilds.get(id);
+        const response = await this.rest.request({
+            method: "get",
+            url: route,
+        });
+        const guild = new Guild_1.Guild(response, this.rest);
+        this.cache.set(guild.id, guild);
+        return guild;
+    }
+    async fetchAll() {
+        const route = Routes_1.Routes.guilds.getAll();
+        const response = await this.rest.request({
+            method: "get",
+            url: route,
+        });
+        for (let guildData of response) {
+            if (!guildData.id)
+                continue;
+            const guild = new Guild_1.Guild(guildData, this.rest);
+            this.cache.set(guild.id, guild);
+            this.rest.guilds.cache.set(guild.id, guild);
+        }
+        return this.cache;
+    }
+    async delete(id) {
+        Assertion_1.Assertion.assertString(id);
+        const route = Routes_1.Routes.guilds.delete(id);
+        const guild = this.cache.get(id);
+        this.rest.emit("guildDelete", guild);
+        await this.rest.request({
+            method: "DELETE",
+            url: route,
+        });
+        this.cache.delete(id);
+        return this.cache;
+    }
+    async deleteAll() {
+        const route = Routes_1.Routes.guilds.deleteAll();
+        this.rest.emit("guildsDelete", this.cache);
+        const value = await this.rest.request({
+            method: "DELETE",
+            url: route,
+        });
+        this.cache.clear();
+        return value;
+    }
+}
+exports.GuildManager = GuildManager;

package/dist/managers/match/GuildMatchManager.d.ts

@@ -0,0 +1,32 @@
+import { REST } from "../../rest/REST";
+import { GuildMatch } from "../../structures/match/GuildMatch";
+import { Collection } from "../../structures/Collection";
+import { Guild } from "../../structures/guild/Guild";
+import { APIGuildMatch } from "../../types/api/APIGuildMatch";
+import { Optional } from "../../types/api";
+export declare class GuildMatchManager {
+    /** A cache of users */
+    cache: Collection<string, GuildMatch>;
+    /** The rest client */
+    rest: REST;
+    /** GuildMatch match guild */
+    guild: Guild;
+    /**
+     * Manage users with the given client
+     * @param users An array of users
+     * @param rest The rest client
+     */
+    constructor(guild: Guild, rest: REST);
+    /**
+     * Fetch a match
+     * @param id Id of the match to fetch
+     * @returns APIBetUser
+     */
+    fetch(id: string): Promise<GuildMatch>;
+    fetchAll(): Promise<Collection<string, GuildMatch>>;
+    set(data: APIGuildMatch): GuildMatch;
+    setAll(data: APIGuildMatch[]): Collection<string, GuildMatch>;
+    create(payload: Optional<APIGuildMatch>): Promise<GuildMatch>;
+    delete(id: string): Promise<Collection<string, GuildMatch>>;
+    deleteAll(): Promise<boolean>;
+}

package/dist/managers/match/GuildMatchManager.js

@@ -0,0 +1,103 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GuildMatchManager = void 0;
+const Routes_1 = require("../../rest/Routes");
+const GuildMatch_1 = require("../../structures/match/GuildMatch");
+const Collection_1 = require("../../structures/Collection");
+const Assertion_1 = require("../../utils/Assertion");
+class GuildMatchManager {
+    /** A cache of users */
+    cache;
+    /** The rest client */
+    rest;
+    /** GuildMatch match guild */
+    guild;
+    /**
+     * Manage users with the given client
+     * @param users An array of users
+     * @param rest The rest client
+     */
+    constructor(guild, rest) {
+        this.guild = guild;
+        this.cache = new Collection_1.Collection("matches");
+        this.rest = rest;
+    }
+    /**
+     * Fetch a match
+     * @param id Id of the match to fetch
+     * @returns APIBetUser
+     */
+    async fetch(id) {
+        const route = Routes_1.Routes.guilds.matches.get(this.guild.id, id);
+        const response = await this.rest.request({
+            method: "get",
+            url: route,
+        });
+        const match = new GuildMatch_1.GuildMatch(response, this.guild, this, this.rest);
+        this.cache.set(match._id, match);
+        this.rest.matches.set(match._id, match);
+        return match;
+    }
+    async fetchAll() {
+        const route = Routes_1.Routes.guilds.matches.getAll(this.guild.id);
+        const response = await this.rest.request({
+            method: "get",
+            url: route,
+        });
+        if (Array.isArray(response) && response.length === 0) {
+            this.cache.clear();
+            return this.cache;
+        }
+        this.setAll(response);
+        return this.cache;
+    }
+    set(data) {
+        if (!data?._id)
+            return;
+        const match = new GuildMatch_1.GuildMatch(data, this?.guild, this, this.rest);
+        this.cache.set(data?._id, match);
+        this.rest.matches.set(data?._id, match);
+        return match;
+    }
+    setAll(data) {
+        if (!data)
+            return this.cache;
+        for (let match of data || [])
+            this.set(match);
+        return this.cache;
+    }
+    async create(payload) {
+        Assertion_1.Assertion.assertObject(payload);
+        const route = Routes_1.Routes.guilds.matches.create(this.guild.id);
+        const response = await this.rest.request({
+            method: "POST",
+            url: route,
+            payload,
+        });
+        const match = this.set(response);
+        return match;
+    }
+    async delete(id) {
+        Assertion_1.Assertion.assertString(id);
+        const route = Routes_1.Routes.guilds.matches.delete(id, this.guild.id);
+        const match = this.cache.get(id);
+        this.rest.emit("matchDelete", match);
+        await this.rest.request({
+            method: "DELETE",
+            url: route,
+        });
+        this.cache.delete(id);
+        return this.cache;
+    }
+    async deleteAll() {
+        const route = Routes_1.Routes.guilds.matches.deleteAll(this.guild.id);
+        this.rest.emit("matchesDelete", this.cache);
+        const value = await this.rest.request({
+            method: "DELETE",
+            url: route,
+        });
+        this.cache.clear();
+        return value;
+    }
+}
+exports.GuildMatchManager = GuildMatchManager;

package/dist/managers/mediator/GuildMediatorManager.d.ts

@@ -0,0 +1,32 @@
+import { REST } from "../../rest/REST";
+import { Collection } from "../../structures/Collection";
+import { Guild } from "../../structures/guild/Guild";
+import { GuildMediator } from "../../structures/mediator/GuildMediator";
+import { Optional } from "../../types/api";
+import { APIGuildMediator } from "../../types/api/APIGuildMediator";
+export declare class GuildMediatorManager {
+    /** A cache of users */
+    cache: Collection<string, GuildMediator>;
+    /** The rest client */
+    rest: REST;
+    /** GuildMediator mediator guild */
+    guild: Guild;
+    /**
+     * Manage users with the given client
+     * @param users An array of users
+     * @param rest The rest client
+     */
+    constructor(guild: Guild, rest: REST);
+    create(payload: Optional<APIGuildMediator>): Promise<GuildMediator>;
+    /**
+     * Fetch a mediator
+     * @param id Id of the mediator to fetch
+     * @returns APImediatorUser
+     */
+    fetch(id: string): Promise<GuildMediator>;
+    fetchAll(): Promise<Collection<string, GuildMediator>>;
+    set(data: APIGuildMediator): GuildMediator;
+    setAll(data: APIGuildMediator[]): Collection<string, GuildMediator>;
+    delete(id: string): Promise<Collection<string, GuildMediator>>;
+    deleteAll(): Promise<boolean>;
+}

package/dist/managers/mediator/GuildMediatorManager.js

@@ -0,0 +1,97 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GuildMediatorManager = void 0;
+const Routes_1 = require("../../rest/Routes");
+const Collection_1 = require("../../structures/Collection");
+const GuildMediator_1 = require("../../structures/mediator/GuildMediator");
+const Assertion_1 = require("../../utils/Assertion");
+class GuildMediatorManager {
+    /** A cache of users */
+    cache;
+    /** The rest client */
+    rest;
+    /** GuildMediator mediator guild */
+    guild;
+    /**
+     * Manage users with the given client
+     * @param users An array of users
+     * @param rest The rest client
+     */
+    constructor(guild, rest) {
+        this.guild = guild;
+        this.rest = rest;
+        this.cache = new Collection_1.Collection("mediators");
+    }
+    async create(payload) {
+        Assertion_1.Assertion.assertObject(payload);
+        const route = Routes_1.Routes.guilds.mediators.create(this.guild.id);
+        const response = await this.rest.request({
+            method: "POST",
+            url: route,
+        });
+        const mediator = this.set(response);
+        return mediator;
+    }
+    /**
+     * Fetch a mediator
+     * @param id Id of the mediator to fetch
+     * @returns APImediatorUser
+     */
+    async fetch(id) {
+        const route = Routes_1.Routes.guilds.mediators.get(this.guild.id, id);
+        const response = await this.rest.request({
+            method: "get",
+            url: route,
+        });
+        const mediator = new GuildMediator_1.GuildMediator(response, this.guild, this, this.rest);
+        this.cache.set(mediator.id, mediator);
+        return mediator;
+    }
+    async fetchAll() {
+        const route = Routes_1.Routes.guilds.mediators.getAll(this.guild.id);
+        const response = await this.rest.request({
+            method: "get",
+            url: route,
+        });
+        this.setAll(response);
+        return this.cache;
+    }
+    set(data) {
+        if (!data.id)
+            return;
+        const mediator = new GuildMediator_1.GuildMediator(data, this.guild, this, this.rest);
+        this.cache.set(data.id, mediator);
+        this.rest.mediators.set(mediator.id, mediator);
+        return mediator;
+    }
+    setAll(data) {
+        if (!data)
+            return this.cache;
+        for (let mediator of data)
+            this.set(mediator);
+        return this.cache;
+    }
+    async delete(id) {
+        Assertion_1.Assertion.assertString(id);
+        const route = Routes_1.Routes.guilds.mediators.delete(id, this.guild.id);
+        const mediator = this.cache.get(id);
+        this.rest.emit("mediatorDelete", mediator);
+        await this.rest.request({
+            method: "DELETE",
+            url: route,
+        });
+        this.cache.delete(id);
+        return this.cache;
+    }
+    async deleteAll() {
+        const route = Routes_1.Routes.guilds.mediators.deleteAll(this.guild.id);
+        this.rest.emit("mediatorsDelete", this.cache);
+        const value = await this.rest.request({
+            method: "DELETE",
+            url: route,
+        });
+        this.cache.clear();
+        return value;
+    }
+}
+exports.GuildMediatorManager = GuildMediatorManager;

package/dist/managers/messages/MessagesManager.d.ts

@@ -0,0 +1,32 @@
+import { REST } from "../../rest/REST";
+import { Collection } from "../../structures/Collection";
+import { Guild } from "../../structures/guild/Guild";
+import { Optional } from "../../types/api";
+import { APIMessage } from "../../types/api/APIMessage";
+export declare class MessagesManager {
+    /** A cache of messages */
+    cache: Collection<string, APIMessage>;
+    /** Key */
+    key: string;
+    baseUrl: string;
+    /** The rest client */
+    rest: REST;
+    /** APIMessage message guild */
+    guild: Guild;
+    /**
+     * Manage messages with the given client
+     * @param messages An array of messages
+     * @param rest The rest client
+     */
+    constructor(guild: Guild, key: string, rest: REST);
+    create(payload: Optional<APIMessage>): Promise<APIMessage>;
+    /**
+     * Fetch a message
+     * @param id Id of the message to fetch
+     * @returns APIgroupedChannelUser
+     */
+    fetch(type: string): Promise<APIMessage>;
+    fetchAll(): Promise<Collection<string, APIMessage>>;
+    set(data: APIMessage): APIMessage;
+    setAll(data: APIMessage[]): Collection<string, APIMessage>;
+}

package/dist/managers/messages/MessagesManager.js

@@ -0,0 +1,82 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MessagesManager = void 0;
+const Routes_1 = require("../../rest/Routes");
+const Collection_1 = require("../../structures/Collection");
+const Assertion_1 = require("../../utils/Assertion");
+class MessagesManager {
+    /** A cache of messages */
+    cache;
+    /** Key */
+    key;
+    baseUrl;
+    /** The rest client */
+    rest;
+    /** APIMessage message guild */
+    guild;
+    /**
+     * Manage messages with the given client
+     * @param messages An array of messages
+     * @param rest The rest client
+     */
+    constructor(guild, key, rest) {
+        this.guild = guild;
+        this.key = key;
+        this.baseUrl = Routes_1.Routes.fields(Routes_1.Routes.guilds.get(guild?.id), key, "messages");
+        this.cache = new Collection_1.Collection(`${key}-messages`);
+        this.rest = rest;
+    }
+    async create(payload) {
+        Assertion_1.Assertion.assertObject(payload);
+        const route = this.baseUrl;
+        const response = await this.rest.request({
+            method: "POST",
+            url: route,
+            payload,
+        });
+        const message = this.set(response);
+        return message;
+    }
+    /**
+     * Fetch a message
+     * @param id Id of the message to fetch
+     * @returns APIgroupedChannelUser
+     */
+    async fetch(type) {
+        const route = Routes_1.Routes.fields(this.baseUrl, type);
+        const response = await this.rest.request({
+            method: "get",
+            url: route,
+        });
+        const channel = this.set(response);
+        this.cache.set(channel.type, channel);
+        return channel;
+    }
+    async fetchAll() {
+        const route = this.baseUrl;
+        const response = await this.rest.request({
+            method: "get",
+            url: route,
+        });
+        for (let data of response) {
+            if (!data.type)
+                continue;
+            this.cache.set(data?.type, data);
+        }
+        return this.cache;
+    }
+    set(data) {
+        if (!data?.type)
+            return;
+        this.cache.set(data?.type, data);
+        return data;
+    }
+    setAll(data) {
+        if (!data)
+            return this.cache;
+        for (let message of data)
+            this.set(message);
+        return this.cache;
+    }
+}
+exports.MessagesManager = MessagesManager;

package/dist/managers/permission/GuildPermissionManager.d.ts

@@ -0,0 +1,26 @@
+import { REST } from "../../rest/REST";
+import { Guild } from "../../structures/guild/Guild";
+import { APIGuildPermissions } from "../../types/api/APIGuildPermissions";
+export declare class GuildPermissionManager {
+    /** The rest client */
+    rest: REST;
+    /** GuildBet bet guild */
+    guild: Guild;
+    permissions: APIGuildPermissions;
+    /**
+     * Manage users with the given client
+     * @param users An array of users
+     * @param rest The rest client
+     */
+    constructor(guild: Guild, rest: REST);
+    /**
+     * Fetch a bet
+     * @param id Id of the bet to fetch
+     * @returns APIBetUser
+     */
+    fetch(): Promise<void>;
+    addId(permissionId: keyof APIGuildPermissions, roleId: string): Promise<string[]>;
+    removeId(permissionId: keyof APIGuildPermissions, roleId: string): Promise<string[]>;
+    setAll(data: APIGuildPermissions): APIGuildPermissions;
+    toJSON(): Record<string, unknown>;
+}

package/dist/managers/permission/GuildPermissionManager.js

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GuildPermissionManager = void 0;
+const Routes_1 = require("../../rest/Routes");
+class GuildPermissionManager {
+    /** The rest client */
+    rest;
+    /** GuildBet bet guild */
+    guild;
+    permissions;
+    /**
+     * Manage users with the given client
+     * @param users An array of users
+     * @param rest The rest client
+     */
+    constructor(guild, rest) {
+        this.guild = guild;
+        this.rest = rest;
+    }
+    /**
+     * Fetch a bet
+     * @param id Id of the bet to fetch
+     * @returns APIBetUser
+     */
+    async fetch() {
+        const route = Routes_1.Routes.guilds.resource(this.guild.id, "permissions");
+        const response = await this.rest.request({
+            method: "get",
+            url: route,
+        });
+        this.setAll(response);
+    }
+    async addId(permissionId, roleId) {
+        const route = Routes_1.Routes.guilds.resources(this.guild.id, "permissions", permissionId, "ids");
+        const payload = { id: roleId };
+        const response = await this.rest.request({
+            method: "post",
+            url: route,
+            payload,
+        });
+        this.permissions[permissionId] = response;
+        return response;
+    }
+    async removeId(permissionId, roleId) {
+        const route = Routes_1.Routes.guilds.resources(this.guild.id, "permissions", permissionId, "ids", roleId);
+        const payload = { id: roleId };
+        const response = await this.rest.request({
+            method: "delete",
+            url: route,
+            payload,
+        });
+        this.permissions[permissionId] = response;
+        return response;
+    }
+    setAll(data) {
+        if (!data)
+            return this.permissions;
+        this.permissions = data;
+    }
+    toJSON() {
+        const json = {};
+        for (const [key, value] of Object.entries(this)) {
+            if (typeof value !== "function") {
+                json[key] = value;
+            }
+        }
+        return json;
+    }
+}
+exports.GuildPermissionManager = GuildPermissionManager;