@duque.edits/sdk 0.1.4 → 0.1.6

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/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;
-}

package/dist/managers/groupedchannel/GroupedChannelManager.js

@@ -1,92 +0,0 @@
-"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/mediator/GuildMediatorManager.d.ts

@@ -1,32 +0,0 @@
-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

@@ -1,98 +0,0 @@
-"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,
-            payload,
-        });
-        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(this.guild.id, 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

@@ -1,32 +0,0 @@
-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<boolean>;
-    /**
-     * 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[]): Collection<string, APIMessage>;
-    setAll(data: APIMessage[]): Collection<string, APIMessage>;
-}

package/dist/managers/messages/MessagesManager.js

@@ -1,89 +0,0 @@
-"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,
-        });
-        this.set(response);
-        return true;
-    }
-    /**
-     * 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 message = this.set(response);
-        this.set(response);
-        return response;
-    }
-    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?.userId}-${Date.now() * Math.random() + 100}`, data);
-        }
-        return this.cache;
-    }
-    set(data) {
-        if (Array.isArray(data)) {
-            for (let message of data) {
-                if (!message?.type)
-                    return;
-                this.cache.set(`${message?.userId}-${Date.now() * Math.random() + 50}`, message);
-            }
-        }
-        else {
-            this.cache.set(`${data?.userId}-${Date.now() * Math.random() + 5}`, data);
-        }
-        return this.cache;
-    }
-    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

@@ -1,26 +0,0 @@
-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/product/GuildProductManager.d.ts

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

package/dist/managers/product/GuildProductManager.js

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