@duque.edits/sdk 0.0.4 → 0.0.6

package/{v1/index.ts → dist/index.d.ts}

@@ -1,30 +1,27 @@
-export * from "./managers/bet/GuildBetManager";
-export * from "./managers/betuser/GuildBetUserManager";
-export * from "./managers/channel/ChannelManager";
-export * from "./managers/groupedchannel/GroupedChannelManager";
-export * from "./managers/guild/GuildManager";
-export * from "./managers/match/GuildMatchManager";
-export * from "./managers/mediator/GuildMediatorManager";
-export * from "./managers/messages/MessagesManager";
-export * from "./managers/permission/GuildPermissionManager";
-export * from "./managers/product/GuildProductManager";
-export * from "./managers/ticket/GuildTicketManager";
-export * from "./managers/user/GuildUserManager";
-
-export * from "./structures/bet/GuildBet";
-export * from "./structures/betuser/GuildBetUser";
-export * from "./structures/channel/Channel";
-export * from "./structures/groupedchannel/GroupedChannel";
-export * from "./structures/guild/Guild";
-export * from "./structures/match/GuildMatch";
-export * from "./structures/mediator/GuildMediator";
-export * from "./structures/product/GuildProduct";
-export * from "./structures/shop/GuildShop";
-export * from "./structures/ticket/GuildTicket";
-export * from "./structures/user/GuildUser";
-export * from "./structures/Collection";
-
-export * from "./rest/REST";
-export * from "./rest/Routes";
-
-export * from "./types/index";
+export * from "./managers/bet/GuildBetManager";
+export * from "./managers/betuser/GuildBetUserManager";
+export * from "./managers/channel/ChannelManager";
+export * from "./managers/groupedchannel/GroupedChannelManager";
+export * from "./managers/guild/GuildManager";
+export * from "./managers/match/GuildMatchManager";
+export * from "./managers/mediator/GuildMediatorManager";
+export * from "./managers/messages/MessagesManager";
+export * from "./managers/permission/GuildPermissionManager";
+export * from "./managers/product/GuildProductManager";
+export * from "./managers/ticket/GuildTicketManager";
+export * from "./managers/user/GuildUserManager";
+export * from "./structures/bet/GuildBet";
+export * from "./structures/betuser/GuildBetUser";
+export * from "./structures/channel/Channel";
+export * from "./structures/groupedchannel/GroupedChannel";
+export * from "./structures/guild/Guild";
+export * from "./structures/match/GuildMatch";
+export * from "./structures/mediator/GuildMediator";
+export * from "./structures/product/GuildProduct";
+export * from "./structures/shop/GuildShop";
+export * from "./structures/ticket/GuildTicket";
+export * from "./structures/user/GuildUser";
+export * from "./structures/Collection";
+export * from "./rest/REST";
+export * from "./rest/Routes";
+export * from "./types/index";

package/dist/index.js

@@ -0,0 +1,43 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./managers/bet/GuildBetManager"), exports);
+__exportStar(require("./managers/betuser/GuildBetUserManager"), exports);
+__exportStar(require("./managers/channel/ChannelManager"), exports);
+__exportStar(require("./managers/groupedchannel/GroupedChannelManager"), exports);
+__exportStar(require("./managers/guild/GuildManager"), exports);
+__exportStar(require("./managers/match/GuildMatchManager"), exports);
+__exportStar(require("./managers/mediator/GuildMediatorManager"), exports);
+__exportStar(require("./managers/messages/MessagesManager"), exports);
+__exportStar(require("./managers/permission/GuildPermissionManager"), exports);
+__exportStar(require("./managers/product/GuildProductManager"), exports);
+__exportStar(require("./managers/ticket/GuildTicketManager"), exports);
+__exportStar(require("./managers/user/GuildUserManager"), exports);
+__exportStar(require("./structures/bet/GuildBet"), exports);
+__exportStar(require("./structures/betuser/GuildBetUser"), exports);
+__exportStar(require("./structures/channel/Channel"), exports);
+__exportStar(require("./structures/groupedchannel/GroupedChannel"), exports);
+__exportStar(require("./structures/guild/Guild"), exports);
+__exportStar(require("./structures/match/GuildMatch"), exports);
+__exportStar(require("./structures/mediator/GuildMediator"), exports);
+__exportStar(require("./structures/product/GuildProduct"), exports);
+__exportStar(require("./structures/shop/GuildShop"), exports);
+__exportStar(require("./structures/ticket/GuildTicket"), exports);
+__exportStar(require("./structures/user/GuildUser"), exports);
+__exportStar(require("./structures/Collection"), exports);
+__exportStar(require("./rest/REST"), exports);
+__exportStar(require("./rest/Routes"), exports);
+__exportStar(require("./types/index"), exports);

package/dist/managers/bet/GuildBetManager.d.ts

@@ -0,0 +1,32 @@
+import { REST } from "../../rest/REST";
+import { GuildBet } from "../../structures/bet/GuildBet";
+import { Collection } from "../../structures/Collection";
+import { Guild } from "../../structures/guild/Guild";
+import { Optional } from "../../types/api";
+import { APIGuildBet } from "../../types/api/APIGuildBet";
+export declare class GuildBetManager {
+    /** A cache of users */
+    cache: Collection<string, GuildBet>;
+    /** The rest client */
+    rest: REST;
+    /** GuildBet bet 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<APIGuildBet>): Promise<GuildBet>;
+    /**
+     * Fetch a bet
+     * @param id Id of the bet to fetch
+     * @returns APIBetUser
+     */
+    fetch(id: string): Promise<GuildBet>;
+    fetchAll(): Promise<Collection<string, GuildBet>>;
+    set(data: APIGuildBet): GuildBet;
+    setAll(data: APIGuildBet[]): Collection<string, GuildBet>;
+    delete(id: string): Promise<Collection<string, GuildBet>>;
+    deleteAll(): Promise<boolean>;
+}

package/dist/managers/bet/GuildBetManager.js

@@ -0,0 +1,107 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GuildBetManager = void 0;
+const Routes_1 = require("../../rest/Routes");
+const GuildBet_1 = require("../../structures/bet/GuildBet");
+const Collection_1 = require("../../structures/Collection");
+const Assertion_1 = require("../../utils/Assertion");
+class GuildBetManager {
+    /** A cache of users */
+    cache;
+    /** The rest client */
+    rest;
+    /** GuildBet bet 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("bets");
+    }
+    async create(payload) {
+        Assertion_1.Assertion.assertObject(payload);
+        const route = Routes_1.Routes.guilds.bets.create(this.guild.id);
+        const response = await this.rest.request({
+            method: "POST",
+            url: route,
+        });
+        const bet = this.set(response);
+        return bet;
+    }
+    /**
+     * Fetch a bet
+     * @param id Id of the bet to fetch
+     * @returns APIBetUser
+     */
+    async fetch(id) {
+        const route = Routes_1.Routes.guilds.bets.get(this.guild.id, id);
+        const response = await this.rest.request({
+            method: "get",
+            url: route,
+        });
+        const bet = new GuildBet_1.GuildBet(response, this.guild, this, this.rest);
+        this.cache.set(bet._id, bet);
+        this.rest.bets.set(bet._id, bet);
+        return bet;
+    }
+    async fetchAll() {
+        const route = Routes_1.Routes.guilds.bets.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;
+        }
+        for (let betData of response) {
+            const bet = new GuildBet_1.GuildBet(betData, this.guild, this, this.rest);
+            this.cache.set(bet._id, bet);
+        }
+        return this.cache;
+    }
+    set(data) {
+        if (!data._id)
+            return;
+        const bet = new GuildBet_1.GuildBet(data, this.guild, this, this.rest);
+        this.cache.set(bet._id, bet);
+        this.rest.bets.set(bet._id, bet);
+        return bet;
+    }
+    setAll(data) {
+        if (!data)
+            return this.cache;
+        for (let bet of data)
+            this.set(bet);
+        return this.cache;
+    }
+    ;
+    async delete(id) {
+        Assertion_1.Assertion.assertString(id);
+        const route = Routes_1.Routes.guilds.bets.delete(id, this.guild.id);
+        const bet = this.cache.get(id);
+        this.rest.emit("betDelete", bet);
+        await this.rest.request({
+            method: "DELETE",
+            url: route,
+        });
+        this.cache.delete(id);
+        return this.cache;
+    }
+    async deleteAll() {
+        const route = Routes_1.Routes.guilds.bets.deleteAll(this.guild.id);
+        this.rest.emit("betsDelete", this.cache);
+        const value = await this.rest.request({
+            method: "DELETE",
+            url: route,
+        });
+        this.cache.clear();
+        return value;
+    }
+}
+exports.GuildBetManager = GuildBetManager;
+;

package/dist/managers/betuser/GuildBetUserManager.d.ts

@@ -0,0 +1,30 @@
+import { REST } from "../../rest/REST";
+import { GuildBetUser } from "../../structures/betuser/GuildBetUser";
+import { Collection } from "../../structures/Collection";
+import { Guild } from "../../structures/guild/Guild";
+import { APIGuildBetUser } from "../../types/api/APIGuildBetUser";
+export declare class GuildBetUserManager {
+    /** A cache of users */
+    cache: Collection<string, GuildBetUser>;
+    /** The rest client */
+    rest: REST;
+    /** Bet user 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);
+    set(data: APIGuildBetUser): Collection<string, GuildBetUser>;
+    setAll(data: APIGuildBetUser[]): Collection<string, GuildBetUser>;
+    /**
+     * Fetch a user
+     * @param id Id of the user to fetch
+     * @returns GuildBetUser
+     */
+    fetch(id: string, name: string): Promise<GuildBetUser>;
+    fetchAll(): Promise<Collection<string, GuildBetUser>>;
+    delete(id: string): Promise<Collection<string, GuildBetUser>>;
+    deleteAll(): Promise<boolean>;
+}

package/dist/managers/betuser/GuildBetUserManager.js

@@ -0,0 +1,94 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GuildBetUserManager = void 0;
+const Routes_1 = require("../../rest/Routes");
+const GuildBetUser_1 = require("../../structures/betuser/GuildBetUser");
+const Collection_1 = require("../../structures/Collection");
+const Assertion_1 = require("../../utils/Assertion");
+class GuildBetUserManager {
+    /** A cache of users */
+    cache;
+    /** The rest client */
+    rest;
+    /** Bet user 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("betUsers");
+    }
+    set(data) {
+        if (!data.id)
+            return;
+        const user = new GuildBetUser_1.GuildBetUser(data, this, this.rest);
+        this.rest.betUsers.set(user.id, user);
+        return this.cache.set(user.id, user);
+    }
+    setAll(data) {
+        if (!data)
+            return this.cache;
+        for (let user of data)
+            this.set(user);
+        return this.cache;
+    }
+    /**
+     * Fetch a user
+     * @param id Id of the user to fetch
+     * @returns GuildBetUser
+     */
+    async fetch(id, name) {
+        const route = Routes_1.Routes.guilds.betUsers.get(this.guild.id, id);
+        const response = await this.rest.request({
+            method: "get",
+            url: route,
+            payload: { name },
+        });
+        if (!response)
+            return this.cache.get(id);
+        const user = new GuildBetUser_1.GuildBetUser(response, this, this.rest);
+        this.cache.set(user?.id, user);
+        this.rest.betUsers.set(user?.id, user);
+        return user;
+    }
+    async fetchAll() {
+        const route = Routes_1.Routes.guilds.betUsers.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;
+    }
+    async delete(id) {
+        Assertion_1.Assertion.assertString(id);
+        const route = Routes_1.Routes.guilds.betUsers.delete(id, this.guild.id);
+        const betUser = this.cache.get(id);
+        this.rest.emit("betDelete", betUser);
+        await this.rest.request({
+            method: "DELETE",
+            url: route,
+        });
+        this.cache.delete(id);
+        return this.cache;
+    }
+    async deleteAll() {
+        const route = Routes_1.Routes.guilds.betUsers.deleteAll(this.guild.id);
+        this.rest.emit("betsDelete", this.cache);
+        const value = await this.rest.request({
+            method: "DELETE",
+            url: route,
+        });
+        this.cache.clear();
+        return value;
+    }
+}
+exports.GuildBetUserManager = GuildBetUserManager;

package/dist/managers/channel/ChannelManager.d.ts

@@ -0,0 +1,39 @@
+import { REST } from "../../rest/REST";
+import { GuildBet } from "../../structures/bet/GuildBet";
+import { Channel } from "../../structures/channel/Channel";
+import { Collection } from "../../structures/Collection";
+import { Guild } from "../../structures/guild/Guild";
+import { GuildMatch } from "../../structures/match/GuildMatch";
+import { Optional } from "../../types/api";
+import { APIBaseChannel } from "../../types/api/APIBaseChannel";
+type Channels = Optional<APIBaseChannel>;
+export declare class ChannelManager<Structure extends GuildBet | GuildMatch> {
+    /** A cache of bet channels */
+    cache: Collection<string, Channel<Structure>>;
+    /** The rest client */
+    rest: REST;
+    /** GuildBet user guild */
+    guild: Guild;
+    /** The bet */
+    structure: Structure;
+    /** Base Url  */
+    baseUrl: string;
+    /**
+     * Manage channels of a bet
+     * @param guild The guild at hand
+     * @param bet The bet at hand
+     * @param rest The rest client
+     */
+    constructor(guild: Guild, structure: Structure, rest: REST);
+    create(id: string, type: string): Promise<Channel<Structure>>;
+    createMany(...channels: Channels[]): Promise<Collection<string, Channel<Structure>>>;
+    deleteMany(...channels: Optional<APIBaseChannel>[]): Promise<Collection<string, Channel<Structure>>>;
+    setAll(data: APIBaseChannel[]): Collection<string, Channel<Structure>>;
+    set(data: APIBaseChannel): Channel<Structure>;
+    update(type: string, payload: Optional<APIBaseChannel>): Promise<Channel<Structure>>;
+    fetch(type: string): Promise<Channel<Structure>>;
+    fetchAll(): Promise<Collection<string, Channel<Structure>>>;
+    delete(type: string): Promise<Collection<string, Channel<Structure>>>;
+    deleteAll(): Promise<boolean>;
+}
+export {};

package/dist/managers/channel/ChannelManager.js

@@ -0,0 +1,147 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ChannelManager = void 0;
+const Routes_1 = require("../../rest/Routes");
+const Channel_1 = require("../../structures/channel/Channel");
+const Collection_1 = require("../../structures/Collection");
+const Assertion_1 = require("../../utils/Assertion");
+class ChannelManager {
+    /** A cache of bet channels */
+    cache;
+    /** The rest client */
+    rest;
+    /** GuildBet user guild */
+    guild;
+    /** The bet */
+    structure;
+    /** Base Url  */
+    baseUrl;
+    /**
+     * Manage channels of a bet
+     * @param guild The guild at hand
+     * @param bet The bet at hand
+     * @param rest The rest client
+     */
+    constructor(guild, structure, rest) {
+        this.structure = structure;
+        this.rest = rest;
+        this.guild = guild;
+        this.cache = new Collection_1.Collection("channels");
+        this.baseUrl = Routes_1.Routes.guilds[structure.key].resource(guild.id, structure._id, "channels");
+    }
+    async create(id, type) {
+        Assertion_1.Assertion.assertString(id);
+        Assertion_1.Assertion.assertString(type);
+        const route = this.baseUrl;
+        const payload = { id, type };
+        const response = await this.rest.request({
+            method: "POST",
+            url: route,
+            payload,
+        });
+        const channel = this.set(response);
+        this.rest.emit("channelCreate", channel);
+        return channel;
+    }
+    async createMany(...channels) {
+        Assertion_1.Assertion.assertArray(channels);
+        const route = Routes_1.Routes.fields(this.baseUrl, "bulk");
+        const payload = { channels };
+        const response = await this.rest.request({
+            method: "POST",
+            url: route,
+            payload,
+        });
+        this.rest.emit("channelBulkCreate", response);
+        return this.setAll(response);
+    }
+    async deleteMany(...channels) {
+        Assertion_1.Assertion.assertArray(channels);
+        const route = Routes_1.Routes.fields(this.baseUrl, "bulk");
+        const payload = { channels };
+        const response = await this.rest.request({
+            method: "DELETE",
+            url: route,
+            payload,
+        });
+        const channel = this.setAll(response);
+        this.rest.emit("channelBulkDelete", channel);
+        return channel;
+    }
+    setAll(data) {
+        if (!data)
+            return this.cache;
+        for (let channelData of data)
+            this.set(channelData);
+        return this.cache;
+    }
+    set(data) {
+        if (!data.type)
+            return;
+        const channel = new Channel_1.Channel({
+            baseUrl: Routes_1.Routes.guilds[this.structure.key].resource(this.guild.id, this.structure._id, "channels"),
+            data: data,
+            guild: this.guild,
+            manager: this,
+        }, this.rest);
+        this.cache.set(data.type, channel);
+        return channel;
+    }
+    async update(type, payload) {
+        Assertion_1.Assertion.assertString(type);
+        Assertion_1.Assertion.assertObject(payload);
+        const route = Routes_1.Routes.fields(this.baseUrl, type);
+        const response = await this.rest.request({
+            method: "PATCH",
+            url: route,
+            payload,
+        });
+        const channel = this.set(response);
+        this.rest.emit("betUpdate", this.structure, this.structure);
+        return channel;
+    }
+    async fetch(type) {
+        Assertion_1.Assertion.assertString(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 response = await this.rest.request({
+            method: "GET",
+            url: this.baseUrl,
+        });
+        if (Array.isArray(response) && response.length === 0) {
+            this.cache.clear();
+            return this.cache;
+        }
+        for (let channelData of response)
+            this.set(channelData);
+        return this.cache;
+    }
+    async delete(type) {
+        Assertion_1.Assertion.assertString(type);
+        const route = this.baseUrl;
+        const response = await this.rest.request({
+            method: "DELETE",
+            url: Routes_1.Routes.fields(route, type),
+        });
+        this.cache.delete(type);
+        return this.cache;
+    }
+    async deleteAll() {
+        const route = this.baseUrl;
+        const value = await this.rest.request({
+            method: "DELETE",
+            url: route,
+        });
+        this.cache.clear();
+        return value;
+    }
+}
+exports.ChannelManager = ChannelManager;

package/dist/managers/groupedchannel/GroupedChannelManager.d.ts

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