@duque.edits/sdk 0.1.5 → 0.1.6

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;

package/dist/managers/ticket/GuildTicketManager.d.ts

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

package/dist/managers/ticket/GuildTicketManager.js

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

package/dist/managers/user/GuildUserManager.d.ts

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

package/dist/rest/APIEndpoints.d.ts

@@ -1,11 +0,0 @@
-declare class Guild {
-    id: string;
-    tickets: [];
-}
-export declare const APIEndpoints: {
-    "guilds/get": {
-        response: typeof Guild;
-    };
-};
-export type APIEndpoint = keyof string;
-export {};