@discordeno/bot 19.0.0-next.8bb91fa → 19.0.0-next.8d1ba2a

package/dist/helpers.js

@@ -0,0 +1,553 @@
+import { snakelize } from '@discordeno/utils';
+export function createBotHelpers(bot) {
+    return {
+        createAutomodRule: async (guildId, options, reason)=>{
+            return bot.transformers.automodRule(bot, snakelize(await bot.rest.createAutomodRule(guildId, options, reason)));
+        },
+        createChannel: async (guildId, options, reason)=>{
+            return bot.transformers.channel(bot, {
+                channel: snakelize(await bot.rest.createChannel(guildId, options, reason)),
+                guildId
+            });
+        },
+        createEmoji: async (guildId, options, reason)=>{
+            return bot.transformers.emoji(bot, snakelize(await bot.rest.createEmoji(guildId, options, reason)));
+        },
+        createForumThread: async (channelId, options, reason)=>{
+            return bot.transformers.channel(bot, {
+                channel: snakelize(await bot.rest.createForumThread(channelId, options, reason))
+            });
+        },
+        createGlobalApplicationCommand: async (command)=>{
+            return bot.transformers.applicationCommand(bot, snakelize(await bot.rest.createGlobalApplicationCommand(command)));
+        },
+        createGuild: async (options)=>{
+            return bot.transformers.guild(bot, {
+                guild: snakelize(await bot.rest.createGuild(options)),
+                shardId: 0
+            });
+        },
+        createGuildApplicationCommand: async (command, guildId)=>{
+            return bot.transformers.applicationCommand(bot, snakelize(await bot.rest.createGuildApplicationCommand(command, guildId)));
+        },
+        createGuildFromTemplate: async (templateCode, options)=>{
+            return bot.transformers.guild(bot, {
+                guild: snakelize(await bot.rest.createGuildFromTemplate(templateCode, options)),
+                shardId: 0
+            });
+        },
+        createGuildSticker: async (guildId, options, reason)=>{
+            return bot.transformers.sticker(bot, snakelize(await bot.rest.createGuildSticker(guildId, options, reason)));
+        },
+        createGuildTemplate: async (guildId, options)=>{
+            return bot.transformers.template(bot, snakelize(await bot.rest.createGuildTemplate(guildId, options)));
+        },
+        createInvite: async (channelId, options, reason)=>{
+            return await bot.rest.createInvite(channelId, options, reason);
+        },
+        createRole: async (guildId, options, reason)=>{
+            return bot.transformers.role(bot, {
+                role: snakelize(await bot.rest.createRole(guildId, options, reason)),
+                guildId
+            });
+        },
+        createScheduledEvent: async (guildId, options, reason)=>{
+            return bot.transformers.scheduledEvent(bot, snakelize(await bot.rest.createScheduledEvent(guildId, options, reason)));
+        },
+        createStageInstance: async (options, reason)=>{
+            return bot.transformers.stageInstance(bot, snakelize(await bot.rest.createStageInstance(options, reason)));
+        },
+        createWebhook: async (channelId, options, reason)=>{
+            return bot.transformers.webhook(bot, snakelize(await bot.rest.createWebhook(channelId, options, reason)));
+        },
+        editApplicationCommandPermissions: async (guildId, commandId, bearerToken, options)=>{
+            return bot.transformers.applicationCommandPermission(bot, snakelize(await bot.rest.editApplicationCommandPermissions(guildId, commandId, bearerToken, options)));
+        },
+        editAutomodRule: async (guildId, ruleId, options, reason)=>{
+            return bot.transformers.automodRule(bot, snakelize(await bot.rest.editAutomodRule(guildId, ruleId, options, reason)));
+        },
+        editBotProfile: async (options)=>{
+            return bot.transformers.user(bot, snakelize(await bot.rest.editBotProfile(options)));
+        },
+        editChannel: async (channelId, options, reason)=>{
+            return bot.transformers.channel(bot, {
+                channel: snakelize(await bot.rest.editChannel(channelId, options, reason))
+            });
+        },
+        editEmoji: async (guildId, id, options, reason)=>{
+            return bot.transformers.emoji(bot, snakelize(await bot.rest.editEmoji(guildId, id, options, reason)));
+        },
+        editFollowupMessage: async (token, messageId, options)=>{
+            return bot.transformers.message(bot, snakelize(await bot.rest.editFollowupMessage(token, messageId, options)));
+        },
+        editGlobalApplicationCommand: async (commandId, options)=>{
+            return bot.transformers.applicationCommand(bot, snakelize(await bot.rest.editGlobalApplicationCommand(commandId, options)));
+        },
+        editGuild: async (guildId, options, reason)=>{
+            return bot.transformers.guild(bot, {
+                guild: snakelize(await bot.rest.editGuild(guildId, options, reason)),
+                shardId: 0
+            });
+        },
+        editGuildApplicationCommand: async (commandId, guildId, options)=>{
+            return bot.transformers.applicationCommand(bot, snakelize(await bot.rest.editGuildApplicationCommand(commandId, guildId, options)));
+        },
+        editGuildSticker: async (guildId, stickerId, options, reason)=>{
+            return bot.transformers.sticker(bot, snakelize(await bot.rest.editGuildSticker(guildId, stickerId, options, reason)));
+        },
+        editGuildTemplate: async (guildId, templateCode, options)=>{
+            return bot.transformers.template(bot, snakelize(await bot.rest.editGuildTemplate(guildId, templateCode, options)));
+        },
+        editMessage: async (channelId, messageId, options)=>{
+            return bot.transformers.message(bot, snakelize(await bot.rest.editMessage(channelId, messageId, options)));
+        },
+        editOriginalInteractionResponse: async (token, options)=>{
+            const result = await bot.rest.editOriginalInteractionResponse(token, options);
+            if (!result) return;
+            return bot.transformers.message(bot, snakelize(result));
+        },
+        editOriginalWebhookMessage: async (webhookId, token, options)=>{
+            return bot.transformers.message(bot, snakelize(await bot.rest.editOriginalWebhookMessage(webhookId, token, options)));
+        },
+        editRole: async (guildId, roleId, options, reason)=>{
+            return bot.transformers.role(bot, {
+                role: snakelize(await bot.rest.editRole(guildId, roleId, options, reason)),
+                guildId
+            });
+        },
+        editRolePositions: async (guildId, options, reason)=>{
+            return snakelize(await bot.rest.editRolePositions(guildId, options, reason)).map((role)=>bot.transformers.role(bot, {
+                    role,
+                    guildId
+                }));
+        },
+        editScheduledEvent: async (guildId, eventId, options, reason)=>{
+            return bot.transformers.scheduledEvent(bot, snakelize(await bot.rest.editScheduledEvent(guildId, eventId, options, reason)));
+        },
+        editStageInstance: async (channelId, topic, reason)=>{
+            return bot.transformers.stageInstance(bot, snakelize(await bot.rest.editStageInstance(channelId, topic, reason)));
+        },
+        editWebhook: async (webhookId, options, reason)=>{
+            return bot.transformers.webhook(bot, snakelize(await bot.rest.editWebhook(webhookId, options, reason)));
+        },
+        editWebhookMessage: async (webhookId, token, messageId, options)=>{
+            return bot.transformers.message(bot, snakelize(await bot.rest.editWebhookMessage(webhookId, token, messageId, options)));
+        },
+        editWebhookWithToken: async (webhookId, token, options)=>{
+            return bot.transformers.webhook(bot, snakelize(await bot.rest.editWebhookWithToken(webhookId, token, options)));
+        },
+        editWelcomeScreen: async (guildId, options, reason)=>{
+            return bot.transformers.welcomeScreen(bot, snakelize(await bot.rest.editWelcomeScreen(guildId, options, reason)));
+        },
+        editWidgetSettings: async (guildId, options, reason)=>{
+            return bot.transformers.widgetSettings(bot, snakelize(await bot.rest.editWidgetSettings(guildId, options, reason)));
+        },
+        executeWebhook: async (webhookId, token, options)=>{
+            const result = await bot.rest.executeWebhook(webhookId, token, options);
+            if (!result) return;
+            return bot.transformers.message(bot, snakelize(result));
+        },
+        followAnnouncement: async (sourceChannelId, targetChannelId)=>{
+            return await bot.rest.followAnnouncement(sourceChannelId, targetChannelId);
+        },
+        getActiveThreads: async (guildId)=>{
+            return await bot.rest.getActiveThreads(guildId);
+        },
+        getApplicationInfo: async ()=>{
+            return bot.transformers.application(bot, snakelize(await bot.rest.getApplicationInfo()));
+        },
+        getApplicationCommandPermission: async (guildId, commandId)=>{
+            return bot.transformers.applicationCommandPermission(bot, snakelize(await bot.rest.getApplicationCommandPermission(guildId, commandId)));
+        },
+        getApplicationCommandPermissions: async (guildId)=>{
+            return (await bot.rest.getApplicationCommandPermissions(guildId)).map((res)=>bot.transformers.applicationCommandPermission(bot, snakelize(res)));
+        },
+        getAuditLog: async (guildId, options)=>{
+            return await bot.rest.getAuditLog(guildId, options);
+        },
+        getAutomodRule: async (guildId, ruleId)=>{
+            return bot.transformers.automodRule(bot, snakelize(await bot.rest.getAutomodRule(guildId, ruleId)));
+        },
+        getAutomodRules: async (guildId)=>{
+            return (await bot.rest.getAutomodRules(guildId)).map((res)=>bot.transformers.automodRule(bot, snakelize(res)));
+        },
+        getAvailableVoiceRegions: async ()=>{
+            return (await bot.rest.getAvailableVoiceRegions()).map((res)=>bot.transformers.voiceRegion(bot, snakelize(res)));
+        },
+        getBan: async (guildId, userId)=>{
+            return await bot.rest.getBan(guildId, userId);
+        },
+        getBans: async (guildId, options)=>{
+            return await bot.rest.getBans(guildId, options);
+        },
+        getChannel: async (channelId)=>{
+            return bot.transformers.channel(bot, {
+                channel: snakelize(await bot.rest.getChannel(channelId))
+            });
+        },
+        getChannelInvites: async (channelId)=>{
+            return await bot.rest.getChannelInvites(channelId);
+        // return (await bot.rest.getChannelInvites(channelId)).map((res) => bot.transformers.invite(bot, snakelize(res)))
+        },
+        getChannels: async (guildId)=>{
+            return (await bot.rest.getChannels(guildId)).map((res)=>bot.transformers.channel(bot, {
+                    channel: snakelize(res),
+                    guildId
+                }));
+        },
+        getChannelWebhooks: async (channelId)=>{
+            return (await bot.rest.getChannelWebhooks(channelId)).map((res)=>bot.transformers.webhook(bot, snakelize(res)));
+        },
+        getDmChannel: async (userId)=>{
+            return bot.transformers.channel(bot, {
+                channel: snakelize(await bot.rest.getDmChannel(userId))
+            });
+        },
+        getEmoji: async (guildId, emojiId)=>{
+            return bot.transformers.emoji(bot, snakelize(await bot.rest.getEmoji(guildId, emojiId)));
+        },
+        getEmojis: async (guildId)=>{
+            return (await bot.rest.getEmojis(guildId)).map((res)=>bot.transformers.emoji(bot, snakelize(res)));
+        },
+        getFollowupMessage: async (token, messageId)=>{
+            return bot.transformers.message(bot, snakelize(await bot.rest.getFollowupMessage(token, messageId)));
+        },
+        getGatewayBot: async ()=>{
+            return bot.transformers.gatewayBot(snakelize(await bot.rest.getGatewayBot()));
+        },
+        getGlobalApplicationCommand: async (commandId)=>{
+            return bot.transformers.applicationCommand(bot, snakelize(await bot.rest.getGlobalApplicationCommand(commandId)));
+        },
+        getGlobalApplicationCommands: async ()=>{
+            return (await bot.rest.getGlobalApplicationCommands()).map((res)=>bot.transformers.applicationCommand(bot, snakelize(res)));
+        },
+        getGuild: async (guildId, options)=>{
+            return bot.transformers.guild(bot, {
+                guild: snakelize(await bot.rest.getGuild(guildId, options)),
+                shardId: 0
+            });
+        },
+        getGuildApplicationCommand: async (commandId, guildId)=>{
+            return bot.transformers.applicationCommand(bot, snakelize(await bot.rest.getGuildApplicationCommand(commandId, guildId)));
+        },
+        getGuildApplicationCommands: async (guildId)=>{
+            return (await bot.rest.getGuildApplicationCommands(guildId)).map((res)=>bot.transformers.applicationCommand(bot, snakelize(res)));
+        },
+        getGuildPreview: async (guildId)=>{
+            return await bot.rest.getGuildPreview(guildId);
+        // return bot.transformers.xxx(bot, snakelize(await bot.rest.getGuildPreview(guildId)))
+        },
+        getGuildSticker: async (guildId, stickerId)=>{
+            return bot.transformers.sticker(bot, snakelize(await bot.rest.getGuildSticker(guildId, stickerId)));
+        },
+        getGuildStickers: async (guildId)=>{
+            return (await bot.rest.getGuildStickers(guildId)).map((res)=>bot.transformers.sticker(bot, snakelize(res)));
+        },
+        getGuildTemplate: async (templateCode)=>{
+            return bot.transformers.template(bot, snakelize(await bot.rest.getGuildTemplate(templateCode)));
+        },
+        getGuildTemplates: async (guildId)=>{
+            return (await bot.rest.getGuildTemplates(guildId)).map((res)=>bot.transformers.template(bot, snakelize(res)));
+        },
+        getGuildWebhooks: async (guildId)=>{
+            return (await bot.rest.getGuildWebhooks(guildId)).map((res)=>bot.transformers.webhook(bot, snakelize(res)));
+        },
+        getIntegrations: async (guildId)=>{
+            return (await bot.rest.getIntegrations(guildId)).map((res)=>bot.transformers.integration(bot, snakelize({
+                    ...res,
+                    guildId: guildId.toString()
+                })));
+        },
+        getInvite: async (inviteCode, options)=>{
+            return await bot.rest.getInvite(inviteCode, options);
+        // return bot.transformers.invite(bot, snakelize(await bot.rest.getInvite(inviteCode, options)))
+        },
+        getInvites: async (guildId)=>{
+            return await bot.rest.getInvites(guildId);
+        // .map((res) => bot.transformers.invite(bot, snakelize(res)))
+        },
+        getMessage: async (channelId, messageId)=>{
+            return bot.transformers.message(bot, snakelize(await bot.rest.getMessage(channelId, messageId)));
+        },
+        getMessages: async (channelId, options)=>{
+            return (await bot.rest.getMessages(channelId, options)).map((res)=>bot.transformers.message(bot, snakelize(res)));
+        },
+        getNitroStickerPacks: async ()=>{
+            return (await bot.rest.getNitroStickerPacks()).map((res)=>bot.transformers.stickerPack(bot, snakelize(res)));
+        },
+        getOriginalInteractionResponse: async (token)=>{
+            return bot.transformers.message(bot, snakelize(await bot.rest.getOriginalInteractionResponse(token)));
+        },
+        getPinnedMessages: async (channelId)=>{
+            return (await bot.rest.getPinnedMessages(channelId)).map((res)=>bot.transformers.message(bot, snakelize(res)));
+        },
+        getPrivateArchivedThreads: async (channelId, options)=>{
+            return await bot.rest.getPrivateArchivedThreads(channelId, options);
+        // return bot.transformers.xxx(bot, snakelize(await bot.rest.getPrivateArchivedThreads(channelId, options)))
+        },
+        getPrivateJoinedArchivedThreads: async (channelId, options)=>{
+            return await bot.rest.getPrivateJoinedArchivedThreads(channelId, options);
+        // return bot.transformers.xxx(bot, snakelize(await bot.rest.getPrivateJoinedArchivedThreads(channelId, options)))
+        },
+        getPruneCount: async (guildId, options)=>{
+            return await bot.rest.getPruneCount(guildId, options);
+        // return bot.transformers.xxx(bot, snakelize(await bot.rest.getPruneCount(guildId, options)))
+        },
+        getPublicArchivedThreads: async (channelId, options)=>{
+            return await bot.rest.getPublicArchivedThreads(channelId, options);
+        // return bot.transformers.xxx(bot, snakelize(await bot.rest.getPublicArchivedThreads(channelId, options)))
+        },
+        getRoles: async (guildId)=>{
+            return snakelize(await bot.rest.getRoles(guildId)).map((role)=>bot.transformers.role(bot, {
+                    role,
+                    guildId
+                }));
+        },
+        getScheduledEvent: async (guildId, eventId, options)=>{
+            return bot.transformers.scheduledEvent(bot, snakelize(await bot.rest.getScheduledEvent(guildId, eventId, options)));
+        },
+        getScheduledEvents: async (guildId, options)=>{
+            return (await bot.rest.getScheduledEvents(guildId, options)).map((res)=>bot.transformers.scheduledEvent(bot, snakelize(res)));
+        },
+        getScheduledEventUsers: async (guildId, eventId, options)=>{
+            return (await bot.rest.getScheduledEventUsers(guildId, eventId, options)).map((u)=>{
+                return {
+                    user: bot.transformers.user(bot, snakelize(u.user)),
+                    member: u.member && bot.transformers.member(bot, snakelize(u.member), guildId, bot.transformers.snowflake(u.user.id))
+                };
+            });
+        },
+        getSessionInfo: async ()=>{
+            return bot.transformers.gatewayBot(snakelize(await bot.rest.getSessionInfo()));
+        },
+        getStageInstance: async (channelId)=>{
+            return bot.transformers.stageInstance(bot, snakelize(await bot.rest.getStageInstance(channelId)));
+        },
+        getSticker: async (stickerId)=>{
+            return bot.transformers.sticker(bot, snakelize(await bot.rest.getSticker(stickerId)));
+        },
+        getThreadMember: async (channelId, userId)=>{
+            return bot.transformers.threadMember(bot, snakelize(await bot.rest.getThreadMember(channelId, userId)));
+        },
+        getThreadMembers: async (channelId)=>{
+            return (await bot.rest.getThreadMembers(channelId)).map((res)=>bot.transformers.threadMember(bot, snakelize(res)));
+        },
+        getReactions: async (channelId, messageId, reaction, options)=>{
+            return (await bot.rest.getReactions(channelId, messageId, reaction, options)).map((res)=>bot.transformers.user(bot, snakelize(res)));
+        },
+        getUser: async (id)=>{
+            return bot.transformers.user(bot, snakelize(await bot.rest.getUser(id)));
+        },
+        getVanityUrl: async (guildId)=>{
+            return await bot.rest.getVanityUrl(guildId);
+        },
+        getVoiceRegions: async (guildId)=>{
+            return (await bot.rest.getVoiceRegions(guildId)).map((res)=>bot.transformers.voiceRegion(bot, snakelize(res)));
+        },
+        getWebhook: async (webhookId)=>{
+            return bot.transformers.webhook(bot, snakelize(await bot.rest.getWebhook(webhookId)));
+        },
+        getWebhookMessage: async (webhookId, token, messageId, options)=>{
+            return bot.transformers.message(bot, snakelize(await bot.rest.getWebhookMessage(webhookId, token, messageId, options)));
+        },
+        getWebhookWithToken: async (webhookId, token)=>{
+            return bot.transformers.webhook(bot, snakelize(await bot.rest.getWebhookWithToken(webhookId, token)));
+        },
+        getWelcomeScreen: async (guildId)=>{
+            return bot.transformers.welcomeScreen(bot, snakelize(await bot.rest.getWelcomeScreen(guildId)));
+        },
+        getWidget: async (guildId)=>{
+            return bot.transformers.widget(bot, snakelize(await bot.rest.getWidget(guildId)));
+        },
+        getWidgetSettings: async (guildId)=>{
+            return bot.transformers.widgetSettings(bot, snakelize(await bot.rest.getWidgetSettings(guildId)));
+        },
+        publishMessage: async (channelId, messageId)=>{
+            return bot.transformers.message(bot, snakelize(await bot.rest.publishMessage(channelId, messageId)));
+        },
+        sendMessage: async (channelId, options)=>{
+            return bot.transformers.message(bot, snakelize(await bot.rest.sendMessage(channelId, options)));
+        },
+        sendFollowupMessage: async (token, options)=>{
+            return bot.transformers.message(bot, snakelize(await bot.rest.sendFollowupMessage(token, options)));
+        },
+        startThreadWithMessage: async (channelId, messageId, options, reason)=>{
+            return bot.transformers.channel(bot, {
+                channel: snakelize(await bot.rest.startThreadWithMessage(channelId, messageId, options, reason))
+            });
+        },
+        startThreadWithoutMessage: async (channelId, options, reason)=>{
+            return bot.transformers.channel(bot, {
+                channel: snakelize(await bot.rest.startThreadWithoutMessage(channelId, options, reason))
+            });
+        },
+        syncGuildTemplate: async (guildId)=>{
+            return bot.transformers.template(bot, snakelize(await bot.rest.syncGuildTemplate(guildId)));
+        },
+        upsertGlobalApplicationCommands: async (commands)=>{
+            return (await bot.rest.upsertGlobalApplicationCommands(commands)).map((res)=>bot.transformers.applicationCommand(bot, snakelize(res)));
+        },
+        upsertGuildApplicationCommands: async (guildId, commands)=>{
+            return (await bot.rest.upsertGuildApplicationCommands(guildId, commands)).map((res)=>bot.transformers.applicationCommand(bot, snakelize(res)));
+        },
+        editBotMember: async (guildId, options, reason)=>{
+            return bot.transformers.member(bot, snakelize(await bot.rest.editBotMember(guildId, options, reason)), guildId, bot.id);
+        },
+        editMember: async (guildId, userId, options, reason)=>{
+            return bot.transformers.member(bot, snakelize(await bot.rest.editMember(guildId, userId, options, reason)), guildId, userId);
+        },
+        getMember: async (guildId, userId)=>{
+            return bot.transformers.member(bot, snakelize(await bot.rest.getMember(guildId, userId)), guildId, userId);
+        },
+        getMembers: async (guildId, options)=>{
+            return (await bot.rest.getMembers(guildId, options)).map((res)=>bot.transformers.member(bot, snakelize(res), guildId, bot.transformers.snowflake(res.user.id)));
+        },
+        pruneMembers: async (guildId, options, reason)=>{
+            return await bot.rest.pruneMembers(guildId, options, reason);
+        },
+        searchMembers: async (guildId, query, options)=>{
+            return (await bot.rest.searchMembers(guildId, query, options)).map((res)=>bot.transformers.member(bot, snakelize(res), guildId, bot.transformers.snowflake(res.user.id)));
+        },
+        // All useless void return functions here
+        addReaction: async (channelId, messageId, reaction)=>{
+            return await bot.rest.addReaction(channelId, messageId, reaction);
+        },
+        addReactions: async (channelId, messageId, reactions, ordered)=>{
+            return await bot.rest.addReactions(channelId, messageId, reactions, ordered);
+        },
+        addRole: async (guildId, userId, roleId, reason)=>{
+            return await bot.rest.addRole(guildId, userId, roleId, reason);
+        },
+        addThreadMember: async (channelId, userId)=>{
+            return await bot.rest.addThreadMember(channelId, userId);
+        },
+        deleteAutomodRule: async (guildId, ruleId, reason)=>{
+            return await bot.rest.deleteAutomodRule(guildId, ruleId, reason);
+        },
+        deleteChannel: async (channelId, reason)=>{
+            return await bot.rest.deleteChannel(channelId, reason);
+        },
+        deleteChannelPermissionOverride: async (channelId, overwriteId, reason)=>{
+            return await bot.rest.deleteChannelPermissionOverride(channelId, overwriteId, reason);
+        },
+        deleteEmoji: async (guildId, id, reason)=>{
+            return await bot.rest.deleteEmoji(guildId, id, reason);
+        },
+        deleteFollowupMessage: async (token, messageId)=>{
+            return await bot.rest.deleteFollowupMessage(token, messageId);
+        },
+        deleteGlobalApplicationCommand: async (commandId)=>{
+            return await bot.rest.deleteGlobalApplicationCommand(commandId);
+        },
+        deleteGuild: async (guildId)=>{
+            return await bot.rest.deleteGuild(guildId);
+        },
+        deleteGuildApplicationCommand: async (commandId, guildId)=>{
+            return await bot.rest.deleteGuildApplicationCommand(commandId, guildId);
+        },
+        deleteGuildSticker: async (guildId, stickerId, reason)=>{
+            return await bot.rest.deleteGuildSticker(guildId, stickerId, reason);
+        },
+        deleteGuildTemplate: async (guildId, templateCode)=>{
+            return await bot.rest.deleteGuildTemplate(guildId, templateCode);
+        },
+        deleteIntegration: async (guildId, integrationId, reason)=>{
+            return await bot.rest.deleteIntegration(guildId, integrationId, reason);
+        },
+        deleteInvite: async (inviteCode, reason)=>{
+            return await bot.rest.deleteInvite(inviteCode, reason);
+        },
+        deleteMessage: async (channelId, messageId, reason)=>{
+            return await bot.rest.deleteMessage(channelId, messageId, reason);
+        },
+        deleteMessages: async (channelId, messageIds, reason)=>{
+            return await bot.rest.deleteMessages(channelId, messageIds, reason);
+        },
+        deleteOriginalInteractionResponse: async (token)=>{
+            return await bot.rest.deleteOriginalInteractionResponse(token);
+        },
+        deleteOwnReaction: async (channelId, messageId, reaction)=>{
+            return await bot.rest.deleteOwnReaction(channelId, messageId, reaction);
+        },
+        deleteReactionsAll: async (channelId, messageId)=>{
+            return await bot.rest.deleteReactionsAll(channelId, messageId);
+        },
+        deleteReactionsEmoji: async (channelId, messageId, reaction)=>{
+            return await bot.rest.deleteReactionsEmoji(channelId, messageId, reaction);
+        },
+        deleteRole: async (guildId, roleId, reason)=>{
+            return await bot.rest.deleteRole(guildId, roleId, reason);
+        },
+        deleteScheduledEvent: async (guildId, eventId)=>{
+            return await bot.rest.deleteScheduledEvent(guildId, eventId);
+        },
+        deleteStageInstance: async (channelId, reason)=>{
+            return await bot.rest.deleteStageInstance(channelId, reason);
+        },
+        deleteUserReaction: async (channelId, messageId, userId, reaction)=>{
+            return await bot.rest.deleteUserReaction(channelId, messageId, userId, reaction);
+        },
+        deleteWebhook: async (webhookId, reason)=>{
+            return await bot.rest.deleteWebhook(webhookId, reason);
+        },
+        deleteWebhookMessage: async (webhookId, token, messageId, options)=>{
+            return await bot.rest.deleteWebhookMessage(webhookId, token, messageId, options);
+        },
+        deleteWebhookWithToken: async (webhookId, token)=>{
+            return await bot.rest.deleteWebhookWithToken(webhookId, token);
+        },
+        editChannelPermissionOverrides: async (channelId, options, reason)=>{
+            return await bot.rest.editChannelPermissionOverrides(channelId, options, reason);
+        },
+        editChannelPositions: async (guildId, channelPositions)=>{
+            return await bot.rest.editChannelPositions(guildId, channelPositions);
+        },
+        editGuildMfaLevel: async (guildId, mfaLevel, reason)=>{
+            return await bot.rest.editGuildMfaLevel(guildId, mfaLevel, reason);
+        },
+        editOwnVoiceState: async (guildId, options)=>{
+            return await bot.rest.editOwnVoiceState(guildId, options);
+        },
+        editUserVoiceState: async (guildId, options)=>{
+            return await bot.rest.editUserVoiceState(guildId, options);
+        },
+        joinThread: async (channelId)=>{
+            return await bot.rest.joinThread(channelId);
+        },
+        leaveGuild: async (guildId)=>{
+            return await bot.rest.leaveGuild(guildId);
+        },
+        leaveThread: async (channelId)=>{
+            return await bot.rest.leaveThread(channelId);
+        },
+        removeRole: async (guildId, userId, roleId, reason)=>{
+            return await bot.rest.removeRole(guildId, userId, roleId, reason);
+        },
+        removeThreadMember: async (channelId, userId)=>{
+            return await bot.rest.removeThreadMember(channelId, userId);
+        },
+        sendInteractionResponse: async (interactionId, token, options)=>{
+            return await bot.rest.sendInteractionResponse(interactionId, token, options);
+        },
+        triggerTypingIndicator: async (channelId)=>{
+            return await bot.rest.triggerTypingIndicator(channelId);
+        },
+        banMember: async (guildId, userId, options, reason)=>{
+            return await bot.rest.banMember(guildId, userId, options, reason);
+        },
+        kickMember: async (guildId, userId, reason)=>{
+            return await bot.rest.kickMember(guildId, userId, reason);
+        },
+        pinMessage: async (channelId, messageId, reason)=>{
+            return await bot.rest.pinMessage(channelId, messageId, reason);
+        },
+        unbanMember: async (guildId, userId, reason)=>{
+            return await bot.rest.unbanMember(guildId, userId, reason);
+        },
+        unpinMessage: async (channelId, messageId, reason)=>{
+            return await bot.rest.unpinMessage(channelId, messageId, reason);
+        }
+    };
+}
+
+//# sourceMappingURL=helpers.js.map