@deffa5556/bail 1.0.6 → 1.0.7

package/cjs/lib/Discord/routes/Webhooks.cjs

@@ -0,0 +1,308 @@
+"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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function (o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function (o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function (o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o)
+                if (Object.prototype.hasOwnProperty.call(o, k))
+                    ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule)
+            return mod;
+        var result = {};
+        if (mod != null)
+            for (var k = ownKeys(mod), i = 0; i < k.length; i++)
+                if (k[i] !== "default")
+                    __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const Routes = __importStar(require("../util/Routes"));
+const Webhook_1 = __importDefault(require("../structures/Webhook"));
+const Message_1 = __importDefault(require("../structures/Message"));
+const QueryBuilder_1 = __importDefault(require("../util/QueryBuilder"));
+/** Various methods for interacting with webhooks. Located at {@link Client#rest | Client#rest}{@link RESTManager#webhooks | .webhooks}. */
+class Webhooks {
+    constructor(manager) {
+        this._manager = manager;
+    }
+    /**
+     * Create a channel webhook.
+     * @param channelID The ID of the channel to create the webhook in.
+     * @param options The options to create the webhook with.
+     * @caching This method **does not** cache its result.
+     */
+    async create(channelID, options) {
+        options = this._manager.client.util._freeze(options);
+        let avatar;
+        if (options.avatar) {
+            avatar = this._manager.client.util._convertImage(options.avatar, "avatar");
+        }
+        return this._manager.authRequest({
+            method: "POST",
+            path: Routes.CHANNEL_WEBHOOKS(channelID),
+            json: {
+                avatar,
+                name: options.name
+            },
+            reason: options.reason
+        }).then(data => new Webhook_1.default(data, this._manager.client));
+    }
+    /**
+     * Delete a webhook.
+     * @param webhookID The ID of the webhook.
+     * @param reason The reason for deleting the webhook.
+     * @caching This method **does not** cache its result.
+     */
+    async delete(webhookID, reason) {
+        await this._manager.authRequest({
+            method: "DELETE",
+            path: Routes.WEBHOOK(webhookID),
+            reason
+        });
+    }
+    /**
+     * Delete a webhook message.
+     * @param webhookID The ID of the webhook.
+     * @param token The token of the webhook.
+     * @param messageID The ID of the message.
+     * @param options The options for deleting the message.
+     * @caching This method **does not** cache its result.
+     */
+    async deleteMessage(webhookID, token, messageID, options) {
+        const query = new QueryBuilder_1.default();
+        query.setIfPresent("thread_id", options?.threadID);
+        await this._manager.authRequest({
+            method: "DELETE",
+            path: Routes.WEBHOOK_MESSAGE(webhookID, token, messageID),
+            query
+        });
+    }
+    /**
+     * Delete a webhook via its token.
+     * @param webhookID The ID of the webhook.
+     * @param token The token of the webhook.
+     * @caching This method **does not** cache its result.
+     */
+    async deleteToken(webhookID, token) {
+        await this._manager.authRequest({
+            method: "DELETE",
+            path: Routes.WEBHOOK(webhookID, token)
+        });
+    }
+    /**
+     * Edit a webhook.
+     * @param webhookID The ID of the webhook.
+     * @param options The options for editing the webhook.
+     * @caching This method **does not** cache its result.
+     */
+    async edit(webhookID, options) {
+        options = this._manager.client.util._freeze(options);
+        let avatar;
+        if (options.avatar) {
+            avatar = this._manager.client.util._convertImage(options.avatar, "avatar");
+        }
+        return this._manager.authRequest({
+            method: "PATCH",
+            path: Routes.WEBHOOK(webhookID),
+            json: {
+                avatar,
+                channel_id: options.channelID,
+                name: options.name
+            },
+            reason: options.reason
+        }).then(data => new Webhook_1.default(data, this._manager.client));
+    }
+    /**
+     * Edit a webhook message.
+     * @param webhookID The ID of the webhook.
+     * @param token The token of the webhook.
+     * @param messageID The ID of the message to edit.
+     * @param options The options for editing the message.
+     * @caching This method **does not** cache its result.
+     */
+    async editMessage(webhookID, token, messageID, options) {
+        options = this._manager.client.util._freeze(options);
+        const query = new QueryBuilder_1.default();
+        query.setIfPresent("thread_id", options?.threadID);
+        return this._manager.authRequest({
+            method: "PATCH",
+            path: Routes.WEBHOOK_MESSAGE(webhookID, token, messageID),
+            json: {
+                allowed_mentions: this._manager.client.util.formatAllowedMentions(options.allowedMentions),
+                attachments: options.attachments,
+                components: options.components ? this._manager.client.util.componentsToRaw(options.components) : undefined,
+                content: options.content,
+                embeds: options.embeds ? this._manager.client.util.embedsToRaw(options.embeds) : undefined,
+                flags: options.flags,
+                poll: options.poll ? {
+                    allow_multiselect: options.poll.allowMultiselect,
+                    answers: options.poll.answers.map(a => ({
+                        poll_media: a.pollMedia
+                    })),
+                    duration: options.poll.duration,
+                    layout_type: options.poll.layoutType,
+                    question: options.poll.question
+                } : undefined
+            },
+            query,
+            files: options.files ?? undefined
+        }).then(data => new Message_1.default(data, this._manager.client));
+    }
+    /**
+     * Edit a webhook via its token.
+     * @param webhookID The ID of the webhook.
+     * @param options The options for editing the webhook.
+     * @caching This method **does not** cache its result.
+     */
+    async editToken(webhookID, token, options) {
+        options = this._manager.client.util._freeze(options);
+        let avatar;
+        if (options.avatar) {
+            avatar = this._manager.client.util._convertImage(options.avatar, "avatar");
+        }
+        return this._manager.authRequest({
+            method: "PATCH",
+            path: Routes.WEBHOOK(webhookID, token),
+            json: {
+                avatar,
+                name: options.name
+            }
+        }).then(data => new Webhook_1.default(data, this._manager.client));
+    }
+    async execute(webhookID, token, options) {
+        options = this._manager.client.util._freeze(options);
+        const query = new QueryBuilder_1.default();
+        query.setIfPresent("wait", options.wait);
+        query.setIfPresent("with_components", options.withComponents);
+        query.setIfPresent("thread_id", options.threadID);
+        return this._manager.authRequest({
+            method: "POST",
+            path: Routes.WEBHOOK(webhookID, token),
+            query,
+            json: {
+                allowed_mentions: this._manager.client.util.formatAllowedMentions(options.allowedMentions),
+                attachments: options.attachments,
+                avatar_url: options.avatarURL,
+                components: options.components ? this._manager.client.util.componentsToRaw(options.components) : undefined,
+                content: options.content,
+                embeds: options.embeds ? this._manager.client.util.embedsToRaw(options.embeds) : undefined,
+                flags: options.flags,
+                poll: options.poll ? {
+                    allow_multiselect: options.poll.allowMultiselect,
+                    answers: options.poll.answers.map(a => ({
+                        poll_media: a.pollMedia
+                    })),
+                    duration: options.poll.duration,
+                    layout_type: options.poll.layoutType,
+                    question: options.poll.question
+                } : undefined,
+                thread_name: options.threadName,
+                tts: options.tts,
+                username: options.username
+            },
+            files: options.files
+        }).then(res => res === null ? undefined : new Message_1.default(res, this._manager.client));
+    }
+    async executeGithub(webhookID, token, options) {
+        options = this._manager.client.util._freeze(options);
+        const query = new QueryBuilder_1.default();
+        query.setIfPresent("wait", options?.wait);
+        return this._manager.authRequest({
+            method: "POST",
+            path: Routes.WEBHOOK_PLATFORM(webhookID, token, "github"),
+            query,
+            json: options
+        }).then(res => res === null ? undefined : new Message_1.default(res, this._manager.client));
+    }
+    async executeSlack(webhookID, token, options) {
+        options = this._manager.client.util._freeze(options);
+        const query = new QueryBuilder_1.default();
+        query.setIfPresent("wait", options?.wait);
+        return this._manager.authRequest({
+            method: "POST",
+            path: Routes.WEBHOOK_PLATFORM(webhookID, token, "slack"),
+            query,
+            json: options
+        }).then(res => res === null ? undefined : new Message_1.default(res, this._manager.client));
+    }
+    /**
+     * Get a webhook by ID (and optionally token).
+     * @param webhookID The ID of the webhook.
+     * @param token The token of the webhook.
+     * @caching This method **does not** cache its result.
+     */
+    async get(webhookID, token) {
+        return this._manager.authRequest({
+            method: "GET",
+            path: Routes.WEBHOOK(webhookID, token)
+        }).then(data => new Webhook_1.default(data, this._manager.client));
+    }
+    /**
+     * Get the webhooks in the specified channel.
+     * @param channelID The ID of the channel to get the webhooks of.
+     * @caching This method **does not** cache its result.
+     */
+    async getForChannel(channelID) {
+        return this._manager.authRequest({
+            method: "GET",
+            path: Routes.CHANNEL_WEBHOOKS(channelID)
+        }).then(data => data.map(d => new Webhook_1.default(d, this._manager.client)));
+    }
+    /**
+     * Get the webhooks in the specified guild.
+     * @param guildID The ID of the guild to get the webhooks of.
+     * @caching This method **does not** cache its result.
+     */
+    async getForGuild(guildID) {
+        return this._manager.authRequest({
+            method: "GET",
+            path: Routes.GUILD_WEBHOOKS(guildID)
+        }).then(data => data.map(d => new Webhook_1.default(d, this._manager.client)));
+    }
+    /**
+     * Get a webhook message.
+     * @param webhookID The ID of the webhook.
+     * @param token The token of the webhook.
+     * @param messageID The ID of the message.
+     * @param threadID The ID of the thread the message is in.
+     * @caching This method **does not** cache its result.
+     */
+    async getMessage(webhookID, token, messageID, threadID) {
+        const query = new QueryBuilder_1.default();
+        query.setIfPresent("thread_id", threadID);
+        return this._manager.authRequest({
+            method: "GET",
+            path: Routes.WEBHOOK_MESSAGE(webhookID, token, messageID),
+            query
+        }).then(data => new Message_1.default(data, this._manager.client));
+    }
+}
+exports.default = Webhooks;

package/cjs/lib/Discord/structures/AnnouncementChannel.cjs

@@ -0,0 +1,46 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const ThreadableChannel_1 = __importDefault(require("./ThreadableChannel"));
+const Constants_1 = require("../Constants");
+/**
+ * Represents a guild announcement channel.
+ * @mergeTarget AnnouncementChannel
+ */
+class AnnouncementChannel extends ThreadableChannel_1.default {
+    constructor(data, client) {
+        super(data, client);
+        this.defaultAutoArchiveDuration = data.default_auto_archive_duration;
+    }
+    /**
+     * Convert this announcement channel to a text channel.
+     */
+    async convert() {
+        return this.client.rest.channels.edit(this.id, { type: Constants_1.ChannelTypes.GUILD_TEXT });
+    }
+    /**
+     * Crosspost a message in this channel.
+     * @param messageID The ID of the message to crosspost.
+     */
+    async crosspostMessage(messageID) {
+        return this.client.rest.channels.crosspostMessage(this.id, messageID);
+    }
+    /**
+     * Follow this announcement channel.
+     * @param webhookChannelID The ID of the channel crossposted messages should be sent to. The client must have the `MANAGE_WEBHOOKS` permission in this channel.
+     * @param reason The reason for following this channel.
+     */
+    async follow(webhookChannelID, reason) {
+        return this.client.rest.channels.followAnnouncement(this.id, webhookChannelID, reason);
+    }
+    toJSON() {
+        return {
+            ...super.toJSON(),
+            rateLimitPerUser: 0,
+            type: this.type
+        };
+    }
+}
+exports.default = AnnouncementChannel;

package/cjs/lib/Discord/structures/AnnouncementThreadChannel.cjs

@@ -0,0 +1,28 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+/** @module AnnouncementThreadChannel */
+const ThreadChannel_1 = __importDefault(require("./ThreadChannel"));
+/** Represents a public thread channel in an announcement channel. */
+class AnnouncementThreadChannel extends ThreadChannel_1.default {
+    constructor(data, client) {
+        super(data, client);
+    }
+    /**
+     * Get the members of this thread.
+     * @param options The options for getting the thread members.
+     */
+    async getThreadMembers(options) {
+        return this.client.rest.channels.getThreadMembers(this.id, options);
+    }
+    toJSON() {
+        return {
+            ...super.toJSON(),
+            threadMetadata: this.threadMetadata,
+            type: this.type
+        };
+    }
+}
+exports.default = AnnouncementThreadChannel;