elynn-baileys 1.0.1

package/lib/Discord/routes/Guilds.js

@@ -0,0 +1,1785 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const ApplicationCommand_1 = __importDefault(require("../structures/ApplicationCommand"));
+const AuditLogEntry_1 = __importDefault(require("../structures/AuditLogEntry"));
+const AutoModerationRule_1 = __importDefault(require("../structures/AutoModerationRule"));
+const Guild_1 = __importDefault(require("../structures/Guild"));
+const GuildPreview_1 = __importDefault(require("../structures/GuildPreview"));
+const GuildScheduledEvent_1 = __importDefault(require("../structures/GuildScheduledEvent"));
+const GuildTemplate_1 = __importDefault(require("../structures/GuildTemplate"));
+const Integration_1 = __importDefault(require("../structures/Integration"));
+const Invite_1 = __importDefault(require("../structures/Invite"));
+const Role_1 = __importDefault(require("../structures/Role"));
+const Soundboard_1 = __importDefault(require("../structures/Soundboard"));
+const VoiceState_1 = __importDefault(require("../structures/VoiceState"));
+const Webhook_1 = __importDefault(require("../structures/Webhook"));
+const QueryBuilder_1 = __importDefault(require("../util/QueryBuilder"));
+const Routes = __importStar(require("../util/Routes"));
+const promises_1 = require("node:timers/promises");
+/** Various methods for interacting with guilds. Located at {@link Client#rest | Client#rest}{@link RESTManager#guilds | .guilds}. */
+class Guilds {
+    _manager;
+    constructor(manager) {
+        this._manager = manager;
+    }
+    /**
+     * Add a member to a guild. Requires an access token with the `guilds.join` scope.
+     *
+     * Returns the newly added member upon success, or void if the member is already in the guild.
+     * @param guildID The ID of the guild.
+     * @param userID The ID of the user to add.
+     * @param options The options for adding the member.
+     * @caching This method **may** cache its result. The result will not be cached if the guild is not cached.
+     * @caches {@link Guild#members | Guild#members}
+     */
+    async addMember(guildID, userID, options) {
+        options = this._manager.client.util._freeze(options);
+        return this._manager.authRequest({
+            method: "PUT",
+            path: Routes.GUILD_MEMBER(guildID, userID),
+            json: {
+                access_token: options.accessToken,
+                deaf: options.deaf,
+                mute: options.mute,
+                nick: options.nick,
+                roles: options.roles
+            }
+        }).then(data => data === null ? undefined : this._manager.client.util.updateMember(guildID, userID, data));
+    }
+    /**
+     * Add a role to a member.
+     * @param guildID The ID of the guild.
+     * @param memberID The ID of the member.
+     * @param roleID The ID of the role to add.
+     * @param reason The reason for adding the role.
+     * @caching This method **does not** cache its result.
+     */
+    async addMemberRole(guildID, memberID, roleID, reason) {
+        await this._manager.authRequest({
+            method: "PUT",
+            path: Routes.GUILD_MEMBER_ROLE(guildID, memberID, roleID),
+            reason
+        });
+    }
+    /**
+     * Begin a prune.
+     * @param guildID The ID of the guild.
+     * @param options The options for the prune.
+     * @caching This method **does not** cache its result.
+     */
+    async beginPrune(guildID, options) {
+        options = this._manager.client.util._freeze(options);
+        return this._manager.authRequest({
+            method: "POST",
+            path: Routes.GUILD_PRUNE(guildID),
+            json: {
+                days: options?.days,
+                compute_prune_count: options?.computePruneCount,
+                include_roles: options?.includeRoles
+            },
+            reason: options?.reason
+        }).then(data => data.pruned);
+    }
+    /**
+     * Ban up to 200 members from a guild. This requires both the `BAN_MEMBERS` and `MANAGE_GUILD` permissions.
+     * If no members were banned, a {@link Constants~JSONErrorCodes.FAILED_TO_BAN_USERS | FAILED_TO_BAN_USERS } will be returned.
+     * The bot user is ignored.
+     * @param guildID The ID of the guild.
+     * @param options The options for banning.
+     */
+    async bulkBan(guildID, options) {
+        options = this._manager.client.util._freeze(options);
+        return this._manager.authRequest({
+            method: "POST",
+            path: Routes.GUILD_BULK_BAN(guildID),
+            json: {
+                delete_message_seconds: options.deleteMessageSeconds,
+                user_ids: options.userIDs
+            },
+            reason: options.reason
+        }).then(data => ({
+            bannedUsers: data.banned_users,
+            failedUsers: data.failed_users
+        }));
+    }
+    /**
+     * Create an auto moderation rule for a guild.
+     * @param guildID The ID of the guild.
+     * @param options The options for creating the rule.
+     * @caching This method **may** cache its result. The result will not be cached if the guild is not cached.
+     * @caches {@link Guild#autoModerationRules | Guild#autoModerationRules}
+     */
+    async createAutoModerationRule(guildID, options) {
+        options = this._manager.client.util._freeze(options);
+        return this._manager.authRequest({
+            method: "POST",
+            path: Routes.GUILD_AUTOMOD_RULES(guildID),
+            json: {
+                actions: options.actions.map(a => ({
+                    metadata: {
+                        channel_id: a.metadata.channelID,
+                        custom_message: a.metadata.customMessage,
+                        duration_seconds: a.metadata.durationSeconds
+                    },
+                    type: a.type
+                })),
+                enabled: options.enabled,
+                event_type: options.eventType,
+                exempt_channels: options.exemptChannels,
+                exempt_roles: options.exemptRoles,
+                name: options.name,
+                trigger_metadata: options.triggerMetadata ? {
+                    allow_list: options.triggerMetadata.allowList,
+                    keyword_filter: options.triggerMetadata.keywordFilter,
+                    mention_raid_protection_enabled: options.triggerMetadata.mentionRaidProtectionEnabled,
+                    mention_total_limit: options.triggerMetadata.mentionTotalLimit,
+                    presets: options.triggerMetadata.presets,
+                    regex_patterns: options.triggerMetadata.regexPatterns
+                } : undefined,
+                trigger_type: options.triggerType
+            },
+            reason: options.reason
+        }).then(data => this._manager.client.guilds.get(guildID)?.autoModerationRules.update(data) ?? new AutoModerationRule_1.default(data, this._manager.client));
+    }
+    /**
+     * Create a ban for a user.
+     * @param guildID The ID of the guild.
+     * @param userID The ID of the user to ban.
+     * @param options The options for creating the ban.
+     * @caching This method **does not** cache its result.
+     */
+    async createBan(guildID, userID, options) {
+        options = this._manager.client.util._freeze(options);
+        let deleteMessageSeconds = options?.deleteMessageSeconds;
+        if (options?.deleteMessageDays !== undefined && !Object.hasOwn(options, "deleteMessageSeconds")) {
+            deleteMessageSeconds = options.deleteMessageDays * 86400;
+        }
+        await this._manager.authRequest({
+            method: "PUT",
+            path: Routes.GUILD_BAN(guildID, userID),
+            json: { delete_message_seconds: deleteMessageSeconds },
+            reason: options?.reason
+        });
+    }
+    /**
+     * Create a channel in a guild.
+     * @param guildID The ID of the guild.
+     * @param options The options for creating the channel.
+     * @caching This method **may** cache its result. The result will not be cached if the guild is not cached.
+     * @caches {@link Guild#channels | Guild#channels}
+     */
+    async createChannel(guildID, type, options) {
+        options = this._manager.client.util._freeze(options);
+        return this._manager.authRequest({
+            method: "POST",
+            path: Routes.GUILD_CHANNELS(guildID),
+            json: {
+                available_tags: options.availableTags ? options.availableTags.map(tag => ({
+                    emoji_id: tag.emoji?.id,
+                    emoji_name: tag.emoji?.name,
+                    moderated: tag.moderated,
+                    name: tag.name
+                })) : options.availableTags,
+                bitrate: options.bitrate,
+                default_auto_archive_duration: options.defaultAutoArchiveDuration,
+                default_forum_layout: options.defaultForumLayout,
+                default_reaction_emoji: options.defaultReactionEmoji ? { emoji_id: options.defaultReactionEmoji.id, emoji_name: options.defaultReactionEmoji.name } : options.defaultReactionEmoji,
+                default_sort_order: options.defaultSortOrder,
+                name: options.name,
+                nsfw: options.nsfw,
+                parent_id: options.parentID,
+                permission_overwrites: options.permissionOverwrites,
+                position: options.position,
+                rate_limit_per_user: options.rateLimitPerUser,
+                rtc_region: options.rtcRegion,
+                topic: options.topic,
+                type,
+                user_limit: options.userLimit,
+                video_quality_mode: options.videoQualityMode
+            },
+            reason: options.reason
+        }).then(data => this._manager.client.util.updateChannel(data));
+    }
+    /**
+     * Create an emoji in a guild.
+     * @param guildID The ID of the guild.
+     * @param options The options for creating the emoji.
+     * @caching This method **may** cache its result. The result will not be cached if the guild is not cached.
+     * @caches {@link Guild#emojis | Guild#emojis}<br>{@link Client#users | Client#users} (creator, if applicable)
+     */
+    async createEmoji(guildID, options) {
+        options = this._manager.client.util._freeze(options);
+        let image;
+        if (options.image) {
+            image = this._manager.client.util._convertImage(options.image, "image");
+        }
+        return this._manager.authRequest({
+            method: "POST",
+            path: Routes.GUILD_EMOJIS(guildID),
+            json: {
+                image,
+                name: options.name,
+                roles: options.roles
+            },
+            reason: options.reason
+        }).then(data => this._manager.client.guilds.get(guildID)?.emojis.update(data) ?? this._manager.client.util.convertGuildEmoji(data));
+    }
+    /**
+     * Create a role.
+     * @param guildID The ID of the guild.
+     * @param options The options for creating the role.
+     * @caching This method **may** cache its result. The result will not be cached if the guild is not cached.
+     * @caches {@link Guild#roles | Guild#roles}
+     */
+    async createRole(guildID, options) {
+        options = this._manager.client.util._freeze(options);
+        let icon;
+        if (options?.icon) {
+            icon = this._manager.client.util._convertImage(options.icon, "icon");
+        }
+        return this._manager.authRequest({
+            method: "POST",
+            path: Routes.GUILD_ROLES(guildID),
+            json: {
+                colors: options?.colors || options?.color ? {
+                    primary_color: options.colors?.primaryColor ?? options.color,
+                    secondary_color: options.colors?.secondaryColor,
+                    tertiary_color: options.colors?.tertiaryColor
+                } : undefined,
+                hoist: options?.hoist,
+                icon,
+                mentionable: options?.mentionable,
+                name: options?.name,
+                permissions: options?.permissions,
+                unicode_emoji: options?.unicodeEmoji
+            },
+            reason: options?.reason
+        }).then(data => this._manager.client.guilds.get(guildID)?.roles.update(data, guildID) ?? new Role_1.default(data, this._manager.client, guildID));
+    }
+    /**
+     * Create a scheduled event in a guild.
+     * @param guildID The ID of the guild.
+     * @param options The options for creating the scheduled event.
+     * @caching This method **may** cache its result. The result will not be cached if the guild is not cached.
+     * @caches {@link Guild#scheduledEvents | Guild#scheduledEvents}
+     */
+    async createScheduledEvent(guildID, options) {
+        options = this._manager.client.util._freeze(options);
+        let image;
+        if (options.image) {
+            image = this._manager.client.util._convertImage(options.image, "image");
+        }
+        return this._manager.authRequest({
+            method: "POST",
+            path: Routes.GUILD_SCHEDULED_EVENTS(guildID),
+            json: {
+                channel_id: options.channelID,
+                description: options.description,
+                entity_metadata: options.entityMetadata ? { location: options.entityMetadata.location } : undefined,
+                entity_type: options.entityType,
+                image,
+                name: options.name,
+                privacy_level: options.privacyLevel,
+                scheduled_end_time: options.scheduledEndTime,
+                scheduled_start_time: options.scheduledStartTime
+            },
+            reason: options.reason
+        }).then(data => this._manager.client.guilds.get(guildID)?.scheduledEvents.update(data) ?? new GuildScheduledEvent_1.default(data, this._manager.client));
+    }
+    /**
+     * Create a soundboard sound
+     * @param guildID The ID of the guild
+     * @param options The options for creating the soundboard sound
+     * @caching This method **may** cache its result. The result will not be cached if the guild is not cached.
+     * @caches {@link Guild#soundboardSounds | Guild#soundboardSounds}
+     */
+    async createSoundboardSound(guildID, options) {
+        options = this._manager.client.util._freeze(options);
+        let sound;
+        if (options.sound) {
+            sound = this._manager.client.util._convertSound(options.sound, "sound");
+        }
+        return this._manager.authRequest({
+            method: "POST",
+            path: Routes.SOUNDBOARD_SOUNDS(guildID),
+            json: {
+                emoji_id: options.emojiID,
+                emoji_name: options.emojiName,
+                name: options.name,
+                sound,
+                volume: options.volume
+            },
+            reason: options.reason
+        }).then(data => this._manager.client.guilds.get(guildID)?.soundboardSounds.update(data) ?? new Soundboard_1.default(data, this._manager.client));
+    }
+    /**
+     * Create a sticker.
+     * @param guildID The ID of the guild.
+     * @param options The options for creating the sticker.
+     * @caching This method **may** cache its result. The result will not be cached if the guild is not cached.
+     * @caches {@link Guild#stickers | Guild#stickers}<br>{@link Client#users | Client#users} (creator, if applicable)
+     */
+    async createSticker(guildID, options) {
+        options = this._manager.client.util._freeze(options);
+        const magic = this._manager.client.util.getMagic(options.file.contents);
+        let mime;
+        switch (magic) {
+            // png & apng have the same magic
+            case "89504E47": {
+                mime = "image/png";
+                break;
+            }
+            // lottie
+            case "7B227622": {
+                mime = "application/json";
+                break;
+            }
+        }
+        const form = new FormData();
+        form.append("description", options.description);
+        form.append("name", options.name);
+        form.append("tags", options.tags);
+        form.append("file", new Blob([options.file.contents], { type: mime }), options.file.name);
+        return this._manager.authRequest({
+            method: "POST",
+            path: Routes.GUILD_STICKERS(guildID),
+            form,
+            reason: options.reason
+        }).then(data => this._manager.client.guilds.get(guildID)?.stickers.update(data) ?? this._manager.client.util.convertSticker(data));
+    }
+    /**
+     * Create a guild template.
+     * @param guildID The ID of the guild to create a template from.
+     * @param options The options for creating the template.
+     */
+    async createTemplate(guildID, options) {
+        options = this._manager.client.util._freeze(options);
+        return this._manager.authRequest({
+            method: "POST",
+            path: Routes.GUILD_TEMPLATES(guildID),
+            json: {
+                description: options.description,
+                name: options.name
+            }
+        }).then(data => new GuildTemplate_1.default(data, this._manager.client));
+    }
+    /**
+     * Delete an auto moderation rule.
+     * @param guildID The ID of the guild.
+     * @param ruleID The ID of the rule to delete.
+     * @param reason The reason for deleting the rule.
+     * @caching This method **does not** cache its result.
+     */
+    async deleteAutoModerationRule(guildID, ruleID, reason) {
+        await this._manager.authRequest({
+            method: "DELETE",
+            path: Routes.GUILD_AUTOMOD_RULE(guildID, ruleID),
+            reason
+        });
+    }
+    /**
+     * Delete an emoji.
+     * @param guildID The ID of the guild.
+     * @param emojiID The ID of the emoji.
+     * @param reason The reason for deleting the emoji.
+     * @caching This method **does not** cache its result.
+     */
+    async deleteEmoji(guildID, emojiID, reason) {
+        await this._manager.authRequest({
+            method: "DELETE",
+            path: Routes.GUILD_EMOJI(guildID, emojiID),
+            reason
+        });
+    }
+    /**
+     * Delete an integration.
+     * @param guildID The ID of the guild.
+     * @param integrationID The ID of the integration.
+     * @param reason The reason for deleting the integration.
+     * @caching This method **does not** cache its result.
+     */
+    async deleteIntegration(guildID, integrationID, reason) {
+        await this._manager.authRequest({
+            method: "DELETE",
+            path: Routes.GUILD_INTEGRATION(guildID, integrationID),
+            reason
+        });
+    }
+    /**
+     * Delete a role.
+     * @param guildID The ID of the guild.
+     * @param roleID The ID of the role to delete.
+     * @param reason The reason for deleting the role.
+     * @caching This method **does not** cache its result.
+     */
+    async deleteRole(guildID, roleID, reason) {
+        await this._manager.authRequest({
+            method: "DELETE",
+            path: Routes.GUILD_ROLE(guildID, roleID),
+            reason
+        });
+    }
+    /**
+     * Delete a scheduled event.
+     * @param guildID The ID of the guild.
+     * @param eventID The ID of the scheduled event.
+     * @param reason The reason for deleting the scheduled event. Discord's docs do not explicitly state a reason can be provided, so it may not be used.
+     * @caching This method **does not** cache its result.
+     */
+    async deleteScheduledEvent(guildID, eventID, reason) {
+        await this._manager.authRequest({
+            method: "DELETE",
+            path: Routes.GUILD_SCHEDULED_EVENT(guildID, eventID),
+            reason
+        });
+    }
+    /**
+     *
+     * @param guildID The ID of the guild.
+     * @param soundID The ID of the soundboard sound to delete.
+     * @param reason The reason for deleting the soundboard sound.
+     * @caching This method **does not** cache its result.
+     */
+    async deleteSoundboardSound(guildID, soundID, reason) {
+        await this._manager.authRequest({
+            method: "DELETE",
+            path: Routes.SOUNDBOARD_SOUND(guildID, soundID),
+            reason
+        });
+    }
+    /**
+     * Delete a sticker.
+     * @param guildID The ID of the guild.
+     * @param stickerID The ID of the sticker to delete.
+     * @param reason The reason for deleting the sticker.
+     * @caching This method **does not** cache its result.
+     */
+    async deleteSticker(guildID, stickerID, reason) {
+        await this._manager.authRequest({
+            method: "DELETE",
+            path: Routes.GUILD_STICKER(guildID, stickerID),
+            reason
+        });
+    }
+    /**
+     * Delete a template.
+     * @param guildID The ID of the guild.
+     * @param code The code of the template.
+     * @caching This method **does not** cache its result.
+     */
+    async deleteTemplate(guildID, code) {
+        await this._manager.authRequest({
+            method: "DELETE",
+            path: Routes.GUILD_TEMPLATE(guildID, code)
+        });
+    }
+    /**
+     * Edit a guild.
+     * @param guildID The ID of the guild.
+     * @param options The options for editing the guild.
+     * @caching This method **may** cache its result. The result will not be cached if the guild is not already cached.
+     * @caches {@link Client#guilds | Client#guilds}
+     */
+    async edit(guildID, options) {
+        options = this._manager.client.util._freeze(options);
+        let banner, discoverySplash, icon, splash;
+        if (options.banner) {
+            banner = this._manager.client.util._convertImage(options.banner, "banner");
+        }
+        if (options.discoverySplash) {
+            discoverySplash = this._manager.client.util._convertImage(options.discoverySplash, "discovery splash");
+        }
+        if (options.icon) {
+            icon = this._manager.client.util._convertImage(options.icon, "icon");
+        }
+        if (options.splash) {
+            splash = this._manager.client.util._convertImage(options.splash, "splash");
+        }
+        return this._manager.authRequest({
+            method: "PATCH",
+            path: Routes.GUILD(guildID),
+            json: {
+                afk_channel_id: options.afkChannelID,
+                afk_timeout: options.afkTimeout,
+                banner,
+                default_message_notifications: options.defaultMessageNotifications,
+                description: options.description,
+                discovery_splash: discoverySplash,
+                explicit_content_filter: options.explicitContentFilter,
+                features: options.features,
+                icon,
+                name: options.name,
+                preferred_locale: options.preferredLocale,
+                premium_progress_bar_enabled: options.premiumProgressBarEnabled,
+                public_updates_channel_id: options.publicUpdatesChannelID,
+                region: options.region,
+                rules_channel_id: options.rulesChannelID,
+                safety_alerts_channel_id: options.safetyAlertsChannelID,
+                splash,
+                system_channel_flags: options.systemChannelFlags,
+                system_channel_id: options.systemChannelID,
+                verification_level: options.verificationLevel
+            },
+            reason: options.reason
+        }).then(data => this._manager.client.guilds.has(guildID) ? this._manager.client.guilds.update(data, true) : new Guild_1.default(data, this._manager.client, true));
+    }
+    /**
+     * Edit an existing auto moderation rule.
+     * @param guildID The ID of the guild.
+     * @param ruleID The ID of the rule to edit.
+     * @param options The options for editing the rule.
+     * @caching This method **may** cache its result. The result will not be cached if the guild is not cached.
+     * @caches {@link Guild#autoModerationRules | Guild#autoModerationRules}
+     */
+    async editAutoModerationRule(guildID, ruleID, options) {
+        options = this._manager.client.util._freeze(options);
+        return this._manager.authRequest({
+            method: "PATCH",
+            path: Routes.GUILD_AUTOMOD_RULE(guildID, ruleID),
+            json: {
+                actions: options.actions?.map(a => ({
+                    metadata: {
+                        channel_id: a.metadata.channelID,
+                        custom_message: a.metadata.customMessage,
+                        duration_seconds: a.metadata.durationSeconds
+                    },
+                    type: a.type
+                })),
+                enabled: options.enabled,
+                event_type: options.eventType,
+                exempt_channels: options.exemptChannels,
+                exempt_roles: options.exemptRoles,
+                name: options.name,
+                trigger_metadata: options.triggerMetadata ? {
+                    allow_list: options.triggerMetadata.allowList,
+                    keyword_filter: options.triggerMetadata.keywordFilter,
+                    mention_raid_protection_enabled: options.triggerMetadata.mentionRaidProtectionEnabled,
+                    mention_total_limit: options.triggerMetadata.mentionTotalLimit,
+                    presets: options.triggerMetadata.presets,
+                    regex_patterns: options.triggerMetadata.regexPatterns
+                } : undefined
+            },
+            reason: options.reason
+        }).then(data => this._manager.client.guilds.get(guildID)?.autoModerationRules.update(data) ?? new AutoModerationRule_1.default(data, this._manager.client));
+    }
+    /**
+     * Edit the positions of channels in a guild.
+     * @param guildID The ID of the guild.
+     * @param options The channels to move. Unedited channels do not need to be specified.
+     * @caching This method **does not** cache its result.
+     */
+    async editChannelPositions(guildID, options) {
+        options = this._manager.client.util._freeze(options);
+        await this._manager.authRequest({
+            method: "PATCH",
+            path: Routes.GUILD_CHANNELS(guildID),
+            json: options.map(o => ({
+                id: o.id,
+                // lock_permissions: o.lockPermissions ?? null,
+                // parent_id:        o.parentID ?? null,
+                position: o.position ?? null
+            }))
+        });
+    }
+    /**
+     * Modify the current member in a guild.
+     * @param guildID The ID of the guild.
+     * @param options The options for editing the member.
+     * @caching This method **may** cache its result. The result will not be cached if the guild is not cached.
+     * @caches {@link Guild#members | Guild#members}<br>{@link Guild#clientMember | Guild#clientMember}
+     */
+    async editCurrentMember(guildID, options) {
+        options = this._manager.client.util._freeze(options);
+        let avatar = options.avatar;
+        let banner = options.banner;
+        if (avatar) {
+            avatar = this._manager.client.util._convertImage(avatar, "avatar");
+        }
+        if (banner) {
+            banner = this._manager.client.util._convertImage(banner, "banner");
+        }
+        return this._manager.authRequest({
+            method: "PATCH",
+            path: Routes.GUILD_MEMBER(guildID, "@me"),
+            json: { nick: options.nick, banner, avatar, bio: options.bio },
+            reason: options.reason
+        }).then(data => this._manager.client.util.updateMember(guildID, data.user.id, data));
+    }
+    /**
+     * Edit the current member's voice state in a guild. `channelID` is required, and the current member must already be in that channel. See [Discord's docs](https://discord.com/developers/docs/resources/guild#modify-current-user-voice-state-caveats) for more information.
+     * @param guildID The ID of the guild.
+     * @param options The options for editing the voice state.
+     * @caching This method **does not** cache its result.
+     */
+    async editCurrentUserVoiceState(guildID, options) {
+        options = this._manager.client.util._freeze(options);
+        await this._manager.authRequest({
+            method: "PATCH",
+            path: Routes.GUILD_VOICE_STATE(guildID, "@me"),
+            json: {
+                channel_id: options.channelID,
+                suppress: options.suppress,
+                request_to_speak_timestamp: options.requestToSpeakTimestamp
+            }
+        });
+    }
+    /**
+     * Edit an existing emoji.
+     * @param guildID The ID of the guild the emoji is in.
+     * @param options The options for editing the emoji.
+     * @caching This method **may** cache its result. The result will not be cached if the guild is not cached.
+     * @caches {@link Guild#emojis | Guild#emojis}
+     */
+    async editEmoji(guildID, emojiID, options) {
+        options = this._manager.client.util._freeze(options);
+        return this._manager.authRequest({
+            method: "PATCH",
+            path: Routes.GUILD_EMOJI(guildID, emojiID),
+            json: {
+                name: options.name,
+                roles: options.roles
+            },
+            reason: options.reason
+        }).then(data => this._manager.client.guilds.get(guildID)?.emojis.update(data) ?? this._manager.client.util.convertGuildEmoji(data));
+    }
+    /**
+     * Edit the incident actions for a guild.
+     * @param guildID The ID of the guild.
+     * @param options The options for editing the incident actions.
+     * @caching This method **does not** cache its result.
+     */
+    async editIncidentActions(guildID, options) {
+        options = this._manager.client.util._freeze(options);
+        return this._manager.authRequest({
+            method: "PUT",
+            path: Routes.GUILD_INCIDENT_ACTIONS(guildID),
+            json: {
+                dms_disabled_until: options.dmsDisabledUntil,
+                invites_disabled_until: options.invitesDisabledUntil
+            },
+            reason: options.reason
+        }).then(data => ({
+            dmsDisabledUntil: data.dms_disabled_until,
+            invitesDisabledUntil: data.invites_disabled_until
+        }));
+    }
+    /**
+     * Edit a guild member. Use editCurrentMember if you wish to update the nick of this client using the `CHANGE_NICKNAME` permission.
+     * @param guildID The ID of the guild.
+     * @param memberID The ID of the member.
+     * @param options The options for editing the member.
+     * @caching This method **may** cache its result. The result will not be cached if the guild is not cached.
+     * @caches {@link Guild#members | Guild#members}
+     */
+    async editMember(guildID, memberID, options) {
+        options = this._manager.client.util._freeze(options);
+        return this._manager.authRequest({
+            method: "PATCH",
+            path: Routes.GUILD_MEMBER(guildID, memberID),
+            json: {
+                channel_id: options.channelID,
+                communication_disabled_until: options.communicationDisabledUntil,
+                deaf: options.deaf,
+                flags: options.flags,
+                mute: options.mute,
+                nick: options.nick,
+                roles: options.roles
+            },
+            reason: options.reason
+        }).then(data => this._manager.client.util.updateMember(guildID, memberID, data));
+    }
+    /**
+     * Edit a guild's onboarding configuration.
+     * @param guildID The ID of the guild.
+     * @param options The options for editing the onboarding configuration.
+     * @caching This method **does not** cache its result.
+     */
+    async editOnboarding(guildID, options) {
+        options = this._manager.client.util._freeze(options);
+        return this._manager.authRequest({
+            method: "PATCH",
+            path: Routes.GUILD_ONBOARDING(guildID),
+            json: {
+                enabled: options.enabled,
+                default_channel_ids: options.defaultChannelIDs,
+                prompts: options.prompts?.map(p => ({
+                    id: p.id,
+                    in_oboarding: p.inOnboarding,
+                    options: p.options.map(o => ({
+                        channel_ids: o.channelIDs,
+                        description: o.description,
+                        emoji: o.emoji,
+                        id: o.id,
+                        role_ids: o.roleIDs,
+                        title: o.title
+                    })),
+                    required: p.required,
+                    single_select: p.singleSelect,
+                    title: p.title
+                })),
+                mode: options.mode
+            },
+            reason: options.reason
+        }).then(data => ({
+            defaultChannelIDs: data.default_channel_ids,
+            enabled: data.enabled,
+            guildID: data.guild_id,
+            mode: data.mode,
+            prompts: data.prompts.map(p => ({
+                id: p.id,
+                inOnboarding: p.in_onboarding,
+                options: p.options.map(o => ({
+                    channelIDs: o.channel_ids,
+                    description: o.description,
+                    emoji: o.emoji,
+                    id: o.id,
+                    roleIDs: o.role_ids,
+                    title: o.title
+                })),
+                required: p.required,
+                singleSelect: p.single_select,
+                title: p.title
+            }))
+        }));
+    }
+    /**
+     * Edit an existing role.
+     * @param guildID The ID of the guild.
+     * @param options The options for editing the role.
+     * @caching This method **may** cache its result. The result will not be cached if the guild is not cached.
+     * @caches {@link Guild#roles | Guild#roles}
+     */
+    async editRole(guildID, roleID, options) {
+        options = this._manager.client.util._freeze(options);
+        let icon;
+        if (options.icon) {
+            icon = this._manager.client.util._convertImage(options.icon, "icon");
+        }
+        return this._manager.authRequest({
+            method: "PATCH",
+            path: Routes.GUILD_ROLE(guildID, roleID),
+            json: {
+                colors: options?.colors || options?.color ? {
+                    primary_color: options.colors?.primaryColor ?? options.color,
+                    secondary_color: options.colors?.secondaryColor,
+                    tertiary_color: options.colors?.tertiaryColor
+                } : undefined,
+                hoist: options.hoist,
+                icon,
+                mentionable: options.mentionable,
+                name: options.name,
+                permissions: options.permissions,
+                unicode_emoji: options.unicodeEmoji
+            },
+            reason: options.reason
+        }).then(data => this._manager.client.guilds.get(guildID)?.roles.update(data, guildID) ?? new Role_1.default(data, this._manager.client, guildID));
+    }
+    /**
+     * Edit the position of roles in a guild.
+     * @param guildID The ID of the guild.
+     * @param options The roles to move.
+     * @caching This method **may** cache its result. The result will not be cached if the guild is not cached.
+     * @caches {@link Guild#roles | Guild#roles}
+     */
+    async editRolePositions(guildID, options, reason) {
+        options = this._manager.client.util._freeze(options);
+        const guild = this._manager.client.guilds.get(guildID);
+        return this._manager.authRequest({
+            method: "PATCH",
+            path: Routes.GUILD_ROLES(guildID),
+            json: options.map(o => ({
+                id: o.id,
+                position: o.position
+            })),
+            reason
+        }).then(data => data.map(role => guild?.roles.update(role, guildID) ?? new Role_1.default(role, this._manager.client, guildID)));
+    }
+    /**
+     * Edit an existing scheduled event in a guild.
+     * @param guildID The ID of the guild.
+     * @param scheduledEventID The ID of the scheduled event.
+     * @param options The options for editing the scheduled event.
+     * @caching This method **may** cache its result. The result will not be cached if the guild is not cached.
+     * @caches {@link Guild#scheduledEvents | Guild#scheduledEvents}
+     */
+    async editScheduledEvent(guildID, scheduledEventID, options) {
+        options = this._manager.client.util._freeze(options);
+        let image;
+        if (options.image) {
+            image = this._manager.client.util._convertImage(options.image, "image");
+        }
+        return this._manager.authRequest({
+            method: "PATCH",
+            path: Routes.GUILD_SCHEDULED_EVENT(guildID, scheduledEventID),
+            json: {
+                channel_id: options.channelID,
+                description: options.description,
+                entity_metadata: options.entityMetadata ? { location: options.entityMetadata.location } : undefined,
+                entity_type: options.entityType,
+                image,
+                name: options.name,
+                privacy_level: options.privacyLevel,
+                status: options.status,
+                scheduled_end_time: options.scheduledEndTime,
+                scheduled_start_time: options.scheduledStartTime
+            },
+            reason: options.reason
+        }).then(data => this._manager.client.guilds.get(guildID)?.scheduledEvents.update(data) ?? new GuildScheduledEvent_1.default(data, this._manager.client));
+    }
+    /**
+     * Edit a soundboard sound.
+     * @param guildID The ID of the guild.
+     * @param soundID The ID of the soundboard sound to edit.
+     * @param options The options for editing the soundboard sound.
+     * @caching This method **may** cache its result. The result will not be cached if the guild is not cached.
+     * @caches {@link Guild#soundboardSounds | Guild#soundboardSounds}
+     */
+    async editSoundboardSound(guildID, soundID, options) {
+        options = this._manager.client.util._freeze(options);
+        return this._manager.authRequest({
+            method: "PATCH",
+            path: Routes.SOUNDBOARD_SOUND(guildID, soundID),
+            json: {
+                emoji_id: options.emojiID,
+                emoji_name: options.emojiName,
+                name: options.name,
+                volume: options.volume
+            },
+            reason: options.reason
+        }).then(data => this._manager.client.guilds.get(guildID)?.soundboardSounds.update(data) ?? new Soundboard_1.default(data, this._manager.client));
+    }
+    /**
+     * Edit a sticker.
+     * @param guildID The ID of the guild.
+     * @param options The options for editing the sticker.
+     * @caching This method **may** cache its result. The result will not be cached if the guild is not cached.
+     * @caches {@link Guild#stickers | Guild#stickers}
+     */
+    async editSticker(guildID, stickerID, options) {
+        options = this._manager.client.util._freeze(options);
+        return this._manager.authRequest({
+            method: "PATCH",
+            path: Routes.GUILD_STICKER(guildID, stickerID),
+            json: {
+                description: options.description,
+                name: options.name,
+                tags: options.tags
+            },
+            reason: options.reason
+        }).then(data => this._manager.client.guilds.get(guildID)?.stickers.update(data) ?? this._manager.client.util.convertSticker(data));
+    }
+    /**
+     * Edit a guild template.
+     * @param guildID The ID of the guild.
+     * @param code The code of the template.
+     * @param options The options for editing the template.
+     * @caching This method **does not** cache its result.
+     */
+    async editTemplate(guildID, code, options) {
+        options = this._manager.client.util._freeze(options);
+        return this._manager.authRequest({
+            method: "POST",
+            path: Routes.GUILD_TEMPLATE(guildID, code),
+            json: {
+                code,
+                description: options.description,
+                name: options.name
+            }
+        }).then(data => new GuildTemplate_1.default(data, this._manager.client));
+    }
+    /**
+     * Edit a guild member's voice state. `channelID` is required, and the user must already be in that channel. See [Discord's docs](https://discord.com/developers/docs/resources/guild#modify-user-voice-state) for more information.
+     * @param guildID The ID of the guild.
+     * @param memberID The ID of the member.
+     * @param options The options for editing the voice state.
+     * @caching This method **does not** cache its result.
+     */
+    async editUserVoiceState(guildID, memberID, options) {
+        options = this._manager.client.util._freeze(options);
+        await this._manager.authRequest({
+            method: "PATCH",
+            path: Routes.GUILD_VOICE_STATE(guildID, memberID),
+            json: {
+                channel_id: options.channelID,
+                suppress: options.suppress
+            }
+        });
+    }
+    /**
+     * Edit the welcome screen in a guild.
+     * @param guildID The ID of the guild.
+     * @param options The options for editing the welcome screen.
+     * @caching This method **does not** cache its result.
+     */
+    async editWelcomeScreen(guildID, options) {
+        options = this._manager.client.util._freeze(options);
+        return this._manager.authRequest({
+            method: "PATCH",
+            path: Routes.GUILD_WELCOME_SCREEN(guildID),
+            json: {
+                description: options.description,
+                enabled: options.enabled,
+                welcome_channels: options.welcomeChannels.map(ch => ({
+                    channel_id: ch.channelID,
+                    description: ch.description,
+                    emoji_id: ch.emojiID,
+                    emoji_name: ch.emojiName
+                }))
+            },
+            reason: options.reason
+        }).then(data => ({
+            description: data.description,
+            welcomeChannels: data.welcome_channels.map(channel => ({
+                channelID: channel.channel_id,
+                description: channel.description,
+                emojiID: channel.emoji_id,
+                emojiName: channel.emoji_name
+            }))
+        }));
+    }
+    /**
+     * Edit the widget of a guild.
+     * @param guildID The ID of the guild.
+     * @param options The options for editing the widget.
+     * @caching This method **does not** cache its result.
+     */
+    async editWidget(guildID, options) {
+        options = this._manager.client.util._freeze(options);
+        return this._manager.authRequest({
+            method: "POST",
+            path: Routes.GUILD_WIDGET(guildID),
+            json: {
+                channel_id: options.channelID,
+                enabled: options.enabled
+            }
+        }).then(data => ({
+            channels: data.channels,
+            id: data.id,
+            instantInvite: data.instant_invite,
+            members: data.members.map(m => ({
+                activity: m.activity,
+                avatar: m.avatar,
+                avatarURL: m.avatar_url,
+                discriminator: m.discriminator,
+                id: m.id,
+                status: m.status,
+                tag: m.username,
+                username: m.username
+            })),
+            name: data.name,
+            presenceCount: data.presence_count
+        }));
+    }
+    /**
+     * Get a guild.
+     * @param guildID The ID of the guild.
+     * @param withCounts If the approximate number of members and online members should be included.
+     * @caching This method **may** cache its result. The result will not be cached if the guild is not already cached.
+     * @caches {@link Client#guilds | Client#guilds}
+     */
+    async get(guildID, withCounts) {
+        const query = new QueryBuilder_1.default();
+        query.setIfPresent("with_counts", withCounts);
+        return this._manager.authRequest({
+            method: "GET",
+            path: Routes.GUILD(guildID),
+            query
+        }).then(data => this._manager.client.guilds.has(guildID) ? this._manager.client.guilds.update(data, true) : new Guild_1.default(data, this._manager.client, true));
+    }
+    /**
+     * Get the active threads in a guild.
+     * @param guildID The ID of the guild.
+     * @caching This method **may** cache its result. The result will not be cached if the guild is not cached.
+     * @caches {@link Guild#threads | Guild#threads}
+     */
+    async getActiveThreads(guildID) {
+        return this._manager.authRequest({
+            method: "GET",
+            path: Routes.GUILD_ACTIVE_THREADS(guildID)
+        }).then(data => ({
+            members: data.members.map(member => ({
+                flags: member.flags,
+                id: member.id,
+                joinTimestamp: new Date(member.join_timestamp),
+                userID: member.user_id
+            })),
+            threads: data.threads.map(rawThread => this._manager.client.util.updateThread(rawThread))
+        }));
+    }
+    /**
+     * Get a guild's audit log.
+     * @param guildID The ID of the guild.
+     * @param options The options for getting the audit logs.
+     * @caching This method **may** cache its result. The result will not be cached if the guild is not cached.
+     * @caches {@link Guild#autoModerationRules | Guild#autoModerationRules}<br>{@link Guild#scheduledEvents | Guild#scheduledEvents}<br>{@link Guild#integrations | Guild#integrations}<br>{@link Guild#threads | Guild#threads}<br>{@link Client#users | Client#users}
+     */
+    async getAuditLog(guildID, options) {
+        const guild = this._manager.client.guilds.get(guildID);
+        const query = new QueryBuilder_1.default();
+        query.setIfPresent("action_type", options?.actionType);
+        query.setIfPresent("before", options?.before);
+        query.setIfPresent("limit", options?.limit);
+        query.setIfPresent("user_id", options?.userID);
+        return this._manager.authRequest({
+            method: "GET",
+            path: Routes.GUILD_AUDIT_LOG(guildID),
+            query
+        }).then(data => ({
+            applicationCommands: data.application_commands.map(command => new ApplicationCommand_1.default(command, this._manager.client)),
+            autoModerationRules: data.auto_moderation_rules.map(rule => guild?.autoModerationRules.update(rule) ?? new AutoModerationRule_1.default(rule, this._manager.client)),
+            entries: data.audit_log_entries.map(entry => new AuditLogEntry_1.default(entry, this._manager.client)),
+            guildScheduledEvents: data.guild_scheduled_events.map(event => guild?.scheduledEvents.update(event) ?? new GuildScheduledEvent_1.default(event, this._manager.client)),
+            integrations: data.integrations.map(integration => guild?.integrations.update(integration, guildID) ?? new Integration_1.default(integration, this._manager.client, guildID)),
+            threads: data.threads.map(rawThread => this._manager.client.util.updateThread(rawThread)),
+            users: data.users.map(user => this._manager.client.users.update(user)),
+            webhooks: data.webhooks.map(webhook => new Webhook_1.default(webhook, this._manager.client))
+        }));
+    }
+    /**
+     * Get an auto moderation rule for a guild.
+     * @param guildID The ID of the guild.
+     * @param ruleID The ID of the rule to get.
+     * @caching This method **may** cache its result. The result will not be cached if the guild is not cached.
+     * @caches {@link Guild#autoModerationRules | Guild#autoModerationRules}
+     */
+    async getAutoModerationRule(guildID, ruleID) {
+        return this._manager.authRequest({
+            method: "GET",
+            path: Routes.GUILD_AUTOMOD_RULE(guildID, ruleID)
+        }).then(data => this._manager.client.guilds.get(guildID)?.autoModerationRules.update(data) ?? new AutoModerationRule_1.default(data, this._manager.client));
+    }
+    /**
+     * Get the auto moderation rules for a guild.
+     * @param guildID The ID of the guild.
+     * @caching This method **may** cache its result. The result will not be cached if the guild is not cached.
+     * @caches {@link Guild#autoModerationRules | Guild#autoModerationRules}
+     */
+    async getAutoModerationRules(guildID) {
+        const guild = this._manager.client.guilds.get(guildID);
+        return this._manager.authRequest({
+            method: "GET",
+            path: Routes.GUILD_AUTOMOD_RULES(guildID)
+        }).then(data => data.map(rule => guild?.autoModerationRules.update(rule) ?? new AutoModerationRule_1.default(rule, this._manager.client)));
+    }
+    /**
+     * Get a ban.
+     * @param guildID The ID of the guild.
+     * @param userID The ID of the user to get the ban of.
+     * @caching This method **does** cache part of its result.
+     * @caches {@link Client#users | Client#users}
+     */
+    async getBan(guildID, userID) {
+        return this._manager.authRequest({
+            method: "GET",
+            path: Routes.GUILD_BAN(guildID, userID)
+        }).then(data => ({
+            reason: data.reason,
+            user: this._manager.client.users.update(data.user)
+        }));
+    }
+    /**
+     * Get the bans in a guild.
+     * @param guildID The ID of the guild.
+     * @param options The options for getting the bans.
+     * @caching This method **does** cache part of its result.
+     * @caches {@link Client#users | Client#users}
+     */
+    async getBans(guildID, options) {
+        const _getBans = async (_options) => {
+            const query = new QueryBuilder_1.default();
+            query.setIfPresent("after", _options?.after);
+            query.setIfPresent("before", _options?.before);
+            query.setIfPresent("limit", _options?.limit);
+            return this._manager.authRequest({
+                method: "GET",
+                path: Routes.GUILD_BANS(guildID),
+                query
+            }).then(data => data.map(ban => ({
+                reason: ban.reason,
+                user: this._manager.client.users.update(ban.user)
+            })));
+        };
+        const limit = options?.limit ?? 1000;
+        let chosenOption;
+        if (options?.after) {
+            chosenOption = "after";
+        }
+        else if (options?.before) {
+            chosenOption = "before";
+        }
+        else {
+            chosenOption = "after";
+        }
+        let optionValue = options?.[chosenOption] ?? undefined;
+        let bans = [];
+        while (bans.length < limit) {
+            const limitLeft = limit - bans.length;
+            const limitToFetch = Math.min(limitLeft, 1000);
+            this._manager.client.emit("debug", `Getting ${limitLeft} more ban${limitLeft === 1 ? "" : "s"} for ${guildID}: ${optionValue ?? ""}`);
+            const bansChunk = await _getBans({
+                limit: limitToFetch,
+                [chosenOption]: optionValue
+            });
+            if (bansChunk.length === 0) {
+                break;
+            }
+            bans = bans.concat(bansChunk);
+            optionValue = bansChunk.at(-1).user.id;
+            if (bansChunk.length < 1000) {
+                break;
+            }
+        }
+        return bans;
+    }
+    /**
+     * Get the channels in a guild. Does not include threads.
+     * @param guildID The ID of the guild.
+     * @caching This method **may** cache its result. The result will not be cached if the guild is not cached.
+     * @caches {@link Guild#channels | Guild#channels}
+     */
+    async getChannels(guildID) {
+        return this._manager.authRequest({
+            method: "GET",
+            path: Routes.GUILD_CHANNELS(guildID)
+        }).then(data => data.map(d => this._manager.client.util.updateChannel(d)));
+    }
+    /**
+     * Get an emoji in a guild.
+     * @param guildID The ID of the guild.
+     * @param emojiID The ID of the emoji to get.
+     * @caching This method **may** cache its result. The result will not be cached if the guild is not cached.
+     * @caches {@link Guild#emojis | Guild#emojis}
+     */
+    async getEmoji(guildID, emojiID) {
+        return this._manager.authRequest({
+            method: "GET",
+            path: Routes.GUILD_EMOJI(guildID, emojiID)
+        }).then(data => this._manager.client.guilds.get(guildID)?.emojis.update(data) ?? this._manager.client.util.convertGuildEmoji(data));
+    }
+    /**
+     * Get the emojis in a guild.
+     * @param guildID The ID of the guild.
+     * @caching This method **may** cache its result. The result will not be cached if the guild is not cached.
+     * @caches {@link Guild#emojis | Guild#emojis} (will be completely cleared and refilled)
+     */
+    async getEmojis(guildID) {
+        return this._manager.authRequest({
+            method: "GET",
+            path: Routes.GUILD_EMOJIS(guildID)
+        }).then(data => {
+            const guild = this._manager.client.guilds.get(guildID);
+            guild?.emojis.clear();
+            return data.map(emoji => guild?.emojis.update(emoji) ?? this._manager.client.util.convertGuildEmoji(emoji));
+        });
+    }
+    /**
+     * Get the integrations in a guild.
+     * @param guildID The ID of the guild.
+     * @caching This method **may** cache its result. The result will not be cached if the guild is not cached.
+     * @caches {@link Guild#integrations | Guild#integrations}
+     */
+    async getIntegrations(guildID) {
+        const guild = this._manager.client.guilds.get(guildID);
+        return this._manager.authRequest({
+            method: "GET",
+            path: Routes.GUILD_INTEGRATIONS(guildID)
+        }).then(data => data.map(integration => guild?.integrations.update(integration, guildID) ?? new Integration_1.default(integration, this._manager.client, guildID)));
+    }
+    /**
+     * Get the invites of a guild.
+     * @param guildID The ID of the guild to get the invites of.
+     * @caching This method **may** cache its result. The result will not be cached if the guild is not cached.
+     * @caches {@link Guild#invites | Guild#invites}
+     */
+    async getInvites(guildID) {
+        const guild = this._manager.client.guilds.get(guildID);
+        return this._manager.authRequest({
+            method: "GET",
+            path: Routes.GUILD_INVITES(guildID)
+        }).then(data => data.map(invite => guild?.invites.update(invite) ?? Invite_1.default.withMetadata(invite, this._manager.client)));
+    }
+    /**
+     * Get a guild member.
+     * @param guildID The ID of the guild.
+     * @param memberID The ID of the member.
+     * @caching This method **may** cache its result. The result will not be cached if the guild is not cached.
+     * @caches {@link Guild#members | Guild#members}
+     */
+    async getMember(guildID, memberID) {
+        return this._manager.authRequest({
+            method: "GET",
+            path: Routes.GUILD_MEMBER(guildID, memberID)
+        }).then(data => this._manager.client.util.updateMember(guildID, memberID, data));
+    }
+    /**
+     * Get a guild's members. This requires the `GUILD_MEMBERS` intent.
+     * @param guildID The ID of the guild.
+     * @param options The options for getting the members.
+     * @caching This method **may** cache its result. The result will not be cached if the guild is not cached.
+     * @caches {@link Guild#members | Guild#members}}
+     */
+    async getMembers(guildID, options) {
+        const query = new QueryBuilder_1.default();
+        query.setIfPresent("after", options?.after);
+        query.setIfPresent("limit", options?.limit);
+        return this._manager.authRequest({
+            method: "GET",
+            path: Routes.GUILD_MEMBERS(guildID),
+            query
+        }).then(data => data.map(d => this._manager.client.util.updateMember(guildID, d.user.id, d)));
+    }
+    /**
+     * Get a guild's onboarding info.
+     * @param guildID The ID of the guild.
+     * @caching This method **does not** cache its result.
+     */
+    async getOnboarding(guildID) {
+        return this._manager.authRequest({
+            method: "GET",
+            path: Routes.GUILD_ONBOARDING(guildID)
+        }).then(data => ({
+            defaultChannelIDs: data.default_channel_ids,
+            enabled: data.enabled,
+            guildID: data.guild_id,
+            mode: data.mode,
+            prompts: data.prompts.map(p => ({
+                id: p.id,
+                inOnboarding: p.in_onboarding,
+                options: p.options.map(o => ({
+                    channelIDs: o.channel_ids,
+                    description: o.description,
+                    emoji: o.emoji,
+                    id: o.id,
+                    roleIDs: o.role_ids,
+                    title: o.title
+                })),
+                required: p.required,
+                singleSelect: p.single_select,
+                title: p.title
+            }))
+        }));
+    }
+    /**
+     * Get a preview of a guild. If the client is not already in this guild, the guild must be lurkable.
+     * @param guildID The ID of the guild.
+     * @caching This method **does not** cache its result.
+     */
+    async getPreview(guildID) {
+        return this._manager.authRequest({
+            method: "GET",
+            path: Routes.GUILD_PREVIEW(guildID)
+        }).then(data => new GuildPreview_1.default(data, this._manager.client));
+    }
+    /**
+     * Get the prune count of a guild.
+     * @param guildID The ID of the guild.
+     * @param options The options for getting the prune count.
+     * @caching This method **does not** cache its result.
+     */
+    async getPruneCount(guildID, options) {
+        const query = new QueryBuilder_1.default();
+        query.setIfPresent("days", options?.days);
+        query.setIfPresent("include_roles", options?.includeRoles?.join(","));
+        return this._manager.authRequest({
+            method: "GET",
+            path: Routes.GUILD_PRUNE(guildID),
+            query
+        }).then(data => data.pruned);
+    }
+    /**
+     * Get a role in a guild.
+     * @param guildID The ID of the guild.
+     * @param roleID The ID of the role to get.
+     * @caching This method **may** cache its result. The result will not be cached if the guild is not cached.
+     * @caches {@link Guild#roles | Guild#roles}
+     */
+    async getRole(guildID, roleID) {
+        const guild = this._manager.client.guilds.get(guildID);
+        return this._manager.authRequest({
+            method: "GET",
+            path: Routes.GUILD_ROLE(guildID, roleID)
+        }).then(data => guild?.roles.update(data, guildID) ?? new Role_1.default(data, this._manager.client, guildID));
+    }
+    /**
+     * Get the member count of the roles in a guild. The result is a key-value map of role id to member count.
+     * @param guildID The ID of the guild.
+     * @caching This method **does not** cache its result.
+     */
+    async getRoleMemberCounts(guildID) {
+        return this._manager.authRequest({
+            method: "GET",
+            path: Routes.GUILD_ROLE_MEMBER_COUNTS(guildID)
+        });
+    }
+    /**
+     * Get the roles in a guild.
+     * @param guildID The ID of the guild.
+     * @caching This method **may** cache its result. The result will not be cached if the guild is not cached.
+     * @caches {@link Guild#roles | Guild#roles}
+     */
+    async getRoles(guildID) {
+        const guild = this._manager.client.guilds.get(guildID);
+        return this._manager.authRequest({
+            method: "GET",
+            path: Routes.GUILD_ROLES(guildID)
+        }).then(data => data.map(role => guild?.roles.update(role, guildID) ?? new Role_1.default(role, this._manager.client, guildID)));
+    }
+    /**
+     * Get a scheduled event.
+     * @param guildID The ID of the guild.
+     * @param eventID The ID of the scheduled event to get.
+     * @param withUserCount If the number of users subscribed to the event should be included.
+     * @caching This method **may** cache its result. The result will not be cached if the guild is not cached.
+     * @caches {@link Guild#scheduledEvents | Guild#scheduledEvents}
+     */
+    async getScheduledEvent(guildID, eventID, withUserCount) {
+        const guild = this._manager.client.guilds.get(guildID);
+        const query = new QueryBuilder_1.default();
+        query.setIfPresent("with_user_count", withUserCount);
+        return this._manager.authRequest({
+            method: "GET",
+            path: Routes.GUILD_SCHEDULED_EVENT(guildID, eventID),
+            query
+        }).then(data => guild?.scheduledEvents.update(data) ?? new GuildScheduledEvent_1.default(data, this._manager.client));
+    }
+    /**
+     * Get the users subscribed to a scheduled event.
+     * @param guildID The ID of the guild.
+     * @param eventID The ID of the scheduled event.
+     * @param options The options for getting the users.
+     * @caching This method **does** cache part its result. Members will not be cached if the guild is not cached.
+     * @caches {@link Client#users | Client#users}<br>{@link Guild#members | Guild#members}
+     */
+    async getScheduledEventUsers(guildID, eventID, options) {
+        const guild = this._manager.client.guilds.get(guildID);
+        const query = new QueryBuilder_1.default();
+        query.setIfPresent("after", options?.after);
+        query.setIfPresent("before", options?.before);
+        query.setIfPresent("limit", options?.limit);
+        query.setIfPresent("with_member", options?.withMember);
+        return this._manager.authRequest({
+            method: "GET",
+            path: Routes.GUILD_SCHEDULED_EVENT_USERS(guildID, eventID)
+        }).then(data => data.map(d => ({
+            guildScheduledEvent: guild?.scheduledEvents.get(d.guild_scheduled_event_id),
+            guildScheduledEventID: d.guild_scheduled_event_id,
+            user: this._manager.client.users.update(d.user),
+            member: d.member ? this._manager.client.util.updateMember(guildID, d.member.user.id, d.member) : undefined
+        })));
+    }
+    /**
+     * Get a guild's scheduled events.
+     * @param guildID The ID of the guild.
+     * @param withUserCount If the number of users subscribed to the event should be included.
+     * @caching This method **may** cache its result. The result will not be cached if the guild is not cached.
+     * @caches {@link Guild#scheduledEvents | Guild#scheduledEvents}
+     */
+    async getScheduledEvents(guildID, withUserCount) {
+        const guild = this._manager.client.guilds.get(guildID);
+        const query = new QueryBuilder_1.default();
+        query.setIfPresent("with_user_count", withUserCount);
+        return this._manager.authRequest({
+            method: "GET",
+            path: Routes.GUILD_SCHEDULED_EVENTS(guildID),
+            query
+        }).then(data => data.map(d => guild?.scheduledEvents.update(d) ?? new GuildScheduledEvent_1.default(d, this._manager.client)));
+    }
+    /**
+     * Get a soundboard sound.
+     * @param guildID The ID of the guild.
+     * @param soundID The ID of the soundboard sound to get.
+     * @caching This method **may** cache its result. The result will not be cached if the guild is not cached.
+     * @caches {@link Guild#soundboardSounds | Guild#soundboardSounds}
+     */
+    async getSoundboardSound(guildID, soundID) {
+        const guild = this._manager.client.guilds.get(guildID);
+        return this._manager.authRequest({
+            method: "GET",
+            path: Routes.SOUNDBOARD_SOUND(guildID, soundID)
+        }).then(data => guild?.soundboardSounds.update(data) ?? new Soundboard_1.default(data, this._manager.client));
+    }
+    /**
+     * Get a guild's soundboard sounds.
+     * @param guildID The ID of the guild.
+     * @caching This method **may** cache its result. The result will not be cached if the guild is not cached.
+     * @caches {@link Guild#soundboardSounds | Guild#soundboardSounds}
+     */
+    async getSoundboardSounds(guildID) {
+        const guild = this._manager.client.guilds.get(guildID);
+        return this._manager.authRequest({
+            method: "GET",
+            path: Routes.SOUNDBOARD_SOUNDS(guildID)
+        }).then(data => data.items.map(d => guild?.soundboardSounds.update(d) ?? new Soundboard_1.default(d, this._manager.client)));
+    }
+    /**
+     * Get a sticker. Response will include a user if the client has the `MANAGE_EMOJIS_AND_STICKERS` permissions.
+     * @param guildID The ID of the guild.
+     * @param stickerID The ID of the sticker to get.
+     * @caching This method **may** cache its result. The result will not be cached if the guild is not cached.
+     * @caches {@link Guild#stickers | Guild#stickers}
+     */
+    async getSticker(guildID, stickerID) {
+        return this._manager.authRequest({
+            method: "GET",
+            path: Routes.GUILD_STICKER(guildID, stickerID)
+        }).then(data => this._manager.client.guilds.get(guildID)?.stickers.update(data) ?? this._manager.client.util.convertSticker(data));
+    }
+    /**
+     * Get a guild's stickers. Stickers will include a user if the client has the `MANAGE_EMOJIS_AND_STICKERS` permissions.
+     * @param guildID The ID of the guild.
+     * @caching This method **may** cache its result. The result will not be cached if the guild is not cached.
+     * @caches {@link Guild#stickers | Guild#stickers} (will be completely cleared and refilled)
+     */
+    async getStickers(guildID) {
+        return this._manager.authRequest({
+            method: "GET",
+            path: Routes.GUILD_STICKERS(guildID)
+        }).then(data => {
+            const guild = this._manager.client.guilds.get(guildID);
+            guild?.stickers.clear();
+            return data.map(sticker => guild?.stickers.update(sticker) ?? this._manager.client.util.convertSticker(sticker));
+        });
+    }
+    /**
+     * Get a guild template.
+     * @param code The code of the template to get.
+     * @caching This method **does not** cache its result.
+     */
+    async getTemplate(code) {
+        return this._manager.authRequest({
+            method: "GET",
+            path: Routes.GUILD_TEMPLATE_CODE(code)
+        }).then(data => new GuildTemplate_1.default(data, this._manager.client));
+    }
+    /**
+     * Get a guild's templates.
+     * @param guildID The ID of the guild.
+     * @caching This method **does not** cache its result.
+     */
+    async getTemplates(guildID) {
+        return this._manager.authRequest({
+            method: "GET",
+            path: Routes.GUILD_TEMPLATES(guildID)
+        }).then(data => data.map(d => new GuildTemplate_1.default(d, this._manager.client)));
+    }
+    /**
+     * Get the vanity url of a guild.
+     * @param guildID The ID of the guild.
+     * @caching This method **does not** cache its result.
+     */
+    async getVanityURL(guildID) {
+        return this._manager.authRequest({
+            method: "GET",
+            path: Routes.GUILD_VANITY_URL(guildID)
+        });
+    }
+    /**
+     * Get the list of usable voice regions for a guild. This will return VIP servers when the guild is VIP-enabled.
+     * @param guildID The ID of the guild.
+     * @caching This method **does not** cache its result.
+     */
+    async getVoiceRegions(guildID) {
+        return this._manager.authRequest({
+            method: "GET",
+            path: Routes.GUILD_VOICE_REGIONS(guildID)
+        });
+    }
+    /**
+     * Get the voice state of a member.
+     * @param guildID The ID of the guild.
+     * @param memberID The ID of the member. Use `@me` for the bot user.
+     * @caching This method **may** cache its result. The result will not be cached if the guild is not cached.
+     * @caches {@link Guild#voiceStates | Guild#voiceStates}
+     */
+    async getVoiceState(guildID, memberID) {
+        return this._manager.authRequest({
+            method: "GET",
+            path: Routes.GUILD_VOICE_STATE(guildID, memberID)
+        }).then(data => this._manager.client.guilds.get(guildID)?.voiceStates.update(data) ?? new VoiceState_1.default(data, this._manager.client));
+    }
+    /**
+     * Get the welcome screen for a guild.
+     * @param guildID The ID of the guild.
+     * @caching This method **does not** cache its result.
+     */
+    async getWelcomeScreen(guildID) {
+        return this._manager.authRequest({
+            method: "GET",
+            path: Routes.GUILD_WELCOME_SCREEN(guildID)
+        }).then(data => ({
+            description: data.description,
+            welcomeChannels: data.welcome_channels.map(channel => ({
+                channelID: channel.channel_id,
+                description: channel.description,
+                emojiID: channel.emoji_id,
+                emojiName: channel.emoji_name
+            }))
+        }));
+    }
+    /**
+     * Get the widget of a guild.
+     * @param guildID The ID of the guild.
+     * @caching This method **does not** cache its result.
+     */
+    async getWidget(guildID) {
+        return this._manager.authRequest({
+            method: "GET",
+            path: Routes.GUILD_WIDGET(guildID)
+        }).then(data => ({
+            channels: data.channels,
+            id: data.id,
+            instantInvite: data.instant_invite,
+            members: data.members.map(m => ({
+                activity: m.activity,
+                avatar: m.avatar,
+                avatarURL: m.avatar_url,
+                discriminator: m.discriminator,
+                id: m.id,
+                status: m.status,
+                tag: m.username,
+                username: m.username
+            })),
+            name: data.name,
+            presenceCount: data.presence_count
+        }));
+    }
+    /**
+     * Get the widget image of a guild.
+     * @param guildID The ID of the guild.
+     * @param style The style of the image.
+     * @caching This method **does not** cache its result.
+     */
+    async getWidgetImage(guildID, style) {
+        const query = new QueryBuilder_1.default();
+        query.setIfPresent("style", style);
+        return this._manager.request({
+            method: "GET",
+            path: Routes.GUILD_WIDGET_IMAGE(guildID),
+            query
+        });
+    }
+    /**
+     * Get the raw JSON widget of a guild.
+     * @param guildID The ID of the guild.
+     * @caching This method **does not** cache its result.
+     */
+    async getWidgetJSON(guildID) {
+        return this._manager.request({
+            method: "GET",
+            path: Routes.GUILD_WIDGET_JSON(guildID)
+        });
+    }
+    /**
+     * Get a guild's widget settings.
+     * @param guildID The ID of the guild.
+     * @caching This method **does not** cache its result.
+     */
+    async getWidgetSettings(guildID) {
+        return this._manager.authRequest({
+            method: "GET",
+            path: Routes.GUILD_WIDGET(guildID)
+        }).then(data => ({
+            channelID: data.channel_id,
+            enabled: data.enabled
+        }));
+    }
+    /**
+     * Search a guild's members.
+     * @param guildID The ID of the guild.
+     * @param options The options to search with.
+     * @param retryOnIndexNotAvailable If the search should be retried if Discord replies with an index unavailable response. This will retry at most one time, waiting for `retry_after` or 15-45 seconds.
+     * @caching This method **may** cache its result. The result will not be cached if the guild is not cached.
+     * @caches {@link Guild#members | Guild#members}
+     */
+    async memberSearch(guildID, options, retryOnIndexNotAvailable = true) {
+        /* eslint-disable @typescript-eslint/explicit-function-return-type, unicorn/consistent-function-scoping */
+        const formatRange = (data) => ({
+            range: data.range === undefined ? undefined : {
+                gte: data.range.gte,
+                lte: data.range.lte
+            }
+        });
+        const formatOrQuery = (data) => ({
+            or_query: data.orQuery
+        });
+        const formatOrQueryRange = (data) => ({
+            or_query: data.orQuery,
+            range: data.range === undefined ? undefined : {
+                gte: data.range.gte,
+                lte: data.range.lte
+            }
+        });
+        const formatAndOrQuery = (data) => ({
+            and_query: data.andQuery,
+            or_query: data.orQuery
+        });
+        const formatSearchFilter = (data) => ({
+            did_rejoin: data.didRejoin,
+            guild_joined_at: data.guildJoinedAt === undefined ? undefined : formatRange(data.guildJoinedAt),
+            is_pending: data.isPending,
+            join_source_type: data.joinSourceType === undefined ? undefined : formatOrQuery(data.joinSourceType),
+            role_ids: data.roleIDs === undefined ? undefined : formatAndOrQuery(data.roleIDs),
+            safety_signals: data.safetySignals === undefined ? undefined : {
+                automod_quarantined_username: data.safetySignals.automodQuarantinedUsername,
+                communication_disabled_until: data.safetySignals.communicationDisabledUntil === undefined ? undefined : formatRange(data.safetySignals.communicationDisabledUntil),
+                unusual_account_activity: data.safetySignals.unusualAccountActivity,
+                unusual_dm_activity_until: data.safetySignals.unusualDmActivityUntil === undefined ? undefined : formatRange(data.safetySignals.unusualDmActivityUntil)
+            },
+            source_invite_code: data.sourceInviteCode === undefined ? undefined : formatOrQuery(data.sourceInviteCode),
+            user_id: data.userID === undefined ? undefined : formatOrQueryRange(data.userID),
+            usernames: data.usernames === undefined ? undefined : formatOrQuery(data.usernames)
+        });
+        const formatPaginationFilter = (data) => ({
+            guild_joined_at: data.guildJoinedAt,
+            user_id: data.userID
+        });
+        /* eslint-enable @typescript-eslint/explicit-function-return-type, unicorn/consistent-function-scoping */
+        return this._manager.authRequest({
+            method: "POST",
+            path: Routes.GUILD_MEMBERS_SEARCH(guildID),
+            json: {
+                after: options?.after === undefined ? undefined : formatPaginationFilter(options.after),
+                and_query: options?.andQuery === undefined ? undefined : formatSearchFilter(options.andQuery),
+                before: options?.before === undefined ? undefined : formatPaginationFilter(options.before),
+                limit: options?.limit,
+                or_query: options?.orQuery === undefined ? undefined : formatSearchFilter(options.orQuery),
+                sort: options?.sort
+            }
+        }).then(async (data) => {
+            if ("retry_after" in data) {
+                if (!retryOnIndexNotAvailable) {
+                    throw new Error(`Member search for guild ${guildID} failed due to the index not being available.`);
+                }
+                let retryAfter = data.retry_after;
+                if (retryAfter === 0) {
+                    retryAfter = Math.floor(Math.random() * 30) + 15;
+                }
+                this._manager.client.emit("debug", `Retrying member search for ${guildID} in ${retryAfter} seconds...`);
+                await (0, promises_1.setTimeout)(retryAfter * 1000);
+                return this.memberSearch(guildID, options, false);
+            }
+            return {
+                guildID: data.guild_id,
+                members: data.members.map(m => ({
+                    integrationType: m.integration_type,
+                    inviterID: m.inviter_id,
+                    joinSourceType: m.join_source_type,
+                    member: this._manager.client.util.updateMember(guildID, m.member.user.id, m.member),
+                    sourceInviteCode: m.source_invite_code
+                })),
+                pageResultCount: data.page_result_count,
+                totalResultCount: data.total_result_count
+            };
+        });
+    }
+    /**
+     * Remove a ban.
+     * @param guildID The ID of the guild.
+     * @param userID The ID of the user to remove the ban from.
+     * @param reason The reason for removing the ban.
+     * @caching This method **does not** cache its result.
+     */
+    async removeBan(guildID, userID, reason) {
+        await this._manager.authRequest({
+            method: "DELETE",
+            path: Routes.GUILD_BAN(guildID, userID),
+            reason
+        });
+    }
+    /**
+     * Remove a member from a guild.
+     * @param guildID The ID of the guild.
+     * @param memberID The ID of the user to remove.
+     * @param reason The reason for the removal.
+     * @caching This method **does not** cache its result.
+     */
+    async removeMember(guildID, memberID, reason) {
+        await this._manager.authRequest({
+            method: "DELETE",
+            path: Routes.GUILD_MEMBER(guildID, memberID),
+            reason
+        });
+    }
+    /**
+     * Remove a role from a member.
+     * @param guildID The ID of the guild.
+     * @param memberID The ID of the member.
+     * @param roleID The ID of the role to remove.
+     * @param reason The reason for removing the role.
+     * @caching This method **does not** cache its result.
+     */
+    async removeMemberRole(guildID, memberID, roleID, reason) {
+        await this._manager.authRequest({
+            method: "DELETE",
+            path: Routes.GUILD_MEMBER_ROLE(guildID, memberID, roleID),
+            reason
+        });
+    }
+    /**
+     * Search the username & nicknames of members in a guild. See {@link REST/Guilds#memberSearch | memberSearch} for a more detailed search.
+     * @param guildID The ID of the guild.
+     * @param options The options to search with.
+     * @caching This method **may** cache its result. The result will not be cached if the guild is not cached.
+     * @caches {@link Guild#members | Guild#members}
+     */
+    async searchMembers(guildID, options) {
+        options = this._manager.client.util._freeze(options);
+        const query = new QueryBuilder_1.default();
+        query.set("query", options.query);
+        query.setIfPresent("limit", options.limit);
+        return this._manager.authRequest({
+            method: "GET",
+            path: Routes.GUILD_SEARCH_MEMBERS(guildID),
+            query
+        }).then(data => data.map(d => this._manager.client.util.updateMember(guildID, d.user.id, d)));
+    }
+    /**
+     * Sync a guild template.
+     * @param guildID The ID of the guild.
+     * @param code The code of the template to sync.
+     * @caching This method **does not** cache its result.
+     */
+    async syncTemplate(guildID, code) {
+        return this._manager.authRequest({
+            method: "POST",
+            path: Routes.GUILD_TEMPLATE(guildID, code)
+        }).then(data => new GuildTemplate_1.default(data, this._manager.client));
+    }
+}
+exports.default = Guilds;