oceanic.js 1.10.3-dev.c6c9f52 → 1.10.3-dev.ca8b6e8

package/dist/lib/routes/Channels.js

@@ -0,0 +1,1160 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const Routes = tslib_1.__importStar(require("../util/Routes"));
+const Invite_1 = tslib_1.__importDefault(require("../structures/Invite"));
+const StageInstance_1 = tslib_1.__importDefault(require("../structures/StageInstance"));
+/** Various methods for interacting with channels. Located at {@link Client#rest | Client#rest}{@link RESTManager#channels | .channels}. */
+class Channels {
+    _manager;
+    constructor(manager) {
+        this._manager = manager;
+    }
+    /**
+     * Add a user to a group channel.
+     * @param groupID The ID of the group to add the user to.
+     * @param options The options for adding the recipient.
+     * @caching This method **does not** cache its result.
+     */
+    async addGroupRecipient(groupID, options) {
+        await this._manager.authRequest({
+            method: "PUT",
+            path: Routes.GROUP_RECIPIENT(groupID, options.userID),
+            json: {
+                access_token: options.accessToken,
+                nick: options.nick
+            }
+        });
+    }
+    /**
+     * Add a member to a thread.
+     * @param channelID The ID of the thread to add them to.
+     * @param userID The ID of the user to add to the thread.
+     * @caching This method **does not** cache its result.
+     */
+    async addThreadMember(channelID, userID) {
+        await this._manager.authRequest({
+            method: "PUT",
+            path: Routes.CHANNEL_THREAD_MEMBER(channelID, userID)
+        });
+    }
+    /**
+     * Create a direct message. This will not create a new channel if you have already started a dm with the user.
+     * @param recipient The ID of the recipient of the direct message.
+     * @caching This method **does** cache its result.
+     * @caches {@link Client#privateChannels | Client#privateChannels}
+     */
+    async createDM(recipient) {
+        let cache;
+        if ((cache = this._manager.client.privateChannels.find(ch => ch.recipient.id === recipient))) {
+            return cache;
+        }
+        return this._manager.authRequest({
+            method: "POST",
+            path: Routes.OAUTH_CHANNELS,
+            json: { recipient_id: recipient }
+        }).then(data => this._manager.client.privateChannels.update(data));
+    }
+    /**
+     * Create a group dm.
+     * @param options The options for creating the group dm.
+     * @caching This method **does** cache its result.
+     * @caches {@link Client#groupChannels | Client#groupChannels}
+     */
+    async createGroupDM(options) {
+        return this._manager.authRequest({
+            method: "POST",
+            path: Routes.OAUTH_CHANNELS,
+            json: {
+                access_tokens: options.accessTokens,
+                nicks: options.nicks
+            }
+        }).then(data => this._manager.client.groupChannels.update(data));
+    }
+    /**
+     * Create an invite for a channel. If the guild is not a `COMMUNITY` server, invites can only be made to last 30 days.
+     * @param channelID The ID of the channel to create an invite for.
+     * @param options The options for creating the invite.
+     * @caching This method **does not** cache its result.
+     */
+    async createInvite(channelID, options) {
+        const reason = options.reason;
+        if (options.reason) {
+            delete options.reason;
+        }
+        return this._manager.authRequest({
+            method: "POST",
+            path: Routes.CHANNEL_INVITES(channelID),
+            json: {
+                max_age: options.maxAge,
+                max_uses: options.maxUses,
+                target_application_id: options.targetApplicationID,
+                target_type: options.targetType,
+                target_user_id: options.targetUserID,
+                temporary: options.temporary,
+                unique: options.unique
+            },
+            reason
+        }).then(data => new Invite_1.default(data, this._manager.client));
+    }
+    /**
+     * Create a message in a channel.
+     * @param channelID The ID of the channel to create the message in.
+     * @param options The options for creating the message.
+     * @caching This method **may** cache its result. The result will not be cached if the channel is not cached.
+     * @caches {@link TextableChannel#messages | TextableChannel#messages}<br>{@link ThreadChannel#messages | ThreadChannel#messages}<br>{@link PrivateChannel#messages | PrivateChannel#messages}
+     */
+    async createMessage(channelID, options) {
+        const files = options.files;
+        if (options.files) {
+            delete options.files;
+        }
+        return this._manager.authRequest({
+            method: "POST",
+            path: Routes.CHANNEL_MESSAGES(channelID),
+            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,
+                enforce_nonce: options.enforceNonce,
+                flags: options.flags,
+                sticker_ids: options.stickerIDs,
+                message_reference: options.messageReference ? {
+                    channel_id: options.messageReference.channelID,
+                    fail_if_not_exists: options.messageReference.failIfNotExists,
+                    guild_id: options.messageReference.guildID,
+                    message_id: options.messageReference.messageID
+                } : undefined,
+                nonce: options.nonce,
+                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,
+                tts: options.tts
+            },
+            files
+        }).then(data => this._manager.client.util.updateMessage(data));
+    }
+    /**
+     * Add a reaction to a message.
+     * @param channelID The ID of the channel the message is in.
+     * @param messageID The ID of the message to add a reaction to.
+     * @param emoji The reaction to add to the message. `name:id` for custom emojis, and the unicode codepoint for default emojis.
+     * @caching This method **does not** cache its result.
+     */
+    async createReaction(channelID, messageID, emoji) {
+        if (emoji === decodeURIComponent(emoji)) {
+            emoji = encodeURIComponent(emoji);
+        }
+        await this._manager.authRequest({
+            method: "PUT",
+            path: Routes.CHANNEL_REACTION_USER(channelID, messageID, emoji, "@me")
+        });
+    }
+    /**
+     * Create a stage instance.
+     * @param channelID The ID of the channel to create the stage instance on.
+     * @param options The options for creating the stage instance.
+     * @caching This method **does not** cache its result.
+     */
+    async createStageInstance(channelID, options) {
+        const reason = options.reason;
+        if (options.reason) {
+            delete options.reason;
+        }
+        return this._manager.authRequest({
+            method: "POST",
+            path: Routes.STAGE_INSTANCES,
+            json: {
+                channel_id: channelID,
+                topic: options.topic,
+                privacy_level: options.privacyLevel,
+                send_start_notification: options.sendStartNotification
+            },
+            reason
+        }).then(data => new StageInstance_1.default(data, this._manager.client));
+    }
+    /**
+     * Crosspost a message in an announcement channel.
+     * @param channelID The ID of the channel to crosspost the message in.
+     * @param messageID The ID of the message to crosspost.
+     * @caching This method **may** cache its result. The result will not be cached if the channel is not cached.
+     * @caches {@link TextableChannel#messages | TextableChannel#messages}<br>{@link ThreadChannel#messages | ThreadChannel#messages}<br>{@link PrivateChannel#messages | PrivateChannel#messages}
+     */
+    async crosspostMessage(channelID, messageID) {
+        return this._manager.authRequest({
+            method: "POST",
+            path: Routes.CHANNEL_MESSAGES_CROSSPOST(channelID, messageID)
+        }).then(data => this._manager.client.util.updateMessage(data));
+    }
+    /**
+     * Delete or close a channel.
+     * @param channelID The ID of the channel to delete or close.
+     * @param reason The reason to be displayed in the audit log.
+     * @caching This method **does not** cache its result.
+     */
+    async delete(channelID, reason) {
+        await this._manager.authRequest({
+            method: "DELETE",
+            path: Routes.CHANNEL(channelID),
+            reason
+        });
+    }
+    /**
+     * Delete an invite.
+     * @param code The code of the invite to delete.
+     * @param reason The reason for deleting the invite.
+     * @caching This method **does not** cache its result.
+     */
+    async deleteInvite(code, reason) {
+        return this._manager.authRequest({
+            method: "DELETE",
+            path: Routes.INVITE(code),
+            reason
+        }).then(data => new Invite_1.default(data, this._manager.client));
+    }
+    /**
+     * Delete a message.
+     * @param channelID The ID of the channel to delete the message in.
+     * @param messageID The ID of the message to delete.
+     * @param reason The reason for deleting the message.
+     * @caching This method **does not** cache its result.
+     */
+    async deleteMessage(channelID, messageID, reason) {
+        await this._manager.authRequest({
+            method: "DELETE",
+            path: Routes.CHANNEL_MESSAGE(channelID, messageID),
+            reason
+        });
+    }
+    /**
+     * Bulk delete messages.
+     * @param channelID The ID of the channel to delete the messages in.
+     * @param messageIDs The IDs of the messages to delete. Any duplicates or messages older than two weeks will cause an error.
+     * @param reason The reason for deleting the messages.
+     * @caching This method **does not** cache its result.
+     */
+    async deleteMessages(channelID, messageIDs, reason) {
+        const chunks = [];
+        messageIDs = Array.from(messageIDs);
+        const amountOfMessages = messageIDs.length;
+        while (messageIDs.length !== 0) {
+            chunks.push(messageIDs.splice(0, 100));
+        }
+        let done = 0;
+        for (const chunk of chunks.values()) {
+            if (chunks.length > 1) {
+                const left = amountOfMessages - done;
+                this._manager.client.emit("debug", `Deleting ${left} messages in ${channelID}`);
+            }
+            if (chunk.length === 1) {
+                this._manager.client.emit("debug", "deleteMessages created a chunk with only 1 element, using deleteMessage instead.");
+                await this.deleteMessage(channelID, chunk[0], reason);
+                continue;
+            }
+            await this._manager.authRequest({
+                method: "POST",
+                path: Routes.CHANNEL_BULK_DELETE_MESSAGES(channelID),
+                json: { messages: chunk },
+                reason
+            });
+            done += chunk.length;
+        }
+        return amountOfMessages;
+    }
+    /**
+     * Delete a permission overwrite.
+     * @param channelID The ID of the channel to delete the permission overwrite in.
+     * @param overwriteID The ID of the permission overwrite to delete.
+     * @param reason The reason for deleting the permission overwrite.
+     * @caching This method **does not** cache its result.
+     */
+    async deletePermission(channelID, overwriteID, reason) {
+        await this._manager.authRequest({
+            method: "DELETE",
+            path: Routes.CHANNEL_PERMISSION(channelID, overwriteID),
+            reason
+        });
+    }
+    /**
+     * Remove a reaction from a message.
+     * @param channelID The ID of the channel the message is in.
+     * @param messageID The ID of the message to remove a reaction from.
+     * @param emoji The reaction to remove from the message. `name:id` for custom emojis, and the unicode codepoint for default emojis.
+     * @param user The user to remove the reaction from, `@me` for the current user (default).
+     * @caching This method **does not** cache its result.
+     */
+    async deleteReaction(channelID, messageID, emoji, user = "@me") {
+        if (emoji === decodeURIComponent(emoji)) {
+            emoji = encodeURIComponent(emoji);
+        }
+        await this._manager.authRequest({
+            method: "DELETE",
+            path: Routes.CHANNEL_REACTION_USER(channelID, messageID, emoji, user)
+        });
+    }
+    /**
+     * Remove all, or a specific emoji's reactions from a message.
+     * @param channelID The ID of the channel the message is in.
+     * @param messageID The ID of the message to remove reactions from.
+     * @param emoji The reaction to remove from the message. `name:id` for custom emojis, and the unicode codepoint for default emojis. Omit to remove all reactions.
+     * @caching This method **does not** cache its result.
+     */
+    async deleteReactions(channelID, messageID, emoji) {
+        if (emoji && emoji === decodeURIComponent(emoji)) {
+            emoji = encodeURIComponent(emoji);
+        }
+        await this._manager.authRequest({
+            method: "DELETE",
+            path: emoji ? Routes.CHANNEL_REACTION(channelID, messageID, emoji) : Routes.CHANNEL_REACTIONS(channelID, messageID)
+        });
+    }
+    /**
+     * Delete a stage instance.
+     * @param channelID The ID of the channel to delete the stage instance on.
+     * @param reason The reason for deleting the stage instance.
+     * @caching This method **does not** cache its result.
+     */
+    async deleteStageInstance(channelID, reason) {
+        await this._manager.authRequest({
+            method: "DELETE",
+            path: Routes.STAGE_INSTANCE(channelID),
+            reason
+        });
+    }
+    /**
+     * Edit a channel.
+     * @param channelID The ID of the channel to edit.
+     * @param options The options for editing the channel.
+     * @caching This method **may** cache its result. If a guild channel, the result will not be cached if the guild is not cached.
+     * @caches {@link Guild#channels | Guild#channels}<br>{@link Guild#threads | Guild#threads}<br>{@link Client#groupChannels | Client#groupChannels}
+     */
+    async edit(channelID, options) {
+        const reason = options.reason;
+        if (options.reason) {
+            delete options.reason;
+        }
+        if (options.icon) {
+            try {
+                options.icon = this._manager.client.util.convertImage(options.icon);
+            }
+            catch (err) {
+                throw new TypeError("Invalid icon provided. Ensure you are providing a valid, fully-qualified base64 url.", { cause: err });
+            }
+        }
+        return this._manager.authRequest({
+            method: "PATCH",
+            path: Routes.CHANNEL(channelID),
+            json: {
+                applied_tags: options.appliedTags,
+                archived: options.archived,
+                auto_archive_duration: options.autoArchiveDuration,
+                available_tags: options.availableTags?.map(tag => ({
+                    emoji_id: tag.emoji?.id,
+                    emoji_name: tag.emoji?.name,
+                    moderated: tag.moderated,
+                    name: tag.name,
+                    id: tag.id
+                })),
+                bitrate: options.bitrate,
+                default_auto_archive_duration: options.defaultAutoArchiveDuration,
+                default_forum_layout: options.defaultForumLayout,
+                default_reaction_emoji: options.defaultReactionEmoji ? { emoji_id: options.defaultReactionEmoji.id, emoji_name: options.defaultReactionEmoji.name } : options.defaultReactionEmoji,
+                default_sort_order: options.defaultSortOrder,
+                default_thread_rate_limit_per_user: options.defaultThreadRateLimitPerUser,
+                flags: options.flags,
+                icon: options.icon,
+                invitable: options.invitable,
+                locked: options.locked,
+                name: options.name,
+                nsfw: options.nsfw,
+                parent_id: options.parentID,
+                permission_overwrites: options.permissionOverwrites,
+                position: options.position,
+                rate_limit_per_user: options.rateLimitPerUser,
+                rtc_region: options.rtcRegion,
+                topic: options.topic,
+                type: options.type,
+                user_limit: options.userLimit,
+                video_quality_mode: options.videoQualityMode
+            },
+            reason
+        }).then(data => this._manager.client.util.updateChannel(data));
+    }
+    /**
+     * Edit a message.
+     * @param channelID The ID of the channel the message is in.
+     * @param messageID The ID of the message to edit.
+     * @param options The options for editing the message.
+     * @caching This method **may** cache its result. The result will not be cached if the channel is not cached.
+     * @caches {@link TextableChannel#messages | TextableChannel#messages}<br>{@link ThreadChannel#messages | ThreadChannel#messages}<br>{@link PrivateChannel#messages | PrivateChannel#messages}
+     */
+    async editMessage(channelID, messageID, options) {
+        const files = options.files ?? undefined;
+        if (options.files) {
+            delete options.files;
+        }
+        return this._manager.authRequest({
+            method: "PATCH",
+            path: Routes.CHANNEL_MESSAGE(channelID, 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
+            },
+            files
+        }).then(data => this._manager.client.util.updateMessage(data));
+    }
+    /**
+     * Edit a permission overwrite.
+     * @param channelID The ID of the channel to edit the permission overwrite for.
+     * @param overwriteID The ID of the permission overwrite to edit.
+     * @param options The options for editing the permission overwrite.
+     * @caching This method **does not** cache its result.
+     */
+    async editPermission(channelID, overwriteID, options) {
+        const reason = options.reason;
+        if (options.reason) {
+            delete options.reason;
+        }
+        await this._manager.authRequest({
+            method: "PUT",
+            path: Routes.CHANNEL_PERMISSION(channelID, overwriteID),
+            json: {
+                allow: options.allow,
+                deny: options.deny,
+                type: options.type
+            },
+            reason
+        });
+    }
+    /**
+     * Edit a stage instance.
+     * @param channelID The ID of the channel to edit the stage instance on.
+     * @param options The options for editing the stage instance.
+     * @caching This method **does not** cache its result.
+     */
+    async editStageInstance(channelID, options) {
+        const reason = options.reason;
+        if (options.reason) {
+            delete options.reason;
+        }
+        return this._manager.authRequest({
+            method: "PATCH",
+            path: Routes.STAGE_INSTANCE(channelID),
+            json: {
+                channel_id: channelID,
+                topic: options.topic,
+                privacy_level: options.privacyLevel
+            },
+            reason
+        }).then(data => new StageInstance_1.default(data, this._manager.client));
+    }
+    /**
+     * End a poll now.
+     * @param channelID The ID of the channel the poll is in.
+     * @param messageID The ID of the message the poll is on.
+     * @caching This method **does not** cache its result.
+     */
+    async expirePoll(channelID, messageID) {
+        await this._manager.authRequest({
+            method: "POST",
+            path: Routes.POLL_EXPIRE(channelID, messageID)
+        });
+    }
+    /**
+     * Follow an announcement channel.
+     * @param channelID The ID of the channel to follow announcements from.
+     * @param webhookChannelID The ID of the channel crossposted messages should be sent to. The client must have the `MANAGE_WEBHOOKS` permission in this channel.
+     * @caching This method **does not** cache its result.
+     */
+    async followAnnouncement(channelID, webhookChannelID) {
+        return this._manager.authRequest({
+            method: "POST",
+            path: Routes.CHANNEL_FOLLOWERS(channelID),
+            json: { webhook_channel_id: webhookChannelID }
+        }).then(data => ({
+            channelID: data.channel_id,
+            webhookID: data.webhook_id
+        }));
+    }
+    /**
+     * Get a channel.
+     * @param channelID The ID of the channel to get.
+     * @caching This method **may** cache its result. The result will not be cached if the guild is not cached.
+     * @caches {@link Guild#channels | Guild#channels}<br>{@link Guild#threads | Guild#threads}<br>{@link Client#privateChannels | Client#privateChannels}<br>{@link Client#groupChannels | Client#groupChannels}
+     */
+    async get(channelID) {
+        return this._manager.authRequest({
+            method: "GET",
+            path: Routes.CHANNEL(channelID)
+        }).then(data => this._manager.client.util.updateChannel(data));
+    }
+    async getInvite(code, options) {
+        const query = new URLSearchParams();
+        if (options?.guildScheduledEventID !== undefined) {
+            query.set("guild_scheduled_event_id", options.guildScheduledEventID);
+        }
+        if (options?.withCounts !== undefined) {
+            query.set("with_counts", options.withCounts.toString());
+        }
+        if (options?.withExpiration !== undefined) {
+            query.set("with_expiration", options.withExpiration.toString());
+        }
+        return this._manager.authRequest({
+            method: "GET",
+            path: Routes.INVITE(code),
+            query
+        }).then(data => new Invite_1.default(data, this._manager.client));
+    }
+    /**
+     * Get the invites of a channel.
+     * @param channelID The ID of the channel to get the invites of.
+     * @caching This method **does not** cache its result.
+     */
+    async getInvites(channelID) {
+        return this._manager.authRequest({
+            method: "GET",
+            path: Routes.CHANNEL_INVITES(channelID)
+        }).then(data => data.map(invite => new Invite_1.default(invite, this._manager.client)));
+    }
+    /**
+     * Get the private archived threads the current user has joined in a channel.
+     * @param channelID The ID of the channel to get the archived threads from.
+     * @param options The options for getting the archived threads.
+     * @caching This method **does not** cache its result.
+     */
+    async getJoinedPrivateArchivedThreads(channelID, options) {
+        return this._manager.authRequest({
+            method: "GET",
+            path: Routes.CHANNEL_PRIVATE_ARCHIVED_THREADS(channelID),
+            json: {
+                before: options?.before,
+                limit: options?.limit
+            }
+        }).then(data => ({
+            hasMore: data.has_more,
+            members: data.members.map(m => ({
+                flags: m.flags,
+                id: m.id,
+                joinTimestamp: new Date(m.join_timestamp),
+                userID: m.user_id
+            })),
+            threads: data.threads.map(d => this._manager.client.util.updateThread(d))
+        }));
+    }
+    /**
+     * Get a message in a channel.
+     * @param channelID The ID of the channel the message is in
+     * @param messageID The ID of the message to get.
+     * @caching This method **may** cache its result. The result will not be cached if the channel is not cached.
+     * @caches {@link TextableChannel#messages | TextableChannel#messages}<br>{@link ThreadChannel#messages | ThreadChannel#messages}<br>{@link PrivateChannel#messages | PrivateChannel#messages}
+     */
+    async getMessage(channelID, messageID) {
+        return this._manager.authRequest({
+            method: "GET",
+            path: Routes.CHANNEL_MESSAGE(channelID, messageID)
+        }).then(data => this._manager.client.util.updateMessage(data));
+    }
+    /**
+     * Get messages in a channel.
+     * @param channelID The ID of the channel to get messages from.
+     * @param options The options for getting messages. `before`, `after`, and `around `All are mutually exclusive.
+     * @caching This method **may** cache its result. The result will not be cached if the channel is not cached.
+     * @caches {@link TextableChannel#messages | TextableChannel#messages}<br>{@link ThreadChannel#messages | ThreadChannel#messages}<br>{@link PrivateChannel#messages | PrivateChannel#messages}
+     */
+    async getMessages(channelID, options) {
+        const query = new URLSearchParams();
+        let chosenOption;
+        if (options?.around !== undefined) {
+            query.set("around", options.around);
+            chosenOption = "around";
+            // eslint-disable-next-line unicorn/no-negated-condition
+        }
+        else if (options?.after !== undefined) {
+            query.set("after", options.after);
+            chosenOption = "after";
+        }
+        else {
+            if (options?.before !== undefined) {
+                query.set("before", options.before);
+            }
+            chosenOption = "before";
+        }
+        if (chosenOption === "around" || (options?.limit && options.limit <= 100)) {
+            const filter = options?.filter?.bind(this) ?? (() => true);
+            if (options?.limit !== undefined) {
+                query.set("limit", Math.min(options.limit, 100).toString());
+            }
+            const messages = await this._manager.authRequest({
+                method: "GET",
+                path: Routes.CHANNEL_MESSAGES(channelID),
+                query
+            }).then(data => data.map(d => this._manager.client.util.updateMessage(d)));
+            for (const message of Array.from(messages)) {
+                const f = filter(message);
+                if (f === false) {
+                    messages.splice(messages.indexOf(message), 1);
+                }
+                if (f === "break") {
+                    messages.splice(messages.indexOf(message));
+                    break;
+                }
+            }
+            return messages;
+        }
+        const results = [];
+        const it = this.getMessagesIterator(channelID, options);
+        for await (const messages of it) {
+            const limit = messages.length < 100 ? messages.length : it.limit + 100;
+            this._manager.client.emit("debug", `Getting ${limit} more message${limit === 1 ? "" : "s"} for ${channelID}: ${it.lastMessage ?? ""}`);
+            results.push(...messages);
+        }
+        return results;
+    }
+    /**
+     * Get an async iterator for getting messages in a channel.
+     * @param channelID The ID of the channel to get messages from.
+     * @param options The options for getting messages. `before`, `after`, and `around `All are mutually exclusive.
+     * @caching This method **may** cache its result. The result will not be cached if the channel is not cached.
+     * @caches {@link TextableChannel#messages | TextableChannel#messages}<br>{@link ThreadChannel#messages | ThreadChannel#messages}<br>{@link PrivateChannel#messages | PrivateChannel#messages}
+     */
+    getMessagesIterator(channelID, options) {
+        const filter = options?.filter?.bind(this) ?? (() => true);
+        const chosenOption = options?.after === undefined ? "before" : "after";
+        // arrow functions cannot be generator functions
+        // eslint-disable-next-line unicorn/no-this-assignment
+        const self = this;
+        const it = {
+            lastMessage: chosenOption === "after" ? options?.after : options?.before,
+            limit: options?.limit ?? 100,
+            async *[Symbol.asyncIterator]() {
+                loop: while (it.limit > 0) {
+                    const messages = await self.getMessages(channelID, {
+                        limit: it.limit >= 100 ? 100 : it.limit,
+                        [chosenOption]: it.lastMessage
+                    });
+                    const originalCount = messages.length;
+                    it.limit -= messages.length;
+                    for (const message of Array.from(messages)) {
+                        const f = filter(message);
+                        if (f === false) {
+                            messages.splice(messages.indexOf(message), 1);
+                        }
+                        if (f === "break") {
+                            messages.splice(messages.indexOf(message));
+                            yield messages;
+                            break loop;
+                        }
+                    }
+                    it.lastMessage = messages.at(-1)?.id;
+                    yield messages;
+                    if (originalCount < 100 || it.limit <= 0) {
+                        break loop;
+                    }
+                }
+            }
+        };
+        return it;
+    }
+    /**
+     * Get the pinned messages in a channel.
+     * @param channelID The ID of the channel to get the pinned messages from.
+     * @caching This method **may** cache its result. The result will not be cached if the channel is not cached.
+     * @caches {@link TextableChannel#messages | TextableChannel#messages}<br>{@link ThreadChannel#messages | ThreadChannel#messages}<br>{@link PrivateChannel#messages | PrivateChannel#messages}
+     */
+    async getPinnedMessages(channelID) {
+        return this._manager.authRequest({
+            method: "GET",
+            path: Routes.CHANNEL_PINS(channelID)
+        }).then(data => data.map(d => this._manager.client.util.updateMessage(d)));
+    }
+    /**
+     * Get the users that voted on a poll answer.
+     * @param channelID The ID of the channel the poll is in.
+     * @param messageID The ID of the message the poll is on.
+     * @param answerID The ID of the poll answer to get voters for.
+     * @param options The options for getting the voters.
+     * @caching This method **does** cache its result.
+     * @caches {@link Client#users | Client#users}
+     */
+    async getPollAnswerUsers(channelID, messageID, answerID, options) {
+        const qs = new URLSearchParams();
+        if (options?.after !== undefined) {
+            qs.set("before", options.after);
+        }
+        if (options?.limit !== undefined) {
+            qs.set("limit", options.limit.toString());
+        }
+        return this._manager.authRequest({
+            method: "GET",
+            path: Routes.POLL_ANSWER_USERS(channelID, messageID, answerID),
+            query: qs
+        }).then(data => {
+            const users = data.users.map(user => this._manager.client.users.update(user));
+            const message = this._manager.client.getChannel(channelID)?.messages.get(messageID);
+            if (message?.poll) {
+                this._manager.client.util.replacePollAnswer(message.poll, answerID, users.length, users.map(u => u.id));
+            }
+            return users;
+        });
+    }
+    /**
+     * Get the private archived threads in a channel.
+     * @param channelID The ID of the channel to get the archived threads from.
+     * @param options The options for getting the archived threads.
+     * @caching This method **may** cache its result. The result will not be cached if the guild is not cached.
+     * @caches {@link Guild#threads | Guild#threads}
+     */
+    async getPrivateArchivedThreads(channelID, options) {
+        const qs = new URLSearchParams();
+        if (options?.before !== undefined) {
+            qs.set("before", options.before);
+        }
+        if (options?.limit !== undefined) {
+            qs.set("limit", options.limit.toString());
+        }
+        return this._manager.authRequest({
+            method: "GET",
+            path: Routes.CHANNEL_PRIVATE_ARCHIVED_THREADS(channelID),
+            query: qs
+        }).then(data => ({
+            hasMore: data.has_more,
+            members: data.members.map(m => ({
+                flags: m.flags,
+                id: m.id,
+                joinTimestamp: new Date(m.join_timestamp),
+                userID: m.user_id
+            })),
+            threads: data.threads.map(d => this._manager.client.util.updateThread(d))
+        }));
+    }
+    /**
+     * Get the private joined archived threads in a channel.
+     * @param channelID The ID of the channel to get the archived threads from.
+     * @param options The options for getting the archived threads.
+     * @caching This method **may** cache its result. The result will not be cached if the guild is not cached.
+     * @caches {@link Guild#threads | Guild#threads}
+     */
+    async getPrivateJoinedArchivedThreads(channelID, options) {
+        const qs = new URLSearchParams();
+        if (options?.before !== undefined) {
+            qs.set("before", options.before);
+        }
+        if (options?.limit !== undefined) {
+            qs.set("limit", options.limit.toString());
+        }
+        return this._manager.authRequest({
+            method: "GET",
+            path: Routes.CHANNEL_JOINED_PRIVATE_ARCHIVED_THREADS(channelID),
+            query: qs
+        }).then(data => ({
+            hasMore: data.has_more,
+            members: data.members.map(m => ({
+                flags: m.flags,
+                id: m.id,
+                joinTimestamp: new Date(m.join_timestamp),
+                userID: m.user_id
+            })),
+            threads: data.threads.map(d => this._manager.client.util.updateThread(d))
+        }));
+    }
+    /**
+     * Get the public archived threads in a channel.
+     * @param channelID The ID of the channel to get the archived threads from.
+     * @param options The options for getting the archived threads.
+     * @caching This method **may** cache its result. The result will not be cached if the guild is not cached.
+     * @caches {@link Guild#threads | Guild#threads}
+     */
+    async getPublicArchivedThreads(channelID, options) {
+        const qs = new URLSearchParams();
+        if (options?.before !== undefined) {
+            qs.set("before", options.before);
+        }
+        if (options?.limit !== undefined) {
+            qs.set("limit", options.limit.toString());
+        }
+        return this._manager.authRequest({
+            method: "GET",
+            path: Routes.CHANNEL_PUBLIC_ARCHIVED_THREADS(channelID),
+            query: qs
+        }).then(data => ({
+            hasMore: data.has_more,
+            members: data.members.map(m => ({
+                flags: m.flags,
+                id: m.id,
+                joinTimestamp: new Date(m.join_timestamp),
+                userID: m.user_id
+            })),
+            threads: data.threads.map(d => this._manager.client.util.updateThread(d))
+        }));
+    }
+    /**
+     * Get the users who reacted with a specific emoji on a message.
+     * @param channelID The ID of the channel the message is in.
+     * @param messageID The ID of the message to get reactions from.
+     * @param emoji The reaction to remove from the message. `name:id` for custom emojis, and the unicode codepoint for default emojis.
+     * @param options The options for getting the reactions.
+     * @caching This method **does not** cache its result.
+     */
+    async getReactions(channelID, messageID, emoji, options) {
+        if (emoji === decodeURIComponent(emoji)) {
+            emoji = encodeURIComponent(emoji);
+        }
+        const _getReactions = async (_options) => {
+            const query = new URLSearchParams();
+            if (_options?.after !== undefined) {
+                query.set("after", _options.after);
+            }
+            if (_options?.limit !== undefined) {
+                query.set("limit", _options.limit.toString());
+            }
+            if (options?.type !== undefined) {
+                query.set("type", String(options.type));
+            }
+            return this._manager.authRequest({
+                method: "GET",
+                path: Routes.CHANNEL_REACTION(channelID, messageID, emoji),
+                query
+            }).then(data => data.map(d => this._manager.client.users.update(d)));
+        };
+        const limit = options?.limit ?? 100;
+        let after = options?.after;
+        let reactions = [];
+        while (reactions.length < limit) {
+            const limitLeft = limit - reactions.length;
+            const limitToFetch = limitLeft <= 100 ? limitLeft : 100;
+            this._manager.client.emit("debug", `Getting ${limitLeft} more ${emoji} reactions for message ${messageID} on ${channelID}: ${after ?? ""}`);
+            const reactionsChunk = await _getReactions({
+                after,
+                limit: limitToFetch
+            });
+            if (reactionsChunk.length === 0) {
+                break;
+            }
+            reactions = reactions.concat(reactionsChunk);
+            after = reactionsChunk.at(-1).id;
+            if (reactionsChunk.length < 100) {
+                break;
+            }
+        }
+        return reactions;
+    }
+    /**
+     * Get the stage instance associated with a channel.
+     * @param channelID The ID of the channel to get the stage instance on.
+     * @caching This method **does not** cache its result.
+     */
+    async getStageInstance(channelID) {
+        return this._manager.authRequest({
+            method: "GET",
+            path: Routes.STAGE_INSTANCE(channelID)
+        }).then(data => new StageInstance_1.default(data, this._manager.client));
+    }
+    /**
+     * Get a thread member.
+     * @param channelID The ID of the thread.
+     * @param userID The ID of the user to get the thread member of.
+     * @caching This method **does not** cache its result.
+     */
+    async getThreadMember(channelID, userID) {
+        return this._manager.authRequest({
+            method: "GET",
+            path: Routes.CHANNEL_THREAD_MEMBER(channelID, userID)
+        }).then(data => ({
+            flags: data.flags,
+            id: data.id,
+            joinTimestamp: new Date(data.join_timestamp),
+            userID: data.user_id
+        }));
+    }
+    /**
+     * Get the members of a thread.
+     * @param channelID The ID of the thread.
+     * @param options The options for getting the thread members.
+     * @caching This method **does not** cache its result.
+     */
+    async getThreadMembers(channelID, options) {
+        const query = new URLSearchParams();
+        if (options?.after !== undefined) {
+            query.set("after", options.after);
+        }
+        if (options?.limit !== undefined) {
+            query.set("limit", options.limit.toString());
+        }
+        if (options?.withMember !== undefined) {
+            query.set("with_member", options.withMember.toString());
+        }
+        return this._manager.authRequest({
+            method: "GET",
+            path: Routes.CHANNEL_THREAD_MEMBERS(channelID),
+            query
+        }).then(data => data.map(d => {
+            // eslint-disable-next-line @typescript-eslint/dot-notation
+            const guild = this._manager.client.getChannel(channelID)?.["_cachedGuild"];
+            const member = guild && options?.withMember ? guild.members.update(d.member, guild.id) : undefined;
+            return {
+                flags: d.flags,
+                id: d.id,
+                joinTimestamp: new Date(d.join_timestamp),
+                member,
+                userID: d.user_id
+            };
+        }));
+    }
+    /** @deprecated Get the list of usable voice regions. Moved to `misc`. */
+    async getVoiceRegions() {
+        return this._manager.authRequest({
+            method: "GET",
+            path: Routes.VOICE_REGIONS
+        });
+    }
+    /**
+     * Join a thread.
+     * @param channelID The ID of the thread to join.
+     * @caching This method **does not** cache its result.
+     */
+    async joinThread(channelID) {
+        await this._manager.authRequest({
+            method: "PUT",
+            path: Routes.CHANNEL_THREAD_MEMBER(channelID, "@me")
+        });
+    }
+    /**
+     * Leave a thread.
+     * @param channelID The ID of the thread to leave.
+     * @caching This method **does not** cache its result.
+     */
+    async leaveThread(channelID) {
+        await this._manager.authRequest({
+            method: "DELETE",
+            path: Routes.CHANNEL_THREAD_MEMBER(channelID, "@me")
+        });
+    }
+    /**
+     * Pin a message in a channel.
+     * @param channelID The ID of the channel to pin the message in.
+     * @param messageID The ID of the message to pin.
+     * @param reason The reason for pinning the message.
+     * @caching This method **does not** cache its result.
+     */
+    async pinMessage(channelID, messageID, reason) {
+        await this._manager.authRequest({
+            method: "PUT",
+            path: Routes.CHANNEL_PINNED_MESSAGE(channelID, messageID),
+            reason
+        });
+    }
+    /**
+     * Purge an amount of messages from a channel.
+     * @param channelID The ID of the channel to purge.
+     * @param options The options to purge. `before`, `after`, and `around `All are mutually exclusive.
+     * @caching This method **does not** cache its result.
+     */
+    async purgeMessages(channelID, options) {
+        const filter = (message) => {
+            if (message.timestamp.getTime() < Date.now() - 1209600000) {
+                return "break";
+            }
+            return options?.filter?.(message) ?? true;
+        };
+        let chosenOption;
+        if (options.after) {
+            chosenOption = "after";
+        }
+        else if (options.around) {
+            chosenOption = "around";
+        }
+        else {
+            chosenOption = "before";
+        }
+        if (chosenOption === "around" || options.limit <= 100) {
+            const messages = await this.getMessages(channelID, {
+                limit: options.limit,
+                [chosenOption]: options[chosenOption]
+            });
+            for (const message of messages) {
+                const f = filter(message);
+                if (f === false) {
+                    messages.splice(messages.indexOf(message), 1);
+                }
+                if (f === "break") {
+                    messages.splice(messages.indexOf(message));
+                    break;
+                }
+            }
+            return this.deleteMessages(channelID, messages.map(message => message.id), options.reason);
+        }
+        const it = this.getMessagesIterator(channelID, {
+            after: options.after,
+            before: options.before,
+            limit: options.limit,
+            filter
+        });
+        let deleted = 0;
+        for await (const messages of it) {
+            deleted += await this.deleteMessages(channelID, messages.map(message => message.id), options.reason);
+        }
+        return deleted;
+    }
+    /**
+     * Remove a user from the group channel.
+     * @param groupID The ID of the group to remove the user from.
+     * @param userID The ID of the user to remove.
+     * @caching This method **does not** cache its result.
+     */
+    async removeGroupRecipient(groupID, userID) {
+        await this._manager.authRequest({
+            method: "DELETE",
+            path: Routes.GROUP_RECIPIENT(groupID, userID)
+        });
+    }
+    /**
+     * Remove a member from a thread.
+     * @param channelID The ID of the thread to remove them from.
+     * @param userID The ID of the user to remove from the thread.
+     * @caching This method **does not** cache its result.
+     */
+    async removeThreadMember(channelID, userID) {
+        await this._manager.authRequest({
+            method: "DELETE",
+            path: Routes.CHANNEL_THREAD_MEMBER(channelID, userID)
+        });
+    }
+    /**
+     * Show a typing indicator in a channel. How long users see this varies from client to client.
+     * @param channelID The ID of the channel to show the typing indicator in.
+     * @caching This method **does not** cache its result.
+     */
+    async sendTyping(channelID) {
+        await this._manager.authRequest({
+            method: "POST",
+            path: Routes.CHANNEL_TYPING(channelID)
+        });
+    }
+    /**
+     * Set a voice status in a channel.
+     * @param channelID The ID of the channel to set the voice status in.
+     * @param status The voice status to set.
+     */
+    async setVoiceStatus(channelID, status) {
+        await this._manager.authRequest({
+            method: "PUT",
+            path: Routes.VOICE_STATUS(channelID),
+            json: { status }
+        });
+    }
+    /**
+     * Create a thread from an existing message.
+     * @param channelID The ID of the channel to create the thread in.
+     * @param messageID The ID of the message to create the thread from.
+     * @param options The options for starting the thread.
+     * @caching This method **may** cache its result. The result will not be cached if the guild is not cached.
+     * @caches {@link Guild#threads | Guild#threads}
+     */
+    async startThreadFromMessage(channelID, messageID, options) {
+        const reason = options.reason;
+        if (options.reason) {
+            delete options.reason;
+        }
+        return this._manager.authRequest({
+            method: "POST",
+            path: Routes.CHANNEL_MESSAGE_THREADS(channelID, messageID),
+            json: {
+                auto_archive_duration: options.autoArchiveDuration,
+                name: options.name,
+                rate_limit_per_user: options.rateLimitPerUser
+            },
+            reason
+        }).then(data => this._manager.client.util.updateThread(data));
+    }
+    /**
+     * Create a thread in a thread only channel (forum & media).
+     * @param channelID The ID of the channel to start the thread in.
+     * @param options The options for starting the thread.
+     * @caching This method **may** cache its result. The result will not be cached if the guild is not cached.
+     * @caches {@link Guild#threads | Guild#threads}
+     */
+    async startThreadInThreadOnlyChannel(channelID, options) {
+        const reason = options.reason;
+        if (options.reason) {
+            delete options.reason;
+        }
+        const files = options.message.files;
+        if (options.message.files) {
+            delete options.message.files;
+        }
+        return this._manager.authRequest({
+            method: "POST",
+            path: Routes.CHANNEL_THREADS(channelID),
+            json: {
+                auto_archive_duration: options.autoArchiveDuration,
+                message: {
+                    allowed_mentions: this._manager.client.util.formatAllowedMentions(options.message.allowedMentions),
+                    attachments: options.message.attachments,
+                    components: options.message.components ? this._manager.client.util.componentsToRaw(options.message.components) : undefined,
+                    content: options.message.content,
+                    embeds: options.message.embeds ? this._manager.client.util.embedsToRaw(options.message.embeds) : undefined,
+                    flags: options.message.flags,
+                    sticker_ids: options.message.stickerIDs
+                },
+                name: options.name,
+                rate_limit_per_user: options.rateLimitPerUser,
+                applied_tags: options.appliedTags
+            },
+            reason,
+            files
+        }).then(data => this._manager.client.util.updateThread(data));
+    }
+    /**
+     * Create a thread without an existing message.
+     * @param channelID The ID of the channel to start the thread in.
+     * @param options The options for starting the thread.
+     * @caching This method **may** cache its result. The result will not be cached if the guild is not cached.
+     * @caches {@link Guild#threads | Guild#threads}
+     */
+    async startThreadWithoutMessage(channelID, options) {
+        const reason = options.reason;
+        if (options.reason) {
+            delete options.reason;
+        }
+        return this._manager.authRequest({
+            method: "POST",
+            path: Routes.CHANNEL_THREADS(channelID),
+            json: {
+                auto_archive_duration: options.autoArchiveDuration,
+                invitable: options.invitable,
+                name: options.name,
+                rate_limit_per_user: options.rateLimitPerUser,
+                type: options.type
+            },
+            reason
+        }).then(data => this._manager.client.util.updateThread(data));
+    }
+    /**
+     * Unpin a message in a channel.
+     * @param channelID The ID of the channel to unpin the message in.
+     * @param messageID The ID of the message to unpin.
+     * @param reason The reason for unpinning the message.
+     * @caching This method **does not** cache its result.
+     */
+    async unpinMessage(channelID, messageID, reason) {
+        await this._manager.authRequest({
+            method: "DELETE",
+            path: Routes.CHANNEL_PINNED_MESSAGE(channelID, messageID),
+            reason
+        });
+    }
+}
+exports.default = Channels;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"Channels.js","sourceRoot":"","sources":["../../../lib/routes/Channels.ts"],"names":[],"mappings":"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"}