disgroove 1.3.4 → 2.0.0-dev.0f17bf6

package/dist/lib/Client.js

@@ -7,7 +7,6 @@ exports.Client = void 0;
 const constants_1 = require("./constants");
 const utils_1 = require("./utils");
 const rest_1 = require("./rest");
-const structures_1 = require("./structures");
 const node_events_1 = __importDefault(require("node:events"));
 const gateway_1 = require("./gateway");
 class Client extends node_events_1.default {
@@ -18,9 +17,10 @@ class Client extends node_events_1.default {
     shards;
     rest;
     util;
+    guildShardMap;
     user;
+    guilds;
     application;
-    guildShardMap;
     constructor(token, options) {
         super();
         this.token = token;
@@ -32,14 +32,216 @@ class Client extends node_events_1.default {
                 : constants_1.GatewayIntents.AllNonPrivileged;
         this.shardsCount = options?.shardsCount ?? "auto";
         this.auth = options?.auth ?? "Bot";
-        this.shards = new gateway_1.ShardsManager();
-        this.rest = new rest_1.REST(token, this.auth);
+        this.shards = new gateway_1.ShardManager();
+        this.rest = new rest_1.RequestManager(token, this.auth);
         this.util = new utils_1.Util();
         this.guildShardMap = {};
     }
+    /** https://discord.com/developers/docs/resources/channel#group-dm-add-recipient */
+    addGroupRecipient(channelId, userId, options) {
+        this.rest.request(rest_1.RestMethods.Put, rest_1.Endpoints.channelRecipient(channelId, userId), {
+            json: {
+                access_token: options.accessToken,
+                nick: options.nick,
+            },
+        });
+    }
+    /** https://discord.com/developers/docs/resources/guild#add-guild-member */
+    addGuildMember(guildId, userId, options) {
+        return this.rest
+            .request(rest_1.RestMethods.Put, rest_1.Endpoints.guildMember(guildId, userId), {
+            json: {
+                access_token: options.accessToken,
+                nick: options.nick,
+                roles: options.roles,
+                mute: options.mute,
+                deaf: options.deaf,
+            },
+        })
+            .then((response) => response !== null ? this.util.toCamelCase(response) : null);
+    }
+    /** https://discord.com/developers/docs/resources/guild#add-guild-member-role */
+    addGuildMemberRole(guildId, userId, roleId, reason) {
+        this.rest.request(rest_1.RestMethods.Put, rest_1.Endpoints.guildMemberRole(guildId, userId, roleId), {
+            reason,
+        });
+    }
+    /** https://discord.com/developers/docs/resources/channel#add-thread-member */
+    addThreadMember(channelId, userId) {
+        this.rest.request(rest_1.RestMethods.Put, rest_1.Endpoints.threadMembers(channelId, userId));
+    }
+    /** https://discord.com/developers/docs/resources/guild#begin-guild-prune */
+    beginGuildPrune(guildId, options, reason) {
+        return this.rest
+            .request(rest_1.RestMethods.Post, rest_1.Endpoints.guildPrune(guildId), {
+            json: {
+                days: options.days,
+                compute_prune_count: options.computePruneCount,
+                include_roles: options.includeRoles,
+                reason: options.reason,
+            },
+            reason,
+        })
+            .then((response) => this.util.toCamelCase(response));
+    }
+    /** https://discord.com/developers/docs/resources/channel#bulk-delete-messages */
+    bulkDeleteMessages(channelId, options, reason) {
+        this.rest.request(rest_1.RestMethods.Post, rest_1.Endpoints.channelBulkDelete(channelId), {
+            json: {
+                messages: options?.messagesIds,
+            },
+            reason,
+        });
+    }
+    /** https://discord.com/developers/docs/interactions/application-commands#bulk-overwrite-global-application-commands */
+    bulkEditGlobalApplicationCommands(applicationId, commands) {
+        return this.rest
+            .request(rest_1.RestMethods.Put, rest_1.Endpoints.applicationCommands(applicationId), {
+            json: commands.map((command) => this.util.toSnakeCase(command)),
+        })
+            .then((response) => response.map((applicationCommand) => this.util.toCamelCase(applicationCommand)));
+    }
+    /** https://discord.com/developers/docs/interactions/application-commands#bulk-overwrite-guild-application-commands */
+    bulkEditGuildApplicationCommands(applicationId, guildId, commands) {
+        return this.rest
+            .request(rest_1.RestMethods.Put, rest_1.Endpoints.applicationGuildCommands(applicationId, guildId), {
+            json: commands.map((command) => this.util.toSnakeCase(command)),
+        })
+            .then((response) => response.map((applicationCommand) => this.util.toCamelCase(applicationCommand)));
+    }
+    /** https://discord.com/developers/docs/topics/gateway#connections */
+    async connect() {
+        this.shardsCount =
+            this.shardsCount === "auto"
+                ? (await this.getGatewayBot()).shards
+                : this.shardsCount;
+        for (let i = 0; i < this.shardsCount; i++)
+            this.shards.set(i, new gateway_1.Shard(i, this));
+        this.shards.connect();
+    }
+    /** https://discord.com/developers/docs/resources/auto-moderation#create-auto-moderation-rule */
+    createAutoModerationRule(guildId, options, reason) {
+        return this.rest
+            .request(rest_1.RestMethods.Post, rest_1.Endpoints.guildAutoModerationRules(guildId), {
+            json: {
+                name: options.name,
+                event_type: options.eventType,
+                trigger_type: options.triggerType,
+                trigger_metadata: options.triggerMetadata,
+                actions: options.actions.map((action) => this.util.toSnakeCase(action)),
+                enabled: options.enabled,
+                exempt_roles: options.exemptRoles,
+                exempt_channels: options.exemptChannels,
+            },
+            reason,
+        })
+            .then((response) => this.util.toCamelCase(response));
+    }
+    /** https://discord.com/developers/docs/resources/guild#create-guild-channel */
+    createChannel(guildId, options, reason) {
+        return this.rest
+            .request(rest_1.RestMethods.Post, rest_1.Endpoints.guildChannels(guildId), {
+            json: {
+                name: options.name,
+                type: options.type,
+                topic: options.topic,
+                bitrate: options.bitrate,
+                user_limit: options.userLimit,
+                rate_limit_per_user: options.rateLimitPerUser,
+                position: options.position,
+                permission_overwrites: options.permissionOverwrites,
+                parent_id: options.parentId,
+                nsfw: options.nsfw,
+                rtc_region: options.rtcRegion,
+                video_quality_mode: options.videoQualityMode,
+                default_auto_archive_duration: options.defaultAutoArchiveDuration,
+                default_reaction_emoji: options.defaultReactionEmoji !== undefined
+                    ? options.defaultReactionEmoji !== null
+                        ? this.util.toSnakeCase(options.defaultReactionEmoji)
+                        : null
+                    : undefined,
+                available_tags: options.availableTags,
+                default_sort_order: options.defaultSortOrder,
+                default_forum_layout: options.defaultForumLayout,
+                default_thread_rate_limit_per_user: options.defaultThreadRateLimitPerUser,
+            },
+            reason,
+        })
+            .then((response) => this.util.toCamelCase(response));
+    }
+    /** https://discord.com/developers/docs/resources/channel#create-channel-invite */
+    createChannelInvite(channelId, options, reason) {
+        return this.rest
+            .request(rest_1.RestMethods.Post, rest_1.Endpoints.channelInvites(channelId), {
+            json: {
+                max_age: options.maxAge,
+                max_uses: options.maxUses,
+                temporary: options.temporary,
+                unique: options.unique,
+                target_type: options.targetType,
+                target_user_id: options.targetUserId,
+                target_application_id: options.targetApplicationId,
+            },
+            reason,
+        })
+            .then((response) => this.util.toCamelCase(response));
+    }
+    /** https://discord.com/developers/docs/resources/webhook#create-webhook */
+    createChannelWebhook(channelId, options, reason) {
+        return this.rest
+            .request(rest_1.RestMethods.Post, rest_1.Endpoints.channelWebhooks(channelId), {
+            json: {
+                name: options.name,
+                avatar: options.avatar,
+            },
+            reason,
+        })
+            .then((response) => this.util.toCamelCase(response));
+    }
+    /** https://discord.com/developers/docs/resources/user#create-dm */
+    createDM(options) {
+        return this.rest
+            .request(rest_1.RestMethods.Post, rest_1.Endpoints.userChannels(), {
+            json: {
+                recipient_id: options.recipientId,
+            },
+        })
+            .then((response) => this.util.toCamelCase(response));
+    }
+    /** https://discord.com/developers/docs/interactions/application-commands#create-global-application-command */
+    createGlobalApplicationCommand(applicationId, options) {
+        return this.rest
+            .request(rest_1.RestMethods.Post, rest_1.Endpoints.applicationCommands(applicationId), {
+            json: {
+                type: options.type,
+                name: options.name,
+                name_localizations: options.nameLocalizations,
+                description: options.description,
+                description_localizations: options.descriptionLocalizations,
+                options: options.options?.map((option) => this.util.toSnakeCase(option)),
+                default_member_permissions: options.defaultMemberPermissions,
+                dm_permission: options.dmPermission,
+                default_permission: options.defaultPermission,
+                nsfw: options.nsfw,
+            },
+        })
+            .then((response) => this.util.toCamelCase(response));
+    }
+    /** https://discord.com/developers/docs/resources/user#create-group-dm */
+    createGroupDM(options) {
+        return this.rest
+            .request(rest_1.RestMethods.Post, rest_1.Endpoints.userChannels(), {
+            json: {
+                access_tokens: options.accessTokens,
+                nicks: options.nicks,
+            },
+        })
+            .then((response) => this.util.toCamelCase(response));
+    }
     /** https://discord.com/developers/docs/resources/guild#create-guild */
-    async createGuild(options) {
-        return new structures_1.Guild(await this.rest.post(rest_1.Endpoints.guilds(), {
+    createGuild(options) {
+        return this.rest
+            .request(rest_1.RestMethods.Post, rest_1.Endpoints.guilds(), {
             json: {
                 name: options.name,
                 region: options.region,
@@ -47,81 +249,1204 @@ class Client extends node_events_1.default {
                 verification_level: options.verificationLevel,
                 default_message_notifications: options.defaultMessageNotifications,
                 explicit_content_filter: options.explicitContentFilter,
-                roles: options.roles?.map((role) => this.util.roleToRaw(role)),
-                channels: options.channels?.map((channel) => ({
-                    id: channel.id,
-                    type: channel.name,
-                    parent_id: channel.parentId,
-                    name: channel.name,
-                })),
+                roles: options.roles?.map((role) => this.util.toSnakeCase(role)),
+                channels: options.channels?.map((channel) => this.util.toSnakeCase(channel)),
+                afk_channel_id: options.afkChannelId,
+                afk_timeout: options.afkTimeout,
+                system_channel_id: options.systemChannelId,
+                system_channel_flags: options.systemChannelFlags,
+            },
+        })
+            .then((response) => this.util.toCamelCase(response));
+    }
+    /** https://discord.com/developers/docs/interactions/application-commands#create-guild-application-command */
+    createGuildApplicationCommand(applicationId, guildId, options) {
+        return this.rest
+            .request(rest_1.RestMethods.Post, rest_1.Endpoints.applicationGuildCommands(applicationId, guildId), {
+            json: {
+                type: options.type,
+                name: options.name,
+                name_localizations: options.nameLocalizations,
+                description: options.description,
+                description_localizations: options.descriptionLocalizations,
+                options: options.options?.map((option) => this.util.toSnakeCase(option)),
+                default_member_permissions: options.defaultMemberPermissions,
+                default_permission: options.defaultPermission,
+                nsfw: options.nsfw,
+            },
+        })
+            .then((response) => this.util.toCamelCase(response));
+    }
+    /** https://discord.com/developers/docs/resources/guild#create-guild-ban */
+    createGuildBan(guildId, userId, options, reason) {
+        this.rest.request(rest_1.RestMethods.Put, rest_1.Endpoints.guildBan(guildId, userId), {
+            json: {
+                delete_message_days: options?.deleteMessageDays,
+                delete_message_seconds: options?.deleteMessageSeconds,
+            },
+            reason,
+        });
+    }
+    /** https://discord.com/developers/docs/resources/emoji#create-guild-emoji */
+    createGuildEmoji(guildId, options, reason) {
+        return this.rest
+            .request(rest_1.RestMethods.Post, rest_1.Endpoints.guildEmojis(guildId), {
+            json: {
+                name: options.name,
+                image: options.image,
+                roles: options.roles,
+            },
+            reason,
+        })
+            .then((response) => this.util.toCamelCase(response));
+    }
+    /** https://discord.com/developers/docs/resources/guild-template#create-guild-from-guild-template */
+    createGuildFromTemplate(code, options) {
+        return this.rest
+            .request(rest_1.RestMethods.Post, rest_1.Endpoints.template(code), {
+            json: {
+                name: options.name,
+                icon: options.icon,
+            },
+        })
+            .then((response) => this.util.toCamelCase(response));
+    }
+    /** https://discord.com/developers/docs/resources/guild#create-guild-role */
+    createGuildRole(guildId, options, reason) {
+        return this.rest
+            .request(rest_1.RestMethods.Post, rest_1.Endpoints.guildRoles(guildId), {
+            json: {
+                name: options.name,
+                permissions: options.permissions,
+                color: options.color,
+                hoist: options.hoist,
+                icon: options.icon,
+                unicode_emoji: options.unicodeEmoji,
+                mentionable: options.mentionable,
+            },
+            reason,
+        })
+            .then((response) => this.util.toCamelCase(response));
+    }
+    /** https://discord.com/developers/docs/resources/guild-scheduled-event#create-guild-scheduled-event */
+    createGuildScheduledEvent(guildId, options, reason) {
+        return this.rest
+            .request(rest_1.RestMethods.Post, rest_1.Endpoints.guildScheduledEvents(guildId), {
+            json: {
+                channel_id: options.channelId,
+                entity_metadata: options.entityMetadata,
+                name: options.name,
+                privacy_level: options.privacyLevel,
+                scheduled_start_time: options.scheduledEndTime,
+                scheduled_end_time: options.scheduledEndTime,
+                description: options.description,
+                entity_type: options.entityType,
+                image: options.image,
+            },
+            reason,
+        })
+            .then((response) => this.util.toCamelCase(response));
+    }
+    /** https://discord.com/developers/docs/resources/sticker#create-guild-sticker */
+    createGuildSticker(guildId, options, reason) {
+        const formData = new FormData();
+        formData.set("name", options.name);
+        formData.set("description", options.description);
+        formData.set("tags", options.tags);
+        formData.set("file", new Blob([options.file.contents]), options.file.name);
+        return this.rest
+            .request(rest_1.RestMethods.Post, rest_1.Endpoints.guildStickers(guildId), {
+            form: formData,
+            reason,
+        })
+            .then((response) => this.util.toCamelCase(response));
+    }
+    /** https://discord.com/developers/docs/resources/guild-template#create-guild-template */
+    createGuildTemplate(guildId, options) {
+        return this.rest
+            .request(rest_1.RestMethods.Post, rest_1.Endpoints.guildTemplates(guildId), {
+            json: {
+                name: options.name,
+                description: options.description,
+            },
+        })
+            .then((response) => this.util.toCamelCase(response));
+    }
+    /** https://discord.com/developers/docs/interactions/receiving-and-responding#create-followup-message */
+    createInteractionFollowupMessage(applicationId, interactionToken, options) {
+        return this.rest
+            .request(rest_1.RestMethods.Post, rest_1.Endpoints.webhook(applicationId, interactionToken), {
+            json: {
+                content: options.content,
+                tts: options.tts,
+                embeds: options.embeds !== undefined
+                    ? options.embeds !== null
+                        ? options.embeds.map((e) => this.util.toSnakeCase(e))
+                        : null
+                    : undefined,
+                allowed_mentions: options.allowedMentions !== undefined
+                    ? options.allowedMentions !== null
+                        ? this.util.toSnakeCase(options.allowedMentions)
+                        : null
+                    : undefined,
+                components: options.components !== undefined
+                    ? options.components !== null
+                        ? options.components.map((c) => this.util.toSnakeCase(c))
+                        : null
+                    : undefined,
+                attachments: options.attachments?.map((attachment) => this.util.toSnakeCase(attachment)),
+                flags: options.flags,
+                thread_name: options.threadName,
+            },
+            files: options.files,
+        })
+            .then((response) => this.util.toCamelCase(response));
+    }
+    /** https://discord.com/developers/docs/interactions/receiving-and-responding#create-interaction-response */
+    createInteractionResponse(interactionId, interactionToken, options) {
+        switch (options.type) {
+            case constants_1.InteractionCallbackType.ChannelMessageWithSource:
+            case constants_1.InteractionCallbackType.UpdateMessage:
+                {
+                    this.rest.request(rest_1.RestMethods.Post, rest_1.Endpoints.interactionCallback(interactionId, interactionToken), {
+                        json: {
+                            type: options.type,
+                            data: {
+                                content: options.data?.content,
+                                embeds: options.data?.embeds !== undefined
+                                    ? this.util.toSnakeCase(options.data.embeds)
+                                    : undefined,
+                                allowed_mentions: options.data?.allowedMentions !== undefined
+                                    ? this.util.toSnakeCase(options.data.allowedMentions)
+                                    : undefined,
+                                flags: options.data?.flags,
+                                components: options.data?.components !== undefined
+                                    ? this.util.toSnakeCase(options.data.components)
+                                    : undefined,
+                                attachments: options.data?.attachments?.map((attachment) => this.util.toSnakeCase(attachment)),
+                            },
+                        },
+                        files: options.data?.files,
+                    });
+                }
+                break;
+            case constants_1.InteractionCallbackType.DeferredChannelMessageWithSource:
+            case constants_1.InteractionCallbackType.DeferredUpdateMessage:
+                {
+                    this.rest.request(rest_1.RestMethods.Post, rest_1.Endpoints.interactionCallback(interactionId, interactionToken), {
+                        json: {
+                            type: options.type,
+                            data: {
+                                flags: options.data?.flags,
+                            },
+                        },
+                    });
+                }
+                break;
+            case constants_1.InteractionCallbackType.ApplicationCommandAutocompleteResult:
+                {
+                    this.rest.request(rest_1.RestMethods.Post, rest_1.Endpoints.interactionCallback(interactionId, interactionToken), {
+                        json: {
+                            type: options.type,
+                            data: {
+                                choices: options.data?.choices?.map((choice) => this.util.toSnakeCase(choice)),
+                            },
+                        },
+                    });
+                }
+                break;
+            case constants_1.InteractionCallbackType.Modal:
+                {
+                    this.rest.request(rest_1.RestMethods.Post, rest_1.Endpoints.interactionCallback(interactionId, interactionToken), {
+                        json: {
+                            type: options.type,
+                            data: {
+                                custom_id: options.data?.customId,
+                                components: options.data?.components !== undefined
+                                    ? this.util.toSnakeCase(options.data.components)
+                                    : undefined,
+                                title: options.data?.title,
+                            },
+                        },
+                    });
+                }
+                break;
+            case constants_1.InteractionCallbackType.PremiumRequired:
+                {
+                    this.rest.request(rest_1.RestMethods.Post, rest_1.Endpoints.interactionCallback(interactionId, interactionToken), {
+                        json: {
+                            type: options.type,
+                            data: {},
+                        },
+                    });
+                }
+                break;
+        }
+    }
+    /** https://discord.com/developers/docs/resources/channel#create-message */
+    createMessage(channelId, options) {
+        return this.rest
+            .request(rest_1.RestMethods.Post, rest_1.Endpoints.channelMessages(channelId), {
+            json: {
+                content: options.content,
+                nonce: options.nonce,
+                tts: options.tts,
+                embeds: options.embeds !== undefined
+                    ? options.embeds.map((e) => this.util.toSnakeCase(e))
+                    : undefined,
+                allowed_mentions: options.allowedMentions !== undefined
+                    ? this.util.toSnakeCase(options.allowedMentions)
+                    : undefined,
+                message_reference: options.messageReference,
+                components: options.components !== undefined
+                    ? options.components.map((c) => this.util.toSnakeCase(c))
+                    : undefined,
+                stickers_ids: options.stickersIds,
+                attachments: options.attachments?.map((attachment) => this.util.toSnakeCase(attachment)),
+                flags: options.flags,
+                enforce_nonce: options.enforceNonce,
+            },
+            files: options.files,
+        })
+            .then((response) => this.util.toCamelCase(response));
+    }
+    /** https://discord.com/developers/docs/resources/channel#create-reaction */
+    createMessageReaction(channelId, messageId, emoji) {
+        this.rest.request(rest_1.RestMethods.Put, rest_1.Endpoints.channelMessageReaction(channelId, messageId, emoji));
+    }
+    /** https://discord.com/developers/docs/resources/stage-instance#create-stage-instance */
+    createStageInstance(options, reason) {
+        return this.rest
+            .request(rest_1.RestMethods.Post, rest_1.Endpoints.stageInstances(), {
+            json: {
+                channel_id: options.channelId,
+                topic: options.topic,
+                privacy_level: options.privacyLevel,
+                send_start_notifications: options.sendStartNotifications,
+                guild_scheduled_event_id: options.guildScheduledEventId,
+            },
+            reason,
+        })
+            .then((response) => this.util.toCamelCase(response));
+    }
+    /** https://discord.com/developers/docs/monetization/entitlements#create-test-entitlement */
+    createTestEntitlement(applicationId, options) {
+        return this.rest
+            .request(rest_1.RestMethods.Post, rest_1.Endpoints.applicationEntitlements(applicationId), {
+            json: {
+                sku_id: options.skuId,
+                owner_id: options.ownerId,
+                owner_type: options.ownerType,
+            },
+        })
+            .then((response) => this.util.toCamelCase(response));
+    }
+    /** https://discord.com/developers/docs/resources/channel#start-thread-in-forum-or-media-channel */
+    createThread(channelId, options, reason) {
+        return this.rest
+            .request(rest_1.RestMethods.Post, rest_1.Endpoints.threads(channelId), {
+            json: {
+                name: options.name,
+                auto_archive_duration: options.autoArchiveDuration,
+                rate_limit_per_user: options.rateLimitPerUser,
+                message: this.util.toSnakeCase(options.message),
+                applied_tags: options.appliedTags,
+            },
+            files: options.files,
+            reason,
+        })
+            .then((response) => this.util.toCamelCase(response));
+    }
+    /** https://discord.com/developers/docs/resources/channel#start-thread-from-message */
+    createThreadFromMessage(channelId, messageId, options, reason) {
+        return this.rest
+            .request(rest_1.RestMethods.Post, rest_1.Endpoints.threads(channelId, messageId), {
+            json: {
+                name: options.name,
+                auto_archive_duration: options.autoArchiveDuration,
+                rate_limit_per_user: options.rateLimitPerUser,
+            },
+            reason,
+        })
+            .then((response) => this.util.toCamelCase(response));
+    }
+    /** https://discord.com/developers/docs/resources/channel#start-thread-without-message */
+    createThreadWithoutMessage(channelId, options, reason) {
+        return this.rest
+            .request(rest_1.RestMethods.Post, rest_1.Endpoints.threads(channelId), {
+            json: {
+                name: options.name,
+                auto_archive_duration: options.autoArchiveDuration,
+                type: options.type,
+                invitable: options.invitable,
+                rate_limit_per_user: options.rateLimitPerUser,
+            },
+            reason,
+        })
+            .then((response) => this.util.toCamelCase(response));
+    }
+    /** https://discord.com/developers/docs/resources/channel#crosspost-message */
+    crosspostMessage(channelId, messageId) {
+        return this.rest
+            .request(rest_1.RestMethods.Post, rest_1.Endpoints.channelMessage(channelId, messageId))
+            .then((response) => this.util.toCamelCase(response));
+    }
+    /** https://discord.com/developers/docs/resources/channel#delete-all-reactions */
+    deleteAllMessageReactions(channelId, messageId, emoji) {
+        this.rest.request(rest_1.RestMethods.Delete, rest_1.Endpoints.channelMessageAllReactions(channelId, messageId, emoji));
+    }
+    /** https://discord.com/developers/docs/resources/auto-moderation#delete-auto-moderation-rule */
+    deleteAutoModerationRule(guildId, autoModerationRuleId, reason) {
+        this.rest.request(rest_1.RestMethods.Delete, rest_1.Endpoints.guildAutoModerationRule(guildId, autoModerationRuleId), {
+            reason,
+        });
+    }
+    /** https://discord.com/developers/docs/resources/channel#deleteclose-channel */
+    deleteChannel(channelId, reason) {
+        return this.rest
+            .request(rest_1.RestMethods.Delete, rest_1.Endpoints.channel(channelId), {
+            reason,
+        })
+            .then((response) => this.util.toCamelCase(response));
+    }
+    /** https://discord.com/developers/docs/resources/channel#delete-channel-permission */
+    deleteChannelPermission(channelId, overwriteId, reason) {
+        this.rest.request(rest_1.RestMethods.Delete, rest_1.Endpoints.channelPermission(channelId, overwriteId), {
+            reason,
+        });
+    }
+    /** https://discord.com/developers/docs/interactions/application-commands#delete-global-application-command */
+    deleteGlobalApplicationCommand(applicationId, commandId) {
+        this.rest.request(rest_1.RestMethods.Delete, rest_1.Endpoints.applicationCommand(applicationId, commandId));
+    }
+    /** https://discord.com/developers/docs/resources/guild#delete-guild */
+    deleteGuild(guildId) {
+        this.rest.request(rest_1.RestMethods.Delete, rest_1.Endpoints.guild(guildId));
+    }
+    /** https://discord.com/developers/docs/interactions/application-commands#delete-guild-application-command */
+    deleteGuildApplicationCommand(applicationId, guildId, commandId) {
+        this.rest.request(rest_1.RestMethods.Delete, rest_1.Endpoints.applicationGuildCommand(applicationId, guildId, commandId));
+    }
+    /** https://discord.com/developers/docs/resources/emoji#delete-guild-emoji */
+    deleteGuildEmoji(guildId, emojiId, reason) {
+        this.rest.request(rest_1.RestMethods.Delete, rest_1.Endpoints.guildEmoji(guildId, emojiId), {
+            reason,
+        });
+    }
+    /** https://discord.com/developers/docs/resources/guild#delete-guild-integration */
+    deleteGuildIntegration(guildId, integrationId, reason) {
+        this.rest.request(rest_1.RestMethods.Delete, rest_1.Endpoints.guildIntegration(guildId, integrationId), {
+            reason,
+        });
+    }
+    /** https://discord.com/developers/docs/resources/guild#delete-guild-role */
+    deleteGuildRole(guildId, roleId, reason) {
+        this.rest.request(rest_1.RestMethods.Delete, rest_1.Endpoints.guildRole(guildId, roleId), {
+            reason,
+        });
+    }
+    /** https://discord.com/developers/docs/resources/guild-scheduled-event#delete-guild-scheduled-event */
+    deleteGuildScheduledEvent(guildId, guildScheduledEventId) {
+        this.rest.request(rest_1.RestMethods.Delete, rest_1.Endpoints.guildScheduledEvent(guildId, guildScheduledEventId));
+    }
+    /** https://discord.com/developers/docs/resources/sticker#delete-guild-sticker */
+    deleteGuildSticker(guildId, stickerId, reason) {
+        this.rest.request(rest_1.RestMethods.Delete, rest_1.Endpoints.guildSticker(guildId, stickerId), {
+            reason,
+        });
+    }
+    /** https://discord.com/developers/docs/resources/guild-template#delete-guild-template */
+    deleteGuildTemplate(guildId, code) {
+        return this.rest
+            .request(rest_1.RestMethods.Delete, rest_1.Endpoints.guildTemplate(guildId, code))
+            .then((response) => this.util.toCamelCase(response));
+    }
+    /** https://discord.com/developers/docs/resources/invite#delete-invite */
+    deleteInvite(code, reason) {
+        return this.rest
+            .request(rest_1.RestMethods.Delete, rest_1.Endpoints.invite(code), {
+            reason,
+        })
+            .then((response) => this.util.toCamelCase(response));
+    }
+    /** https://discord.com/developers/docs/interactions/receiving-and-responding#delete-followup-message */
+    deleteInteractionFollowupMessage(applicationId, interactionToken, messageId) {
+        this.rest.request(rest_1.RestMethods.Delete, rest_1.Endpoints.webhookMessage(applicationId, interactionToken, messageId));
+    }
+    /** https://discord.com/developers/docs/interactions/receiving-and-responding#delete-original-interaction-response */
+    deleteInteractionResponse(applicationId, interactionToken) {
+        this.rest.request(rest_1.RestMethods.Delete, rest_1.Endpoints.webhookMessage(applicationId, interactionToken));
+    }
+    /** https://discord.com/developers/docs/resources/channel#delete-message */
+    deleteMessage(channelId, messageId, reason) {
+        this.rest.request(rest_1.RestMethods.Delete, rest_1.Endpoints.channelMessage(channelId, messageId), {
+            reason,
+        });
+    }
+    /** https://discord.com/developers/docs/resources/channel#delete-user-reaction */
+    deleteMessageReaction(channelId, messageId, emoji, userId) {
+        this.rest.request(rest_1.RestMethods.Delete, rest_1.Endpoints.channelMessageReaction(channelId, messageId, emoji, userId));
+    }
+    /** https://discord.com/developers/docs/resources/stage-instance#delete-stage-instance */
+    deleteStageInstance(channelId, reason) {
+        this.rest.request(rest_1.RestMethods.Delete, rest_1.Endpoints.stageInstance(channelId), {
+            reason,
+        });
+    }
+    /** https://discord.com/developers/docs/monetization/entitlements#delete-test-entitlement */
+    deleteTestEntitlement(applicationId, entitlementId) {
+        this.rest.request(rest_1.RestMethods.Delete, rest_1.Endpoints.applicationEntitlement(applicationId, entitlementId));
+    }
+    /** https://discord.com/developers/docs/resources/webhook#delete-webhook */
+    deleteWebhook(webhookId, reason) {
+        this.rest.request(rest_1.RestMethods.Delete, rest_1.Endpoints.webhook(webhookId), {
+            reason,
+        });
+    }
+    /** https://discord.com/developers/docs/resources/webhook#delete-webhook-message */
+    deleteWebhookMessage(webhookId, webhookToken, messageId, options) {
+        this.rest.request(rest_1.RestMethods.Delete, rest_1.Endpoints.webhookMessage(webhookId, webhookToken, messageId), {
+            query: {
+                thread_id: options?.threadId,
+            },
+        });
+    }
+    /** https://discord.com/developers/docs/resources/webhook#delete-webhook-with-token */
+    deleteWebhookWithToken(webhookId, webhookToken, reason) {
+        this.rest.request(rest_1.RestMethods.Delete, rest_1.Endpoints.webhook(webhookId, webhookToken), {
+            reason,
+            authorization: false,
+        });
+    }
+    disconnect() {
+        this.shards.disconnect();
+    }
+    /** https://discord.com/developers/docs/resources/auto-moderation#modify-auto-moderation-rule */
+    editAutoModerationRule(guildId, autoModerationRuleId, options, reason) {
+        return this.rest
+            .request(rest_1.RestMethods.Patch, rest_1.Endpoints.guildAutoModerationRule(guildId, autoModerationRuleId), {
+            json: {
+                name: options.name,
+                event_type: options.eventType,
+                trigger_type: options.triggerType,
+                trigger_metadata: options.triggerMetadata,
+                actions: options.actions?.map((action) => this.util.toSnakeCase(action)),
+                enabled: options.enabled,
+                exempt_roles: options.exemptRoles,
+                exempt_channels: options.exemptChannels,
+            },
+            reason,
+        })
+            .then((response) => this.util.toCamelCase(response));
+    }
+    /** https://discord.com/developers/docs/interactions/application-commands#edit-application-command-permissions */
+    editApplicationCommandPermissions(applicationId, guildId, commandId, options) {
+        return this.rest
+            .request(rest_1.RestMethods.Put, rest_1.Endpoints.applicationCommandPermissions(applicationId, guildId, commandId), {
+            json: {
+                permissions: options.permissions.map((permission) => this.util.toSnakeCase(permission)),
+            },
+        })
+            .then((response) => this.util.toCamelCase(response));
+    }
+    /** https://discord.com/developers/docs/resources/channel#modify-channel */
+    editChannel(channelId, options, reason) {
+        return this.rest
+            .request(rest_1.RestMethods.Patch, rest_1.Endpoints.channel(channelId), {
+            json: {
+                name: options.name,
+                type: options.type,
+                position: options.position,
+                topic: options.topic,
+                nsfw: options.nsfw,
+                rate_limit_per_user: options.rateLimitPerUser,
+                bitrate: options.bitrate,
+                permission_overwrites: options.permissionOverwrites,
+                parent_id: options.parentId,
+                rtc_region: options.rtcRegion,
+                video_quality_mode: options.videoQualityMode,
+                default_auto_archive_duration: options.defaultAutoArchiveDuration,
+                flags: options.flags,
+                available_tags: options.availableTags,
+                default_reaction_emoji: options.defaultReactionEmoji,
+                default_thread_rate_limit_per_user: options.defaultThreadRateLimitPerUser,
+                default_sort_order: options.defaultSortOrder,
+                default_forum_layout: options.defaultForumLayout,
+                archived: options.archived,
+                auto_archive_duration: options.autoArchiveDuration,
+                locked: options.locked,
+                invitable: options.invitable,
+                applied_tags: options.appliedTags,
+            },
+            reason,
+        })
+            .then((response) => this.util.toCamelCase(response));
+    }
+    /** https://discord.com/developers/docs/resources/channel#edit-channel-permissions */
+    editChannelPermissions(channelId, overwriteId, options, reason) {
+        this.rest.request(rest_1.RestMethods.Put, rest_1.Endpoints.channelPermission(channelId, overwriteId), {
+            json: options,
+            reason,
+        });
+    }
+    /** https://discord.com/developers/docs/resources/guild#modify-guild-channel-positions */
+    editChannelPositions(guildId, options) {
+        this.rest.request(rest_1.RestMethods.Patch, rest_1.Endpoints.guildChannels(guildId), {
+            json: options.map((data) => ({
+                id: data.id,
+                position: data.position,
+                lock_permissions: data.lockPermissions,
+                parent_id: data.parentId,
+            })),
+        });
+    }
+    /** https://discord.com/developers/docs/resources/user#modify-current-user */
+    editCurrentUser(options) {
+        return this.rest
+            .request(rest_1.RestMethods.Patch, rest_1.Endpoints.user(), {
+            json: {
+                username: options.username,
+                avatar: options.avatar,
+            },
+        })
+            .then((response) => this.util.toCamelCase(response));
+    }
+    /** https://discord.com/developers/docs/resources/guild#modify-current-member */
+    editCurrentGuildMember(guildId, options, reason) {
+        return this.rest
+            .request(rest_1.RestMethods.Patch, rest_1.Endpoints.guildMember(guildId), {
+            json: {
+                nick: options.nick,
+            },
+            reason,
+        })
+            .then((response) => this.util.toCamelCase(response));
+    }
+    /** https://discord.com/developers/docs/resources/guild#modify-current-user-voice-state */
+    editCurrentUserVoiceState(guildId, options) {
+        this.rest.request(rest_1.RestMethods.Patch, rest_1.Endpoints.guildVoiceState(guildId), {
+            json: {
+                channel_id: options.channelId,
+                suppress: options.suppress,
+                requestToSpeakTimestamp: options.requestToSpeakTimestamp,
+            },
+        });
+    }
+    /** https://discord.com/developers/docs/resources/application#edit-current-application */
+    editCurrentApplication(options) {
+        return this.rest
+            .request(rest_1.RestMethods.Patch, rest_1.Endpoints.applicationCurrentUser(), {
+            json: {
+                custom_install_url: options.customInstallUrl,
+                description: options.description,
+                role_connections_verification_url: options.roleConnectionsVerificationUrl,
+                install_params: options.installParams,
+                flags: options.flags,
+                icon: options.icon,
+                cover_image: options.coverImage,
+                interactions_endpoint_url: options.interactionsEndpointUrl,
+                tags: options.tags,
+            },
+        })
+            .then((response) => this.util.toCamelCase(response));
+    }
+    /** https://discord.com/developers/docs/interactions/application-commands#edit-global-application-command */
+    editGlobalApplicationCommand(applicationId, commandId, options) {
+        return this.rest
+            .request(rest_1.RestMethods.Patch, rest_1.Endpoints.applicationCommand(applicationId, commandId), {
+            json: {
+                name: options.name,
+                name_localizations: options.nameLocalizations,
+                description: options.description,
+                description_localizations: options.descriptionLocalizations,
+                options: options.options?.map((option) => this.util.toSnakeCase(option)),
+                default_member_permissions: options.defaultMemberPermissions,
+                dm_permission: options.dmPermission,
+                default_permission: options.defaultPermission,
+                nsfw: options.nsfw,
+            },
+        })
+            .then((response) => this.util.toCamelCase(response));
+    }
+    /** https://discord.com/developers/docs/resources/guild#modify-guild */
+    editGuild(guildId, options, reason) {
+        return this.rest
+            .request(rest_1.RestMethods.Patch, rest_1.Endpoints.guild(guildId), {
+            json: {
+                name: options.name,
+                region: options.region,
+                verification_level: options.verificationLevel,
+                default_message_notifications: options.defaultMessageNotifications,
+                explicit_content_filter: options.explicitContentFilter,
                 afk_channel_id: options.afkChannelId,
                 afk_timeout: options.afkTimeout,
+                icon: options.icon,
+                owner_id: options.ownerId,
+                splash: options.splash,
+                discovery_splash: options.discoverySplash,
+                banner: options.banner,
                 system_channel_id: options.systemChannelId,
                 system_channel_flags: options.systemChannelFlags,
+                rules_channel_id: options.rulesChannelId,
+                public_updates_channel_id: options.publicUpdatesChannelId,
+                preferred_locale: options.preferredLocale,
+                features: options.features,
+                description: options.description,
+                premium_progress_bar_enabled: options.premiumProgressBarEnabled,
+                safety_alerts_channel_id: options.safetyAlertsChannelId,
+            },
+            reason,
+        })
+            .then((response) => this.util.toCamelCase(response));
+    }
+    /** https://discord.com/developers/docs/interactions/application-commands#edit-guild-application-command */
+    editGuildApplicationCommand(applicationId, guildId, commandId, options) {
+        return this.rest
+            .request(rest_1.RestMethods.Patch, rest_1.Endpoints.applicationGuildCommand(applicationId, guildId, commandId), {
+            json: {
+                name: options.name,
+                name_localizations: options.nameLocalizations,
+                description: options.description,
+                description_localizations: options.descriptionLocalizations,
+                options: options.options?.map((option) => this.util.toSnakeCase(option)),
+                default_member_permissions: options.defaultMemberPermissions,
+                default_permission: options.defaultPermission,
+                nsfw: options.nsfw,
+            },
+        })
+            .then((response) => this.util.toCamelCase(response));
+    }
+    /** https://discord.com/developers/docs/resources/emoji#modify-guild-emoji */
+    editGuildEmoji(guildId, emojiId, options, reason) {
+        return this.rest
+            .request(rest_1.RestMethods.Patch, rest_1.Endpoints.guildEmoji(guildId, emojiId), {
+            json: {
+                name: options.name,
+                roles: options.roles,
+            },
+            reason,
+        })
+            .then((response) => this.util.toCamelCase(response));
+    }
+    /** https://discord.com/developers/docs/resources/guild#modify-guild-member */
+    editGuildMember(guildId, userId, options, reason) {
+        return this.rest
+            .request(rest_1.RestMethods.Patch, rest_1.Endpoints.guildMember(guildId, userId), {
+            json: {
+                nick: options.nick,
+                roles: options.roles,
+                mute: options.mute,
+                deaf: options.deaf,
+                channel_id: options.channelId,
+                communication_disabled_until: options.communicationDisabledUntil,
+                flags: options.flags,
+            },
+            reason,
+        })
+            .then((response) => this.util.toCamelCase(response));
+    }
+    /** https://discord.com/developers/docs/resources/guild#modify-guild-mfa-level */
+    editGuildMFALevel(guildId, options, reason) {
+        return this.rest.request(rest_1.RestMethods.Post, rest_1.Endpoints.guildMFA(guildId), {
+            json: {
+                level: options.level,
+            },
+            reason,
+        });
+    }
+    /** https://discord.com/developers/docs/resources/guild#modify-guild-onboarding */
+    editGuildOnboarding(guildId, options, reason) {
+        this.rest.request(rest_1.RestMethods.Patch, rest_1.Endpoints.guildOnboarding(guildId), {
+            json: {
+                prompts: options.prompts.map((prompt) => this.util.toSnakeCase(prompt)),
+            },
+            reason,
+        });
+    }
+    /** https://discord.com/developers/docs/resources/guild#modify-guild-role */
+    editGuildRole(guildId, roleId, options, reason) {
+        return this.rest
+            .request(rest_1.RestMethods.Patch, rest_1.Endpoints.guildRole(guildId, roleId), {
+            json: {
+                name: options?.name,
+                permissions: options?.permissions,
+                color: options?.color,
+                hoist: options?.hoist,
+                icon: options?.icon,
+                unicode_emoji: options?.unicodeEmoji,
+                mentionable: options?.mentionable,
+            },
+            reason,
+        })
+            .then((response) => this.util.toCamelCase(response));
+    }
+    /** https://discord.com/developers/docs/resources/guild#modify-guild-role-positions */
+    editGuildRolePositions(guildId, options) {
+        return this.rest
+            .request(rest_1.RestMethods.Patch, rest_1.Endpoints.guildRoles(guildId), {
+            json: options.map((role) => this.util.toSnakeCase(role)),
+        })
+            .then((response) => response.map((role) => this.util.toCamelCase(role)));
+    }
+    /** https://discord.com/developers/docs/resources/guild-scheduled-event#modify-guild-scheduled-event */
+    editGuildScheduledEvent(guildId, guildScheduledEventId, options, reason) {
+        return this.rest
+            .request(rest_1.RestMethods.Patch, rest_1.Endpoints.guildScheduledEvent(guildId, guildScheduledEventId), {
+            json: {
+                channel_id: options.channelId,
+                entity_metadata: options.entityMetadata,
+                name: options.name,
+                privacy_level: options.privacyLevel,
+                scheduled_start_time: options.scheduledStartTime,
+                scheduled_end_time: options.scheduledEndTime,
+                description: options.description,
+                entityType: options.entityType,
+                status: options.status,
+                image: options.image,
+            },
+            reason,
+        })
+            .then((response) => this.util.toCamelCase(response));
+    }
+    /** https://discord.com/developers/docs/resources/sticker#modify-guild-sticker */
+    editGuildSticker(guildId, stickerId, options, reason) {
+        return this.rest
+            .request(rest_1.RestMethods.Patch, rest_1.Endpoints.guildSticker(guildId, stickerId), {
+            json: {
+                name: options.name,
+                description: options.description,
+                tags: options.tags,
+            },
+            reason,
+        })
+            .then((response) => this.util.toCamelCase(response));
+    }
+    /** https://discord.com/developers/docs/resources/guild-template#modify-guild-template */
+    editGuildTemplate(guildId, code, options) {
+        return this.rest
+            .request(rest_1.RestMethods.Patch, rest_1.Endpoints.guildTemplate(guildId, code), {
+            json: {
+                name: options.name,
+                description: options.description,
+            },
+        })
+            .then((response) => this.util.toCamelCase(response));
+    }
+    /** https://discord.com/developers/docs/resources/guild#modify-guild-welcome-screen */
+    editGuildWelcomeScreen(guildId, options, reason) {
+        return this.rest
+            .request(rest_1.RestMethods.Patch, rest_1.Endpoints.guildWelcomeScreen(guildId), {
+            json: {
+                enabled: options.enabled,
+                welcome_channels: options.welcomeChannels,
+                description: options.description,
+            },
+            reason,
+        })
+            .then((response) => this.util.toCamelCase(response));
+    }
+    /** https://discord.com/developers/docs/resources/guild#modify-guild-widget */
+    editGuildWidget(guildId, options, reason) {
+        return this.rest
+            .request(rest_1.RestMethods.Patch, rest_1.Endpoints.guildWidgetSettings(guildId), {
+            json: {
+                enabled: options.enabled,
+                channel_id: options.channelId,
+            },
+            reason,
+        })
+            .then((response) => this.util.toCamelCase(response));
+    }
+    /** https://discord.com/developers/docs/resources/channel#edit-message */
+    editMessage(channelId, messageId, options) {
+        return this.rest
+            .request(rest_1.RestMethods.Patch, rest_1.Endpoints.channelMessage(channelId, messageId), {
+            json: {
+                content: options.content,
+                embeds: options.embeds !== undefined
+                    ? options.embeds !== null
+                        ? options.embeds.map((e) => this.util.toSnakeCase(e))
+                        : null
+                    : undefined,
+                allowed_mentions: options.allowedMentions !== undefined
+                    ? options.allowedMentions !== null
+                        ? this.util.toSnakeCase(options.allowedMentions)
+                        : null
+                    : undefined,
+                components: options.components !== undefined
+                    ? options.components !== null
+                        ? options.components.map((c) => this.util.toSnakeCase(c))
+                        : null
+                    : undefined,
+                attachments: options.attachments?.map((attachment) => this.util.toSnakeCase(attachment)),
+                flags: options.flags,
+            },
+            files: options.files,
+        })
+            .then((response) => this.util.toCamelCase(response));
+    }
+    /** https://discord.com/developers/docs/resources/stage-instance#modify-stage-instance */
+    editStageInstance(channelId, options, reason) {
+        return this.rest
+            .request(rest_1.RestMethods.Patch, rest_1.Endpoints.stageInstance(channelId), {
+            json: {
+                topic: options.topic,
+                privacy_level: options.privacyLevel,
+            },
+            reason,
+        })
+            .then((response) => this.util.toCamelCase(response));
+    }
+    /** https://discord.com/developers/docs/interactions/receiving-and-responding#edit-followup-message */
+    editInteractionFollowupMessage(applicationId, interactionToken, messageId, options) {
+        return this.rest
+            .request(rest_1.RestMethods.Post, rest_1.Endpoints.webhookMessage(applicationId, interactionToken, messageId), {
+            json: {
+                content: options.content,
+                embeds: options.embeds !== undefined
+                    ? options.embeds !== null
+                        ? options.embeds.map((e) => this.util.toSnakeCase(e))
+                        : null
+                    : undefined,
+                allowed_mentions: options.allowedMentions !== undefined
+                    ? options.allowedMentions !== null
+                        ? this.util.toSnakeCase(options.allowedMentions)
+                        : null
+                    : undefined,
+                components: options.components !== undefined
+                    ? options.components !== null
+                        ? options.components.map((c) => this.util.toSnakeCase(c))
+                        : null
+                    : undefined,
+                attachments: options.attachments?.map((attachment) => this.util.toSnakeCase(attachment)),
+                flags: options.flags,
+            },
+            files: options.files,
+            query: {
+                thread_id: options.threadId,
+            },
+        })
+            .then((response) => this.util.toCamelCase(response));
+    }
+    /** https://discord.com/developers/docs/interactions/receiving-and-responding#edit-original-interaction-response */
+    editInteractionResponse(applicationId, interactionToken, options) {
+        return this.rest
+            .request(rest_1.RestMethods.Patch, rest_1.Endpoints.webhookMessage(applicationId, interactionToken), {
+            json: {
+                content: options.content,
+                embeds: options.embeds !== undefined
+                    ? options.embeds !== null
+                        ? options.embeds.map((e) => this.util.toSnakeCase(e))
+                        : null
+                    : undefined,
+                allowed_mentions: options.allowedMentions !== undefined
+                    ? options.allowedMentions !== null
+                        ? this.util.toSnakeCase(options.allowedMentions)
+                        : null
+                    : undefined,
+                components: options.components !== undefined
+                    ? options.components !== null
+                        ? options.components.map((c) => this.util.toSnakeCase(c))
+                        : null
+                    : undefined,
+                attachments: options.attachments?.map((attachment) => this.util.toSnakeCase(attachment)),
+                flags: options.flags,
+            },
+            files: options.files,
+            query: {
+                thread_id: options.threadId,
+            },
+        })
+            .then((response) => this.util.toCamelCase(response));
+    }
+    /** https://discord.com/developers/docs/resources/guild#modify-user-voice-state */
+    editUserVoiceState(guildId, userId, options) {
+        this.rest.request(rest_1.RestMethods.Patch, rest_1.Endpoints.guildVoiceState(guildId, userId), {
+            json: {
+                channel_id: options.channelId,
+                suppress: options.suppress,
+                requestToSpeakTimestamp: options.requestToSpeakTimestamp,
+            },
+        });
+    }
+    /** https://discord.com/developers/docs/resources/webhook#modify-webhook */
+    editWebhook(webhookId, options, reason) {
+        return this.rest
+            .request(rest_1.RestMethods.Patch, rest_1.Endpoints.webhook(webhookId), {
+            json: {
+                name: options.name,
+                avatar: options.avatar,
+                channel_id: options.channelId,
+            },
+            reason,
+        })
+            .then((response) => this.util.toCamelCase(response));
+    }
+    /** https://discord.com/developers/docs/resources/webhook#edit-webhook-message */
+    editWebhookMessage(webhookId, webhookToken, messageId, options) {
+        return this.rest
+            .request(rest_1.RestMethods.Patch, rest_1.Endpoints.webhookMessage(webhookId, webhookToken, messageId), {
+            json: {
+                content: options.content,
+                embeds: options.embeds !== undefined
+                    ? options.embeds !== null
+                        ? options.embeds.map((e) => this.util.toSnakeCase(e))
+                        : null
+                    : undefined,
+                allowed_mentions: options.allowedMentions !== undefined
+                    ? options.allowedMentions !== null
+                        ? this.util.toSnakeCase(options.allowedMentions)
+                        : null
+                    : undefined,
+                components: options.components !== undefined
+                    ? options.components !== null
+                        ? options.components.map((c) => this.util.toSnakeCase(c))
+                        : null
+                    : undefined,
+                attachments: options.attachments?.map((attachment) => this.util.toSnakeCase(attachment)),
+                flags: options.flags,
+            },
+            files: options.files,
+            query: {
+                thread_id: options.threadId,
+            },
+        })
+            .then((response) => this.util.toCamelCase(response));
+    }
+    /** https://discord.com/developers/docs/resources/webhook#modify-webhook-with-token */
+    editWebhookWithToken(webhookId, webhookToken, options, reason) {
+        return this.rest
+            .request(rest_1.RestMethods.Patch, rest_1.Endpoints.webhook(webhookId, webhookToken), {
+            json: {
+                name: options.name,
+                avatar: options.avatar,
+            },
+            reason,
+            authorization: false,
+        })
+            .then((response) => this.util.toCamelCase(response));
+    }
+    /** https://discord.com/developers/docs/resources/webhook#execute-webhook */
+    executeWebhook(webhookId, webhookToken, options) {
+        return this.rest
+            .request(rest_1.RestMethods.Post, rest_1.Endpoints.webhook(webhookId, webhookToken), {
+            json: {
+                content: options.content,
+                username: options.username,
+                avatarUrl: options.avatarUrl,
+                tts: options.tts,
+                embeds: options.embeds !== undefined
+                    ? options.embeds !== null
+                        ? options.embeds.map((e) => this.util.toSnakeCase(e))
+                        : null
+                    : undefined,
+                allowed_mentions: options.allowedMentions !== undefined
+                    ? options.allowedMentions !== null
+                        ? this.util.toSnakeCase(options.allowedMentions)
+                        : null
+                    : undefined,
+                components: options.components !== undefined
+                    ? options.components !== null
+                        ? options.components.map((c) => this.util.toSnakeCase(c))
+                        : null
+                    : undefined,
+                attachments: options.attachments?.map((attachment) => this.util.toSnakeCase(attachment)),
+                flags: options.flags,
+                thread_name: options.threadName,
             },
-        }), this);
+            files: options.files,
+            query: {
+                wait: options.wait,
+                thread_id: options.threadId,
+            },
+        })
+            .then((response) => response !== null ? this.util.toCamelCase(response) : null);
     }
-    /** https://discord.com/developers/docs/resources/guild-template#create-guild-from-guild-template */
-    async createGuildFromTemplate(code, options) {
-        return new structures_1.Guild(await this.rest.post(rest_1.Endpoints.template(code), {
-            json: {
-                name: options.name,
-                icon: options.icon,
+    /**
+     * https://discord.com/developers/docs/resources/webhook#execute-githubcompatible-webhook
+     *
+     * https://discord.com/developers/docs/resources/webhook#execute-slackcompatible-webhook
+     */
+    executeWebhookPlatform(webhookId, webhookToken, platform, options) {
+        return this.rest
+            .request(rest_1.RestMethods.Post, rest_1.Endpoints.webhookPlatform(webhookId, webhookToken, platform), {
+            query: {
+                thread_id: options.threadId,
+                wait: options.wait,
             },
-        }), this);
+            json: options,
+        })
+            .then((response) => response !== null ? this.util.toCamelCase(response) : null);
     }
-    /** https://discord.com/developers/docs/resources/stage-instance#create-stage-instance */
-    async createStageInstance(options, reason) {
-        return new structures_1.StageInstance(await this.rest.post(rest_1.Endpoints.stageInstances(), {
+    /** https://discord.com/developers/docs/resources/channel#follow-announcement-channel */
+    followChannel(channelId, options) {
+        return this.rest
+            .request(rest_1.RestMethods.Post, rest_1.Endpoints.channelFollowers(channelId), {
             json: {
-                channel_id: options.channelId,
-                topic: options.topic,
-                privacy_level: options.privacyLevel,
-                send_start_notifications: options.sendStartNotifications,
-                guild_scheduled_event_id: options.guildScheduledEventId,
+                webhook_channel_id: options.webhookChannelId,
             },
-            reason,
-        }), this);
+        })
+            .then((response) => this.util.toCamelCase(response));
     }
-    /** https://discord.com/developers/docs/resources/application#get-current-application */
-    async getApplication() {
-        return new structures_1.Application(await this.rest.get(rest_1.Endpoints.applicationCurrentUser()), this);
+    /** https://discord.com/developers/docs/resources/guild#list-active-guild-threads */
+    getActiveGuildThreads(guildId) {
+        return this.rest
+            .request(rest_1.RestMethods.Get, rest_1.Endpoints.guildActiveThreads(guildId))
+            .then((response) => this.util.toCamelCase(response));
+    }
+    /** https://discord.com/developers/docs/resources/channel#list-public-archived-threads */
+    getArchivedThreads(channelId, archivedStatus, options) {
+        return this.rest
+            .request(rest_1.RestMethods.Get, rest_1.Endpoints.channelThreads(channelId, archivedStatus, false), {
+            query: {
+                before: options?.before,
+                limit: options?.limit,
+            },
+        })
+            .then((response) => this.util.toCamelCase(response));
+    }
+    /** https://discord.com/developers/docs/resources/audit-log#get-guild-audit-log */
+    getAuditLog(guildId, options) {
+        return this.rest
+            .request(rest_1.RestMethods.Get, rest_1.Endpoints.guildAuditLog(guildId), {
+            query: {
+                user_id: options?.userId,
+                action_type: options?.actionType,
+                before: options?.before,
+                after: options?.after,
+                limit: options?.limit,
+            },
+        })
+            .then((response) => this.util.toCamelCase(response));
+    }
+    /** https://discord.com/developers/docs/resources/auto-moderation#get-auto-moderation-rule */
+    getAutoModerationRule(guildId, ruleId) {
+        return this.rest
+            .request(rest_1.RestMethods.Get, rest_1.Endpoints.guildAutoModerationRule(guildId, ruleId))
+            .then((response) => this.util.toCamelCase(response));
+    }
+    /** https://discord.com/developers/docs/resources/auto-moderation#list-auto-moderation-rules-for-guild */
+    getAutoModerationRules(guildId) {
+        return this.rest
+            .request(rest_1.RestMethods.Get, rest_1.Endpoints.guildAutoModerationRules(guildId))
+            .then((response) => response.map((autoModerationRule) => this.util.toCamelCase(autoModerationRule)));
+    }
+    /** https://discord.com/developers/docs/interactions/application-commands#get-application-command-permissions */
+    getApplicationCommandPermissions(applicationId, guildId, commandId) {
+        return this.rest
+            .request(rest_1.RestMethods.Get, rest_1.Endpoints.applicationCommandPermissions(applicationId, guildId, commandId))
+            .then((response) => this.util.toCamelCase(response));
+    }
+    /** https://discord.com/developers/docs/resources/application-role-connection-metadata#get-application-role-connection-metadata-records */
+    getApplicationRoleConnectionMetadataRecords(applicationId) {
+        return this.rest
+            .request(rest_1.RestMethods.Get, rest_1.Endpoints.applicationRoleConnectionMetadata(applicationId))
+            .then((response) => response.map((applicationRoleConnectionMetadata) => this.util.toCamelCase(applicationRoleConnectionMetadata)));
     }
     /** https://discord.com/developers/docs/resources/channel#get-channel */
-    async getChannel(channelId) {
-        return new structures_1.Channel(await this.rest.get(rest_1.Endpoints.channel(channelId)), this);
+    getChannel(channelId) {
+        return this.rest
+            .request(rest_1.RestMethods.Get, rest_1.Endpoints.channel(channelId))
+            .then((response) => this.util.toCamelCase(response));
+    }
+    /** https://discord.com/developers/docs/resources/guild#get-guild-channels */
+    getChannels(guildId) {
+        return this.rest
+            .request(rest_1.RestMethods.Get, rest_1.Endpoints.guildChannels(guildId))
+            .then((response) => response.map((channel) => this.util.toCamelCase(channel)));
+    }
+    /** https://discord.com/developers/docs/resources/channel#get-channel-invites */
+    getChannelInvites(channelId) {
+        return this.rest
+            .request(rest_1.RestMethods.Get, rest_1.Endpoints.channelInvites(channelId))
+            .then((response) => response.map((invite) => this.util.toCamelCase(invite)));
+    }
+    /** https://discord.com/developers/docs/resources/webhook#get-channel-webhooks */
+    getChannelWebhooks(channelId) {
+        return this.rest
+            .request(rest_1.RestMethods.Get, rest_1.Endpoints.channelWebhooks(channelId))
+            .then((response) => response.map((webhook) => this.util.toCamelCase(webhook)));
+    }
+    /** https://discord.com/developers/docs/resources/application#get-current-application */
+    getCurrentApplication() {
+        return this.rest
+            .request(rest_1.RestMethods.Get, rest_1.Endpoints.applicationCurrentUser())
+            .then((response) => this.util.toCamelCase(response));
+    }
+    /** https://discord.com/developers/docs/resources/user#get-current-user-application-role-connection */
+    getCurrentApplicationRoleConnection(applicationId) {
+        return this.rest
+            .request(rest_1.RestMethods.Get, rest_1.Endpoints.userApplicationRoleConnection(applicationId))
+            .then((response) => this.util.toCamelCase(response));
+    }
+    /** https://discord.com/developers/docs/resources/user#get-current-user-guild-member */
+    getCurrentGuildMember(guildId) {
+        return this.rest
+            .request(rest_1.RestMethods.Get, rest_1.Endpoints.guildMember(guildId))
+            .then((response) => this.util.toCamelCase(response));
+    }
+    /** https://discord.com/developers/docs/resources/user#get-current-user-connections */
+    getCurrentUserConnections() {
+        return this.rest
+            .request(rest_1.RestMethods.Get, rest_1.Endpoints.userConnections())
+            .then((response) => response.map((connection) => this.util.toCamelCase(connection)));
+    }
+    /** https://discord.com/developers/docs/monetization/entitlements#list-entitlements */
+    getEntitlements(applicationId, options) {
+        return this.rest
+            .request(rest_1.RestMethods.Get, rest_1.Endpoints.applicationEntitlements(applicationId), {
+            query: {
+                user_id: options?.userId,
+                sku_ids: options?.skuIds,
+                before: options?.before,
+                after: options?.after,
+                limit: options?.limit,
+                guild_id: options?.guildId,
+                exclude_ended: options?.excludeEnded,
+            },
+        })
+            .then((response) => response.map((entitlement) => this.util.toCamelCase(entitlement)));
     }
     /** https://discord.com/developers/docs/topics/gateway#get-gateway */
-    async getGateway() {
-        return this.rest.get(rest_1.Endpoints.gateway());
+    getGateway() {
+        return this.rest.request(rest_1.RestMethods.Get, rest_1.Endpoints.gateway());
     }
     /** https://discord.com/developers/docs/topics/gateway#get-gateway-bot */
-    async getGatewayBot() {
-        return this.rest
-            .get(rest_1.Endpoints.gatewayBot())
-            .then((response) => ({
-            url: response.url,
-            shards: response.shards,
-            sessionStartLimit: {
-                total: response.session_start_limit.total,
-                remaining: response.session_start_limit.remaining,
-                resetAfter: response.session_start_limit.reset_after,
-                maxConcurrency: response.session_start_limit.max_concurrency,
+    getGatewayBot() {
+        return this.rest
+            .request(rest_1.RestMethods.Get, rest_1.Endpoints.gatewayBot())
+            .then((response) => this.util.toCamelCase(response));
+    }
+    /** https://discord.com/developers/docs/interactions/application-commands#get-global-application-command */
+    getGlobalApplicationCommand(applicationId, commandId) {
+        return this.rest
+            .request(rest_1.RestMethods.Get, rest_1.Endpoints.applicationCommand(applicationId, commandId))
+            .then((response) => this.util.toCamelCase(response));
+    }
+    /** https://discord.com/developers/docs/interactions/application-commands#get-global-application-commands */
+    getGlobalApplicationCommands(applicationId, options) {
+        return this.rest
+            .request(rest_1.RestMethods.Get, rest_1.Endpoints.applicationCommands(applicationId), {
+            query: {
+                with_localizations: options.withLocalizations,
             },
-        }));
+        })
+            .then((response) => response.map((applicationCommand) => this.util.toCamelCase(applicationCommand)));
     }
     /** https://discord.com/developers/docs/resources/guild#get-guild */
-    async getGuild(guildId, options) {
-        return new structures_1.Guild(await this.rest.get(rest_1.Endpoints.guild(guildId), {
+    getGuild(guildId, options) {
+        return this.rest
+            .request(rest_1.RestMethods.Get, rest_1.Endpoints.guild(guildId), {
             query: {
                 with_counts: options?.withCounts,
             },
-        }), this);
+        })
+            .then((response) => this.util.toCamelCase(response));
     }
     /** https://discord.com/developers/docs/resources/user#get-current-user-guilds */
-    async getGuilds(options) {
+    getGuilds(options) {
         return this.rest
-            .get(rest_1.Endpoints.userGuilds(), {
+            .request(rest_1.RestMethods.Get, rest_1.Endpoints.userGuilds(), {
             query: {
                 before: options?.before,
                 after: options?.after,
@@ -129,85 +1454,358 @@ class Client extends node_events_1.default {
                 with_counts: options?.withCounts,
             },
         })
-            .then((response) => response.map((data) => new structures_1.Guild(data, this)));
+            .then((response) => response.map((guild) => this.util.toCamelCase(guild)));
+    }
+    /** https://discord.com/developers/docs/interactions/application-commands#get-guild-application-command */
+    getGuildApplicationCommand(applicationId, guildId, commandId) {
+        return this.rest
+            .request(rest_1.RestMethods.Get, rest_1.Endpoints.applicationGuildCommand(applicationId, guildId, commandId))
+            .then((response) => this.util.toCamelCase(response));
+    }
+    /** https://discord.com/developers/docs/interactions/application-commands#get-guild-application-commands */
+    getGuildApplicationCommands(applicationId, guildId, options) {
+        return this.rest
+            .request(rest_1.RestMethods.Get, rest_1.Endpoints.applicationGuildCommands(applicationId, guildId), {
+            query: {
+                with_localizations: options?.withLocalizations,
+            },
+        })
+            .then((response) => response.map((applicationCommand) => this.util.toCamelCase(applicationCommand)));
+    }
+    /** https://discord.com/developers/docs/interactions/application-commands#get-guild-application-command-permissions */
+    getGuildApplicationCommandPermissions(applicationId, guildId) {
+        return this.rest
+            .request(rest_1.RestMethods.Get, rest_1.Endpoints.guildApplicationCommandsPermissions(applicationId, guildId))
+            .then((response) => this.util.toCamelCase(response));
+    }
+    /** https://discord.com/developers/docs/resources/guild#get-guild-ban */
+    getGuildBan(guildId, userId) {
+        return this.rest
+            .request(rest_1.RestMethods.Get, rest_1.Endpoints.guildBan(guildId, userId))
+            .then((response) => this.util.toCamelCase(response));
+    }
+    /** https://discord.com/developers/docs/resources/guild#get-guild-bans */
+    getGuildBans(guildId, options) {
+        return this.rest
+            .request(rest_1.RestMethods.Get, rest_1.Endpoints.guildBans(guildId), {
+            query: {
+                limit: options?.limit,
+                before: options?.before,
+                after: options?.after,
+            },
+        })
+            .then((response) => response.map((ban) => this.util.toCamelCase(ban)));
+    }
+    /** https://discord.com/developers/docs/resources/emoji#get-guild-emoji */
+    getGuildEmoji(guildId, emojiId) {
+        return this.rest
+            .request(rest_1.RestMethods.Get, rest_1.Endpoints.guildEmoji(guildId, emojiId))
+            .then((response) => this.util.toCamelCase(response));
+    }
+    /** https://discord.com/developers/docs/resources/emoji#list-guild-emojis */
+    getGuildEmojis(guildId) {
+        return this.rest
+            .request(rest_1.RestMethods.Get, rest_1.Endpoints.guildEmojis(guildId))
+            .then((response) => response.map((emoji) => this.util.toCamelCase(emoji)));
+    }
+    /** https://discord.com/developers/docs/resources/guild#get-guild-integrations */
+    getGuildIntegrations(guildId) {
+        return this.rest
+            .request(rest_1.RestMethods.Get, rest_1.Endpoints.guildIntegrations(guildId))
+            .then((response) => response.map((integration) => this.util.toCamelCase(integration)));
+    }
+    /** https://discord.com/developers/docs/resources/guild#get-guild-invites */
+    getGuildInvites(guildId) {
+        return this.rest
+            .request(rest_1.RestMethods.Get, rest_1.Endpoints.guildInvites(guildId))
+            .then((response) => response.map((invite) => this.util.toCamelCase(invite)));
+    }
+    /** https://discord.com/developers/docs/resources/guild#get-guild-member */
+    getGuildMember(guildId, userId) {
+        return this.rest
+            .request(rest_1.RestMethods.Get, rest_1.Endpoints.guildMember(guildId, userId))
+            .then((response) => this.util.toCamelCase(response));
+    }
+    /** https://discord.com/developers/docs/resources/guild#list-guild-members */
+    getGuildMembers(guildId) {
+        return this.rest
+            .request(rest_1.RestMethods.Get, rest_1.Endpoints.guildMembers(guildId))
+            .then((response) => response.map((guildMember) => this.util.toCamelCase(guildMember)));
+    }
+    /** https://discord.com/developers/docs/resources/guild#get-guild-onboarding */
+    getGuildOnboarding(guildId) {
+        return this.rest
+            .request(rest_1.RestMethods.Get, rest_1.Endpoints.guildOnboarding(guildId))
+            .then((response) => this.util.toCamelCase(response));
+    }
+    /** https://discord.com/developers/docs/resources/guild#get-guild-preview */
+    getGuildPreview(guildId) {
+        return this.rest
+            .request(rest_1.RestMethods.Get, rest_1.Endpoints.guildPreview(guildId))
+            .then((response) => this.util.toCamelCase(response));
+    }
+    /** https://discord.com/developers/docs/resources/guild#get-guild-prune-count */
+    getGuildPruneCount(guildId, options) {
+        return this.rest
+            .request(rest_1.RestMethods.Get, rest_1.Endpoints.guildPrune(guildId), {
+            query: {
+                days: options.days,
+                include_roles: options.includeRoles,
+            },
+        })
+            .then((response) => this.util.toCamelCase(response));
+    }
+    /** https://discord.com/developers/docs/resources/guild#get-guild-roles */
+    getGuildRoles(guildId) {
+        return this.rest
+            .request(rest_1.RestMethods.Get, rest_1.Endpoints.guildRoles(guildId))
+            .then((response) => response.map((role) => this.util.toCamelCase(role)));
+    }
+    /** https://discord.com/developers/docs/resources/guild-scheduled-event#list-scheduled-events-for-guild */
+    getGuildScheduledEvents(guildId, options) {
+        return this.rest
+            .request(rest_1.RestMethods.Get, rest_1.Endpoints.guildScheduledEvents(guildId), {
+            query: {
+                with_user_count: options?.withUserCount,
+            },
+        })
+            .then((response) => response.map((guildScheduledEvent) => this.util.toCamelCase(guildScheduledEvent)));
+    }
+    /** https://discord.com/developers/docs/resources/guild-scheduled-event#get-guild-scheduled-event-users */
+    getGuildScheduledEventUsers(guildId, guildScheduledEventId, options) {
+        return this.rest
+            .request(rest_1.RestMethods.Get, rest_1.Endpoints.guildScheduledEvent(guildId, guildScheduledEventId), {
+            query: {
+                limit: options?.limit,
+                with_member: options?.withMember,
+                before: options?.before,
+                after: options?.after,
+            },
+        })
+            .then((response) => response.map((guildScheduledEventUser) => this.util.toCamelCase(guildScheduledEventUser)));
+    }
+    /** https://discord.com/developers/docs/resources/sticker#get-guild-sticker */
+    getGuildSticker(guildId, stickerId) {
+        return this.rest
+            .request(rest_1.RestMethods.Get, rest_1.Endpoints.guildSticker(guildId, stickerId))
+            .then((response) => this.util.toCamelCase(response));
+    }
+    /** https://discord.com/developers/docs/resources/sticker#list-guild-stickers */
+    getGuildStickers(guildId) {
+        return this.rest
+            .request(rest_1.RestMethods.Get, rest_1.Endpoints.guildStickers(guildId))
+            .then((response) => response.map((sticker) => this.util.toCamelCase(sticker)));
+    }
+    /** https://discord.com/developers/docs/resources/guild-template#get-guild-template */
+    getGuildTemplate(guildId, code) {
+        return this.rest
+            .request(rest_1.RestMethods.Get, rest_1.Endpoints.guildTemplate(guildId, code))
+            .then((response) => this.util.toCamelCase(response));
+    }
+    /** https://discord.com/developers/docs/resources/guild-template#get-guild-templates */
+    getGuildTemplates(guildId) {
+        return this.rest
+            .request(rest_1.RestMethods.Get, rest_1.Endpoints.guildTemplates(guildId))
+            .then((response) => response.map((guildTemplate) => this.util.toCamelCase(guildTemplate)));
+    }
+    /** https://discord.com/developers/docs/resources/guild#get-guild-vanity-url */
+    getGuildVanityUrl(guildId) {
+        return this.rest.request(rest_1.RestMethods.Get, rest_1.Endpoints.guildVanityUrl(guildId));
+    }
+    /** https://discord.com/developers/docs/resources/guild#get-guild-voice-regions */
+    getGuildVoiceRegions(guildId) {
+        return this.rest
+            .request(rest_1.RestMethods.Get, rest_1.Endpoints.guildVoiceRegions(guildId))
+            .then((response) => response.map((VoiceRegion) => this.util.toCamelCase(VoiceRegion)));
+    }
+    /** https://discord.com/developers/docs/resources/guild#get-guild-welcome-screen */
+    getGuildWelcomeScreen(guildId) {
+        return this.rest
+            .request(rest_1.RestMethods.Get, rest_1.Endpoints.guildWelcomeScreen(guildId))
+            .then((response) => this.util.toCamelCase(response));
+    }
+    /** https://discord.com/developers/docs/resources/guild#get-guild-widget */
+    getGuildWidget(guildId) {
+        return this.rest
+            .request(rest_1.RestMethods.Get, rest_1.Endpoints.guildWidgetJson(guildId))
+            .then((response) => this.util.toCamelCase(response));
+    }
+    /** https://discord.com/developers/docs/resources/guild#get-guild-widget-image */
+    getGuildWidgetImage(guildId, options) {
+        return this.rest.request(rest_1.RestMethods.Get, rest_1.Endpoints.guildWidgetImage(guildId), {
+            query: {
+                style: options?.style,
+            },
+        });
+    }
+    /** https://discord.com/developers/docs/resources/guild#get-guild-widget-settings */
+    getGuildWidgetSettings(guildId) {
+        return this.rest
+            .request(rest_1.RestMethods.Get, rest_1.Endpoints.guildWidgetSettings(guildId))
+            .then((response) => this.util.toCamelCase(response));
+    }
+    /** https://discord.com/developers/docs/interactions/receiving-and-responding#get-followup-message */
+    getInteractionFollowupMessage(applicationId, interactionToken, messageId, options) {
+        return this.rest
+            .request(rest_1.RestMethods.Get, rest_1.Endpoints.webhookMessage(applicationId, interactionToken, messageId), {
+            query: {
+                thread_id: options?.threadId,
+            },
+        })
+            .then((response) => this.util.toCamelCase(response));
+    }
+    /** https://discord.com/developers/docs/interactions/receiving-and-responding#get-original-interaction-response */
+    getInteractionResponse(applicationId, interactionToken, options) {
+        return this.rest
+            .request(rest_1.RestMethods.Get, rest_1.Endpoints.webhookMessage(applicationId, interactionToken), {
+            query: {
+                thread_id: options?.threadId,
+            },
+        })
+            .then((response) => this.util.toCamelCase(response));
     }
     /** https://discord.com/developers/docs/resources/invite#get-invite */
-    async getInvite(code, options) {
-        return new structures_1.Invite(await this.rest.get(rest_1.Endpoints.invite(code), {
+    getInvite(code, options) {
+        return this.rest
+            .request(rest_1.RestMethods.Get, rest_1.Endpoints.invite(code), {
             query: {
                 with_counts: options?.withCounts,
                 with_expiration: options?.withExpiration,
                 guild_scheduled_event_id: options?.guildScheduledEventId,
             },
-        }), this);
+        })
+            .then((response) => this.util.toCamelCase(response));
+    }
+    /** https://discord.com/developers/docs/resources/channel#list-joined-private-archived-threads */
+    getJoinedPrivateArchivedThreads(channelId, options) {
+        return this.rest
+            .request(rest_1.RestMethods.Get, rest_1.Endpoints.channelThreads(channelId, "private", true), {
+            query: {
+                before: options?.before,
+                limit: options?.limit,
+            },
+        })
+            .then((response) => this.util.toCamelCase(response));
+    }
+    /** https://discord.com/developers/docs/resources/channel#get-channel-message */
+    getMessage(channelId, messageId) {
+        return this.rest
+            .request(rest_1.RestMethods.Get, rest_1.Endpoints.channelMessage(channelId, messageId))
+            .then((response) => this.util.toCamelCase(response));
+    }
+    /** https://discord.com/developers/docs/resources/channel#get-reactions */
+    getMessageReactions(channelId, messageId, emoji, options) {
+        return this.rest
+            .request(rest_1.RestMethods.Get, rest_1.Endpoints.channelMessageAllReactions(channelId, messageId, emoji), {
+            query: {
+                after: options?.after,
+                limit: options?.limit,
+            },
+        })
+            .then((response) => response.map((user) => this.util.toCamelCase(user)));
+    }
+    /** https://discord.com/developers/docs/resources/channel#get-channel-messages */
+    getMessages(channelId, options) {
+        return this.rest
+            .request(rest_1.RestMethods.Get, rest_1.Endpoints.channelMessages(channelId), {
+            query: {
+                around: options.around,
+                before: options.before,
+                after: options.after,
+                limit: options.limit,
+            },
+        })
+            .then((response) => response.map((message) => this.util.toCamelCase(message)));
     }
     /** https://discord.com/developers/docs/topics/oauth2#get-current-bot-application-information */
-    async getOAuth2Application() {
-        return new structures_1.Application(await this.rest.get(rest_1.Endpoints.oauth2CurrentApplication()), this);
+    getOAuth2Application() {
+        return this.rest
+            .request(rest_1.RestMethods.Get, rest_1.Endpoints.oauth2CurrentApplication())
+            .then((response) => this.util.toCamelCase(response));
     }
     /** https://discord.com/developers/docs/topics/oauth2#get-current-authorization-information */
-    async getOAuth2Authorization() {
-        return this.rest
-            .get(rest_1.Endpoints.oauth2Authorization())
-            .then((response) => ({
-            application: new structures_1.Application(response.application, this),
-            scopes: response.scopes,
-            expires: response.expires,
-            user: response.user !== undefined
-                ? new structures_1.User(response.user, this)
-                : undefined,
-        }));
+    getOAuth2Authorization() {
+        return this.rest
+            .request(rest_1.RestMethods.Get, rest_1.Endpoints.oauth2Authorization())
+            .then((response) => this.util.toCamelCase(response));
+    }
+    /** https://discord.com/developers/docs/resources/channel#get-pinned-messages */
+    getPinnedMessages(channelId) {
+        return this.rest
+            .request(rest_1.RestMethods.Get, rest_1.Endpoints.channelPins(channelId))
+            .then((response) => response.map((message) => this.util.toCamelCase(message)));
+    }
+    /** https://discord.com/developers/docs/monetization/skus#list-skus */
+    getSkus(applicationId) {
+        return this.rest
+            .request(rest_1.RestMethods.Get, rest_1.Endpoints.applicationSkus(applicationId))
+            .then((response) => response.map((sku) => this.util.toCamelCase(sku)));
     }
     /** https://discord.com/developers/docs/resources/stage-instance#get-stage-instance */
-    async getStageInstance(channelId) {
-        return new structures_1.StageInstance(await this.rest.get(rest_1.Endpoints.stageInstance(channelId)), this);
+    getStageInstance(channelId) {
+        return this.rest
+            .request(rest_1.RestMethods.Get, rest_1.Endpoints.stageInstance(channelId))
+            .then((response) => this.util.toCamelCase(response));
     }
     /** https://discord.com/developers/docs/resources/sticker#list-sticker-packs */
-    async getStickerPacks() {
-        return this.rest
-            .get(rest_1.Endpoints.stickerPacks())
-            .then((response) => ({
-            stickerPacks: response.sticker_packs.map((stickerPack) => ({
-                id: stickerPack.id,
-                stickers: stickerPack.stickers.map((sticker) => ({
-                    id: sticker.id,
-                    packId: sticker.pack_id,
-                    name: sticker.name,
-                    description: sticker.description,
-                    tags: sticker.tags,
-                    asset: sticker.asset,
-                    type: sticker.type,
-                    formatType: sticker.format_type,
-                    available: sticker.available,
-                    guildId: sticker.guild_id,
-                    user: sticker.user !== undefined
-                        ? new structures_1.User(sticker.user, this).toJSON()
-                        : undefined,
-                    sortValue: sticker.sort_value,
-                })),
-                name: stickerPack.name,
-                skuId: stickerPack.sku_id,
-                coverStickerId: stickerPack.cover_sticker_id,
-                description: stickerPack.description,
-                bannerAssetId: stickerPack.banner_asset_id,
-            })),
-        }));
+    getStickerPacks() {
+        return this.rest
+            .request(rest_1.RestMethods.Get, rest_1.Endpoints.stickerPacks())
+            .then((response) => this.util.toCamelCase(response));
+    }
+    /** https://discord.com/developers/docs/resources/channel#get-thread-member */
+    getThreadMember(channelId, userId, options) {
+        return this.rest
+            .request(rest_1.RestMethods.Get, rest_1.Endpoints.threadMembers(channelId, userId), {
+            query: {
+                with_member: options?.withMember,
+            },
+        })
+            .then((response) => this.util.toCamelCase(response));
+    }
+    /** https://discord.com/developers/docs/resources/channel#list-thread-members */
+    getThreadMembers(channelId, options) {
+        return this.rest
+            .request(rest_1.RestMethods.Get, rest_1.Endpoints.threadMembers(channelId), {
+            query: {
+                with_member: options?.withMember,
+                after: options?.after,
+                limit: options?.limit,
+            },
+        })
+            .then((response) => response.map((threadMember) => this.util.toCamelCase(threadMember)));
     }
     /** https://discord.com/developers/docs/resources/user#get-user */
-    async getUser(userId) {
-        return new structures_1.User(await this.rest.get(rest_1.Endpoints.user(userId)), this);
+    getUser(userId) {
+        return this.rest
+            .request(rest_1.RestMethods.Get, rest_1.Endpoints.user(userId))
+            .then((response) => this.util.toCamelCase(response));
     }
     /** https://discord.com/developers/docs/resources/voice#list-voice-regions */
-    async getVoiceRegions() {
+    getVoiceRegions() {
+        return this.rest
+            .request(rest_1.RestMethods.Get, rest_1.Endpoints.voiceRegions())
+            .then((response) => response.map((voiceRegion) => this.util.toCamelCase(voiceRegion)));
+    }
+    /** https://discord.com/developers/docs/resources/webhook#get-webhook-message */
+    getWebhookMessage(webhookId, webhookToken, messageId, options) {
+        return this.rest
+            .request(rest_1.RestMethods.Get, rest_1.Endpoints.webhookMessage(webhookId, webhookToken, messageId), {
+            query: {
+                thread_id: options?.threadId,
+            },
+        })
+            .then((response) => this.util.toCamelCase(response));
+    }
+    /** https://discord.com/developers/docs/resources/webhook#get-guild-webhooks */
+    getWebhooks(guildId) {
         return this.rest
-            .get(rest_1.Endpoints.voiceRegions())
-            .then((response) => response.map((data) => ({
-            id: data.id,
-            name: data.name,
-            optimal: data.optimal,
-            deprecated: data.deprecated,
-            custom: data.custom,
-        })));
+            .request(rest_1.RestMethods.Get, rest_1.Endpoints.guildWebhooks(guildId))
+            .then((response) => response.map((webhook) => this.util.toCamelCase(webhook)));
+    }
+    /** https://discord.com/developers/docs/resources/channel#join-thread */
+    joinThread(channelId) {
+        this.rest.request(rest_1.RestMethods.Put, rest_1.Endpoints.threadMembers(channelId, "@me"));
     }
     /** https://discord.com/developers/docs/topics/gateway-events#update-voice-state */
     joinVoiceChannel(guildId, channelId, options) {
@@ -221,6 +1819,14 @@ class Client extends node_events_1.default {
             },
         }));
     }
+    /** https://discord.com/developers/docs/resources/user#leave-guild */
+    leaveGuild(guildId) {
+        this.rest.request(rest_1.RestMethods.Delete, rest_1.Endpoints.userGuild(guildId));
+    }
+    /** https://discord.com/developers/docs/resources/channel#leave-thread */
+    leaveThread(channelId) {
+        this.rest.request(rest_1.RestMethods.Delete, rest_1.Endpoints.threadMembers(channelId, "@me"));
+    }
     /** https://discord.com/developers/docs/topics/gateway-events#update-voice-state */
     leaveVoiceChannel(guildId) {
         this.shards.get(this.guildShardMap[guildId])?.ws.send(JSON.stringify({
@@ -233,23 +1839,87 @@ class Client extends node_events_1.default {
             },
         }));
     }
+    /** https://discord.com/developers/docs/resources/channel#pin-message */
+    pinMessage(channelId, messageId, reason) {
+        this.rest.request(rest_1.RestMethods.Put, rest_1.Endpoints.channelPin(channelId, messageId), {
+            reason,
+        });
+    }
+    /** https://discord.com/developers/docs/resources/guild#remove-guild-ban */
+    removeBan(guildId, userId, reason) {
+        this.rest.request(rest_1.RestMethods.Delete, rest_1.Endpoints.guildBan(guildId, userId), {
+            reason,
+        });
+    }
+    /** https://discord.com/developers/docs/resources/channel#group-dm-remove-recipient */
+    removeGroupRecipient(channelId, userId) {
+        this.rest.request(rest_1.RestMethods.Delete, rest_1.Endpoints.channelRecipient(channelId, userId));
+    }
+    /** https://discord.com/developers/docs/resources/guild#remove-guild-member */
+    removeGuildMember(guildId, userId, reason) {
+        this.rest.request(rest_1.RestMethods.Delete, rest_1.Endpoints.guildMember(guildId, userId), {
+            reason,
+        });
+    }
+    /** https://discord.com/developers/docs/resources/guild#remove-guild-member-role */
+    removeGuildMemberRole(guildId, userId, roleId, reason) {
+        this.rest.request(rest_1.RestMethods.Delete, rest_1.Endpoints.guildMemberRole(guildId, userId, roleId), {
+            reason,
+        });
+    }
+    /** https://discord.com/developers/docs/resources/channel#remove-thread-member */
+    removeThreadMember(channelId, userId) {
+        this.rest.request(rest_1.RestMethods.Delete, rest_1.Endpoints.threadMembers(channelId, userId));
+    }
+    /** https://discord.com/developers/docs/resources/guild#search-guild-members */
+    searchGuildMembers(guildId, options) {
+        return this.rest
+            .request(rest_1.RestMethods.Get, rest_1.Endpoints.guildMembersSearch(guildId), {
+            query: {
+                query: options.query,
+                limit: options.limit,
+            },
+        })
+            .then((response) => response.map((guildMember) => this.util.toCamelCase(guildMember)));
+    }
     /** https://discord.com/developers/docs/topics/gateway-events#update-presence */
     setPresence(options) {
         for (const [id, shard] of this.shards)
             shard.setPresence(options);
     }
-    /** https://discord.com/developers/docs/topics/gateway#connections */
-    async connect() {
-        this.shardsCount =
-            this.shardsCount === "auto"
-                ? (await this.getGatewayBot()).shards
-                : this.shardsCount;
-        for (let i = 0; i < this.shardsCount; i++)
-            this.shards.set(i, new gateway_1.Shard(i, this));
-        this.shards.connect();
+    /** https://discord.com/developers/docs/resources/guild-template#sync-guild-template */
+    syncGuildTemplate(guildId, code) {
+        return this.rest
+            .request(rest_1.RestMethods.Put, rest_1.Endpoints.guildTemplate(guildId, code))
+            .then((response) => this.util.toCamelCase(response));
     }
-    disconnect() {
-        this.shards.disconnect();
+    /** https://discord.com/developers/docs/resources/channel#trigger-typing-indicator */
+    triggerTypingIndicator(channelId) {
+        this.rest.request(rest_1.RestMethods.Post, rest_1.Endpoints.channelTyping(channelId));
+    }
+    /** https://discord.com/developers/docs/resources/application-role-connection-metadata#update-application-role-connection-metadata-records */
+    updateApplicationRoleConnectionMetadataRecords(applicationId) {
+        return this.rest
+            .request(rest_1.RestMethods.Put, rest_1.Endpoints.applicationRoleConnectionMetadata(applicationId))
+            .then((response) => response.map((applicationRoleConnectionMetadata) => this.util.toCamelCase(applicationRoleConnectionMetadata)));
+    }
+    /** https://discord.com/developers/docs/resources/user#update-current-user-application-role-connection */
+    updateCurrentApplicationRoleConnection(options) {
+        return this.rest
+            .request(rest_1.RestMethods.Put, rest_1.Endpoints.userApplicationRoleConnection(this.application.id), {
+            json: {
+                platform_name: options.platformName,
+                platform_username: options.platformUsername,
+                metadata: options.metadata,
+            },
+        })
+            .then((response) => this.util.toCamelCase(response));
+    }
+    /** https://discord.com/developers/docs/resources/channel#unpin-message */
+    unpinMessage(channelId, messageId, reason) {
+        this.rest.request(rest_1.RestMethods.Delete, rest_1.Endpoints.channelPin(channelId, messageId), {
+            reason,
+        });
     }
 }
 exports.Client = Client;