@discordjs/core 0.4.0-dev.1677456628-ffdb197.0 → 0.4.0

package/dist/index.mjs

@@ -3,82 +3,191 @@ var __name = (target, value) => __defProp(target, "name", { value, configurable:
 
 // src/api/applicationCommands.ts
 import { makeURLSearchParams } from "@discordjs/rest";
-import {
-  Routes
-} from "discord-api-types/v10";
+import { Routes } from "discord-api-types/v10";
 var ApplicationCommandsAPI = class {
   constructor(rest) {
     this.rest = rest;
   }
+  /**
+  * Fetches all global commands for a application
+  *
+  * @see {@link https://discord.com/developers/docs/interactions/application-commands#get-global-application-commands}
+  * @param applicationId - The application id to fetch commands for
+  * @param options - The options to use when fetching commands
+  */
   async getGlobalCommands(applicationId, options = {}) {
     return this.rest.get(Routes.applicationCommands(applicationId), {
       query: makeURLSearchParams(options)
     });
   }
+  /**
+  * Creates a new global command
+  *
+  * @see {@link https://discord.com/developers/docs/interactions/application-commands#create-global-application-command}
+  * @param applicationId - The application id to create the command for
+  * @param data - The data to use when creating the command
+  */
   async createGlobalCommand(applicationId, data) {
     return this.rest.post(Routes.applicationCommands(applicationId), {
       body: data
     });
   }
+  /**
+  * Fetches a global command
+  *
+  * @see {@link https://discord.com/developers/docs/interactions/application-commands#get-global-application-command}
+  * @param applicationId - The application id to fetch the command from
+  * @param commandId - The command id to fetch
+  */
   async getGlobalCommand(applicationId, commandId) {
-    return this.rest.get(
-      Routes.applicationCommand(applicationId, commandId)
-    );
-  }
+    return this.rest.get(Routes.applicationCommand(applicationId, commandId));
+  }
+  /**
+  * Edits a global command
+  *
+  * @see {@link https://discord.com/developers/docs/interactions/application-commands#edit-global-application-command}
+  * @param applicationId - The application id of the command
+  * @param commandId - The id of the command to edit
+  * @param data - The data to use when editing the command
+  */
   async editGlobalCommand(applicationId, commandId, data) {
     return this.rest.patch(Routes.applicationCommand(applicationId, commandId), {
       body: data
     });
   }
+  /**
+  * Deletes a global command
+  *
+  * @see {@link https://discord.com/developers/docs/interactions/application-commands#delete-global-application-command}
+  * @param applicationId - The application id of the command
+  * @param commandId - The id of the command to delete
+  */
   async deleteGlobalCommand(applicationId, commandId) {
     await this.rest.delete(Routes.applicationCommand(applicationId, commandId));
   }
+  /**
+  * Overwrites global commands
+  *
+  * @see {@link https://discord.com/developers/docs/interactions/application-commands#bulk-overwrite-global-application-commands}
+  * @param applicationId - The application id to overwrite commands for
+  * @param data - The data to use when overwriting commands
+  */
   async bulkOverwriteGlobalCommands(applicationId, data) {
     return this.rest.put(Routes.applicationCommands(applicationId), {
       body: data
     });
   }
+  /**
+  * Fetches all commands for a guild
+  *
+  * @see {@link https://discord.com/developers/docs/interactions/application-commands#get-guild-application-commands}
+  * @param applicationId - The application id to fetch commands for
+  * @param guildId - The guild id to fetch commands for
+  * @param data - The data to use when fetching commands
+  */
   async getGuildCommands(applicationId, guildId, data = {}) {
     return this.rest.get(Routes.applicationGuildCommands(applicationId, guildId), {
       query: makeURLSearchParams(data)
     });
   }
+  /**
+  * Creates a new command for a guild
+  *
+  * @see {@link https://discord.com/developers/docs/interactions/application-commands#create-guild-application-command}
+  * @param applicationId - The application id to create the command for
+  * @param guildId - The guild id to create the command for
+  * @param data - The data to use when creating the command
+  */
   async createGuildCommand(applicationId, guildId, data) {
     return this.rest.post(Routes.applicationGuildCommands(applicationId, guildId), {
       body: data
     });
   }
+  /**
+  * Fetches a guild command
+  *
+  * @see {@link https://discord.com/developers/docs/interactions/application-commands#get-guild-application-command}
+  * @param applicationId - The application id to fetch the command from
+  * @param guildId - The guild id to fetch the command from
+  * @param commandId - The command id to fetch
+  */
   async getGuildCommand(applicationId, guildId, commandId) {
-    return this.rest.get(
-      Routes.applicationGuildCommand(applicationId, guildId, commandId)
-    );
-  }
+    return this.rest.get(Routes.applicationGuildCommand(applicationId, guildId, commandId));
+  }
+  /**
+  * Edits a guild command
+  *
+  * @see {@link https://discord.com/developers/docs/interactions/application-commands#edit-guild-application-command}
+  * @param applicationId - The application id of the command
+  * @param guildId - The guild id of the command
+  * @param commandId - The command id to edit
+  * @param data - The data to use when editing the command
+  */
   async editGuildCommand(applicationId, guildId, commandId, data) {
     return this.rest.patch(Routes.applicationGuildCommand(applicationId, guildId, commandId), {
       body: data
     });
   }
+  /**
+  * Deletes a guild command
+  *
+  * @see {@link https://discord.com/developers/docs/interactions/application-commands#delete-guild-application-command}
+  * @param applicationId - The application id of the command
+  * @param guildId - The guild id of the command
+  * @param commandId - The id of the command to delete
+  */
   async deleteGuildCommand(applicationId, guildId, commandId) {
     await this.rest.delete(Routes.applicationGuildCommand(applicationId, guildId, commandId));
   }
+  /**
+  * Bulk overwrites guild commands
+  *
+  * @see {@link https://discord.com/developers/docs/interactions/application-commands#bulk-overwrite-guild-application-commands}
+  * @param applicationId - The application id to overwrite commands for
+  * @param guildId - The guild id to overwrite commands for
+  * @param data - The data to use when overwriting commands
+  */
   async bulkOverwriteGuildCommands(applicationId, guildId, data) {
     return this.rest.put(Routes.applicationGuildCommands(applicationId, guildId), {
       body: data
     });
   }
+  /**
+  * Fetches the permissions for a guild command
+  *
+  * @see {@link https://discord.com/developers/docs/interactions/application-commands#get-guild-application-command-permissions}
+  * @param applicationId - The application id to get the permissions for
+  * @param guildId - The guild id of the command
+  * @param commandId - The command id to get the permissions for
+  */
   async getGuildCommandPermissions(applicationId, guildId, commandId) {
-    return this.rest.get(
-      Routes.applicationCommandPermissions(applicationId, guildId, commandId)
-    );
-  }
+    return this.rest.get(Routes.applicationCommandPermissions(applicationId, guildId, commandId));
+  }
+  /**
+  * Fetches all permissions for all commands in a guild
+  *
+  * @see {@link https://discord.com/developers/docs/interactions/application-commands#get-application-command-permissions}
+  * @param applicationId - The application id to get the permissions for
+  * @param guildId - The guild id to get the permissions for
+  */
   async getGuildCommandsPermissions(applicationId, guildId) {
-    return this.rest.get(
-      Routes.guildApplicationCommandsPermissions(applicationId, guildId)
-    );
-  }
+    return this.rest.get(Routes.guildApplicationCommandsPermissions(applicationId, guildId));
+  }
+  /**
+  * Edits the permissions for a guild command
+  *
+  * @see {@link https://discord.com/developers/docs/interactions/application-commands#edit-application-command-permissions}
+  * @param userToken - The token of the user to edit permissions on behalf of
+  * @param applicationId - The application id to edit the permissions for
+  * @param guildId - The guild id to edit the permissions for
+  * @param commandId - The id of the command to edit the permissions for
+  * @param data - The data to use when editing the permissions
+  */
   async editGuildCommandPermissions(userToken, applicationId, guildId, commandId, data) {
     return this.rest.put(Routes.applicationCommandPermissions(applicationId, guildId, commandId), {
-      headers: { Authorization: `Bearer ${userToken.replace("Bearer ", "")}` },
+      headers: {
+        Authorization: `Bearer ${userToken.replace("Bearer ", "")}`
+      },
       auth: false,
       body: data
     });
@@ -88,109 +197,309 @@ __name(ApplicationCommandsAPI, "ApplicationCommandsAPI");
 
 // src/api/channel.ts
 import { makeURLSearchParams as makeURLSearchParams2 } from "@discordjs/rest";
-import {
-  Routes as Routes2
-} from "discord-api-types/v10";
+import { Routes as Routes2 } from "discord-api-types/v10";
 var ChannelsAPI = class {
   constructor(rest) {
     this.rest = rest;
   }
+  /**
+  * Sends a message in a channel
+  *
+  * @see {@link https://discord.com/developers/docs/resources/channel#create-message}
+  * @param channelId - The id of the channel to send the message in
+  * @param data - The data to use when sending the message
+  */
   async createMessage(channelId, { files, ...body }) {
     return this.rest.post(Routes2.channelMessages(channelId), {
       files,
       body
     });
   }
+  /**
+  * Edits a message
+  *
+  * @see {@link https://discord.com/developers/docs/resources/channel#edit-message}
+  * @param channelId - The id of the channel the message is in
+  * @param messageId - The id of the message to edit
+  * @param data - The data to use when editing the message
+  */
   async editMessage(channelId, messageId, { files, ...body }) {
     return this.rest.patch(Routes2.channelMessage(channelId, messageId), {
       files,
       body
     });
   }
+  /**
+  * Fetches the reactions for a message
+  *
+  * @see {@link https://discord.com/developers/docs/resources/channel#get-reactions}
+  * @param channelId - The id of the channel the message is in
+  * @param messageId - The id of the message to get the reactions for
+  * @param emoji - The emoji to get the reactions for
+  * @param options - The options to use when fetching the reactions
+  */
   async getMessageReactions(channelId, messageId, emoji, options = {}) {
     return this.rest.get(Routes2.channelMessageReaction(channelId, messageId, encodeURIComponent(emoji)), {
       query: makeURLSearchParams2(options)
     });
   }
+  /**
+  * Deletes a reaction for the current user
+  *
+  * @see {@link https://discord.com/developers/docs/resources/channel#delete-own-reaction}
+  * @param channelId - The id of the channel the message is in
+  * @param messageId - The id of the message to delete the reaction for
+  * @param emoji - The emoji to delete the reaction for
+  */
   async deleteOwnMessageReaction(channelId, messageId, emoji) {
     await this.rest.delete(Routes2.channelMessageOwnReaction(channelId, messageId, encodeURIComponent(emoji)));
   }
+  /**
+  * Deletes a reaction for a user
+  *
+  * @see {@link https://discord.com/developers/docs/resources/channel#delete-user-reaction}
+  * @param channelId - The id of the channel the message is in
+  * @param messageId - The id of the message to delete the reaction for
+  * @param emoji - The emoji to delete the reaction for
+  * @param userId - The id of the user to delete the reaction for
+  */
   async deleteUserMessageReaction(channelId, messageId, emoji, userId) {
     await this.rest.delete(Routes2.channelMessageUserReaction(channelId, messageId, encodeURIComponent(emoji), userId));
   }
+  /**
+  * Deletes all reactions for a message
+  *
+  * @see {@link https://discord.com/developers/docs/resources/channel#delete-all-reactions}
+  * @param channelId - The id of the channel the message is in
+  * @param messageId - The id of the message to delete the reactions for
+  */
   async deleteAllMessageReactions(channelId, messageId) {
     await this.rest.delete(Routes2.channelMessageAllReactions(channelId, messageId));
   }
+  /**
+  * Deletes all reactions of an emoji for a message
+  *
+  * @see {@link https://discord.com/developers/docs/resources/channel#delete-all-reactions-for-emoji}
+  * @param channelId - The id of the channel the message is in
+  * @param messageId - The id of the message to delete the reactions for
+  * @param emoji - The emoji to delete the reactions for
+  */
   async deleteAllMessageReactionsForEmoji(channelId, messageId, emoji) {
     await this.rest.delete(Routes2.channelMessageReaction(channelId, messageId, encodeURIComponent(emoji)));
   }
+  /**
+  * Adds a reaction to a message
+  *
+  * @see {@link https://discord.com/developers/docs/resources/channel#create-reaction}
+  * @param channelId - The id of the channel the message is in
+  * @param messageId - The id of the message to add the reaction to
+  * @param emoji - The emoji to add the reaction with
+  */
   async addMessageReaction(channelId, messageId, emoji) {
     await this.rest.put(Routes2.channelMessageOwnReaction(channelId, messageId, encodeURIComponent(emoji)));
   }
+  /**
+  * Fetches a channel
+  *
+  * @see {@link https://discord.com/developers/docs/resources/channel#get-channel}
+  * @param channelId - The id of the channel
+  */
   async get(channelId) {
     return this.rest.get(Routes2.channel(channelId));
   }
+  /**
+  * Edits a channel
+  *
+  * @see {@link https://discord.com/developers/docs/resources/channel#modify-channel}
+  * @param channelId - The id of the channel to edit
+  * @param data - The new channel data
+  */
   async edit(channelId, data) {
-    return this.rest.patch(Routes2.channel(channelId), { body: data });
+    return this.rest.patch(Routes2.channel(channelId), {
+      body: data
+    });
   }
+  /**
+  * Deletes a channel
+  *
+  * @see {@link https://discord.com/developers/docs/resources/channel#deleteclose-channel}
+  * @param channelId - The id of the channel to delete
+  */
   async delete(channelId) {
     return this.rest.delete(Routes2.channel(channelId));
   }
+  /**
+  * Fetches the messages of a channel
+  *
+  * @see {@link https://discord.com/developers/docs/resources/channel#get-channel-messages}
+  * @param channelId - The id of the channel to fetch messages from
+  * @param options - The options to use when fetching messages
+  */
   async getMessages(channelId, options = {}) {
     return this.rest.get(Routes2.channelMessages(channelId), {
       query: makeURLSearchParams2(options)
     });
   }
+  /**
+  * Shows a typing indicator in a channel
+  *
+  * @see {@link https://discord.com/developers/docs/resources/channel#trigger-typing-indicator}
+  * @param channelId - The id of the channel to show the typing indicator in
+  */
   async showTyping(channelId) {
     await this.rest.post(Routes2.channelTyping(channelId));
   }
+  /**
+  * Fetches the pinned messages of a channel
+  *
+  * @see {@link https://discord.com/developers/docs/resources/channel#get-pinned-messages}
+  * @param channelId - The id of the channel to fetch pinned messages from
+  */
   async getPins(channelId) {
     return this.rest.get(Routes2.channelPins(channelId));
   }
+  /**
+  * Pins a message in a channel
+  *
+  * @see {@link https://discord.com/developers/docs/resources/channel#pin-message}
+  * @param channelId - The id of the channel to pin the message in
+  * @param messageId - The id of the message to pin
+  * @param reason - The reason for pinning the message
+  */
   async pinMessage(channelId, messageId, reason) {
-    await this.rest.put(Routes2.channelPin(channelId, messageId), { reason });
+    await this.rest.put(Routes2.channelPin(channelId, messageId), {
+      reason
+    });
   }
+  /**
+  * Deletes a message
+  *
+  * @see {@link https://discord.com/developers/docs/resources/channel#delete-message}
+  * @param channelId - The id of the channel the message is in
+  * @param messageId - The id of the message to delete
+  * @param reason - The reason for deleting the message
+  */
   async deleteMessage(channelId, messageId, reason) {
-    await this.rest.delete(Routes2.channelMessage(channelId, messageId), { reason });
+    await this.rest.delete(Routes2.channelMessage(channelId, messageId), {
+      reason
+    });
   }
+  /**
+  * Bulk deletes messages
+  *
+  * @see {@link https://discord.com/developers/docs/resources/channel#bulk-delete-messages}
+  * @param channelId - The id of the channel the messages are in
+  * @param messageIds - The ids of the messages to delete
+  */
   async bulkDeleteMessages(channelId, messageIds, reason) {
-    await this.rest.post(Routes2.channelBulkDelete(channelId), { reason, body: { messages: messageIds } });
+    await this.rest.post(Routes2.channelBulkDelete(channelId), {
+      reason,
+      body: {
+        messages: messageIds
+      }
+    });
   }
+  /**
+  * Fetches a message
+  *
+  * @see {@link https://discord.com/developers/docs/resources/channel#get-channel-message}
+  * @param channelId - The id of the channel the message is in
+  * @param messageId - The id of the message to fetch
+  */
   async getMessage(channelId, messageId) {
     return this.rest.get(Routes2.channelMessage(channelId, messageId));
   }
+  /**
+  * Crossposts a message
+  *
+  * @see {@link https://discord.com/developers/docs/resources/channel#crosspost-message}
+  * @param channelId - The id of the channel the message is in
+  * @param messageId - The id of the message to crosspost
+  */
   async crosspostMessage(channelId, messageId) {
-    return this.rest.post(
-      Routes2.channelMessageCrosspost(channelId, messageId)
-    );
-  }
+    return this.rest.post(Routes2.channelMessageCrosspost(channelId, messageId));
+  }
+  /**
+  * Unpins a message in a channel
+  *
+  * @see {@link https://discord.com/developers/docs/resources/channel#unpin-message}
+  * @param channelId - The id of the channel to unpin the message in
+  * @param messageId - The id of the message to unpin
+  * @param reason - The reason for unpinning the message
+  */
   async unpinMessage(channelId, messageId, reason) {
-    await this.rest.delete(Routes2.channelPin(channelId, messageId), { reason });
+    await this.rest.delete(Routes2.channelPin(channelId, messageId), {
+      reason
+    });
   }
+  /**
+  * Follows an announcement channel
+  *
+  * @see {@link https://discord.com/developers/docs/resources/channel#follow-announcement-channel}
+  * @param channelId - The id of the announcement channel to follow
+  * @param webhookChannelId - The id of the webhook channel to follow the announcements in
+  */
   async followAnnouncements(channelId, webhookChannelId) {
     return this.rest.post(Routes2.channelFollowers(channelId), {
-      body: { webhook_channel_id: webhookChannelId }
+      body: {
+        webhook_channel_id: webhookChannelId
+      }
     });
   }
+  /**
+  * Creates a new invite for a channel
+  *
+  * @see {@link https://discord.com/developers/docs/resources/channel#create-channel-invite}
+  * @param channelId - The id of the channel to create an invite for
+  * @param data - The data to use when creating the invite
+  */
   async createInvite(channelId, data, reason) {
     return this.rest.post(Routes2.channelInvites(channelId), {
       reason,
       body: data
     });
   }
+  /**
+  * Fetches the invites of a channel
+  *
+  * @see {@link https://discord.com/developers/docs/resources/channel#get-channel-invites}
+  * @param channelId - The id of the channel to fetch invites from
+  */
   async getInvites(channelId) {
     return this.rest.get(Routes2.channelInvites(channelId));
   }
+  /**
+  * Fetches the archived threads of a channel
+  *
+  * @see {@link https://discord.com/developers/docs/resources/channel#list-public-archived-threads}
+  * @see {@link https://discord.com/developers/docs/resources/channel#list-private-archived-threads}
+  * @param channelId - The id of the channel to fetch archived threads from
+  * @param archivedStatus - The archived status of the threads to fetch
+  * @param options - The options to use when fetching archived threads
+  */
   async getArchivedThreads(channelId, archivedStatus, options = {}) {
     return this.rest.get(Routes2.channelThreads(channelId, archivedStatus), {
       query: makeURLSearchParams2(options)
     });
   }
+  /**
+  * Fetches the private joined archived threads of a channel
+  *
+  * @see {@link https://discord.com/developers/docs/resources/channel#list-joined-private-archived-threads}
+  * @param channelId - The id of the channel to fetch joined archived threads from
+  * @param options - The options to use when fetching joined archived threads
+  */
   async getJoinedPrivateArchivedThreads(channelId, options = {}) {
     return this.rest.get(Routes2.channelJoinedArchivedThreads(channelId), {
       query: makeURLSearchParams2(options)
     });
   }
+  /**
+  * Fetches the webhooks of a channel
+  *
+  * @see {@link https://discord.com/developers/docs/resources/webhook#get-channel-webhooks}
+  * @param id - The id of the channel
+  */
   async getWebhooks(id) {
     return this.rest.get(Routes2.channelWebhooks(id));
   }
@@ -199,356 +508,983 @@ __name(ChannelsAPI, "ChannelsAPI");
 
 // src/api/guild.ts
 import { makeURLSearchParams as makeURLSearchParams3 } from "@discordjs/rest";
-import {
-  Routes as Routes3
-} from "discord-api-types/v10";
+import { Routes as Routes3 } from "discord-api-types/v10";
 var GuildsAPI = class {
   constructor(rest) {
     this.rest = rest;
   }
+  /**
+  * Fetches a guild
+  *
+  * @see {@link https://discord.com/developers/docs/resources/guild#get-guild}
+  * @param guildId - The id of the guild
+  */
   async get(guildId) {
     return this.rest.get(Routes3.guild(guildId));
   }
+  /**
+  * Fetches a guild preview
+  *
+  * @see {@link https://discord.com/developers/docs/resources/guild#get-guild-preview}
+  * @param guildId - The id of the guild to fetch the preview from
+  */
   async getPreview(guildId) {
     return this.rest.get(Routes3.guildPreview(guildId));
   }
+  /**
+  * Creates a guild
+  *
+  * @see {@link https://discord.com/developers/docs/resources/guild#create-guild}
+  * @param data - The guild to create
+  */
   async create(data) {
-    return this.rest.post(Routes3.guilds(), { body: data });
+    return this.rest.post(Routes3.guilds(), {
+      body: data
+    });
   }
+  /**
+  * Edits a guild
+  *
+  * @see {@link https://discord.com/developers/docs/resources/guild#modify-guild}
+  * @param guildId - The id of the guild to edit
+  * @param data - The new guild data
+  * @param reason - The reason for editing this guild
+  */
   async edit(guildId, data, reason) {
-    return this.rest.patch(Routes3.guild(guildId), { reason, body: data });
+    return this.rest.patch(Routes3.guild(guildId), {
+      reason,
+      body: data
+    });
   }
+  /**
+  * Deletes a guild
+  *
+  * @see {@link https://discord.com/developers/docs/resources/guild#delete-guild}
+  * @param guildId - The id of the guild to delete
+  * @param reason - The reason for deleting this guild
+  */
   async delete(guildId, reason) {
-    await this.rest.delete(Routes3.guild(guildId), { reason });
+    await this.rest.delete(Routes3.guild(guildId), {
+      reason
+    });
   }
+  /**
+  * Fetches all the members of a guild
+  *
+  * @see {@link https://discord.com/developers/docs/resources/guild#list-guild-members}
+  * @param guildId - The id of the guild
+  * @param options - The options to use when fetching the guild members
+  */
   async getMembers(guildId, options = {}) {
     return this.rest.get(Routes3.guildMembers(guildId), {
       query: makeURLSearchParams3(options)
     });
   }
+  /**
+  * Fetches a guild's channels
+  *
+  * @see {@link https://discord.com/developers/docs/resources/guild#get-guild-channels}
+  * @param guildId - The id of the guild to fetch the channels from
+  */
   async getChannels(guildId) {
     return this.rest.get(Routes3.guildChannels(guildId));
   }
+  /**
+  * Creates a guild channel
+  *
+  * @see {@link https://discord.com/developers/docs/resources/guild#create-guild-channel}
+  * @param guildId - The id of the guild to create the channel in
+  * @param data - The data to create the new channel
+  * @param reason - The reason for creating this channel
+  */
   async createChannel(guildId, data, reason) {
     return this.rest.post(Routes3.guildChannels(guildId), {
       reason,
       body: data
     });
   }
+  /**
+  * Edits a guild channel's positions
+  *
+  * @see {@link https://discord.com/developers/docs/resources/guild#modify-guild-channel-positions}
+  * @param guildId - The id of the guild to edit the channel positions from
+  * @param data - The data to edit the channel positions with
+  * @param reason - The reason for editing the channel positions
+  */
   async setChannelPositions(guildId, data, reason) {
-    await this.rest.patch(Routes3.guildChannels(guildId), { reason, body: data });
+    await this.rest.patch(Routes3.guildChannels(guildId), {
+      reason,
+      body: data
+    });
   }
+  /**
+  * Fetches the active threads in a guild
+  *
+  * @see {@link https://discord.com/developers/docs/resources/guild#list-active-guild-threads}
+  * @param guildId - The id of the guild to fetch the active threads from
+  */
   async getActiveThreads(guildId) {
     return this.rest.get(Routes3.guildActiveThreads(guildId));
   }
+  /**
+  * Fetches a guild member ban
+  *
+  * @see {@link https://discord.com/developers/docs/resources/guild#get-guild-bans}
+  * @param guildId - The id of the guild to fetch the ban from
+  */
   async getMemberBans(guildId) {
     return this.rest.get(Routes3.guildBans(guildId));
   }
+  /**
+  * Bans a user from a guild
+  *
+  * @see {@link https://discord.com/developers/docs/resources/guild#create-guild-ban}
+  * @param guildId - The id of the guild to ban the member in
+  * @param userId - The id of the user to ban
+  * @param options - Options for banning the user
+  * @param reason - The reason for banning the user
+  */
   async banUser(guildId, userId, options = {}, reason) {
-    await this.rest.put(Routes3.guildBan(guildId, userId), { reason, body: options });
+    await this.rest.put(Routes3.guildBan(guildId, userId), {
+      reason,
+      body: options
+    });
   }
+  /**
+  * Unbans a user from a guild
+  *
+  * @see {@link https://discord.com/developers/docs/resources/guild#remove-guild-ban}
+  * @param guildId - The id of the guild to unban the member in
+  * @param userId - The id of the user to unban
+  * @param reason - The reason for unbanning the user
+  */
   async unbanUser(guildId, userId, reason) {
-    await this.rest.delete(Routes3.guildBan(guildId, userId), { reason });
+    await this.rest.delete(Routes3.guildBan(guildId, userId), {
+      reason
+    });
   }
+  /**
+  * Gets all the roles in a guild
+  *
+  * @see {@link https://discord.com/developers/docs/resources/guild#get-guild-roles}
+  * @param guildId - The id of the guild to fetch the roles from
+  */
   async getRoles(guildId) {
     return this.rest.get(Routes3.guildRoles(guildId));
   }
+  /**
+  * Creates a guild role
+  *
+  * @see {@link https://discord.com/developers/docs/resources/guild#create-guild-role}
+  * @param guildId - The id of the guild to create the role in
+  * @param data - The data to create the role with
+  * @param reason - The reason for creating the role
+  */
   async createRole(guildId, data, reason) {
-    return this.rest.post(Routes3.guildRoles(guildId), { reason, body: data });
+    return this.rest.post(Routes3.guildRoles(guildId), {
+      reason,
+      body: data
+    });
   }
+  /**
+  * Sets role positions in a guild
+  *
+  * @see {@link https://discord.com/developers/docs/resources/guild#modify-guild-role-positions}
+  * @param guildId - The id of the guild to set role positions for
+  * @param data - The data for setting a role position
+  * @param reason - The reason for setting the role position
+  */
   async setRolePositions(guildId, data, reason) {
     return this.rest.patch(Routes3.guildRoles(guildId), {
       reason,
       body: data
     });
   }
+  /**
+  * Edits a guild role
+  *
+  * @see {@link https://discord.com/developers/docs/resources/guild#modify-guild-role}
+  * @param guildId - The id of the guild to edit the role in
+  * @param roleId - The id of the role to edit
+  * @param data - data for editing the role
+  * @param reason - The reason for editing the role
+  */
   async editRole(guildId, roleId, data, reason) {
     return this.rest.patch(Routes3.guildRole(guildId, roleId), {
       reason,
       body: data
     });
   }
+  /**
+  * Deletes a guild role
+  *
+  * @see {@link https://discord.com/developers/docs/resources/guild#delete-guild-role}
+  * @param guildId - The id of the guild to delete the role in
+  * @param roleId - The id of the role to delete
+  * @param reason - The reason for deleting the role
+  */
   async deleteRole(guildId, roleId, reason) {
-    await this.rest.delete(Routes3.guildRole(guildId, roleId), { reason });
+    await this.rest.delete(Routes3.guildRole(guildId, roleId), {
+      reason
+    });
   }
+  /**
+  * Edits the multi-factor-authentication (MFA) level of a guild
+  *
+  * @see {@link https://discord.com/developers/docs/resources/guild#modify-guild-mfa-level}
+  * @param guildId - The id of the guild to edit the MFA level for
+  * @param level - The new MFA level
+  * @param reason - The reason for editing the MFA level
+  */
   async editMFALevel(guildId, level, reason) {
     return this.rest.post(Routes3.guildMFA(guildId), {
       reason,
-      body: { mfa_level: level }
+      body: {
+        mfa_level: level
+      }
     });
   }
+  /**
+  * Fetch the number of members that can be pruned from a guild
+  *
+  * @see {@link https://discord.com/developers/docs/resources/guild#get-guild-prune-count}
+  * @param guildId - The id of the guild to fetch the number of pruned members from
+  * @param options - The options for fetching the number of pruned members
+  */
   async getPruneCount(guildId, options = {}) {
     return this.rest.get(Routes3.guildPrune(guildId), {
       query: makeURLSearchParams3(options)
     });
   }
+  /**
+  * Prunes members in a guild
+  *
+  * @see {@link https://discord.com/developers/docs/resources/guild#begin-guild-prune}
+  * @param guildId - The id of the guild to prune members in
+  * @param options - The options for pruning members
+  * @param reason - The reason for pruning members
+  */
   async beginPrune(guildId, options = {}, reason) {
     return this.rest.post(Routes3.guildPrune(guildId), {
       body: options,
       reason
     });
   }
+  /**
+  * Fetches voice regions for a guild
+  *
+  * @see {@link https://discord.com/developers/docs/resources/guild#get-guild-voice-regions}
+  * @param guildId - The id of the guild to fetch the voice regions from
+  */
   async getVoiceRegions(guildId) {
     return this.rest.get(Routes3.guildVoiceRegions(guildId));
   }
+  /**
+  * Fetches the invites for a guild
+  *
+  * @see {@link https://discord.com/developers/docs/resources/guild#get-guild-invites}
+  * @param guildId - The id of the guild to fetch the invites from
+  */
   async getInvites(guildId) {
     return this.rest.get(Routes3.guildInvites(guildId));
   }
+  /**
+  * Fetches the integrations for a guild
+  *
+  * @see {@link https://discord.com/developers/docs/resources/guild#get-guild-integrations}
+  * @param guildId - The id of the guild to fetch the integrations from
+  */
   async getIntegrations(guildId) {
     return this.rest.get(Routes3.guildIntegrations(guildId));
   }
+  /**
+  * Deletes an integration from a guild
+  *
+  * @see {@link https://discord.com/developers/docs/resources/guild#delete-guild-integration}
+  * @param guildId - The id of the guild to delete the integration from
+  * @param integrationId - The id of the integration to delete
+  * @param reason - The reason for deleting the integration
+  */
   async deleteIntegration(guildId, integrationId, reason) {
-    await this.rest.delete(Routes3.guildIntegration(guildId, integrationId), { reason });
+    await this.rest.delete(Routes3.guildIntegration(guildId, integrationId), {
+      reason
+    });
   }
+  /**
+  * Fetches the widget settings for a guild
+  *
+  * @see {@link https://discord.com/developers/docs/resources/guild#get-guild-widget-settings}
+  * @param guildId - The id of the guild to fetch the widget settings from
+  */
   async getWidgetSettings(guildId) {
     return this.rest.get(Routes3.guildWidgetSettings(guildId));
   }
+  /**
+  * Edits the widget settings for a guild
+  *
+  * @see {@link https://discord.com/developers/docs/resources/guild#modify-guild-widget}
+  * @param guildId - The id of the guild to edit the widget settings from
+  * @param data - The new widget settings data
+  * @param reason - The reason for editing the widget settings
+  */
   async editWidgetSettings(guildId, data, reason) {
     return this.rest.patch(Routes3.guildWidgetSettings(guildId), {
       reason,
       body: data
     });
   }
+  /**
+  * Fetches the widget for a guild
+  *
+  * @see {@link https://discord.com/developers/docs/resources/guild#get-guild-widget}
+  * @param guildId - The id of the guild to fetch the widget from
+  */
   async getWidget(guildId) {
     return this.rest.get(Routes3.guildWidgetJSON(guildId));
   }
+  /**
+  * Fetches the vanity url for a guild
+  *
+  * @see {@link https://discord.com/developers/docs/resources/guild#get-guild-vanity-url}
+  * @param guildId - The id of the guild to fetch the vanity url from
+  */
   async getVanityURL(guildId) {
     return this.rest.get(Routes3.guildVanityUrl(guildId));
   }
+  /**
+  * Fetches the widget image for a guild
+  *
+  * @see {@link https://discord.com/developers/docs/resources/guild#get-guild-widget-image}
+  * @param guildId - The id of the guild to fetch the widget image from
+  * @param style - The style of the widget image
+  */
   async getWidgetImage(guildId, style) {
     return this.rest.get(Routes3.guildWidgetImage(guildId), {
-      query: makeURLSearchParams3({ style })
+      query: makeURLSearchParams3({
+        style
+      })
     });
   }
+  /**
+  * Fetches the welcome screen for a guild
+  *
+  * @see {@link https://discord.com/developers/docs/resources/guild#get-guild-welcome-screen}
+  * @param guildId - The id of the guild to fetch the welcome screen from
+  */
   async getWelcomeScreen(guildId) {
     return this.rest.get(Routes3.guildWelcomeScreen(guildId));
   }
+  /**
+  * Edits the welcome screen for a guild
+  *
+  * @see {@link https://discord.com/developers/docs/resources/guild#modify-guild-welcome-screen}
+  * @param guildId - The id of the guild to edit the welcome screen for
+  * @param data - The new welcome screen data
+  * @param reason - The reason for editing the welcome screen
+  */
   async editWelcomeScreen(guildId, data, reason) {
     return this.rest.patch(Routes3.guildWelcomeScreen(guildId), {
       reason,
       body: data
     });
   }
+  /**
+  * Edits a user's voice state in a guild
+  *
+  * @see {@link https://discord.com/developers/docs/resources/guild#modify-user-voice-state}
+  * @param guildId - The id of the guild to edit the current user's voice state in
+  * @param userId - The id of the user to edit the voice state for
+  * @param data - The data for editing the voice state
+  * @param reason - The reason for editing the voice state
+  */
   async editUserVoiceState(guildId, userId, data, reason) {
-    await this.rest.patch(Routes3.guildVoiceState(guildId, userId), { reason, body: data });
+    await this.rest.patch(Routes3.guildVoiceState(guildId, userId), {
+      reason,
+      body: data
+    });
   }
+  /**
+  * Fetches all emojis for a guild
+  *
+  * @see {@link https://discord.com/developers/docs/resources/emoji#list-guild-emojis}
+  * @param guildId - The id of the guild to fetch the emojis from
+  */
   async getEmojis(guildId) {
     return this.rest.get(Routes3.guildEmojis(guildId));
   }
+  /**
+  * Fetches an emoji for a guild
+  *
+  * @see {@link https://discord.com/developers/docs/resources/emoji#get-guild-emoji}
+  * @param guildId - The id of the guild to fetch the emoji from
+  * @param emojiId - The id of the emoji to fetch
+  */
   async getEmoji(guildId, emojiId) {
     return this.rest.get(Routes3.guildEmoji(guildId, emojiId));
   }
+  /**
+  * Creates a new emoji for a guild
+  *
+  * @see {@link https://discord.com/developers/docs/resources/emoji#create-guild-emoji}
+  * @param guildId - The id of the guild to create the emoji from
+  * @param data - The data for creating the emoji
+  * @param reason - The reason for creating the emoji
+  */
   async createEmoji(guildId, data, reason) {
     return this.rest.post(Routes3.guildEmojis(guildId), {
       reason,
       body: data
     });
   }
+  /**
+  * Edits an emoji for a guild
+  *
+  * @see {@link https://discord.com/developers/docs/resources/emoji#modify-guild-emoji}
+  * @param guildId - The id of the guild to edit the emoji from
+  * @param emojiId - The id of the emoji to edit
+  * @param data - The data for editing the emoji
+  * @param reason - The reason for editing the emoji
+  */
   async editEmoji(guildId, emojiId, data, reason) {
     return this.rest.patch(Routes3.guildEmoji(guildId, emojiId), {
       reason,
       body: data
     });
   }
+  /**
+  * Deletes an emoji for a guild
+  *
+  * @see {@link https://discord.com/developers/docs/resources/emoji#delete-guild-emoji}
+  * @param guildId - The id of the guild to delete the emoji from
+  * @param emojiId - The id of the emoji to delete
+  * @param reason - The reason for deleting the emoji
+  */
   async deleteEmoji(guildId, emojiId, reason) {
-    await this.rest.delete(Routes3.guildEmoji(guildId, emojiId), { reason });
+    await this.rest.delete(Routes3.guildEmoji(guildId, emojiId), {
+      reason
+    });
   }
+  /**
+  * Fetches all scheduled events for a guild
+  *
+  * @see {@link https://discord.com/developers/docs/resources/guild-scheduled-event#list-scheduled-events-for-guild}
+  * @param guildId - The id of the guild to fetch the scheduled events from
+  * @param options - The options for fetching the scheduled events
+  */
   async getScheduledEvents(guildId, options = {}) {
     return this.rest.get(Routes3.guildScheduledEvents(guildId), {
       query: makeURLSearchParams3(options)
     });
   }
+  /**
+  * Creates a new scheduled event for a guild
+  *
+  * @see {@link https://discord.com/developers/docs/resources/guild-scheduled-event#create-guild-scheduled-event}
+  * @param guildId - The id of the guild to create the scheduled event from
+  * @param data - The data to create the event with
+  * @param reason - The reason for creating the scheduled event
+  */
   async createScheduledEvent(guildId, data, reason) {
     return this.rest.post(Routes3.guildScheduledEvents(guildId), {
       reason,
       body: data
     });
   }
+  /**
+  * Fetches a scheduled event for a guild
+  *
+  * @see {@link https://discord.com/developers/docs/resources/guild-scheduled-event#get-guild-scheduled-event}
+  * @param guildId - The id of the guild to fetch the scheduled event from
+  * @param eventId - The id of the scheduled event to fetch
+  * @param options - The options for fetching the scheduled event
+  */
   async getScheduledEvent(guildId, eventId, options = {}) {
     return this.rest.get(Routes3.guildScheduledEvent(guildId, eventId), {
       query: makeURLSearchParams3(options)
     });
   }
+  /**
+  * Edits a scheduled event for a guild
+  *
+  * @see {@link https://discord.com/developers/docs/resources/guild-scheduled-event#modify-guild-scheduled-event}
+  * @param guildId - The id of the guild to edit the scheduled event from
+  * @param eventId - The id of the scheduled event to edit
+  * @param data - The new event data
+  * @param reason - The reason for editing the scheduled event
+  */
   async editScheduledEvent(guildId, eventId, data, reason) {
     return this.rest.patch(Routes3.guildScheduledEvent(guildId, eventId), {
       reason,
       body: data
     });
   }
+  /**
+  * Deletes a scheduled event for a guild
+  *
+  * @see {@link https://discord.com/developers/docs/resources/guild-scheduled-event#delete-guild-scheduled-event}
+  * @param guildId - The id of the guild to delete the scheduled event from
+  * @param eventId - The id of the scheduled event to delete
+  * @param reason - The reason for deleting the scheduled event
+  */
   async deleteScheduledEvent(guildId, eventId, reason) {
-    await this.rest.delete(Routes3.guildScheduledEvent(guildId, eventId), { reason });
+    await this.rest.delete(Routes3.guildScheduledEvent(guildId, eventId), {
+      reason
+    });
   }
+  /**
+  * Gets all users that are interested in a scheduled event
+  *
+  * @see {@link https://discord.com/developers/docs/resources/guild-scheduled-event#get-guild-scheduled-event-users}
+  * @param guildId - The id of the guild to fetch the scheduled event users from
+  * @param eventId - The id of the scheduled event to fetch the users for
+  * @param options - The options for fetching the scheduled event users
+  */
   async getScheduledEventUsers(guildId, eventId, options = {}) {
     return this.rest.get(Routes3.guildScheduledEventUsers(guildId, eventId), {
       query: makeURLSearchParams3(options)
     });
   }
+  /**
+  * Fetches all the templates for a guild
+  *
+  * @see {@link https://discord.com/developers/docs/resources/guild-template#get-guild-templates}
+  * @param guildId - The id of the guild to fetch the templates from
+  */
   async getTemplates(guildId) {
     return this.rest.get(Routes3.guildTemplates(guildId));
   }
+  /**
+  * Syncs a template for a guild
+  *
+  * @see {@link https://discord.com/developers/docs/resources/guild-template#sync-guild-template}
+  * @param guildId - The id of the guild to sync the template from
+  * @param templateCode - The code of the template to sync
+  */
   async syncTemplate(guildId, templateCode) {
     return this.rest.put(Routes3.guildTemplate(guildId, templateCode));
   }
+  /**
+  * Edits a template for a guild
+  *
+  * @see {@link https://discord.com/developers/docs/resources/guild-template#modify-guild-template}
+  * @param guildId - The id of the guild to edit the template from
+  * @param templateCode - The code of the template to edit
+  * @param data - The data for editing the template
+  */
   async editTemplate(guildId, templateCode, data) {
     return this.rest.patch(Routes3.guildTemplate(guildId, templateCode), {
       body: data
     });
   }
+  /**
+  * Deletes a template for a guild
+  *
+  * @see {@link https://discord.com/developers/docs/resources/guild-template#delete-guild-template}
+  * @param guildId - The id of the guild to delete the template from
+  * @param templateCode - The code of the template to delete
+  */
   async deleteTemplate(guildId, templateCode) {
     await this.rest.delete(Routes3.guildTemplate(guildId, templateCode));
   }
+  /**
+  * Fetches all the stickers for a guild
+  *
+  * @see {@link https://discord.com/developers/docs/resources/sticker#list-guild-stickers}
+  * @param guildId - The id of the guild to fetch the stickers from
+  */
   async getStickers(guildId) {
     return this.rest.get(Routes3.guildStickers(guildId));
   }
+  /**
+  * Fetches a sticker for a guild
+  *
+  * @see {@link https://discord.com/developers/docs/resources/sticker#get-guild-sticker}
+  * @param guildId - The id of the guild to fetch the sticker from
+  * @param stickerId - The id of the sticker to fetch
+  */
   async getSticker(guildId, stickerId) {
     return this.rest.get(Routes3.guildSticker(guildId, stickerId));
   }
+  /**
+  * Creates a sticker for a guild
+  *
+  * @see {@link https://discord.com/developers/docs/resources/sticker#create-guild-sticker}
+  * @param guildId - The id of the guild to create the sticker for
+  * @param data - The data for creating the sticker
+  * @param reason - The reason for creating the sticker
+  */
   async createSticker(guildId, { file, ...body }, reason) {
-    const fileData = { ...file, key: "file" };
+    const fileData = {
+      ...file,
+      key: "file"
+    };
     return this.rest.post(Routes3.guildStickers(guildId), {
       appendToFormData: true,
       body,
-      files: [fileData],
+      files: [
+        fileData
+      ],
       reason
     });
   }
+  /**
+  * Edits a sticker for a guild
+  *
+  * @see {@link https://discord.com/developers/docs/resources/sticker#modify-guild-sticker}
+  * @param guildId - The id of the guild to edit the sticker from
+  * @param stickerId - The id of the sticker to edit
+  * @param data - The data for editing the sticker
+  * @param reason - The reason for editing the sticker
+  */
   async editSticker(guildId, stickerId, data, reason) {
     return this.rest.patch(Routes3.guildSticker(guildId, stickerId), {
       reason,
       body: data
     });
   }
+  /**
+  * Deletes a sticker for a guild
+  *
+  * @see {@link https://discord.com/developers/docs/resources/sticker#delete-guild-sticker}
+  * @param guildId - The id of the guild to delete the sticker from
+  * @param stickerId - The id of the sticker to delete
+  * @param reason - The reason for deleting the sticker
+  */
   async deleteSticker(guildId, stickerId, reason) {
-    await this.rest.delete(Routes3.guildSticker(guildId, stickerId), { reason });
+    await this.rest.delete(Routes3.guildSticker(guildId, stickerId), {
+      reason
+    });
   }
+  /**
+  * Fetches the audit logs for a guild
+  *
+  * @see {@link https://discord.com/developers/docs/resources/audit-log#get-guild-audit-log}
+  * @param guildId - The id of the guild to fetch the audit logs from
+  * @param options - The options for fetching the audit logs
+  */
   async getAuditLogs(guildId, options = {}) {
     return this.rest.get(Routes3.guildAuditLog(guildId), {
       query: makeURLSearchParams3(options)
     });
   }
+  /**
+  * Fetches all auto moderation rules for a guild
+  *
+  * @see {@link https://discord.com/developers/docs/resources/auto-moderation#list-auto-moderation-rules-for-guild}
+  * @param guildId - The id of the guild to fetch the auto moderation rules from
+  */
   async getAutoModerationRules(guildId) {
     return this.rest.get(Routes3.guildAutoModerationRules(guildId));
   }
+  /**
+  * Fetches an auto moderation rule for a guild
+  *
+  * @see {@link https://discord.com/developers/docs/resources/auto-moderation#get-auto-moderation-rule}
+  * @param guildId - The id of the guild to fetch the auto moderation rule from
+  * @param ruleId - The id of the auto moderation rule to fetch
+  */
   async getAutoModerationRule(guildId, ruleId) {
-    return this.rest.get(
-      Routes3.guildAutoModerationRule(guildId, ruleId)
-    );
-  }
+    return this.rest.get(Routes3.guildAutoModerationRule(guildId, ruleId));
+  }
+  /**
+  * Creates a new auto moderation rule for a guild
+  *
+  * @see {@link https://discord.com/developers/docs/resources/auto-moderation#create-auto-moderation-rule}
+  * @param guildId - The id of the guild to create the auto moderation rule from
+  * @param data - The data for creating the auto moderation rule
+  */
   async createAutoModerationRule(guildId, data, reason) {
     return this.rest.post(Routes3.guildAutoModerationRules(guildId), {
       reason,
       body: data
     });
   }
+  /**
+  * Edits an auto moderation rule for a guild
+  *
+  * @see {@link https://discord.com/developers/docs/resources/auto-moderation#modify-auto-moderation-rule}
+  * @param guildId - The id of the guild to edit the auto moderation rule from
+  * @param ruleId - The id of the auto moderation rule to edit
+  * @param data - The data for editing the auto moderation rule
+  * @param reason - The reason for editing the auto moderation rule
+  */
   async editAutoModerationRule(guildId, ruleId, data, reason) {
     return this.rest.patch(Routes3.guildAutoModerationRule(guildId, ruleId), {
       reason,
       body: data
     });
   }
+  /**
+  * Deletes an auto moderation rule for a guild
+  *
+  * @see {@link https://discord.com/developers/docs/resources/auto-moderation#delete-auto-moderation-rule}
+  * @param guildId - The id of the guild to delete the auto moderation rule from
+  * @param ruleId - The id of the auto moderation rule to delete
+  * @param reason - The reason for deleting the auto moderation rule
+  */
   async deleteAutoModerationRule(guildId, ruleId, reason) {
-    await this.rest.delete(Routes3.guildAutoModerationRule(guildId, ruleId), { reason });
+    await this.rest.delete(Routes3.guildAutoModerationRule(guildId, ruleId), {
+      reason
+    });
   }
+  /**
+  * Fetches a guild member
+  *
+  * @see {@link https://discord.com/developers/docs/resources/guild#get-guild-member}
+  * @param guildId - The id of the guild
+  * @param userId - The id of the user
+  */
   async getMember(guildId, userId) {
     return this.rest.get(Routes3.guildMember(guildId, userId));
   }
+  /**
+  * Searches for guild members
+  *
+  * @see {@link https://discord.com/developers/docs/resources/guild#search-guild-members}
+  * @param guildId - The id of the guild to search in
+  * @param query - The query to search for
+  * @param limit - The maximum number of members to return
+  */
   async searchForMembers(guildId, options) {
     return this.rest.get(Routes3.guildMembersSearch(guildId), {
       query: makeURLSearchParams3(options)
     });
   }
+  /**
+  * Edits a guild member
+  *
+  * @see {@link https://discord.com/developers/docs/resources/guild#modify-guild-member}
+  * @param guildId - The id of the guild
+  * @param userId - The id of the user
+  * @param data - The data to use when editing the guild member
+  * @param reason - The reason for editing this guild member
+  */
   async editMember(guildId, userId, data = {}, reason) {
     return this.rest.patch(Routes3.guildMember(guildId, userId), {
       reason,
       body: data
     });
   }
+  /**
+  * Adds a role to a guild member
+  *
+  * @see {@link https://discord.com/developers/docs/resources/guild#add-guild-member-role}
+  * @param guildId - The id of the guild
+  * @param userId - The id of the user
+  * @param roleId - The id of the role
+  * @param reason - The reason for adding this role to the guild member
+  */
   async addRoleToMember(guildId, userId, roleId, reason) {
-    await this.rest.put(Routes3.guildMemberRole(guildId, userId, roleId), { reason });
+    await this.rest.put(Routes3.guildMemberRole(guildId, userId, roleId), {
+      reason
+    });
   }
+  /**
+  * Removes a role from a guild member
+  *
+  * @see {@link https://discord.com/developers/docs/resources/guild#remove-guild-member-role}
+  * @param guildId - The id of the guild
+  * @param userId - The id of the user
+  * @param roleId - The id of the role
+  * @param reason - The reason for removing this role from the guild member
+  */
   async removeRoleFromMember(guildId, userId, roleId, reason) {
-    await this.rest.delete(Routes3.guildMemberRole(guildId, userId, roleId), { reason });
+    await this.rest.delete(Routes3.guildMemberRole(guildId, userId, roleId), {
+      reason
+    });
   }
+  /**
+  * Fetches a guild template
+  *
+  * @see {@link https://discord.com/developers/docs/resources/guild-template#get-guild-template}
+  * @param templateCode - The code of the template
+  */
   async getTemplate(templateCode) {
     return this.rest.get(Routes3.template(templateCode));
   }
+  /**
+  * Creates a new template
+  *
+  * @see {@link https://discord.com/developers/docs/resources/guild-template#create-guild-template}
+  * @param templateCode - The code of the template
+  * @param data - The data to use when creating the template
+  */
   async createTemplate(templateCode, data) {
-    return this.rest.post(Routes3.template(templateCode), { body: data });
+    return this.rest.post(Routes3.template(templateCode), {
+      body: data
+    });
   }
+  /**
+  * Fetches webhooks for a guild
+  *
+  * @see {@link https://discord.com/developers/docs/resources/webhook#get-guild-webhooks}
+  * @param id - The id of the guild
+  */
   async getWebhooks(id) {
     return this.rest.get(Routes3.guildWebhooks(id));
   }
+  /**
+  * Sets the voice state for the current user
+  *
+  * @see {@link https://discord.com/developers/docs/resources/guild#modify-current-user-voice-state}
+  * @param guildId - The id of the guild
+  * @param options - The options to use when setting the voice state
+  */
+  async setVoiceState(guildId, options = {}) {
+    return this.rest.patch(Routes3.guildVoiceState(guildId, "@me"), {
+      body: options
+    });
+  }
 };
 __name(GuildsAPI, "GuildsAPI");
 
 // src/api/interactions.ts
-import {
-  InteractionResponseType,
-  Routes as Routes4
-} from "discord-api-types/v10";
+import { InteractionResponseType, Routes as Routes4 } from "discord-api-types/v10";
 var InteractionsAPI = class {
   constructor(rest, webhooks) {
     this.rest = rest;
     this.webhooks = webhooks;
   }
+  /**
+  * Replies to an interaction
+  *
+  * @see {@link https://discord.com/developers/docs/interactions/receiving-and-responding#create-interaction-response}
+  * @param interactionId - The id of the interaction
+  * @param interactionToken - The token of the interaction
+  * @param data - The data to use when replying
+  */
   async reply(interactionId, interactionToken, { files, ...data }) {
     await this.rest.post(Routes4.interactionCallback(interactionId, interactionToken), {
       files,
+      auth: false,
       body: {
         type: InteractionResponseType.ChannelMessageWithSource,
         data
       }
     });
   }
+  /**
+  * Defers the reply to an interaction
+  *
+  * @see {@link https://discord.com/developers/docs/interactions/receiving-and-responding#create-interaction-response}
+  * @param interactionId - The id of the interaction
+  * @param interactionToken - The token of the interaction
+  */
   async defer(interactionId, interactionToken) {
     await this.rest.post(Routes4.interactionCallback(interactionId, interactionToken), {
+      auth: false,
       body: {
         type: InteractionResponseType.DeferredChannelMessageWithSource
       }
     });
   }
+  /**
+  * Defers an update from a message component interaction
+  *
+  * @see {@link https://discord.com/developers/docs/interactions/receiving-and-responding#create-interaction-response}
+  * @param interactionId - The id of the interaction
+  * @param interactionToken - The token of the interaction
+  */
   async deferMessageUpdate(interactionId, interactionToken) {
     await this.rest.post(Routes4.interactionCallback(interactionId, interactionToken), {
+      auth: false,
       body: {
         type: InteractionResponseType.DeferredMessageUpdate
       }
     });
   }
+  /**
+  * Reply to a deferred interaction
+  *
+  * @see {@link https://discord.com/developers/docs/interactions/receiving-and-responding#create-followup-message}
+  * @param applicationId - The application id of the interaction
+  * @param interactionToken - The token of the interaction
+  * @param data - The data to use when replying
+  */
   async followUp(applicationId, interactionToken, data) {
     await this.webhooks.execute(applicationId, interactionToken, data);
   }
+  /**
+  * Edits the initial reply to an interaction
+  *
+  * @see {@link https://discord.com/developers/docs/interactions/receiving-and-responding#edit-original-interaction-response}
+  * @see {@link https://discord.com/developers/docs/interactions/receiving-and-responding#edit-followup-message}
+  * @param applicationId - The application id of the interaction
+  * @param interactionToken - The token of the interaction
+  * @param data - The data to use when editing the reply
+  * @param messageId - The id of the message to edit. If omitted, the original reply will be edited
+  */
   async editReply(applicationId, interactionToken, data, messageId) {
     return this.webhooks.editMessage(applicationId, interactionToken, messageId ?? "@original", data);
   }
+  /**
+  * Fetches the initial reply to an interaction
+  *
+  * @see {@link https://discord.com/developers/docs/interactions/receiving-and-responding#get-original-interaction-response}
+  * @param applicationId - The application id of the interaction
+  * @param interactionToken - The token of the interaction
+  */
   async getOriginalReply(applicationId, interactionToken) {
-    return this.webhooks.getMessage(
-      applicationId,
-      interactionToken,
-      "@original"
-    );
-  }
+    return this.webhooks.getMessage(applicationId, interactionToken, "@original");
+  }
+  /**
+  * Deletes the initial reply to an interaction
+  *
+  * @see {@link https://discord.com/developers/docs/interactions/receiving-and-responding#delete-original-interaction-response}
+  * @see {@link https://discord.com/developers/docs/interactions/receiving-and-responding#delete-followup-message}
+  * @param applicationId - The application id of the interaction
+  * @param interactionToken - The token of the interaction
+  * @param messageId - The id of the message to delete. If omitted, the original reply will be deleted
+  */
   async deleteReply(applicationId, interactionToken, messageId) {
     await this.webhooks.deleteMessage(applicationId, interactionToken, messageId ?? "@original");
   }
+  /**
+  * Updates the the message the component interaction was triggered on
+  *
+  * @see {@link https://discord.com/developers/docs/interactions/receiving-and-responding#create-interaction-response}
+  * @param interactionId - The id of the interaction
+  * @param interactionToken - The token of the interaction
+  * @param data - The data to use when updating the interaction
+  */
   async updateMessage(interactionId, interactionToken, { files, ...data }) {
     await this.rest.post(Routes4.interactionCallback(interactionId, interactionToken), {
       files,
+      auth: false,
       body: {
         type: InteractionResponseType.UpdateMessage,
         data
       }
     });
   }
+  /**
+  * Sends an autocomplete response to an interaction
+  *
+  * @see {@link https://discord.com/developers/docs/interactions/receiving-and-responding#create-interaction-response}
+  * @param interactionId - The id of the interaction
+  * @param interactionToken - The token of the interaction
+  * @param data - Data for the autocomplete response
+  */
   async createAutocompleteResponse(interactionId, interactionToken, data) {
     await this.rest.post(Routes4.interactionCallback(interactionId, interactionToken), {
+      auth: false,
       body: {
         type: InteractionResponseType.ApplicationCommandAutocompleteResult,
         data
       }
     });
   }
+  /**
+  * Sends a modal response to an interaction
+  *
+  * @see {@link https://discord.com/developers/docs/interactions/receiving-and-responding#create-interaction-response}
+  * @param interactionId - The id of the interaction
+  * @param interactionToken - The token of the interaction
+  * @param data - The modal to send
+  */
   async createModal(interactionId, interactionToken, data) {
     await this.rest.post(Routes4.interactionCallback(interactionId, interactionToken), {
+      auth: false,
       body: {
         type: InteractionResponseType.Modal,
         data
@@ -565,13 +1501,28 @@ var InvitesAPI = class {
   constructor(rest) {
     this.rest = rest;
   }
+  /**
+  * Fetches an invite
+  *
+  * @see {@link https://discord.com/developers/docs/resources/invite#get-invite}
+  * @param code - The invite code
+  */
   async get(code, options = {}) {
     return this.rest.get(Routes5.invite(code), {
       query: makeURLSearchParams4(options)
     });
   }
+  /**
+  * Deletes an invite
+  *
+  * @see {@link https://discord.com/developers/docs/resources/invite#delete-invite}
+  * @param code - The invite code
+  * @param reason - The reason for deleting the invite
+  */
   async delete(code, reason) {
-    await this.rest.delete(Routes5.invite(code), { reason });
+    await this.rest.delete(Routes5.invite(code), {
+      reason
+    });
   }
 };
 __name(InvitesAPI, "InvitesAPI");
@@ -579,19 +1530,28 @@ __name(InvitesAPI, "InvitesAPI");
 // src/api/oauth2.ts
 import { URL } from "node:url";
 import { makeURLSearchParams as makeURLSearchParams5 } from "@discordjs/rest";
-import {
-  Routes as Routes6,
-  RouteBases
-} from "discord-api-types/v10";
+import { Routes as Routes6, RouteBases } from "discord-api-types/v10";
 var OAuth2API = class {
   constructor(rest) {
     this.rest = rest;
   }
+  /**
+  * Creates an OAuth2 authorization URL given the options
+  *
+  * @see {@link https://discord.com/developers/docs/topics/oauth2#authorization-code-grant-authorization-url-example}
+  * @param options - The options for creating the authorization URL
+  */
   generateAuthorizationURL(options) {
     const url = new URL(`${RouteBases.api}${Routes6.oauth2Authorization()}`);
     url.search = makeURLSearchParams5(options).toString();
     return url.toString();
   }
+  /**
+  * Performs an OAuth2 token exchange, giving you an access token
+  *
+  * @see {@link https://discord.com/developers/docs/topics/oauth2#authorization-code-grant-access-token-exchange-example}
+  * @param options - The options for the token exchange request
+  */
   async tokenExchange(options) {
     return this.rest.post(Routes6.oauth2TokenExchange(), {
       body: makeURLSearchParams5(options),
@@ -601,6 +1561,12 @@ var OAuth2API = class {
       }
     });
   }
+  /**
+  * Refreshes an OAuth2 access token, giving you a new one
+  *
+  * @see {@link https://discord.com/developers/docs/topics/oauth2#authorization-code-grant-refresh-token-exchange-example}
+  * @param options - The options for the refresh token request
+  */
   async refreshToken(options) {
     return this.rest.post(Routes6.oauth2TokenExchange(), {
       body: makeURLSearchParams5(options),
@@ -610,6 +1576,14 @@ var OAuth2API = class {
       }
     });
   }
+  /**
+  * Fetches the bearer token for the current application
+  *
+  * @remarks
+  * This is primarily used for testing purposes
+  * @see {@link https://discord.com/developers/docs/topics/oauth2#client-credentials-grant}
+  * @param options - The options for the client credentials grant request
+  */
   async getToken(options) {
     return this.rest.post(Routes6.oauth2TokenExchange(), {
       body: makeURLSearchParams5(options),
@@ -619,9 +1593,19 @@ var OAuth2API = class {
       }
     });
   }
+  /**
+  * Fetches the current bot's application information
+  *
+  * @see {@link https://discord.com/developers/docs/topics/oauth2#get-current-bot-application-information}
+  */
   async getCurrentBotApplicationInformation() {
     return this.rest.get(Routes6.oauth2CurrentApplication());
   }
+  /**
+  * Fetches the current authorization information
+  *
+  * @see {@link https://discord.com/developers/docs/topics/oauth2#get-current-authorization-information}
+  */
   async getCurrentAuthorizationInformation() {
     return this.rest.get(Routes6.oauth2CurrentAuthorization());
   }
@@ -629,18 +1613,27 @@ var OAuth2API = class {
 __name(OAuth2API, "OAuth2API");
 
 // src/api/roleConnections.ts
-import {
-  Routes as Routes7
-} from "discord-api-types/v10";
+import { Routes as Routes7 } from "discord-api-types/v10";
 var RoleConnectionsAPI = class {
   constructor(rest) {
     this.rest = rest;
   }
+  /**
+  * Gets the role connection metadata records for the application
+  *
+  * @see {@link https://discord.com/developers/docs/resources/application-role-connection-metadata#get-application-role-connection-metadata-records}
+  * @param applicationId - The id of the application to get role connection metadata records for
+  */
   async getMetadataRecords(applicationId) {
-    return this.rest.get(
-      Routes7.applicationRoleConnectionMetadata(applicationId)
-    );
-  }
+    return this.rest.get(Routes7.applicationRoleConnectionMetadata(applicationId));
+  }
+  /**
+  * Updates the role connection metadata records for the application
+  *
+  * @see {@link https://discord.com/developers/docs/resources/application-role-connection-metadata#update-application-role-connection-metadata-records}
+  * @param applicationId - The id of the application to update role connection metadata records for
+  * @param options - The new role connection metadata records
+  */
   async updateMetadataRecords(applicationId, options) {
     return this.rest.put(Routes7.applicationRoleConnectionMetadata(applicationId), {
       body: options
@@ -650,16 +1643,25 @@ var RoleConnectionsAPI = class {
 __name(RoleConnectionsAPI, "RoleConnectionsAPI");
 
 // src/api/sticker.ts
-import {
-  Routes as Routes8
-} from "discord-api-types/v10";
+import { Routes as Routes8 } from "discord-api-types/v10";
 var StickersAPI = class {
   constructor(rest) {
     this.rest = rest;
   }
+  /**
+  * Fetches all of the nitro sticker packs
+  *
+  * @see {@link https://discord.com/developers/docs/resources/sticker#list-nitro-sticker-packs}
+  */
   async getNitroStickers() {
     return this.rest.get(Routes8.nitroStickerPacks());
   }
+  /**
+  * Fetches a sticker
+  *
+  * @see {@link https://discord.com/developers/docs/resources/sticker#get-sticker}
+  * @param stickerId - The id of the sticker
+  */
   async get(stickerId) {
     return this.rest.get(Routes8.sticker(stickerId));
   }
@@ -667,42 +1669,105 @@ var StickersAPI = class {
 __name(StickersAPI, "StickersAPI");
 
 // src/api/thread.ts
-import {
-  Routes as Routes9
-} from "discord-api-types/v10";
+import { Routes as Routes9 } from "discord-api-types/v10";
 var ThreadsAPI = class {
   constructor(rest) {
     this.rest = rest;
   }
+  /**
+  * Fetches a thread
+  *
+  * @see {@link https://discord.com/developers/docs/resources/channel#get-channel}
+  * @param threadId - The id of the thread
+  */
   async get(threadId) {
     return this.rest.get(Routes9.channel(threadId));
   }
+  /**
+  * Creates a new thread
+  *
+  * @see {@link https://discord.com/developers/docs/resources/channel#start-thread-from-message}
+  * @see {@link https://discord.com/developers/docs/resources/channel#start-thread-without-message}
+  * @param channelId - The id of the channel to start the thread in
+  * @param data - The data to use when starting the thread
+  */
   async create(channelId, { message_id, ...body }) {
-    return this.rest.post(Routes9.threads(channelId, message_id), { body });
+    return this.rest.post(Routes9.threads(channelId, message_id), {
+      body
+    });
   }
+  /**
+  * Creates a new forum post
+  *
+  * @see {@link https://discord.com/developers/docs/resources/channel#start-thread-in-forum-channel}
+  * @param channelId - The id of the forum channel to start the thread in
+  * @param data - The data to use when starting the thread
+  */
   async createForumThread(channelId, { message, ...optionsBody }) {
     const { files, ...messageBody } = message;
     const body = {
       ...optionsBody,
       message: messageBody
     };
-    return this.rest.post(Routes9.threads(channelId), { files, body });
+    return this.rest.post(Routes9.threads(channelId), {
+      files,
+      body
+    });
   }
+  /**
+  * Adds the current user to a thread
+  *
+  * @see {@link https://discord.com/developers/docs/resources/channel#join-thread}
+  * @param threadId - The id of the thread to join
+  */
   async join(threadId) {
     await this.rest.put(Routes9.threadMembers(threadId, "@me"));
   }
+  /**
+  * Adds a member to a thread
+  *
+  * @see {@link https://discord.com/developers/docs/resources/channel#add-thread-member}
+  * @param threadId - The id of the thread to add the member to
+  * @param userId - The id of the user to add to the thread
+  */
   async addMember(threadId, userId) {
     await this.rest.put(Routes9.threadMembers(threadId, userId));
   }
+  /**
+  * Removes the current user from a thread
+  *
+  * @see {@link https://discord.com/developers/docs/resources/channel#leave-thread}
+  * @param threadId - The id of the thread to leave
+  */
   async leave(threadId) {
     await this.rest.delete(Routes9.threadMembers(threadId, "@me"));
   }
+  /**
+  * Removes a member from a thread
+  *
+  * @see {@link https://discord.com/developers/docs/resources/channel#remove-thread-member}
+  * @param threadId - The id of the thread to remove the member from
+  * @param userId - The id of the user to remove from the thread
+  */
   async removeMember(threadId, userId) {
     await this.rest.delete(Routes9.threadMembers(threadId, userId));
   }
+  /**
+  * Fetches a member of a thread
+  *
+  * @see {@link https://discord.com/developers/docs/resources/channel#get-thread-member}
+  * @param threadId - The id of the thread to fetch the member from
+  * @param userId - The id of the user
+  */
   async getMember(threadId, userId) {
     return this.rest.get(Routes9.threadMembers(threadId, userId));
   }
+  /**
+  * Fetches all members of a thread
+  *
+  * @see {@link https://discord.com/developers/docs/resources/channel#list-thread-members}
+  * @param threadId - The id of the thread to fetch the members from
+  */
   async getAllMembers(threadId) {
     return this.rest.get(Routes9.threadMembers(threadId));
   }
@@ -711,57 +1776,119 @@ __name(ThreadsAPI, "ThreadsAPI");
 
 // src/api/user.ts
 import { makeURLSearchParams as makeURLSearchParams6 } from "@discordjs/rest";
-import {
-  Routes as Routes10
-} from "discord-api-types/v10";
+import { Routes as Routes10 } from "discord-api-types/v10";
 var UsersAPI = class {
   constructor(rest) {
     this.rest = rest;
   }
+  /**
+  * Fetches a user by their id
+  *
+  * @see {@link https://discord.com/developers/docs/resources/user#get-user}
+  * @param userId - The id of the user to fetch
+  */
   async get(userId) {
     return this.rest.get(Routes10.user(userId));
   }
+  /**
+  * Returns the user object of the requester's account
+  *
+  * @see {@link https://discord.com/developers/docs/resources/user#get-current-user}
+  */
   async getCurrent() {
     return this.rest.get(Routes10.user("@me"));
   }
+  /**
+  * Returns a list of partial guild objects the current user is a member of
+  *
+  * @see {@link https://discord.com/developers/docs/resources/user#get-current-user-guilds}
+  * @param options - The options to use when fetching the current user's guilds
+  */
   async getGuilds(options = {}) {
     return this.rest.get(Routes10.userGuilds(), {
       query: makeURLSearchParams6(options)
     });
   }
+  /**
+  * Leaves the guild with the given id
+  *
+  * @see {@link https://discord.com/developers/docs/resources/user#leave-guild}
+  * @param guildId - The id of the guild
+  */
   async leaveGuild(guildId) {
     await this.rest.delete(Routes10.userGuild(guildId));
   }
+  /**
+  * Edits the current user
+  *
+  * @see {@link https://discord.com/developers/docs/resources/user#modify-current-user}
+  * @param user - The new data for the current user
+  */
   async edit(user) {
-    return this.rest.patch(Routes10.user("@me"), { body: user });
+    return this.rest.patch(Routes10.user("@me"), {
+      body: user
+    });
   }
+  /**
+  * Fetches the guild member for the current user
+  *
+  * @see {@link https://discord.com/developers/docs/resources/user#get-current-user-guild-member}
+  * @param guildId - The id of the guild
+  */
   async getGuildMember(guildId) {
     return this.rest.get(Routes10.userGuildMember(guildId));
   }
+  /**
+  * Edits the guild member for the current user
+  *
+  * @see {@link https://discord.com/developers/docs/resources/guild#modify-current-member}
+  * @param guildId - The id of the guild
+  * @param member - The new data for the guild member
+  * @param reason - The reason for editing this guild member
+  */
   async editGuildMember(guildId, member = {}, reason) {
     return this.rest.patch(Routes10.guildMember(guildId, "@me"), {
       reason,
       body: member
     });
   }
-  async setVoiceState(guildId, options = {}) {
-    return this.rest.patch(Routes10.guildVoiceState(guildId, "@me"), {
-      body: options
-    });
-  }
+  /**
+  * Opens a new DM channel with a user
+  *
+  * @see {@link https://discord.com/developers/docs/resources/user#create-dm}
+  * @param userId - The id of the user to open a DM channel with
+  */
   async createDM(userId) {
     return this.rest.post(Routes10.userChannels(), {
-      body: { recipient_id: userId }
+      body: {
+        recipient_id: userId
+      }
     });
   }
+  /**
+  * Gets the current user's connections
+  *
+  * @see {@link https://discord.com/developers/docs/resources/user#get-user-connections}
+  */
   async getConnections() {
     return this.rest.get(Routes10.userConnections());
   }
+  /**
+  * Gets the current user's active application role connection
+  *
+  * @see {@link https://discord.com/developers/docs/resources/user#get-user-application-role-connection}
+  * @param applicationId - The id of the application
+  */
   async getApplicationRoleConnection(applicationId) {
-    return this.rest.get(
-      Routes10.userApplicationRoleConnection(applicationId)
-    );
-  }
+    return this.rest.get(Routes10.userApplicationRoleConnection(applicationId));
+  }
+  /**
+  * Updates the current user's application role connection
+  *
+  * @see {@link https://discord.com/developers/docs/resources/user#update-user-application-role-connection}
+  * @param applicationId - The id of the application
+  * @param options - The options to use when updating the application role connection
+  */
   async updateApplicationRoleConnection(applicationId, options) {
     return this.rest.put(Routes10.userApplicationRoleConnection(applicationId), {
       body: options
@@ -776,6 +1903,11 @@ var VoiceAPI = class {
   constructor(rest) {
     this.rest = rest;
   }
+  /**
+  * Fetches all voice regions
+  *
+  * @see {@link https://discord.com/developers/docs/resources/voice#list-voice-regions}
+  */
   async getVoiceRegions() {
     return this.rest.get(Routes11.voiceRegions());
   }
@@ -784,41 +1916,91 @@ __name(VoiceAPI, "VoiceAPI");
 
 // src/api/webhook.ts
 import { makeURLSearchParams as makeURLSearchParams7 } from "@discordjs/rest";
-import {
-  Routes as Routes12
-} from "discord-api-types/v10";
+import { Routes as Routes12 } from "discord-api-types/v10";
 var WebhooksAPI = class {
   constructor(rest) {
     this.rest = rest;
   }
+  /**
+  * Fetches a webhook
+  *
+  * @see {@link https://discord.com/developers/docs/resources/webhook#get-webhook}
+  * @see {@link https://discord.com/developers/docs/resources/webhook#get-webhook-with-token}
+  * @param id - The id of the webhook
+  * @param token - The token of the webhook
+  */
   async get(id, token) {
     return this.rest.get(Routes12.webhook(id, token));
   }
+  /**
+  * Creates a new webhook
+  *
+  * @see {@link https://discord.com/developers/docs/resources/webhook#create-webhook}
+  * @param channelId - The id of the channel to create the webhook in
+  * @param data - The data to use when creating the webhook
+  * @param reason - The reason for creating the webhook
+  */
   async create(channelId, data, reason) {
     return this.rest.post(Routes12.channelWebhooks(channelId), {
       reason,
       body: data
     });
   }
+  /**
+  * Edits a webhook
+  *
+  * @see {@link https://discord.com/developers/docs/resources/webhook#modify-webhook}
+  * @see {@link https://discord.com/developers/docs/resources/webhook#modify-webhook-with-token}
+  * @param id - The id of the webhook to edit
+  * @param webhook - The new webhook data
+  * @param options - The options to use when editing the webhook
+  */
   async edit(id, webhook, { token, reason } = {}) {
-    return this.rest.patch(Routes12.webhook(id, token), { reason, body: webhook });
+    return this.rest.patch(Routes12.webhook(id, token), {
+      reason,
+      body: webhook
+    });
   }
+  /**
+  * Deletes a webhook
+  *
+  * @see {@link https://discord.com/developers/docs/resources/webhook#delete-webhook}
+  * @see {@link https://discord.com/developers/docs/resources/webhook#delete-webhook-with-token}
+  * @param id - The id of the webhook to delete
+  * @param options - The options to use when deleting the webhook
+  */
   async delete(id, { token, reason } = {}) {
-    await this.rest.delete(Routes12.webhook(id, token), { reason });
-  }
-  async execute(id, token, {
-    wait,
-    thread_id,
-    files,
-    ...body
-  }) {
+    await this.rest.delete(Routes12.webhook(id, token), {
+      reason
+    });
+  }
+  /**
+  * Executes a webhook
+  *
+  * @see {@link https://discord.com/developers/docs/resources/webhook#execute-webhook}
+  * @param id - The id of the webhook
+  * @param token - The token of the webhook
+  * @param data - The data to use when executing the webhook
+  */
+  async execute(id, token, { wait, thread_id, files, ...body }) {
     return this.rest.post(Routes12.webhook(id, token), {
-      query: makeURLSearchParams7({ wait, thread_id }),
+      query: makeURLSearchParams7({
+        wait,
+        thread_id
+      }),
       files,
       body,
       auth: false
     });
   }
+  /**
+  * Executes a slack webhook
+  *
+  * @see {@link https://discord.com/developers/docs/resources/webhook#execute-slackcompatible-webhook}
+  * @param id - The id of the webhook
+  * @param token - The token of the webhook
+  * @param options - The options to use when executing the webhook
+  */
   async executeSlack(id, token, body, options = {}) {
     await this.rest.post(Routes12.webhookPlatform(id, token, "slack"), {
       query: makeURLSearchParams7(options),
@@ -826,6 +2008,14 @@ var WebhooksAPI = class {
       auth: false
     });
   }
+  /**
+  * Executes a github webhook
+  *
+  * @see {@link https://discord.com/developers/docs/resources/webhook#execute-githubcompatible-webhook}
+  * @param id - The id of the webhook
+  * @param token - The token of the webhook
+  * @param options - The options to use when executing the webhook
+  */
   async executeGitHub(id, token, body, options = {}) {
     await this.rest.post(Routes12.webhookPlatform(id, token, "github"), {
       query: makeURLSearchParams7(options),
@@ -833,19 +2023,48 @@ var WebhooksAPI = class {
       auth: false
     });
   }
+  /**
+  * Fetches an associated message from a webhook
+  *
+  * @see {@link https://discord.com/developers/docs/resources/webhook#get-webhook-message}
+  * @param id - The id of the webhook
+  * @param token - The token of the webhook
+  * @param messageId - The id of the message to fetch
+  * @param options - The options to use when fetching the message
+  */
   async getMessage(id, token, messageId, options = {}) {
     return this.rest.get(Routes12.webhookMessage(id, token, messageId), {
       query: makeURLSearchParams7(options),
       auth: false
     });
   }
+  /**
+  * Edits an associated message from a webhook
+  *
+  * @see {@link https://discord.com/developers/docs/resources/webhook#edit-webhook-message}
+  * @param id - The id of the webhook
+  * @param token - The token of the webhook
+  * @param messageId - The id of the message to edit
+  * @param data - The data to use when editing the message
+  */
   async editMessage(id, token, messageId, { thread_id, ...body }) {
     return this.rest.patch(Routes12.webhookMessage(id, token, messageId), {
-      query: makeURLSearchParams7({ thread_id }),
+      query: makeURLSearchParams7({
+        thread_id
+      }),
       auth: false,
       body
     });
   }
+  /**
+  * Deletes an associated message from a webhook
+  *
+  * @see {@link https://discord.com/developers/docs/resources/webhook#delete-webhook-message}
+  * @param id - The id of the webhook
+  * @param token - The token of the webhook
+  * @param messageId - The id of the message to delete
+  * @param options - The options to use when deleting the message
+  */
   async deleteMessage(id, token, messageId, options = {}) {
     await this.rest.delete(Routes12.webhookMessage(id, token, messageId), {
       query: makeURLSearchParams7(options),
@@ -872,18 +2091,6 @@ var API = class {
     this.webhooks = new WebhooksAPI(rest);
     this.interactions = new InteractionsAPI(rest, this.webhooks);
   }
-  applicationCommands;
-  channels;
-  guilds;
-  interactions;
-  invites;
-  oauth2;
-  roleConnections;
-  stickers;
-  threads;
-  users;
-  voice;
-  webhooks;
 };
 __name(API, "API");
 
@@ -893,14 +2100,8 @@ import { calculateShardId } from "@discordjs/util";
 import { WebSocketShardEvents } from "@discordjs/ws";
 import { DiscordSnowflake } from "@sapphire/snowflake";
 import { AsyncEventEmitter } from "@vladfrangu/async_event_emitter";
-import {
-  GatewayDispatchEvents,
-  GatewayOpcodes
-} from "discord-api-types/v10";
+import { GatewayDispatchEvents, GatewayOpcodes } from "discord-api-types/v10";
 var Client = class extends AsyncEventEmitter {
-  rest;
-  ws;
-  api;
   constructor({ rest, ws }) {
     super();
     this.rest = rest;
@@ -910,6 +2111,13 @@ var Client = class extends AsyncEventEmitter {
       this.emit(dispatch.t, this.wrapIntrinsicProps(dispatch.d, shardId));
     });
   }
+  /**
+  * Requests guild members from the gateway.
+  *
+  * @see {@link https://discord.com/developers/docs/topics/gateway-events#request-guild-members}
+  * @param options - The options for the request
+  * @param timeout - The timeout for waiting for each guild members chunk event
+  */
   async requestGuildMembers(options, timeout = 1e4) {
     const shardId = calculateShardId(options.guild_id, await this.ws.getShardCount());
     const nonce = options.nonce ?? DiscordSnowflake.generate().toString();
@@ -932,6 +2140,7 @@ var Client = class extends AsyncEventEmitter {
     });
     await this.ws.send(shardId, {
       op: GatewayOpcodes.RequestGuildMembers,
+      // eslint-disable-next-line id-length
       d: {
         ...options,
         nonce
@@ -939,16 +2148,30 @@ var Client = class extends AsyncEventEmitter {
     });
     return promise;
   }
+  /**
+  * Updates the voice state of the bot user
+  *
+  * @see {@link https://discord.com/developers/docs/topics/gateway-events#update-voice-state}
+  * @param options - The options for updating the voice state
+  */
   async updateVoiceState(options) {
     const shardId = calculateShardId(options.guild_id, await this.ws.getShardCount());
     await this.ws.send(shardId, {
       op: GatewayOpcodes.VoiceStateUpdate,
+      // eslint-disable-next-line id-length
       d: options
     });
   }
+  /**
+  * Updates the presence of the bot user
+  *
+  * @param shardId - The id of the shard to update the presence in
+  * @param options - The options for updating the presence
+  */
   async updatePresence(shardId, options) {
     await this.ws.send(shardId, {
       op: GatewayOpcodes.PresenceUpdate,
+      // eslint-disable-next-line id-length
       d: options
     });
   }
@@ -975,7 +2198,10 @@ function withFiles(files, options) {
     name: file.name ?? index.toString(),
     data: file.data
   }));
-  return { body, files: outputFiles };
+  return {
+    body,
+    files: outputFiles
+  };
 }
 __name(withFiles, "withFiles");