@discordeno/rest 22.0.1-next.fca3cbb → 22.0.1-next.fdb61e1

package/dist/endpoints.js

@@ -0,0 +1,3711 @@
+import { Buffer } from 'node:buffer';
+import { processReactionString } from '@discordeno/utils';
+/**
+ * @internal You are not supposed to use the functions in this object directly. Use the RestManager instead.
+ */ export const restEndpoints = {
+    /**
+   * Adds a reaction to a message.
+   *
+   * @param channelId - The ID of the channel the message to add a reaction to is in.
+   * @param messageId - The ID of the message to add a reaction to.
+   * @param reaction - The reaction to add to the message.
+   * @returns
+   *
+   * @remarks
+   * Requires the `READ_MESSAGE_HISTORY` permission.
+   *
+   * If nobody else has reacted to the message:
+   * - Requires the `ADD_REACTIONS` permission.
+   *
+   * Fires a _Message Reaction Add_ gateway event.
+   *
+   * @see {@link https://docs.discord.com/developers/resources/channel#create-reaction}
+   */ async addReaction (rest, channelId, messageId, reaction) {
+        reaction = processReactionString(reaction);
+        await rest.put(rest.routes.channels.reactions.bot(channelId, messageId, reaction));
+    },
+    /**
+   * Adds multiple a reaction to a message.
+   *
+   * This function uses the `addReaction()` helper behind the scenes.
+   *
+   * @param channelId - The ID of the channel the message to add reactions to is in.
+   * @param messageId - The ID of the message to add the reactions to.
+   * @param reactions - The reactions to add to the message.
+   * @param ordered - Whether the reactions must be added in order or not.
+   *
+   * @remarks
+   * Requires the `READ_MESSAGE_HISTORY` permission.
+   *
+   * If nobody else has reacted to the message:
+   * - Requires the `ADD_REACTIONS` permission.
+   *
+   * Fires a _Message Reaction Add_ gateway event for every reaction added.
+   */ async addReactions (rest, channelId, messageId, reactions, ordered) {
+        if (!ordered) {
+            await Promise.all(reactions.map(async (reaction)=>{
+                await rest.snake.addReaction(channelId, messageId, reaction);
+            }));
+            return;
+        }
+        for (const reaction of reactions){
+            await rest.snake.addReaction(channelId, messageId, reaction);
+        }
+    },
+    /**
+   * Adds a role to a member.
+   *
+   * @param guildId - The ID of the guild the member to add the role to is in.
+   * @param userId - The user ID of the member to add the role to.
+   * @param roleId - The ID of the role to add to the member.
+   * @param {string} [reason] - An optional reason for the action, to be included in the audit log.
+   *
+   * @remarks
+   * Requires the `MANAGE_ROLES` permission.
+   *
+   * Fires a _Guild Member Update_ gateway event.
+   *
+   * @see {@link https://docs.discord.com/developers/resources/guild#add-guild-member-role}
+   */ async addRole (rest, guildId, userId, roleId, reason) {
+        await rest.put(rest.routes.guilds.roles.member(guildId, userId, roleId), {
+            reason
+        });
+    },
+    /**
+   * Adds a member to a thread.
+   *
+   * @param channelId - The ID of the thread to add the member to.
+   * @param userId - The user ID of the member to add to the thread.
+   *
+   * @remarks
+   * Requires the ability to send messages in the thread.
+   * Requires the thread not be archived.
+   *
+   * Fires a _Thread Members Update_ gateway event.
+   *
+   * @see {@link https://docs.discord.com/developers/resources/channel#add-thread-member}
+   */ async addThreadMember (rest, channelId, userId) {
+        await rest.put(rest.routes.channels.threads.user(channelId, userId));
+    },
+    /**
+   * Adds a recipient to a group DM.
+   *
+   * @param channelId - The ID of the group dm to add the user to.
+   * @param userId - The user ID of the user to add to the group dm.
+   * @param options - The options for adding the user
+   *
+   * @remarks
+   * Requires an OAuth2 access token with the `gdm.join` scope
+   *
+   * @see {@link https://docs.discord.com/developers/resources/channel#group-dm-add-recipient}
+   */ async addDmRecipient (rest, channelId, userId, options) {
+        await rest.put(rest.routes.channels.dmRecipient(channelId, userId), {
+            body: options
+        });
+    },
+    /**
+   * Adds a member to a guild.
+   *
+   * @param guildId - The ID of the thread to add the member to.
+   * @param userId - The user ID of the member to add to the thread.
+   * @param options - The options for the add of a guild member
+   *
+   * @remarks
+   * Requires the bot to be in the specified server
+   * Requires an OAuth2 access token with the `guilds.join` scope
+   *
+   * Fires a _Guild Member Add_ gateway event.
+   *
+   * @see {@link https://docs.discord.com/developers/resources/guild#add-guild-member}
+   */ async addGuildMember (rest, guildId, userId, options) {
+        return await rest.put(rest.routes.guilds.members.member(guildId, userId), {
+            body: options
+        });
+    },
+    /**
+   * Creates an automod rule in a guild.
+   *
+   * @param guildId - The ID of the guild to create the rule in.
+   * @param options - The parameters for the creation of the rule.
+   * @param {string} [reason] - An optional reason for the action, to be included in the audit log.
+   * @returns An instance of the created {@link DiscordAutoModerationRule}.
+   *
+   * @remarks
+   * Requires the `MANAGE_GUILD` permission.
+   *
+   * Fires an _Auto Moderation Rule Create_ gateway event.
+   *
+   * @see {@link https://docs.discord.com/developers/resources/auto-moderation#create-auto-moderation-rule}
+   */ async createAutomodRule (rest, guildId, options, reason) {
+        return await rest.post(rest.routes.guilds.automod.rules(guildId), {
+            body: options,
+            reason
+        });
+    },
+    /**
+   * Creates a channel within a guild.
+   *
+   * @param guildId - The ID of the guild to create the channel within.
+   * @param options - The parameters for the creation of the channel.
+   * @param {string} [reason] - An optional reason for the action, to be included in the audit log.
+   * @returns An instance of the created {@link DiscordChannel}.
+   *
+   * @remarks
+   * Requires the `MANAGE_CHANNELS` permission.
+   *
+   * If setting permission overwrites, only the permissions the bot user has in the guild can be allowed or denied.
+   *
+   * Setting the `MANAGE_ROLES` permission is only possible for guild administrators.
+   *
+   * Fires a _Channel Create_ gateway event.
+   *
+   * @see {@link https://docs.discord.com/developers/resources/guild#create-guild-channel}
+   */ async createChannel (rest, guildId, options, reason) {
+        return await rest.post(rest.routes.guilds.channels(guildId), {
+            body: options,
+            reason
+        });
+    },
+    /**
+   * Creates an emoji in a guild.
+   *
+   * @param guildId - The ID of the guild in which to create the emoji.
+   * @param options - The parameters for the creation of the emoji.
+   * @param {string} [reason] - An optional reason for the action, to be included in the audit log.
+   * @returns An instance of the created {@link DiscordEmoji}.
+   *
+   * @remarks
+   * Requires the `CREATE_GUILD_EXPRESSIONS` permission.
+   *
+   * Emojis have a maximum file size of 256 kilobits. Attempting to upload a larger emoji will cause the route to return 400 Bad Request.
+   *
+   * Fires a _Guild Emojis Update_ gateway event.
+   *
+   * @see {@link https://docs.discord.com/developers/resources/emoji#create-guild-emoji}
+   */ async createEmoji (rest, guildId, options, reason) {
+        return await rest.post(rest.routes.guilds.emojis(guildId), {
+            body: options,
+            reason
+        });
+    },
+    /**
+   * Creates an emoji for the application.
+   *
+   * @param options - The parameters for the creation of the emoji.
+   * @returns An instance of the created {@link DiscordEmoji}.
+   *
+   * @see {@link https://docs.discord.com/developers/resources/emoji#create-application-emoji}
+   */ async createApplicationEmoji (rest, options) {
+        return await rest.post(rest.routes.applicationEmojis(rest.applicationId), {
+            body: options
+        });
+    },
+    /**
+   * Creates a new thread in a forum channel or media channel, and sends a message within the created thread.
+   *
+   * @param channelId - The ID of the forum channel to create the thread within.
+   * @param options - The parameters for the creation of the thread.
+   * @param {string} [reason] - An optional reason for the action, to be included in the audit log.
+   * @returns An instance of {@link DiscordChannel} with a nested {@link DiscordChannel} object.
+   *
+   * @remarks
+   * Requires the `CREATE_MESSAGES` permission.
+   *
+   * Fires a _Thread Create_ gateway event.
+   * Fires a _Message Create_ gateway event.
+   *
+   * @see {@link https://docs.discord.com/developers/resources/channel#start-thread-in-forum-or-media-channel}
+   */ async createForumThread (rest, channelId, options, reason) {
+        return await rest.post(rest.routes.channels.forum(channelId), {
+            body: options,
+            files: options.files,
+            reason
+        });
+    },
+    /**
+   * Creates an application command accessible globally; across different guilds and channels.
+   *
+   * @param command - The command to create.
+   * @param options - Additional options for the endpoint
+   * @returns An instance of the created {@link DiscordApplicationCommand}.
+   *
+   * @remarks
+   * ⚠️ Creating a command with the same name as an existing command for your application will overwrite the old command.
+   * ⚠️ Global commands once created are cached for periods of __an hour__, so changes made to existing commands will take an hour to surface.
+   * ⚠️ You can only create up to 200 _new_ commands daily.
+   *
+   * When using the bearer token the token needs the `applications.commands.update` scope and must be a `Client grant` token.
+   *  You will be able to update only your own application commands
+   *
+   * @see {@link https://docs.discord.com/developers/interactions/application-commands#create-global-application-command}
+   */ async createGlobalApplicationCommand (rest, command, options) {
+        const restOptions = {
+            body: command
+        };
+        if (options?.bearerToken) {
+            restOptions.unauthorized = true;
+            restOptions.headers = {
+                authorization: `Bearer ${options.bearerToken}`
+            };
+        }
+        return await rest.post(rest.routes.interactions.commands.commands(rest.applicationId), restOptions);
+    },
+    /**
+   * Creates an application command only accessible in a specific guild.
+   *
+   * @param command - The command to create.
+   * @param guildId - The ID of the guild to create the command for.
+   * @param options - Additional options for the endpoint
+   * @returns An instance of the created {@link DiscordApplicationCommand}.
+   *
+   * @remarks
+   * ⚠️ Creating a command with the same name as an existing command for your application will overwrite the old command.
+   * ⚠️ You can only create up to 200 _new_ commands daily.
+   *
+   * When using the bearer token the token needs the `applications.commands.update` scope and must be a `Client grant` token.
+   *  You will be able to update only your own application commands
+   *
+   * @see {@link https://docs.discord.com/developers/interactions/application-commands#create-guild-application-command}
+   */ async createGuildApplicationCommand (rest, command, guildId, options) {
+        const restOptions = {
+            body: command
+        };
+        if (options?.bearerToken) {
+            restOptions.unauthorized = true;
+            restOptions.headers = {
+                authorization: `Bearer ${options.bearerToken}`
+            };
+        }
+        return await rest.post(rest.routes.interactions.commands.guilds.all(rest.applicationId, guildId), restOptions);
+    },
+    /**
+   * Create a new sticker for the guild.
+   *
+   * @param guildId The ID of the guild to get
+   * @param {string} [reason] - An optional reason for the action, to be included in the audit log.
+   * @return A {@link DiscordSticker}
+   *
+   * @remarks
+   * Requires the `CREATE_GUILD_EXPRESSIONS` permission.
+   * Fires a Guild Stickers Update Gateway event.
+   * Every guilds has five free sticker slots by default, and each Boost level will grant access to more slots.
+   * Lottie stickers can only be uploaded on guilds that have either the `VERIFIED` and/or the `PARTNERED` guild feature.
+   *
+   * @see {@link https://docs.discord.com/developers/resources/sticker#create-guild-sticker}
+   */ async createGuildSticker (rest, guildId, options, reason) {
+        const form = new FormData();
+        form.append('file', options.file.blob, options.file.name);
+        form.append('name', options.name);
+        form.append('description', options.description);
+        form.append('tags', options.tags);
+        return await rest.post(rest.routes.guilds.stickers(guildId), {
+            body: form,
+            reason
+        });
+    },
+    /**
+   * Creates a template from a guild.
+   *
+   * @param guildId - The ID of the guild to create the template from.
+   * @param options - The parameters for the creation of the template.
+   * @returns An instance of the created {@link DiscordTemplate}.
+   *
+   * @remarks
+   * Requires the `MANAGE_GUILD` permission.
+   *
+   * Fires a _Guild Update_ gateway event.
+   *
+   * @see {@link https://docs.discord.com/developers/resources/guild-template#create-guild-template}
+   */ async createGuildTemplate (rest, guildId, options) {
+        return await rest.post(rest.routes.guilds.templates.all(guildId), {
+            body: options
+        });
+    },
+    /**
+   * Creates an invite to a channel in a guild.
+   *
+   * @param channelId - The ID of the channel to create the invite to.
+   * @param options - The parameters for the creation of the invite.
+   * @param {string} [reason] - An optional reason for the action, to be included in the audit log.
+   * @returns An instance of the created {@link DiscordInvite}.
+   *
+   * @remarks
+   * Requires the `CREATE_INSTANT_INVITE` permission.
+   *
+   * Fires an _Invite Create_ gateway event.
+   *
+   * @privateRemarks
+   * The request body is not optional, and an empty JSON object must be sent regardless of whether any fields are being transmitted.
+   *
+   * @see {@link https://docs.discord.com/developers/resources/channel#create-channel-invite}
+   */ async createInvite (rest, channelId, options, reason) {
+        options ??= {};
+        if (!options.targetUsersFile) {
+            return await rest.post(rest.routes.channels.invites(channelId), {
+                body: options,
+                reason
+            });
+        }
+        // When we have to upload a file, we need to use FormData, and all other fields need to be part of the payload_json field.
+        const form = new FormData();
+        form.append('payload_json', JSON.stringify(rest.changeToDiscordFormat({
+            ...options,
+            targetUsersFile: undefined
+        })));
+        form.append('target_users_file', options.targetUsersFile);
+        return await rest.post(rest.routes.channels.invites(channelId), {
+            body: form,
+            reason
+        });
+    },
+    /**
+   * Get guild role member counts
+   *
+   * Returns a map of role IDs to the number of members with the role. Does not include the \@everyone role.
+   *
+   * @param guildId - The ID of the guild to get role member counts for.
+   *
+   * @see {@link https://docs.discord.com/developers/resources/guild#get-guild-role-member-counts}
+   */ async getGuildRoleMemberCounts (rest, guildId) {
+        return await rest.get(rest.routes.guilds.roles.memberCounts(guildId));
+    },
+    /**
+   * Creates a role in a guild.
+   *
+   * @param guildId - The ID of the guild to create the role in.
+   * @param options - The parameters for the creation of the role.
+   * @param {string} [reason] - An optional reason for the action, to be included in the audit log.
+   * @returns An instance of the created {@link DiscordRole}.
+   *
+   * @remarks
+   * Requires the `MANAGE_ROLES` permission.
+   *
+   * Fires a _Guild Role Create_ gateway event.
+   *
+   * @see {@link https://docs.discord.com/developers/resources/guild#create-guild-role}
+   */ async createRole (rest, guildId, options, reason) {
+        return await rest.post(rest.routes.guilds.roles.all(guildId), {
+            body: options,
+            reason
+        });
+    },
+    /**
+   * Creates a scheduled event in a guild.
+   *
+   * @param guildId - The ID of the guild to create the scheduled event in.
+   * @param options - The parameters for the creation of the scheduled event.
+   * @param {string} [reason] - An optional reason for the action, to be included in the audit log.
+   * @returns An instance of the created {@link DiscordScheduledEvent}.
+   *
+   * @remarks
+   * Requires the `MANAGE_EVENTS` permission.
+   *
+   * A guild can only have a maximum of 100 events with a status of {@link ScheduledEventStatus}.Active or {@link ScheduledEventStatus}.Scheduled (inclusive).
+   *
+   * Fires a _Guild Scheduled Event Create_ gateway event.
+   *
+   * @see {@link https://docs.discord.com/developers/resources/guild-scheduled-event#create-guild-scheduled-event}
+   */ async createScheduledEvent (rest, guildId, options, reason) {
+        return await rest.post(rest.routes.guilds.events.events(guildId), {
+            body: options,
+            reason
+        });
+    },
+    /**
+   * Creates a stage instance associated with a stage channel.
+   *
+   * @param options - The parameters for the creation of the stage instance.
+   * @param {string} [reason] - An optional reason for the action, to be included in the audit log.
+   * @returns An instance of the created {@link DiscordStageInstance}.
+   *
+   * @remarks
+   * Requires the user to be a moderator of the stage channel.
+   *
+   * Fires a _Stage Instance Create_ gateway event.
+   *
+   * @see {@link https://docs.discord.com/developers/resources/stage-instance#create-stage-instance}
+   */ async createStageInstance (rest, options, reason) {
+        return await rest.post(rest.routes.channels.stages(), {
+            body: options,
+            reason
+        });
+    },
+    /**
+   * Creates a webhook.
+   *
+   * @param channelId - The ID of the channel to create the webhook in.
+   * @param options - The parameters for the creation of the webhook.
+   * @param {string} [reason] - An optional reason for the action, to be included in the audit log.
+   * @returns An instance of the created {@link DiscordWebhook}.
+   *
+   * @remarks
+   * Requires the `MANAGE_WEBHOOKS` permission.
+   *
+   * ⚠️ The webhook name must not contain the substrings 'clyde', or 'discord' (case-insensitive).
+   *
+   * Fires a _Webhooks Update_ gateway event.
+   *
+   * @see {@link https://docs.discord.com/developers/resources/webhook#create-webhook}
+   */ async createWebhook (rest, channelId, options, reason) {
+        return await rest.post(rest.routes.channels.webhooks(channelId), {
+            body: options,
+            reason
+        });
+    },
+    /**
+   * Deletes an automod rule.
+   *
+   * @param guildId - The ID of the guild to delete the rule from.
+   * @param ruleId - The ID of the automod rule to delete.
+   * @param {string} [reason] - An optional reason for the action, to be included in the audit log.
+   *
+   * @remarks
+   * Requires the `MANAGE_GUILD` permission.
+   *
+   * Fires an _Auto Moderation Rule Delete_ gateway event.
+   *
+   * @see {@link https://docs.discord.com/developers/resources/auto-moderation#delete-auto-moderation-rule}
+   */ async deleteAutomodRule (rest, guildId, ruleId, reason) {
+        await rest.delete(rest.routes.guilds.automod.rule(guildId, ruleId), {
+            reason
+        });
+    },
+    /**
+   * Set a voice channel’s status
+   *
+   * @param channelId - The ID of the channel to set the status of.
+   * @param options - The parameters for the status of the voice channel.
+   * @param {string} [reason] - An optional reason for the action, to be included in the audit log.
+   * @returns Nothing
+   *
+   * @remarks
+   * Requires the `SET_VOICE_CHANNEL_STATUS` permission, and additionally the `MANAGE_CHANNELS` permission if the current user is not connected to the voice channel.
+   *
+   * Fires a _Voice Channel Status Update_ Gateway event.
+   *
+   * @see {@link https://docs.discord.com/developers/resources/channel#set-voice-channel-status}
+   */ async setVoiceChannelStatus (rest, channelId, options, reason) {
+        await rest.put(rest.routes.channels.voiceStatus(channelId), {
+            body: options,
+            reason
+        });
+    },
+    /**
+   * Deletes a channel from within a guild.
+   *
+   * @param channelId - The ID of the channel to delete.
+   * @param {string} [reason] - An optional reason for the action, to be included in the audit log.
+   * @returns nothing
+   *
+   * @remarks
+   * For community guilds, the _Rules_, _Guidelines_ and _Community Update_ channels cannot be deleted.
+   *
+   * If the channel is a thread:
+   * - Requires the `MANAGE_THREADS` permission.
+   *
+   * - Fires a _Thread Delete_ gateway event.
+   *
+   * Otherwise:
+   * - Requires the `MANAGE_CHANNELS` permission.
+   *
+   * - ⚠️ Deleting a category channel does not delete its child channels.
+   *   Instead, they will have their `parent_id` property removed, and a `Channel Update` gateway event will fire for each of them.
+   *
+   * - Fires a _Channel Delete_ gateway event.
+   *
+   * @see {@link https://docs.discord.com/developers/resources/channel#deleteclose-channel}
+   */ async deleteChannel (rest, channelId, reason) {
+        await rest.delete(rest.routes.channels.channel(channelId), {
+            reason
+        });
+    },
+    /**
+   * Deletes a permission override for a user or role in a channel.
+   *
+   * @param channelId - The ID of the channel to delete the permission override of.
+   * @param overwriteId - The ID of the permission override to delete.
+   * @param {string} [reason] - An optional reason for the action, to be included in the audit log.
+   *
+   * @remarks
+   * Requires the `MANAGE_ROLES` permission.
+   *
+   * Fires a _Channel Update_ gateway event.
+   *
+   * @see {@link https://docs.discord.com/developers/resources/channel#delete-channel-permission}
+   */ async deleteChannelPermissionOverride (rest, channelId, overwriteId, reason) {
+        await rest.delete(rest.routes.channels.overwrite(channelId, overwriteId), {
+            reason
+        });
+    },
+    /**
+   * Deletes an emoji from a guild.
+   *
+   * @param guildId - The ID of the guild from which to delete the emoji.
+   * @param id - The ID of the emoji to delete.
+   * @param {string} [reason] - An optional reason for the action, to be included in the audit log.
+   *
+   * @remarks
+   * For emojis created by the current user, requires either the `CREATE_GUILD_EXPRESSIONS` or `MANAGE_GUILD_EXPRESSIONS` permission.
+   * For other emojis, requires the `MANAGE_GUILD_EXPRESSIONS` permission.
+   *
+   * Fires a _Guild Emojis Update_ gateway event.
+   *
+   * @see {@link https://docs.discord.com/developers/resources/emoji#delete-guild-emoji}
+   */ async deleteEmoji (rest, guildId, id, reason) {
+        await rest.delete(rest.routes.guilds.emoji(guildId, id), {
+            reason
+        });
+    },
+    /**
+   * Deletes an emoji from the application.
+   *
+   * @param id - The ID of the emoji to delete.
+   *
+   * @see {@link https://docs.discord.com/developers/resources/emoji#delete-application-emoji}
+   */ async deleteApplicationEmoji (rest, id) {
+        await rest.delete(rest.routes.applicationEmoji(rest.applicationId, id));
+    },
+    /**
+   * Deletes a follow-up message to an interaction.
+   *
+   * @param token - The interaction token to use, provided in the original interaction.
+   * @param messageId - The ID of the message to delete.
+   *
+   * @remarks
+   * Unlike `deleteMessage()`, this endpoint allows the bot user to act without needing to see the channel the message is in.
+   *
+   * Fires a _Message Delete_ event.
+   *
+   * @see {@link https://docs.discord.com/developers/interactions/receiving-and-responding#delete-followup-message}
+   */ async deleteFollowupMessage (rest, token, messageId) {
+        await rest.delete(rest.routes.interactions.responses.message(rest.applicationId, token, messageId), {
+            unauthorized: true
+        });
+    },
+    /**
+   * Deletes an application command registered globally.
+   *
+   * @param commandId - The ID of the command to delete.
+   *
+   * @see {@link https://docs.discord.com/developers/interactions/application-commands#delete-global-application-command}
+   */ async deleteGlobalApplicationCommand (rest, commandId) {
+        await rest.delete(rest.routes.interactions.commands.command(rest.applicationId, commandId));
+    },
+    /**
+   * Deletes an application command registered in a guild.
+   *
+   * @param guildId - The ID of the guild to delete the command from.
+   * @param commandId - The ID of the command to delete from the guild.
+   *
+   * @see {@link https://docs.discord.com/developers/interactions/application-commands#delete-guild-application-command}
+   */ async deleteGuildApplicationCommand (rest, commandId, guildId) {
+        await rest.delete(rest.routes.interactions.commands.guilds.one(rest.applicationId, guildId, commandId));
+    },
+    /**
+   * Delete a new sticker for the guild.
+   *
+   * @param guildId The ID of the guild to get
+   * @param {string} [reason] - An optional reason for the action, to be included in the audit log.
+   * @return A {@link DiscordSticker}
+   *
+   * @remarks
+   * For stickers created by the current user, requires either the `CREATE_GUILD_EXPRESSIONS` or `MANAGE_GUILD_EXPRESSIONS` permission.
+   * For other stickers, requires the `MANAGE_GUILD_EXPRESSIONS` permission.
+   * Fires a Guild Stickers Update Gateway event.
+   * Every guilds has five free sticker slots by default, and each Boost level will grant access to more slots.
+   * Lottie stickers can only be uploaded on guilds that have either the `VERIFIED` and/or the `PARTNERED` guild feature.
+   *
+   * @see {@link https://docs.discord.com/developers/resources/sticker#delete-guild-sticker}
+   */ async deleteGuildSticker (rest, guildId, stickerId, reason) {
+        await rest.delete(rest.routes.guilds.sticker(guildId, stickerId), {
+            reason
+        });
+    },
+    /**
+   * Deletes a template from a guild.
+   *
+   * @param guildId - The ID of the guild to delete the template from.
+   * @param templateCode - The code of the template to delete.
+   *
+   * @remarks
+   * Requires the `MANAGE_GUILD` permission.
+   *
+   * Fires a _Guild Update_ gateway event.
+   *
+   * @see {@link https://docs.discord.com/developers/resources/guild-template#delete-guild-template}
+   */ async deleteGuildTemplate (rest, guildId, templateCode) {
+        await rest.delete(rest.routes.guilds.templates.guild(guildId, templateCode));
+    },
+    /**
+   * Deletes an integration attached to a guild.
+   *
+   * @param guildId - The ID of the guild from which to delete the integration.
+   * @param integrationId - The ID of the integration to delete from the guild.
+   * @param {string} [reason] - An optional reason for the action, to be included in the audit log.
+   *
+   * @remarks
+   * Requires the `MANAGE_GUILD` permission.
+   *
+   * Deletes all webhooks associated with the integration, and kicks the associated bot if there is one.
+   *
+   * Fires a _Guild Integrations Update_ gateway event.
+   * Fires a _Integration Delete_ gateway event.
+   *
+   * @see {@link https://docs.discord.com/developers/resources/guild#delete-guild-integration}
+   */ async deleteIntegration (rest, guildId, integrationId, reason) {
+        await rest.delete(rest.routes.guilds.integration(guildId, integrationId), {
+            reason
+        });
+    },
+    /**
+   * Deletes an invite to a channel.
+   *
+   * @param inviteCode - The invite code of the invite to delete.
+   * @param {string} [reason] - An optional reason for the action, to be included in the audit log.
+   *
+   * @remarks
+   * Requires the `MANAGE_CHANNELS` permission.
+   *
+   * Fires an _Invite Delete_ gateway event.
+   *
+   * @see {@link https://docs.discord.com/developers/resources/channel#delete-channel-invite}
+   */ async deleteInvite (rest, inviteCode, reason) {
+        await rest.delete(rest.routes.guilds.invite(inviteCode), {
+            reason
+        });
+    },
+    /**
+   * Gets the users allowed to see and accept this invite.
+   *
+   * @param inviteCode - The invite code of the invite to update.
+   * @returns CSV file containing the user IDs with the header `user_id` and each user ID from the original file
+   *
+   * @remarks
+   * Requires called to be the inviter, or have `MANAGE_GUILD` permission, or have `VIEW_AUDIT_LOG` permission.
+   *
+   * @see {@link https://docs.discord.com/developers/resources/invite#get-target-users}
+   */ async getTargetUsers (rest, inviteCode) {
+        return await rest.get(rest.routes.guilds.inviteTargetUsers(inviteCode));
+    },
+    /**
+   * Updates the users allowed to see and accept this invite.
+   *
+   * @param inviteCode - The invite code of the invite to update.
+   * @param targetUsersFile - A CSV file with a single column of user IDs for all the users able to accept this invite
+   *
+   * @remarks
+   * Requires the caller to be the inviter or have the `MANAGE_GUILD` permission.
+   *
+   * Uploading a file with invalid user IDs will result in a 400 with the invalid IDs described.
+   *
+   * @see {@link https://docs.discord.com/developers/resources/invite#update-target-users}
+   */ async updateTargetUsers (rest, inviteCode, targetUsersFile) {
+        const form = new FormData();
+        form.append('target_users_file', targetUsersFile);
+        await rest.put(rest.routes.guilds.inviteTargetUsers(inviteCode), {
+            body: form
+        });
+    },
+    /**
+   * Processing target users from a CSV when creating or updating an invite is done asynchronously. This endpoint allows you to check the status of that job.
+   *
+   * @param inviteCode - The invite code of the invite to check the target users job status for.
+   * @returns An object containing the status of the target users job.
+   *
+   * @remarks
+   * Requires the caller to be the inviter, or have `MANAGE_GUILD` permission, or have `VIEW_AUDIT_LOG` permission.
+   *
+   * @see {@link https://docs.discord.com/developers/resources/invite#get-target-users-job-status}
+   */ async getTargetUsersJobStatus (rest, inviteCode) {
+        return await rest.get(rest.routes.guilds.inviteTargetUsersJobStatus(inviteCode));
+    },
+    /**
+   * Deletes a message from a channel.
+   *
+   * @param channelId - The ID of the channel to delete the message from.
+   * @param messageId - The ID of the message to delete from the channel.
+   * @param {string} [reason] - An optional reason for the action, to be included in the audit log.
+   *
+   * @remarks
+   * If not deleting own message:
+   * - Requires the `MANAGE_MESSAGES` permission.
+   *
+   * Fires a _Message Delete_ gateway event.
+   *
+   * @see {@link https://docs.discord.com/developers/resources/channel#delete-message}
+   */ async deleteMessage (rest, channelId, messageId, reason) {
+        await rest.delete(rest.routes.channels.message(channelId, messageId), {
+            reason
+        });
+    },
+    /**
+   * Deletes multiple messages from a channel.
+   *
+   * @param channelId - The ID of the channel to delete the messages from.
+   * @param messageIds - The IDs of the messages to delete from the channel.
+   * @param {string} [reason] - An optional reason for the action, to be included in the audit log.
+   *
+   * @remarks
+   * Requires the `MANAGE_MESSAGES` permission.
+   *
+   * ⚠️ Messages older than 2 weeks old cannot be deleted.
+   *
+   * Fires a _Message Delete Bulk_ gateway event.
+   *
+   * @see {@link https://docs.discord.com/developers/resources/channel#bulk-delete-messages}
+   */ async deleteMessages (rest, channelId, messageIds, reason) {
+        await rest.post(rest.routes.channels.bulk(channelId), {
+            body: {
+                messages: messageIds.slice(0, 100).map((id)=>id.toString())
+            },
+            reason
+        });
+    },
+    /**
+   * Deletes the initial message response to an interaction.
+   *
+   * @param token - The interaction token to use, provided in the original interaction.
+   *
+   * @remarks
+   * Unlike `deleteMessage()`, this endpoint allows the bot user to act without needing to see the channel the message is in.
+   *
+   * Fires a _Message Delete_ event.
+   *
+   * @see {@link https://docs.discord.com/developers/interactions/receiving-and-responding#delete-original-interaction-response}
+   */ async deleteOriginalInteractionResponse (rest, token) {
+        await rest.delete(rest.routes.interactions.responses.original(rest.applicationId, token), {
+            unauthorized: true
+        });
+    },
+    /**
+   * Deletes a reaction added by the bot user from a message.
+   *
+   * @param channelId - The ID of the channel the message to delete the reaction from is in.
+   * @param messageId - The ID of the message to delete the reaction from.
+   * @param reaction - The reaction to delete from the message.
+   *
+   * @remarks
+   * Requires the `READ_MESSAGE_HISTORY` permission.
+   *
+   * Fires a _Message Reaction Remove_ gateway event.
+   *
+   * @see {@link https://docs.discord.com/developers/resources/channel#delete-own-reaction}
+   */ async deleteOwnReaction (rest, channelId, messageId, reaction) {
+        reaction = processReactionString(reaction);
+        await rest.delete(rest.routes.channels.reactions.bot(channelId, messageId, reaction));
+    },
+    /**
+   * Deletes all reactions for all emojis from a message.
+   *
+   * @param channelId - The ID of the channel the message to delete the reactions from is in.
+   * @param messageId - The ID of the message to delete the reactions from.
+   *
+   * @remarks
+   * Requires the `READ_MESSAGE_HISTORY` permission.
+   *
+   * Requires the `MANAGE_MESSAGES` permission.
+   *
+   * Fires a _Message Reaction Remove All_ gateway event.
+   *
+   * @see {@link https://docs.discord.com/developers/resources/channel#delete-all-reactions}
+   */ async deleteReactionsAll (rest, channelId, messageId) {
+        await rest.delete(rest.routes.channels.reactions.all(channelId, messageId));
+    },
+    /**
+   * Deletes all reactions for an emoji from a message.
+   *
+   * @param channelId - The ID of the channel the message to delete the reactions from is in.
+   * @param messageId - The ID of the message to delete the reactions from.
+   * @param reaction - The reaction to remove from the message.
+   *
+   * @remarks
+   * Requires the `READ_MESSAGE_HISTORY` permission.
+   *
+   * Requires the `MANAGE_MESSAGES` permission.
+   *
+   * Fires a _Message Reaction Remove Emoji_ gateway event.
+   *
+   * @see {@link https://docs.discord.com/developers/resources/channel#delete-all-reactions-for-emoji}
+   */ async deleteReactionsEmoji (rest, channelId, messageId, reaction) {
+        reaction = processReactionString(reaction);
+        await rest.delete(rest.routes.channels.reactions.emoji(channelId, messageId, reaction));
+    },
+    /**
+   * Deletes a role from a guild.
+   *
+   * @param guildId - The ID of the guild to delete the role from.
+   * @param roleId - The ID of the role to delete.
+   * @param {string} [reason] - An optional reason for the action, to be included in the audit log.
+   *
+   * @remarks
+   * Requires the `MANAGE_ROLES` permission.
+   *
+   * Fires a _Guild Role Delete_ gateway event.
+   *
+   * @see {@link https://docs.discord.com/developers/resources/guild#delete-guild-role}
+   */ async deleteRole (rest, guildId, roleId, reason) {
+        await rest.delete(rest.routes.guilds.roles.one(guildId, roleId), {
+            reason
+        });
+    },
+    /**
+   * Deletes a scheduled event from a guild.
+   *
+   * @param guildId - The ID of the guild to delete the scheduled event from.
+   * @param eventId - The ID of the scheduled event to delete.
+   *
+   * @remarks
+   * Requires the `MANAGE_EVENTS` permission.
+   *
+   * Fires a _Guild Scheduled Event Delete_ gateway event.
+   *
+   * @see {@link https://docs.discord.com/developers/resources/guild-scheduled-event#delete-guild-scheduled-event}
+   */ async deleteScheduledEvent (rest, guildId, eventId) {
+        await rest.delete(rest.routes.guilds.events.event(guildId, eventId));
+    },
+    /**
+   * Deletes the stage instance associated with a stage channel, if one exists.
+   *
+   * @param channelId - The ID of the stage channel the stage instance is associated with.
+   * @param {string} [reason] - An optional reason for the action, to be included in the audit log.
+   *
+   * @remarks
+   * Requires the user to be a moderator of the stage channel.
+   *
+   * Fires a _Stage Instance Delete_ gateway event.
+   *
+   * @see {@link https://docs.discord.com/developers/resources/stage-instance#delete-stage-instance}
+   */ async deleteStageInstance (rest, channelId, reason) {
+        await rest.delete(rest.routes.channels.stage(channelId), {
+            reason
+        });
+    },
+    /**
+   * Deletes a user's reaction from a message.
+   *
+   * @param channelId - The ID of the channel the message to delete the reaction from is in.
+   * @param messageId - The ID of the message to delete the reaction from.
+   * @param userId - The ID of the user whose reaction to delete.
+   * @param reaction - The reaction to delete from the message.
+   *
+   * @remarks
+   * Requires the `READ_MESSAGE_HISTORY` permission.
+   *
+   * Requires the `MANAGE_MESSAGES` permission.
+   *
+   * Fires a _Message Reaction Remove_ gateway event.
+   *
+   * @see {@link https://docs.discord.com/developers/resources/channel#delete-user-reaction}
+   */ async deleteUserReaction (rest, channelId, messageId, userId, reaction) {
+        reaction = processReactionString(reaction);
+        await rest.delete(rest.routes.channels.reactions.user(channelId, messageId, reaction, userId));
+    },
+    /**
+   * Deletes a webhook.
+   *
+   * @param webhookId - The ID of the webhook to delete.
+   *
+   * @remarks
+   * Requires the `MANAGE_WEBHOOKS` permission.
+   *
+   * Fires a _Webhooks Update_ gateway event.
+   *
+   * @see {@link https://docs.discord.com/developers/resources/webhook#delete-webhook}
+   */ async deleteWebhook (rest, webhookId, reason) {
+        await rest.delete(rest.routes.webhooks.id(webhookId), {
+            reason
+        });
+    },
+    /**
+   * Deletes a webhook message.
+   *
+   * @param webhookId - The ID of the webhook to delete the message belonging to.
+   * @param token - The webhook token, used to manage the webhook.
+   * @param messageId - The ID of the message to delete.
+   * @param options - The parameters for the deletion of the message.
+   *
+   * @remarks
+   * Fires a _Message Delete_ gateway event.
+   *
+   * @see {@link https://docs.discord.com/developers/resources/webhook#delete-webhook}
+   */ async deleteWebhookMessage (rest, webhookId, token, messageId, options) {
+        await rest.delete(rest.routes.webhooks.message(webhookId, token, messageId, options), {
+            unauthorized: true
+        });
+    },
+    /**
+   * Deletes a webhook message using the webhook token, thereby bypassing the need for authentication + permissions.
+   *
+   * @param webhookId - The ID of the webhook to delete the message belonging to.
+   * @param token - The webhook token, used to delete the webhook.
+   *
+   * @remarks
+   * Fires a _Message Delete_ gateway event.
+   *
+   * @see {@link https://docs.discord.com/developers/resources/webhook#delete-webhook-with-token}
+   */ async deleteWebhookWithToken (rest, webhookId, token) {
+        await rest.delete(rest.routes.webhooks.webhook(webhookId, token), {
+            unauthorized: true
+        });
+    },
+    /**
+   * Edits the permissions for a guild application command.
+   *
+   * @param guildId - The ID of the guild the command is registered in.
+   * @param commandId - The ID of the command to edit the permissions of.
+   * @param bearerToken - The bearer token to use to make the request.
+   * @param options - The parameters for the edit of the command permissions.
+   * @returns An instance of the edited {@link DiscordGuildApplicationCommandPermissions}.
+   *
+   * @remarks
+   * The bearer token requires the `applications.commands.permissions.update` scope to be enabled, and to have access to the guild whose ID has been provided in the parameters.
+   *
+   * @see {@link https://docs.discord.com/developers/interactions/application-commands#edit-application-command-permissions}
+   */ async editApplicationCommandPermissions (rest, guildId, commandId, bearerToken, options) {
+        return await rest.put(rest.routes.interactions.commands.permission(rest.applicationId, guildId, commandId), {
+            body: {
+                permissions: options
+            },
+            headers: {
+                authorization: `Bearer ${bearerToken}`
+            }
+        });
+    },
+    /**
+   * Edits an automod rule.
+   *
+   * @param guildId - The ID of the guild to edit the rule in.
+   * @param ruleId - The ID of the rule to edit.
+   * @param options - The parameters for the edit of the rule.
+   * @param {string} [reason] - An optional reason for the action, to be included in the audit log.
+   * @returns An instance of the edited {@link DiscordAutoModerationRule}.
+   *
+   * @remarks
+   * Requires the `MANAGE_GUILD` permission.
+   *
+   * Fires an _Auto Moderation Rule Update_ gateway event.
+   *
+   * @see {@link https://docs.discord.com/developers/resources/auto-moderation#modify-auto-moderation-rule}
+   */ async editAutomodRule (rest, guildId, ruleId, options, reason) {
+        return await rest.patch(rest.routes.guilds.automod.rule(guildId, ruleId), {
+            body: options,
+            reason
+        });
+    },
+    /**
+   * Modifies the bot's username, avatar or banner.
+   *
+   * @param options - The parameters for the edit of the bot's profile.
+   * @returns An instance of the edited {@link DiscordUser}.
+   *
+   * @remarks
+   * Editing the `username` may cause the bot's discriminator to be randomized.
+   *
+   * `avatar` and `banner` must to be a Data URI scheme. {@link urlToBase64} from `@discordeno/utils` can be used to convert a URL to a Data URI scheme.
+   *
+   * @see {@link https://docs.discord.com/developers/resources/user#modify-current-user}
+   */ async editBotProfile (rest, options) {
+        return await rest.patch(rest.routes.currentUser(), {
+            body: options
+        });
+    },
+    /**
+   * Edits a channel's settings.
+   *
+   * @param channelId - The ID of the channel to edit.
+   * @param options - The parameters for the edit of the channel.
+   * @param {string} [reason] - An optional reason for the action, to be included in the audit log.
+   * @returns An instance of the edited {@link DiscordChannel}.
+   *
+   * @remarks
+   * If editing a channel of type {@link ChannelTypes}.GroupDm:
+   * - Fires a _Channel Update_ gateway event.
+   *
+   * If editing a thread channel:
+   * - Requires the `MANAGE_THREADS` permission __unless__ if setting the `archived` property to `false` when the `locked` property is also `false`, in which case only the `SEND_MESSAGES` permission is required.
+   *
+   * - Fires a _Thread Update_ gateway event.
+   *
+   * If editing a guild channel:
+   * - Requires the `MANAGE_CHANNELS` permission.
+   *
+   * - If modifying permission overrides:
+   *   - Requires the `MANAGE_ROLES` permission.
+   *
+   *   - Only permissions the bot user has in the guild or parent channel can be allowed/denied __unless__ the bot user has a `MANAGE_ROLES` permission override in the channel.
+   *
+   * - If modifying a channel of type {@link ChannelTypes}.GuildCategory:
+   *     - Fires a _Channel Update_ gateway event for each child channel impacted in this change.
+   * - Otherwise:
+   *     - Fires a _Channel Update_ gateway event.
+   */ async editChannel (rest, channelId, options, reason) {
+        return await rest.patch(rest.routes.channels.channel(channelId), {
+            body: options,
+            reason
+        });
+    },
+    /**
+   * Edits the permission overrides for a user or role in a channel.
+   *
+   * @param channelId - The ID of the channel to edit the permission overrides of.
+   * @param options - The permission override.
+   * @param {string} [reason] - An optional reason for the action, to be included in the audit log.
+   *
+   * @remarks
+   * Requires the `MANAGE_ROLES` permission.
+   *
+   * Only permissions the bot user has in the guild or parent channel can be allowed/denied __unless__ the bot user has a `MANAGE_ROLES` permission override in the channel.
+   *
+   * Fires a _Channel Update_ gateway event.
+   *
+   * @see {@link https://docs.discord.com/developers/resources/channel#edit-channel-permissions}
+   */ async editChannelPermissionOverrides (rest, channelId, options, reason) {
+        await rest.put(rest.routes.channels.overwrite(channelId, options.id), {
+            body: options,
+            reason
+        });
+    },
+    /**
+   * Edits the positions of a set of channels in a guild.
+   *
+   * @param guildId - The ID of the guild in which to edit the positions of the channels.
+   * @param channelPositions - A set of objects defining the updated positions of the channels.
+   *
+   * @remarks
+   * Requires the `MANAGE_CHANNELS` permission.
+   *
+   * Fires a _Channel Update_ gateway event for every channel impacted in this change.
+   *
+   * At most one entry per request may change `parent_id`. A request that changes `parent_id` for more than one channel fails with a 400 response and error code 40009.
+   *
+   * Permissions are checked per entry, based on what the entry changes:
+   * - An entry that only changes `position` requires the `MANAGE_CHANNELS` permission at the guild level (or on the channel's current parent category). It does **not** require access to the individual channel, so a full reordering may include channels the current user cannot view.
+   * - An entry that changes `parent_id` requires the `MANAGE_CHANNELS` permission on that channel and on the destination (the new parent category, or the guild when moving the channel out of a category), and the current user must be able to view the channel. Otherwise the request fails with a `403` response and error code 50001. Setting `lock_permissions` additionally requires `MANAGE_ROLES`.
+   *
+   * @see {@link https://docs.discord.com/developers/resources/guild#modify-guild-channel-positions}
+   */ async editChannelPositions (rest, guildId, channelPositions) {
+        await rest.patch(rest.routes.guilds.channels(guildId), {
+            body: channelPositions
+        });
+    },
+    /**
+   * Edits an emoji.
+   *
+   * @param guildId - The ID of the guild in which to edit the emoji.
+   * @param id - The ID of the emoji to edit.
+   * @param options - The parameters for the edit of the emoji.
+   * @param {string} [reason] - An optional reason for the action, to be included in the audit log.
+   * @returns An instance of the updated {@link DiscordEmoji}.
+   *
+   * @remarks
+   * For emojis created by the current user, requires either the `CREATE_GUILD_EXPRESSIONS` or `MANAGE_GUILD_EXPRESSIONS` permission.
+   * For other emojis, requires the `MANAGE_GUILD_EXPRESSIONS` permission.
+   *
+   * Fires a `Guild Emojis Update` gateway event.
+   *
+   * @see {@link https://docs.discord.com/developers/resources/emoji#modify-guild-emoji}
+   */ async editEmoji (rest, guildId, id, options, reason) {
+        return await rest.patch(rest.routes.guilds.emoji(guildId, id), {
+            body: options,
+            reason
+        });
+    },
+    /**
+   * Edits an application emoji.
+   *
+   * @param id - The ID of the emoji to edit.
+   * @param options - The parameters for the edit of the emoji.
+   * @returns An instance of the updated {@link DiscordEmoji}.
+   *
+   * @see {@link https://docs.discord.com/developers/resources/emoji#modify-application-emoji}
+   */ async editApplicationEmoji (rest, id, options) {
+        return await rest.patch(rest.routes.applicationEmoji(rest.applicationId, id), {
+            body: options
+        });
+    },
+    /**
+   * Edits a follow-up message to an interaction.
+   *
+   * @param token - The interaction token to use, provided in the original interaction.
+   * @param messageId - The ID of the message to edit.
+   * @param options - The parameters for the edit of the message.
+   * @returns An instance of the edited {@link DiscordMessage}.
+   *
+   * @remarks
+   * Unlike `editMessage()`, this endpoint allows the bot user to act without needing to see the channel the message is in.
+   *
+   * Does not support ephemeral follow-up messages due to these being stateless.
+   *
+   * Fires a _Message Update_ event.
+   *
+   * @see {@link https://docs.discord.com/developers/interactions/receiving-and-responding#edit-followup-message}
+   */ async editFollowupMessage (rest, token, messageId, options) {
+        return await rest.patch(rest.routes.interactions.responses.message(rest.applicationId, token, messageId), {
+            body: options,
+            files: options.files,
+            unauthorized: true
+        });
+    },
+    /**
+   * Edits a global application command.
+   *
+   * @param commandId - The ID of the command to edit.
+   * @param options - The parameters for the edit of the command.
+   * @returns An instance of the edited {@link DiscordApplicationCommand}.
+   *
+   * @see {@link https://docs.discord.com/developers/interactions/application-commands#edit-global-application-command}
+   */ async editGlobalApplicationCommand (rest, commandId, options) {
+        return await rest.patch(rest.routes.interactions.commands.command(rest.applicationId, commandId), {
+            body: options
+        });
+    },
+    /**
+   * Edits a guild's settings.
+   *
+   * @param guildId - The ID of the guild to edit.
+   * @param options - The parameters for the edit of the guild.
+   * @param {string} [reason] - An optional reason for the action, to be included in the audit log.
+   * @returns An instance of the edited {@link DiscordGuild}.
+   *
+   * @remarks
+   * Requires the `MANAGE_GUILD` permission.
+   *
+   * If attempting to add or remove the {@link GuildFeatures}.Community feature:
+   * - Requires the `ADMINISTRATOR` permission.
+   *
+   * Fires a _Guild Update_ gateway event.
+   *
+   * @see {@link https://docs.discord.com/developers/resources/guild#modify-guild}
+   */ async editGuild (rest, guildId, options, reason) {
+        return await rest.patch(rest.routes.guilds.guild(guildId), {
+            body: options,
+            reason
+        });
+    },
+    /**
+   * Edits an application command registered in a guild.
+   *
+   * @param guildId - The ID of the guild the command is registered in.
+   * @param commandId - The ID of the command to edit.
+   * @param options - The parameters for the edit of the command.
+   * @returns An instance of the edited {@link DiscordApplicationCommand}.
+   *
+   * @see {@link https://docs.discord.com/developers/interactions/application-commands#edit-guild-application-command}
+   */ async editGuildApplicationCommand (rest, commandId, guildId, options) {
+        return await rest.patch(rest.routes.interactions.commands.guilds.one(rest.applicationId, guildId, commandId), {
+            body: options
+        });
+    },
+    /**
+   * Edit the given sticker.
+   *
+   * @param guildId The ID of the guild to get
+   * @param {string} [reason] - An optional reason for the action, to be included in the audit log.
+   * @return A {@link DiscordSticker}
+   *
+   * @remarks
+   * For stickers created by the current user, requires either the `CREATE_GUILD_EXPRESSIONS` or `MANAGE_GUILD_EXPRESSIONS` permission.
+   * For other stickers, requires the `MANAGE_GUILD_EXPRESSIONS` permission.
+   * Fires a Guild Stickers Update Gateway event.
+   *
+   * @see {@link https://docs.discord.com/developers/resources/sticker#modify-guild-sticker}
+   */ async editGuildSticker (rest, guildId, stickerId, options, reason) {
+        return await rest.patch(rest.routes.guilds.sticker(guildId, stickerId), {
+            body: options,
+            reason
+        });
+    },
+    /**
+   * Edits a template's settings.
+   *
+   * @param guildId - The ID of the guild to edit a template of.
+   * @param templateCode - The code of the template to edit.
+   * @param options - The parameters for the edit of the template.
+   * @returns An instance of the edited {@link DiscordTemplate}.
+   *
+   * @remarks
+   * Requires the `MANAGE_GUILD` permission.
+   *
+   * Fires a _Guild Update_ gateway event.
+   *
+   * @see {@link https://docs.discord.com/developers/resources/guild-template#modify-guild-template}
+   */ async editGuildTemplate (rest, guildId, templateCode, options) {
+        return await rest.patch(rest.routes.guilds.templates.guild(guildId, templateCode), {
+            body: options
+        });
+    },
+    /**
+   * Edits a message.
+   *
+   * @param channelId - The ID of the channel to edit the message in.
+   * @param messageId - The IDs of the message to edit.
+   * @param options - The parameters for the edit of the message.
+   * @returns An instance of the edited {@link DiscordMessage}.
+   *
+   * @remarks
+   * If editing another user's message:
+   * - Requires the `MANAGE_MESSAGES` permission.
+   * - Only the {@link EditMessage.flags | flags} property of the options object parameter can be edited.
+   *
+   * Fires a _Message Update_ gateway event.
+   *
+   * @see {@link https://docs.discord.com/developers/resources/channel#edit-message}
+   */ async editMessage (rest, channelId, messageId, options) {
+        return await rest.patch(rest.routes.channels.message(channelId, messageId), {
+            body: options,
+            files: options.files
+        });
+    },
+    /**
+   * Edits the initial message response to an interaction.
+   *
+   * @param token - The interaction token to use, provided in the original interaction.
+   * @param options - The parameters for the edit of the response.
+   * @returns An instance of the edited {@link DiscordMessage}.
+   *
+   * @remarks
+   * Unlike `editMessage()`, this endpoint allows the bot user to act without needing to see the channel the message is in.
+   *
+   * Does not support ephemeral follow-up messages due to these being stateless.
+   *
+   * Fires a _Message Update_ event.
+   *
+   * @see {@link https://docs.discord.com/developers/interactions/receiving-and-responding#edit-original-interaction-response}
+   */ async editOriginalInteractionResponse (rest, token, options) {
+        return await rest.patch(rest.routes.interactions.responses.original(rest.applicationId, token), {
+            body: options,
+            files: options.files,
+            unauthorized: true
+        });
+    },
+    /**
+   * Edits the voice state of the bot user.
+   *
+   * @param guildId - The ID of the guild in which to edit the voice state of the bot user.
+   * @param options - The parameters for the edit of the voice state.
+   *
+   * @remarks
+   * The {@link EditOwnVoiceState.channelId | channelId} property of the options object parameter must point to a stage channel, and the bot user must already have joined it.
+   *
+   * If attempting to unmute oneself:
+   * - Requires the `MUTE_MEMBERS` permission.
+   *
+   * If attempting to request to speak:
+   * - Requires the `REQUEST_TO_SPEAK` permission.
+   *
+   * @see {@link https://docs.discord.com/developers/resources/voice#modify-current-user-voice-state}
+   */ async editOwnVoiceState (rest, guildId, options) {
+        await rest.patch(rest.routes.guilds.voice(guildId), {
+            body: {
+                ...options,
+                requestToSpeakTimestamp: options.requestToSpeakTimestamp ? new Date(options.requestToSpeakTimestamp).toISOString() : options.requestToSpeakTimestamp
+            }
+        });
+    },
+    /**
+   * Edits a role in a guild.
+   *
+   * @param guildId - The ID of the guild to edit the role in.
+   * @param roleId - The ID of the role to edit.
+   * @param options - The parameters for the edit of the role.
+   * @param {string} [reason] - An optional reason for the action, to be included in the audit log.
+   * @returns An instance of the edited {@link DiscordRole}.
+   *
+   * @remarks
+   * Requires the `MANAGE_ROLES` permission.
+   *
+   * Fires a _Guild Role Update_ gateway event.
+   *
+   * @see {@link https://docs.discord.com/developers/resources/guild#modify-guild-role}
+   */ async editRole (rest, guildId, roleId, options, reason) {
+        return await rest.patch(rest.routes.guilds.roles.one(guildId, roleId), {
+            body: options,
+            reason
+        });
+    },
+    /**
+   * Edits the positions of a set of roles.
+   *
+   * @param guildId - The ID of the guild to edit the role positions in.
+   * @param options - The parameters for the edit of the role positions.
+   * @param {string} [reason] - An optional reason for the action, to be included in the audit log.
+   * @returns A collection of {@link DiscordRole} objects assorted by role ID.
+   *
+   * @remarks
+   * Requires the `MANAGE_ROLES` permission.
+   *
+   * Fires a _Guild Role Update_ gateway event for every role impacted in this change.
+   *
+   * @see {@link https://docs.discord.com/developers/resources/guild#modify-guild-role-positions}
+   */ async editRolePositions (rest, guildId, options, reason) {
+        return await rest.patch(rest.routes.guilds.roles.all(guildId), {
+            body: options,
+            reason
+        });
+    },
+    /**
+   * Edits a scheduled event.
+   *
+   * @param guildId - The ID of the guild to edit the scheduled event in.
+   * @param eventId - The ID of the scheduled event to edit.
+   * @param {string} [reason] - An optional reason for the action, to be included in the audit log.
+   * @returns An instance of the edited {@link DiscordScheduledEvent}.
+   *
+   * @remarks
+   * Requires the `MANAGE_EVENTS` permission.
+   *
+   * To start or end an event, modify the event's `status` property.
+   *
+   * The `entity_metadata` property is discarded for events whose `entity_type` is not {@link ScheduledEventEntityType}.External.
+   *
+   * Fires a _Guild Scheduled Event Update_ gateway event.
+   *
+   * @see {@link https://docs.discord.com/developers/resources/guild-scheduled-event#modify-guild-scheduled-event}
+   */ async editScheduledEvent (rest, guildId, eventId, options, reason) {
+        return await rest.patch(rest.routes.guilds.events.event(guildId, eventId), {
+            body: options,
+            reason
+        });
+    },
+    /**
+   * Edits a stage instance.
+   *
+   * @param channelId - The ID of the stage channel the stage instance is associated with.
+   * @param topic - Topic of the Stage instance (1-120 characters).
+   * @param {string} [reason] - An optional reason for the action, to be included in the audit log.
+   * @returns An instance of the updated {@link DiscordStageInstance}.
+   *
+   * @remarks
+   * Requires the user to be a moderator of the stage channel.
+   *
+   * Fires a _Stage Instance Update_ event.
+   *
+   * @see {@link https://docs.discord.com/developers/resources/stage-instance#modify-stage-instance}
+   */ async editStageInstance (rest, channelId, topic, reason) {
+        return await rest.patch(rest.routes.channels.stage(channelId), {
+            body: {
+                topic
+            },
+            reason
+        });
+    },
+    /**
+   * Edits the voice state of another user.
+   *
+   * @param guildId - The ID of the guild in which to edit the voice state of the bot user.
+   * @param options - The parameters for the edit of the voice state.
+   *
+   * @remarks
+   * The {@link EditOwnVoiceState.channelId | channelId} property of the options object parameter must point to a stage channel, and the user must already have joined it.
+   *
+   * Requires the `MUTE_MEMBERS` permission.
+   *
+   * @see {@link https://docs.discord.com/developers/resources/voice#modify-user-voice-state}
+   */ async editUserVoiceState (rest, guildId, options) {
+        await rest.patch(rest.routes.guilds.voice(guildId, options.userId), {
+            body: options
+        });
+    },
+    /**
+   * Edit the current user application role connection for the application.
+   *
+   * @param bearerToken - The access token of the user
+   * @param applicationId - The id of the application to edit the role connection
+   * @param options - The options to edit
+   * @returns {DiscordApplicationRoleConnection}
+   *
+   * @remarks
+   * This requires the `role_connections.write` scope.
+   *
+   * @see {@link https://docs.discord.com/developers/resources/user#update-user-application-role-connection}
+   */ async editUserApplicationRoleConnection (rest, bearerToken, applicationId, options) {
+        return await rest.put(rest.routes.oauth2.roleConnections(applicationId), {
+            body: options,
+            headers: {
+                authorization: `Bearer ${bearerToken}`
+            },
+            unauthorized: true
+        });
+    },
+    /**
+   * Deletes the application role connection for the user.
+   *
+   * @param bearerToken - The access token of the user
+   * @param applicationId - The id of the application to delete the role connection
+   *
+   * @remarks
+   * This requires the `role_connections.write` scope.
+   *
+   * @see {@link https://docs.discord.com/developers/resources/user#delete-current-user-application-role-connection}
+   */ async deleteCurrentUserApplicationRoleConnection (rest, bearerToken, applicationId) {
+        return await rest.delete(rest.routes.oauth2.roleConnections(applicationId), {
+            headers: {
+                authorization: `Bearer ${bearerToken}`
+            },
+            unauthorized: true
+        });
+    },
+    /**
+   * Edits a webhook.
+   *
+   * @param webhookId - The ID of the webhook to edit.
+   * @param {string} [reason] - An optional reason for the action, to be included in the audit log.
+   * @returns An instance of the edited {@link DiscordWebhook}.
+   *
+   * @remarks
+   * Requires the `MANAGE_WEBHOOKS` permission.
+   *
+   * Fires a _Webhooks Update_ gateway event.
+   *
+   * @see {@link https://docs.discord.com/developers/resources/webhook#edit-webhook}
+   */ async editWebhook (rest, webhookId, options, reason) {
+        return await rest.patch(rest.routes.webhooks.id(webhookId), {
+            body: options,
+            reason
+        });
+    },
+    /**
+   * Edits a webhook message.
+   *
+   * @param webhookId - The ID of the webhook to edit the message of.
+   * @param token - The webhook token, used to edit the message.
+   * @param messageId - The ID of the message to edit.
+   * @param options - The parameters for the edit of the message.
+   * @returns An instance of the edited {@link DiscordMessage}.
+   *
+   * @remarks
+   * Fires a _Message Update_ gateway event.
+   *
+   * @see {@link https://docs.discord.com/developers/resources/webhook#edit-webhook-message}
+   */ async editWebhookMessage (rest, webhookId, token, messageId, options) {
+        return await rest.patch(rest.routes.webhooks.message(webhookId, token, messageId, options), {
+            body: options,
+            files: options.files,
+            unauthorized: true
+        });
+    },
+    /**
+   * Edits a webhook using the webhook token, thereby bypassing the need for authentication + permissions.
+   *
+   * @param webhookId - The ID of the webhook to edit.
+   * @param token - The webhook token, used to edit the webhook.
+   * @returns An instance of the edited {@link DiscordWebhook}.
+   *
+   * @remarks
+   * Requires the `MANAGE_WEBHOOKS` permission.
+   *
+   * Fires a _Webhooks Update_ gateway event.
+   *
+   * @see {@link https://docs.discord.com/developers/resources/webhook#modify-webhook-with-token}
+   */ async editWebhookWithToken (rest, webhookId, token, options) {
+        return await rest.patch(rest.routes.webhooks.webhook(webhookId, token), {
+            body: options,
+            unauthorized: true
+        });
+    },
+    /**
+   * Edits a guild's welcome screen.
+   *
+   * @param guildId - The ID of the guild to edit the welcome screen of.
+   * @param options - The parameters for the edit of the welcome screen.
+   * @param {string} [reason] - An optional reason for the action, to be included in the audit log.
+   * @returns An instance of the edited {@link DiscordWelcomeScreen}.
+   *
+   * @remarks
+   * Requires the `MANAGE_GUILD` permission.
+   *
+   * Fires a _Guild Update_ gateway event.
+   *
+   * @see {@link https://docs.discord.com/developers/resources/guild#modify-guild-welcome-screen}
+   */ async editWelcomeScreen (rest, guildId, options, reason) {
+        return await rest.patch(rest.routes.guilds.welcome(guildId), {
+            body: options,
+            reason
+        });
+    },
+    /**
+   * Edits the settings of a guild's widget.
+   *
+   * @param guildId - The ID of the guild to edit the settings of the widget of.
+   * @param {string} [reason] - An optional reason for the action, to be included in the audit log.
+   * @returns An instance of the edited {@link DiscordGuildWidgetSettings}.
+   *
+   * @remarks
+   * Requires the `MANAGE_GUILD` permission.
+   *
+   * Fires a _Guild Update_ gateway event.
+   *
+   * @see {@link https://docs.discord.com/developers/resources/guild#modify-guild-widget}
+   */ async editWidgetSettings (rest, guildId, options, reason) {
+        return await rest.patch(rest.routes.guilds.widget(guildId), {
+            body: options,
+            reason
+        });
+    },
+    /**
+   * Executes a webhook, causing a message to be posted in the channel configured for the webhook.
+   *
+   * @param webhookId - The ID of the webhook to execute.
+   * @param token - The webhook token, used to execute the webhook.
+   * @param options - The parameters for the execution of the webhook.
+   * @returns An instance of the created {@link DiscordMessage}, or `undefined` if the {@link ExecuteWebhook.wait | wait} property of the options object parameter is set to `false`.
+   *
+   * @remarks
+   * If the webhook channel is a forum channel, you must provide a value for either `threadId` or `threadName`.
+   *
+   * @see {@link https://docs.discord.com/developers/resources/webhook#execute-webhook}
+   */ async executeWebhook (rest, webhookId, token, options) {
+        return await rest.post(rest.routes.webhooks.webhook(webhookId, token, options), {
+            body: options,
+            unauthorized: true
+        });
+    },
+    /**
+   * Follows an announcement channel, allowing messages posted within it to be cross-posted into the target channel.
+   *
+   * @param sourceChannelId - The ID of the announcement channel to follow.
+   * @param targetChannelId - The ID of the target channel - the channel to cross-post to.
+   * @param {string} [reason] - An optional reason for the action, to be included in the audit log.
+   * @returns An instance of {@link DiscordFollowedChannel}.
+   *
+   * @remarks
+   * Requires the `MANAGE_WEBHOOKS` permission in the __target channel__.
+   *
+   * Fires a _Webhooks Update_ gateway event.
+   *
+   * @see {@link https://docs.discord.com/developers/resources/channel#follow-announcement-channel}
+   */ async followAnnouncement (rest, sourceChannelId, targetChannelId, reason) {
+        return await rest.post(rest.routes.channels.follow(sourceChannelId), {
+            body: {
+                webhookChannelId: targetChannelId
+            },
+            reason
+        });
+    },
+    /**
+   * Gets the list of all active threads for a guild.
+   *
+   * @param guildId - The ID of the guild to get the threads of.
+   * @returns An instance of {@link DiscordListActiveThreads}.
+   *
+   * @remarks
+   * Returns both public and private threads.
+   *
+   * Threads are ordered by the `id` property in descending order.
+   *
+   * @see {@link https://docs.discord.com/developers/resources/guild#list-active-guild-threads}
+   */ async getActiveThreads (rest, guildId) {
+        return await rest.get(rest.routes.channels.threads.active(guildId));
+    },
+    /** Get the applications info */ async getApplicationInfo (rest) {
+        return await rest.get(rest.routes.oauth2.application());
+    },
+    /**
+   * Edit properties of the app associated with the requesting bot user.
+   *
+   * @remarks
+   * Only properties that are passed will be updated.
+   */ async editApplicationInfo (rest, body) {
+        return await rest.patch(rest.routes.application(), {
+            body
+        });
+    },
+    /**
+   * Get the current authentication info for the authenticated user
+   *
+   * @param bearerToken - Any OAuth2 derived access token
+   * @returns An instance of {@link DiscordCurrentAuthorization}
+   *
+   * @remarks
+   * The user object is not defined if the scopes do not include `identify`.
+   * In the user object, if defined, the email is not included if the scopes do not include `email`
+   */ async getCurrentAuthenticationInfo (rest, bearerToken) {
+        return await rest.get(rest.routes.oauth2.currentAuthorization(), {
+            headers: {
+                authorization: `Bearer ${bearerToken}`
+            },
+            unauthorized: true
+        });
+    },
+    /**
+   * Exchange the information to get a OAuth2 accessToken token
+   *
+   * @param clientId - Application's client id
+   * @param clientSecret - application's client secret
+   * @param options - The options to make the exchange with discord
+   */ async exchangeToken (rest, clientId, clientSecret, options) {
+        const basicCredentials = Buffer.from(`${clientId}:${clientSecret}`);
+        const restOptions = {
+            body: options,
+            headers: {
+                'content-type': 'application/x-www-form-urlencoded',
+                authorization: `Basic ${basicCredentials.toString('base64')}`
+            },
+            runThroughQueue: false,
+            unauthorized: true
+        };
+        if (options.grantType === 'client_credentials') {
+            restOptions.body.scope = options.scope.join(' ');
+        }
+        return await rest.post(rest.routes.oauth2.tokenExchange(), restOptions);
+    },
+    /**
+   * Revoke an access_token
+   *
+   * @param clientId - Application's client id
+   * @param clientSecret - application's client secret
+   * @param options - The options to revoke the access_token
+   */ async revokeToken (rest, clientId, clientSecret, options) {
+        const basicCredentials = Buffer.from(`${clientId}:${clientSecret}`);
+        await rest.post(rest.routes.oauth2.tokenRevoke(), {
+            body: options,
+            headers: {
+                'content-type': 'application/x-www-form-urlencoded',
+                authorization: `Basic ${basicCredentials.toString('base64')}`
+            },
+            unauthorized: true
+        });
+    },
+    /**
+   * Gets the permissions of a guild application command.
+   *
+   * @param guildId - The ID of the guild the command is registered in.
+   * @param commandId - The ID of the command to get the permissions of.
+   * @param options - The OAuth2 related optional parameters for the endpoint
+   * @returns An instance of {@link DiscordGuildApplicationCommandPermissions}.
+   *
+   * @remarks
+   * Then specifying the options object the access token passed-in requires the OAuth2 scope `applications.commands.permissions.update`
+   *
+   * @see {@link https://docs.discord.com/developers/interactions/application-commands#get-application-command-permissions}
+   */ async getApplicationCommandPermission (rest, guildId, commandId, options) {
+        const restOptions = {};
+        if (options?.accessToken) {
+            restOptions.unauthorized = true;
+            restOptions.headers = {
+                authorization: `Bearer ${options.accessToken}`
+            };
+        }
+        return await rest.get(rest.routes.interactions.commands.permission(options?.applicationId ?? rest.applicationId, guildId, commandId), restOptions);
+    },
+    /**
+   * Gets the permissions of all application commands registered in a guild by the ID of the guild and optionally an external application.
+   *
+   * @param guildId - The ID of the guild to get the permissions objects of.
+   * @param options - The OAuth2 related optional parameters for the endpoint
+   * @returns A collection of {@link DiscordGuildApplicationCommandPermissions} objects assorted by command ID.
+   *
+   * @remarks
+   * Then specifying the options object the access token passed-in requires the OAuth2 scope `applications.commands.permissions.update`
+   *
+   * @see {@link https://docs.discord.com/developers/interactions/application-commands#get-guild-application-command-permissions}
+   */ async getApplicationCommandPermissions (rest, guildId, options) {
+        const restOptions = {};
+        if (options?.accessToken) {
+            restOptions.unauthorized = true;
+            restOptions.headers = {
+                authorization: `Bearer ${options.accessToken}`
+            };
+        }
+        return await rest.get(rest.routes.interactions.commands.permissions(options?.applicationId ?? rest.applicationId, guildId), restOptions);
+    },
+    /**
+   * Gets a guild's audit log.
+   *
+   * @param guildId - The ID of the guild to get the audit log of.
+   * @param options - The parameters for the fetching of the audit log.
+   * @returns An instance of {@link DiscordAuditLog}.
+   *
+   * @remarks
+   * Requires the `VIEW_AUDIT_LOG` permission.
+   *
+   * @see {@link https://docs.discord.com/developers/resources/audit-log#get-guild-audit-log}
+   */ async getAuditLog (rest, guildId, options) {
+        return await rest.get(rest.routes.guilds.auditlogs(guildId, options));
+    },
+    /**
+   * Gets an automod rule by its ID.
+   *
+   * @param guildId - The ID of the guild to get the rule of.
+   * @param ruleId - The ID of the rule to get.
+   * @returns An instance of {@link DiscordAutoModerationRule}.
+   *
+   * @remarks
+   * Requires the `MANAGE_GUILD` permission.
+   *
+   * @see {@link https://docs.discord.com/developers/resources/auto-moderation#get-auto-moderation-rule}
+   */ async getAutomodRule (rest, guildId, ruleId) {
+        return await rest.get(rest.routes.guilds.automod.rule(guildId, ruleId));
+    },
+    /**
+   * Gets the list of automod rules for a guild.
+   *
+   * @param guildId - The ID of the guild to get the rules from.
+   * @returns A collection of {@link DiscordAutoModerationRule} objects assorted by rule ID.
+   *
+   * @remarks
+   * Requires the `MANAGE_GUILD` permission.
+   *
+   * @see {@link https://docs.discord.com/developers/resources/auto-moderation#list-auto-moderation-rules-for-guild}
+   */ async getAutomodRules (rest, guildId) {
+        return await rest.get(rest.routes.guilds.automod.rules(guildId));
+    },
+    /**
+   * Gets the list of available voice regions.
+   *
+   * @returns A collection of {@link DiscordVoiceRegion} objects assorted by voice region ID.
+   */ async getAvailableVoiceRegions (rest) {
+        return await rest.get(rest.routes.regions());
+    },
+    /**
+   * Gets a ban by user ID.
+   *
+   * @param guildId - The ID of the guild to get the ban from.
+   * @param userId - The ID of the user to get the ban for.
+   * @returns An instance of {@link DiscordBan}.
+   *
+   * @remarks
+   * Requires the `BAN_MEMBERS` permission.
+   *
+   * @see {@link https://docs.discord.com/developers/resources/guild#get-guild-ban}
+   */ async getBan (rest, guildId, userId) {
+        return await rest.get(rest.routes.guilds.members.ban(guildId, userId));
+    },
+    /**
+   * Gets the list of bans for a guild.
+   *
+   * @param guildId - The ID of the guild to get the list of bans for.
+   * @param options - The parameters for the fetching of the list of bans.
+   * @returns A collection of {@link DiscordBan} objects assorted by user ID.
+   *
+   * @remarks
+   * Requires the `BAN_MEMBERS` permission.
+   *
+   * Users are ordered by their IDs in _ascending_ order.
+   *
+   * @see {@link https://docs.discord.com/developers/resources/guild#get-guild-bans}
+   */ async getBans (rest, guildId, options) {
+        return await rest.get(rest.routes.guilds.members.bans(guildId, options));
+    },
+    /**
+   * Gets a channel by its ID.
+   *
+   * @param channelId - The ID of the channel to get.
+   * @returns An instance of {@link DiscordChannel}.
+   *
+   * @remarks
+   * If the channel is a thread, a {@link DiscordThreadMember} object is included in the result.
+   *
+   * @see {@link https://docs.discord.com/developers/resources/channel#get-channel}
+   */ async getChannel (rest, channelId) {
+        return await rest.get(rest.routes.channels.channel(channelId));
+    },
+    /**
+   * Gets the list of invites for a channel.
+   *
+   * @param channelId - The ID of the channel to get the invites of.
+   * @returns A collection of {@link DiscordInviteMetadata} objects assorted by invite code.
+   *
+   * @remarks
+   * Requires the `MANAGE_CHANNELS` permission.
+   *
+   * Only usable for guild channels.
+   *
+   * @see {@link https://docs.discord.com/developers/resources/channel#get-channel-invites}
+   */ async getChannelInvites (rest, channelId) {
+        return await rest.get(rest.routes.channels.invites(channelId));
+    },
+    /**
+   * Gets the list of channels for a guild.
+   *
+   * @param guildId - The ID of the guild to get the channels of.
+   * @returns A collection of {@link DiscordChannel} objects assorted by channel ID.
+   *
+   * @remarks
+   * Excludes threads.
+   *
+   * @see {@link https://docs.discord.com/developers/resources/guild#get-guild-channels}
+   */ async getChannels (rest, guildId) {
+        return await rest.get(rest.routes.guilds.channels(guildId));
+    },
+    /**
+   * Gets a list of webhooks for a channel.
+   *
+   * @param channelId - The ID of the channel which to get the webhooks of.
+   * @returns A collection of {@link DiscordWebhook} objects assorted by webhook ID.
+   *
+   * @remarks
+   * Requires the `MANAGE_WEBHOOKS` permission.
+   *
+   * @see {@link https://docs.discord.com/developers/resources/webhook#get-channel-webhooks}
+   */ async getChannelWebhooks (rest, channelId) {
+        return await rest.get(rest.routes.channels.webhooks(channelId));
+    },
+    /**
+   * Gets or creates a DM channel with a user.
+   *
+   * @param userId - The ID of the user to create the DM channel with.
+   * @returns An instance of {@link DiscordChannel}.
+   *
+   * @see {@link https://docs.discord.com/developers/resources/user#create-dm}
+   */ async getDmChannel (rest, userId) {
+        return await rest.post(rest.routes.channels.dm(), {
+            body: {
+                recipientId: userId
+            }
+        });
+    },
+    /**
+   * Create a new group DM channel with multiple users.
+   *
+   * @param options - The options for create a new group dm
+   * @returns An instance of {@link DiscordChannel}.
+   *
+   * @remarks
+   * The access tokens require to have the `gdm.join` scope
+   *
+   * This endpoint is limited to 10 active group DMs.
+   *
+   * Fires a _Channel create_ gateway event.
+   *
+   * @see {@link https://docs.discord.com/developers/resources/user#create-group-dm}
+   */ async getGroupDmChannel (rest, options) {
+        return await rest.post(rest.routes.channels.dm(), {
+            body: options
+        });
+    },
+    /**
+   * Gets an emoji by its ID.
+   *
+   * @param guildId - The ID of the guild from which to get the emoji.
+   * @param emojiId - The ID of the emoji to get.
+   * @returns An instance of {@link DiscordEmoji}.
+   *
+   * @remarks
+   * Includes the `user` field if the bot has the `MANAGE_GUILD_EXPRESSIONS` permission,
+   * or if the bot created the emoji and has the `CREATE_GUILD_EXPRESSIONS` permission.
+   *
+   * @see {@link https://docs.discord.com/developers/resources/emoji#get-guild-emoji}
+   */ async getEmoji (rest, guildId, emojiId) {
+        return await rest.get(rest.routes.guilds.emoji(guildId, emojiId));
+    },
+    /**
+   * Gets an application emoji by its ID.
+   *
+   * @param emojiId - The ID of the emoji to get.
+   * @returns An instance of {@link DiscordEmoji}.
+   *
+   * @remarks
+   * Always includes the `user` object for the team member that uploaded the emoji from the app's settings, or for the bot user if uploaded using the API.
+   *
+   * @see {@link https://docs.discord.com/developers/resources/emoji#get-application-emoji}
+   */ async getApplicationEmoji (rest, emojiId) {
+        return await rest.get(rest.routes.applicationEmoji(rest.applicationId, emojiId));
+    },
+    /**
+   * Gets the list of emojis for a guild.
+   *
+   * @param guildId - The ID of the guild which to get the emojis of.
+   * @returns A collection of {@link DiscordEmoji} objects assorted by emoji ID.
+   *
+   * @remarks
+   * Includes `user` fields if the bot has the `CREATE_GUILD_EXPRESSIONS` or `MANAGE_GUILD_EXPRESSIONS` permission.
+   *
+   * @see {@link https://docs.discord.com/developers/resources/emoji#list-guild-emojis}
+   */ async getEmojis (rest, guildId) {
+        return await rest.get(rest.routes.guilds.emojis(guildId));
+    },
+    /**
+   * Gets the list of emojis for an application.
+   *
+   * @returns An object with the array of {@link DiscordEmoji} objects.
+   *
+   * @remarks
+   * Always includes the `user` object for the team member that uploaded the emoji from the app's settings, or for the bot user if uploaded using the API.
+   *
+   * @see {@link https://docs.discord.com/developers/resources/emoji#list-application-emojis}
+   */ async getApplicationEmojis (rest) {
+        return await rest.get(rest.routes.applicationEmojis(rest.applicationId));
+    },
+    /**
+   * Gets a follow-up message to an interaction by the ID of the message.
+   *
+   * @param token - The interaction token to use, provided in the original interaction.
+   * @param messageId - The ID of the message to get.
+   * @returns An instance of {@link DiscordMessage}.
+   *
+   * @remarks
+   * Unlike `getMessage()`, this endpoint allows the bot user to act without:
+   * - Needing to be able to see the contents of the channel that the message is in. (`READ_MESSAGES` permission.)
+   * - Requiring the `MESSAGE_CONTENT` intent.
+   *
+   * Does not support ephemeral follow-up messages due to these being stateless.
+   *
+   * @see {@link https://docs.discord.com/developers/interactions/receiving-and-responding#get-followup-message}
+   */ async getFollowupMessage (rest, token, messageId) {
+        return await rest.get(rest.routes.interactions.responses.message(rest.applicationId, token, messageId), {
+            unauthorized: true
+        });
+    },
+    /** Get the bots Gateway metadata that can help during the operation of large or sharded bots. */ async getGatewayBot (rest) {
+        return await rest.get(rest.routes.gatewayBot());
+    },
+    /**
+   * Gets a global application command by its ID.
+   *
+   * @param commandId - The ID of the command to get.
+   * @returns An instance of {@link DiscordApplicationCommand}.
+   *
+   * @see {@link https://docs.discord.com/developers/interactions/application-commands#get-global-application-command}
+   */ async getGlobalApplicationCommand (rest, commandId) {
+        return await rest.get(rest.routes.interactions.commands.command(rest.applicationId, commandId));
+    },
+    /**
+   * Gets the list of your bot's global application commands.
+   *
+   * @param options - The parameters for the fetching of global application commands
+   * @returns A collection of {@link DiscordApplicationCommand} objects assorted by command ID.
+   *
+   * @see {@link https://docs.discord.com/developers/interactions/application-commands#get-global-application-commands}
+   */ async getGlobalApplicationCommands (rest, options) {
+        return await rest.get(rest.routes.interactions.commands.commands(rest.applicationId, options?.withLocalizations));
+    },
+    /**
+   * Gets a guild by its ID.
+   *
+   * @param guildId - The ID of the guild to get.
+   * @param options - The parameters for the fetching of the guild.
+   * @returns An instance of {@link DiscordGuild}.
+   *
+   * @see {@link https://docs.discord.com/developers/resources/guild#get-guild}
+   */ async getGuild (rest, guildId, options) {
+        options ??= {
+            counts: true
+        };
+        return await rest.get(rest.routes.guilds.guild(guildId, options.counts));
+    },
+    /**
+   * Get the user guilds.
+   *
+   * @param bearerToken - The access token of the user, if unspecified the bot token is used instead
+   * @param options - The parameters for the fetching of the guild.
+   * @returns An array of partial {@link DiscordGuild}.
+   *
+   * @remarks
+   * If used with an access token, the token needs to have the `guilds` scope
+   *
+   * @see {@link https://docs.discord.com/developers/resources/user#get-current-user-guilds}
+   */ async getGuilds (rest, bearerToken, options) {
+        const makeRequestOptions = bearerToken ? {
+            headers: {
+                authorization: `Bearer ${bearerToken}`
+            },
+            unauthorized: true
+        } : undefined;
+        return await rest.get(rest.routes.guilds.userGuilds(options), makeRequestOptions);
+    },
+    /**
+   * Gets a guild application command by its ID.
+   *
+   * @param guildId - The ID of the guild the command is registered in.
+   * @param commandId - The ID of the command to get.
+   * @returns An instance of {@link DiscordApplicationCommand}.
+   *
+   * @see {@link https://docs.discord.com/developers/interactions/application-commands#get-guild-application-command}
+   */ async getGuildApplicationCommand (rest, commandId, guildId) {
+        return await rest.get(rest.routes.interactions.commands.guilds.one(rest.applicationId, guildId, commandId));
+    },
+    /**
+   * Gets the list of application commands registered by your bot in a guild.
+   *
+   * @param guildId - The ID of the guild the commands are registered in.
+   * @param options - The parameters for the fetching of guild application commands
+   * @returns A collection of {@link DiscordApplicationCommand} objects assorted by command ID.
+   *
+   * @see {@link https://docs.discord.com/developers/interactions/application-commands#get-global-application-commandss}
+   */ async getGuildApplicationCommands (rest, guildId, options) {
+        return await rest.get(rest.routes.interactions.commands.guilds.all(rest.applicationId, guildId, options?.withLocalizations));
+    },
+    /**
+   * Gets the preview of a guild by a guild's ID.
+   *
+   * @param guildId - The ID of the guild to get the preview of.
+   * @returns An instance of {@link DiscordGuildPreview}.
+   *
+   * @remarks
+   * If the bot user is not in the guild, the guild must be discoverable.
+   *
+   * @see {@link https://docs.discord.com/developers/resources/guild#get-guild-preview}
+   */ async getGuildPreview (rest, guildId) {
+        return await rest.get(rest.routes.guilds.preview(guildId));
+    },
+    /**
+   * Returns a sticker object for the given guild and sticker IDs.
+   *
+   * @param guildId The ID of the guild to get
+   * @param stickerId The ID of the sticker to get
+   * @return A {@link DiscordSticker}
+   *
+   * @remarks Includes the user field if the bot has the `CREATE_GUILD_EXPRESSIONS` or `MANAGE_GUILD_EXPRESSIONS` permission.
+   *
+   * @see {@link https://docs.discord.com/developers/resources/sticker#get-guild-sticker}
+   */ async getGuildSticker (rest, guildId, stickerId) {
+        return await rest.get(rest.routes.guilds.sticker(guildId, stickerId));
+    },
+    /**
+   * Returns an array of sticker objects for the given guild.
+   *
+   * @param guildId The ID of the guild to get
+   * @returns A collection of {@link DiscordSticker} objects assorted by sticker ID.
+   *
+   * @remarks Includes user fields if the bot has the `CREATE_GUILD_EXPRESSIONS` or `MANAGE_GUILD_EXPRESSIONS` permission.
+   *
+   * @see {@link https://docs.discord.com/developers/resources/sticker#list-guild-stickers}
+   */ async getGuildStickers (rest, guildId) {
+        return await rest.get(rest.routes.guilds.stickers(guildId));
+    },
+    /**
+   * Gets a template by its code.
+   *
+   * @param templateCode - The code of the template to get.
+   * @returns An instance of {@link DiscordTemplate}.
+   *
+   * @remarks
+   * Requires the `MANAGE_GUILD` permission.
+   *
+   * @see {@link https://docs.discord.com/developers/resources/guild-template#get-guild-template}
+   */ async getGuildTemplate (rest, templateCode) {
+        return await rest.get(rest.routes.guilds.templates.code(templateCode));
+    },
+    /**
+   * Gets the list of templates for a guild.
+   *
+   * @param guildId - The ID of the guild to get the list of templates for.
+   * @returns A collection of {@link DiscordTemplate} objects assorted by template code.
+   *
+   * @remarks
+   * Requires the `MANAGE_GUILD` permission.
+   *
+   * @see {@link https://docs.discord.com/developers/resources/guild-template#get-guild-templates}
+   */ async getGuildTemplates (rest, guildId) {
+        return await rest.get(rest.routes.guilds.templates.all(guildId));
+    },
+    /**
+   * Gets the list of webhooks for a guild.
+   *
+   * @param guildId - The ID of the guild to get the list of webhooks for.
+   * @returns A collection of {@link DiscordWebhook} objects assorted by webhook ID.
+   *
+   * @remarks
+   * Requires the `MANAGE_WEBHOOKS` permission.
+   *
+   * @see {@link https://docs.discord.com/developers/resources/webhook#get-guild-webhooks}
+   */ async getGuildWebhooks (rest, guildId) {
+        return await rest.get(rest.routes.guilds.webhooks(guildId));
+    },
+    /**
+   * Gets the list of integrations attached to a guild.
+   *
+   * @param guildId - The ID of the guild to get the list of integrations from.
+   * @returns A collection of {@link DiscordIntegration} objects assorted by integration ID.
+   *
+   * @remarks
+   * Requires the `MANAGE_GUILD` permission.
+   *
+   * @see {@link https://docs.discord.com/developers/resources/guild#get-guild-integrations}
+   */ async getIntegrations (rest, guildId) {
+        return await rest.get(rest.routes.guilds.integrations(guildId));
+    },
+    /**
+   * Gets an invite to a channel by its invite code.
+   *
+   * @param inviteCode - The invite code of the invite to get.
+   * @param options - The parameters for the fetching of the invite.
+   * @returns An instance of {@link DiscordInviteMetadata}.
+   *
+   * @see {@link https://docs.discord.com/developers/resources/invite#get-invite}
+   */ async getInvite (rest, inviteCode, options) {
+        return await rest.get(rest.routes.guilds.invite(inviteCode, options));
+    },
+    /**
+   * Gets the list of invites for a guild.
+   *
+   * @param guildId - The ID of the guild to get the invites from.
+   * @returns A collection of {@link DiscordInviteMetadata} objects assorted by invite code.
+   *
+   * @remarks
+   * Requires the `MANAGE_GUILD` or `VIEW_AUDIT_LOG` permission.
+   *
+   * @see {@link https://docs.discord.com/developers/resources/invite#get-invites}
+   */ async getInvites (rest, guildId) {
+        return await rest.get(rest.routes.guilds.invites(guildId));
+    },
+    /**
+   * Gets a message from a channel by the ID of the message.
+   *
+   * @param channelId - The ID of the channel from which to get the message.
+   * @param messageId - The ID of the message to get.
+   * @returns An instance of {@link DiscordMessage}.
+   *
+   * @remarks
+   * Requires that the bot user be able to see the contents of the channel in which the message was posted.
+   *
+   * If getting a message from a guild channel:
+   * - Requires the `READ_MESSAGE_HISTORY` permission.
+   *
+   * @see {@link https://docs.discord.com/developers/resources/channel#get-channel-message}
+   */ async getMessage (rest, channelId, messageId) {
+        return await rest.get(rest.routes.channels.message(channelId, messageId));
+    },
+    /**
+   * Gets multiple messages from a channel.
+   *
+   * @param channelId - The ID of the channel from which to get the messages.
+   * @param options - The parameters for the fetching of the messages.
+   * @returns Returns an array of {@link DiscordMessage} objects from newest to oldest on success.
+   *
+   * @remarks
+   * Requires that the bot user be able to see the contents of the channel in which the messages were posted.
+   *
+   * If getting a messages from a guild channel:
+   * - Requires the `READ_MESSAGE_HISTORY` permission.
+   *
+   * @see {@link https://docs.discord.com/developers/resources/channel#get-channel-messages}
+   */ async getMessages (rest, channelId, options) {
+        return await rest.get(rest.routes.channels.messages(channelId, options));
+    },
+    /**
+   * Search messages in a guild.
+   *
+   * @remarks
+   * Requires `READ_MESSAGE_HISTORY` and is restricted by the `MESSAGE_CONTENT` intent.
+   *
+   * @see {@link https://docs.discord.com/developers/resources/message#search-guild-messages}
+   */ async searchGuildMessages (rest, guildId, options) {
+        return await rest.get(rest.routes.guilds.messagesSearch(guildId, options));
+    },
+    /**
+   * Returns a sticker pack for the given ID.
+   *
+   * @returns A {@link DiscordStickerPack} object.
+   *
+   * @see {@link https://docs.discord.com/developers/resources/sticker#get-sticker-pack}
+   */ async getStickerPack (rest, stickerPackId) {
+        return await rest.get(rest.routes.stickerPack(stickerPackId));
+    },
+    /**
+   * Returns the list of sticker packs available.
+   *
+   * @returns A collection of {@link DiscordStickerPack} objects assorted by sticker ID.
+   *
+   * @see {@link https://docs.discord.com/developers/resources/sticker#list-sticker-packs}
+   */ async getStickerPacks (rest) {
+        return await rest.get(rest.routes.stickerPacks());
+    },
+    /**
+   * Gets the initial message response to an interaction.
+   *
+   * @param token - The interaction token to use, provided in the original interaction.
+   * @returns An instance of {@link DiscordMessage}.
+   *
+   * @remarks
+   * Unlike `getMessage()`, this endpoint allows the bot user to act without:
+   * - Needing to be able to see the contents of the channel that the message is in. (`READ_MESSAGES` permission.)
+   * - Requiring the `MESSAGE_CONTENT` intent.
+   *
+   * Does not support ephemeral follow-up messages due to these being stateless.
+   *
+   * @see {@link https://docs.discord.com/developers/interactions/receiving-and-responding#get-original-interaction-response}
+   */ async getOriginalInteractionResponse (rest, token) {
+        return await rest.get(rest.routes.interactions.responses.original(rest.applicationId, token), {
+            unauthorized: true
+        });
+    },
+    /**
+   * Retrieves the list of pins in a channel.
+   *
+   * @param channelId - The ID of the channel to get the pins for.
+   * @param options - The options for the fetching of the pins.
+   * @returns A {@link DiscordGetChannelPins} objects
+   *
+   * @remarks
+   * Requires the `VIEW_CHANNEL` permission.
+   *
+   * If the user is missing the `READ_MESSAGE_HISTORY` permission in the channel, then no pins will be returned.
+   *
+   * @see {@link https://docs.discord.com/developers/resources/message#get-channel-pins}
+   */ async getChannelPins (rest, channelId, options) {
+        return await rest.get(rest.routes.channels.messagePins(channelId, options));
+    },
+    /**
+   * Gets the pinned messages for a channel.
+   *
+   * @param channelId - The ID of the channel to get the pinned messages for.
+   * @returns A collection of {@link DiscordMessage} objects assorted by message ID.
+   *
+   * @remarks
+   * Requires that the bot user be able to see the contents of the channel in which the messages were posted.
+   *
+   * If getting a message from a guild channel:
+   * - Requires the `READ_MESSAGE_HISTORY` permission.
+   *
+   * @see {@link https://docs.discord.com/developers/resources/message#get-pinned-messages-deprecated}
+   * @deprecated Use {@link getChannelPins} instead.
+   */ async getPinnedMessages (rest, channelId) {
+        return await rest.get(rest.routes.channels.pins(channelId));
+    },
+    /**
+   * Gets the list of private archived threads for a channel.
+   *
+   * @param channelId - The ID of the channel to get the archived threads for.
+   * @param options - The parameters for the fetching of threads.
+   * @returns An instance of {@link DiscordListArchivedThreads}.
+   *
+   * @remarks
+   * Requires the `READ_MESSAGE_HISTORY` permission.
+   * Requires the `MANAGE_THREADS` permission.
+   *
+   * Returns threads of type {@link ChannelTypes}.GuildPrivateThread.
+   *
+   * Threads are ordered by the `archive_timestamp` property included in the metadata of the object in descending order.
+   *
+   * @see {@link https://docs.discord.com/developers/resources/channel#list-private-archived-threads}
+   */ async getPrivateArchivedThreads (rest, channelId, options) {
+        return await rest.get(rest.routes.channels.threads.private(channelId, options));
+    },
+    /**
+   * Gets the list of private archived threads the bot is a member of for a channel.
+   *
+   * @param channelId - The ID of the channel to get the archived threads for.
+   * @param options - The parameters for the fetching of threads.
+   * @returns An instance of {@link DiscordListArchivedThreads}.
+   *
+   * @remarks
+   * Requires the `READ_MESSAGE_HISTORY` permission.
+   *
+   * Returns threads of type {@link ChannelTypes}.GuildPrivateThread.
+   *
+   * Threads are ordered by the `id` property in descending order.
+   *
+   * @see {@link https://docs.discord.com/developers/resources/channel#list-joined-private-archived-threads}
+   */ async getPrivateJoinedArchivedThreads (rest, channelId, options) {
+        return await rest.get(rest.routes.channels.threads.joined(channelId, options));
+    },
+    /**
+   * Gets the number of members that would be kicked from a guild during pruning.
+   *
+   * @param guildId - The ID of the guild to get the prune count of.
+   * @param options - The parameters for the fetching of the prune count.
+   * @returns A number indicating the number of members that would be kicked.
+   *
+   * @remarks
+   * Requires the `MANAGE_GUILD` and `KICK_MEMBERS` permissions, unless the guild has the `PRUNE_REQUIRES_ADMIN` guild feature, in which case it requires the `ADMINISTRATOR` permission.
+   *
+   * @see {@link https://docs.discord.com/developers/resources/guild#get-guild-prune-count}
+   */ async getPruneCount (rest, guildId, options) {
+        return await rest.get(rest.routes.guilds.prune(guildId, options));
+    },
+    /**
+   * Gets the list of public archived threads for a channel.
+   *
+   * @param channelId - The ID of the channel to get the archived threads for.
+   * @param options - The parameters for the fetching of threads.
+   * @returns An instance of {@link DiscordListArchivedThreads}.
+   *
+   * @remarks
+   * Requires the `READ_MESSAGE_HISTORY` permission.
+   *
+   * If called on a channel of type {@link ChannelTypes}.GuildText, returns threads of type {@link ChannelTypes}.GuildPublicThread.
+   * If called on a channel of type {@link ChannelTypes}.GuildNews, returns threads of type {@link ChannelTypes}.GuildNewsThread.
+   *
+   * Threads are ordered by the `archive_timestamp` property included in the metadata of the object in descending order.
+   *
+   * @see {@link https://docs.discord.com/developers/resources/channel#list-public-archived-threads}
+   */ async getPublicArchivedThreads (rest, channelId, options) {
+        return await rest.get(rest.routes.channels.threads.public(channelId, options));
+    },
+    /**
+   * Gets the list of roles for a guild.
+   *
+   * @param guildId - The ID of the guild to get the list of roles for.
+   * @returns A collection of {@link DiscordRole} objects assorted by role ID.
+   *
+   * @remarks
+   * ⚠️ This endpoint should be used sparingly due to {@link DiscordRole} objects already being included in guild payloads.
+   *
+   * @see {@link https://docs.discord.com/developers/resources/guild#get-guild-roles}
+   */ async getRoles (rest, guildId) {
+        return await rest.get(rest.routes.guilds.roles.all(guildId));
+    },
+    /**
+   * Gets a role by id for a guild.
+   *
+   * @param guildId - The ID of the guild to get role for.
+   * @param roleId - The ID of the role.
+   * @returns A {@link DiscordRole} object.
+   *
+   * @see {@link https://docs.discord.com/developers/resources/guild#get-guild-role}
+   */ async getRole (rest, guildId, roleId) {
+        return await rest.get(rest.routes.guilds.roles.one(guildId, roleId));
+    },
+    /**
+   * Gets a scheduled event by its ID.
+   *
+   * @param guildId - The ID of the guild to get the scheduled event from.
+   * @param eventId - The ID of the scheduled event to get.
+   * @param options - The parameters for the fetching of the scheduled event.
+   * @returns An instance of {@link DiscordScheduledEvent}.
+   *
+   * @see {@link https://docs.discord.com/developers/resources/guild-scheduled-event#get-guild-scheduled-event}
+   */ async getScheduledEvent (rest, guildId, eventId, options) {
+        return await rest.get(rest.routes.guilds.events.event(guildId, eventId, options?.withUserCount));
+    },
+    /**
+   * Gets the list of scheduled events for a guild.
+   *
+   * @param guildId - The ID of the guild to get the scheduled events from.
+   * @param options - The parameters for the fetching of the scheduled events.
+   * @returns A collection of {@link DiscordScheduledEvent} objects assorted by event ID.
+   *
+   * @see {@link https://docs.discord.com/developers/resources/guild-scheduled-event#list-scheduled-events-for-guild}
+   */ async getScheduledEvents (rest, guildId, options) {
+        return await rest.get(rest.routes.guilds.events.events(guildId, options?.withUserCount));
+    },
+    /**
+   * Gets the list of subscribers to a scheduled event from a guild.
+   *
+   * @param guildId - The ID of the guild to get the subscribers to the scheduled event from.
+   * @param eventId - The ID of the scheduled event to get the subscribers of.
+   * @param options - The parameters for the fetching of the subscribers.
+   * @returns A collection of {@link DiscordUser} objects assorted by user ID.
+   *
+   * @remarks
+   * Requires the `MANAGE_EVENTS` permission.
+   *
+   * Users are ordered by their IDs in _ascending_ order.
+   *
+   * @see {@link https://docs.discord.com/developers/resources/guild-scheduled-event#get-guild-scheduled-event-users}
+   */ async getScheduledEventUsers (rest, guildId, eventId, options) {
+        return await rest.get(rest.routes.guilds.events.users(guildId, eventId, options));
+    },
+    /** Get the bots Gateway metadata that can help during the operation of large or sharded bots. */ async getSessionInfo (rest) {
+        return await rest.snake.getGatewayBot();
+    },
+    /**
+   * Gets the stage instance associated with a stage channel, if one exists.
+   *
+   * @param channelId - The ID of the stage channel the stage instance is associated with.
+   * @returns An instance of {@link DiscordStageInstance}.
+   *
+   * @see {@link https://docs.discord.com/developers/resources/stage-instance#get-stage-instance}
+   */ async getStageInstance (rest, channelId) {
+        return await rest.get(rest.routes.channels.stage(channelId));
+    },
+    /**
+   * Returns the current user's voice state in the guild.
+   *
+   * @param guildId - The ID of the guild to get the voice state from.
+   * @returns An instance of {@link DiscordVoiceState}.
+   *
+   * @see {@link https://docs.discord.com/developers/resources/voice#get-current-user-voice-state}
+   */ async getOwnVoiceState (rest, guildId) {
+        return await rest.get(rest.routes.guilds.voice(guildId));
+    },
+    /**
+   * Returns the specified user's voice state in the guild.
+   *
+   * @param guildId - The ID of the guild to get the voice state from.
+   * @param userId - The ID of the user to get the voice state from
+   * @returns An instance of {@link DiscordVoiceState}.
+   *
+   * @remarks
+   * If the specified user is connected to a voice channel, the current user must have permission to connect to the channel.
+   *
+   * @see {@link https://docs.discord.com/developers/resources/voice#get-user-voice-state}
+   */ async getUserVoiceState (rest, guildId, userId) {
+        return await rest.get(rest.routes.guilds.voice(guildId, userId));
+    },
+    /**
+   * Returns a sticker object for the given sticker ID.
+   *
+   * @param stickerId The ID of the sticker to get
+   * @returns A {@link DiscordSticker}
+   *
+   * @see {@link https://docs.discord.com/developers/resources/sticker#get-sticker}
+   */ async getSticker (rest, stickerId) {
+        return await rest.get(rest.routes.sticker(stickerId));
+    },
+    /**
+   * Gets a thread member by their user ID.
+   *
+   * @param channelId - The ID of the thread to get the thread member of.
+   * @param userId - The user ID of the thread member to get.
+   * @param options - The parameters for the fetching of the thread member.
+   * @returns An instance of {@link DiscordThreadMember}.
+   *
+   * @see {@link https://docs.discord.com/developers/resources/channel#get-thread-member}
+   */ async getThreadMember (rest, channelId, userId, options) {
+        return await rest.get(rest.routes.channels.threads.getUser(channelId, userId, options));
+    },
+    /**
+   * Gets the list of thread members for a thread.
+   *
+   * @param channelId - The ID of the thread to get the thread members of.
+   * @param options - The parameters for the fetching of the thread members.
+   * @returns A collection of {@link DiscordThreadMember} assorted by user ID.
+   *
+   * @remarks
+   * Requires the application to have the `GUILD_MEMBERS` privileged intent enabled.
+   *
+   * @see {@link https://docs.discord.com/developers/resources/channel#list-thread-members}
+   */ async getThreadMembers (rest, channelId, options) {
+        return await rest.get(rest.routes.channels.threads.members(channelId, options));
+    },
+    /**
+   * Gets the list of users that reacted with an emoji to a message.
+   *
+   * @param channelId - The ID of the channel the message to get the users for is in.
+   * @param messageId - The ID of the message to get the users for.
+   * @param reaction - The reaction for which to get the users.
+   * @param options - The parameters for the fetching of the users.
+   * @returns A collection of {@link DiscordUser} objects assorted by user ID.
+   *
+   * @see {@link https://docs.discord.com/developers/resources/channel#get-reactions}
+   */ async getReactions (rest, channelId, messageId, reaction, options) {
+        return await rest.get(rest.routes.channels.reactions.message(channelId, messageId, reaction, options));
+    },
+    /**
+   * Get a user's data from the api
+   *
+   * @param id The user's id
+   * @returns {DiscordUser}
+   */ async getUser (rest, id) {
+        return await rest.get(rest.routes.user(id));
+    },
+    /**
+   * Get the current user data.
+   *
+   * @param bearerToken - The access token of the user
+   * @returns {DiscordUser}
+   *
+   * @remarks
+   * This requires the `identify` scope.
+   *
+   * To get the mail this also requires the `email` scope
+   */ async getCurrentUser (rest, bearerToken) {
+        return await rest.get(rest.routes.currentUser(), {
+            headers: {
+                authorization: `Bearer ${bearerToken}`
+            },
+            unauthorized: true
+        });
+    },
+    /**
+   * Get the current user connections.
+   *
+   * @param bearerToken - The access token of the user
+   * @returns {DiscordConnection[]}
+   *
+   * @remarks
+   * This requires the `connections` scope.
+   */ async getUserConnections (rest, bearerToken) {
+        return await rest.get(rest.routes.oauth2.connections(), {
+            headers: {
+                authorization: `Bearer ${bearerToken}`
+            },
+            unauthorized: true
+        });
+    },
+    /**
+   * Get the current user application role connection for the application.
+   *
+   * @param bearerToken - The access token of the user
+   * @param applicationId - The id of the application to get the role connection
+   * @returns {DiscordApplicationRoleConnection}
+   *
+   * @remarks
+   * The access token requires the `role_connections.write` scope.
+   *
+   * @see {@link https://docs.discord.com/developers/resources/user#get-user-application-role-connection}
+   */ async getUserApplicationRoleConnection (rest, bearerToken, applicationId) {
+        return await rest.get(rest.routes.oauth2.roleConnections(applicationId), {
+            headers: {
+                authorization: `Bearer ${bearerToken}`
+            },
+            unauthorized: true
+        });
+    },
+    /**
+   * Gets information about the vanity url of a guild.
+   *
+   * @param guildId - The ID of the guild to get the vanity url information for.
+   * @returns An instance of {@link DiscordVanityUrl}.
+   *
+   * @remarks
+   * Requires the `MANAGE_GUILD` permission.
+   *
+   * The `code` property will be `null` if the guild does not have a set vanity url.
+   *
+   * @see {@link https://docs.discord.com/developers/resources/guild#get-guild-vanity-url}
+   */ async getVanityUrl (rest, guildId) {
+        return await rest.get(rest.routes.guilds.vanity(guildId));
+    },
+    /**
+   * Gets the list of voice regions for a guild.
+   *
+   * @param guildId - The ID of the guild to get the voice regions for.
+   * @returns A collection of {@link DiscordVoiceRegion} objects assorted by voice region ID.
+   *
+   * @see {@link https://docs.discord.com/developers/resources/guild#get-guild-voice-regions}
+   */ async getVoiceRegions (rest, guildId) {
+        return await rest.get(rest.routes.guilds.regions(guildId));
+    },
+    /**
+   * Gets a webhook by its ID.
+   *
+   * @param webhookId - The ID of the webhook to get.
+   * @returns An instance of {@link DiscordWebhook}.
+   *
+   * @remarks
+   * Requires the `MANAGE_WEBHOOKS` permission unless the application making the request owns the webhook.
+   *
+   * @see {@link https://docs.discord.com/developers/resources/webhook#get-webhook}
+   */ async getWebhook (rest, webhookId) {
+        return await rest.get(rest.routes.webhooks.id(webhookId));
+    },
+    /**
+   * Gets a webhook message by its ID.
+   *
+   * @param webhookId - The ID of the webhook to get a message of.
+   * @param token - The webhook token, used to get webhook messages.
+   * @param messageId - the ID of the webhook message to get.
+   * @param options - The parameters for the fetching of the message.
+   * @returns An instance of {@link DiscordMessage}.
+   *
+   * @see {@link https://docs.discord.com/developers/resources/webhook#get-webhook-message}
+   */ async getWebhookMessage (rest, webhookId, token, messageId, options) {
+        return await rest.get(rest.routes.webhooks.message(webhookId, token, messageId, options), {
+            unauthorized: true
+        });
+    },
+    /**
+   * Gets a webhook using the webhook token, thereby bypassing the need for authentication + permissions.
+   *
+   * @param webhookId - The ID of the webhook to get.
+   * @param token - The webhook token, used to get the webhook.
+   * @returns An instance of {@link DiscordWebhook}.
+   *
+   * @see {@link https://docs.discord.com/developers/resources/webhook#get-webhook-with-token}
+   */ async getWebhookWithToken (rest, webhookId, token) {
+        return await rest.get(rest.routes.webhooks.webhook(webhookId, token), {
+            unauthorized: true
+        });
+    },
+    /**
+   * Gets the welcome screen for a guild.
+   *
+   * @param guildId - The ID of the guild to get the welcome screen for.
+   * @returns An instance of {@link DiscordWelcomeScreen}.
+   *
+   * @remarks
+   * If the welcome screen is not enabled:
+   * - Requires the `MANAGE_GUILD` permission.
+   *
+   * @see {@link https://docs.discord.com/developers/resources/guild#get-guild-welcome-screen}
+   */ async getWelcomeScreen (rest, guildId) {
+        return await rest.get(rest.routes.guilds.welcome(guildId));
+    },
+    /**
+   * Gets the guild widget by guild ID.
+   *
+   * @param guildId - The ID of the guild to get the widget of.
+   * @returns An instance of {@link DiscordGuildWidget}.
+   *
+   * @remarks
+   * Fires an `INVITE_CREATED` Gateway event when an invite channel is defined and a new `Invite` is generated.
+   *
+   * @see {@link https://docs.discord.com/developers/resources/guild#get-guild-widget}
+   */ async getWidget (rest, guildId) {
+        return await rest.get(rest.routes.guilds.widgetJson(guildId));
+    },
+    /**
+   * Gets the settings of a guild's widget.
+   *
+   * @param guildId - The ID of the guild to get the widget of.
+   * @returns An instance of {@link DiscordGuildWidgetSettings}.
+   *
+   * @remarks
+   * Requires the `MANAGE_GUILD` permission.
+   *
+   * @see {@link https://docs.discord.com/developers/resources/guild#get-guild-widget-settings}
+   */ async getWidgetSettings (rest, guildId) {
+        return await rest.get(rest.routes.guilds.widget(guildId));
+    },
+    /**
+   * Adds the bot user to a thread.
+   *
+   * @param channelId - The ID of the thread to add the bot user to.
+   *
+   * @remarks
+   * Requires the thread not be archived.
+   *
+   * Fires a _Thread Members Update_ gateway event.
+   *
+   * @see {@link https://docs.discord.com/developers/resources/channel#join-thread}
+   */ async joinThread (rest, channelId) {
+        await rest.put(rest.routes.channels.threads.me(channelId));
+    },
+    /**
+   * Leaves a guild.
+   *
+   * @param guildId - The ID of the guild to leave.
+   *
+   * @remarks
+   * Fires a _Guild Delete_ event.
+   *
+   * @see {@link https://docs.discord.com/developers/resources/user#leave-guild}
+   */ async leaveGuild (rest, guildId) {
+        await rest.delete(rest.routes.guilds.leave(guildId));
+    },
+    /**
+   * Removes the bot user from a thread.
+   *
+   * @param channelId - The ID of the thread to remove the bot user from.
+   *
+   * @remarks
+   * Requires the thread not be archived.
+   *
+   * Fires a _Thread Members Update_ gateway event.
+   *
+   * @see {@link https://docs.discord.com/developers/resources/channel#leave-thread}
+   */ async leaveThread (rest, channelId) {
+        await rest.delete(rest.routes.channels.threads.me(channelId));
+    },
+    /**
+   * Cross-posts a message posted in an announcement channel to subscribed channels.
+   *
+   * @param channelId - The ID of the announcement channel.
+   * @param messageId - The ID of the message to cross-post.
+   * @returns An instance of the cross-posted {@link DiscordMessage}.
+   *
+   * @remarks
+   * Requires the `SEND_MESSAGES` permission.
+   *
+   * If not cross-posting own message:
+   * - Requires the `MANAGE_MESSAGES` permission.
+   *
+   * Fires a _Message Create_ event in the guilds the subscribed channels are in.
+   *
+   * @see {@link https://docs.discord.com/developers/resources/channel#crosspost-message}
+   */ async publishMessage (rest, channelId, messageId) {
+        return await rest.post(rest.routes.channels.crosspost(channelId, messageId));
+    },
+    /**
+   * Removes a role from a member.
+   *
+   * @param guildId - The ID of the guild the member to remove the role from is in.
+   * @param userId - The user ID of the member to remove the role from.
+   * @param roleId - The ID of the role to remove from the member.
+   * @param {string} [reason] - An optional reason for the action, to be included in the audit log.
+   *
+   * @remarks
+   * Requires the `MANAGE_ROLES` permission.
+   *
+   * Fires a _Guild Member Update_ gateway event.
+   *
+   * @see {@link https://docs.discord.com/developers/resources/guild#remove-guild-member-role}
+   */ async removeRole (rest, guildId, userId, roleId, reason) {
+        await rest.delete(rest.routes.guilds.roles.member(guildId, userId, roleId), {
+            reason
+        });
+    },
+    /**
+   * Removes a member from a thread.
+   *
+   * @param channelId - The ID of the thread to remove the thread member of.
+   * @param userId - The user ID of the thread member to remove.
+   *
+   * @remarks
+   * If the thread is of type {@link ChannelTypes}.GuildPrivateThread, requires to be the creator of the thread.
+   * Otherwise, requires the `MANAGE_THREADS` permission.
+   *
+   * Requires the thread not be archived.
+   *
+   * Fires a _Thread Members Update_ gateway event.
+   *
+   * @see {@link https://docs.discord.com/developers/resources/channel#remove-thread-member}
+   */ async removeThreadMember (rest, channelId, userId) {
+        await rest.delete(rest.routes.channels.threads.user(channelId, userId));
+    },
+    /**
+   * Removes a member from a Group DM.
+   *
+   * @param channelId - The ID of the channel to remove the recipient user of.
+   * @param userId - The user ID of the user to remove.
+   *
+   * @see {@link https://docs.discord.com/developers/resources/channel#group-dm-remove-recipient}
+   */ async removeDmRecipient (rest, channelId, userId) {
+        await rest.delete(rest.routes.channels.dmRecipient(channelId, userId));
+    },
+    /**
+   * Sends a message to a channel.
+   *
+   * @param channelId - The ID of the channel to send the message in.
+   * @param options - The parameters for the creation of the message.
+   * @returns An instance of the created {@link DiscordMessage}.
+   *
+   * @remarks
+   * Requires that the bot user be able to see the contents of the channel the message is to be sent in.
+   *
+   * If sending a message to a guild channel:
+   * - Requires the `SEND_MESSAGES` permission.
+   *
+   * If sending a TTS message:
+   * - Requires the `SEND_TTS_MESSAGES` permission.
+   *
+   * If sending a message as a reply to another message:
+   * - Requires the `READ_MESSAGE_HISTORY` permission.
+   * - The message being replied to cannot be a system message.
+   *
+   * ⚠️ The maximum size of a request (accounting for any attachments and message content) for bot users is _8 MiB_.
+   *
+   * Fires a _Message Create_ gateway event.
+   *
+   * @see {@link https://docs.discord.com/developers/resources/channel#create-message}
+   */ async sendMessage (rest, channelId, options) {
+        return await rest.post(rest.routes.channels.messages(channelId), {
+            body: options,
+            files: options.files
+        });
+    },
+    /**
+   * Sends a follow-up message to an interaction.
+   *
+   * @param token - The interaction token to use, provided in the original interaction.
+   * @param options - The parameters for the creation of the message.
+   * @returns An instance of the created {@link DiscordMessage}.
+   *
+   * @remarks
+   * ⚠️ Interaction tokens are only valid for _15 minutes_.
+   *
+   * By default, mentions are suppressed. To enable mentions, pass a mention object with the callback data.
+   *
+   * Unlike `sendMessage()`, this endpoint allows the bot user to act without:
+   * - Needing to be able to see the contents of the channel that the message is in. (`READ_MESSAGES` permission.)
+   * - Requiring the `MESSAGE_CONTENT` intent.
+   *
+   * Apps are limited to 5 followup messages per interaction if it was initiated from a user-installed app and isn't installed in the server
+   * You can check if it was initiated from a user-installed app that isn't installed in the server by checking if {@link DiscordInteraction.authorizing_integration_owners | authorizingIntegrationOwners} only contains {@link DiscordApplicationIntegrationType.UserInstall | UserInstall}.
+   *
+   * Fires a _Message Create_ event.
+   *
+   * @see {@link https://docs.discord.com/developers/interactions/receiving-and-responding#create-followup-message}
+   */ async sendFollowupMessage (rest, token, options) {
+        return await rest.post(rest.routes.webhooks.webhook(rest.applicationId, token), {
+            body: options,
+            files: options.files,
+            unauthorized: true
+        });
+    },
+    /**
+   * Sends a response to an interaction.
+   *
+   * @param interactionId - The ID of the interaction to respond to.
+   * @param token - The interaction token to use, provided in the original interaction.
+   * @param options - The parameters for the creation of the message.
+   * @param params - The query parameters for the response of the callback
+   * @returns Nothing or the {@link DiscordInteractionCallbackResponse} if withResponse param is true
+   *
+   * @remarks
+   * ⚠️ Interaction tokens are only valid for _15 minutes_.
+   *
+   * By default, mentions are suppressed. To enable mentions, pass a mention object with the callback data.
+   *
+   * Unlike `sendMessage()`, this endpoint allows the bot user to act without:
+   * - Needing to be able to see the contents of the channel that the message is in. (`READ_MESSAGES` permission.)
+   * - Requiring the `MESSAGE_CONTENT` intent.
+   *
+   * Fires a _Message Create_ event.
+   *
+   * @see {@link https://docs.discord.com/developers/interactions/receiving-and-responding#create-interaction-response}
+   */ async sendInteractionResponse (rest, interactionId, token, options, params) {
+        return await rest.post(rest.routes.interactions.responses.callback(interactionId, token, params), {
+            body: options,
+            files: options.data?.files,
+            runThroughQueue: false,
+            unauthorized: true
+        });
+    },
+    /**
+   * Creates a thread, using an existing message as its point of origin.
+   *
+   * @param channelId - The ID of the channel in which to create the thread.
+   * @param messageId - The ID of the message to use as the thread's point of origin.
+   * @param options - The parameters to use for the creation of the thread.
+   * @param {string} [reason] - An optional reason for the action, to be included in the audit log.
+   * @returns An instance of the created {@link DiscordChannel}.
+   *
+   * @remarks
+   * If called on a channel of type {@link ChannelTypes}.GuildText, creates a {@link ChannelTypes}.GuildPublicThread.
+   * If called on a channel of type {@link ChannelTypes}.GuildNews, creates a {@link ChannelTypes}.GuildNewsThread.
+   * Does not work on channels of type {@link ChannelTypes}.GuildForum.
+   *
+   * The ID of the created thread will be the same as the ID of the source message.
+   *
+   * Fires a _Thread Create_ gateway event.
+   *
+   * @see {@link https://docs.discord.com/developers/resources/channel#start-thread-from-message}
+   */ async startThreadWithMessage (rest, channelId, messageId, options, reason) {
+        return await rest.post(rest.routes.channels.threads.message(channelId, messageId), {
+            body: options,
+            reason
+        });
+    },
+    /**
+   * Creates a thread without using a message as the thread's point of origin.
+   *
+   * @param channelId - The ID of the channel in which to create the thread.
+   * @param options - The parameters to use for the creation of the thread.
+   * @param {string} [reason] - An optional reason for the action, to be included in the audit log.
+   * @returns An instance of the created {@link DiscordChannel | Thread}.
+   *
+   * @remarks
+   * Creating a private thread requires the server to be boosted.
+   *
+   * Fires a _Thread Create_ gateway event.
+   *
+   * @see {@link https://docs.discord.com/developers/resources/channel#start-thread-without-message}
+   */ async startThreadWithoutMessage (rest, channelId, options, reason) {
+        return await rest.post(rest.routes.channels.threads.all(channelId), {
+            body: options,
+            reason
+        });
+    },
+    /**
+   * Get a list of users that voted for this specific answer.
+   *
+   * @param channelId - The ID of the channel in which the message with the poll lives
+   * @param messageId - The ID of the message in which the poll lives
+   * @param answerId - The ID of the answer to get the users that voted that answer
+   * @param options - The options for the request
+   * @returns The list of users that voted for the specific answer.
+   */ async getPollAnswerVoters (rest, channelId, messageId, answerId, options) {
+        return await rest.get(rest.routes.channels.polls.votes(channelId, messageId, answerId, options));
+    },
+    /**
+   * Immediately ends the poll.
+   *
+   * @param channelId - The ID of the channel in which the message with the poll lives
+   * @param messageId - The ID of the message in which the poll lives
+   * @returns The message with the expired poll
+   *
+   * @remarks
+   * You cannot end polls from other users.
+   *
+   * Fires a _Message Update_ gateway event
+   */ async endPoll (rest, channelId, messageId) {
+        return await rest.post(rest.routes.channels.polls.expire(channelId, messageId));
+    },
+    /**
+   * Synchronises a template with the current state of a guild.
+   *
+   * @param guildId - The ID of the guild to synchronise a template of.
+   * @returns An instance of the edited {@link DiscordTemplate}.
+   *
+   * @remarks
+   * Requires the `MANAGE_GUILD` permission.
+   *
+   * Fires a _Guild Update_ gateway event.
+   *
+   * @see {@link https://docs.discord.com/developers/resources/guild-template#get-guild-templates}
+   */ async syncGuildTemplate (rest, guildId) {
+        return await rest.put(rest.routes.guilds.templates.all(guildId));
+    },
+    /**
+   * Triggers a typing indicator for the specified channel, which expires after 10 seconds.
+   *
+   * @param channelId - The ID of the channel in which to trigger the typing indicator.
+   *
+   * @remarks
+   * Generally bots should **not** use this route.
+   * However, if a bot is responding to a command and expects the computation to take a few seconds,
+   * this endpoint may be called to let the user know that the bot is processing their message.
+   *
+   * Fires a _Typing Start_ gateway event.
+   *
+   * @see {@link https://docs.discord.com/developers/resources/channel#trigger-typing-indicator}
+   */ async triggerTypingIndicator (rest, channelId) {
+        await rest.post(rest.routes.channels.typing(channelId));
+    },
+    /**
+   * Re-registers the list of global application commands, overwriting the previous commands completely.
+   *
+   * @param commands - The list of commands to use to overwrite the previous list.
+   * @param options - Additional options for the endpoint.
+   * @returns A collection of {@link DiscordApplicationCommand} objects assorted by command ID.
+   *
+   * @remarks
+   * ❗ Commands that are not present in the `commands` array will be __deleted__.
+   *
+   * ⚠️ Commands that do not already exist will count towards the daily limit of _200_ new commands.
+   *
+   * When using the bearer token the token needs the `applications.commands.update` scope and must be a `Client grant` token.
+   *  You will be able to update only your own application commands
+   *
+   * @see {@link https://docs.discord.com/developers/interactions/application-commands#bulk-overwrite-global-application-commands}
+   */ async upsertGlobalApplicationCommands (rest, commands, options) {
+        const restOptions = {
+            body: commands
+        };
+        if (options?.bearerToken) {
+            restOptions.unauthorized = true;
+            restOptions.headers = {
+                authorization: `Bearer ${options.bearerToken}`
+            };
+        }
+        return await rest.put(rest.routes.interactions.commands.commands(rest.applicationId), restOptions);
+    },
+    /**
+   * Re-registers the list of application commands registered in a guild, overwriting the previous commands completely.
+   *
+   * @param guildId - The ID of the guild whose list of commands to overwrite.
+   * @param commands - The list of commands to use to overwrite the previous list.
+   * @param options - Additional options for the endpoint.
+   * @returns A collection of {@link DiscordApplicationCommand} objects assorted by command ID.
+   *
+   * @remarks
+   * ❗ Commands that are not present in the `commands` array will be __deleted__.
+   *
+   * ⚠️ Commands that do not already exist will count towards the daily limit of _200_ new commands.
+   *
+   * When using the bearer token the token needs the `applications.commands.update` scope and must be a `Client grant` token.
+   *  You will be able to update only your own application commands
+   *
+   * @see {@link https://docs.discord.com/developers/interactions/application-commands#bulk-overwrite-guild-application-commands}
+   */ async upsertGuildApplicationCommands (rest, guildId, commands, options) {
+        const restOptions = {
+            body: commands
+        };
+        if (options?.bearerToken) {
+            restOptions.unauthorized = true;
+            restOptions.headers = {
+                authorization: `Bearer ${options.bearerToken}`
+            };
+        }
+        return await rest.put(rest.routes.interactions.commands.guilds.all(rest.applicationId, guildId), restOptions);
+    },
+    /**
+   * Bans a user from a guild.
+   *
+   * @param guildId - The ID of the guild to ban the user from.
+   * @param userId - The ID of the user to ban from the guild.
+   * @param options - The parameters for the creation of the ban.
+   * @param {string} [reason] - An optional reason for the action, to be included in the audit log.
+   *
+   * @remarks
+   * Requires the `BAN_MEMBERS` permission.
+   *
+   * Fires a _Guild Ban Add_ gateway event.
+   *
+   * @see {@link https://docs.discord.com/developers/resources/guild#create-guild-ban}
+   */ async banMember (rest, guildId, userId, options, reason) {
+        await rest.put(rest.routes.guilds.members.ban(guildId, userId), {
+            body: options,
+            reason
+        });
+    },
+    /**
+   * Bans up to 200 users from a guild.
+   *
+   * @param guildId - The ID of the guild to ban the users from.
+   * @param options - The users to ban and the other options for the ban.
+   * @param {string} [reason] - An optional reason for the action, to be included in the audit log.
+   *
+   * @remarks
+   * Requires the `BAN_MEMBERS` and `MANAGE_GUILD` permissions.
+   *
+   * If all provided users fail to be banned, discord will respond with an error (code: `500000: Failed to ban users`)
+   *
+   * Fires as many _Guild Ban Add_ gateway events as many user where banned.
+   *
+   * @see {@link https://docs.discord.com/developers/resources/guild#bulk-guild-ban}
+   */ async bulkBanMembers (rest, guildId, options, reason) {
+        return await rest.post(rest.routes.guilds.members.bulkBan(guildId), {
+            body: options,
+            reason
+        });
+    },
+    /**
+   * Edits the nickname of the bot user.
+   *
+   * @param guildId - The ID of the guild to edit the nickname of the bot user in.
+   * @param options - The parameters for the edit of the nickname.
+   * @param {string} [reason] - An optional reason for the action, to be included in the audit log.
+   * @returns An instance of the edited {@link DiscordMember}
+   *
+   * @remarks
+   * Fires a _Guild Member Update_ gateway event.
+   *
+   * @see {@link https://docs.discord.com/developers/resources/guild#modify-current-member}
+   */ async editCurrentMember (rest, guildId, options, reason) {
+        return await rest.patch(rest.routes.guilds.members.bot(guildId), {
+            body: options,
+            reason
+        });
+    },
+    /**
+   * Edits a member's properties.
+   *
+   * @param guildId - The ID of the guild to edit the member of.
+   * @param userId - The user ID of the member to edit.
+   * @param {string} [reason] - An optional reason for the action, to be included in the audit log.
+   * @param options - The parameters for the edit of the user.
+   *
+   * @remarks
+   * This endpoint requires various permissions depending on what is edited about the member.
+   * To find out the required permission to enact a change, read the documentation of this endpoint's {@link ModifyGuildMember | parameters}.
+   *
+   * Fires a _Guild Member Update_ gateway event.
+   *
+   * @see {@link https://docs.discord.com/developers/resources/guild#modify-guild-member}
+   */ async editMember (rest, guildId, userId, options, reason) {
+        return await rest.patch(rest.routes.guilds.members.member(guildId, userId), {
+            body: options,
+            reason
+        });
+    },
+    /**
+   * Gets the current member object.
+   *
+   * @param bearerToken - The access token of the user
+   * @param guildId - The ID of the guild to get the member object for.
+   * @returns An instance of {@link DiscordMemberWithUser}.
+   *
+   * @remarks
+   * The access tokens needs the `guilds.members.read` scope
+   *
+   * @see {@link https://docs.discord.com/developers/resources/user#get-current-user-guild-member}
+   */ async getCurrentMember (rest, guildId, bearerToken) {
+        return await rest.get(rest.routes.guilds.members.currentMember(guildId), {
+            headers: {
+                authorization: `Bearer ${bearerToken}`
+            },
+            unauthorized: true
+        });
+    },
+    /**
+   * Gets the member object by user ID.
+   *
+  
+   * @param guildId - The ID of the guild to get the member object for.
+   * @param userId - The ID of the user to get the member object for.
+   * @returns An instance of {@link DiscordMemberWithUser}.
+   *
+   * @see {@link https://docs.discord.com/developers/resources/guild#get-guild-member}
+   */ async getMember (rest, guildId, userId) {
+        return await rest.get(rest.routes.guilds.members.member(guildId, userId));
+    },
+    /**
+   * Gets the list of members for a guild.
+   *
+   * @param guildId - The ID of the guild to get the list of members for.
+   * @param options - The parameters for the fetching of the members.
+   * @returns A collection of {@link DiscordMemberWithUser} objects assorted by user ID.
+   *
+   * @remarks
+   * Requires the `GUILD_MEMBERS` intent.
+   *
+   * ⚠️ It is not recommended to use this endpoint with very large bots. Instead, opt to use `fetchMembers()`:
+   * REST communication only permits 50 requests to be made per second, while gateways allow for up to 120 requests
+   * per minute per shard. For more information, read {@link https://docs.discord.com/developers/topics/rate-limits#rate-limits}.
+   *
+   * @see {@link https://docs.discord.com/developers/resources/guild#list-guild-members}
+   * @see {@link https://docs.discord.com/developers/events/gateway-events#request-guild-members}
+   * @see {@link https://docs.discord.com/developers/topics/rate-limits#rate-limits}
+   */ async getMembers (rest, guildId, options) {
+        return await rest.get(rest.routes.guilds.members.members(guildId, options));
+    },
+    /**
+   * Returns a serialized activity instance, if it exists. Useful for preventing unwanted activity sessions.
+   *
+   * @param applicationId - The ID of the application
+   * @param instanceId - The ID of the activity instance
+   */ async getApplicationActivityInstance (rest, applicationId, instanceId) {
+        return await rest.get(rest.routes.applicationActivityInstance(applicationId, instanceId));
+    },
+    /**
+   * Kicks a member from a guild.
+   *
+  
+   * @param guildId - The ID of the guild to kick the member from.
+   * @param userId - The user ID of the member to kick from the guild.
+   * @param {string} [reason] - An optional reason for the action, to be included in the audit log.
+   *
+   * @remarks
+   * Requires the `KICK_MEMBERS` permission.
+   *
+   * Fires a _Guild Member Remove_ gateway event.
+   *
+   * @see {@link https://docs.discord.com/developers/resources/guild#remove-guild-member}
+   */ async kickMember (rest, guildId, userId, reason) {
+        await rest.delete(rest.routes.guilds.members.member(guildId, userId), {
+            reason
+        });
+    },
+    /**
+   * Pins a message in a channel.
+   *
+   * @param channelId - The ID of the channel where the message is to be pinned.
+   * @param messageId - The ID of the message to pin.
+   * @param {string} [reason] - An optional reason for the action, to be included in the audit log.
+   *
+   * @remarks
+   * Requires the `PIN_MESSAGES` permission.
+   *
+   * Fires a _Channel Pins Update_ event.
+   *
+   * @see {@link https://docs.discord.com/developers/resources/message#pin-message}
+   */ async pinMessage (rest, channelId, messageId, reason) {
+        await rest.put(rest.routes.channels.messagePin(channelId, messageId), {
+            reason
+        });
+    },
+    /**
+   * Initiates the process of pruning inactive members.
+   *
+  
+   * @param guildId - The ID of the guild to prune the members of.
+   * @param options - The parameters for the pruning of members.
+   * @param {string} [reason] - An optional reason for the action, to be included in the audit log.
+   * @returns A number indicating how many members were pruned.
+   *
+   * @remarks
+   * Requires the `MANAGE_GUILD` and `KICK_MEMBERS` permissions, unless the guild has the `PRUNE_REQUIRES_ADMIN` guild feature, in which case it requires the `ADMINISTRATOR` permission.
+   *
+   * ❗ Requests to this endpoint will time out for large guilds. To prevent this from happening, set the {@link BeginGuildPrune.computePruneCount} property of the options object parameter to `false`. This will begin the process of pruning, and immediately return `undefined`, rather than wait for the process to complete before returning the actual count of members that have been kicked.
+   *
+   * ⚠️ By default, this process will not remove members with a role. To include the members who have a _particular subset of roles_, specify the role(s) in the {@link BeginGuildPrune.includeRoles | includeRoles} property of the options object parameter.
+   *
+   * Fires a _Guild Member Remove_ gateway event for every member kicked.
+   *
+   * @see {@link https://docs.discord.com/developers/resources/guild#begin-guild-prune}
+   */ async pruneMembers (rest, guildId, options, reason) {
+        return await rest.post(rest.routes.guilds.members.prune(guildId), {
+            body: options,
+            reason
+        });
+    },
+    /**
+   * Gets the list of members whose usernames or nicknames start with a provided string.
+   *
+  
+   * @param guildId - The ID of the guild to search in.
+   * @param query - The string to match usernames or nicknames against.
+   * @param options - The parameters for searching through the members.
+   * @returns A collection of {@link DiscordMember} objects assorted by user ID.
+   *
+   * @see {@link https://docs.discord.com/developers/resources/guild#search-guild-members}
+   */ async searchMembers (rest, guildId, query, options) {
+        return await rest.get(rest.routes.guilds.members.search(guildId, query, options));
+    },
+    /**
+   * Unbans a user from a guild.
+   *
+   * @param guildId - The ID of the guild to unban the user in.
+   * @param userId - The ID of the user to unban.
+   * @param {string} [reason] - An optional reason for the action, to be included in the audit log.
+   *
+   * @remarks
+   * Requires the `BAN_MEMBERS` permission.
+   *
+   * Fires a _Guild Ban Remove_ gateway event.
+   *
+   * @see {@link https://docs.discord.com/developers/resources/guild#remove-guild-ban}
+   */ async unbanMember (rest, guildId, userId, reason) {
+        await rest.delete(rest.routes.guilds.members.ban(guildId, userId), {
+            reason
+        });
+    },
+    /**
+   * Unpin a message in a channel.
+   *
+   * @param channelId - The ID of the channel where the message is pinned.
+   * @param messageId - The ID of the message to unpin.
+   * @param {string} [reason] - An optional reason for the action, to be included in the audit log.
+   *
+   * @remarks
+   * Requires the `PIN_MESSAGES` permission.
+   *
+   * Fires a _Channel Pins Update_ event.
+   *
+   * @see {@link https://docs.discord.com/developers/resources/message#unpin-message}
+   */ async unpinMessage (rest, channelId, messageId, reason) {
+        await rest.delete(rest.routes.channels.messagePin(channelId, messageId), {
+            reason
+        });
+    },
+    /**
+   * Get the guild onboarding
+   *
+   * @param guildId - The guild to get the onboarding from
+   */ async getGuildOnboarding (rest, guildId) {
+        return await rest.get(rest.routes.guilds.onboarding(guildId));
+    },
+    /**
+   * Modifies the onboarding configuration of the guild.
+   *
+   * @param guildId - The guild to edit the onboarding from
+   * @param {string} [reason] - An optional reason for the action, to be included in the audit log.
+   *
+   * @remarks
+   * Requires the `MANAGE_GUILD` and `MANAGE_ROLES` permissions.
+   *
+   * Onboarding enforces constraints when enabled. These constraints are:
+   *  - at least 7 default channels
+   *  - at least 5 of the 7 channels must allow sending messages to the \@everyone role
+   *
+   * The `mode` field modifies what is considered when enforcing these constraints.
+   */ async editGuildOnboarding (rest, guildId, options, reason) {
+        return await rest.put(rest.routes.guilds.onboarding(guildId), {
+            body: options,
+            reason
+        });
+    },
+    /**
+   * Modifies the incident actions of the guild.
+   *
+   * @param guildId - The guild to edit the incident actions from
+   * @param options - The options for the incident actions
+   *
+   * @remarks
+   * Requires the `MANAGE_GUILD` permission.
+   */ async modifyGuildIncidentActions (rest, guildId, options) {
+        return await rest.put(rest.routes.guilds.incidentActions(guildId), {
+            body: options
+        });
+    },
+    /**
+   * Returns all entitlements for a given app, active and expired.
+   *
+   * @param applicationId - The id of the application to get the entitlements
+   * @param {GetEntitlements} [options] - The optional query params for the endpoint
+   */ async listEntitlements (rest, applicationId, options) {
+        return await rest.get(rest.routes.monetization.entitlements(applicationId, options));
+    },
+    /**
+   * Returns an entitlement.
+   *
+   * @param applicationId - The id of the application to get the entitlement
+   * @param entitlementId - The id of the entitlement to get
+   */ async getEntitlement (rest, applicationId, entitlementId) {
+        return await rest.get(rest.routes.monetization.entitlement(applicationId, entitlementId));
+    },
+    /**
+   * Creates a test entitlement to a given SKU for a given guild or user. Discord will act as though that user or guild has entitlement to your premium offering.
+   *
+   * @param applicationId - The id of the application to create the entitlement
+   * @param body - The options for new entitlement
+   *
+   * @remarks
+   * This endpoint returns a partial entitlement object.
+   * It will not contain subscription_id, starts_at, or ends_at, as it's valid in perpetuity.
+   */ async createTestEntitlement (rest, applicationId, body) {
+        return await rest.post(rest.routes.monetization.entitlements(applicationId), {
+            body
+        });
+    },
+    /**
+   * Deletes a currently-active test entitlement. Discord will act as though that user or guild no longer has entitlement to your premium offering.
+   *
+   * @param applicationId - The id of the application from where delete the entitlement
+   * @param entitlementId - The id of the entitlement to delete
+   */ async deleteTestEntitlement (rest, applicationId, entitlementId) {
+        await rest.delete(rest.routes.monetization.entitlement(applicationId, entitlementId));
+    },
+    /**
+   * For One-Time Purchase consumable SKUs, marks a given entitlement for the user as consumed. The entitlement will have `consumed: true` when using {@link listEntitlements | List Entitlements}
+   *
+   * @param applicationId - The id of the application to get the entitlement
+   * @param entitlementId - The id of the entitlement to get
+   */ async consumeEntitlement (rest, applicationId, entitlementId) {
+        await rest.post(rest.routes.monetization.consumeEntitlement(applicationId, entitlementId));
+    },
+    /**
+   * Returns all SKUs for a given application
+   *
+   * @param applicationId - The id of the application to get the SKUs
+   */ async listSkus (rest, applicationId) {
+        return await rest.get(rest.routes.monetization.skus(applicationId));
+    },
+    /**
+   * Returns all subscriptions containing the SKU, filtered by user.
+   *
+   * @param skuId - The id of the sku of get the subscriptions for
+   */ async listSubscriptions (rest, skuId, options) {
+        return await rest.get(rest.routes.monetization.subscriptions(skuId, options));
+    },
+    /**
+   * Get a subscription by its ID.
+   *
+   * @param skuId - The id of the sku of get the subscriptions for
+   */ async getSubscription (rest, skuId, subscriptionId) {
+        return await rest.get(rest.routes.monetization.subscription(skuId, subscriptionId));
+    },
+    /**
+   * Send a soundboard sound to a voice channel the user is connected to.
+   *
+   * @param channelId - The id of the voice channel
+   *
+   * @remarks
+   * Fires a _Voice Channel Effect Send_ Gateway event.
+   *
+   * Requires the `SPEAK` and `USE_SOUNDBOARD` permissions, and also the `USE_EXTERNAL_SOUNDS` permission if the sound is from a different server.
+   * Additionally, requires the user to be connected to the voice channel, having a voice state without `deaf`, `self_deaf`, `mute`, or `suppress` enabled.
+   */ async sendSoundboardSound (rest, channelId, options) {
+        await rest.post(rest.routes.soundboard.sendSound(channelId), {
+            body: options
+        });
+    },
+    /** Returns an array of soundboard sound objects that can be used by all users. */ async listDefaultSoundboardSounds (rest) {
+        return await rest.get(rest.routes.soundboard.listDefault());
+    },
+    /**
+   * Returns a list of the guild's soundboard sounds.
+   *
+   * @param guildId - The guild to get the sounds from
+   *
+   * @remarks
+   * Includes `user` fields if the bot has the `CREATE_GUILD_EXPRESSIONS` or `MANAGE_GUILD_EXPRESSIONS` permission.
+   */ async listGuildSoundboardSounds (rest, guildId) {
+        return await rest.get(rest.routes.soundboard.guildSounds(guildId));
+    },
+    /**
+   * Returns a soundboard sound object for the given sound id.
+   *
+   * @param guildId - The guild to get the sounds from
+   * @param soundId - The sound id
+   *
+   * @remarks
+   * Includes `user` fields if the bot has the `CREATE_GUILD_EXPRESSIONS` or `MANAGE_GUILD_EXPRESSIONS` permission.
+   */ async getGuildSoundboardSound (rest, guildId, soundId) {
+        return await rest.get(rest.routes.soundboard.guildSound(guildId, soundId));
+    },
+    /**
+   * Create a new soundboard sound for the guild.
+   *
+   * @param guildId - The guild to create the sounds in
+   * @param options - The options to create the sound
+   * @param reason - The audit log reason
+   *
+   * @remarks
+   * Fires a _Guild Soundboard Sound Create_ Gateway event.
+   *
+   * Requires the `CREATE_GUILD_EXPRESSIONS` permission.
+   */ async createGuildSoundboardSound (rest, guildId, options, reason) {
+        return await rest.post(rest.routes.soundboard.guildSounds(guildId), {
+            body: options,
+            reason
+        });
+    },
+    /**
+   * Modify the given soundboard sound.
+   *
+   * @param guildId - The guild to create the sounds in
+   * @param soundId - The sound id to update
+   * @param options - The options to update the sound
+   * @param reason - The audit log reason
+   *
+   * @remarks
+   * Fires a _Guild Soundboard Sound Update_ Gateway event.
+   *
+   * For sounds created by the current user, requires either the `CREATE_GUILD_EXPRESSIONS` or `MANAGE_GUILD_EXPRESSIONS` permission.
+   * For other sounds, requires the `MANAGE_GUILD_EXPRESSIONS` permission.
+   */ async modifyGuildSoundboardSound (rest, guildId, soundId, options, reason) {
+        return await rest.post(rest.routes.soundboard.guildSound(guildId, soundId), {
+            body: options,
+            reason
+        });
+    },
+    /**
+   * Delete the given soundboard sound.
+   *
+   * @param guildId - The guild to create the sounds in
+   * @param soundId - The sound id to delete
+   * @param reason - The audit log reason
+   *
+   * @remarks
+   * Fires a _Guild Soundboard Sound Delete_ Gateway event.
+   *
+   * For sounds created by the current user, requires either the `CREATE_GUILD_EXPRESSIONS` or `MANAGE_GUILD_EXPRESSIONS` permission.
+   * For other sounds, requires the `MANAGE_GUILD_EXPRESSIONS` permission.
+   */ async deleteGuildSoundboardSound (rest, guildId, soundId, reason) {
+        return await rest.delete(rest.routes.soundboard.guildSound(guildId, soundId), {
+            reason
+        });
+    },
+    /**
+   * Returns a list of application role connection metadata objects for the given application.
+   *
+   * @param applicationId - The application to get the role connections from
+   * @returns A list of application role connection metadata objects
+   */ async listApplicationRoleConnectionsMetadataRecords (rest, applicationId) {
+        return await rest.get(rest.routes.applicationRoleConnectionMetadata(applicationId));
+    },
+    /**
+   * Updates and returns a list of application role connection metadata objects for the given application.
+   *
+   * @param applicationId - The application to get the role connections from
+   * @param options - The options to update the role connections
+   * @returns A list of application role connection metadata objects
+   *
+   * @remarks
+   * An application can have a maximum of 5 metadata records.
+   */ async updateApplicationRoleConnectionsMetadataRecords (rest, applicationId, options) {
+        return await rest.put(rest.routes.applicationRoleConnectionMetadata(applicationId), {
+            body: options
+        });
+    },
+    /**
+   * Creates a new lobby, adding any of the specified members to it, if provided.
+   *
+   * @param options - The options to create the lobby
+   * @returns The created lobby
+   */ async createLobby (rest, options) {
+        return await rest.post(rest.routes.lobby.create(), {
+            body: options
+        });
+    },
+    /**
+   * Creates a new lobby for the application identified by a `secret`, or joins the calling user to the existing lobby with that secret if one already exists.
+   *
+   * Updates lobby metadata and the calling member's metadata on join.
+   *
+   * @param options - The options to create or join the lobby
+   * @returns - The created or joined lobby
+   *
+   * @remarks
+   * Uses `Bearer` token for authorization with the `sdk.social_layer` scope.
+   */ async createOrJoinLobby (rest, options) {
+        return await rest.put(rest.routes.lobby.create(), {
+            body: options
+        });
+    },
+    /**
+   * Returns a lobby object for the specified lobby id, if it exists.
+   *
+   * @param lobbyId - The ID of the lobby to get
+   * @returns The lobby object
+   */ async getLobby (rest, lobbyId) {
+        return await rest.get(rest.routes.lobby.lobby(lobbyId));
+    },
+    /**
+   * Modifies the specified lobby with new values, if provided.
+   *
+   * @param lobbyId - The ID of the lobby to modify
+   * @param options - The options to modify the lobby
+   * @returns The modified lobby
+   */ async modifyLobby (rest, lobbyId, options) {
+        return await rest.patch(rest.routes.lobby.lobby(lobbyId), {
+            body: options
+        });
+    },
+    /**
+   * Deletes the specified lobby if it exists.
+   *
+   * It is safe to call even if the lobby is already deleted as well.
+   *
+   * @param lobbyId - The ID of the lobby to delete
+   * @returns Nothing
+   */ async deleteLobby (rest, lobbyId) {
+        return await rest.delete(rest.routes.lobby.lobby(lobbyId));
+    },
+    /**
+   * Adds the provided user to the specified lobby. If called when the user is already a member of the lobby will update fields such as metadata on that user instead.
+   *
+   * @param lobbyId - The ID of the lobby to add the user to
+   * @param userId - The ID of the user to add to the lobby
+   * @param options - The options to add the user to the lobby
+   * @returns The lobby member object
+   */ async addMemberToLobby (rest, lobbyId, userId, options) {
+        return await rest.put(rest.routes.lobby.member(lobbyId, userId), {
+            body: options
+        });
+    },
+    /**
+   * Adds, updates, or removes up to 25 members from the specified lobby in a single request.
+   *
+   * @param lobbyId - The ID of the lobby to add, update, or remove members from
+   * @param options - The options to add, update, or remove members from the lobby
+   * @returns Returns an array of lobby member objects for the upserted members. Removed members are not included in the response.
+   *
+   * @remarks
+   * Members with `remove_member: false` (the default) are upserted — added if not present, or updated with the provided metadata and flags if already a member. Members with `remove_member: true` are removed.
+   *
+   * Users unknown to Discord will return a 404 UNKNOWN_USER error.
+   * Users that fail permission checks or who have already reached the maximum number of lobbies per application (and are not already a member of this lobby) are silently dropped from the upsert set.
+   *
+   * @see {@link https://docs.discord.com/developers/resources/lobby#bulk-update-lobby-members}
+   */ async bulkUpdateLobbyMembers (rest, lobbyId, options) {
+        return await rest.post(rest.routes.lobby.membersBulk(lobbyId), {
+            body: options
+        });
+    },
+    /**
+   * Removes the provided user from the specified lobby. It is safe to call this even if the user is no longer a member of the lobby, but will fail if the lobby does not exist.
+   *
+   * @param lobbyId - The ID of the lobby to remove the user from
+   * @param userId - The ID of the user to remove from the lobby
+   * @returns Nothing
+   */ async removeMemberFromLobby (rest, lobbyId, userId) {
+        return await rest.delete(rest.routes.lobby.member(lobbyId, userId));
+    },
+    /**
+   * Removes the current user from the specified lobby. It is safe to call this even if the user is no longer a member of the lobby, but will fail if the lobby does not exist.
+   *
+   * @param lobbyId - The ID of the lobby to remove the user from
+   * @param bearerToken - The access token of the user
+   * @returns Nothing
+   *
+   * @remarks
+   * This requires a bearer token for authorization
+   */ async leaveLobby (rest, lobbyId, bearerToken) {
+        return await rest.delete(rest.routes.lobby.leave(lobbyId), {
+            headers: {
+                authorization: `Bearer ${bearerToken}`
+            },
+            unauthorized: true
+        });
+    },
+    /**
+   * Links an existing text channel to a lobby.
+   *
+   * @param lobbyId - The ID of the lobby to link the channel to
+   * @param bearerToken - The access token of the user
+   * @param options - The options to link the channel to the lobby
+   * @returns The updated lobby object
+   *
+   * @remarks
+   * Uses bearer token for authorization and the user must be a lobby member with the CanLinkLobby lobby member flag.
+   */ async linkChannelToLobby (rest, lobbyId, bearerToken, options) {
+        return await rest.patch(rest.routes.lobby.link(lobbyId), {
+            body: options,
+            headers: {
+                authorization: `Bearer ${bearerToken}`
+            },
+            unauthorized: true
+        });
+    },
+    /**
+   * Unlinks any currently linked channels from the specified lobby.
+   *
+   * @param lobbyId - The ID of the lobby to unlink the channel from
+   * @param bearerToken - The access token of the user
+   * @returns The updated lobby object
+   *
+   * @remarks
+   * Uses bearer token for authorization and the user must be a lobby member with the CanLinkLobby lobby member flag.
+   */ async unlinkChannelToLobby (rest, lobbyId, bearerToken) {
+        return await rest.patch(rest.routes.lobby.link(lobbyId), {
+            headers: {
+                authorization: `Bearer ${bearerToken}`
+            },
+            unauthorized: true
+        });
+    },
+    /**
+   * Sets the moderation metadata for a lobby message. The metadata is app-scoped and delivered to active game clients via the Social SDK as a realtime message update.
+   *
+   * @param lobbyId - The ID of the lobby to set the moderation metadata
+   * @param messageId - The ID of the message to set the moderation metadata
+   * @param options - The moderation metadata to set
+   *
+   * @remarks
+   * Uses `Bot` token for authorization.
+   *
+   * For the options: Free-form key–value pairs describing the moderation decision. Up to 5 keys; key length <= 1024 characters; value length <= 2000 characters
+   *
+   * @see {@link https://discord.com/developers/docs/game-sdk/social-sdk/chat-moderation#server-side-chat-moderation} for the full moderation flow.
+   */ async updateLobbyMessageModerationMetadata (rest, lobbyId, messageId, options) {
+        await rest.put(rest.routes.lobby.moderationMetadata(lobbyId, messageId), {
+            body: options
+        });
+    },
+    /**
+   * Sends a message to the specified lobby. The calling user must be a member of the lobby.
+   *
+   * @param bearerToken - The access token of the user
+   * @param lobbyId - The ID of the lobby to send the message to
+   * @param options - The options to send the message
+   * @returns Returns the created lobby message object.
+   *
+   * @remarks
+   * Uses `Bearer` token for authorization with the `sdk.social_layer` scope.
+   *
+   * If the lobby has a linked channel, the message is also forwarded to that channel.
+   * If forwarding fails (for example, due to AutoMod), the lobby message is still delivered to other lobby members.
+   */ async sendLobbyMessage (rest, bearerToken, lobbyId, options) {
+        return await rest.post(rest.routes.lobby.messages(lobbyId), {
+            body: options,
+            headers: {
+                authorization: `Bearer ${bearerToken}`
+            },
+            unauthorized: true
+        });
+    },
+    /**
+   * Returns the most recent messages in the specified lobby. The calling user must be a member of the lobby.
+   *
+   * @param bearerToken - The access token of the user
+   * @param lobbyId - The ID of the lobby to get the messages from
+   * @param options - The options to get the messages
+   * @returns Returns an array of lobby message objects
+   *
+   * @remarks
+   * Uses `Bearer` token for authorization with the `sdk.social_layer` scope.
+   */ async getLobbyMessages (rest, bearerToken, lobbyId, options) {
+        return await rest.get(rest.routes.lobby.messages(lobbyId, options), {
+            headers: {
+                authorization: `Bearer ${bearerToken}`
+            },
+            unauthorized: true
+        });
+    },
+    /**
+   * Creates a single-use guild invite to the lobby's linked channel, targeted at the calling user.
+   *
+   *
+   * @param bearerToken - The access token of the user
+   * @param lobbyId - The ID of the lobby to create the invite for
+   * @returns The created invite object
+   *
+   * @remarks
+   * Uses `Bearer` token for authorization with the `sdk.social_layer` scope.
+   *
+   * The lobby must have a linked channel and the caller must be a member of the lobby.
+   * The invite expires after one hour.
+   */ async createLobbyChannelInviteForSelf (rest, bearerToken, lobbyId) {
+        return rest.post(rest.routes.lobby.inviteSelf(lobbyId), {
+            headers: {
+                authorization: `Bearer ${bearerToken}`
+            },
+            unauthorized: true
+        });
+    },
+    /**
+   * Creates a single-use guild invite to the lobby's linked channel on behalf of an application, targeted at the specified user.
+   *
+   * @param lobbyId - The ID of the lobby to create the invite for
+   * @param userId - The ID of the user to create the invite for
+   * @returns The created invite object
+   *
+   * @remarks
+   * Uses `Bot` token for authorization
+   *
+   * The lobby must have a linked channel.
+   * The invite expires after one hour.
+   */ async createLobbyChannelInviteForUser (rest, lobbyId, userId) {
+        return rest.post(rest.routes.lobby.inviteUser(lobbyId, userId));
+    }
+};
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../src/endpoints.ts"],"sourcesContent":["import { Buffer } from 'node:buffer';\nimport type {\n  AddDmRecipientOptions,\n  AddGuildMemberOptions,\n  AddLobbyMember,\n  AtLeastOne,\n  BeginGuildPrune,\n  BigString,\n  BulkUpdateLobbyMember,\n  Camelize,\n  ChannelTypes,\n  CreateApplicationCommand,\n  CreateApplicationEmoji,\n  CreateAutoModerationRuleOptions,\n  CreateChannelInvite,\n  CreateForumPostWithMessage,\n  CreateGlobalApplicationCommandOptions,\n  CreateGroupDmOptions,\n  CreateGuildApplicationCommandOptions,\n  CreateGuildBan,\n  CreateGuildBulkBan,\n  CreateGuildChannel,\n  CreateGuildEmoji,\n  CreateGuildRole,\n  CreateGuildSoundboardSound,\n  CreateGuildStickerOptions,\n  CreateLobby,\n  CreateMessageOptions,\n  CreateOrJoinLobby,\n  CreateScheduledEvent,\n  CreateStageInstance,\n  CreateTemplate,\n  CreateTestEntitlement,\n  CreateWebhook,\n  DeleteWebhookMessageOptions,\n  DiscordAccessTokenResponse,\n  DiscordActivityInstance,\n  DiscordApplication,\n  DiscordApplicationCommand,\n  DiscordApplicationCommandPermissions,\n  DiscordApplicationIntegrationType,\n  DiscordApplicationRoleConnection,\n  DiscordApplicationRoleConnectionMetadata,\n  DiscordAuditLog,\n  DiscordAutoModerationRule,\n  DiscordBan,\n  DiscordBulkBan,\n  DiscordChannel,\n  DiscordConnection,\n  DiscordCurrentAuthorization,\n  DiscordEmoji,\n  DiscordEntitlement,\n  DiscordFollowedChannel,\n  DiscordGetAnswerVotesResponse,\n  DiscordGetChannelPins,\n  DiscordGetGatewayBot,\n  DiscordGuild,\n  DiscordGuildApplicationCommandPermissions,\n  DiscordGuildOnboarding,\n  DiscordGuildPreview,\n  DiscordGuildWidget,\n  DiscordGuildWidgetSettings,\n  DiscordIncidentsData,\n  DiscordIntegration,\n  DiscordInteraction,\n  DiscordInteractionCallbackResponse,\n  DiscordInvite,\n  DiscordInviteMetadata,\n  DiscordListActiveThreads,\n  DiscordListArchivedThreads,\n  DiscordLobby,\n  DiscordLobbyInvite,\n  DiscordLobbyMember,\n  DiscordLobbyMessage,\n  DiscordMember,\n  DiscordMemberWithUser,\n  DiscordMessage,\n  DiscordPrunedCount,\n  DiscordRole,\n  DiscordScheduledEvent,\n  DiscordSearchGuildMessages,\n  DiscordSearchGuildMessagesIndexing,\n  DiscordSku,\n  DiscordSoundboardSound,\n  DiscordStageInstance,\n  DiscordSticker,\n  DiscordStickerPack,\n  DiscordSubscription,\n  DiscordTargetUsersJobStatus,\n  DiscordTemplate,\n  DiscordThreadMember,\n  DiscordTokenExchange,\n  DiscordTokenRevocation,\n  DiscordUser,\n  DiscordVanityUrl,\n  DiscordVoiceRegion,\n  DiscordVoiceState,\n  DiscordWebhook,\n  DiscordWelcomeScreen,\n  EditApplication,\n  EditAutoModerationRuleOptions,\n  EditChannelPermissionOverridesOptions,\n  EditGuildOnboarding,\n  EditGuildRole,\n  EditGuildStickerOptions,\n  EditMessage,\n  EditOwnVoiceState,\n  EditScheduledEvent,\n  EditUserVoiceState,\n  EditWebhookMessageOptions,\n  ExecuteWebhook,\n  GetApplicationCommandPermissionOptions,\n  GetBans,\n  GetChannelPinsOptions,\n  GetEntitlements,\n  GetGlobalApplicationCommandsOptions,\n  GetGuildApplicationCommandsOptions,\n  GetGuildAuditLog,\n  GetGuildPruneCountQuery,\n  GetInvite,\n  GetLobbyMessages,\n  GetMessagesOptions,\n  GetPollAnswerVotes,\n  GetReactions,\n  GetScheduledEvents,\n  GetScheduledEventUsers,\n  GetThreadMember,\n  GetUserGuilds,\n  GetWebhookMessageOptions,\n  GuildFeatures,\n  InteractionCallbackData,\n  InteractionCallbackOptions,\n  InteractionResponse,\n  LinkChannelToLobby,\n  ListArchivedThreads,\n  ListGuildMembers,\n  ListSkuSubscriptionsOptions,\n  ListThreadMembers,\n  ModifyApplicationEmoji,\n  ModifyChannel,\n  ModifyCurrentMember,\n  ModifyGuild,\n  ModifyGuildChannelPositions,\n  ModifyGuildEmoji,\n  ModifyGuildIncidentActions,\n  ModifyGuildMember,\n  ModifyGuildSoundboardSound,\n  ModifyGuildTemplate,\n  ModifyGuildWelcomeScreen,\n  ModifyLobby,\n  ModifyRolePositions,\n  ModifyWebhook,\n  ScheduledEventEntityType,\n  ScheduledEventStatus,\n  SearchGuildMessagesOptions,\n  SearchMembers,\n  SendLobbyMessage,\n  SendSoundboardSound,\n  SetVoiceChannelStatus,\n  StartThreadWithMessage,\n  StartThreadWithoutMessage,\n  UpsertGlobalApplicationCommandOptions,\n  UpsertGuildApplicationCommandOptions,\n} from '@discordeno/types';\nimport { processReactionString, urlToBase64 } from '@discordeno/utils';\nimport type { MakeRequestOptions, RestManager } from './types.js';\n\n/**\n * @internal You are not supposed to use the functions in this object directly. Use the RestManager instead.\n */\nexport const restEndpoints = {\n  /**\n   * Adds a reaction to a message.\n   *\n   * @param channelId - The ID of the channel the message to add a reaction to is in.\n   * @param messageId - The ID of the message to add a reaction to.\n   * @param reaction - The reaction to add to the message.\n   * @returns\n   *\n   * @remarks\n   * Requires the `READ_MESSAGE_HISTORY` permission.\n   *\n   * If nobody else has reacted to the message:\n   * - Requires the `ADD_REACTIONS` permission.\n   *\n   * Fires a _Message Reaction Add_ gateway event.\n   *\n   * @see {@link https://docs.discord.com/developers/resources/channel#create-reaction}\n   */\n  async addReaction(rest: RestManager, channelId: BigString, messageId: BigString, reaction: string): Promise<void> {\n    reaction = processReactionString(reaction);\n\n    await rest.put(rest.routes.channels.reactions.bot(channelId, messageId, reaction));\n  },\n  /**\n   * Adds multiple a reaction to a message.\n   *\n   * This function uses the `addReaction()` helper behind the scenes.\n   *\n   * @param channelId - The ID of the channel the message to add reactions to is in.\n   * @param messageId - The ID of the message to add the reactions to.\n   * @param reactions - The reactions to add to the message.\n   * @param ordered - Whether the reactions must be added in order or not.\n   *\n   * @remarks\n   * Requires the `READ_MESSAGE_HISTORY` permission.\n   *\n   * If nobody else has reacted to the message:\n   * - Requires the `ADD_REACTIONS` permission.\n   *\n   * Fires a _Message Reaction Add_ gateway event for every reaction added.\n   */\n  async addReactions(rest: RestManager, channelId: BigString, messageId: BigString, reactions: string[], ordered?: boolean): Promise<void> {\n    if (!ordered) {\n      await Promise.all(\n        reactions.map(async (reaction) => {\n          await rest.snake.addReaction(channelId, messageId, reaction);\n        }),\n      );\n      return;\n    }\n\n    for (const reaction of reactions) {\n      await rest.snake.addReaction(channelId, messageId, reaction);\n    }\n  },\n  /**\n   * Adds a role to a member.\n   *\n   * @param guildId - The ID of the guild the member to add the role to is in.\n   * @param userId - The user ID of the member to add the role to.\n   * @param roleId - The ID of the role to add to the member.\n   * @param {string} [reason] - An optional reason for the action, to be included in the audit log.\n   *\n   * @remarks\n   * Requires the `MANAGE_ROLES` permission.\n   *\n   * Fires a _Guild Member Update_ gateway event.\n   *\n   * @see {@link https://docs.discord.com/developers/resources/guild#add-guild-member-role}\n   */\n  async addRole(rest: RestManager, guildId: BigString, userId: BigString, roleId: BigString, reason?: string): Promise<void> {\n    await rest.put(rest.routes.guilds.roles.member(guildId, userId, roleId), { reason });\n  },\n  /**\n   * Adds a member to a thread.\n   *\n   * @param channelId - The ID of the thread to add the member to.\n   * @param userId - The user ID of the member to add to the thread.\n   *\n   * @remarks\n   * Requires the ability to send messages in the thread.\n   * Requires the thread not be archived.\n   *\n   * Fires a _Thread Members Update_ gateway event.\n   *\n   * @see {@link https://docs.discord.com/developers/resources/channel#add-thread-member}\n   */\n  async addThreadMember(rest: RestManager, channelId: BigString, userId: BigString): Promise<void> {\n    await rest.put(rest.routes.channels.threads.user(channelId, userId));\n  },\n  /**\n   * Adds a recipient to a group DM.\n   *\n   * @param channelId - The ID of the group dm to add the user to.\n   * @param userId - The user ID of the user to add to the group dm.\n   * @param options - The options for adding the user\n   *\n   * @remarks\n   * Requires an OAuth2 access token with the `gdm.join` scope\n   *\n   * @see {@link https://docs.discord.com/developers/resources/channel#group-dm-add-recipient}\n   */\n  async addDmRecipient(rest: RestManager, channelId: BigString, userId: BigString, options: AddDmRecipientOptions): Promise<void> {\n    await rest.put(rest.routes.channels.dmRecipient(channelId, userId), { body: options });\n  },\n  /**\n   * Adds a member to a guild.\n   *\n   * @param guildId - The ID of the thread to add the member to.\n   * @param userId - The user ID of the member to add to the thread.\n   * @param options - The options for the add of a guild member\n   *\n   * @remarks\n   * Requires the bot to be in the specified server\n   * Requires an OAuth2 access token with the `guilds.join` scope\n   *\n   * Fires a _Guild Member Add_ gateway event.\n   *\n   * @see {@link https://docs.discord.com/developers/resources/guild#add-guild-member}\n   */\n  async addGuildMember(rest: RestManager, guildId: BigString, userId: BigString, options: AddGuildMemberOptions): Promise<void> {\n    return await rest.put(rest.routes.guilds.members.member(guildId, userId), {\n      body: options,\n    });\n  },\n  /**\n   * Creates an automod rule in a guild.\n   *\n   * @param guildId - The ID of the guild to create the rule in.\n   * @param options - The parameters for the creation of the rule.\n   * @param {string} [reason] - An optional reason for the action, to be included in the audit log.\n   * @returns An instance of the created {@link DiscordAutoModerationRule}.\n   *\n   * @remarks\n   * Requires the `MANAGE_GUILD` permission.\n   *\n   * Fires an _Auto Moderation Rule Create_ gateway event.\n   *\n   * @see {@link https://docs.discord.com/developers/resources/auto-moderation#create-auto-moderation-rule}\n   */\n  async createAutomodRule(\n    rest: RestManager,\n    guildId: BigString,\n    options: CreateAutoModerationRuleOptions,\n    reason?: string,\n  ): Promise<DiscordAutoModerationRule> {\n    return await rest.post<DiscordAutoModerationRule>(rest.routes.guilds.automod.rules(guildId), { body: options, reason });\n  },\n  /**\n   * Creates a channel within a guild.\n   *\n   * @param guildId - The ID of the guild to create the channel within.\n   * @param options - The parameters for the creation of the channel.\n   * @param {string} [reason] - An optional reason for the action, to be included in the audit log.\n   * @returns An instance of the created {@link DiscordChannel}.\n   *\n   * @remarks\n   * Requires the `MANAGE_CHANNELS` permission.\n   *\n   * If setting permission overwrites, only the permissions the bot user has in the guild can be allowed or denied.\n   *\n   * Setting the `MANAGE_ROLES` permission is only possible for guild administrators.\n   *\n   * Fires a _Channel Create_ gateway event.\n   *\n   * @see {@link https://docs.discord.com/developers/resources/guild#create-guild-channel}\n   */\n  async createChannel(rest: RestManager, guildId: BigString, options: CreateGuildChannel, reason?: string): Promise<DiscordChannel> {\n    return await rest.post<DiscordChannel>(rest.routes.guilds.channels(guildId), { body: options, reason });\n  },\n  /**\n   * Creates an emoji in a guild.\n   *\n   * @param guildId - The ID of the guild in which to create the emoji.\n   * @param options - The parameters for the creation of the emoji.\n   * @param {string} [reason] - An optional reason for the action, to be included in the audit log.\n   * @returns An instance of the created {@link DiscordEmoji}.\n   *\n   * @remarks\n   * Requires the `CREATE_GUILD_EXPRESSIONS` permission.\n   *\n   * Emojis have a maximum file size of 256 kilobits. Attempting to upload a larger emoji will cause the route to return 400 Bad Request.\n   *\n   * Fires a _Guild Emojis Update_ gateway event.\n   *\n   * @see {@link https://docs.discord.com/developers/resources/emoji#create-guild-emoji}\n   */\n  async createEmoji(rest: RestManager, guildId: BigString, options: CreateGuildEmoji, reason?: string): Promise<DiscordEmoji> {\n    return await rest.post<DiscordEmoji>(rest.routes.guilds.emojis(guildId), { body: options, reason });\n  },\n  /**\n   * Creates an emoji for the application.\n   *\n   * @param options - The parameters for the creation of the emoji.\n   * @returns An instance of the created {@link DiscordEmoji}.\n   *\n   * @see {@link https://docs.discord.com/developers/resources/emoji#create-application-emoji}\n   */\n  async createApplicationEmoji(rest: RestManager, options: CreateApplicationEmoji): Promise<DiscordEmoji> {\n    return await rest.post<DiscordEmoji>(rest.routes.applicationEmojis(rest.applicationId), { body: options });\n  },\n  /**\n   * Creates a new thread in a forum channel or media channel, and sends a message within the created thread.\n   *\n   * @param channelId - The ID of the forum channel to create the thread within.\n   * @param options - The parameters for the creation of the thread.\n   * @param {string} [reason] - An optional reason for the action, to be included in the audit log.\n   * @returns An instance of {@link DiscordChannel} with a nested {@link DiscordChannel} object.\n   *\n   * @remarks\n   * Requires the `CREATE_MESSAGES` permission.\n   *\n   * Fires a _Thread Create_ gateway event.\n   * Fires a _Message Create_ gateway event.\n   *\n   * @see {@link https://docs.discord.com/developers/resources/channel#start-thread-in-forum-or-media-channel}\n   */\n  async createForumThread(rest: RestManager, channelId: BigString, options: CreateForumPostWithMessage, reason?: string): Promise<DiscordChannel> {\n    return await rest.post<DiscordChannel>(rest.routes.channels.forum(channelId), { body: options, files: options.files, reason });\n  },\n  /**\n   * Creates an application command accessible globally; across different guilds and channels.\n   *\n   * @param command - The command to create.\n   * @param options - Additional options for the endpoint\n   * @returns An instance of the created {@link DiscordApplicationCommand}.\n   *\n   * @remarks\n   * ⚠️ Creating a command with the same name as an existing command for your application will overwrite the old command.\n   * ⚠️ Global commands once created are cached for periods of __an hour__, so changes made to existing commands will take an hour to surface.\n   * ⚠️ You can only create up to 200 _new_ commands daily.\n   *\n   * When using the bearer token the token needs the `applications.commands.update` scope and must be a `Client grant` token.\n   *  You will be able to update only your own application commands\n   *\n   * @see {@link https://docs.discord.com/developers/interactions/application-commands#create-global-application-command}\n   */\n  async createGlobalApplicationCommand(\n    rest: RestManager,\n    command: CreateApplicationCommand,\n    options?: CreateGlobalApplicationCommandOptions,\n  ): Promise<DiscordApplicationCommand> {\n    const restOptions: MakeRequestOptions = { body: command };\n\n    if (options?.bearerToken) {\n      restOptions.unauthorized = true;\n      restOptions.headers = {\n        authorization: `Bearer ${options.bearerToken}`,\n      };\n    }\n\n    return await rest.post<DiscordApplicationCommand>(rest.routes.interactions.commands.commands(rest.applicationId), restOptions);\n  },\n  /**\n   * Creates an application command only accessible in a specific guild.\n   *\n   * @param command - The command to create.\n   * @param guildId - The ID of the guild to create the command for.\n   * @param options - Additional options for the endpoint\n   * @returns An instance of the created {@link DiscordApplicationCommand}.\n   *\n   * @remarks\n   * ⚠️ Creating a command with the same name as an existing command for your application will overwrite the old command.\n   * ⚠️ You can only create up to 200 _new_ commands daily.\n   *\n   * When using the bearer token the token needs the `applications.commands.update` scope and must be a `Client grant` token.\n   *  You will be able to update only your own application commands\n   *\n   * @see {@link https://docs.discord.com/developers/interactions/application-commands#create-guild-application-command}\n   */\n  async createGuildApplicationCommand(\n    rest: RestManager,\n    command: CreateApplicationCommand,\n    guildId: BigString,\n    options?: CreateGuildApplicationCommandOptions,\n  ): Promise<DiscordApplicationCommand> {\n    const restOptions: MakeRequestOptions = { body: command };\n\n    if (options?.bearerToken) {\n      restOptions.unauthorized = true;\n      restOptions.headers = {\n        authorization: `Bearer ${options.bearerToken}`,\n      };\n    }\n\n    return await rest.post<DiscordApplicationCommand>(rest.routes.interactions.commands.guilds.all(rest.applicationId, guildId), restOptions);\n  },\n  /**\n   * Create a new sticker for the guild.\n   *\n   * @param guildId The ID of the guild to get\n   * @param {string} [reason] - An optional reason for the action, to be included in the audit log.\n   * @return A {@link DiscordSticker}\n   *\n   * @remarks\n   * Requires the `CREATE_GUILD_EXPRESSIONS` permission.\n   * Fires a Guild Stickers Update Gateway event.\n   * Every guilds has five free sticker slots by default, and each Boost level will grant access to more slots.\n   * Lottie stickers can only be uploaded on guilds that have either the `VERIFIED` and/or the `PARTNERED` guild feature.\n   *\n   * @see {@link https://docs.discord.com/developers/resources/sticker#create-guild-sticker}\n   */\n  async createGuildSticker(rest: RestManager, guildId: BigString, options: CreateGuildStickerOptions, reason?: string): Promise<DiscordSticker> {\n    const form = new FormData();\n    form.append('file', options.file.blob, options.file.name);\n    form.append('name', options.name);\n    form.append('description', options.description);\n    form.append('tags', options.tags);\n\n    return await rest.post<DiscordSticker>(rest.routes.guilds.stickers(guildId), { body: form, reason });\n  },\n  /**\n   * Creates a template from a guild.\n   *\n   * @param guildId - The ID of the guild to create the template from.\n   * @param options - The parameters for the creation of the template.\n   * @returns An instance of the created {@link DiscordTemplate}.\n   *\n   * @remarks\n   * Requires the `MANAGE_GUILD` permission.\n   *\n   * Fires a _Guild Update_ gateway event.\n   *\n   * @see {@link https://docs.discord.com/developers/resources/guild-template#create-guild-template}\n   */\n  async createGuildTemplate(rest: RestManager, guildId: BigString, options: CreateTemplate): Promise<DiscordTemplate> {\n    return await rest.post<DiscordTemplate>(rest.routes.guilds.templates.all(guildId), { body: options });\n  },\n  /**\n   * Creates an invite to a channel in a guild.\n   *\n   * @param channelId - The ID of the channel to create the invite to.\n   * @param options - The parameters for the creation of the invite.\n   * @param {string} [reason] - An optional reason for the action, to be included in the audit log.\n   * @returns An instance of the created {@link DiscordInvite}.\n   *\n   * @remarks\n   * Requires the `CREATE_INSTANT_INVITE` permission.\n   *\n   * Fires an _Invite Create_ gateway event.\n   *\n   * @privateRemarks\n   * The request body is not optional, and an empty JSON object must be sent regardless of whether any fields are being transmitted.\n   *\n   * @see {@link https://docs.discord.com/developers/resources/channel#create-channel-invite}\n   */\n  async createInvite(rest: RestManager, channelId: BigString, options?: CreateChannelInvite, reason?: string): Promise<DiscordInvite> {\n    options ??= {};\n\n    if (!options.targetUsersFile) {\n      return await rest.post<DiscordInvite>(rest.routes.channels.invites(channelId), { body: options, reason });\n    }\n\n    // When we have to upload a file, we need to use FormData, and all other fields need to be part of the payload_json field.\n    const form = new FormData();\n\n    form.append('payload_json', JSON.stringify(rest.changeToDiscordFormat({ ...options, targetUsersFile: undefined })));\n    form.append('target_users_file', options.targetUsersFile);\n\n    return await rest.post<DiscordInvite>(rest.routes.channels.invites(channelId), { body: form, reason });\n  },\n  /**\n   * Get guild role member counts\n   *\n   * Returns a map of role IDs to the number of members with the role. Does not include the \\@everyone role.\n   *\n   * @param guildId - The ID of the guild to get role member counts for.\n   *\n   * @see {@link https://docs.discord.com/developers/resources/guild#get-guild-role-member-counts}\n   */\n  async getGuildRoleMemberCounts(rest: RestManager, guildId: BigString): Promise<Record<string, number>> {\n    return await rest.get<Record<string, number>>(rest.routes.guilds.roles.memberCounts(guildId));\n  },\n  /**\n   * Creates a role in a guild.\n   *\n   * @param guildId - The ID of the guild to create the role in.\n   * @param options - The parameters for the creation of the role.\n   * @param {string} [reason] - An optional reason for the action, to be included in the audit log.\n   * @returns An instance of the created {@link DiscordRole}.\n   *\n   * @remarks\n   * Requires the `MANAGE_ROLES` permission.\n   *\n   * Fires a _Guild Role Create_ gateway event.\n   *\n   * @see {@link https://docs.discord.com/developers/resources/guild#create-guild-role}\n   */\n  async createRole(rest: RestManager, guildId: BigString, options: CreateGuildRole, reason?: string): Promise<DiscordRole> {\n    return await rest.post<DiscordRole>(rest.routes.guilds.roles.all(guildId), { body: options, reason });\n  },\n  /**\n   * Creates a scheduled event in a guild.\n   *\n   * @param guildId - The ID of the guild to create the scheduled event in.\n   * @param options - The parameters for the creation of the scheduled event.\n   * @param {string} [reason] - An optional reason for the action, to be included in the audit log.\n   * @returns An instance of the created {@link DiscordScheduledEvent}.\n   *\n   * @remarks\n   * Requires the `MANAGE_EVENTS` permission.\n   *\n   * A guild can only have a maximum of 100 events with a status of {@link ScheduledEventStatus}.Active or {@link ScheduledEventStatus}.Scheduled (inclusive).\n   *\n   * Fires a _Guild Scheduled Event Create_ gateway event.\n   *\n   * @see {@link https://docs.discord.com/developers/resources/guild-scheduled-event#create-guild-scheduled-event}\n   */\n  async createScheduledEvent(rest: RestManager, guildId: BigString, options: CreateScheduledEvent, reason?: string): Promise<DiscordScheduledEvent> {\n    return await rest.post<DiscordScheduledEvent>(rest.routes.guilds.events.events(guildId), { body: options, reason });\n  },\n  /**\n   * Creates a stage instance associated with a stage channel.\n   *\n   * @param options - The parameters for the creation of the stage instance.\n   * @param {string} [reason] - An optional reason for the action, to be included in the audit log.\n   * @returns An instance of the created {@link DiscordStageInstance}.\n   *\n   * @remarks\n   * Requires the user to be a moderator of the stage channel.\n   *\n   * Fires a _Stage Instance Create_ gateway event.\n   *\n   * @see {@link https://docs.discord.com/developers/resources/stage-instance#create-stage-instance}\n   */\n  async createStageInstance(rest: RestManager, options: CreateStageInstance, reason?: string): Promise<DiscordStageInstance> {\n    return await rest.post<DiscordStageInstance>(rest.routes.channels.stages(), { body: options, reason });\n  },\n  /**\n   * Creates a webhook.\n   *\n   * @param channelId - The ID of the channel to create the webhook in.\n   * @param options - The parameters for the creation of the webhook.\n   * @param {string} [reason] - An optional reason for the action, to be included in the audit log.\n   * @returns An instance of the created {@link DiscordWebhook}.\n   *\n   * @remarks\n   * Requires the `MANAGE_WEBHOOKS` permission.\n   *\n   * ⚠️ The webhook name must not contain the substrings 'clyde', or 'discord' (case-insensitive).\n   *\n   * Fires a _Webhooks Update_ gateway event.\n   *\n   * @see {@link https://docs.discord.com/developers/resources/webhook#create-webhook}\n   */\n  async createWebhook(rest: RestManager, channelId: BigString, options: CreateWebhook, reason?: string): Promise<DiscordWebhook> {\n    return await rest.post<DiscordWebhook>(rest.routes.channels.webhooks(channelId), {\n      body: options,\n      reason,\n    });\n  },\n  /**\n   * Deletes an automod rule.\n   *\n   * @param guildId - The ID of the guild to delete the rule from.\n   * @param ruleId - The ID of the automod rule to delete.\n   * @param {string} [reason] - An optional reason for the action, to be included in the audit log.\n   *\n   * @remarks\n   * Requires the `MANAGE_GUILD` permission.\n   *\n   * Fires an _Auto Moderation Rule Delete_ gateway event.\n   *\n   * @see {@link https://docs.discord.com/developers/resources/auto-moderation#delete-auto-moderation-rule}\n   */\n  async deleteAutomodRule(rest: RestManager, guildId: BigString, ruleId: BigString, reason?: string): Promise<void> {\n    await rest.delete(rest.routes.guilds.automod.rule(guildId, ruleId), { reason });\n  },\n  /**\n   * Set a voice channel’s status\n   *\n   * @param channelId - The ID of the channel to set the status of.\n   * @param options - The parameters for the status of the voice channel.\n   * @param {string} [reason] - An optional reason for the action, to be included in the audit log.\n   * @returns Nothing\n   *\n   * @remarks\n   * Requires the `SET_VOICE_CHANNEL_STATUS` permission, and additionally the `MANAGE_CHANNELS` permission if the current user is not connected to the voice channel.\n   *\n   * Fires a _Voice Channel Status Update_ Gateway event.\n   *\n   * @see {@link https://docs.discord.com/developers/resources/channel#set-voice-channel-status}\n   */\n  async setVoiceChannelStatus(rest: RestManager, channelId: BigString, options: SetVoiceChannelStatus, reason?: string): Promise<void> {\n    await rest.put(rest.routes.channels.voiceStatus(channelId), { body: options, reason });\n  },\n  /**\n   * Deletes a channel from within a guild.\n   *\n   * @param channelId - The ID of the channel to delete.\n   * @param {string} [reason] - An optional reason for the action, to be included in the audit log.\n   * @returns nothing\n   *\n   * @remarks\n   * For community guilds, the _Rules_, _Guidelines_ and _Community Update_ channels cannot be deleted.\n   *\n   * If the channel is a thread:\n   * - Requires the `MANAGE_THREADS` permission.\n   *\n   * - Fires a _Thread Delete_ gateway event.\n   *\n   * Otherwise:\n   * - Requires the `MANAGE_CHANNELS` permission.\n   *\n   * - ⚠️ Deleting a category channel does not delete its child channels.\n   *   Instead, they will have their `parent_id` property removed, and a `Channel Update` gateway event will fire for each of them.\n   *\n   * - Fires a _Channel Delete_ gateway event.\n   *\n   * @see {@link https://docs.discord.com/developers/resources/channel#deleteclose-channel}\n   */\n  async deleteChannel(rest: RestManager, channelId: BigString, reason?: string): Promise<void> {\n    await rest.delete(rest.routes.channels.channel(channelId), {\n      reason,\n    });\n  },\n  /**\n   * Deletes a permission override for a user or role in a channel.\n   *\n   * @param channelId - The ID of the channel to delete the permission override of.\n   * @param overwriteId - The ID of the permission override to delete.\n   * @param {string} [reason] - An optional reason for the action, to be included in the audit log.\n   *\n   * @remarks\n   * Requires the `MANAGE_ROLES` permission.\n   *\n   * Fires a _Channel Update_ gateway event.\n   *\n   * @see {@link https://docs.discord.com/developers/resources/channel#delete-channel-permission}\n   */\n  async deleteChannelPermissionOverride(rest: RestManager, channelId: BigString, overwriteId: BigString, reason?: string): Promise<void> {\n    await rest.delete(rest.routes.channels.overwrite(channelId, overwriteId), { reason });\n  },\n  /**\n   * Deletes an emoji from a guild.\n   *\n   * @param guildId - The ID of the guild from which to delete the emoji.\n   * @param id - The ID of the emoji to delete.\n   * @param {string} [reason] - An optional reason for the action, to be included in the audit log.\n   *\n   * @remarks\n   * For emojis created by the current user, requires either the `CREATE_GUILD_EXPRESSIONS` or `MANAGE_GUILD_EXPRESSIONS` permission.\n   * For other emojis, requires the `MANAGE_GUILD_EXPRESSIONS` permission.\n   *\n   * Fires a _Guild Emojis Update_ gateway event.\n   *\n   * @see {@link https://docs.discord.com/developers/resources/emoji#delete-guild-emoji}\n   */\n  async deleteEmoji(rest: RestManager, guildId: BigString, id: BigString, reason?: string): Promise<void> {\n    await rest.delete(rest.routes.guilds.emoji(guildId, id), { reason });\n  },\n  /**\n   * Deletes an emoji from the application.\n   *\n   * @param id - The ID of the emoji to delete.\n   *\n   * @see {@link https://docs.discord.com/developers/resources/emoji#delete-application-emoji}\n   */\n  async deleteApplicationEmoji(rest: RestManager, id: BigString): Promise<void> {\n    await rest.delete(rest.routes.applicationEmoji(rest.applicationId, id));\n  },\n  /**\n   * Deletes a follow-up message to an interaction.\n   *\n   * @param token - The interaction token to use, provided in the original interaction.\n   * @param messageId - The ID of the message to delete.\n   *\n   * @remarks\n   * Unlike `deleteMessage()`, this endpoint allows the bot user to act without needing to see the channel the message is in.\n   *\n   * Fires a _Message Delete_ event.\n   *\n   * @see {@link https://docs.discord.com/developers/interactions/receiving-and-responding#delete-followup-message}\n   */\n  async deleteFollowupMessage(rest: RestManager, token: string, messageId: BigString): Promise<void> {\n    await rest.delete(rest.routes.interactions.responses.message(rest.applicationId, token, messageId), { unauthorized: true });\n  },\n  /**\n   * Deletes an application command registered globally.\n   *\n   * @param commandId - The ID of the command to delete.\n   *\n   * @see {@link https://docs.discord.com/developers/interactions/application-commands#delete-global-application-command}\n   */\n  async deleteGlobalApplicationCommand(rest: RestManager, commandId: BigString): Promise<void> {\n    await rest.delete(rest.routes.interactions.commands.command(rest.applicationId, commandId));\n  },\n  /**\n   * Deletes an application command registered in a guild.\n   *\n   * @param guildId - The ID of the guild to delete the command from.\n   * @param commandId - The ID of the command to delete from the guild.\n   *\n   * @see {@link https://docs.discord.com/developers/interactions/application-commands#delete-guild-application-command}\n   */\n  async deleteGuildApplicationCommand(rest: RestManager, commandId: BigString, guildId: BigString): Promise<void> {\n    await rest.delete(rest.routes.interactions.commands.guilds.one(rest.applicationId, guildId, commandId));\n  },\n  /**\n   * Delete a new sticker for the guild.\n   *\n   * @param guildId The ID of the guild to get\n   * @param {string} [reason] - An optional reason for the action, to be included in the audit log.\n   * @return A {@link DiscordSticker}\n   *\n   * @remarks\n   * For stickers created by the current user, requires either the `CREATE_GUILD_EXPRESSIONS` or `MANAGE_GUILD_EXPRESSIONS` permission.\n   * For other stickers, requires the `MANAGE_GUILD_EXPRESSIONS` permission.\n   * Fires a Guild Stickers Update Gateway event.\n   * Every guilds has five free sticker slots by default, and each Boost level will grant access to more slots.\n   * Lottie stickers can only be uploaded on guilds that have either the `VERIFIED` and/or the `PARTNERED` guild feature.\n   *\n   * @see {@link https://docs.discord.com/developers/resources/sticker#delete-guild-sticker}\n   */\n  async deleteGuildSticker(rest: RestManager, guildId: BigString, stickerId: BigString, reason?: string): Promise<void> {\n    await rest.delete(rest.routes.guilds.sticker(guildId, stickerId), { reason });\n  },\n  /**\n   * Deletes a template from a guild.\n   *\n   * @param guildId - The ID of the guild to delete the template from.\n   * @param templateCode - The code of the template to delete.\n   *\n   * @remarks\n   * Requires the `MANAGE_GUILD` permission.\n   *\n   * Fires a _Guild Update_ gateway event.\n   *\n   * @see {@link https://docs.discord.com/developers/resources/guild-template#delete-guild-template}\n   */\n  async deleteGuildTemplate(rest: RestManager, guildId: BigString, templateCode: string): Promise<void> {\n    await rest.delete(rest.routes.guilds.templates.guild(guildId, templateCode));\n  },\n  /**\n   * Deletes an integration attached to a guild.\n   *\n   * @param guildId - The ID of the guild from which to delete the integration.\n   * @param integrationId - The ID of the integration to delete from the guild.\n   * @param {string} [reason] - An optional reason for the action, to be included in the audit log.\n   *\n   * @remarks\n   * Requires the `MANAGE_GUILD` permission.\n   *\n   * Deletes all webhooks associated with the integration, and kicks the associated bot if there is one.\n   *\n   * Fires a _Guild Integrations Update_ gateway event.\n   * Fires a _Integration Delete_ gateway event.\n   *\n   * @see {@link https://docs.discord.com/developers/resources/guild#delete-guild-integration}\n   */\n  async deleteIntegration(rest: RestManager, guildId: BigString, integrationId: BigString, reason?: string): Promise<void> {\n    await rest.delete(rest.routes.guilds.integration(guildId, integrationId), { reason });\n  },\n  /**\n   * Deletes an invite to a channel.\n   *\n   * @param inviteCode - The invite code of the invite to delete.\n   * @param {string} [reason] - An optional reason for the action, to be included in the audit log.\n   *\n   * @remarks\n   * Requires the `MANAGE_CHANNELS` permission.\n   *\n   * Fires an _Invite Delete_ gateway event.\n   *\n   * @see {@link https://docs.discord.com/developers/resources/channel#delete-channel-invite}\n   */\n  async deleteInvite(rest: RestManager, inviteCode: string, reason?: string): Promise<void> {\n    await rest.delete(rest.routes.guilds.invite(inviteCode), { reason });\n  },\n  /**\n   * Gets the users allowed to see and accept this invite.\n   *\n   * @param inviteCode - The invite code of the invite to update.\n   * @returns CSV file containing the user IDs with the header `user_id` and each user ID from the original file\n   *\n   * @remarks\n   * Requires called to be the inviter, or have `MANAGE_GUILD` permission, or have `VIEW_AUDIT_LOG` permission.\n   *\n   * @see {@link https://docs.discord.com/developers/resources/invite#get-target-users}\n   */\n  async getTargetUsers(rest: RestManager, inviteCode: string): Promise<string> {\n    return await rest.get<string>(rest.routes.guilds.inviteTargetUsers(inviteCode));\n  },\n  /**\n   * Updates the users allowed to see and accept this invite.\n   *\n   * @param inviteCode - The invite code of the invite to update.\n   * @param targetUsersFile - A CSV file with a single column of user IDs for all the users able to accept this invite\n   *\n   * @remarks\n   * Requires the caller to be the inviter or have the `MANAGE_GUILD` permission.\n   *\n   * Uploading a file with invalid user IDs will result in a 400 with the invalid IDs described.\n   *\n   * @see {@link https://docs.discord.com/developers/resources/invite#update-target-users}\n   */\n  async updateTargetUsers(rest: RestManager, inviteCode: string, targetUsersFile: Blob): Promise<void> {\n    const form = new FormData();\n    form.append('target_users_file', targetUsersFile);\n\n    await rest.put(rest.routes.guilds.inviteTargetUsers(inviteCode), { body: form });\n  },\n  /**\n   * Processing target users from a CSV when creating or updating an invite is done asynchronously. This endpoint allows you to check the status of that job.\n   *\n   * @param inviteCode - The invite code of the invite to check the target users job status for.\n   * @returns An object containing the status of the target users job.\n   *\n   * @remarks\n   * Requires the caller to be the inviter, or have `MANAGE_GUILD` permission, or have `VIEW_AUDIT_LOG` permission.\n   *\n   * @see {@link https://docs.discord.com/developers/resources/invite#get-target-users-job-status}\n   */\n  async getTargetUsersJobStatus(rest: RestManager, inviteCode: string): Promise<DiscordTargetUsersJobStatus> {\n    return await rest.get<DiscordTargetUsersJobStatus>(rest.routes.guilds.inviteTargetUsersJobStatus(inviteCode));\n  },\n  /**\n   * Deletes a message from a channel.\n   *\n   * @param channelId - The ID of the channel to delete the message from.\n   * @param messageId - The ID of the message to delete from the channel.\n   * @param {string} [reason] - An optional reason for the action, to be included in the audit log.\n   *\n   * @remarks\n   * If not deleting own message:\n   * - Requires the `MANAGE_MESSAGES` permission.\n   *\n   * Fires a _Message Delete_ gateway event.\n   *\n   * @see {@link https://docs.discord.com/developers/resources/channel#delete-message}\n   */\n  async deleteMessage(rest: RestManager, channelId: BigString, messageId: BigString, reason?: string): Promise<void> {\n    await rest.delete(rest.routes.channels.message(channelId, messageId), { reason });\n  },\n  /**\n   * Deletes multiple messages from a channel.\n   *\n   * @param channelId - The ID of the channel to delete the messages from.\n   * @param messageIds - The IDs of the messages to delete from the channel.\n   * @param {string} [reason] - An optional reason for the action, to be included in the audit log.\n   *\n   * @remarks\n   * Requires the `MANAGE_MESSAGES` permission.\n   *\n   * ⚠️ Messages older than 2 weeks old cannot be deleted.\n   *\n   * Fires a _Message Delete Bulk_ gateway event.\n   *\n   * @see {@link https://docs.discord.com/developers/resources/channel#bulk-delete-messages}\n   */\n  async deleteMessages(rest: RestManager, channelId: BigString, messageIds: BigString[], reason?: string): Promise<void> {\n    await rest.post(rest.routes.channels.bulk(channelId), {\n      body: {\n        messages: messageIds.slice(0, 100).map((id) => id.toString()),\n      },\n      reason,\n    });\n  },\n  /**\n   * Deletes the initial message response to an interaction.\n   *\n   * @param token - The interaction token to use, provided in the original interaction.\n   *\n   * @remarks\n   * Unlike `deleteMessage()`, this endpoint allows the bot user to act without needing to see the channel the message is in.\n   *\n   * Fires a _Message Delete_ event.\n   *\n   * @see {@link https://docs.discord.com/developers/interactions/receiving-and-responding#delete-original-interaction-response}\n   */\n  async deleteOriginalInteractionResponse(rest: RestManager, token: string): Promise<void> {\n    await rest.delete(rest.routes.interactions.responses.original(rest.applicationId, token), { unauthorized: true });\n  },\n  /**\n   * Deletes a reaction added by the bot user from a message.\n   *\n   * @param channelId - The ID of the channel the message to delete the reaction from is in.\n   * @param messageId - The ID of the message to delete the reaction from.\n   * @param reaction - The reaction to delete from the message.\n   *\n   * @remarks\n   * Requires the `READ_MESSAGE_HISTORY` permission.\n   *\n   * Fires a _Message Reaction Remove_ gateway event.\n   *\n   * @see {@link https://docs.discord.com/developers/resources/channel#delete-own-reaction}\n   */\n  async deleteOwnReaction(rest: RestManager, channelId: BigString, messageId: BigString, reaction: string): Promise<void> {\n    reaction = processReactionString(reaction);\n\n    await rest.delete(rest.routes.channels.reactions.bot(channelId, messageId, reaction));\n  },\n  /**\n   * Deletes all reactions for all emojis from a message.\n   *\n   * @param channelId - The ID of the channel the message to delete the reactions from is in.\n   * @param messageId - The ID of the message to delete the reactions from.\n   *\n   * @remarks\n   * Requires the `READ_MESSAGE_HISTORY` permission.\n   *\n   * Requires the `MANAGE_MESSAGES` permission.\n   *\n   * Fires a _Message Reaction Remove All_ gateway event.\n   *\n   * @see {@link https://docs.discord.com/developers/resources/channel#delete-all-reactions}\n   */\n  async deleteReactionsAll(rest: RestManager, channelId: BigString, messageId: BigString): Promise<void> {\n    await rest.delete(rest.routes.channels.reactions.all(channelId, messageId));\n  },\n  /**\n   * Deletes all reactions for an emoji from a message.\n   *\n   * @param channelId - The ID of the channel the message to delete the reactions from is in.\n   * @param messageId - The ID of the message to delete the reactions from.\n   * @param reaction - The reaction to remove from the message.\n   *\n   * @remarks\n   * Requires the `READ_MESSAGE_HISTORY` permission.\n   *\n   * Requires the `MANAGE_MESSAGES` permission.\n   *\n   * Fires a _Message Reaction Remove Emoji_ gateway event.\n   *\n   * @see {@link https://docs.discord.com/developers/resources/channel#delete-all-reactions-for-emoji}\n   */\n  async deleteReactionsEmoji(rest: RestManager, channelId: BigString, messageId: BigString, reaction: string): Promise<void> {\n    reaction = processReactionString(reaction);\n\n    await rest.delete(rest.routes.channels.reactions.emoji(channelId, messageId, reaction));\n  },\n  /**\n   * Deletes a role from a guild.\n   *\n   * @param guildId - The ID of the guild to delete the role from.\n   * @param roleId - The ID of the role to delete.\n   * @param {string} [reason] - An optional reason for the action, to be included in the audit log.\n   *\n   * @remarks\n   * Requires the `MANAGE_ROLES` permission.\n   *\n   * Fires a _Guild Role Delete_ gateway event.\n   *\n   * @see {@link https://docs.discord.com/developers/resources/guild#delete-guild-role}\n   */\n  async deleteRole(rest: RestManager, guildId: BigString, roleId: BigString, reason?: string): Promise<void> {\n    await rest.delete(rest.routes.guilds.roles.one(guildId, roleId), { reason });\n  },\n  /**\n   * Deletes a scheduled event from a guild.\n   *\n   * @param guildId - The ID of the guild to delete the scheduled event from.\n   * @param eventId - The ID of the scheduled event to delete.\n   *\n   * @remarks\n   * Requires the `MANAGE_EVENTS` permission.\n   *\n   * Fires a _Guild Scheduled Event Delete_ gateway event.\n   *\n   * @see {@link https://docs.discord.com/developers/resources/guild-scheduled-event#delete-guild-scheduled-event}\n   */\n  async deleteScheduledEvent(rest: RestManager, guildId: BigString, eventId: BigString): Promise<void> {\n    await rest.delete(rest.routes.guilds.events.event(guildId, eventId));\n  },\n  /**\n   * Deletes the stage instance associated with a stage channel, if one exists.\n   *\n   * @param channelId - The ID of the stage channel the stage instance is associated with.\n   * @param {string} [reason] - An optional reason for the action, to be included in the audit log.\n   *\n   * @remarks\n   * Requires the user to be a moderator of the stage channel.\n   *\n   * Fires a _Stage Instance Delete_ gateway event.\n   *\n   * @see {@link https://docs.discord.com/developers/resources/stage-instance#delete-stage-instance}\n   */\n  async deleteStageInstance(rest: RestManager, channelId: BigString, reason?: string): Promise<void> {\n    await rest.delete(rest.routes.channels.stage(channelId), { reason });\n  },\n  /**\n   * Deletes a user's reaction from a message.\n   *\n   * @param channelId - The ID of the channel the message to delete the reaction from is in.\n   * @param messageId - The ID of the message to delete the reaction from.\n   * @param userId - The ID of the user whose reaction to delete.\n   * @param reaction - The reaction to delete from the message.\n   *\n   * @remarks\n   * Requires the `READ_MESSAGE_HISTORY` permission.\n   *\n   * Requires the `MANAGE_MESSAGES` permission.\n   *\n   * Fires a _Message Reaction Remove_ gateway event.\n   *\n   * @see {@link https://docs.discord.com/developers/resources/channel#delete-user-reaction}\n   */\n  async deleteUserReaction(rest: RestManager, channelId: BigString, messageId: BigString, userId: BigString, reaction: string): Promise<void> {\n    reaction = processReactionString(reaction);\n\n    await rest.delete(rest.routes.channels.reactions.user(channelId, messageId, reaction, userId));\n  },\n  /**\n   * Deletes a webhook.\n   *\n   * @param webhookId - The ID of the webhook to delete.\n   *\n   * @remarks\n   * Requires the `MANAGE_WEBHOOKS` permission.\n   *\n   * Fires a _Webhooks Update_ gateway event.\n   *\n   * @see {@link https://docs.discord.com/developers/resources/webhook#delete-webhook}\n   */\n  async deleteWebhook(rest: RestManager, webhookId: BigString, reason?: string): Promise<void> {\n    await rest.delete(rest.routes.webhooks.id(webhookId), { reason });\n  },\n  /**\n   * Deletes a webhook message.\n   *\n   * @param webhookId - The ID of the webhook to delete the message belonging to.\n   * @param token - The webhook token, used to manage the webhook.\n   * @param messageId - The ID of the message to delete.\n   * @param options - The parameters for the deletion of the message.\n   *\n   * @remarks\n   * Fires a _Message Delete_ gateway event.\n   *\n   * @see {@link https://docs.discord.com/developers/resources/webhook#delete-webhook}\n   */\n  async deleteWebhookMessage(\n    rest: RestManager,\n    webhookId: BigString,\n    token: string,\n    messageId: BigString,\n    options?: DeleteWebhookMessageOptions,\n  ): Promise<void> {\n    await rest.delete(rest.routes.webhooks.message(webhookId, token, messageId, options), { unauthorized: true });\n  },\n  /**\n   * Deletes a webhook message using the webhook token, thereby bypassing the need for authentication + permissions.\n   *\n   * @param webhookId - The ID of the webhook to delete the message belonging to.\n   * @param token - The webhook token, used to delete the webhook.\n   *\n   * @remarks\n   * Fires a _Message Delete_ gateway event.\n   *\n   * @see {@link https://docs.discord.com/developers/resources/webhook#delete-webhook-with-token}\n   */\n  async deleteWebhookWithToken(rest: RestManager, webhookId: BigString, token: string): Promise<void> {\n    await rest.delete(rest.routes.webhooks.webhook(webhookId, token), {\n      unauthorized: true,\n    });\n  },\n  /**\n   * Edits the permissions for a guild application command.\n   *\n   * @param guildId - The ID of the guild the command is registered in.\n   * @param commandId - The ID of the command to edit the permissions of.\n   * @param bearerToken - The bearer token to use to make the request.\n   * @param options - The parameters for the edit of the command permissions.\n   * @returns An instance of the edited {@link DiscordGuildApplicationCommandPermissions}.\n   *\n   * @remarks\n   * The bearer token requires the `applications.commands.permissions.update` scope to be enabled, and to have access to the guild whose ID has been provided in the parameters.\n   *\n   * @see {@link https://docs.discord.com/developers/interactions/application-commands#edit-application-command-permissions}\n   */\n  async editApplicationCommandPermissions(\n    rest: RestManager,\n    guildId: BigString,\n    commandId: BigString,\n    bearerToken: string,\n    options: Camelize<DiscordApplicationCommandPermissions[]>,\n  ): Promise<DiscordGuildApplicationCommandPermissions> {\n    return await rest.put<DiscordGuildApplicationCommandPermissions>(\n      rest.routes.interactions.commands.permission(rest.applicationId, guildId, commandId),\n      {\n        body: {\n          permissions: options,\n        },\n        headers: { authorization: `Bearer ${bearerToken}` },\n      },\n    );\n  },\n  /**\n   * Edits an automod rule.\n   *\n   * @param guildId - The ID of the guild to edit the rule in.\n   * @param ruleId - The ID of the rule to edit.\n   * @param options - The parameters for the edit of the rule.\n   * @param {string} [reason] - An optional reason for the action, to be included in the audit log.\n   * @returns An instance of the edited {@link DiscordAutoModerationRule}.\n   *\n   * @remarks\n   * Requires the `MANAGE_GUILD` permission.\n   *\n   * Fires an _Auto Moderation Rule Update_ gateway event.\n   *\n   * @see {@link https://docs.discord.com/developers/resources/auto-moderation#modify-auto-moderation-rule}\n   */\n  async editAutomodRule(\n    rest: RestManager,\n    guildId: BigString,\n    ruleId: BigString,\n    options: Partial<EditAutoModerationRuleOptions>,\n    reason?: string,\n  ): Promise<DiscordAutoModerationRule> {\n    return await rest.patch<DiscordAutoModerationRule>(rest.routes.guilds.automod.rule(guildId, ruleId), { body: options, reason });\n  },\n  /**\n   * Modifies the bot's username, avatar or banner.\n   *\n   * @param options - The parameters for the edit of the bot's profile.\n   * @returns An instance of the edited {@link DiscordUser}.\n   *\n   * @remarks\n   * Editing the `username` may cause the bot's discriminator to be randomized.\n   *\n   * `avatar` and `banner` must to be a Data URI scheme. {@link urlToBase64} from `@discordeno/utils` can be used to convert a URL to a Data URI scheme.\n   *\n   * @see {@link https://docs.discord.com/developers/resources/user#modify-current-user}\n   */\n  async editBotProfile(\n    rest: RestManager,\n    options: { username?: string; botAvatarURL?: string | null; botBannerURL?: string | null },\n  ): Promise<DiscordUser> {\n    return await rest.patch<DiscordUser>(rest.routes.currentUser(), {\n      body: options,\n    });\n  },\n  /**\n   * Edits a channel's settings.\n   *\n   * @param channelId - The ID of the channel to edit.\n   * @param options - The parameters for the edit of the channel.\n   * @param {string} [reason] - An optional reason for the action, to be included in the audit log.\n   * @returns An instance of the edited {@link DiscordChannel}.\n   *\n   * @remarks\n   * If editing a channel of type {@link ChannelTypes}.GroupDm:\n   * - Fires a _Channel Update_ gateway event.\n   *\n   * If editing a thread channel:\n   * - Requires the `MANAGE_THREADS` permission __unless__ if setting the `archived` property to `false` when the `locked` property is also `false`, in which case only the `SEND_MESSAGES` permission is required.\n   *\n   * - Fires a _Thread Update_ gateway event.\n   *\n   * If editing a guild channel:\n   * - Requires the `MANAGE_CHANNELS` permission.\n   *\n   * - If modifying permission overrides:\n   *   - Requires the `MANAGE_ROLES` permission.\n   *\n   *   - Only permissions the bot user has in the guild or parent channel can be allowed/denied __unless__ the bot user has a `MANAGE_ROLES` permission override in the channel.\n   *\n   * - If modifying a channel of type {@link ChannelTypes}.GuildCategory:\n   *     - Fires a _Channel Update_ gateway event for each child channel impacted in this change.\n   * - Otherwise:\n   *     - Fires a _Channel Update_ gateway event.\n   */\n  async editChannel(rest: RestManager, channelId: BigString, options: ModifyChannel, reason?: string): Promise<DiscordChannel> {\n    return await rest.patch<DiscordChannel>(rest.routes.channels.channel(channelId), { body: options, reason });\n  },\n  /**\n   * Edits the permission overrides for a user or role in a channel.\n   *\n   * @param channelId - The ID of the channel to edit the permission overrides of.\n   * @param options - The permission override.\n   * @param {string} [reason] - An optional reason for the action, to be included in the audit log.\n   *\n   * @remarks\n   * Requires the `MANAGE_ROLES` permission.\n   *\n   * Only permissions the bot user has in the guild or parent channel can be allowed/denied __unless__ the bot user has a `MANAGE_ROLES` permission override in the channel.\n   *\n   * Fires a _Channel Update_ gateway event.\n   *\n   * @see {@link https://docs.discord.com/developers/resources/channel#edit-channel-permissions}\n   */\n  async editChannelPermissionOverrides(\n    rest: RestManager,\n    channelId: BigString,\n    options: EditChannelPermissionOverridesOptions,\n    reason?: string,\n  ): Promise<void> {\n    await rest.put(rest.routes.channels.overwrite(channelId, options.id), { body: options, reason });\n  },\n  /**\n   * Edits the positions of a set of channels in a guild.\n   *\n   * @param guildId - The ID of the guild in which to edit the positions of the channels.\n   * @param channelPositions - A set of objects defining the updated positions of the channels.\n   *\n   * @remarks\n   * Requires the `MANAGE_CHANNELS` permission.\n   *\n   * Fires a _Channel Update_ gateway event for every channel impacted in this change.\n   *\n   * At most one entry per request may change `parent_id`. A request that changes `parent_id` for more than one channel fails with a 400 response and error code 40009.\n   *\n   * Permissions are checked per entry, based on what the entry changes:\n   * - An entry that only changes `position` requires the `MANAGE_CHANNELS` permission at the guild level (or on the channel's current parent category). It does **not** require access to the individual channel, so a full reordering may include channels the current user cannot view.\n   * - An entry that changes `parent_id` requires the `MANAGE_CHANNELS` permission on that channel and on the destination (the new parent category, or the guild when moving the channel out of a category), and the current user must be able to view the channel. Otherwise the request fails with a `403` response and error code 50001. Setting `lock_permissions` additionally requires `MANAGE_ROLES`.\n   *\n   * @see {@link https://docs.discord.com/developers/resources/guild#modify-guild-channel-positions}\n   */\n  async editChannelPositions(rest: RestManager, guildId: BigString, channelPositions: ModifyGuildChannelPositions[]): Promise<void> {\n    await rest.patch(rest.routes.guilds.channels(guildId), { body: channelPositions });\n  },\n  /**\n   * Edits an emoji.\n   *\n   * @param guildId - The ID of the guild in which to edit the emoji.\n   * @param id - The ID of the emoji to edit.\n   * @param options - The parameters for the edit of the emoji.\n   * @param {string} [reason] - An optional reason for the action, to be included in the audit log.\n   * @returns An instance of the updated {@link DiscordEmoji}.\n   *\n   * @remarks\n   * For emojis created by the current user, requires either the `CREATE_GUILD_EXPRESSIONS` or `MANAGE_GUILD_EXPRESSIONS` permission.\n   * For other emojis, requires the `MANAGE_GUILD_EXPRESSIONS` permission.\n   *\n   * Fires a `Guild Emojis Update` gateway event.\n   *\n   * @see {@link https://docs.discord.com/developers/resources/emoji#modify-guild-emoji}\n   */\n  async editEmoji(rest: RestManager, guildId: BigString, id: BigString, options: ModifyGuildEmoji, reason?: string): Promise<DiscordEmoji> {\n    return await rest.patch<DiscordEmoji>(rest.routes.guilds.emoji(guildId, id), { body: options, reason });\n  },\n  /**\n   * Edits an application emoji.\n   *\n   * @param id - The ID of the emoji to edit.\n   * @param options - The parameters for the edit of the emoji.\n   * @returns An instance of the updated {@link DiscordEmoji}.\n   *\n   * @see {@link https://docs.discord.com/developers/resources/emoji#modify-application-emoji}\n   */\n  async editApplicationEmoji(rest: RestManager, id: BigString, options: ModifyApplicationEmoji): Promise<DiscordEmoji> {\n    return await rest.patch<DiscordEmoji>(rest.routes.applicationEmoji(rest.applicationId, id), { body: options });\n  },\n  /**\n   * Edits a follow-up message to an interaction.\n   *\n   * @param token - The interaction token to use, provided in the original interaction.\n   * @param messageId - The ID of the message to edit.\n   * @param options - The parameters for the edit of the message.\n   * @returns An instance of the edited {@link DiscordMessage}.\n   *\n   * @remarks\n   * Unlike `editMessage()`, this endpoint allows the bot user to act without needing to see the channel the message is in.\n   *\n   * Does not support ephemeral follow-up messages due to these being stateless.\n   *\n   * Fires a _Message Update_ event.\n   *\n   * @see {@link https://docs.discord.com/developers/interactions/receiving-and-responding#edit-followup-message}\n   */\n  async editFollowupMessage(rest: RestManager, token: string, messageId: BigString, options: InteractionCallbackData): Promise<DiscordMessage> {\n    return await rest.patch<DiscordMessage>(rest.routes.interactions.responses.message(rest.applicationId, token, messageId), {\n      body: options,\n      files: options.files,\n      unauthorized: true,\n    });\n  },\n  /**\n   * Edits a global application command.\n   *\n   * @param commandId - The ID of the command to edit.\n   * @param options - The parameters for the edit of the command.\n   * @returns An instance of the edited {@link DiscordApplicationCommand}.\n   *\n   * @see {@link https://docs.discord.com/developers/interactions/application-commands#edit-global-application-command}\n   */\n  async editGlobalApplicationCommand(rest: RestManager, commandId: BigString, options: CreateApplicationCommand): Promise<DiscordApplicationCommand> {\n    return await rest.patch<DiscordApplicationCommand>(rest.routes.interactions.commands.command(rest.applicationId, commandId), { body: options });\n  },\n  /**\n   * Edits a guild's settings.\n   *\n   * @param guildId - The ID of the guild to edit.\n   * @param options - The parameters for the edit of the guild.\n   * @param {string} [reason] - An optional reason for the action, to be included in the audit log.\n   * @returns An instance of the edited {@link DiscordGuild}.\n   *\n   * @remarks\n   * Requires the `MANAGE_GUILD` permission.\n   *\n   * If attempting to add or remove the {@link GuildFeatures}.Community feature:\n   * - Requires the `ADMINISTRATOR` permission.\n   *\n   * Fires a _Guild Update_ gateway event.\n   *\n   * @see {@link https://docs.discord.com/developers/resources/guild#modify-guild}\n   */\n  async editGuild(rest: RestManager, guildId: BigString, options: ModifyGuild, reason?: string): Promise<DiscordGuild> {\n    return await rest.patch<DiscordGuild>(rest.routes.guilds.guild(guildId), { body: options, reason });\n  },\n  /**\n   * Edits an application command registered in a guild.\n   *\n   * @param guildId - The ID of the guild the command is registered in.\n   * @param commandId - The ID of the command to edit.\n   * @param options - The parameters for the edit of the command.\n   * @returns An instance of the edited {@link DiscordApplicationCommand}.\n   *\n   * @see {@link https://docs.discord.com/developers/interactions/application-commands#edit-guild-application-command}\n   */\n  async editGuildApplicationCommand(\n    rest: RestManager,\n    commandId: BigString,\n    guildId: BigString,\n    options: CreateApplicationCommand,\n  ): Promise<DiscordApplicationCommand> {\n    return await rest.patch<DiscordApplicationCommand>(rest.routes.interactions.commands.guilds.one(rest.applicationId, guildId, commandId), {\n      body: options,\n    });\n  },\n  /**\n   * Edit the given sticker.\n   *\n   * @param guildId The ID of the guild to get\n   * @param {string} [reason] - An optional reason for the action, to be included in the audit log.\n   * @return A {@link DiscordSticker}\n   *\n   * @remarks\n   * For stickers created by the current user, requires either the `CREATE_GUILD_EXPRESSIONS` or `MANAGE_GUILD_EXPRESSIONS` permission.\n   * For other stickers, requires the `MANAGE_GUILD_EXPRESSIONS` permission.\n   * Fires a Guild Stickers Update Gateway event.\n   *\n   * @see {@link https://docs.discord.com/developers/resources/sticker#modify-guild-sticker}\n   */\n  async editGuildSticker(\n    rest: RestManager,\n    guildId: BigString,\n    stickerId: BigString,\n    options: AtLeastOne<EditGuildStickerOptions>,\n    reason?: string,\n  ): Promise<DiscordSticker> {\n    return await rest.patch<DiscordSticker>(rest.routes.guilds.sticker(guildId, stickerId), { body: options, reason });\n  },\n  /**\n   * Edits a template's settings.\n   *\n   * @param guildId - The ID of the guild to edit a template of.\n   * @param templateCode - The code of the template to edit.\n   * @param options - The parameters for the edit of the template.\n   * @returns An instance of the edited {@link DiscordTemplate}.\n   *\n   * @remarks\n   * Requires the `MANAGE_GUILD` permission.\n   *\n   * Fires a _Guild Update_ gateway event.\n   *\n   * @see {@link https://docs.discord.com/developers/resources/guild-template#modify-guild-template}\n   */\n  async editGuildTemplate(rest: RestManager, guildId: BigString, templateCode: string, options: ModifyGuildTemplate): Promise<DiscordTemplate> {\n    return await rest.patch<DiscordTemplate>(rest.routes.guilds.templates.guild(guildId, templateCode), { body: options });\n  },\n  /**\n   * Edits a message.\n   *\n   * @param channelId - The ID of the channel to edit the message in.\n   * @param messageId - The IDs of the message to edit.\n   * @param options - The parameters for the edit of the message.\n   * @returns An instance of the edited {@link DiscordMessage}.\n   *\n   * @remarks\n   * If editing another user's message:\n   * - Requires the `MANAGE_MESSAGES` permission.\n   * - Only the {@link EditMessage.flags | flags} property of the options object parameter can be edited.\n   *\n   * Fires a _Message Update_ gateway event.\n   *\n   * @see {@link https://docs.discord.com/developers/resources/channel#edit-message}\n   */\n  async editMessage(rest: RestManager, channelId: BigString, messageId: BigString, options: EditMessage): Promise<DiscordMessage> {\n    return await rest.patch<DiscordMessage>(rest.routes.channels.message(channelId, messageId), { body: options, files: options.files });\n  },\n  /**\n   * Edits the initial message response to an interaction.\n   *\n   * @param token - The interaction token to use, provided in the original interaction.\n   * @param options - The parameters for the edit of the response.\n   * @returns An instance of the edited {@link DiscordMessage}.\n   *\n   * @remarks\n   * Unlike `editMessage()`, this endpoint allows the bot user to act without needing to see the channel the message is in.\n   *\n   * Does not support ephemeral follow-up messages due to these being stateless.\n   *\n   * Fires a _Message Update_ event.\n   *\n   * @see {@link https://docs.discord.com/developers/interactions/receiving-and-responding#edit-original-interaction-response}\n   */\n  async editOriginalInteractionResponse(rest: RestManager, token: string, options: InteractionCallbackData): Promise<DiscordMessage> {\n    return await rest.patch<DiscordMessage>(rest.routes.interactions.responses.original(rest.applicationId, token), {\n      body: options,\n      files: options.files,\n      unauthorized: true,\n    });\n  },\n  /**\n   * Edits the voice state of the bot user.\n   *\n   * @param guildId - The ID of the guild in which to edit the voice state of the bot user.\n   * @param options - The parameters for the edit of the voice state.\n   *\n   * @remarks\n   * The {@link EditOwnVoiceState.channelId | channelId} property of the options object parameter must point to a stage channel, and the bot user must already have joined it.\n   *\n   * If attempting to unmute oneself:\n   * - Requires the `MUTE_MEMBERS` permission.\n   *\n   * If attempting to request to speak:\n   * - Requires the `REQUEST_TO_SPEAK` permission.\n   *\n   * @see {@link https://docs.discord.com/developers/resources/voice#modify-current-user-voice-state}\n   */\n  async editOwnVoiceState(rest: RestManager, guildId: BigString, options: EditOwnVoiceState): Promise<void> {\n    await rest.patch(rest.routes.guilds.voice(guildId), {\n      body: {\n        ...options,\n        requestToSpeakTimestamp: options.requestToSpeakTimestamp\n          ? new Date(options.requestToSpeakTimestamp).toISOString()\n          : options.requestToSpeakTimestamp,\n      },\n    });\n  },\n  /**\n   * Edits a role in a guild.\n   *\n   * @param guildId - The ID of the guild to edit the role in.\n   * @param roleId - The ID of the role to edit.\n   * @param options - The parameters for the edit of the role.\n   * @param {string} [reason] - An optional reason for the action, to be included in the audit log.\n   * @returns An instance of the edited {@link DiscordRole}.\n   *\n   * @remarks\n   * Requires the `MANAGE_ROLES` permission.\n   *\n   * Fires a _Guild Role Update_ gateway event.\n   *\n   * @see {@link https://docs.discord.com/developers/resources/guild#modify-guild-role}\n   */\n  async editRole(rest: RestManager, guildId: BigString, roleId: BigString, options: EditGuildRole, reason?: string): Promise<DiscordRole> {\n    return await rest.patch<DiscordRole>(rest.routes.guilds.roles.one(guildId, roleId), { body: options, reason });\n  },\n  /**\n   * Edits the positions of a set of roles.\n   *\n   * @param guildId - The ID of the guild to edit the role positions in.\n   * @param options - The parameters for the edit of the role positions.\n   * @param {string} [reason] - An optional reason for the action, to be included in the audit log.\n   * @returns A collection of {@link DiscordRole} objects assorted by role ID.\n   *\n   * @remarks\n   * Requires the `MANAGE_ROLES` permission.\n   *\n   * Fires a _Guild Role Update_ gateway event for every role impacted in this change.\n   *\n   * @see {@link https://docs.discord.com/developers/resources/guild#modify-guild-role-positions}\n   */\n  async editRolePositions(rest: RestManager, guildId: BigString, options: ModifyRolePositions[], reason?: string): Promise<DiscordRole[]> {\n    return await rest.patch<DiscordRole[]>(rest.routes.guilds.roles.all(guildId), { body: options, reason });\n  },\n  /**\n   * Edits a scheduled event.\n   *\n   * @param guildId - The ID of the guild to edit the scheduled event in.\n   * @param eventId - The ID of the scheduled event to edit.\n   * @param {string} [reason] - An optional reason for the action, to be included in the audit log.\n   * @returns An instance of the edited {@link DiscordScheduledEvent}.\n   *\n   * @remarks\n   * Requires the `MANAGE_EVENTS` permission.\n   *\n   * To start or end an event, modify the event's `status` property.\n   *\n   * The `entity_metadata` property is discarded for events whose `entity_type` is not {@link ScheduledEventEntityType}.External.\n   *\n   * Fires a _Guild Scheduled Event Update_ gateway event.\n   *\n   * @see {@link https://docs.discord.com/developers/resources/guild-scheduled-event#modify-guild-scheduled-event}\n   */\n  async editScheduledEvent(\n    rest: RestManager,\n    guildId: BigString,\n    eventId: BigString,\n    options: Partial<EditScheduledEvent>,\n    reason?: string,\n  ): Promise<DiscordScheduledEvent> {\n    return await rest.patch<DiscordScheduledEvent>(rest.routes.guilds.events.event(guildId, eventId), { body: options, reason });\n  },\n  /**\n   * Edits a stage instance.\n   *\n   * @param channelId - The ID of the stage channel the stage instance is associated with.\n   * @param topic - Topic of the Stage instance (1-120 characters).\n   * @param {string} [reason] - An optional reason for the action, to be included in the audit log.\n   * @returns An instance of the updated {@link DiscordStageInstance}.\n   *\n   * @remarks\n   * Requires the user to be a moderator of the stage channel.\n   *\n   * Fires a _Stage Instance Update_ event.\n   *\n   * @see {@link https://docs.discord.com/developers/resources/stage-instance#modify-stage-instance}\n   */\n  async editStageInstance(rest: RestManager, channelId: BigString, topic: string, reason?: string): Promise<DiscordStageInstance> {\n    return await rest.patch<DiscordStageInstance>(rest.routes.channels.stage(channelId), { body: { topic }, reason });\n  },\n  /**\n   * Edits the voice state of another user.\n   *\n   * @param guildId - The ID of the guild in which to edit the voice state of the bot user.\n   * @param options - The parameters for the edit of the voice state.\n   *\n   * @remarks\n   * The {@link EditOwnVoiceState.channelId | channelId} property of the options object parameter must point to a stage channel, and the user must already have joined it.\n   *\n   * Requires the `MUTE_MEMBERS` permission.\n   *\n   * @see {@link https://docs.discord.com/developers/resources/voice#modify-user-voice-state}\n   */\n  async editUserVoiceState(rest: RestManager, guildId: BigString, options: EditUserVoiceState): Promise<void> {\n    await rest.patch(rest.routes.guilds.voice(guildId, options.userId), { body: options });\n  },\n  /**\n   * Edit the current user application role connection for the application.\n   *\n   * @param bearerToken - The access token of the user\n   * @param applicationId - The id of the application to edit the role connection\n   * @param options - The options to edit\n   * @returns {DiscordApplicationRoleConnection}\n   *\n   * @remarks\n   * This requires the `role_connections.write` scope.\n   *\n   * @see {@link https://docs.discord.com/developers/resources/user#update-user-application-role-connection}\n   */\n  async editUserApplicationRoleConnection(\n    rest: RestManager,\n    bearerToken: string,\n    applicationId: BigString,\n    options: Camelize<DiscordApplicationRoleConnection>,\n  ): Promise<DiscordApplicationRoleConnection> {\n    return await rest.put<DiscordApplicationRoleConnection>(rest.routes.oauth2.roleConnections(applicationId), {\n      body: options,\n      headers: {\n        authorization: `Bearer ${bearerToken}`,\n      },\n      unauthorized: true,\n    });\n  },\n  /**\n   * Deletes the application role connection for the user.\n   *\n   * @param bearerToken - The access token of the user\n   * @param applicationId - The id of the application to delete the role connection\n   *\n   * @remarks\n   * This requires the `role_connections.write` scope.\n   *\n   * @see {@link https://docs.discord.com/developers/resources/user#delete-current-user-application-role-connection}\n   */\n  async deleteCurrentUserApplicationRoleConnection(rest: RestManager, bearerToken: string, applicationId: BigString): Promise<void> {\n    return await rest.delete(rest.routes.oauth2.roleConnections(applicationId), {\n      headers: {\n        authorization: `Bearer ${bearerToken}`,\n      },\n      unauthorized: true,\n    });\n  },\n  /**\n   * Edits a webhook.\n   *\n   * @param webhookId - The ID of the webhook to edit.\n   * @param {string} [reason] - An optional reason for the action, to be included in the audit log.\n   * @returns An instance of the edited {@link DiscordWebhook}.\n   *\n   * @remarks\n   * Requires the `MANAGE_WEBHOOKS` permission.\n   *\n   * Fires a _Webhooks Update_ gateway event.\n   *\n   * @see {@link https://docs.discord.com/developers/resources/webhook#edit-webhook}\n   */\n  async editWebhook(rest: RestManager, webhookId: BigString, options: ModifyWebhook, reason?: string): Promise<DiscordWebhook> {\n    return await rest.patch<DiscordWebhook>(rest.routes.webhooks.id(webhookId), { body: options, reason });\n  },\n  /**\n   * Edits a webhook message.\n   *\n   * @param webhookId - The ID of the webhook to edit the message of.\n   * @param token - The webhook token, used to edit the message.\n   * @param messageId - The ID of the message to edit.\n   * @param options - The parameters for the edit of the message.\n   * @returns An instance of the edited {@link DiscordMessage}.\n   *\n   * @remarks\n   * Fires a _Message Update_ gateway event.\n   *\n   * @see {@link https://docs.discord.com/developers/resources/webhook#edit-webhook-message}\n   */\n  async editWebhookMessage(\n    rest: RestManager,\n    webhookId: BigString,\n    token: string,\n    messageId: BigString,\n    options: EditWebhookMessageOptions,\n  ): Promise<DiscordMessage> {\n    return await rest.patch<DiscordMessage>(rest.routes.webhooks.message(webhookId, token, messageId, options), {\n      body: options,\n      files: options.files,\n      unauthorized: true,\n    });\n  },\n  /**\n   * Edits a webhook using the webhook token, thereby bypassing the need for authentication + permissions.\n   *\n   * @param webhookId - The ID of the webhook to edit.\n   * @param token - The webhook token, used to edit the webhook.\n   * @returns An instance of the edited {@link DiscordWebhook}.\n   *\n   * @remarks\n   * Requires the `MANAGE_WEBHOOKS` permission.\n   *\n   * Fires a _Webhooks Update_ gateway event.\n   *\n   * @see {@link https://docs.discord.com/developers/resources/webhook#modify-webhook-with-token}\n   */\n  async editWebhookWithToken(\n    rest: RestManager,\n    webhookId: BigString,\n    token: string,\n    options: Omit<ModifyWebhook, 'channelId'>,\n  ): Promise<DiscordWebhook> {\n    return await rest.patch<DiscordWebhook>(rest.routes.webhooks.webhook(webhookId, token), {\n      body: options,\n      unauthorized: true,\n    });\n  },\n  /**\n   * Edits a guild's welcome screen.\n   *\n   * @param guildId - The ID of the guild to edit the welcome screen of.\n   * @param options - The parameters for the edit of the welcome screen.\n   * @param {string} [reason] - An optional reason for the action, to be included in the audit log.\n   * @returns An instance of the edited {@link DiscordWelcomeScreen}.\n   *\n   * @remarks\n   * Requires the `MANAGE_GUILD` permission.\n   *\n   * Fires a _Guild Update_ gateway event.\n   *\n   * @see {@link https://docs.discord.com/developers/resources/guild#modify-guild-welcome-screen}\n   */\n  async editWelcomeScreen(rest: RestManager, guildId: BigString, options: ModifyGuildWelcomeScreen, reason?: string): Promise<DiscordWelcomeScreen> {\n    return await rest.patch<DiscordWelcomeScreen>(rest.routes.guilds.welcome(guildId), { body: options, reason });\n  },\n  /**\n   * Edits the settings of a guild's widget.\n   *\n   * @param guildId - The ID of the guild to edit the settings of the widget of.\n   * @param {string} [reason] - An optional reason for the action, to be included in the audit log.\n   * @returns An instance of the edited {@link DiscordGuildWidgetSettings}.\n   *\n   * @remarks\n   * Requires the `MANAGE_GUILD` permission.\n   *\n   * Fires a _Guild Update_ gateway event.\n   *\n   * @see {@link https://docs.discord.com/developers/resources/guild#modify-guild-widget}\n   */\n  async editWidgetSettings(\n    rest: RestManager,\n    guildId: BigString,\n    options: Camelize<DiscordGuildWidgetSettings>,\n    reason?: string,\n  ): Promise<DiscordGuildWidgetSettings> {\n    return await rest.patch<DiscordGuildWidgetSettings>(rest.routes.guilds.widget(guildId), { body: options, reason });\n  },\n  /**\n   * Executes a webhook, causing a message to be posted in the channel configured for the webhook.\n   *\n   * @param webhookId - The ID of the webhook to execute.\n   * @param token - The webhook token, used to execute the webhook.\n   * @param options - The parameters for the execution of the webhook.\n   * @returns An instance of the created {@link DiscordMessage}, or `undefined` if the {@link ExecuteWebhook.wait | wait} property of the options object parameter is set to `false`.\n   *\n   * @remarks\n   * If the webhook channel is a forum channel, you must provide a value for either `threadId` or `threadName`.\n   *\n   * @see {@link https://docs.discord.com/developers/resources/webhook#execute-webhook}\n   */\n  async executeWebhook(rest: RestManager, webhookId: BigString, token: string, options: ExecuteWebhook): Promise<DiscordMessage | undefined> {\n    return await rest.post<DiscordMessage>(rest.routes.webhooks.webhook(webhookId, token, options), {\n      body: options,\n      unauthorized: true,\n    });\n  },\n  /**\n   * Follows an announcement channel, allowing messages posted within it to be cross-posted into the target channel.\n   *\n   * @param sourceChannelId - The ID of the announcement channel to follow.\n   * @param targetChannelId - The ID of the target channel - the channel to cross-post to.\n   * @param {string} [reason] - An optional reason for the action, to be included in the audit log.\n   * @returns An instance of {@link DiscordFollowedChannel}.\n   *\n   * @remarks\n   * Requires the `MANAGE_WEBHOOKS` permission in the __target channel__.\n   *\n   * Fires a _Webhooks Update_ gateway event.\n   *\n   * @see {@link https://docs.discord.com/developers/resources/channel#follow-announcement-channel}\n   */\n  async followAnnouncement(\n    rest: RestManager,\n    sourceChannelId: BigString,\n    targetChannelId: BigString,\n    reason?: string,\n  ): Promise<DiscordFollowedChannel> {\n    return await rest.post<DiscordFollowedChannel>(rest.routes.channels.follow(sourceChannelId), {\n      body: {\n        webhookChannelId: targetChannelId,\n      },\n      reason,\n    });\n  },\n  /**\n   * Gets the list of all active threads for a guild.\n   *\n   * @param guildId - The ID of the guild to get the threads of.\n   * @returns An instance of {@link DiscordListActiveThreads}.\n   *\n   * @remarks\n   * Returns both public and private threads.\n   *\n   * Threads are ordered by the `id` property in descending order.\n   *\n   * @see {@link https://docs.discord.com/developers/resources/guild#list-active-guild-threads}\n   */\n  async getActiveThreads(rest: RestManager, guildId: BigString): Promise<DiscordListActiveThreads> {\n    return await rest.get<DiscordListActiveThreads>(rest.routes.channels.threads.active(guildId));\n  },\n  /** Get the applications info */\n  async getApplicationInfo(rest: RestManager): Promise<DiscordApplication> {\n    return await rest.get<DiscordApplication>(rest.routes.oauth2.application());\n  },\n  /**\n   * Edit properties of the app associated with the requesting bot user.\n   *\n   * @remarks\n   * Only properties that are passed will be updated.\n   */\n  async editApplicationInfo(rest: RestManager, body: EditApplication): Promise<DiscordApplication> {\n    return await rest.patch<DiscordApplication>(rest.routes.application(), {\n      body,\n    });\n  },\n  /**\n   * Get the current authentication info for the authenticated user\n   *\n   * @param bearerToken - Any OAuth2 derived access token\n   * @returns An instance of {@link DiscordCurrentAuthorization}\n   *\n   * @remarks\n   * The user object is not defined if the scopes do not include `identify`.\n   * In the user object, if defined, the email is not included if the scopes do not include `email`\n   */\n  async getCurrentAuthenticationInfo(rest: RestManager, bearerToken: string): Promise<DiscordCurrentAuthorization> {\n    return await rest.get<DiscordCurrentAuthorization>(rest.routes.oauth2.currentAuthorization(), {\n      headers: {\n        authorization: `Bearer ${bearerToken}`,\n      },\n      unauthorized: true,\n    });\n  },\n  /**\n   * Exchange the information to get a OAuth2 accessToken token\n   *\n   * @param clientId - Application's client id\n   * @param clientSecret - application's client secret\n   * @param options - The options to make the exchange with discord\n   */\n  async exchangeToken(\n    rest: RestManager,\n    clientId: BigString,\n    clientSecret: string,\n    options: Camelize<DiscordTokenExchange>,\n  ): Promise<DiscordAccessTokenResponse> {\n    const basicCredentials = Buffer.from(`${clientId}:${clientSecret}`);\n\n    const restOptions: MakeRequestOptions = {\n      body: options,\n      headers: {\n        'content-type': 'application/x-www-form-urlencoded',\n        authorization: `Basic ${basicCredentials.toString('base64')}`,\n      },\n      runThroughQueue: false,\n      unauthorized: true,\n    };\n\n    if (options.grantType === 'client_credentials') {\n      restOptions.body.scope = options.scope.join(' ');\n    }\n\n    return await rest.post<DiscordAccessTokenResponse>(rest.routes.oauth2.tokenExchange(), restOptions);\n  },\n  /**\n   * Revoke an access_token\n   *\n   * @param clientId - Application's client id\n   * @param clientSecret - application's client secret\n   * @param options - The options to revoke the access_token\n   */\n  async revokeToken(rest: RestManager, clientId: BigString, clientSecret: string, options: Camelize<DiscordTokenRevocation>): Promise<void> {\n    const basicCredentials = Buffer.from(`${clientId}:${clientSecret}`);\n\n    await rest.post(rest.routes.oauth2.tokenRevoke(), {\n      body: options,\n      headers: {\n        'content-type': 'application/x-www-form-urlencoded',\n        authorization: `Basic ${basicCredentials.toString('base64')}`,\n      },\n      unauthorized: true,\n    });\n  },\n  /**\n   * Gets the permissions of a guild application command.\n   *\n   * @param guildId - The ID of the guild the command is registered in.\n   * @param commandId - The ID of the command to get the permissions of.\n   * @param options - The OAuth2 related optional parameters for the endpoint\n   * @returns An instance of {@link DiscordGuildApplicationCommandPermissions}.\n   *\n   * @remarks\n   * Then specifying the options object the access token passed-in requires the OAuth2 scope `applications.commands.permissions.update`\n   *\n   * @see {@link https://docs.discord.com/developers/interactions/application-commands#get-application-command-permissions}\n   */\n  async getApplicationCommandPermission(\n    rest: RestManager,\n    guildId: BigString,\n    commandId: BigString,\n    options?: GetApplicationCommandPermissionOptions,\n  ): Promise<DiscordGuildApplicationCommandPermissions> {\n    const restOptions: Omit<MakeRequestOptions, 'body'> = {};\n\n    if (options?.accessToken) {\n      restOptions.unauthorized = true;\n      restOptions.headers = {\n        authorization: `Bearer ${options.accessToken}`,\n      };\n    }\n\n    return await rest.get<DiscordGuildApplicationCommandPermissions>(\n      rest.routes.interactions.commands.permission(options?.applicationId ?? rest.applicationId, guildId, commandId),\n      restOptions,\n    );\n  },\n  /**\n   * Gets the permissions of all application commands registered in a guild by the ID of the guild and optionally an external application.\n   *\n   * @param guildId - The ID of the guild to get the permissions objects of.\n   * @param options - The OAuth2 related optional parameters for the endpoint\n   * @returns A collection of {@link DiscordGuildApplicationCommandPermissions} objects assorted by command ID.\n   *\n   * @remarks\n   * Then specifying the options object the access token passed-in requires the OAuth2 scope `applications.commands.permissions.update`\n   *\n   * @see {@link https://docs.discord.com/developers/interactions/application-commands#get-guild-application-command-permissions}\n   */\n  async getApplicationCommandPermissions(\n    rest: RestManager,\n    guildId: BigString,\n    options?: GetApplicationCommandPermissionOptions,\n  ): Promise<DiscordGuildApplicationCommandPermissions[]> {\n    const restOptions: Omit<MakeRequestOptions, 'body'> = {};\n\n    if (options?.accessToken) {\n      restOptions.unauthorized = true;\n      restOptions.headers = {\n        authorization: `Bearer ${options.accessToken}`,\n      };\n    }\n\n    return await rest.get<DiscordGuildApplicationCommandPermissions[]>(\n      rest.routes.interactions.commands.permissions(options?.applicationId ?? rest.applicationId, guildId),\n      restOptions,\n    );\n  },\n  /**\n   * Gets a guild's audit log.\n   *\n   * @param guildId - The ID of the guild to get the audit log of.\n   * @param options - The parameters for the fetching of the audit log.\n   * @returns An instance of {@link DiscordAuditLog}.\n   *\n   * @remarks\n   * Requires the `VIEW_AUDIT_LOG` permission.\n   *\n   * @see {@link https://docs.discord.com/developers/resources/audit-log#get-guild-audit-log}\n   */\n  async getAuditLog(rest: RestManager, guildId: BigString, options?: GetGuildAuditLog): Promise<DiscordAuditLog> {\n    return await rest.get<DiscordAuditLog>(rest.routes.guilds.auditlogs(guildId, options));\n  },\n  /**\n   * Gets an automod rule by its ID.\n   *\n   * @param guildId - The ID of the guild to get the rule of.\n   * @param ruleId - The ID of the rule to get.\n   * @returns An instance of {@link DiscordAutoModerationRule}.\n   *\n   * @remarks\n   * Requires the `MANAGE_GUILD` permission.\n   *\n   * @see {@link https://docs.discord.com/developers/resources/auto-moderation#get-auto-moderation-rule}\n   */\n  async getAutomodRule(rest: RestManager, guildId: BigString, ruleId: BigString): Promise<DiscordAutoModerationRule> {\n    return await rest.get<DiscordAutoModerationRule>(rest.routes.guilds.automod.rule(guildId, ruleId));\n  },\n  /**\n   * Gets the list of automod rules for a guild.\n   *\n   * @param guildId - The ID of the guild to get the rules from.\n   * @returns A collection of {@link DiscordAutoModerationRule} objects assorted by rule ID.\n   *\n   * @remarks\n   * Requires the `MANAGE_GUILD` permission.\n   *\n   * @see {@link https://docs.discord.com/developers/resources/auto-moderation#list-auto-moderation-rules-for-guild}\n   */\n  async getAutomodRules(rest: RestManager, guildId: BigString): Promise<DiscordAutoModerationRule[]> {\n    return await rest.get<DiscordAutoModerationRule[]>(rest.routes.guilds.automod.rules(guildId));\n  },\n  /**\n   * Gets the list of available voice regions.\n   *\n   * @returns A collection of {@link DiscordVoiceRegion} objects assorted by voice region ID.\n   */\n  async getAvailableVoiceRegions(rest: RestManager): Promise<DiscordVoiceRegion[]> {\n    return await rest.get<DiscordVoiceRegion[]>(rest.routes.regions());\n  },\n  /**\n   * Gets a ban by user ID.\n   *\n   * @param guildId - The ID of the guild to get the ban from.\n   * @param userId - The ID of the user to get the ban for.\n   * @returns An instance of {@link DiscordBan}.\n   *\n   * @remarks\n   * Requires the `BAN_MEMBERS` permission.\n   *\n   * @see {@link https://docs.discord.com/developers/resources/guild#get-guild-ban}\n   */\n  async getBan(rest: RestManager, guildId: BigString, userId: BigString): Promise<DiscordBan> {\n    return await rest.get<DiscordBan>(rest.routes.guilds.members.ban(guildId, userId));\n  },\n  /**\n   * Gets the list of bans for a guild.\n   *\n   * @param guildId - The ID of the guild to get the list of bans for.\n   * @param options - The parameters for the fetching of the list of bans.\n   * @returns A collection of {@link DiscordBan} objects assorted by user ID.\n   *\n   * @remarks\n   * Requires the `BAN_MEMBERS` permission.\n   *\n   * Users are ordered by their IDs in _ascending_ order.\n   *\n   * @see {@link https://docs.discord.com/developers/resources/guild#get-guild-bans}\n   */\n  async getBans(rest: RestManager, guildId: BigString, options?: GetBans): Promise<DiscordBan[]> {\n    return await rest.get<DiscordBan[]>(rest.routes.guilds.members.bans(guildId, options));\n  },\n  /**\n   * Gets a channel by its ID.\n   *\n   * @param channelId - The ID of the channel to get.\n   * @returns An instance of {@link DiscordChannel}.\n   *\n   * @remarks\n   * If the channel is a thread, a {@link DiscordThreadMember} object is included in the result.\n   *\n   * @see {@link https://docs.discord.com/developers/resources/channel#get-channel}\n   */\n  async getChannel(rest: RestManager, channelId: BigString): Promise<DiscordChannel> {\n    return await rest.get<DiscordChannel>(rest.routes.channels.channel(channelId));\n  },\n  /**\n   * Gets the list of invites for a channel.\n   *\n   * @param channelId - The ID of the channel to get the invites of.\n   * @returns A collection of {@link DiscordInviteMetadata} objects assorted by invite code.\n   *\n   * @remarks\n   * Requires the `MANAGE_CHANNELS` permission.\n   *\n   * Only usable for guild channels.\n   *\n   * @see {@link https://docs.discord.com/developers/resources/channel#get-channel-invites}\n   */\n  async getChannelInvites(rest: RestManager, channelId: BigString): Promise<DiscordInviteMetadata[]> {\n    return await rest.get<DiscordInviteMetadata[]>(rest.routes.channels.invites(channelId));\n  },\n  /**\n   * Gets the list of channels for a guild.\n   *\n   * @param guildId - The ID of the guild to get the channels of.\n   * @returns A collection of {@link DiscordChannel} objects assorted by channel ID.\n   *\n   * @remarks\n   * Excludes threads.\n   *\n   * @see {@link https://docs.discord.com/developers/resources/guild#get-guild-channels}\n   */\n  async getChannels(rest: RestManager, guildId: BigString): Promise<DiscordChannel[]> {\n    return await rest.get<DiscordChannel[]>(rest.routes.guilds.channels(guildId));\n  },\n  /**\n   * Gets a list of webhooks for a channel.\n   *\n   * @param channelId - The ID of the channel which to get the webhooks of.\n   * @returns A collection of {@link DiscordWebhook} objects assorted by webhook ID.\n   *\n   * @remarks\n   * Requires the `MANAGE_WEBHOOKS` permission.\n   *\n   * @see {@link https://docs.discord.com/developers/resources/webhook#get-channel-webhooks}\n   */\n  async getChannelWebhooks(rest: RestManager, channelId: BigString): Promise<DiscordWebhook[]> {\n    return await rest.get<DiscordWebhook[]>(rest.routes.channels.webhooks(channelId));\n  },\n  /**\n   * Gets or creates a DM channel with a user.\n   *\n   * @param userId - The ID of the user to create the DM channel with.\n   * @returns An instance of {@link DiscordChannel}.\n   *\n   * @see {@link https://docs.discord.com/developers/resources/user#create-dm}\n   */\n  async getDmChannel(rest: RestManager, userId: BigString): Promise<DiscordChannel> {\n    return await rest.post<DiscordChannel>(rest.routes.channels.dm(), {\n      body: { recipientId: userId },\n    });\n  },\n  /**\n   * Create a new group DM channel with multiple users.\n   *\n   * @param options - The options for create a new group dm\n   * @returns An instance of {@link DiscordChannel}.\n   *\n   * @remarks\n   * The access tokens require to have the `gdm.join` scope\n   *\n   * This endpoint is limited to 10 active group DMs.\n   *\n   * Fires a _Channel create_ gateway event.\n   *\n   * @see {@link https://docs.discord.com/developers/resources/user#create-group-dm}\n   */\n  async getGroupDmChannel(rest: RestManager, options: CreateGroupDmOptions): Promise<DiscordChannel> {\n    return await rest.post<DiscordChannel>(rest.routes.channels.dm(), {\n      body: options,\n    });\n  },\n  /**\n   * Gets an emoji by its ID.\n   *\n   * @param guildId - The ID of the guild from which to get the emoji.\n   * @param emojiId - The ID of the emoji to get.\n   * @returns An instance of {@link DiscordEmoji}.\n   *\n   * @remarks\n   * Includes the `user` field if the bot has the `MANAGE_GUILD_EXPRESSIONS` permission,\n   * or if the bot created the emoji and has the `CREATE_GUILD_EXPRESSIONS` permission.\n   *\n   * @see {@link https://docs.discord.com/developers/resources/emoji#get-guild-emoji}\n   */\n  async getEmoji(rest: RestManager, guildId: BigString, emojiId: BigString): Promise<DiscordEmoji> {\n    return await rest.get<DiscordEmoji>(rest.routes.guilds.emoji(guildId, emojiId));\n  },\n  /**\n   * Gets an application emoji by its ID.\n   *\n   * @param emojiId - The ID of the emoji to get.\n   * @returns An instance of {@link DiscordEmoji}.\n   *\n   * @remarks\n   * Always includes the `user` object for the team member that uploaded the emoji from the app's settings, or for the bot user if uploaded using the API.\n   *\n   * @see {@link https://docs.discord.com/developers/resources/emoji#get-application-emoji}\n   */\n  async getApplicationEmoji(rest: RestManager, emojiId: BigString): Promise<DiscordEmoji> {\n    return await rest.get<DiscordEmoji>(rest.routes.applicationEmoji(rest.applicationId, emojiId));\n  },\n  /**\n   * Gets the list of emojis for a guild.\n   *\n   * @param guildId - The ID of the guild which to get the emojis of.\n   * @returns A collection of {@link DiscordEmoji} objects assorted by emoji ID.\n   *\n   * @remarks\n   * Includes `user` fields if the bot has the `CREATE_GUILD_EXPRESSIONS` or `MANAGE_GUILD_EXPRESSIONS` permission.\n   *\n   * @see {@link https://docs.discord.com/developers/resources/emoji#list-guild-emojis}\n   */\n  async getEmojis(rest: RestManager, guildId: BigString): Promise<DiscordEmoji[]> {\n    return await rest.get<DiscordEmoji[]>(rest.routes.guilds.emojis(guildId));\n  },\n  /**\n   * Gets the list of emojis for an application.\n   *\n   * @returns An object with the array of {@link DiscordEmoji} objects.\n   *\n   * @remarks\n   * Always includes the `user` object for the team member that uploaded the emoji from the app's settings, or for the bot user if uploaded using the API.\n   *\n   * @see {@link https://docs.discord.com/developers/resources/emoji#list-application-emojis}\n   */\n  async getApplicationEmojis(rest: RestManager): Promise<{ items: DiscordEmoji[] }> {\n    return await rest.get<{ items: DiscordEmoji[] }>(rest.routes.applicationEmojis(rest.applicationId));\n  },\n  /**\n   * Gets a follow-up message to an interaction by the ID of the message.\n   *\n   * @param token - The interaction token to use, provided in the original interaction.\n   * @param messageId - The ID of the message to get.\n   * @returns An instance of {@link DiscordMessage}.\n   *\n   * @remarks\n   * Unlike `getMessage()`, this endpoint allows the bot user to act without:\n   * - Needing to be able to see the contents of the channel that the message is in. (`READ_MESSAGES` permission.)\n   * - Requiring the `MESSAGE_CONTENT` intent.\n   *\n   * Does not support ephemeral follow-up messages due to these being stateless.\n   *\n   * @see {@link https://docs.discord.com/developers/interactions/receiving-and-responding#get-followup-message}\n   */\n  async getFollowupMessage(rest: RestManager, token: string, messageId: BigString): Promise<DiscordMessage> {\n    return await rest.get<DiscordMessage>(rest.routes.interactions.responses.message(rest.applicationId, token, messageId), { unauthorized: true });\n  },\n  /** Get the bots Gateway metadata that can help during the operation of large or sharded bots. */\n  async getGatewayBot(rest: RestManager): Promise<DiscordGetGatewayBot> {\n    return await rest.get<DiscordGetGatewayBot>(rest.routes.gatewayBot());\n  },\n  /**\n   * Gets a global application command by its ID.\n   *\n   * @param commandId - The ID of the command to get.\n   * @returns An instance of {@link DiscordApplicationCommand}.\n   *\n   * @see {@link https://docs.discord.com/developers/interactions/application-commands#get-global-application-command}\n   */\n  async getGlobalApplicationCommand(rest: RestManager, commandId: BigString): Promise<DiscordApplicationCommand> {\n    return await rest.get<DiscordApplicationCommand>(rest.routes.interactions.commands.command(rest.applicationId, commandId));\n  },\n  /**\n   * Gets the list of your bot's global application commands.\n   *\n   * @param options - The parameters for the fetching of global application commands\n   * @returns A collection of {@link DiscordApplicationCommand} objects assorted by command ID.\n   *\n   * @see {@link https://docs.discord.com/developers/interactions/application-commands#get-global-application-commands}\n   */\n  async getGlobalApplicationCommands(rest: RestManager, options?: GetGlobalApplicationCommandsOptions): Promise<DiscordApplicationCommand[]> {\n    return await rest.get<DiscordApplicationCommand[]>(rest.routes.interactions.commands.commands(rest.applicationId, options?.withLocalizations));\n  },\n  /**\n   * Gets a guild by its ID.\n   *\n   * @param guildId - The ID of the guild to get.\n   * @param options - The parameters for the fetching of the guild.\n   * @returns An instance of {@link DiscordGuild}.\n   *\n   * @see {@link https://docs.discord.com/developers/resources/guild#get-guild}\n   */\n  async getGuild(rest: RestManager, guildId: BigString, options?: { counts?: boolean }): Promise<DiscordGuild> {\n    options ??= { counts: true };\n\n    return await rest.get<DiscordGuild>(rest.routes.guilds.guild(guildId, options.counts));\n  },\n  /**\n   * Get the user guilds.\n   *\n   * @param bearerToken - The access token of the user, if unspecified the bot token is used instead\n   * @param options - The parameters for the fetching of the guild.\n   * @returns An array of partial {@link DiscordGuild}.\n   *\n   * @remarks\n   * If used with an access token, the token needs to have the `guilds` scope\n   *\n   * @see {@link https://docs.discord.com/developers/resources/user#get-current-user-guilds}\n   */\n  async getGuilds(rest: RestManager, bearerToken?: string, options?: GetUserGuilds): Promise<Partial<DiscordGuild>[]> {\n    const makeRequestOptions: MakeRequestOptions | undefined = bearerToken\n      ? {\n          headers: {\n            authorization: `Bearer ${bearerToken}`,\n          },\n          unauthorized: true,\n        }\n      : undefined;\n\n    return await rest.get<Partial<DiscordGuild>[]>(rest.routes.guilds.userGuilds(options), makeRequestOptions);\n  },\n  /**\n   * Gets a guild application command by its ID.\n   *\n   * @param guildId - The ID of the guild the command is registered in.\n   * @param commandId - The ID of the command to get.\n   * @returns An instance of {@link DiscordApplicationCommand}.\n   *\n   * @see {@link https://docs.discord.com/developers/interactions/application-commands#get-guild-application-command}\n   */\n  async getGuildApplicationCommand(rest: RestManager, commandId: BigString, guildId: BigString): Promise<DiscordApplicationCommand> {\n    return await rest.get<DiscordApplicationCommand>(rest.routes.interactions.commands.guilds.one(rest.applicationId, guildId, commandId));\n  },\n  /**\n   * Gets the list of application commands registered by your bot in a guild.\n   *\n   * @param guildId - The ID of the guild the commands are registered in.\n   * @param options - The parameters for the fetching of guild application commands\n   * @returns A collection of {@link DiscordApplicationCommand} objects assorted by command ID.\n   *\n   * @see {@link https://docs.discord.com/developers/interactions/application-commands#get-global-application-commandss}\n   */\n  async getGuildApplicationCommands(\n    rest: RestManager,\n    guildId: BigString,\n    options?: GetGuildApplicationCommandsOptions,\n  ): Promise<DiscordApplicationCommand[]> {\n    return await rest.get<DiscordApplicationCommand[]>(\n      rest.routes.interactions.commands.guilds.all(rest.applicationId, guildId, options?.withLocalizations),\n    );\n  },\n  /**\n   * Gets the preview of a guild by a guild's ID.\n   *\n   * @param guildId - The ID of the guild to get the preview of.\n   * @returns An instance of {@link DiscordGuildPreview}.\n   *\n   * @remarks\n   * If the bot user is not in the guild, the guild must be discoverable.\n   *\n   * @see {@link https://docs.discord.com/developers/resources/guild#get-guild-preview}\n   */\n  async getGuildPreview(rest: RestManager, guildId: BigString): Promise<DiscordGuildPreview> {\n    return await rest.get<DiscordGuildPreview>(rest.routes.guilds.preview(guildId));\n  },\n  /**\n   * Returns a sticker object for the given guild and sticker IDs.\n   *\n   * @param guildId The ID of the guild to get\n   * @param stickerId The ID of the sticker to get\n   * @return A {@link DiscordSticker}\n   *\n   * @remarks Includes the user field if the bot has the `CREATE_GUILD_EXPRESSIONS` or `MANAGE_GUILD_EXPRESSIONS` permission.\n   *\n   * @see {@link https://docs.discord.com/developers/resources/sticker#get-guild-sticker}\n   */\n  async getGuildSticker(rest: RestManager, guildId: BigString, stickerId: BigString): Promise<DiscordSticker> {\n    return await rest.get<DiscordSticker>(rest.routes.guilds.sticker(guildId, stickerId));\n  },\n  /**\n   * Returns an array of sticker objects for the given guild.\n   *\n   * @param guildId The ID of the guild to get\n   * @returns A collection of {@link DiscordSticker} objects assorted by sticker ID.\n   *\n   * @remarks Includes user fields if the bot has the `CREATE_GUILD_EXPRESSIONS` or `MANAGE_GUILD_EXPRESSIONS` permission.\n   *\n   * @see {@link https://docs.discord.com/developers/resources/sticker#list-guild-stickers}\n   */\n  async getGuildStickers(rest: RestManager, guildId: BigString): Promise<DiscordSticker[]> {\n    return await rest.get<DiscordSticker[]>(rest.routes.guilds.stickers(guildId));\n  },\n  /**\n   * Gets a template by its code.\n   *\n   * @param templateCode - The code of the template to get.\n   * @returns An instance of {@link DiscordTemplate}.\n   *\n   * @remarks\n   * Requires the `MANAGE_GUILD` permission.\n   *\n   * @see {@link https://docs.discord.com/developers/resources/guild-template#get-guild-template}\n   */\n  async getGuildTemplate(rest: RestManager, templateCode: string): Promise<DiscordTemplate> {\n    return await rest.get<DiscordTemplate>(rest.routes.guilds.templates.code(templateCode));\n  },\n  /**\n   * Gets the list of templates for a guild.\n   *\n   * @param guildId - The ID of the guild to get the list of templates for.\n   * @returns A collection of {@link DiscordTemplate} objects assorted by template code.\n   *\n   * @remarks\n   * Requires the `MANAGE_GUILD` permission.\n   *\n   * @see {@link https://docs.discord.com/developers/resources/guild-template#get-guild-templates}\n   */\n  async getGuildTemplates(rest: RestManager, guildId: BigString): Promise<DiscordTemplate[]> {\n    return await rest.get<DiscordTemplate[]>(rest.routes.guilds.templates.all(guildId));\n  },\n  /**\n   * Gets the list of webhooks for a guild.\n   *\n   * @param guildId - The ID of the guild to get the list of webhooks for.\n   * @returns A collection of {@link DiscordWebhook} objects assorted by webhook ID.\n   *\n   * @remarks\n   * Requires the `MANAGE_WEBHOOKS` permission.\n   *\n   * @see {@link https://docs.discord.com/developers/resources/webhook#get-guild-webhooks}\n   */\n  async getGuildWebhooks(rest: RestManager, guildId: BigString): Promise<DiscordWebhook[]> {\n    return await rest.get<DiscordWebhook[]>(rest.routes.guilds.webhooks(guildId));\n  },\n  /**\n   * Gets the list of integrations attached to a guild.\n   *\n   * @param guildId - The ID of the guild to get the list of integrations from.\n   * @returns A collection of {@link DiscordIntegration} objects assorted by integration ID.\n   *\n   * @remarks\n   * Requires the `MANAGE_GUILD` permission.\n   *\n   * @see {@link https://docs.discord.com/developers/resources/guild#get-guild-integrations}\n   */\n  async getIntegrations(rest: RestManager, guildId: BigString): Promise<DiscordIntegration[]> {\n    return await rest.get<DiscordIntegration[]>(rest.routes.guilds.integrations(guildId));\n  },\n  /**\n   * Gets an invite to a channel by its invite code.\n   *\n   * @param inviteCode - The invite code of the invite to get.\n   * @param options - The parameters for the fetching of the invite.\n   * @returns An instance of {@link DiscordInviteMetadata}.\n   *\n   * @see {@link https://docs.discord.com/developers/resources/invite#get-invite}\n   */\n  async getInvite(rest: RestManager, inviteCode: string, options?: GetInvite): Promise<DiscordInviteMetadata> {\n    return await rest.get<DiscordInviteMetadata>(rest.routes.guilds.invite(inviteCode, options));\n  },\n  /**\n   * Gets the list of invites for a guild.\n   *\n   * @param guildId - The ID of the guild to get the invites from.\n   * @returns A collection of {@link DiscordInviteMetadata} objects assorted by invite code.\n   *\n   * @remarks\n   * Requires the `MANAGE_GUILD` or `VIEW_AUDIT_LOG` permission.\n   *\n   * @see {@link https://docs.discord.com/developers/resources/invite#get-invites}\n   */\n  async getInvites(rest: RestManager, guildId: BigString): Promise<DiscordInviteMetadata[]> {\n    return await rest.get<DiscordInviteMetadata[]>(rest.routes.guilds.invites(guildId));\n  },\n  /**\n   * Gets a message from a channel by the ID of the message.\n   *\n   * @param channelId - The ID of the channel from which to get the message.\n   * @param messageId - The ID of the message to get.\n   * @returns An instance of {@link DiscordMessage}.\n   *\n   * @remarks\n   * Requires that the bot user be able to see the contents of the channel in which the message was posted.\n   *\n   * If getting a message from a guild channel:\n   * - Requires the `READ_MESSAGE_HISTORY` permission.\n   *\n   * @see {@link https://docs.discord.com/developers/resources/channel#get-channel-message}\n   */\n  async getMessage(rest: RestManager, channelId: BigString, messageId: BigString): Promise<DiscordMessage> {\n    return await rest.get<DiscordMessage>(rest.routes.channels.message(channelId, messageId));\n  },\n  /**\n   * Gets multiple messages from a channel.\n   *\n   * @param channelId - The ID of the channel from which to get the messages.\n   * @param options - The parameters for the fetching of the messages.\n   * @returns Returns an array of {@link DiscordMessage} objects from newest to oldest on success.\n   *\n   * @remarks\n   * Requires that the bot user be able to see the contents of the channel in which the messages were posted.\n   *\n   * If getting a messages from a guild channel:\n   * - Requires the `READ_MESSAGE_HISTORY` permission.\n   *\n   * @see {@link https://docs.discord.com/developers/resources/channel#get-channel-messages}\n   */\n  async getMessages(rest: RestManager, channelId: BigString, options?: GetMessagesOptions): Promise<DiscordMessage[]> {\n    return await rest.get<DiscordMessage[]>(rest.routes.channels.messages(channelId, options));\n  },\n  /**\n   * Search messages in a guild.\n   *\n   * @remarks\n   * Requires `READ_MESSAGE_HISTORY` and is restricted by the `MESSAGE_CONTENT` intent.\n   *\n   * @see {@link https://docs.discord.com/developers/resources/message#search-guild-messages}\n   */\n  async searchGuildMessages(\n    rest: RestManager,\n    guildId: BigString,\n    options?: SearchGuildMessagesOptions,\n  ): Promise<DiscordSearchGuildMessages | DiscordSearchGuildMessagesIndexing> {\n    return await rest.get<DiscordSearchGuildMessages | DiscordSearchGuildMessagesIndexing>(rest.routes.guilds.messagesSearch(guildId, options));\n  },\n  /**\n   * Returns a sticker pack for the given ID.\n   *\n   * @returns A {@link DiscordStickerPack} object.\n   *\n   * @see {@link https://docs.discord.com/developers/resources/sticker#get-sticker-pack}\n   */\n  async getStickerPack(rest: RestManager, stickerPackId: BigString): Promise<DiscordStickerPack> {\n    return await rest.get<DiscordStickerPack>(rest.routes.stickerPack(stickerPackId));\n  },\n  /**\n   * Returns the list of sticker packs available.\n   *\n   * @returns A collection of {@link DiscordStickerPack} objects assorted by sticker ID.\n   *\n   * @see {@link https://docs.discord.com/developers/resources/sticker#list-sticker-packs}\n   */\n  async getStickerPacks(rest: RestManager): Promise<DiscordStickerPack[]> {\n    return await rest.get<DiscordStickerPack[]>(rest.routes.stickerPacks());\n  },\n  /**\n   * Gets the initial message response to an interaction.\n   *\n   * @param token - The interaction token to use, provided in the original interaction.\n   * @returns An instance of {@link DiscordMessage}.\n   *\n   * @remarks\n   * Unlike `getMessage()`, this endpoint allows the bot user to act without:\n   * - Needing to be able to see the contents of the channel that the message is in. (`READ_MESSAGES` permission.)\n   * - Requiring the `MESSAGE_CONTENT` intent.\n   *\n   * Does not support ephemeral follow-up messages due to these being stateless.\n   *\n   * @see {@link https://docs.discord.com/developers/interactions/receiving-and-responding#get-original-interaction-response}\n   */\n  async getOriginalInteractionResponse(rest: RestManager, token: string): Promise<DiscordMessage> {\n    return await rest.get<DiscordMessage>(rest.routes.interactions.responses.original(rest.applicationId, token), { unauthorized: true });\n  },\n  /**\n   * Retrieves the list of pins in a channel.\n   *\n   * @param channelId - The ID of the channel to get the pins for.\n   * @param options - The options for the fetching of the pins.\n   * @returns A {@link DiscordGetChannelPins} objects\n   *\n   * @remarks\n   * Requires the `VIEW_CHANNEL` permission.\n   *\n   * If the user is missing the `READ_MESSAGE_HISTORY` permission in the channel, then no pins will be returned.\n   *\n   * @see {@link https://docs.discord.com/developers/resources/message#get-channel-pins}\n   */\n  async getChannelPins(rest: RestManager, channelId: BigString, options?: GetChannelPinsOptions): Promise<DiscordGetChannelPins> {\n    return await rest.get(rest.routes.channels.messagePins(channelId, options));\n  },\n  /**\n   * Gets the pinned messages for a channel.\n   *\n   * @param channelId - The ID of the channel to get the pinned messages for.\n   * @returns A collection of {@link DiscordMessage} objects assorted by message ID.\n   *\n   * @remarks\n   * Requires that the bot user be able to see the contents of the channel in which the messages were posted.\n   *\n   * If getting a message from a guild channel:\n   * - Requires the `READ_MESSAGE_HISTORY` permission.\n   *\n   * @see {@link https://docs.discord.com/developers/resources/message#get-pinned-messages-deprecated}\n   * @deprecated Use {@link getChannelPins} instead.\n   */\n  async getPinnedMessages(rest: RestManager, channelId: BigString): Promise<DiscordMessage[]> {\n    return await rest.get<DiscordMessage[]>(rest.routes.channels.pins(channelId));\n  },\n  /**\n   * Gets the list of private archived threads for a channel.\n   *\n   * @param channelId - The ID of the channel to get the archived threads for.\n   * @param options - The parameters for the fetching of threads.\n   * @returns An instance of {@link DiscordListArchivedThreads}.\n   *\n   * @remarks\n   * Requires the `READ_MESSAGE_HISTORY` permission.\n   * Requires the `MANAGE_THREADS` permission.\n   *\n   * Returns threads of type {@link ChannelTypes}.GuildPrivateThread.\n   *\n   * Threads are ordered by the `archive_timestamp` property included in the metadata of the object in descending order.\n   *\n   * @see {@link https://docs.discord.com/developers/resources/channel#list-private-archived-threads}\n   */\n  async getPrivateArchivedThreads(rest: RestManager, channelId: BigString, options?: ListArchivedThreads): Promise<DiscordListArchivedThreads> {\n    return await rest.get<DiscordListArchivedThreads>(rest.routes.channels.threads.private(channelId, options));\n  },\n  /**\n   * Gets the list of private archived threads the bot is a member of for a channel.\n   *\n   * @param channelId - The ID of the channel to get the archived threads for.\n   * @param options - The parameters for the fetching of threads.\n   * @returns An instance of {@link DiscordListArchivedThreads}.\n   *\n   * @remarks\n   * Requires the `READ_MESSAGE_HISTORY` permission.\n   *\n   * Returns threads of type {@link ChannelTypes}.GuildPrivateThread.\n   *\n   * Threads are ordered by the `id` property in descending order.\n   *\n   * @see {@link https://docs.discord.com/developers/resources/channel#list-joined-private-archived-threads}\n   */\n  async getPrivateJoinedArchivedThreads(rest: RestManager, channelId: BigString, options?: ListArchivedThreads): Promise<DiscordListArchivedThreads> {\n    return await rest.get<DiscordListArchivedThreads>(rest.routes.channels.threads.joined(channelId, options));\n  },\n  /**\n   * Gets the number of members that would be kicked from a guild during pruning.\n   *\n   * @param guildId - The ID of the guild to get the prune count of.\n   * @param options - The parameters for the fetching of the prune count.\n   * @returns A number indicating the number of members that would be kicked.\n   *\n   * @remarks\n   * Requires the `MANAGE_GUILD` and `KICK_MEMBERS` permissions, unless the guild has the `PRUNE_REQUIRES_ADMIN` guild feature, in which case it requires the `ADMINISTRATOR` permission.\n   *\n   * @see {@link https://docs.discord.com/developers/resources/guild#get-guild-prune-count}\n   */\n  async getPruneCount(rest: RestManager, guildId: BigString, options?: GetGuildPruneCountQuery): Promise<DiscordPrunedCount> {\n    return await rest.get<DiscordPrunedCount>(rest.routes.guilds.prune(guildId, options));\n  },\n  /**\n   * Gets the list of public archived threads for a channel.\n   *\n   * @param channelId - The ID of the channel to get the archived threads for.\n   * @param options - The parameters for the fetching of threads.\n   * @returns An instance of {@link DiscordListArchivedThreads}.\n   *\n   * @remarks\n   * Requires the `READ_MESSAGE_HISTORY` permission.\n   *\n   * If called on a channel of type {@link ChannelTypes}.GuildText, returns threads of type {@link ChannelTypes}.GuildPublicThread.\n   * If called on a channel of type {@link ChannelTypes}.GuildNews, returns threads of type {@link ChannelTypes}.GuildNewsThread.\n   *\n   * Threads are ordered by the `archive_timestamp` property included in the metadata of the object in descending order.\n   *\n   * @see {@link https://docs.discord.com/developers/resources/channel#list-public-archived-threads}\n   */\n  async getPublicArchivedThreads(rest: RestManager, channelId: BigString, options?: ListArchivedThreads): Promise<DiscordListArchivedThreads> {\n    return await rest.get<DiscordListArchivedThreads>(rest.routes.channels.threads.public(channelId, options));\n  },\n  /**\n   * Gets the list of roles for a guild.\n   *\n   * @param guildId - The ID of the guild to get the list of roles for.\n   * @returns A collection of {@link DiscordRole} objects assorted by role ID.\n   *\n   * @remarks\n   * ⚠️ This endpoint should be used sparingly due to {@link DiscordRole} objects already being included in guild payloads.\n   *\n   * @see {@link https://docs.discord.com/developers/resources/guild#get-guild-roles}\n   */\n  async getRoles(rest: RestManager, guildId: BigString): Promise<DiscordRole[]> {\n    return await rest.get<DiscordRole[]>(rest.routes.guilds.roles.all(guildId));\n  },\n  /**\n   * Gets a role by id for a guild.\n   *\n   * @param guildId - The ID of the guild to get role for.\n   * @param roleId - The ID of the role.\n   * @returns A {@link DiscordRole} object.\n   *\n   * @see {@link https://docs.discord.com/developers/resources/guild#get-guild-role}\n   */\n  async getRole(rest: RestManager, guildId: BigString, roleId: BigString): Promise<DiscordRole> {\n    return await rest.get<DiscordRole>(rest.routes.guilds.roles.one(guildId, roleId));\n  },\n  /**\n   * Gets a scheduled event by its ID.\n   *\n   * @param guildId - The ID of the guild to get the scheduled event from.\n   * @param eventId - The ID of the scheduled event to get.\n   * @param options - The parameters for the fetching of the scheduled event.\n   * @returns An instance of {@link DiscordScheduledEvent}.\n   *\n   * @see {@link https://docs.discord.com/developers/resources/guild-scheduled-event#get-guild-scheduled-event}\n   */\n  async getScheduledEvent(\n    rest: RestManager,\n    guildId: BigString,\n    eventId: BigString,\n    options?: { withUserCount?: boolean },\n  ): Promise<DiscordScheduledEvent> {\n    return await rest.get<DiscordScheduledEvent>(rest.routes.guilds.events.event(guildId, eventId, options?.withUserCount));\n  },\n  /**\n   * Gets the list of scheduled events for a guild.\n   *\n   * @param guildId - The ID of the guild to get the scheduled events from.\n   * @param options - The parameters for the fetching of the scheduled events.\n   * @returns A collection of {@link DiscordScheduledEvent} objects assorted by event ID.\n   *\n   * @see {@link https://docs.discord.com/developers/resources/guild-scheduled-event#list-scheduled-events-for-guild}\n   */\n  async getScheduledEvents(rest: RestManager, guildId: BigString, options?: GetScheduledEvents): Promise<DiscordScheduledEvent[]> {\n    return await rest.get<DiscordScheduledEvent[]>(rest.routes.guilds.events.events(guildId, options?.withUserCount));\n  },\n  /**\n   * Gets the list of subscribers to a scheduled event from a guild.\n   *\n   * @param guildId - The ID of the guild to get the subscribers to the scheduled event from.\n   * @param eventId - The ID of the scheduled event to get the subscribers of.\n   * @param options - The parameters for the fetching of the subscribers.\n   * @returns A collection of {@link DiscordUser} objects assorted by user ID.\n   *\n   * @remarks\n   * Requires the `MANAGE_EVENTS` permission.\n   *\n   * Users are ordered by their IDs in _ascending_ order.\n   *\n   * @see {@link https://docs.discord.com/developers/resources/guild-scheduled-event#get-guild-scheduled-event-users}\n   */\n  async getScheduledEventUsers(\n    rest: RestManager,\n    guildId: BigString,\n    eventId: BigString,\n    options?: GetScheduledEventUsers,\n  ): Promise<{ user: DiscordUser; member?: DiscordMember }[]> {\n    return await rest.get<Array<{ user: DiscordUser; member?: DiscordMember }>>(rest.routes.guilds.events.users(guildId, eventId, options));\n  },\n  /** Get the bots Gateway metadata that can help during the operation of large or sharded bots. */\n  async getSessionInfo(rest: RestManager): Promise<DiscordGetGatewayBot> {\n    return await rest.snake.getGatewayBot();\n  },\n  /**\n   * Gets the stage instance associated with a stage channel, if one exists.\n   *\n   * @param channelId - The ID of the stage channel the stage instance is associated with.\n   * @returns An instance of {@link DiscordStageInstance}.\n   *\n   * @see {@link https://docs.discord.com/developers/resources/stage-instance#get-stage-instance}\n   */\n  async getStageInstance(rest: RestManager, channelId: BigString): Promise<DiscordStageInstance> {\n    return await rest.get<DiscordStageInstance>(rest.routes.channels.stage(channelId));\n  },\n  /**\n   * Returns the current user's voice state in the guild.\n   *\n   * @param guildId - The ID of the guild to get the voice state from.\n   * @returns An instance of {@link DiscordVoiceState}.\n   *\n   * @see {@link https://docs.discord.com/developers/resources/voice#get-current-user-voice-state}\n   */\n  async getOwnVoiceState(rest: RestManager, guildId: BigString): Promise<DiscordVoiceState> {\n    return await rest.get<DiscordVoiceState>(rest.routes.guilds.voice(guildId));\n  },\n  /**\n   * Returns the specified user's voice state in the guild.\n   *\n   * @param guildId - The ID of the guild to get the voice state from.\n   * @param userId - The ID of the user to get the voice state from\n   * @returns An instance of {@link DiscordVoiceState}.\n   *\n   * @remarks\n   * If the specified user is connected to a voice channel, the current user must have permission to connect to the channel.\n   *\n   * @see {@link https://docs.discord.com/developers/resources/voice#get-user-voice-state}\n   */\n  async getUserVoiceState(rest: RestManager, guildId: BigString, userId: BigString): Promise<DiscordVoiceState> {\n    return await rest.get<DiscordVoiceState>(rest.routes.guilds.voice(guildId, userId));\n  },\n  /**\n   * Returns a sticker object for the given sticker ID.\n   *\n   * @param stickerId The ID of the sticker to get\n   * @returns A {@link DiscordSticker}\n   *\n   * @see {@link https://docs.discord.com/developers/resources/sticker#get-sticker}\n   */\n  async getSticker(rest: RestManager, stickerId: BigString): Promise<DiscordSticker> {\n    return await rest.get<DiscordSticker>(rest.routes.sticker(stickerId));\n  },\n  /**\n   * Gets a thread member by their user ID.\n   *\n   * @param channelId - The ID of the thread to get the thread member of.\n   * @param userId - The user ID of the thread member to get.\n   * @param options - The parameters for the fetching of the thread member.\n   * @returns An instance of {@link DiscordThreadMember}.\n   *\n   * @see {@link https://docs.discord.com/developers/resources/channel#get-thread-member}\n   */\n  async getThreadMember(rest: RestManager, channelId: BigString, userId: BigString, options?: GetThreadMember): Promise<DiscordThreadMember> {\n    return await rest.get<DiscordThreadMember>(rest.routes.channels.threads.getUser(channelId, userId, options));\n  },\n  /**\n   * Gets the list of thread members for a thread.\n   *\n   * @param channelId - The ID of the thread to get the thread members of.\n   * @param options - The parameters for the fetching of the thread members.\n   * @returns A collection of {@link DiscordThreadMember} assorted by user ID.\n   *\n   * @remarks\n   * Requires the application to have the `GUILD_MEMBERS` privileged intent enabled.\n   *\n   * @see {@link https://docs.discord.com/developers/resources/channel#list-thread-members}\n   */\n  async getThreadMembers(rest: RestManager, channelId: BigString, options?: ListThreadMembers): Promise<DiscordThreadMember[]> {\n    return await rest.get<DiscordThreadMember[]>(rest.routes.channels.threads.members(channelId, options));\n  },\n  /**\n   * Gets the list of users that reacted with an emoji to a message.\n   *\n   * @param channelId - The ID of the channel the message to get the users for is in.\n   * @param messageId - The ID of the message to get the users for.\n   * @param reaction - The reaction for which to get the users.\n   * @param options - The parameters for the fetching of the users.\n   * @returns A collection of {@link DiscordUser} objects assorted by user ID.\n   *\n   * @see {@link https://docs.discord.com/developers/resources/channel#get-reactions}\n   */\n  async getReactions(\n    rest: RestManager,\n    channelId: BigString,\n    messageId: BigString,\n    reaction: string,\n    options?: GetReactions,\n  ): Promise<DiscordUser[]> {\n    return await rest.get<DiscordUser[]>(rest.routes.channels.reactions.message(channelId, messageId, reaction, options));\n  },\n  /**\n   * Get a user's data from the api\n   *\n   * @param id The user's id\n   * @returns {DiscordUser}\n   */\n  async getUser(rest: RestManager, id: BigString): Promise<DiscordUser> {\n    return await rest.get<DiscordUser>(rest.routes.user(id));\n  },\n  /**\n   * Get the current user data.\n   *\n   * @param bearerToken - The access token of the user\n   * @returns {DiscordUser}\n   *\n   * @remarks\n   * This requires the `identify` scope.\n   *\n   * To get the mail this also requires the `email` scope\n   */\n  async getCurrentUser(rest: RestManager, bearerToken: string): Promise<DiscordUser> {\n    return await rest.get<DiscordUser>(rest.routes.currentUser(), {\n      headers: {\n        authorization: `Bearer ${bearerToken}`,\n      },\n      unauthorized: true,\n    });\n  },\n  /**\n   * Get the current user connections.\n   *\n   * @param bearerToken - The access token of the user\n   * @returns {DiscordConnection[]}\n   *\n   * @remarks\n   * This requires the `connections` scope.\n   */\n  async getUserConnections(rest: RestManager, bearerToken: string): Promise<DiscordConnection[]> {\n    return await rest.get<DiscordConnection[]>(rest.routes.oauth2.connections(), {\n      headers: {\n        authorization: `Bearer ${bearerToken}`,\n      },\n      unauthorized: true,\n    });\n  },\n  /**\n   * Get the current user application role connection for the application.\n   *\n   * @param bearerToken - The access token of the user\n   * @param applicationId - The id of the application to get the role connection\n   * @returns {DiscordApplicationRoleConnection}\n   *\n   * @remarks\n   * The access token requires the `role_connections.write` scope.\n   *\n   * @see {@link https://docs.discord.com/developers/resources/user#get-user-application-role-connection}\n   */\n  async getUserApplicationRoleConnection(\n    rest: RestManager,\n    bearerToken: string,\n    applicationId: BigString,\n  ): Promise<DiscordApplicationRoleConnection> {\n    return await rest.get<DiscordApplicationRoleConnection>(rest.routes.oauth2.roleConnections(applicationId), {\n      headers: {\n        authorization: `Bearer ${bearerToken}`,\n      },\n      unauthorized: true,\n    });\n  },\n  /**\n   * Gets information about the vanity url of a guild.\n   *\n   * @param guildId - The ID of the guild to get the vanity url information for.\n   * @returns An instance of {@link DiscordVanityUrl}.\n   *\n   * @remarks\n   * Requires the `MANAGE_GUILD` permission.\n   *\n   * The `code` property will be `null` if the guild does not have a set vanity url.\n   *\n   * @see {@link https://docs.discord.com/developers/resources/guild#get-guild-vanity-url}\n   */\n  async getVanityUrl(rest: RestManager, guildId: BigString): Promise<DiscordVanityUrl> {\n    return await rest.get<DiscordVanityUrl>(rest.routes.guilds.vanity(guildId));\n  },\n  /**\n   * Gets the list of voice regions for a guild.\n   *\n   * @param guildId - The ID of the guild to get the voice regions for.\n   * @returns A collection of {@link DiscordVoiceRegion} objects assorted by voice region ID.\n   *\n   * @see {@link https://docs.discord.com/developers/resources/guild#get-guild-voice-regions}\n   */\n  async getVoiceRegions(rest: RestManager, guildId: BigString): Promise<DiscordVoiceRegion[]> {\n    return await rest.get<DiscordVoiceRegion[]>(rest.routes.guilds.regions(guildId));\n  },\n  /**\n   * Gets a webhook by its ID.\n   *\n   * @param webhookId - The ID of the webhook to get.\n   * @returns An instance of {@link DiscordWebhook}.\n   *\n   * @remarks\n   * Requires the `MANAGE_WEBHOOKS` permission unless the application making the request owns the webhook.\n   *\n   * @see {@link https://docs.discord.com/developers/resources/webhook#get-webhook}\n   */\n  async getWebhook(rest: RestManager, webhookId: BigString): Promise<DiscordWebhook> {\n    return await rest.get<DiscordWebhook>(rest.routes.webhooks.id(webhookId));\n  },\n  /**\n   * Gets a webhook message by its ID.\n   *\n   * @param webhookId - The ID of the webhook to get a message of.\n   * @param token - The webhook token, used to get webhook messages.\n   * @param messageId - the ID of the webhook message to get.\n   * @param options - The parameters for the fetching of the message.\n   * @returns An instance of {@link DiscordMessage}.\n   *\n   * @see {@link https://docs.discord.com/developers/resources/webhook#get-webhook-message}\n   */\n  async getWebhookMessage(\n    rest: RestManager,\n    webhookId: BigString,\n    token: string,\n    messageId: BigString,\n    options?: GetWebhookMessageOptions,\n  ): Promise<DiscordMessage> {\n    return await rest.get<DiscordMessage>(rest.routes.webhooks.message(webhookId, token, messageId, options), {\n      unauthorized: true,\n    });\n  },\n  /**\n   * Gets a webhook using the webhook token, thereby bypassing the need for authentication + permissions.\n   *\n   * @param webhookId - The ID of the webhook to get.\n   * @param token - The webhook token, used to get the webhook.\n   * @returns An instance of {@link DiscordWebhook}.\n   *\n   * @see {@link https://docs.discord.com/developers/resources/webhook#get-webhook-with-token}\n   */\n  async getWebhookWithToken(rest: RestManager, webhookId: BigString, token: string): Promise<DiscordWebhook> {\n    return await rest.get<DiscordWebhook>(rest.routes.webhooks.webhook(webhookId, token), {\n      unauthorized: true,\n    });\n  },\n  /**\n   * Gets the welcome screen for a guild.\n   *\n   * @param guildId - The ID of the guild to get the welcome screen for.\n   * @returns An instance of {@link DiscordWelcomeScreen}.\n   *\n   * @remarks\n   * If the welcome screen is not enabled:\n   * - Requires the `MANAGE_GUILD` permission.\n   *\n   * @see {@link https://docs.discord.com/developers/resources/guild#get-guild-welcome-screen}\n   */\n  async getWelcomeScreen(rest: RestManager, guildId: BigString): Promise<DiscordWelcomeScreen> {\n    return await rest.get<DiscordWelcomeScreen>(rest.routes.guilds.welcome(guildId));\n  },\n  /**\n   * Gets the guild widget by guild ID.\n   *\n   * @param guildId - The ID of the guild to get the widget of.\n   * @returns An instance of {@link DiscordGuildWidget}.\n   *\n   * @remarks\n   * Fires an `INVITE_CREATED` Gateway event when an invite channel is defined and a new `Invite` is generated.\n   *\n   * @see {@link https://docs.discord.com/developers/resources/guild#get-guild-widget}\n   */\n  async getWidget(rest: RestManager, guildId: BigString): Promise<DiscordGuildWidget> {\n    return await rest.get<DiscordGuildWidget>(rest.routes.guilds.widgetJson(guildId));\n  },\n  /**\n   * Gets the settings of a guild's widget.\n   *\n   * @param guildId - The ID of the guild to get the widget of.\n   * @returns An instance of {@link DiscordGuildWidgetSettings}.\n   *\n   * @remarks\n   * Requires the `MANAGE_GUILD` permission.\n   *\n   * @see {@link https://docs.discord.com/developers/resources/guild#get-guild-widget-settings}\n   */\n  async getWidgetSettings(rest: RestManager, guildId: BigString): Promise<DiscordGuildWidgetSettings> {\n    return await rest.get<DiscordGuildWidgetSettings>(rest.routes.guilds.widget(guildId));\n  },\n  /**\n   * Adds the bot user to a thread.\n   *\n   * @param channelId - The ID of the thread to add the bot user to.\n   *\n   * @remarks\n   * Requires the thread not be archived.\n   *\n   * Fires a _Thread Members Update_ gateway event.\n   *\n   * @see {@link https://docs.discord.com/developers/resources/channel#join-thread}\n   */\n  async joinThread(rest: RestManager, channelId: BigString): Promise<void> {\n    await rest.put(rest.routes.channels.threads.me(channelId));\n  },\n  /**\n   * Leaves a guild.\n   *\n   * @param guildId - The ID of the guild to leave.\n   *\n   * @remarks\n   * Fires a _Guild Delete_ event.\n   *\n   * @see {@link https://docs.discord.com/developers/resources/user#leave-guild}\n   */\n  async leaveGuild(rest: RestManager, guildId: BigString): Promise<void> {\n    await rest.delete(rest.routes.guilds.leave(guildId));\n  },\n  /**\n   * Removes the bot user from a thread.\n   *\n   * @param channelId - The ID of the thread to remove the bot user from.\n   *\n   * @remarks\n   * Requires the thread not be archived.\n   *\n   * Fires a _Thread Members Update_ gateway event.\n   *\n   * @see {@link https://docs.discord.com/developers/resources/channel#leave-thread}\n   */\n  async leaveThread(rest: RestManager, channelId: BigString): Promise<void> {\n    await rest.delete(rest.routes.channels.threads.me(channelId));\n  },\n  /**\n   * Cross-posts a message posted in an announcement channel to subscribed channels.\n   *\n   * @param channelId - The ID of the announcement channel.\n   * @param messageId - The ID of the message to cross-post.\n   * @returns An instance of the cross-posted {@link DiscordMessage}.\n   *\n   * @remarks\n   * Requires the `SEND_MESSAGES` permission.\n   *\n   * If not cross-posting own message:\n   * - Requires the `MANAGE_MESSAGES` permission.\n   *\n   * Fires a _Message Create_ event in the guilds the subscribed channels are in.\n   *\n   * @see {@link https://docs.discord.com/developers/resources/channel#crosspost-message}\n   */\n  async publishMessage(rest: RestManager, channelId: BigString, messageId: BigString): Promise<DiscordMessage> {\n    return await rest.post<DiscordMessage>(rest.routes.channels.crosspost(channelId, messageId));\n  },\n  /**\n   * Removes a role from a member.\n   *\n   * @param guildId - The ID of the guild the member to remove the role from is in.\n   * @param userId - The user ID of the member to remove the role from.\n   * @param roleId - The ID of the role to remove from the member.\n   * @param {string} [reason] - An optional reason for the action, to be included in the audit log.\n   *\n   * @remarks\n   * Requires the `MANAGE_ROLES` permission.\n   *\n   * Fires a _Guild Member Update_ gateway event.\n   *\n   * @see {@link https://docs.discord.com/developers/resources/guild#remove-guild-member-role}\n   */\n  async removeRole(rest: RestManager, guildId: BigString, userId: BigString, roleId: BigString, reason?: string): Promise<void> {\n    await rest.delete(rest.routes.guilds.roles.member(guildId, userId, roleId), { reason });\n  },\n  /**\n   * Removes a member from a thread.\n   *\n   * @param channelId - The ID of the thread to remove the thread member of.\n   * @param userId - The user ID of the thread member to remove.\n   *\n   * @remarks\n   * If the thread is of type {@link ChannelTypes}.GuildPrivateThread, requires to be the creator of the thread.\n   * Otherwise, requires the `MANAGE_THREADS` permission.\n   *\n   * Requires the thread not be archived.\n   *\n   * Fires a _Thread Members Update_ gateway event.\n   *\n   * @see {@link https://docs.discord.com/developers/resources/channel#remove-thread-member}\n   */\n  async removeThreadMember(rest: RestManager, channelId: BigString, userId: BigString): Promise<void> {\n    await rest.delete(rest.routes.channels.threads.user(channelId, userId));\n  },\n  /**\n   * Removes a member from a Group DM.\n   *\n   * @param channelId - The ID of the channel to remove the recipient user of.\n   * @param userId - The user ID of the user to remove.\n   *\n   * @see {@link https://docs.discord.com/developers/resources/channel#group-dm-remove-recipient}\n   */\n  async removeDmRecipient(rest: RestManager, channelId: BigString, userId: BigString): Promise<void> {\n    await rest.delete(rest.routes.channels.dmRecipient(channelId, userId));\n  },\n  /**\n   * Sends a message to a channel.\n   *\n   * @param channelId - The ID of the channel to send the message in.\n   * @param options - The parameters for the creation of the message.\n   * @returns An instance of the created {@link DiscordMessage}.\n   *\n   * @remarks\n   * Requires that the bot user be able to see the contents of the channel the message is to be sent in.\n   *\n   * If sending a message to a guild channel:\n   * - Requires the `SEND_MESSAGES` permission.\n   *\n   * If sending a TTS message:\n   * - Requires the `SEND_TTS_MESSAGES` permission.\n   *\n   * If sending a message as a reply to another message:\n   * - Requires the `READ_MESSAGE_HISTORY` permission.\n   * - The message being replied to cannot be a system message.\n   *\n   * ⚠️ The maximum size of a request (accounting for any attachments and message content) for bot users is _8 MiB_.\n   *\n   * Fires a _Message Create_ gateway event.\n   *\n   * @see {@link https://docs.discord.com/developers/resources/channel#create-message}\n   */\n  async sendMessage(rest: RestManager, channelId: BigString, options: CreateMessageOptions): Promise<DiscordMessage> {\n    return await rest.post<DiscordMessage>(rest.routes.channels.messages(channelId), { body: options, files: options.files });\n  },\n  /**\n   * Sends a follow-up message to an interaction.\n   *\n   * @param token - The interaction token to use, provided in the original interaction.\n   * @param options - The parameters for the creation of the message.\n   * @returns An instance of the created {@link DiscordMessage}.\n   *\n   * @remarks\n   * ⚠️ Interaction tokens are only valid for _15 minutes_.\n   *\n   * By default, mentions are suppressed. To enable mentions, pass a mention object with the callback data.\n   *\n   * Unlike `sendMessage()`, this endpoint allows the bot user to act without:\n   * - Needing to be able to see the contents of the channel that the message is in. (`READ_MESSAGES` permission.)\n   * - Requiring the `MESSAGE_CONTENT` intent.\n   *\n   * Apps are limited to 5 followup messages per interaction if it was initiated from a user-installed app and isn't installed in the server\n   * You can check if it was initiated from a user-installed app that isn't installed in the server by checking if {@link DiscordInteraction.authorizing_integration_owners | authorizingIntegrationOwners} only contains {@link DiscordApplicationIntegrationType.UserInstall | UserInstall}.\n   *\n   * Fires a _Message Create_ event.\n   *\n   * @see {@link https://docs.discord.com/developers/interactions/receiving-and-responding#create-followup-message}\n   */\n  async sendFollowupMessage(rest: RestManager, token: string, options: InteractionCallbackData): Promise<DiscordMessage> {\n    return await rest.post(rest.routes.webhooks.webhook(rest.applicationId, token), {\n      body: options,\n      files: options.files,\n      unauthorized: true,\n    });\n  },\n  /**\n   * Sends a response to an interaction.\n   *\n   * @param interactionId - The ID of the interaction to respond to.\n   * @param token - The interaction token to use, provided in the original interaction.\n   * @param options - The parameters for the creation of the message.\n   * @param params - The query parameters for the response of the callback\n   * @returns Nothing or the {@link DiscordInteractionCallbackResponse} if withResponse param is true\n   *\n   * @remarks\n   * ⚠️ Interaction tokens are only valid for _15 minutes_.\n   *\n   * By default, mentions are suppressed. To enable mentions, pass a mention object with the callback data.\n   *\n   * Unlike `sendMessage()`, this endpoint allows the bot user to act without:\n   * - Needing to be able to see the contents of the channel that the message is in. (`READ_MESSAGES` permission.)\n   * - Requiring the `MESSAGE_CONTENT` intent.\n   *\n   * Fires a _Message Create_ event.\n   *\n   * @see {@link https://docs.discord.com/developers/interactions/receiving-and-responding#create-interaction-response}\n   */\n  async sendInteractionResponse(\n    rest: RestManager,\n    interactionId: BigString,\n    token: string,\n    options: InteractionResponse,\n    params?: InteractionCallbackOptions,\n  ): Promise<void | DiscordInteractionCallbackResponse> {\n    return await rest.post<void | DiscordInteractionCallbackResponse>(rest.routes.interactions.responses.callback(interactionId, token, params), {\n      body: options,\n      files: options.data?.files,\n      runThroughQueue: false,\n      unauthorized: true,\n    });\n  },\n  /**\n   * Creates a thread, using an existing message as its point of origin.\n   *\n   * @param channelId - The ID of the channel in which to create the thread.\n   * @param messageId - The ID of the message to use as the thread's point of origin.\n   * @param options - The parameters to use for the creation of the thread.\n   * @param {string} [reason] - An optional reason for the action, to be included in the audit log.\n   * @returns An instance of the created {@link DiscordChannel}.\n   *\n   * @remarks\n   * If called on a channel of type {@link ChannelTypes}.GuildText, creates a {@link ChannelTypes}.GuildPublicThread.\n   * If called on a channel of type {@link ChannelTypes}.GuildNews, creates a {@link ChannelTypes}.GuildNewsThread.\n   * Does not work on channels of type {@link ChannelTypes}.GuildForum.\n   *\n   * The ID of the created thread will be the same as the ID of the source message.\n   *\n   * Fires a _Thread Create_ gateway event.\n   *\n   * @see {@link https://docs.discord.com/developers/resources/channel#start-thread-from-message}\n   */\n  async startThreadWithMessage(\n    rest: RestManager,\n    channelId: BigString,\n    messageId: BigString,\n    options: StartThreadWithMessage,\n    reason?: string,\n  ): Promise<DiscordChannel> {\n    return await rest.post<DiscordChannel>(rest.routes.channels.threads.message(channelId, messageId), { body: options, reason });\n  },\n  /**\n   * Creates a thread without using a message as the thread's point of origin.\n   *\n   * @param channelId - The ID of the channel in which to create the thread.\n   * @param options - The parameters to use for the creation of the thread.\n   * @param {string} [reason] - An optional reason for the action, to be included in the audit log.\n   * @returns An instance of the created {@link DiscordChannel | Thread}.\n   *\n   * @remarks\n   * Creating a private thread requires the server to be boosted.\n   *\n   * Fires a _Thread Create_ gateway event.\n   *\n   * @see {@link https://docs.discord.com/developers/resources/channel#start-thread-without-message}\n   */\n  async startThreadWithoutMessage(\n    rest: RestManager,\n    channelId: BigString,\n    options: StartThreadWithoutMessage,\n    reason?: string,\n  ): Promise<DiscordChannel> {\n    return await rest.post<DiscordChannel>(rest.routes.channels.threads.all(channelId), { body: options, reason });\n  },\n  /**\n   * Get a list of users that voted for this specific answer.\n   *\n   * @param channelId - The ID of the channel in which the message with the poll lives\n   * @param messageId - The ID of the message in which the poll lives\n   * @param answerId - The ID of the answer to get the users that voted that answer\n   * @param options - The options for the request\n   * @returns The list of users that voted for the specific answer.\n   */\n  async getPollAnswerVoters(\n    rest: RestManager,\n    channelId: BigString,\n    messageId: BigString,\n    answerId: number,\n    options?: GetPollAnswerVotes,\n  ): Promise<DiscordGetAnswerVotesResponse> {\n    return await rest.get<DiscordGetAnswerVotesResponse>(rest.routes.channels.polls.votes(channelId, messageId, answerId, options));\n  },\n  /**\n   * Immediately ends the poll.\n   *\n   * @param channelId - The ID of the channel in which the message with the poll lives\n   * @param messageId - The ID of the message in which the poll lives\n   * @returns The message with the expired poll\n   *\n   * @remarks\n   * You cannot end polls from other users.\n   *\n   * Fires a _Message Update_ gateway event\n   */\n  async endPoll(rest: RestManager, channelId: BigString, messageId: BigString): Promise<DiscordMessage> {\n    return await rest.post<DiscordMessage>(rest.routes.channels.polls.expire(channelId, messageId));\n  },\n  /**\n   * Synchronises a template with the current state of a guild.\n   *\n   * @param guildId - The ID of the guild to synchronise a template of.\n   * @returns An instance of the edited {@link DiscordTemplate}.\n   *\n   * @remarks\n   * Requires the `MANAGE_GUILD` permission.\n   *\n   * Fires a _Guild Update_ gateway event.\n   *\n   * @see {@link https://docs.discord.com/developers/resources/guild-template#get-guild-templates}\n   */\n  async syncGuildTemplate(rest: RestManager, guildId: BigString): Promise<DiscordTemplate> {\n    return await rest.put<DiscordTemplate>(rest.routes.guilds.templates.all(guildId));\n  },\n  /**\n   * Triggers a typing indicator for the specified channel, which expires after 10 seconds.\n   *\n   * @param channelId - The ID of the channel in which to trigger the typing indicator.\n   *\n   * @remarks\n   * Generally bots should **not** use this route.\n   * However, if a bot is responding to a command and expects the computation to take a few seconds,\n   * this endpoint may be called to let the user know that the bot is processing their message.\n   *\n   * Fires a _Typing Start_ gateway event.\n   *\n   * @see {@link https://docs.discord.com/developers/resources/channel#trigger-typing-indicator}\n   */\n  async triggerTypingIndicator(rest: RestManager, channelId: BigString): Promise<void> {\n    await rest.post(rest.routes.channels.typing(channelId));\n  },\n  /**\n   * Re-registers the list of global application commands, overwriting the previous commands completely.\n   *\n   * @param commands - The list of commands to use to overwrite the previous list.\n   * @param options - Additional options for the endpoint.\n   * @returns A collection of {@link DiscordApplicationCommand} objects assorted by command ID.\n   *\n   * @remarks\n   * ❗ Commands that are not present in the `commands` array will be __deleted__.\n   *\n   * ⚠️ Commands that do not already exist will count towards the daily limit of _200_ new commands.\n   *\n   * When using the bearer token the token needs the `applications.commands.update` scope and must be a `Client grant` token.\n   *  You will be able to update only your own application commands\n   *\n   * @see {@link https://docs.discord.com/developers/interactions/application-commands#bulk-overwrite-global-application-commands}\n   */\n  async upsertGlobalApplicationCommands(\n    rest: RestManager,\n    commands: CreateApplicationCommand[],\n    options?: UpsertGlobalApplicationCommandOptions,\n  ): Promise<DiscordApplicationCommand[]> {\n    const restOptions: MakeRequestOptions = { body: commands };\n\n    if (options?.bearerToken) {\n      restOptions.unauthorized = true;\n      restOptions.headers = {\n        authorization: `Bearer ${options.bearerToken}`,\n      };\n    }\n\n    return await rest.put<DiscordApplicationCommand[]>(rest.routes.interactions.commands.commands(rest.applicationId), restOptions);\n  },\n  /**\n   * Re-registers the list of application commands registered in a guild, overwriting the previous commands completely.\n   *\n   * @param guildId - The ID of the guild whose list of commands to overwrite.\n   * @param commands - The list of commands to use to overwrite the previous list.\n   * @param options - Additional options for the endpoint.\n   * @returns A collection of {@link DiscordApplicationCommand} objects assorted by command ID.\n   *\n   * @remarks\n   * ❗ Commands that are not present in the `commands` array will be __deleted__.\n   *\n   * ⚠️ Commands that do not already exist will count towards the daily limit of _200_ new commands.\n   *\n   * When using the bearer token the token needs the `applications.commands.update` scope and must be a `Client grant` token.\n   *  You will be able to update only your own application commands\n   *\n   * @see {@link https://docs.discord.com/developers/interactions/application-commands#bulk-overwrite-guild-application-commands}\n   */\n  async upsertGuildApplicationCommands(\n    rest: RestManager,\n    guildId: BigString,\n    commands: CreateApplicationCommand[],\n    options?: UpsertGuildApplicationCommandOptions,\n  ): Promise<DiscordApplicationCommand[]> {\n    const restOptions: MakeRequestOptions = { body: commands };\n\n    if (options?.bearerToken) {\n      restOptions.unauthorized = true;\n      restOptions.headers = {\n        authorization: `Bearer ${options.bearerToken}`,\n      };\n    }\n\n    return await rest.put<DiscordApplicationCommand[]>(rest.routes.interactions.commands.guilds.all(rest.applicationId, guildId), restOptions);\n  },\n  /**\n   * Bans a user from a guild.\n   *\n   * @param guildId - The ID of the guild to ban the user from.\n   * @param userId - The ID of the user to ban from the guild.\n   * @param options - The parameters for the creation of the ban.\n   * @param {string} [reason] - An optional reason for the action, to be included in the audit log.\n   *\n   * @remarks\n   * Requires the `BAN_MEMBERS` permission.\n   *\n   * Fires a _Guild Ban Add_ gateway event.\n   *\n   * @see {@link https://docs.discord.com/developers/resources/guild#create-guild-ban}\n   */\n  async banMember(rest: RestManager, guildId: BigString, userId: BigString, options?: CreateGuildBan, reason?: string): Promise<void> {\n    await rest.put<void>(rest.routes.guilds.members.ban(guildId, userId), { body: options, reason });\n  },\n  /**\n   * Bans up to 200 users from a guild.\n   *\n   * @param guildId - The ID of the guild to ban the users from.\n   * @param options - The users to ban and the other options for the ban.\n   * @param {string} [reason] - An optional reason for the action, to be included in the audit log.\n   *\n   * @remarks\n   * Requires the `BAN_MEMBERS` and `MANAGE_GUILD` permissions.\n   *\n   * If all provided users fail to be banned, discord will respond with an error (code: `500000: Failed to ban users`)\n   *\n   * Fires as many _Guild Ban Add_ gateway events as many user where banned.\n   *\n   * @see {@link https://docs.discord.com/developers/resources/guild#bulk-guild-ban}\n   */\n  async bulkBanMembers(rest: RestManager, guildId: BigString, options: CreateGuildBulkBan, reason?: string): Promise<DiscordBulkBan> {\n    return await rest.post<DiscordBulkBan>(rest.routes.guilds.members.bulkBan(guildId), { body: options, reason });\n  },\n  /**\n   * Edits the nickname of the bot user.\n   *\n   * @param guildId - The ID of the guild to edit the nickname of the bot user in.\n   * @param options - The parameters for the edit of the nickname.\n   * @param {string} [reason] - An optional reason for the action, to be included in the audit log.\n   * @returns An instance of the edited {@link DiscordMember}\n   *\n   * @remarks\n   * Fires a _Guild Member Update_ gateway event.\n   *\n   * @see {@link https://docs.discord.com/developers/resources/guild#modify-current-member}\n   */\n  async editCurrentMember(rest: RestManager, guildId: BigString, options: ModifyCurrentMember, reason?: string): Promise<DiscordMember> {\n    return await rest.patch<DiscordMember>(rest.routes.guilds.members.bot(guildId), { body: options, reason });\n  },\n  /**\n   * Edits a member's properties.\n   *\n   * @param guildId - The ID of the guild to edit the member of.\n   * @param userId - The user ID of the member to edit.\n   * @param {string} [reason] - An optional reason for the action, to be included in the audit log.\n   * @param options - The parameters for the edit of the user.\n   *\n   * @remarks\n   * This endpoint requires various permissions depending on what is edited about the member.\n   * To find out the required permission to enact a change, read the documentation of this endpoint's {@link ModifyGuildMember | parameters}.\n   *\n   * Fires a _Guild Member Update_ gateway event.\n   *\n   * @see {@link https://docs.discord.com/developers/resources/guild#modify-guild-member}\n   */\n  async editMember(rest: RestManager, guildId: BigString, userId: BigString, options: ModifyGuildMember, reason?: string): Promise<DiscordMember> {\n    return await rest.patch<DiscordMemberWithUser>(rest.routes.guilds.members.member(guildId, userId), { body: options, reason });\n  },\n  /**\n   * Gets the current member object.\n   *\n   * @param bearerToken - The access token of the user\n   * @param guildId - The ID of the guild to get the member object for.\n   * @returns An instance of {@link DiscordMemberWithUser}.\n   *\n   * @remarks\n   * The access tokens needs the `guilds.members.read` scope\n   *\n   * @see {@link https://docs.discord.com/developers/resources/user#get-current-user-guild-member}\n   */\n  async getCurrentMember(rest: RestManager, guildId: BigString, bearerToken: string): Promise<DiscordMemberWithUser> {\n    return await rest.get<DiscordMemberWithUser>(rest.routes.guilds.members.currentMember(guildId), {\n      headers: {\n        authorization: `Bearer ${bearerToken}`,\n      },\n      unauthorized: true,\n    });\n  },\n  /**\n   * Gets the member object by user ID.\n   *\n  \n   * @param guildId - The ID of the guild to get the member object for.\n   * @param userId - The ID of the user to get the member object for.\n   * @returns An instance of {@link DiscordMemberWithUser}.\n   *\n   * @see {@link https://docs.discord.com/developers/resources/guild#get-guild-member}\n   */\n  async getMember(rest: RestManager, guildId: BigString, userId: BigString): Promise<DiscordMemberWithUser> {\n    return await rest.get<DiscordMemberWithUser>(rest.routes.guilds.members.member(guildId, userId));\n  },\n  /**\n   * Gets the list of members for a guild.\n   *\n   * @param guildId - The ID of the guild to get the list of members for.\n   * @param options - The parameters for the fetching of the members.\n   * @returns A collection of {@link DiscordMemberWithUser} objects assorted by user ID.\n   *\n   * @remarks\n   * Requires the `GUILD_MEMBERS` intent.\n   *\n   * ⚠️ It is not recommended to use this endpoint with very large bots. Instead, opt to use `fetchMembers()`:\n   * REST communication only permits 50 requests to be made per second, while gateways allow for up to 120 requests\n   * per minute per shard. For more information, read {@link https://docs.discord.com/developers/topics/rate-limits#rate-limits}.\n   *\n   * @see {@link https://docs.discord.com/developers/resources/guild#list-guild-members}\n   * @see {@link https://docs.discord.com/developers/events/gateway-events#request-guild-members}\n   * @see {@link https://docs.discord.com/developers/topics/rate-limits#rate-limits}\n   */\n  async getMembers(rest: RestManager, guildId: BigString, options: ListGuildMembers): Promise<DiscordMemberWithUser[]> {\n    return await rest.get<DiscordMemberWithUser[]>(rest.routes.guilds.members.members(guildId, options));\n  },\n  /**\n   * Returns a serialized activity instance, if it exists. Useful for preventing unwanted activity sessions.\n   *\n   * @param applicationId - The ID of the application\n   * @param instanceId - The ID of the activity instance\n   */\n  async getApplicationActivityInstance(rest: RestManager, applicationId: BigString, instanceId: string): Promise<DiscordActivityInstance> {\n    return await rest.get<DiscordActivityInstance>(rest.routes.applicationActivityInstance(applicationId, instanceId));\n  },\n  /**\n   * Kicks a member from a guild.\n   *\n  \n   * @param guildId - The ID of the guild to kick the member from.\n   * @param userId - The user ID of the member to kick from the guild.\n   * @param {string} [reason] - An optional reason for the action, to be included in the audit log.\n   *\n   * @remarks\n   * Requires the `KICK_MEMBERS` permission.\n   *\n   * Fires a _Guild Member Remove_ gateway event.\n   *\n   * @see {@link https://docs.discord.com/developers/resources/guild#remove-guild-member}\n   */\n  async kickMember(rest: RestManager, guildId: BigString, userId: BigString, reason?: string): Promise<void> {\n    await rest.delete(rest.routes.guilds.members.member(guildId, userId), {\n      reason,\n    });\n  },\n  /**\n   * Pins a message in a channel.\n   *\n   * @param channelId - The ID of the channel where the message is to be pinned.\n   * @param messageId - The ID of the message to pin.\n   * @param {string} [reason] - An optional reason for the action, to be included in the audit log.\n   *\n   * @remarks\n   * Requires the `PIN_MESSAGES` permission.\n   *\n   * Fires a _Channel Pins Update_ event.\n   *\n   * @see {@link https://docs.discord.com/developers/resources/message#pin-message}\n   */\n  async pinMessage(rest: RestManager, channelId: BigString, messageId: BigString, reason?: string): Promise<void> {\n    await rest.put(rest.routes.channels.messagePin(channelId, messageId), { reason });\n  },\n  /**\n   * Initiates the process of pruning inactive members.\n   *\n  \n   * @param guildId - The ID of the guild to prune the members of.\n   * @param options - The parameters for the pruning of members.\n   * @param {string} [reason] - An optional reason for the action, to be included in the audit log.\n   * @returns A number indicating how many members were pruned.\n   *\n   * @remarks\n   * Requires the `MANAGE_GUILD` and `KICK_MEMBERS` permissions, unless the guild has the `PRUNE_REQUIRES_ADMIN` guild feature, in which case it requires the `ADMINISTRATOR` permission.\n   *\n   * ❗ Requests to this endpoint will time out for large guilds. To prevent this from happening, set the {@link BeginGuildPrune.computePruneCount} property of the options object parameter to `false`. This will begin the process of pruning, and immediately return `undefined`, rather than wait for the process to complete before returning the actual count of members that have been kicked.\n   *\n   * ⚠️ By default, this process will not remove members with a role. To include the members who have a _particular subset of roles_, specify the role(s) in the {@link BeginGuildPrune.includeRoles | includeRoles} property of the options object parameter.\n   *\n   * Fires a _Guild Member Remove_ gateway event for every member kicked.\n   *\n   * @see {@link https://docs.discord.com/developers/resources/guild#begin-guild-prune}\n   */\n  async pruneMembers(rest: RestManager, guildId: BigString, options: BeginGuildPrune, reason?: string): Promise<{ pruned: number | null }> {\n    return await rest.post<{ pruned: number | null }>(rest.routes.guilds.members.prune(guildId), { body: options, reason });\n  },\n  /**\n   * Gets the list of members whose usernames or nicknames start with a provided string.\n   *\n  \n   * @param guildId - The ID of the guild to search in.\n   * @param query - The string to match usernames or nicknames against.\n   * @param options - The parameters for searching through the members.\n   * @returns A collection of {@link DiscordMember} objects assorted by user ID.\n   *\n   * @see {@link https://docs.discord.com/developers/resources/guild#search-guild-members}\n   */\n  async searchMembers(\n    rest: RestManager,\n    guildId: BigString,\n    query: string,\n    options?: Omit<SearchMembers, 'query'>,\n  ): Promise<DiscordMemberWithUser[]> {\n    return await rest.get<DiscordMemberWithUser[]>(rest.routes.guilds.members.search(guildId, query, options));\n  },\n  /**\n   * Unbans a user from a guild.\n   *\n   * @param guildId - The ID of the guild to unban the user in.\n   * @param userId - The ID of the user to unban.\n   * @param {string} [reason] - An optional reason for the action, to be included in the audit log.\n   *\n   * @remarks\n   * Requires the `BAN_MEMBERS` permission.\n   *\n   * Fires a _Guild Ban Remove_ gateway event.\n   *\n   * @see {@link https://docs.discord.com/developers/resources/guild#remove-guild-ban}\n   */\n  async unbanMember(rest: RestManager, guildId: BigString, userId: BigString, reason?: string): Promise<void> {\n    await rest.delete(rest.routes.guilds.members.ban(guildId, userId), { reason });\n  },\n  /**\n   * Unpin a message in a channel.\n   *\n   * @param channelId - The ID of the channel where the message is pinned.\n   * @param messageId - The ID of the message to unpin.\n   * @param {string} [reason] - An optional reason for the action, to be included in the audit log.\n   *\n   * @remarks\n   * Requires the `PIN_MESSAGES` permission.\n   *\n   * Fires a _Channel Pins Update_ event.\n   *\n   * @see {@link https://docs.discord.com/developers/resources/message#unpin-message}\n   */\n  async unpinMessage(rest: RestManager, channelId: BigString, messageId: BigString, reason?: string): Promise<void> {\n    await rest.delete(rest.routes.channels.messagePin(channelId, messageId), { reason });\n  },\n  /**\n   * Get the guild onboarding\n   *\n   * @param guildId - The guild to get the onboarding from\n   */\n  async getGuildOnboarding(rest: RestManager, guildId: BigString): Promise<DiscordGuildOnboarding> {\n    return await rest.get<DiscordGuildOnboarding>(rest.routes.guilds.onboarding(guildId));\n  },\n  /**\n   * Modifies the onboarding configuration of the guild.\n   *\n   * @param guildId - The guild to edit the onboarding from\n   * @param {string} [reason] - An optional reason for the action, to be included in the audit log.\n   *\n   * @remarks\n   * Requires the `MANAGE_GUILD` and `MANAGE_ROLES` permissions.\n   *\n   * Onboarding enforces constraints when enabled. These constraints are:\n   *  - at least 7 default channels\n   *  - at least 5 of the 7 channels must allow sending messages to the \\@everyone role\n   *\n   * The `mode` field modifies what is considered when enforcing these constraints.\n   */\n  async editGuildOnboarding(rest: RestManager, guildId: BigString, options: EditGuildOnboarding, reason?: string): Promise<DiscordGuildOnboarding> {\n    return await rest.put<DiscordGuildOnboarding>(rest.routes.guilds.onboarding(guildId), {\n      body: options,\n      reason,\n    });\n  },\n  /**\n   * Modifies the incident actions of the guild.\n   *\n   * @param guildId - The guild to edit the incident actions from\n   * @param options - The options for the incident actions\n   *\n   * @remarks\n   * Requires the `MANAGE_GUILD` permission.\n   */\n  async modifyGuildIncidentActions(rest: RestManager, guildId: BigString, options: ModifyGuildIncidentActions): Promise<DiscordIncidentsData> {\n    return await rest.put<DiscordIncidentsData>(rest.routes.guilds.incidentActions(guildId), { body: options });\n  },\n  /**\n   * Returns all entitlements for a given app, active and expired.\n   *\n   * @param applicationId - The id of the application to get the entitlements\n   * @param {GetEntitlements} [options] - The optional query params for the endpoint\n   */\n  async listEntitlements(rest: RestManager, applicationId: BigString, options?: GetEntitlements): Promise<DiscordEntitlement[]> {\n    return await rest.get<DiscordEntitlement[]>(rest.routes.monetization.entitlements(applicationId, options));\n  },\n  /**\n   * Returns an entitlement.\n   *\n   * @param applicationId - The id of the application to get the entitlement\n   * @param entitlementId - The id of the entitlement to get\n   */\n  async getEntitlement(rest: RestManager, applicationId: BigString, entitlementId: BigString): Promise<DiscordEntitlement> {\n    return await rest.get<DiscordEntitlement>(rest.routes.monetization.entitlement(applicationId, entitlementId));\n  },\n  /**\n   * Creates a test entitlement to a given SKU for a given guild or user. Discord will act as though that user or guild has entitlement to your premium offering.\n   *\n   * @param applicationId - The id of the application to create the entitlement\n   * @param body - The options for new entitlement\n   *\n   * @remarks\n   * This endpoint returns a partial entitlement object.\n   * It will not contain subscription_id, starts_at, or ends_at, as it's valid in perpetuity.\n   */\n  async createTestEntitlement(rest: RestManager, applicationId: BigString, body: CreateTestEntitlement): Promise<Partial<DiscordEntitlement>> {\n    return await rest.post<DiscordEntitlement>(rest.routes.monetization.entitlements(applicationId), {\n      body,\n    });\n  },\n  /**\n   * Deletes a currently-active test entitlement. Discord will act as though that user or guild no longer has entitlement to your premium offering.\n   *\n   * @param applicationId - The id of the application from where delete the entitlement\n   * @param entitlementId - The id of the entitlement to delete\n   */\n  async deleteTestEntitlement(rest: RestManager, applicationId: BigString, entitlementId: BigString): Promise<void> {\n    await rest.delete(rest.routes.monetization.entitlement(applicationId, entitlementId));\n  },\n  /**\n   * For One-Time Purchase consumable SKUs, marks a given entitlement for the user as consumed. The entitlement will have `consumed: true` when using {@link listEntitlements | List Entitlements}\n   *\n   * @param applicationId - The id of the application to get the entitlement\n   * @param entitlementId - The id of the entitlement to get\n   */\n  async consumeEntitlement(rest: RestManager, applicationId: BigString, entitlementId: BigString): Promise<void> {\n    await rest.post(rest.routes.monetization.consumeEntitlement(applicationId, entitlementId));\n  },\n  /**\n   * Returns all SKUs for a given application\n   *\n   * @param applicationId - The id of the application to get the SKUs\n   */\n  async listSkus(rest: RestManager, applicationId: BigString): Promise<DiscordSku[]> {\n    return await rest.get<DiscordSku[]>(rest.routes.monetization.skus(applicationId));\n  },\n  /**\n   * Returns all subscriptions containing the SKU, filtered by user.\n   *\n   * @param skuId - The id of the sku of get the subscriptions for\n   */\n  async listSubscriptions(rest: RestManager, skuId: BigString, options?: ListSkuSubscriptionsOptions): Promise<DiscordSubscription[]> {\n    return await rest.get<DiscordSubscription[]>(rest.routes.monetization.subscriptions(skuId, options));\n  },\n  /**\n   * Get a subscription by its ID.\n   *\n   * @param skuId - The id of the sku of get the subscriptions for\n   */\n  async getSubscription(rest: RestManager, skuId: BigString, subscriptionId: BigString): Promise<DiscordSubscription> {\n    return await rest.get<DiscordSubscription>(rest.routes.monetization.subscription(skuId, subscriptionId));\n  },\n  /**\n   * Send a soundboard sound to a voice channel the user is connected to.\n   *\n   * @param channelId - The id of the voice channel\n   *\n   * @remarks\n   * Fires a _Voice Channel Effect Send_ Gateway event.\n   *\n   * Requires the `SPEAK` and `USE_SOUNDBOARD` permissions, and also the `USE_EXTERNAL_SOUNDS` permission if the sound is from a different server.\n   * Additionally, requires the user to be connected to the voice channel, having a voice state without `deaf`, `self_deaf`, `mute`, or `suppress` enabled.\n   */\n  async sendSoundboardSound(rest: RestManager, channelId: BigString, options: SendSoundboardSound): Promise<void> {\n    await rest.post(rest.routes.soundboard.sendSound(channelId), {\n      body: options,\n    });\n  },\n  /** Returns an array of soundboard sound objects that can be used by all users. */\n  async listDefaultSoundboardSounds(rest: RestManager): Promise<DiscordSoundboardSound[]> {\n    return await rest.get<DiscordSoundboardSound[]>(rest.routes.soundboard.listDefault());\n  },\n  /**\n   * Returns a list of the guild's soundboard sounds.\n   *\n   * @param guildId - The guild to get the sounds from\n   *\n   * @remarks\n   * Includes `user` fields if the bot has the `CREATE_GUILD_EXPRESSIONS` or `MANAGE_GUILD_EXPRESSIONS` permission.\n   */\n  async listGuildSoundboardSounds(rest: RestManager, guildId: BigString): Promise<{ items: DiscordSoundboardSound[] }> {\n    return await rest.get<{ items: DiscordSoundboardSound[] }>(rest.routes.soundboard.guildSounds(guildId));\n  },\n  /**\n   * Returns a soundboard sound object for the given sound id.\n   *\n   * @param guildId - The guild to get the sounds from\n   * @param soundId - The sound id\n   *\n   * @remarks\n   * Includes `user` fields if the bot has the `CREATE_GUILD_EXPRESSIONS` or `MANAGE_GUILD_EXPRESSIONS` permission.\n   */\n  async getGuildSoundboardSound(rest: RestManager, guildId: BigString, soundId: BigString): Promise<DiscordSoundboardSound> {\n    return await rest.get<DiscordSoundboardSound>(rest.routes.soundboard.guildSound(guildId, soundId));\n  },\n  /**\n   * Create a new soundboard sound for the guild.\n   *\n   * @param guildId - The guild to create the sounds in\n   * @param options - The options to create the sound\n   * @param reason - The audit log reason\n   *\n   * @remarks\n   * Fires a _Guild Soundboard Sound Create_ Gateway event.\n   *\n   * Requires the `CREATE_GUILD_EXPRESSIONS` permission.\n   */\n  async createGuildSoundboardSound(\n    rest: RestManager,\n    guildId: BigString,\n    options: CreateGuildSoundboardSound,\n    reason?: string,\n  ): Promise<DiscordSoundboardSound> {\n    return await rest.post<DiscordSoundboardSound>(rest.routes.soundboard.guildSounds(guildId), {\n      body: options,\n      reason,\n    });\n  },\n  /**\n   * Modify the given soundboard sound.\n   *\n   * @param guildId - The guild to create the sounds in\n   * @param soundId - The sound id to update\n   * @param options - The options to update the sound\n   * @param reason - The audit log reason\n   *\n   * @remarks\n   * Fires a _Guild Soundboard Sound Update_ Gateway event.\n   *\n   * For sounds created by the current user, requires either the `CREATE_GUILD_EXPRESSIONS` or `MANAGE_GUILD_EXPRESSIONS` permission.\n   * For other sounds, requires the `MANAGE_GUILD_EXPRESSIONS` permission.\n   */\n  async modifyGuildSoundboardSound(\n    rest: RestManager,\n    guildId: BigString,\n    soundId: BigString,\n    options: ModifyGuildSoundboardSound,\n    reason?: string,\n  ): Promise<DiscordSoundboardSound> {\n    return await rest.post<DiscordSoundboardSound>(rest.routes.soundboard.guildSound(guildId, soundId), {\n      body: options,\n      reason,\n    });\n  },\n  /**\n   * Delete the given soundboard sound.\n   *\n   * @param guildId - The guild to create the sounds in\n   * @param soundId - The sound id to delete\n   * @param reason - The audit log reason\n   *\n   * @remarks\n   * Fires a _Guild Soundboard Sound Delete_ Gateway event.\n   *\n   * For sounds created by the current user, requires either the `CREATE_GUILD_EXPRESSIONS` or `MANAGE_GUILD_EXPRESSIONS` permission.\n   * For other sounds, requires the `MANAGE_GUILD_EXPRESSIONS` permission.\n   */\n  async deleteGuildSoundboardSound(rest: RestManager, guildId: BigString, soundId: BigString, reason?: string): Promise<void> {\n    return await rest.delete(rest.routes.soundboard.guildSound(guildId, soundId), {\n      reason,\n    });\n  },\n  /**\n   * Returns a list of application role connection metadata objects for the given application.\n   *\n   * @param applicationId - The application to get the role connections from\n   * @returns A list of application role connection metadata objects\n   */\n  async listApplicationRoleConnectionsMetadataRecords(\n    rest: RestManager,\n    applicationId: BigString,\n  ): Promise<DiscordApplicationRoleConnectionMetadata[]> {\n    return await rest.get<DiscordApplicationRoleConnectionMetadata[]>(rest.routes.applicationRoleConnectionMetadata(applicationId));\n  },\n  /**\n   * Updates and returns a list of application role connection metadata objects for the given application.\n   *\n   * @param applicationId - The application to get the role connections from\n   * @param options - The options to update the role connections\n   * @returns A list of application role connection metadata objects\n   *\n   * @remarks\n   * An application can have a maximum of 5 metadata records.\n   */\n  async updateApplicationRoleConnectionsMetadataRecords(\n    rest: RestManager,\n    applicationId: BigString,\n    options: Camelize<DiscordApplicationRoleConnectionMetadata[]>,\n  ): Promise<DiscordApplicationRoleConnectionMetadata[]> {\n    return await rest.put<DiscordApplicationRoleConnectionMetadata[]>(rest.routes.applicationRoleConnectionMetadata(applicationId), {\n      body: options,\n    });\n  },\n  /**\n   * Creates a new lobby, adding any of the specified members to it, if provided.\n   *\n   * @param options - The options to create the lobby\n   * @returns The created lobby\n   */\n  async createLobby(rest: RestManager, options: CreateLobby): Promise<DiscordLobby> {\n    return await rest.post<DiscordLobby>(rest.routes.lobby.create(), {\n      body: options,\n    });\n  },\n  /**\n   * Creates a new lobby for the application identified by a `secret`, or joins the calling user to the existing lobby with that secret if one already exists.\n   *\n   * Updates lobby metadata and the calling member's metadata on join.\n   *\n   * @param options - The options to create or join the lobby\n   * @returns - The created or joined lobby\n   *\n   * @remarks\n   * Uses `Bearer` token for authorization with the `sdk.social_layer` scope.\n   */\n  async createOrJoinLobby(rest: RestManager, options: CreateOrJoinLobby): Promise<DiscordLobby> {\n    return await rest.put<DiscordLobby>(rest.routes.lobby.create(), {\n      body: options,\n    });\n  },\n  /**\n   * Returns a lobby object for the specified lobby id, if it exists.\n   *\n   * @param lobbyId - The ID of the lobby to get\n   * @returns The lobby object\n   */\n  async getLobby(rest: RestManager, lobbyId: BigString): Promise<DiscordLobby> {\n    return await rest.get<DiscordLobby>(rest.routes.lobby.lobby(lobbyId));\n  },\n  /**\n   * Modifies the specified lobby with new values, if provided.\n   *\n   * @param lobbyId - The ID of the lobby to modify\n   * @param options - The options to modify the lobby\n   * @returns The modified lobby\n   */\n  async modifyLobby(rest: RestManager, lobbyId: BigString, options: ModifyLobby): Promise<DiscordLobby> {\n    return await rest.patch<DiscordLobby>(rest.routes.lobby.lobby(lobbyId), {\n      body: options,\n    });\n  },\n  /**\n   * Deletes the specified lobby if it exists.\n   *\n   * It is safe to call even if the lobby is already deleted as well.\n   *\n   * @param lobbyId - The ID of the lobby to delete\n   * @returns Nothing\n   */\n  async deleteLobby(rest: RestManager, lobbyId: BigString): Promise<void> {\n    return await rest.delete(rest.routes.lobby.lobby(lobbyId));\n  },\n  /**\n   * Adds the provided user to the specified lobby. If called when the user is already a member of the lobby will update fields such as metadata on that user instead.\n   *\n   * @param lobbyId - The ID of the lobby to add the user to\n   * @param userId - The ID of the user to add to the lobby\n   * @param options - The options to add the user to the lobby\n   * @returns The lobby member object\n   */\n  async addMemberToLobby(rest: RestManager, lobbyId: BigString, userId: BigString, options: AddLobbyMember): Promise<DiscordLobbyMember> {\n    return await rest.put<DiscordLobbyMember>(rest.routes.lobby.member(lobbyId, userId), {\n      body: options,\n    });\n  },\n  /**\n   * Adds, updates, or removes up to 25 members from the specified lobby in a single request.\n   *\n   * @param lobbyId - The ID of the lobby to add, update, or remove members from\n   * @param options - The options to add, update, or remove members from the lobby\n   * @returns Returns an array of lobby member objects for the upserted members. Removed members are not included in the response.\n   *\n   * @remarks\n   * Members with `remove_member: false` (the default) are upserted — added if not present, or updated with the provided metadata and flags if already a member. Members with `remove_member: true` are removed.\n   *\n   * Users unknown to Discord will return a 404 UNKNOWN_USER error.\n   * Users that fail permission checks or who have already reached the maximum number of lobbies per application (and are not already a member of this lobby) are silently dropped from the upsert set.\n   *\n   * @see {@link https://docs.discord.com/developers/resources/lobby#bulk-update-lobby-members}\n   */\n  async bulkUpdateLobbyMembers(rest: RestManager, lobbyId: BigString, options: BulkUpdateLobbyMember[]): Promise<DiscordLobbyMember[]> {\n    return await rest.post<DiscordLobbyMember[]>(rest.routes.lobby.membersBulk(lobbyId), {\n      body: options,\n    });\n  },\n  /**\n   * Removes the provided user from the specified lobby. It is safe to call this even if the user is no longer a member of the lobby, but will fail if the lobby does not exist.\n   *\n   * @param lobbyId - The ID of the lobby to remove the user from\n   * @param userId - The ID of the user to remove from the lobby\n   * @returns Nothing\n   */\n  async removeMemberFromLobby(rest: RestManager, lobbyId: BigString, userId: BigString): Promise<void> {\n    return await rest.delete(rest.routes.lobby.member(lobbyId, userId));\n  },\n  /**\n   * Removes the current user from the specified lobby. It is safe to call this even if the user is no longer a member of the lobby, but will fail if the lobby does not exist.\n   *\n   * @param lobbyId - The ID of the lobby to remove the user from\n   * @param bearerToken - The access token of the user\n   * @returns Nothing\n   *\n   * @remarks\n   * This requires a bearer token for authorization\n   */\n  async leaveLobby(rest: RestManager, lobbyId: BigString, bearerToken: string): Promise<void> {\n    return await rest.delete(rest.routes.lobby.leave(lobbyId), {\n      headers: {\n        authorization: `Bearer ${bearerToken}`,\n      },\n      unauthorized: true,\n    });\n  },\n  /**\n   * Links an existing text channel to a lobby.\n   *\n   * @param lobbyId - The ID of the lobby to link the channel to\n   * @param bearerToken - The access token of the user\n   * @param options - The options to link the channel to the lobby\n   * @returns The updated lobby object\n   *\n   * @remarks\n   * Uses bearer token for authorization and the user must be a lobby member with the CanLinkLobby lobby member flag.\n   */\n  async linkChannelToLobby(rest: RestManager, lobbyId: BigString, bearerToken: string, options: LinkChannelToLobby): Promise<DiscordLobby> {\n    return await rest.patch<DiscordLobby>(rest.routes.lobby.link(lobbyId), {\n      body: options,\n      headers: {\n        authorization: `Bearer ${bearerToken}`,\n      },\n      unauthorized: true,\n    });\n  },\n  /**\n   * Unlinks any currently linked channels from the specified lobby.\n   *\n   * @param lobbyId - The ID of the lobby to unlink the channel from\n   * @param bearerToken - The access token of the user\n   * @returns The updated lobby object\n   *\n   * @remarks\n   * Uses bearer token for authorization and the user must be a lobby member with the CanLinkLobby lobby member flag.\n   */\n  async unlinkChannelToLobby(rest: RestManager, lobbyId: BigString, bearerToken: string): Promise<DiscordLobby> {\n    return await rest.patch<DiscordLobby>(rest.routes.lobby.link(lobbyId), {\n      headers: {\n        authorization: `Bearer ${bearerToken}`,\n      },\n      unauthorized: true,\n    });\n  },\n  /**\n   * Sets the moderation metadata for a lobby message. The metadata is app-scoped and delivered to active game clients via the Social SDK as a realtime message update.\n   *\n   * @param lobbyId - The ID of the lobby to set the moderation metadata\n   * @param messageId - The ID of the message to set the moderation metadata\n   * @param options - The moderation metadata to set\n   *\n   * @remarks\n   * Uses `Bot` token for authorization.\n   *\n   * For the options: Free-form key–value pairs describing the moderation decision. Up to 5 keys; key length <= 1024 characters; value length <= 2000 characters\n   *\n   * @see {@link https://discord.com/developers/docs/game-sdk/social-sdk/chat-moderation#server-side-chat-moderation} for the full moderation flow.\n   */\n  async updateLobbyMessageModerationMetadata(\n    rest: RestManager,\n    lobbyId: BigString,\n    messageId: BigString,\n    options: Record<string, string>,\n  ): Promise<void> {\n    await rest.put(rest.routes.lobby.moderationMetadata(lobbyId, messageId), {\n      body: options,\n    });\n  },\n  /**\n   * Sends a message to the specified lobby. The calling user must be a member of the lobby.\n   *\n   * @param bearerToken - The access token of the user\n   * @param lobbyId - The ID of the lobby to send the message to\n   * @param options - The options to send the message\n   * @returns Returns the created lobby message object.\n   *\n   * @remarks\n   * Uses `Bearer` token for authorization with the `sdk.social_layer` scope.\n   *\n   * If the lobby has a linked channel, the message is also forwarded to that channel.\n   * If forwarding fails (for example, due to AutoMod), the lobby message is still delivered to other lobby members.\n   */\n  async sendLobbyMessage(rest: RestManager, bearerToken: string, lobbyId: BigString, options: SendLobbyMessage): Promise<DiscordLobbyMessage> {\n    return await rest.post<DiscordLobbyMessage>(rest.routes.lobby.messages(lobbyId), {\n      body: options,\n      headers: {\n        authorization: `Bearer ${bearerToken}`,\n      },\n      unauthorized: true,\n    });\n  },\n  /**\n   * Returns the most recent messages in the specified lobby. The calling user must be a member of the lobby.\n   *\n   * @param bearerToken - The access token of the user\n   * @param lobbyId - The ID of the lobby to get the messages from\n   * @param options - The options to get the messages\n   * @returns Returns an array of lobby message objects\n   *\n   * @remarks\n   * Uses `Bearer` token for authorization with the `sdk.social_layer` scope.\n   */\n  async getLobbyMessages(rest: RestManager, bearerToken: string, lobbyId: BigString, options?: GetLobbyMessages): Promise<DiscordLobbyMessage[]> {\n    return await rest.get<DiscordLobbyMessage[]>(rest.routes.lobby.messages(lobbyId, options), {\n      headers: {\n        authorization: `Bearer ${bearerToken}`,\n      },\n      unauthorized: true,\n    });\n  },\n  /**\n   * Creates a single-use guild invite to the lobby's linked channel, targeted at the calling user.\n   *\n   *\n   * @param bearerToken - The access token of the user\n   * @param lobbyId - The ID of the lobby to create the invite for\n   * @returns The created invite object\n   *\n   * @remarks\n   * Uses `Bearer` token for authorization with the `sdk.social_layer` scope.\n   *\n   * The lobby must have a linked channel and the caller must be a member of the lobby.\n   * The invite expires after one hour.\n   */\n  async createLobbyChannelInviteForSelf(rest: RestManager, bearerToken: string, lobbyId: BigString): Promise<DiscordLobbyInvite> {\n    return rest.post<DiscordLobbyInvite>(rest.routes.lobby.inviteSelf(lobbyId), {\n      headers: {\n        authorization: `Bearer ${bearerToken}`,\n      },\n      unauthorized: true,\n    });\n  },\n  /**\n   * Creates a single-use guild invite to the lobby's linked channel on behalf of an application, targeted at the specified user.\n   *\n   * @param lobbyId - The ID of the lobby to create the invite for\n   * @param userId - The ID of the user to create the invite for\n   * @returns The created invite object\n   *\n   * @remarks\n   * Uses `Bot` token for authorization\n   *\n   * The lobby must have a linked channel.\n   * The invite expires after one hour.\n   */\n  async createLobbyChannelInviteForUser(rest: RestManager, lobbyId: BigString, userId: BigString): Promise<DiscordLobbyInvite> {\n    return rest.post<DiscordLobbyInvite>(rest.routes.lobby.inviteUser(lobbyId, userId));\n  },\n};\n\n// We remove the rest parameter as it shouldn't be in the final function signature and is injected by the RestManager when calling the endpoint function.\nexport type RestEndpoints = {\n  [K in keyof typeof restEndpoints]: (typeof restEndpoints)[K] extends (...args: [RestManager, ...infer B]) => infer R ? (...args: B) => R : never;\n};\n\nexport type CamelizedRestEndpoints = {\n  [K in keyof RestEndpoints]: RestEndpoints[K] extends (...args: infer A) => Promise<infer R> ? (...args: A) => Promise<Camelize<R>> : never;\n};\n"],"names":["Buffer","processReactionString","restEndpoints","addReaction","rest","channelId","messageId","reaction","put","routes","channels","reactions","bot","addReactions","ordered","Promise","all","map","snake","addRole","guildId","userId","roleId","reason","guilds","roles","member","addThreadMember","threads","user","addDmRecipient","options","dmRecipient","body","addGuildMember","members","createAutomodRule","post","automod","rules","createChannel","createEmoji","emojis","createApplicationEmoji","applicationEmojis","applicationId","createForumThread","forum","files","createGlobalApplicationCommand","command","restOptions","bearerToken","unauthorized","headers","authorization","interactions","commands","createGuildApplicationCommand","createGuildSticker","form","FormData","append","file","blob","name","description","tags","stickers","createGuildTemplate","templates","createInvite","targetUsersFile","invites","JSON","stringify","changeToDiscordFormat","undefined","getGuildRoleMemberCounts","get","memberCounts","createRole","createScheduledEvent","events","createStageInstance","stages","createWebhook","webhooks","deleteAutomodRule","ruleId","delete","rule","setVoiceChannelStatus","voiceStatus","deleteChannel","channel","deleteChannelPermissionOverride","overwriteId","overwrite","deleteEmoji","id","emoji","deleteApplicationEmoji","applicationEmoji","deleteFollowupMessage","token","responses","message","deleteGlobalApplicationCommand","commandId","deleteGuildApplicationCommand","one","deleteGuildSticker","stickerId","sticker","deleteGuildTemplate","templateCode","guild","deleteIntegration","integrationId","integration","deleteInvite","inviteCode","invite","getTargetUsers","inviteTargetUsers","updateTargetUsers","getTargetUsersJobStatus","inviteTargetUsersJobStatus","deleteMessage","deleteMessages","messageIds","bulk","messages","slice","toString","deleteOriginalInteractionResponse","original","deleteOwnReaction","deleteReactionsAll","deleteReactionsEmoji","deleteRole","deleteScheduledEvent","eventId","event","deleteStageInstance","stage","deleteUserReaction","deleteWebhook","webhookId","deleteWebhookMessage","deleteWebhookWithToken","webhook","editApplicationCommandPermissions","permission","permissions","editAutomodRule","patch","editBotProfile","currentUser","editChannel","editChannelPermissionOverrides","editChannelPositions","channelPositions","editEmoji","editApplicationEmoji","editFollowupMessage","editGlobalApplicationCommand","editGuild","editGuildApplicationCommand","editGuildSticker","editGuildTemplate","editMessage","editOriginalInteractionResponse","editOwnVoiceState","voice","requestToSpeakTimestamp","Date","toISOString","editRole","editRolePositions","editScheduledEvent","editStageInstance","topic","editUserVoiceState","editUserApplicationRoleConnection","oauth2","roleConnections","deleteCurrentUserApplicationRoleConnection","editWebhook","editWebhookMessage","editWebhookWithToken","editWelcomeScreen","welcome","editWidgetSettings","widget","executeWebhook","followAnnouncement","sourceChannelId","targetChannelId","follow","webhookChannelId","getActiveThreads","active","getApplicationInfo","application","editApplicationInfo","getCurrentAuthenticationInfo","currentAuthorization","exchangeToken","clientId","clientSecret","basicCredentials","from","runThroughQueue","grantType","scope","join","tokenExchange","revokeToken","tokenRevoke","getApplicationCommandPermission","accessToken","getApplicationCommandPermissions","getAuditLog","auditlogs","getAutomodRule","getAutomodRules","getAvailableVoiceRegions","regions","getBan","ban","getBans","bans","getChannel","getChannelInvites","getChannels","getChannelWebhooks","getDmChannel","dm","recipientId","getGroupDmChannel","getEmoji","emojiId","getApplicationEmoji","getEmojis","getApplicationEmojis","getFollowupMessage","getGatewayBot","gatewayBot","getGlobalApplicationCommand","getGlobalApplicationCommands","withLocalizations","getGuild","counts","getGuilds","makeRequestOptions","userGuilds","getGuildApplicationCommand","getGuildApplicationCommands","getGuildPreview","preview","getGuildSticker","getGuildStickers","getGuildTemplate","code","getGuildTemplates","getGuildWebhooks","getIntegrations","integrations","getInvite","getInvites","getMessage","getMessages","searchGuildMessages","messagesSearch","getStickerPack","stickerPackId","stickerPack","getStickerPacks","stickerPacks","getOriginalInteractionResponse","getChannelPins","messagePins","getPinnedMessages","pins","getPrivateArchivedThreads","private","getPrivateJoinedArchivedThreads","joined","getPruneCount","prune","getPublicArchivedThreads","public","getRoles","getRole","getScheduledEvent","withUserCount","getScheduledEvents","getScheduledEventUsers","users","getSessionInfo","getStageInstance","getOwnVoiceState","getUserVoiceState","getSticker","getThreadMember","getUser","getThreadMembers","getReactions","getCurrentUser","getUserConnections","connections","getUserApplicationRoleConnection","getVanityUrl","vanity","getVoiceRegions","getWebhook","getWebhookMessage","getWebhookWithToken","getWelcomeScreen","getWidget","widgetJson","getWidgetSettings","joinThread","me","leaveGuild","leave","leaveThread","publishMessage","crosspost","removeRole","removeThreadMember","removeDmRecipient","sendMessage","sendFollowupMessage","sendInteractionResponse","interactionId","params","callback","data","startThreadWithMessage","startThreadWithoutMessage","getPollAnswerVoters","answerId","polls","votes","endPoll","expire","syncGuildTemplate","triggerTypingIndicator","typing","upsertGlobalApplicationCommands","upsertGuildApplicationCommands","banMember","bulkBanMembers","bulkBan","editCurrentMember","editMember","getCurrentMember","currentMember","getMember","getMembers","getApplicationActivityInstance","instanceId","applicationActivityInstance","kickMember","pinMessage","messagePin","pruneMembers","searchMembers","query","search","unbanMember","unpinMessage","getGuildOnboarding","onboarding","editGuildOnboarding","modifyGuildIncidentActions","incidentActions","listEntitlements","monetization","entitlements","getEntitlement","entitlementId","entitlement","createTestEntitlement","deleteTestEntitlement","consumeEntitlement","listSkus","skus","listSubscriptions","skuId","subscriptions","getSubscription","subscriptionId","subscription","sendSoundboardSound","soundboard","sendSound","listDefaultSoundboardSounds","listDefault","listGuildSoundboardSounds","guildSounds","getGuildSoundboardSound","soundId","guildSound","createGuildSoundboardSound","modifyGuildSoundboardSound","deleteGuildSoundboardSound","listApplicationRoleConnectionsMetadataRecords","applicationRoleConnectionMetadata","updateApplicationRoleConnectionsMetadataRecords","createLobby","lobby","create","createOrJoinLobby","getLobby","lobbyId","modifyLobby","deleteLobby","addMemberToLobby","bulkUpdateLobbyMembers","membersBulk","removeMemberFromLobby","leaveLobby","linkChannelToLobby","link","unlinkChannelToLobby","updateLobbyMessageModerationMetadata","moderationMetadata","sendLobbyMessage","getLobbyMessages","createLobbyChannelInviteForSelf","inviteSelf","createLobbyChannelInviteForUser","inviteUser"],"mappings":"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"}