snowtransfer 0.18.0 → 0.18.1

package/dist/methods/Channel.js

@@ -0,0 +1,982 @@
+"use strict";
+const Endpoints = require("../Endpoints");
+const Constants = require("../Constants");
+const v10_1 = require("discord-api-types/v10");
+/**
+ * Methods for interacting with Channels and Messages
+ * @since 0.1.0
+ */
+class ChannelMethods {
+    requestHandler;
+    options;
+    /**
+     * Create a new Channel Method handler
+     *
+     * Usually SnowTransfer creates a method handler for you, this is here for completion
+     *
+     * You can access the methods listed via `client.channel.method`, where `client` is an initialized SnowTransfer instance
+     * @param requestHandler request handler that calls the rest api
+     * @param options Options for the SnowTransfer instance
+     */
+    constructor(requestHandler, options) {
+        this.requestHandler = requestHandler;
+        this.options = options;
+    }
+    /**
+     * Get a channel via Id
+     * @since 0.1.0
+     * @param channelId Id of the channel
+     * @returns [discord channel](https://discord.com/developers/docs/resources/channel#channel-object) object
+     *
+     * @example
+     * const client = new SnowTransfer("TOKEN")
+     * const channel = await client.channel.getChannel("channel id")
+     */
+    async getChannel(channelId) {
+        return this.requestHandler.request(Endpoints.CHANNEL(channelId), {}, "get", "json");
+    }
+    async editChannel(channelId, data, reason) {
+        return this.requestHandler.request(Endpoints.CHANNEL(channelId), {}, "patch", "json", data, Constants.reasonHeader(reason));
+    }
+    /**
+     * Delete a channel or thread via Id
+     *
+     * This either **deletes** a Guild Channel/thread or **closes** a Direct Message Channel
+     *
+     * **Be careful with deleting Guild Channels as this cannot be undone!**
+     *
+     * When deleting a category, this does **not** delete the child channels of a category. They will just have their `parent_id` removed.
+     *
+     * For community guilds, the rules channel and the community updates channel cannot be deleted.
+     * @since 0.1.0
+     * @param channelId Id of the channel
+     * @param reason Reason for deleting the channel
+     * @returns [discord channel](https://discord.com/developers/docs/resources/channel#channel-object) object
+     *
+     * | Permissions needed | Condition                      |
+     * |--------------------|--------------------------------|
+     * | MANAGE_CHANNELS    | if channel is not a DM channel |
+     * | MANAGE_THREADS     | if channel is a thread         |
+     *
+     * @example
+     * // Deletes a channel via id because it wasn't needed anymore
+     * const client = new SnowTransfer("TOKEN")
+     * client.channel.deleteChannel("channel id", "No longer needed")
+     */
+    async deleteChannel(channelId, reason) {
+        return this.requestHandler.request(Endpoints.CHANNEL(channelId), {}, "delete", "json", {}, Constants.reasonHeader(reason));
+    }
+    /**
+     * Get a list of messages from a channel
+     * @since 0.1.0
+     * @param channelId Id of the channel
+     * @param options Options for getting channel messages
+     * @returns Array of [discord message](https://discord.com/developers/docs/resources/channel#message-object) objects
+     *
+     * | Permissions needed   | Condition                                                                        |
+     * |----------------------|----------------------------------------------------------------------------------|
+     * | VIEW_CHANNEL         | if channel is not a DM channel                                                   |
+     * | READ_MESSAGE_HISTORY | if channel is not a DM channel, unless you want the API to return an empty Array |
+     *
+     * @example
+     * // Fetch the last 20 messages from a channel
+     * const client = new SnowTransfer("TOKEN")
+     * const options = {
+     * 	limit: 20
+     * }
+     * const messages = await client.channel.getChannelMessages("channel id", options)
+     */
+    async getChannelMessages(channelId, options) {
+        const query = { limit: 50, ...options };
+        if (query.around) {
+            delete query.before;
+            delete query.after;
+        }
+        else if (query.before) {
+            delete query.around;
+            delete query.after;
+        }
+        else if (query.after) {
+            delete query.before;
+            delete query.around;
+        }
+        if (query.limit < Constants.GET_CHANNEL_MESSAGES_MIN_RESULTS ||
+            query.limit > Constants.GET_CHANNEL_MESSAGES_MAX_RESULTS)
+            throw new RangeError(`Amount of messages that may be requested has to be between ${Constants.GET_CHANNEL_MESSAGES_MIN_RESULTS} and ${Constants.GET_CHANNEL_MESSAGES_MAX_RESULTS}`);
+        return this.requestHandler.request(Endpoints.CHANNEL_MESSAGES(channelId), query, "get", "json");
+    }
+    /**
+     * Get a single message via Id
+     * @since 0.1.0
+     * @param channelId Id of the channel
+     * @param messageId Id of the message
+     * @returns [discord message](https://discord.com/developers/docs/resources/channel#message-object) object
+     *
+     * | Permissions needed   | Condition                      |
+     * |----------------------|--------------------------------|
+     * | VIEW_CHANNEL         | if channel is not a DM channel |
+     * | READ_MESSAGE_HISTORY | if channel is not a DM channel |
+     *
+     * @example
+     * // Get a single message from a channel via id
+     * const client = new SnowTransfer("TOKEN")
+     * const message = await client.channel.getChannelMessage("channel id", "message id")
+     */
+    async getChannelMessage(channelId, messageId) {
+        return this.requestHandler.request(Endpoints.CHANNEL_MESSAGE(channelId, messageId), {}, "get", "json");
+    }
+    /**
+     * Creates a new Message within a channel or thread
+     *
+     * **Make sure to use a filename with a proper extension (e.g. png, jpeg, etc.) when you want to upload files**
+     * @since 0.1.0
+     * @param channelId Id of the Channel or thread to send a message to
+     * @param data Data to send, if data is a string it will be used as the content of the message,
+     * if data is not a string you should take a look at the properties below to know what you may send
+     * @param options Options for sending this message
+     * @returns [discord message](https://discord.com/developers/docs/resources/channel#message-object) object
+     *
+     * | Permissions needed       | Condition                                                     |
+     * |--------------------------|---------------------------------------------------------------|
+     * | VIEW_CHANNEL             | if channel is not a DM channel                                |
+     * | READ_MESSAGE_HISTORY     | if channel is not a DM channel and message is a reply         |
+     * | SEND_MESSAGES            | if channel is not a DM channel and if channel is not a thread |
+     * | SEND_TTS_MESSAGES        | if channel is not a DM channel and tts is set to true         |
+     * | SEND_MESSAGES_IN_THREADS | if channel is a thread                                        |
+     *
+     * @example
+     * // Make a bot say "hi" within a channel
+     * // createMessage sends the passed data as content, when you give it a string
+     * const client = new SnowTransfer("TOKEN")
+     * client.channel.createMessage("channel id", "hi")
+     *
+     * @example
+     * // Send a rich embed object
+     * const client = new SnowTransfer("TOKEN")
+     * const embedData = {
+     * 	title: "This is a nice embed",
+     * 	description: "But winter is so cold",
+     * 	fields: [
+     * 		{ name: "Brr", value: "Insert snowflake emoji here" }
+     * 	]
+     * }
+     * client.channel.createMessage("channel id", { embeds: [embedData] })
+     *
+     * @example
+     * // Send a file with a comment
+     * const client = new SnowTransfer("TOKEN")
+     * // fileData will be a buffer with the data of the png image.
+     * const fileData = fs.readFileSync("nice_picture.png") // You should probably use fs.promises.readFile, since it is asynchronous, synchronous methods block the thread.
+     * client.channel.createMessage("channel id", { content: "This is a nice picture", files: [{ name: "Optional_Filename.png", file: fileData }] })
+     */
+    async createMessage(channelId, data) {
+        if (typeof data !== "string" &&
+            !data.content &&
+            (!data.message_reference || (data.message_reference?.type !== v10_1.MessageReferenceType.Forward)) &&
+            !data.embeds?.length &&
+            !data.sticker_ids?.length &&
+            !data.components?.length &&
+            !data.files?.length &&
+            !data.poll)
+            throw new Error("Missing content, message_reference type 1, embeds, sticker_ids, components, files, or poll");
+        if (typeof data === "string")
+            data = { content: data };
+        const payload = Constants.cloneUserInput(data);
+        if ((payload.content || payload.embeds) &&
+            payload.flags &&
+            (payload.flags & v10_1.MessageFlags.IsComponentsV2) === v10_1.MessageFlags.IsComponentsV2)
+            throw new Error("The message flags was set to include IsComponentsV2, but content and/or embeds were also present. You can either have content/embeds or components v2, not both.");
+        // Sanitize the message
+        payload.allowed_mentions ??= this.options.allowed_mentions;
+        if (payload.files)
+            return this.requestHandler.request(Endpoints.CHANNEL_MESSAGES(channelId), {}, "post", "multipart", await Constants.standardMultipartHandler(payload));
+        else
+            return this.requestHandler.request(Endpoints.CHANNEL_MESSAGES(channelId), {}, "post", "json", payload);
+    }
+    /**
+     * Creates a new voice Message within a channel or thread
+     * @since 0.10.0
+     * @param channelId Id of the Channel or thread to send a message to
+     * @param data Buffer of the audio file to send. Tested file types are ogg, mp3, m4a, wav, flac. Other file types work, but some can only be embedded on mobile. Try it and see:tm:
+     * @param audioDurationSeconds The duration of the audio file in seconds
+     * @param waveform A preview of the entire voice message, with 1 byte per datapoint encoded in base64.
+     * Official clients sample the recording at most once per 100 milliseconds, but will downsample so that no more than 256 datapoints are in the waveform.
+     * If you have no clue what you're doing or don't want to mess with audio processing, leave this as an empty string (default).
+     * Refer to Constants.generateWaveform for guidance on computing it yourself.
+     * @returns non editable [discord message](https://discord.com/developers/docs/resources/channel#message-object) object
+     *
+     * | Permissions needed       | Condition                                                     |
+     * |--------------------------|---------------------------------------------------------------|
+     * | VIEW_CHANNEL             | if channel is not a DM channel                                |
+     * | READ_MESSAGE_HISTORY     | if channel is not a DM channel and message is a reply         |
+     * | SEND_MESSAGES            | if channel is not a DM channel and if channel is not a thread |
+     * | SEND_MESSAGES_IN_THREADS | if channel is a thread                                        |
+     *
+     * @example
+     * // Send a voice message that has a duration of 6 seconds
+     * const client = new SnowTransfer("TOKEN")
+     * // fileData will be a buffer with the data of the ogg audio
+     * const fileData = fs.readFileSync("6-second-long-audio.ogg") // You should probably use fs.promises.readFile, since it is asynchronous, synchronous methods block the thread.
+     * client.channel.createVoiceMessage("channel id", fileData, 6)
+     */
+    // Code for this function was provided by flazepe on Discord. Thank you <3 https://github.com/flazepe
+    async createVoiceMessage(channelId, data, audioDurationSeconds, waveform = "") {
+        // create attachment
+        const { upload_url, upload_filename } = await this.requestHandler.request(Endpoints.CHANNEL_ATTACHMENTS(channelId), {}, "post", "json", {
+            files: [{
+                    id: "69420",
+                    filename: "voice-message.ogg",
+                    file_size: data.byteLength
+                }]
+        }).then(d => d.attachments[0]);
+        // @ts-expect-error A Buffer is compatible as BodyInit. Trust. upload file to cdn
+        const uploaded = await this.requestHandler.options.fetch(upload_url, { method: "PUT", body: data });
+        if (!uploaded.ok)
+            throw new Error(`Uploading the voice message audio failed with status ${uploaded.status}: ${await uploaded.text().catch(() => "")}`);
+        // Actually send the voice message
+        return this.requestHandler.request(Endpoints.CHANNEL_MESSAGES(channelId), {}, "post", "json", {
+            attachments: [{
+                    id: "42069",
+                    uploaded_filename: upload_filename,
+                    filename: "voice-message.ogg",
+                    duration_secs: audioDurationSeconds,
+                    waveform
+                }],
+            flags: v10_1.MessageFlags.IsVoiceMessage
+        });
+    }
+    /**
+     * Crosspost a message in a news channel to all following channels
+     * @since 0.3.0
+     * @param channelId Id of the news channel
+     * @param messageId Id of the message
+     * @returns [discord message](https://discord.com/developers/docs/resources/channel#message-object) object
+     *
+     * | Permissions needed | Condition                                      |
+     * |--------------------|------------------------------------------------|
+     * | VIEW_CHANNEL       | always                                         |
+     * | SEND_MESSAGES      | if the message was sent by the current user    |
+     * | MANAGE_MESSAGES    | if the message wasn't sent by the current user |
+     *
+     * @example
+     * // Crosspost a message
+     * const client = new SnowTransfer("TOKEN")
+     * client.channel.crosspostMessage("channel id", "message id")
+     */
+    async crosspostMessage(channelId, messageId) {
+        return this.requestHandler.request(Endpoints.CHANNEL_MESSAGE_CROSSPOST(channelId, messageId), {}, "post", "json");
+    }
+    /**
+     * Adds a reaction to a message
+     * @since 0.1.0
+     * @param channelId Id of the channel
+     * @param messageId Id of the message
+     * @param emoji uri encoded reaction emoji to add
+     * you may either use a discord emoji in the format `:emoji_name:emoji_id` or a unicode emoji,
+     * which can be found [here](http://www.unicode.org/emoji/charts/full-emoji-list.html)
+     * @returns Resolves the Promise on successful execution
+     *
+     * | Permissions needed   | Condition                                                                          |
+     * |----------------------|------------------------------------------------------------------------------------|
+     * | VIEW_CHANNEL         | if channel is not a DM channel                                                     |
+     * | READ_MESSAGE_HISTORY | if channel is not a DM channel                                                     |
+     * | ADD_REACTIONS        | When no other user has reacted with the emoji used and channel is not a DM channel |
+     *
+     * @example
+     * // This example uses a discord emoji
+     * const client = new SnowTransfer("TOKEN")
+     * client.channel.createReaction("channel Id", "message Id", encodeURIComponent("awooo:322522663304036352"))
+     *
+     * @example
+     * // using a utf-8 emoji
+     * const client = new SnowTransfer("TOKEN")
+     * client.channel.createReaction("channel Id", "message Id", encodeURIComponent("😀"))
+     */
+    async createReaction(channelId, messageId, emoji) {
+        return this.requestHandler.request(Endpoints.CHANNEL_MESSAGE_REACTION_USER(channelId, messageId, emoji, "@me"), {}, "put", "json");
+    }
+    /**
+     * Delete a reaction added by the current user from a message
+     * @since 0.1.0
+     * @param channelId Id of the channel
+     * @param messageId Id of the message
+     * @param emoji reaction emoji
+     * @returns Resolves the Promise on successful execution
+     *
+     * | Permission           | Condition                      |
+     * |----------------------|--------------------------------|
+     * | VIEW_CHANNEL         | if channel is not a DM channel |
+     * | READ_MESSAGE_HISTORY | if channel is not a DM channel |
+     *
+     * @example
+     * // This example uses a discord emoji
+     * const client = new SnowTransfer("TOKEN")
+     * client.channel.deleteReactionSelf("channel Id", "message Id", encodeURIComponent("awooo:322522663304036352"))
+     *
+     * @example
+     * // using a utf-8 emoji
+     * const client = new SnowTransfer("TOKEN")
+     * client.channel.deleteReactionSelf("channel Id", "message Id", encodeURIComponent("😀"))
+     */
+    async deleteReactionSelf(channelId, messageId, emoji) {
+        return this.requestHandler.request(Endpoints.CHANNEL_MESSAGE_REACTION_USER(channelId, messageId, emoji, "@me"), {}, "delete", "json");
+    }
+    /**
+     * Delete a reaction from a message in a guild channel
+     * @since 0.1.0
+     * @param channelId Id of the guild channel
+     * @param messageId Id of the message
+     * @param emoji reaction emoji
+     * @param userId Id of the user
+     * @returns Resolves the Promise on successful execution
+     *
+     * | Permission           | Condition |
+     * |----------------------|-----------|
+     * | MANAGE_MESSAGES      | always    |
+     * | VIEW_CHANNEL         | always    |
+     * | READ_MESSAGE_HISTORY | always    |
+     *
+     * @example
+     * // This example uses a discord emoji
+     * const client = new SnowTransfer("TOKEN")
+     * client.channel.deleteReaction("channel Id", "message Id", encodeURIComponent("awooo:322522663304036352"), "user Id")
+     *
+     * @example
+     * // using a utf-8 emoji
+     * const client = new SnowTransfer("TOKEN")
+     * // If a user Id is not supplied, the emoji from that message will be removed for all users
+     * client.channel.deleteReaction("channel Id", "message Id", encodeURIComponent("😀"))
+     */
+    async deleteReaction(channelId, messageId, emoji, userId) {
+        return this.requestHandler.request(userId ? Endpoints.CHANNEL_MESSAGE_REACTION_USER(channelId, messageId, emoji, userId) : Endpoints.CHANNEL_MESSAGE_REACTION(channelId, messageId, emoji), {}, "delete", "json");
+    }
+    /**
+     * Get a list of users that reacted with a certain emoji on a certain message
+     * @since 0.1.0
+     * @param channelId Id of the channel
+     * @param messageId Id of the message
+     * @param emoji reaction emoji
+     * @param options Options for getting users
+     * @returns Array of [user objects](https://discord.com/developers/docs/resources/user#user-object)
+     *
+     * | Permissions needed   | Condition                      |
+     * |----------------------|--------------------------------|
+     * | VIEW_CHANNEL         | if channel is not a DM channel |
+     * | READ_MESSAGE_HISTORY | if channel is not a DM channel |
+     *
+     * @example
+     * // This example uses a discord emoji
+     * const client = new SnowTransfer("TOKEN")
+     * const reactions = await client.channel.getReactions("channel Id", "message Id", encodeURIComponent("awooo:322522663304036352"))
+     */
+    async getReactions(channelId, messageId, emoji, options) {
+        return this.requestHandler.request(Endpoints.CHANNEL_MESSAGE_REACTION(channelId, messageId, emoji), options, "get", "json");
+    }
+    /**
+     * Delete all reactions from a message in a guild channel
+     * @since 0.1.0
+     * @param channelId Id of the guild channel
+     * @param messageId Id of the message
+     * @returns Resolves the Promise on successful execution
+     *
+     * | Permissions needed   | Condition |
+     * |----------------------|-----------|
+     * | VIEW_CHANNEL         | always    |
+     * | READ_MESSAGE_HISTORY | always    |
+     * | MANAGE_MESSAGES      | always    |
+     *
+     * @example
+     * const client = new SnowTransfer("TOKEN")
+     * client.channel.deleteAllReactions("channel Id", "message Id")
+     */
+    async deleteAllReactions(channelId, messageId) {
+        return this.requestHandler.request(Endpoints.CHANNEL_MESSAGE_REACTIONS(channelId, messageId), {}, "delete", "json");
+    }
+    /**
+     * Edit a message sent by the current user or edit the message flags of another user's message
+     * @since 0.1.0
+     * @param channelId Id of the channel
+     * @param messageId Id of the message
+     * @param data Data to send
+     * @param options Options for editing this message
+     * @returns [discord message](https://discord.com/developers/docs/resources/channel#message-object) object
+     *
+     * | Permissions needed | Condition                                        |
+     * |--------------------|--------------------------------------------------|
+     * | VIEW_CHANNEL       | if channel is not a DM channel                   |
+     * | MANAGE_MESSAGES    | When editing someone else's message to set flags |
+     *
+     * @example
+     * // Simple ping response
+     * const client = new SnowTransfer("TOKEN")
+     * const time = Date.now()
+     * const message = await client.channel.createMessage("channel id", "pong")
+     * client.channel.editMessage("channel id", message.id, `pong ${Date.now() - time}ms`)
+     */
+    async editMessage(channelId, messageId, data) {
+        if (typeof data === "string")
+            data = { content: data };
+        const payload = Constants.cloneUserInput(data);
+        if ((payload.content || payload.embeds) &&
+            payload.flags &&
+            (payload.flags & v10_1.MessageFlags.IsComponentsV2) === v10_1.MessageFlags.IsComponentsV2)
+            throw new Error("The message flags was set to include IsComponentsV2, but content and/or embeds were also present. You can either have content/embeds or components v2, not both.");
+        // Sanitize the message
+        payload.allowed_mentions ??= this.options.allowed_mentions;
+        if (payload.files)
+            return this.requestHandler.request(Endpoints.CHANNEL_MESSAGE(channelId, messageId), {}, "patch", "multipart", await Constants.standardMultipartHandler(payload));
+        else
+            return this.requestHandler.request(Endpoints.CHANNEL_MESSAGE(channelId, messageId), {}, "patch", "json", payload);
+    }
+    /**
+     * Delete a message
+     * @since 0.1.0
+     * @param channelId Id of the channel
+     * @param messageId Id of the message
+     * @param reason Reason for deleting the message
+     * @returns Resolves the Promise on successful execution
+     *
+     * | Permissions needed | Condition                                    |
+     * |--------------------|----------------------------------------------|
+     * | VIEW_CHANNEL       | if channel is not a DM channel               |
+     * | MANAGE_MESSAGES    | When the bot isn't the author of the message |
+     *
+     * @example
+     * // Delete a message
+     * const client = new SnowTransfer("TOKEN")
+     * client.channel.deleteMessage("channel id", "message id")
+     */
+    async deleteMessage(channelId, messageId, reason) {
+        return this.requestHandler.request(Endpoints.CHANNEL_MESSAGE(channelId, messageId), {}, "delete", "json", {}, Constants.reasonHeader(reason));
+    }
+    /**
+     * Bulk delete messages from a guild channel, messages may not be older than 2 weeks
+     * @since 0.18.0
+     * @param channelId Id of the guild channel
+     * @param messages array of message ids to delete
+     * @param reason Reason for deleting the messages
+     * @returns Resolves the Promise on successful execution
+     *
+     * | Permissions needed | Condition |
+     * |--------------------|-----------|
+     * | VIEW_CHANNEL       | always    |
+     * | MANAGE_MESSAGES    | always    |
+     *
+     * @example
+     * // Bulk deletes 2 messages with a reason of "spam"
+     * const client = new SnowTransfer("TOKEN")
+     * client.channel.deleteMessages("channel id", ["message id 1", "message id 2"], "spam")
+     */
+    async deleteMessages(channelId, messages, reason) {
+        if (messages.length < Constants.BULK_DELETE_MESSAGES_MIN || messages.length > Constants.BULK_DELETE_MESSAGES_MAX)
+            throw new RangeError(`Amount of messages to be deleted has to be between ${Constants.BULK_DELETE_MESSAGES_MIN} and ${Constants.BULK_DELETE_MESSAGES_MAX}`);
+        // (Current date - (discord epoch + 2 weeks)) * (2**22) weird constant that everybody seems to use
+        const oldestSnowflake = BigInt(Date.now() - 1421280000000) * (BigInt(2) ** BigInt(22));
+        const forbiddenMessage = messages.find(m => BigInt(m) < oldestSnowflake);
+        if (forbiddenMessage)
+            throw new Error(`The message ${forbiddenMessage} is older than 2 weeks and may not be deleted using the bulk delete endpoint`);
+        const data = { messages };
+        return this.requestHandler.request(Endpoints.CHANNEL_BULK_DELETE(channelId), {}, "post", "json", data, Constants.reasonHeader(reason));
+    }
+    /**
+     * Modify the permission overwrites of a guild channel
+     * @since 0.1.0
+     * @param channelId Id of the guild channel
+     * @param permissionId Id of the permission overwrite
+     * @param data modified [permission overwrite](https://discord.com/developers/docs/resources/channel#edit-channel-permissions-json-params) object
+     * @param reason Reason for editing the channel permission
+     * @returns Resolves the Promise on successful execution
+     *
+     * | Permissions needed | Condition                  |
+     * |--------------------|----------------------------|
+     * | MANAGE_CHANNELS    | if channel is not a thread |
+     * | MANAGE_THREADS     | if channel is a thread     |
+     * | MANAGE_ROLES       | always                     |
+     * | VIEW_CHANNEL       | always                     |
+     *
+     * @example
+     * // Edits the permissions of a user to allow viewing the channel only
+     * const client = new SnowTransfer("TOKEN")
+     * client.channel.editChannelPermission("channel id", "user id", { allow: String(1 << 10), type: 1 })
+     */
+    async editChannelPermission(channelId, permissionId, data, reason) {
+        return this.requestHandler.request(Endpoints.CHANNEL_PERMISSION(channelId, permissionId), {}, "put", "json", data, Constants.reasonHeader(reason));
+    }
+    /**
+     * Get a list of invites for a guild channel
+     * @since 0.1.0
+     * @param channelId Id of the guild channel
+     * @returns Array of [invite objects](https://discord.com/developers/docs/resources/invite#invite-object) (with metadata)
+     *
+     * | Permissions needed | Condition |
+     * |--------------------|-----------|
+     * | VIEW_CHANNEL       | always    |
+     * | MANAGE_CHANNELS    | always    |
+     *
+     * @example
+     * const client = new SnowTransfer("TOKEN")
+     * const invites = await client.channel.getChannelInvites("channel id")
+     */
+    async getChannelInvites(channelId) {
+        return this.requestHandler.request(Endpoints.CHANNEL_INVITES(channelId), {}, "get", "json");
+    }
+    /**
+     * Create an invite for a guild channel
+     *
+     * If no data argument is passed, the invite will be created with the defaults
+     * @since 0.1.0
+     * @param channelId Id of the channel
+     * @param data invite data (optional)
+     * @param reason Reason for creating the invite
+     * @returns [Invite object](https://discord.com/developers/docs/resources/invite#invite-object) (with metadata)
+     *
+     * | Permissions needed    | Condition                                                                |
+     * |-----------------------|--------------------------------------------------------------------------|
+     * | VIEW_CHANNEL          | always                                                                   |
+     * | CREATE_INSTANT_INVITE | always                                                                   |
+     * | MANAGE_ROLES          | If specifying role_ids. You cannot specify a role higher than the sender |
+     *
+     * @example
+     * // Creates a unique permanent invite with infinite uses
+     * const client = new SnowTransfer("TOKEN")
+     * const invite = await client.channel.createChannelInvite("channel id", { max_age: 0, max_uses: 0, unique: true })
+     */
+    async createChannelInvite(channelId, data, reason) {
+        const payload = { max_age: 86400, max_uses: 0, temporary: false, unique: false, ...data };
+        const targetUsers = payload?.target_users;
+        if (targetUsers?.length) {
+            delete payload.target_users;
+            const form = new FormData();
+            await Constants.standardAddToFormHandler(form, "target_users_file", `Users\n${targetUsers.join(",\n")},`, "target_users_file.csv");
+            form.append("payload_json", JSON.stringify(payload));
+            return this.requestHandler.request(Endpoints.CHANNEL_INVITES(channelId), {}, "post", "multipart", form, Constants.reasonHeader(reason));
+        }
+        return this.requestHandler.request(Endpoints.CHANNEL_INVITES(channelId), {}, "post", "json", payload, Constants.reasonHeader(reason));
+    }
+    /**
+     * Delete a permission overwrite from a guild channel
+     * @since 0.1.0
+     * @param channelId Id of the guild channel
+     * @param permissionId Id of the permission overwrite
+     * @param reason Reason for deleting the permission
+     * @returns Resolves the Promise on successful execution
+     *
+     * | Permissions needed | Condition                  |
+     * |--------------------|----------------------------|
+     * | MANAGE_CHANNELS    | if channel is not a thread |
+     * | MANAGE_THREADS     | if channel is a thread     |
+     * | MANAGE_ROLES       | always                     |
+     * | VIEW_CHANNEL       | always                     |
+     *
+     * @example
+     * // Deletes the permission overwrite of a user
+     * const client = new SnowTransfer("TOKEN")
+     * client.channel.deleteChannelPermission("channel id", "user id", "Abusing channel")
+     */
+    async deleteChannelPermission(channelId, permissionId, reason) {
+        return this.requestHandler.request(Endpoints.CHANNEL_PERMISSION(channelId, permissionId), {}, "delete", "json", {}, Constants.reasonHeader(reason));
+    }
+    /**
+     * Follow an announcement channel to another channel
+     * @since 0.7.0
+     * @param channelId The Id of the announcement channel
+     * @param webhookChannelId The Id of the channel messages will be sent to
+     * @param reason Reason for following the annoucement channel
+     * @returns A [followed channel](https://discord.com/developers/docs/resources/channel#followed-channel-object) object
+     *
+     * | Permissions needed | Condition |
+     * |--------------------|-----------|
+     * | MANAGE_WEBHOOKS    | always    |
+     *
+     * @example
+     * // Follows an announcement channel to a text channel
+     * const client = new SnowTransfer("TOKEN")
+     * client.channel.followAnnouncementChannel("news channel id", "text channel id")
+     */
+    async followAnnouncementChannel(channelId, webhookChannelId, reason) {
+        return this.requestHandler.request(Endpoints.CHANNEL_FOLLOWERS(channelId), {}, "post", "json", { webhook_channel_id: webhookChannelId }, Constants.reasonHeader(reason));
+    }
+    /**
+     * Send an indicator that the current user is typing within a channel.
+     *
+     * **You should generally avoid this method unless used for longer computations (>1s)**
+     * @since 0.1.0
+     * @param channelId Id of the channel
+     * @returns Resolves the Promise on successful execution
+     *
+     * | Permissions needed       | Condition                      |
+     * |--------------------------|--------------------------------|
+     * | VIEW_CHANNEL             | if channel is not a DM channel |
+     * | SEND_MESSAGES            | if channel is not a thread     |
+     * | SEND_MESSAGES_IN_THREADS | if channel is a thread         |
+     *
+     * @example
+     * const client = new SnowTransfer("TOKEN")
+     * client.channel.startChannelTyping("channel id")
+     */
+    async startChannelTyping(channelId) {
+        return this.requestHandler.request(Endpoints.CHANNEL_TYPING(channelId), {}, "post", "json");
+    }
+    /**
+     * Get a list of pinned messages for a channel
+     * @since 0.1.0
+     * @param channelId Id of the channel
+     * @returns Array of [message objects](https://discord.com/developers/docs/resources/channel#message-object)
+     *
+     * | Permissions needed   | Condition                      |
+     * |----------------------|--------------------------------|
+     * | VIEW_CHANNEL         | if channel is not a DM channel |
+     * | READ_MESSAGE_HISTORY | if channel is not a DM channel |
+     *
+     * @example
+     * const client = new SnowTransfer("TOKEN")
+     * const messages = await client.channel.getChannelPinnedMessages("channel id")
+     */
+    async getChannelPinnedMessages(channelId, options) {
+        return this.requestHandler.request(Endpoints.CHANNEL_PINS(channelId), options, "get", "json");
+    }
+    /**
+     * Pin a message within a channel
+     * @since 0.18.0
+     * @param channelId Id of the channel
+     * @param messageId Id of the message
+     * @param reason Reason for pinning the message
+     * @returns Resolves the Promise on successful execution
+     *
+     * | Permissions needed   | Condition                      |
+     * |----------------------|--------------------------------|
+     * | VIEW_CHANNEL         | if channel is not a DM channel |
+     * | READ_MESSAGE_HISTORY | if channel is not a DM channel |
+     * | PIN_MESSAGES         | if channel is not a DM channel |
+     *
+     * @example
+     * // Pin a message because it was a good meme
+     * const client = new SnowTransfer("TOKEN")
+     * client.channel.createChannelPinnedMessage("channel id", "message id", "Good meme")
+     */
+    async createChannelPinnedMessage(channelId, messageId, reason) {
+        return this.requestHandler.request(Endpoints.CHANNEL_PIN(channelId, messageId), {}, "put", "json", {}, Constants.reasonHeader(reason));
+    }
+    /**
+     * Remove a pinned message from a channel
+     * @since 0.18.0
+     * @param channelId Id of the channel
+     * @param messageId Id of the message
+     * @param reason Reason for removing the pinned message
+     * @returns Resolves the Promise on successful execution
+     *
+     * | Permissions needed   | Condition                      |
+     * |----------------------|--------------------------------|
+     * | VIEW_CHANNEL         | if channel is not a DM channel |
+     * | READ_MESSAGE_HISTORY | if channel is not a DM channel |
+     * | PIN_MESSAGES         | if channel is not a DM channel |
+     *
+     * @example
+     * // Remove a pinned message because mod abuse :(
+     * const client = new SnowTransfer("TOKEN")
+     * client.channel.deleteChannelPinnedMessage("channel id", "message id", "Mod abuse")
+     */
+    async deleteChannelPinnedMessage(channelId, messageId, reason) {
+        return this.requestHandler.request(Endpoints.CHANNEL_PIN(channelId, messageId), {}, "delete", "json", {}, Constants.reasonHeader(reason));
+    }
+    /**
+     * Creates a public thread off a message in a guild channel
+     * @since 0.3.0
+     * @param channelId Id of the guild channel
+     * @param messageId Id of the message
+     * @param data Thread meta data
+     * @param reason Reason for creating the thread
+     * @returns [thread channel](https://discord.com/developers/docs/resources/channel#channel-object) object
+     *
+     * | Permissions needed    | Condition |
+     * |-----------------------|-----------|
+     * | VIEW_CHANNEL          | always    |
+     * | CREATE_PUBLIC_THREADS | always    |
+     *
+     * @example
+     * // Create a thread off a cool art piece to discuss
+     * const client = new SnowTransfer("TOKEN")
+     * const thread = await client.channel.createThreadWithMessage("channel id", "message id", { name: "cool-art", }, "I wanna talk about it!")
+     */
+    async createThreadWithMessage(channelId, messageId, data, reason) {
+        return this.requestHandler.request(Endpoints.CHANNEL_MESSAGE_THREADS(channelId, messageId), {}, "post", "json", data, Constants.reasonHeader(reason));
+    }
+    async createThreadWithoutMessage(channelId, data, reason) {
+        return this.requestHandler.request(Endpoints.CHANNEL_THREADS(channelId), {}, "post", "json", data, Constants.reasonHeader(reason));
+    }
+    /**
+     * Join a thread
+     * @since 0.3.0
+     * @param threadId Id of the thread
+     * @returns Resolves the Promise on successful execution
+     *
+     * | Permissions needed | Condition |
+     * |--------------------|-----------|
+     * | VIEW_CHANNEL       | always    |
+     *
+     * @example
+     * const client = new SnowTransfer("TOKEN")
+     * client.channel.joinThread("thread id")
+     */
+    async joinThread(threadId) {
+        return this.requestHandler.request(Endpoints.CHANNEL_THREAD_MEMBER(threadId, "@me"), {}, "put", "json");
+    }
+    /**
+     * Add a user to a thread
+     *
+     * CurrentUser must be a member of the thread
+     * @since 0.18.0
+     * @param threadId Id of the thread
+     * @param userId Id of the user to add
+     * @returns Resolves the Promise on successful execution
+     *
+     * | Permissions needed          | Condition |
+     * |-----------------------------|-----------|
+     * | CurrentUser added to Thread | always    |
+     * | SEND_MESSAGES_IN_THREADS    | always    |
+     *
+     * @example
+     * const client = new SnowTransfer("TOKEN")
+     * client.channel.joinThreadMember("thread id", "user id")
+     */
+    async joinThreadMember(threadId, userId) {
+        return this.requestHandler.request(Endpoints.CHANNEL_THREAD_MEMBER(threadId, userId), {}, "put", "json");
+    }
+    /**
+     * Leave a thread
+     * @since 0.3.0
+     * @param threadId Id of the thread
+     * @returns Resolves the Promise on successful execution
+     *
+     * @example
+     * const client = new SnowTransfer("TOKEN")
+     * client.channel.leaveThread("thread id")
+     */
+    async leaveThread(threadId) {
+        return this.requestHandler.request(Endpoints.CHANNEL_THREAD_MEMBER(threadId, "@me"), {}, "delete", "json");
+    }
+    /**
+     * Remove a user from a thread
+     * @since 0.18.0
+     * @param threadId Id of the thread
+     * @param userId Id of the user to remove
+     * @returns Resolves the Promise on successful execution
+     *
+     * | Permissions needed | Condition                                            |
+     * |--------------------|------------------------------------------------------|
+     * | MANAGE_THREADS     | if the current user is not the creator of the thread |
+     *
+     * @example
+     * const client = new SnowTransfer("TOKEN")
+     * client.channel.deleteThreadMember("thread id", "user id")
+     */
+    async deleteThreadMember(threadId, userId) {
+        return this.requestHandler.request(Endpoints.CHANNEL_THREAD_MEMBER(threadId, userId), {}, "delete", "json");
+    }
+    /**
+     * Gets a member of a thread
+     * @since 0.3.0
+     * @param threadId Id of the thread
+     * @param userId Id of the user
+     * @param withMember If a member object should be present
+     * @returns A [thread member](https://discord.com/developers/docs/resources/channel#thread-member-object)
+     *
+     * | Permissions needed | Condition |
+     * |--------------------|-----------|
+     * | VIEW_CHANNEL       | always    |
+     *
+     * @example
+     * const client = new SnowTransfer("TOKEN")
+     * const member = await client.channel.getThreadMember("thread id", "user id")
+     */
+    async getThreadMember(threadId, userId, withMember) {
+        return this.requestHandler.request(Endpoints.CHANNEL_THREAD_MEMBER(threadId, userId), { with_member: withMember }, "get", "json");
+    }
+    /**
+     * Gets all members within a thread
+     * @since 0.3.0
+     * @param channelId Id of the Thread
+     * @param options Options for getting members
+     * @returns Array of [thread members](https://discord.com/developers/docs/resources/channel#thread-member-object)
+     *
+     * | Permissions needed | Condition |
+     * |--------------------|-----------|
+     * | VIEW_CHANNEL       | always    |
+     *
+     * | Intents       |
+     * |---------------|
+     * | GUILD_MEMBERS |
+     *
+     * @example
+     * const client = new SnowTransfer("TOKEN")
+     * const members = await client.channel.getThreadMembers("thread id")
+     */
+    async getThreadMembers(channelId, options) {
+        return this.requestHandler.request(Endpoints.CHANNEL_THREAD_MEMBERS(channelId), options, "get", "json");
+    }
+    /**
+     * Gets all threads that are public and archived within a guild channel
+     * @since 0.3.0
+     * @param channelId Id of the guild channel
+     * @param options Options for getting threads
+     * @returns Object containing [public threads](https://discord.com/developers/docs/resources/channel#channel-object), [thread members](https://discord.com/developers/docs/resources/channel#thread-member-object) of the CurrentUser, and if there are more results in the pagination
+     *
+     * | Permissions needed   | Condition |
+     * |----------------------|-----------|
+     * | VIEW_CHANNEL         | always    |
+     * | READ_MESSAGE_HISTORY | always    |
+     *
+     * @example
+     * const client = new SnowTransfer("TOKEN")
+     * const result = await client.channel.getChannelArchivedPublicThreads("channel id")
+     */
+    async getChannelArchivedPublicThreads(channelId, options) {
+        return this.requestHandler.request(Endpoints.CHANNEL_THREADS_ARCHIVED_PUBLIC(channelId), options, "get", "json");
+    }
+    /**
+     * Gets all threads that are private and archived within a guild channel
+     *
+     * CurrentUser must be a member of the thread if they do not have MANAGE_THREADS permissions
+     * @since 0.3.0
+     * @param channelId Id of the Channel
+     * @param options Options for getting threads
+     * @returns Object containing [private threads](https://discord.com/developers/docs/resources/channel#channel-object), [thread members](https://discord.com/developers/docs/resources/channel#thread-member-object) of the CurrentUser, and if there are more results in the pagination
+     *
+     * | Permissions needed   | Condition                            |
+     * |----------------------|--------------------------------------|
+     * | VIEW_CHANNEL         | always                               |
+     * | READ_MESSAGE_HISTORY | always                               |
+     * | MANAGE_THREADS       | if CurrentUser isn't added to Thread |
+     *
+     * @example
+     * const client = new SnowTransfer("TOKEN")
+     * const result = await client.channel.getChannelArchivedPrivateThreads("channel id")
+     */
+    async getChannelArchivedPrivateThreads(channelId, options) {
+        return this.requestHandler.request(Endpoints.CHANNEL_THREADS_ARCHIVED_PRIVATE(channelId), options, "get", "json");
+    }
+    /**
+     * Gets all threads that are private and archived within a guild channel that the CurrentUser is apart of
+     *
+     * CurrentUser must be a member of the thread if they do not have MANAGE_THREADS permissions
+     * @since 0.3.0
+     * @param channelId Id of the Channel
+     * @param options Option for getting threads
+     * @returns Object containing [private threads](https://discord.com/developers/docs/resources/channel#channel-object), [thread members](https://discord.com/developers/docs/resources/channel#thread-member-object) of the CurrentUser, and if there are more results in the pagination
+     *
+     * | Permissions needed | Condition |
+     * |--------------------|-----------|
+     * | VIEW_CHANNEL       | always    |
+     *
+     * @example
+     * const client = new SnowTransfer("TOKEN")
+     * const result = await client.channel.getChannelArchivedPrivateThreadsUser("channel id")
+     */
+    async getChannelArchivedPrivateThreadsUser(channelId, options) {
+        return this.requestHandler.request(Endpoints.CHANNEL_THREADS_ARCHIVED_PRIVATE_USER(channelId), options, "get", "json");
+    }
+    /**
+     * Refreshes Discord CDN attachments by URL to give you non-expired links. This also works on attachments the token may not have access to through means like guild bot presence
+     * @since 0.10.7
+     * @param attachments A list of Discord CDN attachment URLs. Does not require the URL(s) to have the expiration info parameters
+     * @returns Object containing a list of the original URLs inputted and refreshed URLs
+     *
+     * @example
+     * const client = new SnowTransfer("TOKEN")
+     * const result = await client.channel.refreshAttachmentURLs("https://cdn.discordapp.com/attachments/1109362097952931840/1277799507911905280/traveler.gif")
+     */
+    async refreshAttachmentURLs(attachments) {
+        return this.requestHandler.request(Endpoints.ATTACHMENTS_REFRESH_URLS, {}, "post", "json", {
+            attachment_urls: Array.isArray(attachments) ? attachments : [attachments]
+        });
+    }
+    /**
+     * Get a list of users that voted for this specific answer
+     * @since 0.13.0
+     * @param channelId Id of the channel
+     * @param messageId Id of the message
+     * @param answerId Id of the answer
+     * @param options Options for getting the poll answers
+     * @returns An [answer object](https://discord.com/developers/docs/resources/poll#get-answer-voters-response-body)
+     *
+     * @example
+     * // Get whoever voted for an answer
+     * const client = new SnowTransfer("TOKEN")
+     * const data = await client.channel.getPollAnswerVoters("channel id", "message id", "answer id")
+     */
+    async getPollAnswerVoters(channelId, messageId, answerId, options) {
+        return this.requestHandler.request(Endpoints.POLL_ANSWER(channelId, messageId, answerId), options, "get", "json");
+    }
+    /**
+     * Immediately ends the poll. You cannot end polls from other users
+     * @since 0.13.0
+     * @param channelId Id of the channel
+     * @param messageId Id of the message
+     * @returns A [message object](https://discord.com/developers/docs/resources/message#message-object)
+     *
+     * @example
+     * // End a poll that the bot made
+     * const client = new SnowTransfer("TOKEN")
+     * client.channel.endPoll("channel id", "message id")
+     */
+    async endPoll(channelId, messageId) {
+        return this.requestHandler.request(Endpoints.POLL_EXPIRE(channelId, messageId), {}, "post", "json");
+    }
+    /**
+     * Sets a voice channel's status message
+     * @since 0.17.0
+     * @param channelId Id of the channel
+     * @param status The new status of the voice channel
+     * @param reason Reason for changing the status
+     * @returns Resolves the Promise on successful execution
+     *
+     * | Permissions needed       | Condition                             |
+     * |--------------------------|---------------------------------------|
+     * | VIEW_CHANNEL             | always                                |
+     * | SET_VOICE_CHANNEL_STATUS | always                                |
+     * | MANAGE_CHANNELS          | if CurrentUser isn't in voice channel |
+     *
+     * @example
+     * // Sets the status to poggers
+     * const client = new SnowTransfer("TOKEN")
+     * client.channel.setVoiceChannelStatus("channel id", "poggers")
+     *
+     * @example
+     * // clears the status
+     * client.channel.setVoiceChannelStatus("channel id", "")
+     */
+    async setVoiceChannelStatus(channelId, status, reason) {
+        return this.requestHandler.request(Endpoints.CHANNEL_VOICE_STATUS(channelId), {}, "put", "json", { status }, Constants.reasonHeader(reason));
+    }
+    /**
+     * Sets a voice channel's "vibe" as Discord calls it, but it's actually just an image over all participants of a channel others in and not in the channel can see
+     * @since 0.17.6
+     * @param channelId Id of the channel
+     * @param imageUrl URL of an image to display
+     * @param reason Reason for changing the image
+     * @returns A [Guild Voice Channel](https://discord.com/developers/docs/resources/channel#channel-object)
+     *
+     * | Permissions needed       | Condition                             |
+     * |--------------------------|---------------------------------------|
+     * | VIEW_CHANNEL             | always                                |
+     * | SET_VOICE_CHANNEL_STATUS | always                                |
+     * | MANAGE_CHANNELS          | if CurrentUser isn't in voice channel |
+     *
+     * @example
+     * // Sets the "vibe" image of the voice channel to Rick
+     * const client = new SnowTransfer("TOKEN")
+     * client.channel.setVoiceChannelHangout("channel id", "https://i3.ytimg.com/vi/dQw4w9WgXcQ/maxresdefault.jpg")
+     *
+     * @example
+     * // clears the image
+     * client.channel.setVoiceChannelHangout("channel id", "")
+     */
+    async setVoiceChannelHangout(channelId, imageUrl, reason) {
+        return this.requestHandler.request(Endpoints.CHANNEL_VOICE_HANGOUT(channelId), {}, "post", "json", { url: imageUrl }, Constants.reasonHeader(reason));
+    }
+}
+module.exports = ChannelMethods;
+// Wolke >>
+// https://www.youtube.com/watch?v=LIlZCmETvsY have a weird video to distract yourself from the problems that will come upon ya
+// PapiOphidian >>
+// Thanks, Wolke :)