disgroove 2.2.0-dev.15819eb → 2.2.0-dev.301452e

package/dist/lib/Client.js

@@ -47,9 +47,8 @@ class Client extends node_events_1.default {
         });
     }
     /** 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), {
+    async addGuildMember(guildId, userId, options) {
+        const response = await this.rest.request(rest_1.RESTMethods.Put, rest_1.Endpoints.guildMember(guildId, userId), {
             json: {
                 access_token: options.accessToken,
                 nick: options.nick,
@@ -57,8 +56,8 @@ class Client extends node_events_1.default {
                 mute: options.mute,
                 deaf: options.deaf,
             },
-        })
-            .then((response) => response !== null ? this.util.toCamelCase(response) : null);
+        });
+        return response !== null ? this.util.guildMemberFromRaw(response) : null;
     }
     /** https://discord.com/developers/docs/resources/guild#add-guild-member-role */
     addGuildMemberRole(guildId, userId, roleId, reason) {
@@ -72,8 +71,7 @@ class Client extends node_events_1.default {
     }
     /** 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), {
+        return this.rest.request(rest_1.RESTMethods.Post, rest_1.Endpoints.guildPrune(guildId), {
             json: {
                 days: options.days,
                 compute_prune_count: options.computePruneCount,
@@ -81,20 +79,21 @@ class Client extends node_events_1.default {
                 reason: options.reason,
             },
             reason,
-        })
-            .then((response) => this.util.toCamelCase(response));
+        });
     }
     /** https://discord.com/developers/docs/resources/guild#bulk-guild-ban */
-    bulkGuildBan(guildId, options, reason) {
-        return this.rest
-            .request(rest_1.RESTMethods.Post, rest_1.Endpoints.bulkGuildBan(guildId), {
+    async bulkGuildBan(guildId, options, reason) {
+        const response = await this.rest.request(rest_1.RESTMethods.Post, rest_1.Endpoints.bulkGuildBan(guildId), {
             json: {
                 user_ids: options.userIds,
                 delete_message_seconds: options.deleteMessageSeconds,
             },
             reason,
-        })
-            .then((response) => this.util.toCamelCase(response));
+        });
+        return {
+            bannedUsers: response.banned_users,
+            failedUsers: response.failed_users,
+        };
     }
     /** https://discord.com/developers/docs/resources/channel#bulk-delete-messages */
     bulkDeleteMessages(channelId, options, reason) {
@@ -106,20 +105,18 @@ class Client extends node_events_1.default {
         });
     }
     /** 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)));
+    async bulkEditGlobalApplicationCommands(applicationId, commands) {
+        const response = await this.rest.request(rest_1.RESTMethods.Put, rest_1.Endpoints.applicationCommands(applicationId), {
+            json: commands.map((command) => this.util.partialApplicationCommandToRaw(command)),
+        });
+        return response.map((c) => this.util.applicationCommandFromRaw(c));
     }
     /** 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)));
+    async bulkEditGuildApplicationCommands(applicationId, guildId, commands) {
+        const response = await this.rest.request(rest_1.RESTMethods.Put, rest_1.Endpoints.applicationGuildCommands(applicationId, guildId), {
+            json: commands.map((command) => this.util.partialApplicationCommandToRaw(command)),
+        });
+        return response.map((c) => this.util.applicationCommandFromRaw(c));
     }
     /** https://discord.com/developers/docs/topics/gateway#connections */
     async connect() {
@@ -136,27 +133,32 @@ class Client extends node_events_1.default {
         this.rest.request(rest_1.RESTMethods.Post, rest_1.Endpoints.applicationEntitlementConsume(applicationId, entitlementId));
     }
     /** 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), {
+    async createAutoModerationRule(guildId, options, reason) {
+        const response = await 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)),
+                actions: options.actions.map((action) => ({
+                    type: action.type,
+                    metadata: {
+                        channel_id: action.metadata.channelId,
+                        duration_seconds: action.metadata.durationSeconds,
+                        custom_message: action.metadata.customMessage,
+                    },
+                })),
                 enabled: options.enabled,
                 exempt_roles: options.exemptRoles,
                 exempt_channels: options.exemptChannels,
             },
             reason,
-        })
-            .then((response) => this.util.toCamelCase(response));
+        });
+        return this.util.autoModerationRuleFromRaw(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), {
+    async createChannel(guildId, options, reason) {
+        const response = await this.rest.request(rest_1.RESTMethods.Post, rest_1.Endpoints.guildChannels(guildId), {
             json: {
                 name: options.name,
                 type: options.type,
@@ -173,7 +175,10 @@ class Client extends node_events_1.default {
                 default_auto_archive_duration: options.defaultAutoArchiveDuration,
                 default_reaction_emoji: options.defaultReactionEmoji !== undefined
                     ? options.defaultReactionEmoji !== null
-                        ? this.util.toSnakeCase(options.defaultReactionEmoji)
+                        ? {
+                            emoji_id: options.defaultReactionEmoji.emojiId,
+                            emoji_name: options.defaultReactionEmoji.emojiName,
+                        }
                         : null
                     : undefined,
                 available_tags: options.availableTags,
@@ -182,13 +187,12 @@ class Client extends node_events_1.default {
                 default_thread_rate_limit_per_user: options.defaultThreadRateLimitPerUser,
             },
             reason,
-        })
-            .then((response) => this.util.toCamelCase(response));
+        });
+        return this.util.channelFromRaw(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), {
+    async createChannelInvite(channelId, options, reason) {
+        const response = await this.rest.request(rest_1.RESTMethods.Post, rest_1.Endpoints.channelInvites(channelId), {
             json: {
                 max_age: options.maxAge,
                 max_uses: options.maxUses,
@@ -199,65 +203,49 @@ class Client extends node_events_1.default {
                 target_application_id: options.targetApplicationId,
             },
             reason,
-        })
-            .then((response) => this.util.toCamelCase(response));
+        });
+        return this.util.inviteFromRaw(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), {
+    async createChannelWebhook(channelId, options, reason) {
+        const response = await 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));
+        });
+        return this.util.webhookFromRaw(response);
     }
     /** https://discord.com/developers/docs/resources/user#create-dm */
-    createDM(options) {
-        return this.rest
-            .request(rest_1.RESTMethods.Post, rest_1.Endpoints.userChannels(), {
+    async createDM(options) {
+        const response = await this.rest.request(rest_1.RESTMethods.Post, rest_1.Endpoints.userChannels(), {
             json: {
                 recipient_id: options.recipientId,
             },
-        })
-            .then((response) => this.util.toCamelCase(response));
+        });
+        return this.util.channelFromRaw(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));
+    async createGlobalApplicationCommand(applicationId, options) {
+        const response = await this.rest.request(rest_1.RESTMethods.Post, rest_1.Endpoints.applicationCommands(applicationId), {
+            json: this.util.partialApplicationCommandToRaw(options),
+        });
+        return this.util.applicationCommandFromRaw(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(), {
+    async createGroupDM(options) {
+        const response = await 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));
+        });
+        return this.util.channelFromRaw(response);
     }
     /** https://discord.com/developers/docs/resources/guild#create-guild */
-    createGuild(options) {
-        return this.rest
-            .request(rest_1.RESTMethods.Post, rest_1.Endpoints.guilds(), {
+    async createGuild(options) {
+        const response = await this.rest.request(rest_1.RESTMethods.Post, rest_1.Endpoints.guilds(), {
             json: {
                 name: options.name,
                 region: options.region,
@@ -265,33 +253,29 @@ 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.toSnakeCase(role)),
-                channels: options.channels?.map((channel) => this.util.toSnakeCase(channel)),
+                roles: options.roles?.map((role) => ({
+                    name: role.name,
+                    color: role.color,
+                    hoist: role.hoist,
+                    icon: role.icon,
+                    unicode_emoji: role.unicodeEmoji,
+                    permissions: role.permissions,
+                    mentionable: role.mentionable,
+                })),
                 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));
+        });
+        return this.util.guildFromRaw(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));
+    async createGuildApplicationCommand(applicationId, guildId, options) {
+        const response = await this.rest.request(rest_1.RESTMethods.Post, rest_1.Endpoints.applicationGuildCommands(applicationId, guildId), {
+            json: this.util.partialApplicationCommandToRaw(options),
+        });
+        return this.util.applicationCommandFromRaw(response);
     }
     /** https://discord.com/developers/docs/resources/guild#create-guild-ban */
     createGuildBan(guildId, userId, options, reason) {
@@ -304,33 +288,30 @@ class Client extends node_events_1.default {
         });
     }
     /** 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), {
+    async createGuildEmoji(guildId, options, reason) {
+        const response = await 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));
+        });
+        return this.util.emojiFromRaw(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), {
+    async createGuildFromTemplate(code, options) {
+        const response = await 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));
+        });
+        return this.util.guildFromRaw(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), {
+    async createGuildRole(guildId, options, reason) {
+        const response = await this.rest.request(rest_1.RESTMethods.Post, rest_1.Endpoints.guildRoles(guildId), {
             json: {
                 name: options.name,
                 permissions: options.permissions,
@@ -341,13 +322,12 @@ class Client extends node_events_1.default {
                 mentionable: options.mentionable,
             },
             reason,
-        })
-            .then((response) => this.util.toCamelCase(response));
+        });
+        return this.util.roleFromRaw(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), {
+    async createGuildScheduledEvent(guildId, options, reason) {
+        const response = await this.rest.request(rest_1.RESTMethods.Post, rest_1.Endpoints.guildScheduledEvents(guildId), {
             json: {
                 channel_id: options.channelId,
                 entity_metadata: options.entityMetadata,
@@ -360,63 +340,63 @@ class Client extends node_events_1.default {
                 image: options.image,
             },
             reason,
-        })
-            .then((response) => this.util.toCamelCase(response));
+        });
+        return this.util.guildScheduledEventFromRaw(response);
     }
     /** https://discord.com/developers/docs/resources/sticker#create-guild-sticker */
-    createGuildSticker(guildId, options, reason) {
+    async 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), {
+        const response = await this.rest.request(rest_1.RESTMethods.Post, rest_1.Endpoints.guildStickers(guildId), {
             form: formData,
             reason,
-        })
-            .then((response) => this.util.toCamelCase(response));
+        });
+        return this.util.stickerFromRaw(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), {
+    async createGuildTemplate(guildId, options) {
+        const response = await 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));
+        });
+        return this.util.guildTemplateFromRaw(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), {
+    async createInteractionFollowupMessage(applicationId, interactionToken, options) {
+        const response = await 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,
+                embeds: options.embeds !== null
+                    ? options.embeds?.map((embed) => this.util.embedToRaw(embed))
+                    : null,
                 allowed_mentions: options.allowedMentions !== undefined
                     ? options.allowedMentions !== null
-                        ? this.util.toSnakeCase(options.allowedMentions)
+                        ? {
+                            parse: options.allowedMentions.parse,
+                            roles: options.allowedMentions.roles,
+                            users: options.allowedMentions.users,
+                            replied_user: options.allowedMentions.repliedUser,
+                        }
                         : null
                     : undefined,
                 components: options.components !== undefined
                     ? options.components !== null
-                        ? options.components.map((c) => this.util.toSnakeCase(c))
+                        ? this.util.messageComponentsToRaw(options.components)
                         : null
                     : undefined,
-                attachments: options.attachments?.map((attachment) => this.util.toSnakeCase(attachment)),
+                attachments: options.attachments?.map((attachment) => this.util.attachmentToRaw(attachment)),
                 flags: options.flags,
                 thread_name: options.threadName,
             },
             files: options.files,
-        })
-            .then((response) => this.util.toCamelCase(response));
+        });
+        return this.util.messageFromRaw(response);
     }
     /** https://discord.com/developers/docs/interactions/receiving-and-responding#create-interaction-response */
     createInteractionResponse(interactionId, interactionToken, options) {
@@ -430,18 +410,32 @@ class Client extends node_events_1.default {
                             data: {
                                 content: options.data?.content,
                                 embeds: options.data?.embeds !== undefined
-                                    ? this.util.toSnakeCase(options.data.embeds)
+                                    ? options.data.embeds.map((embed) => this.util.embedToRaw(embed))
                                     : undefined,
                                 allowed_mentions: options.data?.allowedMentions !== undefined
-                                    ? this.util.toSnakeCase(options.data.allowedMentions)
+                                    ? {
+                                        parse: options.data.allowedMentions.parse,
+                                        roles: options.data.allowedMentions.roles,
+                                        users: options.data.allowedMentions.users,
+                                        replied_user: options.data.allowedMentions.repliedUser,
+                                    }
                                     : undefined,
                                 flags: options.data?.flags,
                                 components: options.data?.components !== undefined
-                                    ? this.util.toSnakeCase(options.data.components)
+                                    ? this.util.messageComponentsToRaw(options.data.components)
                                     : undefined,
-                                attachments: options.data?.attachments?.map((attachment) => this.util.toSnakeCase(attachment)),
+                                attachments: options.data?.attachments?.map((attachment) => this.util.attachmentToRaw(attachment)),
                                 poll: options.data?.poll !== undefined
-                                    ? this.util.toSnakeCase(options.data?.poll)
+                                    ? {
+                                        question: options.data.poll.question,
+                                        answers: options.data.poll.answers.map((answer) => ({
+                                            answer_id: answer.answerId,
+                                            poll_media: answer.pollMedia,
+                                        })),
+                                        duration: options.data.poll.duration,
+                                        allow_multiselect: options.data.poll.allowMultiselect,
+                                        layout_type: options.data.poll.layoutType,
+                                    }
                                     : undefined,
                             },
                         },
@@ -468,7 +462,11 @@ class Client extends node_events_1.default {
                         json: {
                             type: options.type,
                             data: {
-                                choices: options.data?.choices?.map((choice) => this.util.toSnakeCase(choice)),
+                                choices: options.data?.choices?.map((choice) => ({
+                                    name: choice.name,
+                                    name_localizations: choice.nameLocalizations,
+                                    value: choice.value,
+                                })),
                             },
                         },
                     });
@@ -482,7 +480,7 @@ class Client extends node_events_1.default {
                             data: {
                                 custom_id: options.data?.customId,
                                 components: options.data?.components !== undefined
-                                    ? this.util.toSnakeCase(options.data.components)
+                                    ? this.util.messageComponentsToRaw(options.data.components)
                                     : undefined,
                                 title: options.data?.title,
                             },
@@ -503,43 +501,53 @@ class Client extends node_events_1.default {
         }
     }
     /** 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), {
+    async createMessage(channelId, options) {
+        const response = await 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,
+                embeds: options.embeds?.map((embed) => this.util.embedToRaw(embed)),
                 allowed_mentions: options.allowedMentions !== undefined
-                    ? this.util.toSnakeCase(options.allowedMentions)
+                    ? {
+                        parse: options.allowedMentions.parse,
+                        roles: options.allowedMentions.roles,
+                        users: options.allowedMentions.users,
+                        replied_user: options.allowedMentions.repliedUser,
+                    }
                     : undefined,
                 message_reference: options.messageReference,
                 components: options.components !== undefined
-                    ? options.components.map((c) => this.util.toSnakeCase(c))
+                    ? this.util.messageComponentsToRaw(options.components)
                     : undefined,
                 stickers_ids: options.stickersIds,
-                attachments: options.attachments?.map((attachment) => this.util.toSnakeCase(attachment)),
+                attachments: options.attachments?.map((attachment) => this.util.attachmentToRaw(attachment)),
                 flags: options.flags,
                 enforce_nonce: options.enforceNonce,
                 poll: options.poll !== undefined
-                    ? this.util.toSnakeCase(options.poll)
+                    ? {
+                        question: options.poll.question,
+                        answers: options.poll.answers.map((answer) => ({
+                            answer_id: answer.answerId,
+                            poll_media: answer.pollMedia,
+                        })),
+                        duration: options.poll.duration,
+                        allow_multiselect: options.poll.allowMultiselect,
+                        layout_type: options.poll.layoutType,
+                    }
                     : undefined,
             },
             files: options.files,
-        })
-            .then((response) => this.util.toCamelCase(response));
+        });
+        return this.util.messageFromRaw(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(), {
+    async createStageInstance(options, reason) {
+        const response = await this.rest.request(rest_1.RESTMethods.Post, rest_1.Endpoints.stageInstances(), {
             json: {
                 channel_id: options.channelId,
                 topic: options.topic,
@@ -548,54 +556,63 @@ class Client extends node_events_1.default {
                 guild_scheduled_event_id: options.guildScheduledEventId,
             },
             reason,
-        })
-            .then((response) => this.util.toCamelCase(response));
+        });
+        return this.util.stageInstanceFromRaw(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), {
+    async createTestEntitlement(applicationId, options) {
+        const response = await 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));
+        });
+        return this.util.testEntitlementFromRaw(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), {
+    async createThread(channelId, options, reason) {
+        const response = await 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),
+                message: {
+                    content: options.message.content,
+                    embeds: options.message.embeds?.map((embed) => this.util.embedToRaw(embed)),
+                    allowed_mentions: options.message.allowedMentions !== undefined
+                        ? options.message.allowedMentions !== null
+                            ? {
+                                parse: options.message.allowedMentions.parse,
+                                roles: options.message.allowedMentions.roles,
+                                users: options.message.allowedMentions.users,
+                                replied_user: options.message.allowedMentions.repliedUser,
+                            }
+                            : null
+                        : undefined,
+                },
                 applied_tags: options.appliedTags,
             },
             files: options.files,
             reason,
-        })
-            .then((response) => this.util.toCamelCase(response));
+        });
+        return this.util.channelFromRaw(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), {
+    async createThreadFromMessage(channelId, messageId, options, reason) {
+        const response = await 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));
+        });
+        return this.util.channelFromRaw(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), {
+    async createThreadWithoutMessage(channelId, options, reason) {
+        const response = await this.rest.request(rest_1.RESTMethods.Post, rest_1.Endpoints.threads(channelId), {
             json: {
                 name: options.name,
                 auto_archive_duration: options.autoArchiveDuration,
@@ -604,14 +621,13 @@ class Client extends node_events_1.default {
                 rate_limit_per_user: options.rateLimitPerUser,
             },
             reason,
-        })
-            .then((response) => this.util.toCamelCase(response));
+        });
+        return this.util.channelFromRaw(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));
+    async crosspostMessage(channelId, messageId) {
+        const response = await this.rest.request(rest_1.RESTMethods.Post, rest_1.Endpoints.channelMessage(channelId, messageId));
+        return this.util.messageFromRaw(response);
     }
     /** https://discord.com/developers/docs/resources/channel#delete-all-reactions */
     deleteAllMessageReactions(channelId, messageId, emoji) {
@@ -624,12 +640,11 @@ class Client extends node_events_1.default {
         });
     }
     /** 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), {
+    async deleteChannel(channelId, reason) {
+        const response = await this.rest.request(rest_1.RESTMethods.Delete, rest_1.Endpoints.channel(channelId), {
             reason,
-        })
-            .then((response) => this.util.toCamelCase(response));
+        });
+        return this.util.channelFromRaw(response);
     }
     /** https://discord.com/developers/docs/resources/channel#delete-channel-permission */
     deleteChannelPermission(channelId, overwriteId, reason) {
@@ -678,18 +693,16 @@ class Client extends node_events_1.default {
         });
     }
     /** 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));
+    async deleteGuildTemplate(guildId, code) {
+        const response = await this.rest.request(rest_1.RESTMethods.Delete, rest_1.Endpoints.guildTemplate(guildId, code));
+        return this.util.guildTemplateFromRaw(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), {
+    async deleteInvite(code, reason) {
+        const response = await this.rest.request(rest_1.RESTMethods.Delete, rest_1.Endpoints.invite(code), {
             reason,
-        })
-            .then((response) => this.util.toCamelCase(response));
+        });
+        return this.util.inviteFromRaw(response);
     }
     /** https://discord.com/developers/docs/interactions/receiving-and-responding#delete-followup-message */
     deleteInteractionFollowupMessage(applicationId, interactionToken, messageId) {
@@ -744,37 +757,59 @@ class Client extends node_events_1.default {
         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), {
+    async editAutoModerationRule(guildId, autoModerationRuleId, options, reason) {
+        const response = await 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)),
+                actions: options.actions?.map((action) => ({
+                    type: action.type,
+                    metadata: {
+                        channel_id: action.metadata.channelId,
+                        duration_seconds: action.metadata.durationSeconds,
+                        custom_message: action.metadata.customMessage,
+                    },
+                })),
                 enabled: options.enabled,
                 exempt_roles: options.exemptRoles,
                 exempt_channels: options.exemptChannels,
             },
             reason,
-        })
-            .then((response) => this.util.toCamelCase(response));
+        });
+        return this.util.autoModerationRuleFromRaw(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), {
+    async editApplicationCommandPermissions(applicationId, guildId, commandId, options) {
+        const response = await this.rest.request(rest_1.RESTMethods.Put, rest_1.Endpoints.applicationCommandPermissions(applicationId, guildId, commandId), {
             json: {
-                permissions: options.permissions.map((permission) => this.util.toSnakeCase(permission)),
+                permissions: options.permissions.map((permission) => ({
+                    id: permission.id,
+                    application_id: permission.applicationId,
+                    guild_id: permission.guildId,
+                    permissions: permission.permissions.map((perm) => ({
+                        id: perm.id,
+                        type: perm.type,
+                        permission: perm.permission,
+                    })),
+                })),
             },
-        })
-            .then((response) => this.util.toCamelCase(response));
+        });
+        return {
+            id: response.id,
+            applicationId: response.application_id,
+            guildId: response.guild_id,
+            permissions: response.permissions.map((permission) => ({
+                id: permission.id,
+                type: permission.type,
+                permission: permission.permission,
+            })),
+        };
     }
     /** 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), {
+    async editChannel(channelId, options, reason) {
+        const response = await this.rest.request(rest_1.RESTMethods.Patch, rest_1.Endpoints.channel(channelId), {
             json: {
                 name: options.name,
                 type: options.type,
@@ -801,8 +836,8 @@ class Client extends node_events_1.default {
                 applied_tags: options.appliedTags,
             },
             reason,
-        })
-            .then((response) => this.util.toCamelCase(response));
+        });
+        return this.util.channelFromRaw(response);
     }
     /** https://discord.com/developers/docs/resources/channel#edit-channel-permissions */
     editChannelPermissions(channelId, overwriteId, options, reason) {
@@ -823,27 +858,25 @@ class Client extends node_events_1.default {
         });
     }
     /** https://discord.com/developers/docs/resources/user#modify-current-user */
-    editCurrentUser(options) {
-        return this.rest
-            .request(rest_1.RESTMethods.Patch, rest_1.Endpoints.user(), {
+    async editCurrentUser(options) {
+        const response = await this.rest.request(rest_1.RESTMethods.Patch, rest_1.Endpoints.user(), {
             json: {
                 username: options.username,
                 avatar: options.avatar,
                 banner: options.banner,
             },
-        })
-            .then((response) => this.util.toCamelCase(response));
+        });
+        return this.util.userFromRaw(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), {
+    async editCurrentGuildMember(guildId, options, reason) {
+        const response = await this.rest.request(rest_1.RESTMethods.Patch, rest_1.Endpoints.guildMember(guildId), {
             json: {
                 nick: options.nick,
             },
             reason,
-        })
-            .then((response) => this.util.toCamelCase(response));
+        });
+        return this.util.guildMemberFromRaw(response);
     }
     /** https://discord.com/developers/docs/resources/guild#modify-current-user-voice-state */
     editCurrentUserVoiceState(guildId, options) {
@@ -856,9 +889,8 @@ class Client extends node_events_1.default {
         });
     }
     /** https://discord.com/developers/docs/resources/application#edit-current-application */
-    editCurrentApplication(options) {
-        return this.rest
-            .request(rest_1.RESTMethods.Patch, rest_1.Endpoints.applicationCurrentUser(), {
+    async editCurrentApplication(options) {
+        const response = await this.rest.request(rest_1.RESTMethods.Patch, rest_1.Endpoints.applicationCurrentUser(), {
             json: {
                 custom_install_url: options.customInstallUrl,
                 description: options.description,
@@ -870,31 +902,19 @@ class Client extends node_events_1.default {
                 interactions_endpoint_url: options.interactionsEndpointUrl,
                 tags: options.tags,
             },
-        })
-            .then((response) => this.util.toCamelCase(response));
+        });
+        return this.util.applicationFromRaw(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));
+    async editGlobalApplicationCommand(applicationId, commandId, options) {
+        const response = await this.rest.request(rest_1.RESTMethods.Patch, rest_1.Endpoints.applicationCommand(applicationId, commandId), {
+            json: this.util.partialApplicationCommandToRaw(options),
+        });
+        return this.util.applicationCommandFromRaw(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), {
+    async editGuild(guildId, options, reason) {
+        const response = await this.rest.request(rest_1.RESTMethods.Patch, rest_1.Endpoints.guild(guildId), {
             json: {
                 name: options.name,
                 region: options.region,
@@ -919,42 +939,30 @@ class Client extends node_events_1.default {
                 safety_alerts_channel_id: options.safetyAlertsChannelId,
             },
             reason,
-        })
-            .then((response) => this.util.toCamelCase(response));
+        });
+        return this.util.guildFromRaw(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));
+    async editGuildApplicationCommand(applicationId, guildId, commandId, options) {
+        const response = await this.rest.request(rest_1.RESTMethods.Patch, rest_1.Endpoints.applicationGuildCommand(applicationId, guildId, commandId), {
+            json: this.util.partialApplicationCommandToRaw(options),
+        });
+        return this.util.applicationCommandFromRaw(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), {
+    async editGuildEmoji(guildId, emojiId, options, reason) {
+        const response = await 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));
+        });
+        return this.util.emojiFromRaw(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), {
+    async editGuildMember(guildId, userId, options, reason) {
+        const response = await this.rest.request(rest_1.RESTMethods.Patch, rest_1.Endpoints.guildMember(guildId, userId), {
             json: {
                 nick: options.nick,
                 roles: options.roles,
@@ -965,8 +973,8 @@ class Client extends node_events_1.default {
                 flags: options.flags,
             },
             reason,
-        })
-            .then((response) => this.util.toCamelCase(response));
+        });
+        return this.util.guildMemberFromRaw(response);
     }
     /** https://discord.com/developers/docs/resources/guild#modify-guild-mfa-level */
     editGuildMFALevel(guildId, options, reason) {
@@ -981,15 +989,34 @@ class Client extends node_events_1.default {
     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)),
+                prompts: options.prompts.map((prompt) => ({
+                    id: prompt.id,
+                    type: prompt.type,
+                    options: prompt.options.map((promptOption) => ({
+                        id: promptOption.id,
+                        channel_ids: promptOption.channelIds,
+                        role_ids: promptOption.roleIds,
+                        emoji: promptOption.emoji !== undefined
+                            ? this.util.emojiToRaw(promptOption.emoji)
+                            : undefined,
+                        emoji_id: promptOption.emojiId,
+                        emoji_name: promptOption.emojiName,
+                        emoji_animated: promptOption.emojiAnimated,
+                        title: promptOption.title,
+                        description: promptOption.description,
+                    })),
+                    title: prompt.id,
+                    single_select: prompt.id,
+                    required: prompt.id,
+                    in_onboarding: prompt.id,
+                })),
             },
             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), {
+    async editGuildRole(guildId, roleId, options, reason) {
+        const response = await this.rest.request(rest_1.RESTMethods.Patch, rest_1.Endpoints.guildRole(guildId, roleId), {
             json: {
                 name: options?.name,
                 permissions: options?.permissions,
@@ -1000,21 +1027,19 @@ class Client extends node_events_1.default {
                 mentionable: options?.mentionable,
             },
             reason,
-        })
-            .then((response) => this.util.toCamelCase(response));
+        });
+        return this.util.roleFromRaw(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)));
+    async editGuildRolePositions(guildId, options) {
+        const response = await this.rest.request(rest_1.RESTMethods.Patch, rest_1.Endpoints.guildRoles(guildId), {
+            json: options,
+        });
+        return response.map((role) => this.util.roleFromRaw(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), {
+    async editGuildScheduledEvent(guildId, guildScheduledEventId, options, reason) {
+        const response = await this.rest.request(rest_1.RESTMethods.Patch, rest_1.Endpoints.guildScheduledEvent(guildId, guildScheduledEventId), {
             json: {
                 channel_id: options.channelId,
                 entity_metadata: options.entityMetadata,
@@ -1028,159 +1053,171 @@ class Client extends node_events_1.default {
                 image: options.image,
             },
             reason,
-        })
-            .then((response) => this.util.toCamelCase(response));
+        });
+        return this.util.guildScheduledEventFromRaw(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), {
+    async editGuildSticker(guildId, stickerId, options, reason) {
+        const response = await 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));
+        });
+        return this.util.stickerFromRaw(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), {
+    async editGuildTemplate(guildId, code, options) {
+        const response = await 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));
+        });
+        return this.util.guildTemplateFromRaw(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), {
+    async editGuildWelcomeScreen(guildId, options, reason) {
+        const response = await 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));
+        });
+        return {
+            description: response.description,
+            welcomeChannels: response.welcome_channels.map((welcomeScreenChannel) => ({
+                channelId: welcomeScreenChannel.channel_id,
+                description: welcomeScreenChannel.description,
+                emojiId: welcomeScreenChannel.emoji_id,
+                emojiName: welcomeScreenChannel.emoji_name,
+            })),
+        };
     }
     /** 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), {
+    async editGuildWidget(guildId, options, reason) {
+        const response = await 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));
+        });
+        return {
+            enabled: response.enabled,
+            channelId: response.channel_id,
+        };
     }
     /** 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), {
+    async editMessage(channelId, messageId, options) {
+        const response = await 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,
+                embeds: options.embeds !== null
+                    ? options.embeds?.map((embed) => this.util.embedToRaw(embed))
+                    : null,
                 allowed_mentions: options.allowedMentions !== undefined
                     ? options.allowedMentions !== null
-                        ? this.util.toSnakeCase(options.allowedMentions)
+                        ? {
+                            parse: options.allowedMentions.parse,
+                            roles: options.allowedMentions.roles,
+                            users: options.allowedMentions.users,
+                            replied_user: options.allowedMentions.repliedUser,
+                        }
                         : null
                     : undefined,
                 components: options.components !== undefined
                     ? options.components !== null
-                        ? options.components.map((c) => this.util.toSnakeCase(c))
+                        ? this.util.messageComponentsToRaw(options.components)
                         : null
                     : undefined,
-                attachments: options.attachments?.map((attachment) => this.util.toSnakeCase(attachment)),
+                attachments: options.attachments?.map((attachment) => this.util.attachmentToRaw(attachment)),
                 flags: options.flags,
             },
             files: options.files,
-        })
-            .then((response) => this.util.toCamelCase(response));
+        });
+        return this.util.messageFromRaw(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), {
+    async editStageInstance(channelId, options, reason) {
+        const response = await 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));
+        });
+        return this.util.stageInstanceFromRaw(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), {
+    async editInteractionFollowupMessage(applicationId, interactionToken, messageId, options) {
+        const response = await 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,
+                embeds: options.embeds !== null
+                    ? options.embeds?.map((embed) => this.util.embedToRaw(embed))
+                    : null,
                 allowed_mentions: options.allowedMentions !== undefined
                     ? options.allowedMentions !== null
-                        ? this.util.toSnakeCase(options.allowedMentions)
+                        ? {
+                            parse: options.allowedMentions.parse,
+                            roles: options.allowedMentions.roles,
+                            users: options.allowedMentions.users,
+                            replied_user: options.allowedMentions.repliedUser,
+                        }
                         : null
                     : undefined,
                 components: options.components !== undefined
                     ? options.components !== null
-                        ? options.components.map((c) => this.util.toSnakeCase(c))
+                        ? this.util.messageComponentsToRaw(options.components)
                         : null
                     : undefined,
-                attachments: options.attachments?.map((attachment) => this.util.toSnakeCase(attachment)),
+                attachments: options.attachments?.map((attachment) => this.util.attachmentToRaw(attachment)),
                 flags: options.flags,
             },
             files: options.files,
             query: {
                 thread_id: options.threadId,
             },
-        })
-            .then((response) => this.util.toCamelCase(response));
+        });
+        return this.util.messageFromRaw(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), {
+    async editInteractionResponse(applicationId, interactionToken, options) {
+        const response = await 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,
+                embeds: options.embeds !== null
+                    ? options.embeds?.map((embed) => this.util.embedToRaw(embed))
+                    : null,
                 allowed_mentions: options.allowedMentions !== undefined
                     ? options.allowedMentions !== null
-                        ? this.util.toSnakeCase(options.allowedMentions)
+                        ? {
+                            parse: options.allowedMentions.parse,
+                            roles: options.allowedMentions.roles,
+                            users: options.allowedMentions.users,
+                            replied_user: options.allowedMentions.repliedUser,
+                        }
                         : null
                     : undefined,
                 components: options.components !== undefined
                     ? options.components !== null
-                        ? options.components.map((c) => this.util.toSnakeCase(c))
+                        ? this.util.messageComponentsToRaw(options.components)
                         : null
                     : undefined,
-                attachments: options.attachments?.map((attachment) => this.util.toSnakeCase(attachment)),
+                attachments: options.attachments?.map((attachment) => this.util.attachmentToRaw(attachment)),
                 flags: options.flags,
             },
             files: options.files,
             query: {
                 thread_id: options.threadId,
             },
-        })
-            .then((response) => this.util.toCamelCase(response));
+        });
+        return this.util.messageFromRaw(response);
     }
     /** https://discord.com/developers/docs/resources/guild#modify-user-voice-state */
     editUserVoiceState(guildId, userId, options) {
@@ -1193,98 +1230,108 @@ class Client extends node_events_1.default {
         });
     }
     /** 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), {
+    async editWebhook(webhookId, options, reason) {
+        const response = await 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));
+        });
+        return this.util.webhookFromRaw(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), {
+    async editWebhookMessage(webhookId, webhookToken, messageId, options) {
+        const response = await 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,
+                embeds: options.embeds !== null
+                    ? options.embeds?.map((embed) => this.util.embedToRaw(embed))
+                    : null,
                 allowed_mentions: options.allowedMentions !== undefined
                     ? options.allowedMentions !== null
-                        ? this.util.toSnakeCase(options.allowedMentions)
+                        ? {
+                            parse: options.allowedMentions.parse,
+                            roles: options.allowedMentions.roles,
+                            users: options.allowedMentions.users,
+                            replied_user: options.allowedMentions.repliedUser,
+                        }
                         : null
                     : undefined,
                 components: options.components !== undefined
                     ? options.components !== null
-                        ? options.components.map((c) => this.util.toSnakeCase(c))
+                        ? this.util.messageComponentsToRaw(options.components)
                         : null
                     : undefined,
-                attachments: options.attachments?.map((attachment) => this.util.toSnakeCase(attachment)),
+                attachments: options.attachments?.map((attachment) => this.util.attachmentToRaw(attachment)),
                 flags: options.flags,
             },
             files: options.files,
             query: {
                 thread_id: options.threadId,
             },
-        })
-            .then((response) => this.util.toCamelCase(response));
+        });
+        return this.util.messageFromRaw(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), {
+    async editWebhookWithToken(webhookId, webhookToken, options, reason) {
+        const response = await 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));
+        });
+        return this.util.webhookFromRaw(response);
     }
     /** https://discord.com/developers/docs/resources/poll#end-poll */
-    endPoll(channelId, messageId) {
-        return this.rest
-            .request(rest_1.RESTMethods.Post, rest_1.Endpoints.pollExpire(channelId, messageId))
-            .then((response) => this.util.toCamelCase(response));
+    async endPoll(channelId, messageId) {
+        const response = await this.rest.request(rest_1.RESTMethods.Post, rest_1.Endpoints.pollExpire(channelId, messageId));
+        return this.util.messageFromRaw(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), {
+    async executeWebhook(webhookId, webhookToken, options) {
+        const response = await 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,
+                embeds: options.embeds !== null
+                    ? options.embeds?.map((embed) => this.util.embedToRaw(embed))
+                    : null,
                 allowed_mentions: options.allowedMentions !== undefined
                     ? options.allowedMentions !== null
-                        ? this.util.toSnakeCase(options.allowedMentions)
+                        ? {
+                            parse: options.allowedMentions.parse,
+                            roles: options.allowedMentions.roles,
+                            users: options.allowedMentions.users,
+                            replied_user: options.allowedMentions.repliedUser,
+                        }
                         : null
                     : undefined,
                 components: options.components !== undefined
                     ? options.components !== null
-                        ? options.components.map((c) => this.util.toSnakeCase(c))
+                        ? this.util.messageComponentsToRaw(options.components)
                         : null
                     : undefined,
-                attachments: options.attachments?.map((attachment) => this.util.toSnakeCase(attachment)),
+                attachments: options.attachments?.map((attachment) => this.util.attachmentToRaw(attachment)),
                 flags: options.flags,
                 thread_name: options.threadName,
                 applied_tags: options.appliedTags,
                 poll: options.poll !== undefined
-                    ? this.util.toSnakeCase(options.poll)
+                    ? {
+                        question: options.poll.question,
+                        answers: options.poll.answers.map((answer) => ({
+                            answer_id: answer.answerId,
+                            poll_media: answer.pollMedia,
+                        })),
+                        duration: options.poll.duration,
+                        allow_multiselect: options.poll.allowMultiselect,
+                        layout_type: options.poll.layoutType,
+                    }
                     : undefined,
             },
             files: options.files,
@@ -1292,57 +1339,78 @@ class Client extends node_events_1.default {
                 wait: options.wait,
                 thread_id: options.threadId,
             },
-        })
-            .then((response) => response !== null ? this.util.toCamelCase(response) : null);
+        });
+        return response !== null ? this.util.messageFromRaw(response) : response;
     }
     /**
      * 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), {
+    async executeWebhookPlatform(webhookId, webhookToken, platform, options) {
+        const response = await this.rest.request(rest_1.RESTMethods.Post, rest_1.Endpoints.webhookPlatform(webhookId, webhookToken, platform), {
             query: {
                 thread_id: options.threadId,
                 wait: options.wait,
             },
             json: options,
-        })
-            .then((response) => response !== null ? this.util.toCamelCase(response) : null);
+        });
+        return response !== null ? this.util.messageFromRaw(response) : null;
     }
     /** https://discord.com/developers/docs/resources/channel#follow-announcement-channel */
-    followChannel(channelId, options, reason) {
-        return this.rest
-            .request(rest_1.RESTMethods.Post, rest_1.Endpoints.channelFollowers(channelId), {
+    async followChannel(channelId, options, reason) {
+        const response = await this.rest.request(rest_1.RESTMethods.Post, rest_1.Endpoints.channelFollowers(channelId), {
             json: {
                 webhook_channel_id: options.webhookChannelId,
             },
             reason,
-        })
-            .then((response) => this.util.toCamelCase(response));
+        });
+        return {
+            channelId: response.channel_id,
+            webhookId: response.webhook_id,
+        };
     }
     /** 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));
+    async getActiveGuildThreads(guildId) {
+        const response = await this.rest.request(rest_1.RESTMethods.Get, rest_1.Endpoints.guildActiveThreads(guildId));
+        return {
+            threads: response.threads.map((thread) => this.util.channelFromRaw(thread)),
+            members: response.members.map((threadMember) => ({
+                id: threadMember.id,
+                userId: threadMember.user_id,
+                joinTimestamp: threadMember.join_timestamp,
+                flags: threadMember.flags,
+                member: threadMember.member !== undefined
+                    ? this.util.guildMemberFromRaw(threadMember.member)
+                    : undefined,
+            })),
+        };
     }
     /** 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), {
+    async getArchivedThreads(channelId, archivedStatus, options) {
+        const response = await 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));
+        });
+        return {
+            threads: response.threads.map((thread) => this.util.channelFromRaw(thread)),
+            members: response.members.map((threadMember) => ({
+                id: threadMember.id,
+                userId: threadMember.user_id,
+                joinTimestamp: threadMember.join_timestamp,
+                flags: threadMember.flags,
+                member: threadMember.member !== undefined
+                    ? this.util.guildMemberFromRaw(threadMember.member)
+                    : undefined,
+            })),
+            hasMore: response.has_more,
+        };
     }
     /** 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), {
+    async getAuditLog(guildId, options) {
+        const response = await this.rest.request(rest_1.RESTMethods.Get, rest_1.Endpoints.guildAuditLog(guildId), {
             query: {
                 user_id: options?.userId,
                 action_type: options?.actionType,
@@ -1350,85 +1418,110 @@ class Client extends node_events_1.default {
                 after: options?.after,
                 limit: options?.limit,
             },
-        })
-            .then((response) => this.util.toCamelCase(response));
+        });
+        return this.util.auditLogFromRaw(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));
+    async getAutoModerationRule(guildId, ruleId) {
+        const response = await this.rest.request(rest_1.RESTMethods.Get, rest_1.Endpoints.guildAutoModerationRule(guildId, ruleId));
+        return this.util.autoModerationRuleFromRaw(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)));
+    async getAutoModerationRules(guildId) {
+        const response = await this.rest.request(rest_1.RESTMethods.Get, rest_1.Endpoints.guildAutoModerationRules(guildId));
+        return response.map((autoModerationRule) => this.util.autoModerationRuleFromRaw(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));
+    async getApplicationCommandPermissions(applicationId, guildId, commandId) {
+        const response = await this.rest.request(rest_1.RESTMethods.Get, rest_1.Endpoints.applicationCommandPermissions(applicationId, guildId, commandId));
+        return {
+            id: response.id,
+            applicationId: response.application_id,
+            guildId: response.guild_id,
+            permissions: response.permissions.map((permission) => ({
+                id: permission.id,
+                type: permission.type,
+                permission: permission.permission,
+            })),
+        };
     }
     /** 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)));
+    async getApplicationRoleConnectionMetadataRecords(applicationId) {
+        const response = await this.rest.request(rest_1.RESTMethods.Get, rest_1.Endpoints.applicationRoleConnectionMetadata(applicationId));
+        return response.map((applicationRoleConnectionMetadata) => ({
+            type: applicationRoleConnectionMetadata.type,
+            key: applicationRoleConnectionMetadata.key,
+            name: applicationRoleConnectionMetadata.name,
+            nameLocalizations: applicationRoleConnectionMetadata.name_localizations,
+            description: applicationRoleConnectionMetadata.description,
+            descriptionLocalizations: applicationRoleConnectionMetadata.description_localizations,
+        }));
     }
     /** https://discord.com/developers/docs/resources/channel#get-channel */
-    getChannel(channelId) {
-        return this.rest
-            .request(rest_1.RESTMethods.Get, rest_1.Endpoints.channel(channelId))
-            .then((response) => this.util.toCamelCase(response));
+    async getChannel(channelId) {
+        const response = await this.rest.request(rest_1.RESTMethods.Get, rest_1.Endpoints.channel(channelId));
+        return this.util.channelFromRaw(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)));
+    async getChannels(guildId) {
+        const response = await this.rest.request(rest_1.RESTMethods.Get, rest_1.Endpoints.guildChannels(guildId));
+        return response.map((channel) => this.util.channelFromRaw(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)));
+    async getChannelInvites(channelId) {
+        const response = await this.rest.request(rest_1.RESTMethods.Get, rest_1.Endpoints.channelInvites(channelId));
+        return response.map((invite) => this.util.inviteFromRaw(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)));
+    async getChannelWebhooks(channelId) {
+        const response = await this.rest.request(rest_1.RESTMethods.Get, rest_1.Endpoints.channelWebhooks(channelId));
+        return response.map((webhook) => this.util.webhookFromRaw(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));
+    async getCurrentApplication() {
+        const response = await this.rest.request(rest_1.RESTMethods.Get, rest_1.Endpoints.applicationCurrentUser());
+        return this.util.applicationFromRaw(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));
+    async getCurrentApplicationRoleConnection(applicationId) {
+        const response = await this.rest.request(rest_1.RESTMethods.Get, rest_1.Endpoints.userApplicationRoleConnection(applicationId));
+        return {
+            platformName: response.platform_name,
+            platformUsername: response.platform_username,
+            metadata: {
+                type: response.metadata.type,
+                key: response.metadata.key,
+                name: response.metadata.name,
+                nameLocalizations: response.metadata.name_localizations,
+                description: response.metadata.description,
+                descriptionLocalizations: response.metadata.description_localizations,
+            },
+        };
     }
     /** 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));
+    async getCurrentGuildMember(guildId) {
+        const response = await this.rest.request(rest_1.RESTMethods.Get, rest_1.Endpoints.guildMember(guildId));
+        return this.util.guildMemberFromRaw(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)));
+    async getCurrentUserConnections() {
+        const response = await this.rest.request(rest_1.RESTMethods.Get, rest_1.Endpoints.userConnections());
+        return response.map((connection) => ({
+            id: connection.id,
+            name: connection.name,
+            type: connection.type,
+            revoked: connection.revoked,
+            integrations: connection.integrations?.map((integration) => this.util.integrationFromRaw(integration)),
+            verified: connection.verified,
+            friendSync: connection.friend_sync,
+            showActivity: connection.show_activity,
+            twoWayLink: connection.two_way_link,
+            visibility: connection.visibility,
+        }));
     }
     /** 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), {
+    async getEntitlements(applicationId, options) {
+        const response = await this.rest.request(rest_1.RESTMethods.Get, rest_1.Endpoints.applicationEntitlements(applicationId), {
             query: {
                 user_id: options?.userId,
                 sku_ids: options?.skuIds,
@@ -1438,231 +1531,290 @@ class Client extends node_events_1.default {
                 guild_id: options?.guildId,
                 exclude_ended: options?.excludeEnded,
             },
-        })
-            .then((response) => response.map((entitlement) => this.util.toCamelCase(entitlement)));
+        });
+        return response.map((entitlement) => this.util.entitlementFromRaw(entitlement));
     }
     /** https://discord.com/developers/docs/topics/gateway#get-gateway */
     getGateway() {
         return this.rest.request(rest_1.RESTMethods.Get, rest_1.Endpoints.gateway());
     }
     /** https://discord.com/developers/docs/topics/gateway#get-gateway-bot */
-    getGatewayBot() {
-        return this.rest
-            .request(rest_1.RESTMethods.Get, rest_1.Endpoints.gatewayBot())
-            .then((response) => this.util.toCamelCase(response));
+    async getGatewayBot() {
+        const response = await this.rest.request(rest_1.RESTMethods.Get, rest_1.Endpoints.gatewayBot());
+        return {
+            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,
+            },
+        };
     }
     /** 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));
+    async getGlobalApplicationCommand(applicationId, commandId) {
+        const response = await this.rest.request(rest_1.RESTMethods.Get, rest_1.Endpoints.applicationCommand(applicationId, commandId));
+        return this.util.applicationCommandFromRaw(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), {
+    async getGlobalApplicationCommands(applicationId, options) {
+        const response = await 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)));
+        });
+        return response.map((applicationCommand) => this.util.applicationCommandFromRaw(applicationCommand));
     }
     /** https://discord.com/developers/docs/resources/guild#get-guild */
-    getGuild(guildId, options) {
-        return this.rest
-            .request(rest_1.RESTMethods.Get, rest_1.Endpoints.guild(guildId), {
+    async getGuild(guildId, options) {
+        const response = await this.rest.request(rest_1.RESTMethods.Get, rest_1.Endpoints.guild(guildId), {
             query: {
                 with_counts: options?.withCounts,
             },
-        })
-            .then((response) => this.util.toCamelCase(response));
+        });
+        return this.util.guildFromRaw(response);
     }
     /** https://discord.com/developers/docs/resources/user#get-current-user-guilds */
-    getGuilds(options) {
-        return this.rest
-            .request(rest_1.RESTMethods.Get, rest_1.Endpoints.userGuilds(), {
+    async getGuilds(options) {
+        const response = await this.rest.request(rest_1.RESTMethods.Get, rest_1.Endpoints.userGuilds(), {
             query: {
                 before: options?.before,
                 after: options?.after,
                 limit: options?.limit,
                 with_counts: options?.withCounts,
             },
-        })
-            .then((response) => response.map((guild) => this.util.toCamelCase(guild)));
+        });
+        return response.map((guild) => this.util.guildFromRaw(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));
+    async getGuildApplicationCommand(applicationId, guildId, commandId) {
+        const response = await this.rest.request(rest_1.RESTMethods.Get, rest_1.Endpoints.applicationGuildCommand(applicationId, guildId, commandId));
+        return this.util.applicationCommandFromRaw(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), {
+    async getGuildApplicationCommands(applicationId, guildId, options) {
+        const response = await 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)));
+        });
+        return response.map((applicationCommand) => this.util.applicationCommandFromRaw(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));
+    async getGuildApplicationCommandPermissions(applicationId, guildId) {
+        const response = await this.rest.request(rest_1.RESTMethods.Get, rest_1.Endpoints.guildApplicationCommandsPermissions(applicationId, guildId));
+        return {
+            id: response.id,
+            applicationId: response.application_id,
+            guildId: response.guild_id,
+            permissions: response.permissions.map((permission) => ({
+                id: permission.id,
+                type: permission.type,
+                permission: permission.permission,
+            })),
+        };
     }
     /** 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));
+    async getGuildBan(guildId, userId) {
+        const response = await this.rest.request(rest_1.RESTMethods.Get, rest_1.Endpoints.guildBan(guildId, userId));
+        return {
+            reason: response.reason,
+            user: this.util.userFromRaw(response.user),
+        };
     }
     /** 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), {
+    async getGuildBans(guildId, options) {
+        const response = await 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)));
+        });
+        return response.map((ban) => ({
+            reason: ban.reason,
+            user: this.util.userFromRaw(ban.user),
+        }));
     }
     /** 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));
+    async getGuildEmoji(guildId, emojiId) {
+        const response = await this.rest.request(rest_1.RESTMethods.Get, rest_1.Endpoints.guildEmoji(guildId, emojiId));
+        return this.util.emojiFromRaw(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)));
+    async getGuildEmojis(guildId) {
+        const response = await this.rest.request(rest_1.RESTMethods.Get, rest_1.Endpoints.guildEmojis(guildId));
+        return response.map((emoji) => this.util.emojiFromRaw(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)));
+    async getGuildIntegrations(guildId) {
+        const response = await this.rest.request(rest_1.RESTMethods.Get, rest_1.Endpoints.guildIntegrations(guildId));
+        return response.map((integration) => this.util.integrationFromRaw(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)));
+    async getGuildInvites(guildId) {
+        const response = await this.rest.request(rest_1.RESTMethods.Get, rest_1.Endpoints.guildInvites(guildId));
+        return response.map((invite) => this.util.inviteFromRaw(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));
+    async getGuildMember(guildId, userId) {
+        const response = await this.rest.request(rest_1.RESTMethods.Get, rest_1.Endpoints.guildMember(guildId, userId));
+        return this.util.guildMemberFromRaw(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)));
+    async getGuildMembers(guildId) {
+        const response = await this.rest.request(rest_1.RESTMethods.Get, rest_1.Endpoints.guildMembers(guildId));
+        return response.map((guildMember) => this.util.guildMemberFromRaw(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));
+    async getGuildOnboarding(guildId) {
+        const response = await this.rest.request(rest_1.RESTMethods.Get, rest_1.Endpoints.guildOnboarding(guildId));
+        return {
+            guildId: response.guild_id,
+            prompts: response.prompts.map((prompt) => ({
+                id: prompt.id,
+                type: prompt.type,
+                options: prompt.options.map((promptOption) => ({
+                    id: promptOption.id,
+                    channelIds: promptOption.channel_ids,
+                    roleIds: promptOption.role_ids,
+                    emoji: promptOption.emoji !== undefined
+                        ? this.util.emojiFromRaw(promptOption.emoji)
+                        : undefined,
+                    emojiId: promptOption.emoji_id,
+                    emojiName: promptOption.emoji_name,
+                    emojiAnimated: promptOption.emoji_animated,
+                    title: promptOption.title,
+                    description: promptOption.description,
+                })),
+                title: prompt.title,
+                singleSelect: prompt.single_select,
+                required: prompt.required,
+                inOnboarding: prompt.in_onboarding,
+            })),
+            defaultChannelIds: response.default_channel_ids,
+            enabled: response.enabled,
+            mode: response.mode,
+        };
     }
     /** 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));
+    async getGuildPreview(guildId) {
+        const response = await this.rest.request(rest_1.RESTMethods.Get, rest_1.Endpoints.guildPreview(guildId));
+        return {
+            id: response.id,
+            name: response.name,
+            icon: response.icon,
+            splash: response.splash,
+            discoverySplash: response.discovery_splash,
+            emojis: response.emojis.map((emoji) => this.util.emojiFromRaw(emoji)),
+            features: response.features,
+            approximateMemberCount: response.approximate_member_count,
+            approximatePresenceCount: response.approximate_presence_count,
+            description: response.description,
+            stickers: response.stickers?.map((sticker) => this.util.stickerFromRaw(sticker)),
+        };
     }
     /** 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), {
+        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)));
+    async getGuildRoles(guildId) {
+        const response = await this.rest.request(rest_1.RESTMethods.Get, rest_1.Endpoints.guildRoles(guildId));
+        return response.map((role) => this.util.roleFromRaw(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), {
+    async getGuildScheduledEvents(guildId, options) {
+        const response = await 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)));
+        });
+        return response.map((guildScheduledEvent) => this.util.guildScheduledEventFromRaw(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), {
+    async getGuildScheduledEventUsers(guildId, guildScheduledEventId, options) {
+        const response = await 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)));
+        });
+        return response.map((guildScheduledEventUser) => ({
+            guildScheduledEventId: guildScheduledEventUser.guild_scheduled_event_id,
+            user: this.util.userFromRaw(guildScheduledEventUser.user),
+            member: guildScheduledEventUser.member !== undefined
+                ? this.util.guildMemberFromRaw(guildScheduledEventUser.member)
+                : undefined,
+        }));
     }
     /** 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));
+    async getGuildSticker(guildId, stickerId) {
+        const response = await this.rest.request(rest_1.RESTMethods.Get, rest_1.Endpoints.guildSticker(guildId, stickerId));
+        return this.util.stickerFromRaw(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)));
+    async getGuildStickers(guildId) {
+        const response = await this.rest.request(rest_1.RESTMethods.Get, rest_1.Endpoints.guildStickers(guildId));
+        return response.map((sticker) => this.util.stickerFromRaw(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));
+    async getGuildTemplate(guildId, code) {
+        const response = await this.rest.request(rest_1.RESTMethods.Get, rest_1.Endpoints.guildTemplate(guildId, code));
+        return this.util.guildTemplateFromRaw(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)));
+    async getGuildTemplates(guildId) {
+        const response = await this.rest.request(rest_1.RESTMethods.Get, rest_1.Endpoints.guildTemplates(guildId));
+        return response.map((guildTemplate) => this.util.guildTemplateFromRaw(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)));
+    async getGuildVoiceRegions(guildId) {
+        const response = await this.rest.request(rest_1.RESTMethods.Get, rest_1.Endpoints.guildVoiceRegions(guildId));
+        return response.map((voiceRegion) => ({
+            id: voiceRegion.id,
+            name: voiceRegion.name,
+            optimal: voiceRegion.optimal,
+            deprecated: voiceRegion.deprecated,
+            custom: voiceRegion.custom,
+        }));
     }
     /** 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));
+    async getGuildWelcomeScreen(guildId) {
+        const response = await this.rest.request(rest_1.RESTMethods.Get, rest_1.Endpoints.guildWelcomeScreen(guildId));
+        return {
+            description: response.description,
+            welcomeChannels: response.welcome_channels.map((welcomeScreenChannel) => ({
+                channelId: welcomeScreenChannel.channel_id,
+                description: welcomeScreenChannel.description,
+                emojiId: welcomeScreenChannel.emoji_id,
+                emojiName: welcomeScreenChannel.emoji_name,
+            })),
+        };
     }
     /** 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));
+    async getGuildWidget(guildId) {
+        const response = await this.rest.request(rest_1.RESTMethods.Get, rest_1.Endpoints.guildWidgetJSON(guildId));
+        return {
+            id: response.id,
+            name: response.name,
+            instantInvite: response.instant_invite,
+            channels: response.channels.map((channel) => this.util.channelFromRaw(channel)),
+            members: response.members.map((member) => this.util.userFromRaw(member)),
+            presenceCount: response.presence_count,
+        };
     }
     /** https://discord.com/developers/docs/resources/guild#get-guild-widget-image */
     getGuildWidgetImage(guildId, options) {
@@ -1673,181 +1825,216 @@ class Client extends node_events_1.default {
         });
     }
     /** 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));
+    async getGuildWidgetSettings(guildId) {
+        const response = await this.rest.request(rest_1.RESTMethods.Get, rest_1.Endpoints.guildWidgetSettings(guildId));
+        return {
+            enabled: response.enabled,
+            channelId: response.channel_id,
+        };
     }
     /** 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), {
+    async getInteractionFollowupMessage(applicationId, interactionToken, messageId, options) {
+        const response = await 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));
+        });
+        return this.util.messageFromRaw(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), {
+    async getInteractionResponse(applicationId, interactionToken, options) {
+        const response = await this.rest.request(rest_1.RESTMethods.Get, rest_1.Endpoints.webhookMessage(applicationId, interactionToken), {
             query: {
                 thread_id: options?.threadId,
             },
-        })
-            .then((response) => this.util.toCamelCase(response));
+        });
+        return this.util.messageFromRaw(response);
     }
     /** https://discord.com/developers/docs/resources/invite#get-invite */
-    getInvite(code, options) {
-        return this.rest
-            .request(rest_1.RESTMethods.Get, rest_1.Endpoints.invite(code), {
+    async getInvite(code, options) {
+        const response = await 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,
             },
-        })
-            .then((response) => this.util.toCamelCase(response));
+        });
+        return this.util.inviteFromRaw(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), {
+    async getJoinedPrivateArchivedThreads(channelId, options) {
+        const response = await 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));
+        });
+        return {
+            threads: response.threads.map((thread) => this.util.channelFromRaw(thread)),
+            members: response.members.map((threadMember) => ({
+                id: threadMember.id,
+                userId: threadMember.user_id,
+                joinTimestamp: threadMember.join_timestamp,
+                flags: threadMember.flags,
+                member: threadMember.member !== undefined
+                    ? this.util.guildMemberFromRaw(threadMember.member)
+                    : undefined,
+            })),
+            hasMore: response.has_more,
+        };
     }
     /** 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));
+    async getMessage(channelId, messageId) {
+        const response = await this.rest.request(rest_1.RESTMethods.Get, rest_1.Endpoints.channelMessage(channelId, messageId));
+        return this.util.messageFromRaw(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), {
+    async getMessageReactions(channelId, messageId, emoji, options) {
+        const response = await this.rest.request(rest_1.RESTMethods.Get, rest_1.Endpoints.channelMessageAllReactions(channelId, messageId, emoji), {
             query: {
                 type: options?.type,
                 after: options?.after,
                 limit: options?.limit,
             },
-        })
-            .then((response) => response.map((user) => this.util.toCamelCase(user)));
+        });
+        return response.map((user) => this.util.userFromRaw(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), {
+    async getMessages(channelId, options) {
+        const response = await 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)));
+        });
+        return response.map((message) => this.util.messageFromRaw(message));
     }
     /** https://discord.com/developers/docs/topics/oauth2#get-current-bot-application-information */
-    getOAuth2Application() {
-        return this.rest
-            .request(rest_1.RESTMethods.Get, rest_1.Endpoints.oauth2CurrentApplication())
-            .then((response) => this.util.toCamelCase(response));
+    async getOAuth2Application() {
+        const response = await this.rest.request(rest_1.RESTMethods.Get, rest_1.Endpoints.oauth2CurrentApplication());
+        return this.util.applicationFromRaw(response);
     }
     /** https://discord.com/developers/docs/topics/oauth2#get-current-authorization-information */
-    getOAuth2Authorization() {
-        return this.rest
-            .request(rest_1.RESTMethods.Get, rest_1.Endpoints.oauth2Authorization())
-            .then((response) => this.util.toCamelCase(response));
+    async getOAuth2Authorization() {
+        const response = await this.rest.request(rest_1.RESTMethods.Get, rest_1.Endpoints.oauth2Authorization());
+        return {
+            application: this.util.applicationFromRaw(response.application),
+            scopes: response.scopes,
+            expires: response.expires,
+            user: response.user !== undefined
+                ? this.util.userFromRaw(response.user)
+                : undefined,
+        };
     }
     /** 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)));
+    async getPinnedMessages(channelId) {
+        const response = await this.rest.request(rest_1.RESTMethods.Get, rest_1.Endpoints.channelPins(channelId));
+        return response.map((message) => this.util.messageFromRaw(message));
     }
     /** https://discord.com/developers/docs/resources/poll#get-answer-voters */
-    getPollAnswerVoters(channelId, messageId, answerId, options) {
-        return this.rest
-            .request(rest_1.RESTMethods.Get, rest_1.Endpoints.pollAnswerVoters(channelId, messageId, answerId), {
+    async getPollAnswerVoters(channelId, messageId, answerId, options) {
+        const response = await this.rest.request(rest_1.RESTMethods.Get, rest_1.Endpoints.pollAnswerVoters(channelId, messageId, answerId), {
             query: {
                 after: options?.after,
                 limit: options?.limit,
             },
-        })
-            .then((response) => this.util.toCamelCase(response));
+        });
+        return {
+            users: response.users.map((user) => this.util.userFromRaw(user)),
+        };
     }
     /** 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)));
+    async getSkus(applicationId) {
+        const response = await this.rest.request(rest_1.RESTMethods.Get, rest_1.Endpoints.applicationSkus(applicationId));
+        return response.map((sku) => this.util.skuFromRaw(sku));
     }
     /** https://discord.com/developers/docs/resources/stage-instance#get-stage-instance */
-    getStageInstance(channelId) {
-        return this.rest
-            .request(rest_1.RESTMethods.Get, rest_1.Endpoints.stageInstance(channelId))
-            .then((response) => this.util.toCamelCase(response));
+    async getStageInstance(channelId) {
+        const response = await this.rest.request(rest_1.RESTMethods.Get, rest_1.Endpoints.stageInstance(channelId));
+        return this.util.stageInstanceFromRaw(response);
     }
     /** https://discord.com/developers/docs/resources/sticker#list-sticker-packs */
-    getStickerPacks() {
-        return this.rest
-            .request(rest_1.RESTMethods.Get, rest_1.Endpoints.stickerPacks())
-            .then((response) => this.util.toCamelCase(response));
+    async getStickerPacks() {
+        const response = await this.rest.request(rest_1.RESTMethods.Get, rest_1.Endpoints.stickerPacks());
+        return {
+            stickerPacks: response.sticker_packs.map((stickerPack) => ({
+                id: stickerPack.id,
+                stickers: stickerPack.stickers.map((sticker) => this.util.stickerFromRaw(sticker)),
+                name: stickerPack.name,
+                skuId: stickerPack.sku_id,
+                coverStickerId: stickerPack.cover_sticker_id,
+                description: stickerPack.description,
+                bannerAssetId: stickerPack.banner_asset_id,
+            })),
+        };
     }
     /** 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), {
+    async getThreadMember(channelId, userId, options) {
+        const response = await this.rest.request(rest_1.RESTMethods.Get, rest_1.Endpoints.threadMembers(channelId, userId), {
             query: {
                 with_member: options?.withMember,
             },
-        })
-            .then((response) => this.util.toCamelCase(response));
+        });
+        return {
+            id: response.id,
+            userId: response.user_id,
+            joinTimestamp: response.join_timestamp,
+            flags: response.flags,
+            member: response.member !== undefined
+                ? this.util.guildMemberFromRaw(response.member)
+                : undefined,
+        };
     }
     /** 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), {
+    async getThreadMembers(channelId, options) {
+        const response = await 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)));
+        });
+        return response.map((threadMember) => ({
+            id: threadMember.id,
+            userId: threadMember.user_id,
+            joinTimestamp: threadMember.join_timestamp,
+            flags: threadMember.flags,
+            member: threadMember.member !== undefined
+                ? this.util.guildMemberFromRaw(threadMember.member)
+                : undefined,
+        }));
     }
     /** https://discord.com/developers/docs/resources/user#get-user */
-    getUser(userId) {
-        return this.rest
-            .request(rest_1.RESTMethods.Get, rest_1.Endpoints.user(userId))
-            .then((response) => this.util.toCamelCase(response));
+    async getUser(userId) {
+        const response = await this.rest.request(rest_1.RESTMethods.Get, rest_1.Endpoints.user(userId));
+        return this.util.userFromRaw(response);
     }
     /** https://discord.com/developers/docs/resources/voice#list-voice-regions */
-    getVoiceRegions() {
-        return this.rest
-            .request(rest_1.RESTMethods.Get, rest_1.Endpoints.voiceRegions())
-            .then((response) => response.map((voiceRegion) => this.util.toCamelCase(voiceRegion)));
+    async getVoiceRegions() {
+        const response = await this.rest.request(rest_1.RESTMethods.Get, rest_1.Endpoints.voiceRegions());
+        return response.map((voiceRegion) => ({
+            id: voiceRegion.id,
+            name: voiceRegion.name,
+            optimal: voiceRegion.optimal,
+            deprecated: voiceRegion.deprecated,
+            custom: voiceRegion.custom,
+        }));
     }
     /** 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), {
+    async getWebhookMessage(webhookId, webhookToken, messageId, options) {
+        const response = await 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));
+        });
+        return this.util.messageFromRaw(response);
     }
     /** https://discord.com/developers/docs/resources/webhook#get-guild-webhooks */
-    getWebhooks(guildId) {
-        return this.rest
-            .request(rest_1.RESTMethods.Get, rest_1.Endpoints.guildWebhooks(guildId))
-            .then((response) => response.map((webhook) => this.util.toCamelCase(webhook)));
+    async getWebhooks(guildId) {
+        const response = await this.rest.request(rest_1.RESTMethods.Get, rest_1.Endpoints.guildWebhooks(guildId));
+        return response.map((webhook) => this.util.webhookFromRaw(webhook));
     }
     /** https://discord.com/developers/docs/resources/channel#join-thread */
     joinThread(channelId) {
@@ -1918,15 +2105,14 @@ class Client extends node_events_1.default {
         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), {
+    async searchGuildMembers(guildId, options) {
+        const response = await 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)));
+        });
+        return response.map((guildMember) => this.util.guildMemberFromRaw(guildMember));
     }
     /** https://discord.com/developers/docs/topics/gateway-events#update-presence */
     setPresence(options) {
@@ -1934,32 +2120,47 @@ class Client extends node_events_1.default {
             shard.setPresence(options);
     }
     /** 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));
+    async syncGuildTemplate(guildId, code) {
+        const response = await this.rest.request(rest_1.RESTMethods.Put, rest_1.Endpoints.guildTemplate(guildId, code));
+        return this.util.guildTemplateFromRaw(response);
     }
     /** 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)));
+    async updateApplicationRoleConnectionMetadataRecords(applicationId) {
+        const response = await this.rest.request(rest_1.RESTMethods.Put, rest_1.Endpoints.applicationRoleConnectionMetadata(applicationId));
+        return response.map((applicationRoleConnectionMetadata) => ({
+            type: applicationRoleConnectionMetadata.type,
+            key: applicationRoleConnectionMetadata.key,
+            name: applicationRoleConnectionMetadata.name,
+            nameLocalizations: applicationRoleConnectionMetadata.name_localizations,
+            description: applicationRoleConnectionMetadata.description,
+            descriptionLocalizations: applicationRoleConnectionMetadata.description_localizations,
+        }));
     }
     /** 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), {
+    async updateCurrentApplicationRoleConnection(options) {
+        const response = await 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));
+        });
+        return {
+            platformName: response.platform_name,
+            platformUsername: response.platform_username,
+            metadata: {
+                type: response.metadata.type,
+                key: response.metadata.key,
+                name: response.metadata.name,
+                nameLocalizations: response.metadata.name_localizations,
+                description: response.metadata.description,
+                descriptionLocalizations: response.metadata.description_localizations,
+            },
+        };
     }
     /** https://discord.com/developers/docs/resources/channel#unpin-message */
     unpinMessage(channelId, messageId, reason) {