@duque.edits/sdk 0.1.5 → 0.1.6

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

@@ -1,35 +0,0 @@
-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";
-type OptionalGuildBet = Optional<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>;
-    createMany(bets: OptionalGuildBet[]): Promise<Collection<string, 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>;
-}
-export {};

package/dist/managers/bet/GuildBetManager.js

@@ -1,126 +0,0 @@
-"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,
-            payload,
-        });
-        const bet = this.set(response);
-        return bet;
-    }
-    async createMany(bets) {
-        Assertion_1.Assertion.assertArray(bets);
-        const route = Routes_1.Routes.guilds.bets.resource(this.guild.id, "bulk");
-        const payload = { bets };
-        const response = await this.rest.request({
-            method: "POST",
-            url: route,
-            payload,
-        });
-        this.rest.emit("betBulkCreate", response);
-        this.setAll(response);
-        const coll = new Collection_1.Collection();
-        for (let bt of response) {
-            const bet = new GuildBet_1.GuildBet(bt, this.guild, this, this.rest);
-            coll.set(bt._id, bet);
-        }
-        return coll;
-    }
-    /**
-     * 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;
-        if (!this.guild)
-            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

@@ -1,36 +0,0 @@
-import { REST } from "../../rest/REST";
-import { GuildBetUser } from "../../structures/betuser/GuildBetUser";
-import { Collection } from "../../structures/Collection";
-import { Guild } from "../../structures/guild/Guild";
-import { APIPlayer, Optional } from "../../types";
-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);
-    updateMany(data: Optional<APIPlayer>[]): Promise<Collection<string, GuildBetUser>>;
-    update(id: string, data: Optional<APIGuildBetUser> & {
-        type: "add" | "remove";
-    }): Promise<GuildBetUser>;
-    set(data: APIGuildBetUser): Collection<string, GuildBetUser>;
-    setAll(data: APIGuildBetUser[]): Collection<string, GuildBetUser>;
-    resetAll(): Promise<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

@@ -1,151 +0,0 @@
-"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");
-    }
-    async updateMany(data) {
-        const route = Routes_1.Routes.guilds.resources(this.guild.id, "betUsers", "bulk");
-        const payload = { betUsers: data };
-        const response = await this.rest.request({
-            method: "PATCH",
-            url: route,
-            payload,
-        });
-        this.setAll(response);
-        return this.cache;
-    }
-    async update(id, data) {
-        const route = Routes_1.Routes.guilds.betUsers.update(this.guild.id, id);
-        const payload = {};
-        const numericFields = ["coins", "wins", "credit", "losses", "mvps", "games"];
-        const arrayFields = ["items", "betsPlayed"];
-        if (data.type === "add" || data.type === "remove") {
-            for (const key in data) {
-                if (key === "type")
-                    continue;
-                const value = data[key];
-                if (numericFields.includes(key)) {
-                    const current = this[key];
-                    const num = value;
-                    payload[key] = Math.max(0, data.type === "add" ? current + num : num - current);
-                }
-                else if (key === "blacklist") {
-                    payload["blacklist"] = value;
-                }
-                else if (arrayFields.includes(key)) {
-                    const current = this[key];
-                    const incoming = value;
-                    payload[key] =
-                        data.type === "add"
-                            ? [...new Set([...current, ...incoming])]
-                            : current.filter((x) => !incoming.includes(x));
-                }
-            }
-        }
-        const response = await this.rest.request({
-            method: "patch",
-            url: route,
-            payload,
-        });
-        const user = new GuildBetUser_1.GuildBetUser(response, this, this.rest);
-        this.cache.set(user.id, user);
-        return user;
-    }
-    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;
-    }
-    async resetAll() {
-        const route = Routes_1.Routes.guilds.betUsers.getAll(this.guild.id);
-        const response = await this.rest.request({
-            method: "PUT",
-            url: route,
-        });
-        this.setAll(response);
-        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

@@ -1,39 +0,0 @@
-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(data: Optional<APIBaseChannel>): 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

@@ -1,148 +0,0 @@
-"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(data) {
-        const { id, type } = data;
-        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/giveaway/GiveawayManager.d.ts

@@ -1,16 +0,0 @@
-import { REST } from "../../rest/REST";
-import { Collection } from "../../structures/Collection";
-import { Giveaway } from "../../structures/giveaway/Giveaway";
-import { Optional } from "../../types";
-import { APIGiveaway } from "../../types/api/APIGiveaway";
-type AllowedTypes = Optional<APIGiveaway> | Giveaway | Giveaway[] | Optional<APIGiveaway>[];
-export declare class GiveawayManager {
-    cache: Collection<String, Giveaway>;
-    readonly rest: REST;
-    constructor(rest: REST);
-    fetchAll(): Promise<Collection<String, Giveaway>>;
-    create(data: Optional<APIGiveaway>): Promise<Giveaway>;
-    deleteAll(): Promise<Collection<String, Giveaway>>;
-    set(data: AllowedTypes): void;
-}
-export {};

package/dist/managers/giveaway/GiveawayManager.js

@@ -1,57 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.GiveawayManager = void 0;
-const Routes_1 = require("../../rest/Routes");
-const Collection_1 = require("../../structures/Collection");
-const Giveaway_1 = require("../../structures/giveaway/Giveaway");
-class GiveawayManager {
-    cache;
-    rest;
-    constructor(rest) {
-        this.rest = rest;
-        this.cache = new Collection_1.Collection("giveaways");
-    }
-    async fetchAll() {
-        const route = Routes_1.Routes.giveaways.getAll();
-        const response = await this.rest.request({
-            method: "get",
-            url: route,
-        });
-        this.set(response);
-        return this.cache;
-    }
-    async create(data) {
-        const route = Routes_1.Routes.giveaways.create();
-        const payload = data;
-        const response = await this.rest.request({
-            method: "post",
-            url: route,
-            payload,
-        });
-        const giveaway = new Giveaway_1.Giveaway(response, this);
-        this.set(giveaway);
-        return giveaway;
-    }
-    async deleteAll() {
-        const route = Routes_1.Routes.giveaways.deleteAll();
-        const response = await this.rest.request({
-            method: "delete",
-            url: route,
-        });
-        this.cache.clear();
-        return this.cache;
-    }
-    set(data) {
-        if (Array.isArray(data)) {
-            for (let giv of data) {
-                giv = new Giveaway_1.Giveaway(giv, this);
-                this.cache.set(giv._id, giv);
-            }
-        }
-        else {
-            data = new Giveaway_1.Giveaway(data, this);
-            this.cache.set(data._id, data);
-        }
-    }
-}
-exports.GiveawayManager = GiveawayManager;

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

@@ -1,34 +0,0 @@
-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;
-}