@discordeno/rest 19.0.0-next.fc13bdf → 19.0.0-next.fd518cb

package/dist/manager.js

@@ -1,506 +1,40 @@
 /* eslint-disable @typescript-eslint/restrict-template-expressions */ /* eslint-disable no-const-assign */ import { InteractionResponseTypes } from '@discordeno/types';
-import { calculateBits, camelize, camelToSnakeCase, delay, findFiles, getBotIdFromToken, isGetMessagesAfter, isGetMessagesAround, isGetMessagesBefore, isGetMessagesLimit, logger, processReactionString, urlToBase64 } from '@discordeno/utils';
+import { calculateBits, camelize, camelToSnakeCase, delay, getBotIdFromToken, logger, processReactionString, urlToBase64 } from '@discordeno/utils';
 import { createInvalidRequestBucket } from './invalidBucket.js';
 import { Queue } from './queue.js';
+import { createRoutes } from './routes.js';
 // TODO: make dynamic based on package.json file
 const version = '19.0.0-alpha.1';
+export const DISCORD_API_VERSION = 10;
+export const DISCORD_API_URL = 'https://discord.com/api';
+export const AUDIT_LOG_REASON_HEADER = 'x-audit-log-reason';
+export const RATE_LIMIT_REMAINING_HEADER = 'x-ratelimit-remaining';
+export const RATE_LIMIT_RESET_AFTER_HEADER = 'x-ratelimit-reset-after';
+export const RATE_LIMIT_GLOBAL_HEADER = 'x-ratelimit-global';
+export const RATE_LIMIT_BUCKET_HEADER = 'x-ratelimit-bucket';
+export const RATE_LIMIT_LIMIT_HEADER = 'x-ratelimit-limit';
+export const RATE_LIMIT_SCOPE_HEADER = 'x-ratelimit-scope';
 export function createRestManager(options) {
-    // Falsy token string check
-    if (!options.token) throw new Error('You must provide a valid token.');
+    const applicationId = options.applicationId ? BigInt(options.applicationId) : options.token ? getBotIdFromToken(options.token) : undefined;
+    if (!applicationId) {
+        throw new Error('`applicationId` was not provided and was not able to extract the id from the bots token. Please explicitly pass `applicationId` to the rest manager.');
+    }
+    const baseUrl = options.proxy?.baseUrl ?? DISCORD_API_URL;
     const rest = {
-        token: options.token,
-        applicationId: options.applicationId ? BigInt(options.applicationId) : getBotIdFromToken(options.token),
-        version: options.version ?? 10,
-        baseUrl: options.baseUrl ?? 'https://discord.com/api',
-        maxRetryCount: Infinity,
+        applicationId,
+        authorization: options.proxy?.authorization,
+        baseUrl,
+        deleteQueueDelay: 60000,
         globallyRateLimited: false,
+        invalidBucket: createInvalidRequestBucket({}),
+        isProxied: !baseUrl.startsWith(DISCORD_API_URL),
+        maxRetryCount: Infinity,
         processingRateLimitedPaths: false,
-        deleteQueueDelay: 60000,
         queues: new Map(),
         rateLimitedPaths: new Map(),
-        invalidBucket: createInvalidRequestBucket({}),
-        routes: {
-            webhooks: {
-                id: (webhookId)=>{
-                    return `/webhooks/${webhookId}`;
-                },
-                message: (webhookId, token, messageId, options)=>{
-                    let url = `/webhooks/${webhookId}/${token}/messages/${messageId}?`;
-                    if (options) {
-                        if (options.threadId) url += `thread_id=${options.threadId}`;
-                    }
-                    return url;
-                },
-                original: (webhookId, token, options)=>{
-                    let url = `/webhooks/${webhookId}/${token}/messages/@original?`;
-                    if (options) {
-                        if (options.threadId) url += `thread_id=${options.threadId}`;
-                    }
-                    return url;
-                },
-                webhook: (webhookId, token, options)=>{
-                    let url = `/webhooks/${webhookId}/${token}?`;
-                    if (options) {
-                        if (options?.wait !== undefined) url += `wait=${options.wait.toString()}`;
-                        if (options.threadId) url += `thread_id=${options.threadId}`;
-                    }
-                    return url;
-                }
-            },
-            // Miscellaneous Endpoints
-            sessionInfo: ()=>rest.routes.gatewayBot(),
-            // Channel Endpoints
-            channels: {
-                bulk: (channelId)=>{
-                    return `/channels/${channelId}/messages/bulk-delete`;
-                },
-                dm: ()=>{
-                    return '/users/@me/channels';
-                },
-                pin: (channelId, messageId)=>{
-                    return `/channels/${channelId}/pins/${messageId}`;
-                },
-                pins: (channelId)=>{
-                    return `/channels/${channelId}/pins`;
-                },
-                reactions: {
-                    bot: (channelId, messageId, emoji)=>{
-                        return `/channels/${channelId}/messages/${messageId}/reactions/${encodeURIComponent(emoji)}/@me`;
-                    },
-                    user: (channelId, messageId, emoji, userId)=>{
-                        return `/channels/${channelId}/messages/${messageId}/reactions/${encodeURIComponent(emoji)}/${userId}`;
-                    },
-                    all: (channelId, messageId)=>{
-                        return `/channels/${channelId}/messages/${messageId}/reactions`;
-                    },
-                    emoji: (channelId, messageId, emoji, options)=>{
-                        let url = `/channels/${channelId}/messages/${messageId}/reactions/${encodeURIComponent(emoji)}?`;
-                        if (options) {
-                            // eslint-disable-next-line @typescript-eslint/restrict-template-expressions
-                            if (options.after) url += `after=${options.after}`;
-                            // eslint-disable-next-line @typescript-eslint/restrict-template-expressions
-                            if (options.limit) url += `&limit=${options.limit}`;
-                        }
-                        return url;
-                    },
-                    message: (channelId, messageId, emoji, options)=>{
-                        let url = `/channels/${channelId}/messages/${messageId}/reactions/${encodeURIComponent(emoji)}?`;
-                        if (options) {
-                            // eslint-disable-next-line @typescript-eslint/restrict-template-expressions
-                            if (options.after) url += `after=${options.after}`;
-                            // eslint-disable-next-line @typescript-eslint/restrict-template-expressions
-                            if (options.limit) url += `&limit=${options.limit}`;
-                        }
-                        return url;
-                    }
-                },
-                webhooks: (channelId)=>{
-                    return `/channels/${channelId}/webhooks`;
-                },
-                channel: (channelId)=>{
-                    return `/channels/${channelId}`;
-                },
-                follow: (channelId)=>{
-                    return `/channels/${channelId}/followers`;
-                },
-                forum: (channelId)=>{
-                    return `/channels/${channelId}/threads?has_message=true`;
-                },
-                invites: (channelId)=>{
-                    return `/channels/${channelId}/invites`;
-                },
-                message: (channelId, messageId)=>{
-                    return `/channels/${channelId}/messages/${messageId}`;
-                },
-                messages: (channelId, options)=>{
-                    let url = `/channels/${channelId}/messages?`;
-                    if (options) {
-                        if (isGetMessagesAfter(options) && options.after) {
-                            url += `after=${options.after}`;
-                        }
-                        if (isGetMessagesBefore(options) && options.before) {
-                            url += `&before=${options.before}`;
-                        }
-                        if (isGetMessagesAround(options) && options.around) {
-                            url += `&around=${options.around}`;
-                        }
-                        if (isGetMessagesLimit(options) && options.limit) {
-                            url += `&limit=${options.limit}`;
-                        }
-                    }
-                    return url;
-                },
-                overwrite: (channelId, overwriteId)=>{
-                    return `/channels/${channelId}/permissions/${overwriteId}`;
-                },
-                crosspost: (channelId, messageId)=>{
-                    return `/channels/${channelId}/messages/${messageId}/crosspost`;
-                },
-                stages: ()=>{
-                    return '/stage-instances';
-                },
-                stage: (channelId)=>{
-                    return `/stage-instances/${channelId}`;
-                },
-                // Thread Endpoints
-                threads: {
-                    message: (channelId, messageId)=>{
-                        return `/channels/${channelId}/messages/${messageId}/threads`;
-                    },
-                    all: (channelId)=>{
-                        return `/channels/${channelId}/threads`;
-                    },
-                    active: (guildId)=>{
-                        return `/guilds/${guildId}/threads/active`;
-                    },
-                    members: (channelId)=>{
-                        return `/channels/${channelId}/thread-members`;
-                    },
-                    me: (channelId)=>{
-                        return `/channels/${channelId}/thread-members/@me`;
-                    },
-                    user: (channelId, userId)=>{
-                        return `/channels/${channelId}/thread-members/${userId}`;
-                    },
-                    archived: (channelId)=>{
-                        return `/channels/${channelId}/threads/archived`;
-                    },
-                    public: (channelId, options)=>{
-                        let url = `/channels/${channelId}/threads/archived/public?`;
-                        if (options) {
-                            if (options.before) {
-                                url += `before=${new Date(options.before).toISOString()}`;
-                            }
-                            // eslint-disable-next-line @typescript-eslint/restrict-template-expressions
-                            if (options.limit) url += `&limit=${options.limit}`;
-                        }
-                        return url;
-                    },
-                    private: (channelId, options)=>{
-                        let url = `/channels/${channelId}/threads/archived/private?`;
-                        if (options) {
-                            if (options.before) {
-                                url += `before=${new Date(options.before).toISOString()}`;
-                            }
-                            // eslint-disable-next-line @typescript-eslint/restrict-template-expressions
-                            if (options.limit) url += `&limit=${options.limit}`;
-                        }
-                        return url;
-                    },
-                    joined: (channelId, options)=>{
-                        let url = `/channels/${channelId}/users/@me/threads/archived/private?`;
-                        if (options) {
-                            if (options.before) {
-                                url += `before=${new Date(options.before).toISOString()}`;
-                            }
-                            // eslint-disable-next-line @typescript-eslint/restrict-template-expressions
-                            if (options.limit) url += `&limit=${options.limit}`;
-                        }
-                        return url;
-                    }
-                },
-                typing: (channelId)=>{
-                    return `/channels/${channelId}/typing`;
-                }
-            },
-            // Guild Endpoints
-            guilds: {
-                all: ()=>{
-                    return '/guilds';
-                },
-                auditlogs: (guildId, options)=>{
-                    let url = `/guilds/${guildId}/audit-logs?`;
-                    if (options) {
-                        // eslint-disable-next-line @typescript-eslint/restrict-template-expressions
-                        if (options.actionType) url += `action_type=${options.actionType}`;
-                        // eslint-disable-next-line @typescript-eslint/restrict-template-expressions
-                        if (options.before) url += `&before=${options.before}`;
-                        // eslint-disable-next-line @typescript-eslint/restrict-template-expressions
-                        if (options.limit) url += `&limit=${options.limit}`;
-                        // eslint-disable-next-line @typescript-eslint/restrict-template-expressions
-                        if (options.userId) url += `&user_id=${options.userId}`;
-                    }
-                    return url;
-                },
-                automod: {
-                    rule: (guildId, ruleId)=>{
-                        return `/guilds/${guildId}/auto-moderation/rules/${ruleId}`;
-                    },
-                    rules: (guildId)=>{
-                        return `/guilds/${guildId}/auto-moderation/rules`;
-                    }
-                },
-                channels: (guildId)=>{
-                    return `/guilds/${guildId}/channels`;
-                },
-                emoji: (guildId, emojiId)=>{
-                    return `/guilds/${guildId}/emojis/${emojiId}`;
-                },
-                emojis: (guildId)=>{
-                    return `/guilds/${guildId}/emojis`;
-                },
-                events: {
-                    events: (guildId, withUserCount)=>{
-                        let url = `/guilds/${guildId}/scheduled-events?`;
-                        if (withUserCount !== undefined) {
-                            url += `with_user_count=${withUserCount.toString()}`;
-                        }
-                        return url;
-                    },
-                    event: (guildId, eventId, withUserCount)=>{
-                        let url = `/guilds/${guildId}/scheduled-events/${eventId}`;
-                        if (withUserCount !== undefined) {
-                            url += `with_user_count=${withUserCount.toString()}`;
-                        }
-                        return url;
-                    },
-                    users: (guildId, eventId, options)=>{
-                        let url = `/guilds/${guildId}/scheduled-events/${eventId}/users?`;
-                        if (options) {
-                            // eslint-disable-next-line @typescript-eslint/restrict-template-expressions
-                            if (options.limit !== undefined) url += `limit=${options.limit}`;
-                            if (options.withMember !== undefined) {
-                                // eslint-disable-next-line @typescript-eslint/restrict-template-expressions
-                                url += `&with_member=${options.withMember.toString()}`;
-                            }
-                            // eslint-disable-next-line @typescript-eslint/restrict-template-expressions
-                            if (options.after !== undefined) url += `&after=${options.after}`;
-                            // eslint-disable-next-line @typescript-eslint/restrict-template-expressions
-                            if (options.before !== undefined) url += `&before=${options.before}`;
-                        }
-                        return url;
-                    }
-                },
-                guild (guildId, withCounts) {
-                    let url = `/guilds/${guildId}?`;
-                    if (withCounts !== undefined) {
-                        url += `with_counts=${withCounts.toString()}`;
-                    }
-                    return url;
-                },
-                integration (guildId, integrationId) {
-                    return `/guilds/${guildId}/integrations/${integrationId}`;
-                },
-                integrations: (guildId)=>{
-                    return `/guilds/${guildId}/integrations?include_applications=true`;
-                },
-                invite (inviteCode, options) {
-                    let url = `/invites/${inviteCode}?`;
-                    if (options) {
-                        if (options.withCounts !== undefined) {
-                            // eslint-disable-next-line @typescript-eslint/restrict-template-expressions
-                            url += `with_counts=${options.withCounts.toString()}`;
-                        }
-                        if (options.withExpiration !== undefined) {
-                            // eslint-disable-next-line @typescript-eslint/restrict-template-expressions
-                            url += `&with_expiration=${options.withExpiration.toString()}`;
-                        }
-                        if (options.scheduledEventId) {
-                            // eslint-disable-next-line @typescript-eslint/restrict-template-expressions
-                            url += `&guild_scheduled_event_id=${options.scheduledEventId}`;
-                        }
-                    }
-                    return url;
-                },
-                invites: (guildId)=>{
-                    return `/guilds/${guildId}/invites`;
-                },
-                leave: (guildId)=>{
-                    return `/users/@me/guilds/${guildId}`;
-                },
-                members: {
-                    ban: (guildId, userId)=>{
-                        return `/guilds/${guildId}/bans/${userId}`;
-                    },
-                    bans: (guildId, options)=>{
-                        let url = `/guilds/${guildId}/bans?`;
-                        if (options) {
-                            // eslint-disable-next-line @typescript-eslint/restrict-template-expressions
-                            if (options.limit) url += `limit=${options.limit}`;
-                            // eslint-disable-next-line @typescript-eslint/restrict-template-expressions
-                            if (options.after) url += `&after=${options.after}`;
-                            // eslint-disable-next-line @typescript-eslint/restrict-template-expressions
-                            if (options.before) url += `&before=${options.before}`;
-                        }
-                        return url;
-                    },
-                    bot: (guildId)=>{
-                        return `/guilds/${guildId}/members/@me`;
-                    },
-                    member: (guildId, userId)=>{
-                        return `/guilds/${guildId}/members/${userId}`;
-                    },
-                    members: (guildId, options)=>{
-                        let url = `/guilds/${guildId}/members?`;
-                        if (options !== undefined) {
-                            // eslint-disable-next-line @typescript-eslint/restrict-template-expressions
-                            if (options.limit) url += `limit=${options.limit}`;
-                            // eslint-disable-next-line @typescript-eslint/restrict-template-expressions
-                            if (options.after) url += `&after=${options.after}`;
-                        }
-                        return url;
-                    },
-                    search: (guildId, query, options)=>{
-                        let url = `/guilds/${guildId}/members/search?query=${encodeURIComponent(query)}`;
-                        if (options) {
-                            if (options.limit !== undefined) url += `&limit=${options.limit}`;
-                        }
-                        return url;
-                    },
-                    prune: (guildId, options)=>{
-                        let url = `/guilds/${guildId}/prune?`;
-                        if (options) {
-                            // eslint-disable-next-line @typescript-eslint/restrict-template-expressions
-                            if (options.days) url += `days=${options.days}`;
-                            if (Array.isArray(options.includeRoles)) {
-                                // eslint-disable-next-line @typescript-eslint/restrict-template-expressions
-                                url += `&include_roles=${options.includeRoles.join(',')}`;
-                            } else if (options.includeRoles) {
-                                // eslint-disable-next-line @typescript-eslint/restrict-template-expressions
-                                url += `&include_roles=${options.includeRoles}`;
-                            }
-                        }
-                        return url;
-                    }
-                },
-                mfa: (guildId)=>`/guilds/${guildId}/mfa`,
-                preview: (guildId)=>{
-                    return `/guilds/${guildId}/preview`;
-                },
-                prune: (guildId, options)=>{
-                    let url = `/guilds/${guildId}/prune?`;
-                    if (options) {
-                        // eslint-disable-next-line @typescript-eslint/restrict-template-expressions
-                        if (options.days) url += `days=${options.days}`;
-                        if (Array.isArray(options.includeRoles)) {
-                            // eslint-disable-next-line @typescript-eslint/restrict-template-expressions
-                            url += `&include_roles=${options.includeRoles.join(',')}`;
-                        } else if (options.includeRoles) {
-                            // eslint-disable-next-line @typescript-eslint/restrict-template-expressions
-                            url += `&include_roles=${options.includeRoles}`;
-                        }
-                    }
-                    return url;
-                },
-                roles: {
-                    one: (guildId, roleId)=>{
-                        return `/guilds/${guildId}/roles/${roleId}`;
-                    },
-                    all: (guildId)=>{
-                        return `/guilds/${guildId}/roles`;
-                    },
-                    member: (guildId, memberId, roleId)=>{
-                        return `/guilds/${guildId}/members/${memberId}/roles/${roleId}`;
-                    }
-                },
-                stickers: (guildId)=>{
-                    return `/guilds/${guildId}/stickers`;
-                },
-                sticker: (guildId, stickerId)=>{
-                    return `/guilds/${guildId}/stickers/${stickerId}`;
-                },
-                voice: (guildId, userId)=>{
-                    return `/guilds/${guildId}/voice-states/${userId ?? '@me'}`;
-                },
-                templates: {
-                    code: (code)=>{
-                        return `/guilds/templates/${code}`;
-                    },
-                    guild: (guildId, code)=>{
-                        return `/guilds/${guildId}/templates/${code}`;
-                    },
-                    all: (guildId)=>{
-                        return `/guilds/${guildId}/templates`;
-                    }
-                },
-                vanity: (guildId)=>{
-                    return `/guilds/${guildId}/vanity-url`;
-                },
-                regions: (guildId)=>{
-                    return `/guilds/${guildId}/regions`;
-                },
-                webhooks: (guildId)=>{
-                    return `/guilds/${guildId}/webhooks`;
-                },
-                welcome: (guildId)=>{
-                    return `/guilds/${guildId}/welcome-screen`;
-                },
-                widget: (guildId)=>{
-                    return `/guilds/${guildId}/widget`;
-                },
-                widgetJson: (guildId)=>{
-                    return `/guilds/${guildId}/widget.json`;
-                }
-            },
-            sticker: (stickerId)=>{
-                return `/stickers/${stickerId}`;
-            },
-            regions: ()=>{
-                return '/voice/regions';
-            },
-            // Interaction Endpoints
-            interactions: {
-                commands: {
-                    // Application Endpoints
-                    commands: (applicationId)=>{
-                        return `/applications/${applicationId}/commands`;
-                    },
-                    guilds: {
-                        all (applicationId, guildId) {
-                            return `/applications/${applicationId}/guilds/${guildId}/commands`;
-                        },
-                        one (applicationId, guildId, commandId, withLocalizations) {
-                            let url = `/applications/${applicationId}/guilds/${guildId}/commands/${commandId}?`;
-                            if (withLocalizations !== undefined) {
-                                url += `with_localizations=${withLocalizations.toString()}`;
-                            }
-                            return url;
-                        }
-                    },
-                    permissions: (applicationId, guildId)=>{
-                        return `/applications/${applicationId}/guilds/${guildId}/commands/permissions`;
-                    },
-                    permission: (applicationId, guildId, commandId)=>{
-                        return `/applications/${applicationId}/guilds/${guildId}/commands/${commandId}/permissions`;
-                    },
-                    command: (applicationId, commandId, withLocalizations)=>{
-                        let url = `/applications/${applicationId}/commands/${commandId}?`;
-                        if (withLocalizations !== undefined) {
-                            url += `withLocalizations=${withLocalizations.toString()}`;
-                        }
-                        return url;
-                    }
-                },
-                responses: {
-                    // Interaction Endpoints
-                    callback: (interactionId, token)=>{
-                        return `/interactions/${interactionId}/${token}/callback`;
-                    },
-                    original: (interactionId, token)=>{
-                        return `/webhooks/${interactionId}/${token}/messages/@original`;
-                    },
-                    message: (applicationId, token, messageId)=>{
-                        return `/webhooks/${applicationId}/${token}/messages/${messageId}`;
-                    }
-                }
-            },
-            // User endpoints
-            user (userId) {
-                return `/users/${userId}`;
-            },
-            userBot () {
-                return '/users/@me';
-            },
-            oauth2Application () {
-                return 'oauth2/applications/@me';
-            },
-            gatewayBot () {
-                return '/gateway/bot';
-            },
-            nitroStickerPacks () {
-                return '/sticker-packs';
-            }
-        },
+        token: options.token,
+        version: options.version ?? DISCORD_API_VERSION,
+        routes: createRoutes(),
         checkRateLimits (url) {
             const ratelimited = rest.rateLimitedPaths.get(url);
             const global = rest.rateLimitedPaths.get('global');
@@ -526,11 +60,11 @@ export function createRestManager(options) {
                         'permissions',
                         'allow',
                         'deny'
-                    ].includes(key)) {
+                    ].includes(key) && obj[key] !== undefined) {
                         newObj[key] = calculateBits(obj[key]);
                         continue;
                     }
-                    if (key === 'defaultMemberPermissions') {
+                    if (key === 'defaultMemberPermissions' && obj[key] !== undefined) {
                         newObj.default_member_permissions = calculateBits(obj[key]);
                         continue;
                     }
@@ -541,56 +75,47 @@ export function createRestManager(options) {
             if (typeof obj === 'bigint') return obj.toString();
             return obj;
         },
-        createRequest (options) {
+        createRequestBody (method, options) {
             const headers = {
                 'user-agent': `DiscordBot (https://github.com/discordeno/discordeno, v${version})`
             };
-            if (!options.unauthorized) headers.authorization = `Bot ${rest.token}`;
-            // SOMETIMES SPECIAL HEADERS (E.G. CUSTOM AUTHORIZATION) NEED TO BE USED
-            if (options.headers) {
-                for(const key in options.headers){
-                    headers[key.toLowerCase()] = options.headers[key];
-                }
-            }
-            // GET METHODS SHOULD NOT HAVE A BODY
-            if (options.method === 'GET') {
-                options.body = undefined;
-            }
+            if (options?.unauthorized !== false) headers.authorization = `Bot ${rest.token}`;
             // IF A REASON IS PROVIDED ENCODE IT IN HEADERS
-            if (options.body?.reason) {
-                headers['X-Audit-Log-Reason'] = encodeURIComponent(options.body.reason);
-                options.body.reason = undefined;
+            if (options?.reason !== undefined) {
+                headers[AUDIT_LOG_REASON_HEADER] = encodeURIComponent(options?.reason);
             }
-            if (options.body) {
-                const { file  } = options.body;
-                if (file) {
-                    const files = findFiles(file);
-                    const form = new FormData();
-                    // WHEN CREATING A STICKER, DISCORD WANTS FORM DATA ONLY
-                    if (options.url?.endsWith('/stickers') && options.method === 'POST') {
-                        form.append('file', files[0].blob, files[0].name);
-                        form.append('name', options.body.name);
-                        form.append('description', options.body.description);
-                        form.append('tags', options.body.tags);
-                    } else {
-                        for(let i = 0; i < files.length; i++){
-                            form.append(`file${i}`, files[i].blob, files[i].name);
-                        }
-                        if (file) options.body.file = undefined;
-                        form.append('payload_json', JSON.stringify(rest.changeToDiscordFormat(options.body)));
-                    }
-                    options.body.file = form;
-                } else if (options.body && ![
-                    'GET',
-                    'DELETE'
-                ].includes(options.method)) {
-                    headers['Content-Type'] = 'application/json';
+            let body;
+            // TODO: check if we need to add specific check for GET method
+            // Since GET does not allow bodies
+            // Have to check for attachments first, since body then has to be send in a different way.
+            if (options?.files !== undefined) {
+                const form = new FormData();
+                for(let i = 0; i < options.files.length; ++i){
+                    form.append(`file${i}`, options.files[i].blob, options.files[i].name);
+                }
+                form.append('payload_json', JSON.stringify({
+                    ...options.body,
+                    files: undefined
+                }));
+                body = form;
+            // No need to set the `content-type` header since `fetch` does that automatically for us when we use a `FormData` object.
+            } else if (options?.body !== undefined) {
+                if (options.body instanceof FormData) {
+                    body = options.body;
+                // No need to set the `content-type` header since `fetch` does that automatically for us when we use a `FormData` object.
+                } else {
+                    body = JSON.stringify(rest.changeToDiscordFormat(options.body));
+                    headers['content-type'] = `application/json`;
                 }
             }
+            // SOMETIMES SPECIAL HEADERS (E.G. CUSTOM AUTHORIZATION) NEED TO BE USED
+            if (options?.headers) {
+                Object.assign(headers, options.headers);
+            }
             return {
+                body,
                 headers,
-                body: options.body?.file ?? JSON.stringify(rest.changeToDiscordFormat(options.body)),
-                method: options.method
+                method
             };
         },
         processRateLimitedPaths () {
@@ -623,13 +148,13 @@ export function createRestManager(options) {
         /** Processes the rate limit headers and determines if it needs to be rate limited and returns the bucket id if available */ processHeaders (url, headers) {
             let rateLimited = false;
             // GET ALL NECESSARY HEADERS
-            const remaining = headers.get('x-ratelimit-remaining');
-            const retryAfter = headers.get('x-ratelimit-reset-after');
+            const remaining = headers.get(RATE_LIMIT_REMAINING_HEADER);
+            const retryAfter = headers.get(RATE_LIMIT_RESET_AFTER_HEADER);
             const reset = Date.now() + Number(retryAfter) * 1000;
-            const global = headers.get('x-ratelimit-global');
+            const global = headers.get(RATE_LIMIT_GLOBAL_HEADER);
             // undefined override null needed for typings
-            const bucketId = headers.get('x-ratelimit-bucket') ?? undefined;
-            const limit = headers.get('x-ratelimit-limit');
+            const bucketId = headers.get(RATE_LIMIT_BUCKET_HEADER) ?? undefined;
+            const limit = headers.get(RATE_LIMIT_LIMIT_HEADER);
             rest.queues.get(url)?.handleCompletedRequest({
                 remaining: remaining ? Number(remaining) : undefined,
                 interval: retryAfter ? Number(retryAfter) * 1000 : undefined,
@@ -655,8 +180,8 @@ export function createRestManager(options) {
             }
             // IF THERE IS NO REMAINING GLOBAL LIMIT, MARK IT RATE LIMITED GLOBALLY
             if (global) {
-                const retryAfter1 = headers.get('retry-after');
-                const globalReset = Date.now() + Number(retryAfter1) * 1000;
+                const retryAfter = headers.get('retry-after');
+                const globalReset = Date.now() + Number(retryAfter) * 1000;
                 //   rest.debug(
                 // `[REST = Globally Rate Limited] URL: ${url} | Global Rest: ${globalReset}`
                 //   )
@@ -684,13 +209,8 @@ export function createRestManager(options) {
             return rateLimited ? bucketId : undefined;
         },
         async sendRequest (options) {
-            const url = options.url.startsWith('https://') ? options.url : `${rest.baseUrl}/v${rest.version}${options.url}`;
-            const payload = rest.createRequest({
-                method: options.method,
-                url: options.url,
-                body: options.body,
-                ...options.options
-            });
+            const url = `${rest.baseUrl}/v${rest.version}${options.route}`;
+            const payload = rest.createRequestBody(options.method, options.requestBodyOptions);
             logger.debug(`sending request to ${url}`, 'with payload:', {
                 ...payload,
                 headers: {
@@ -701,75 +221,73 @@ export function createRestManager(options) {
             const response = await fetch(url, payload);
             logger.debug(`request fetched from ${url} with status ${response.status} & ${response.statusText}`);
             // Set the bucket id if it was available on the headers
-            const bucketId = rest.processHeaders(rest.simplifyUrl(options.url, options.method), response.headers);
+            const bucketId = rest.processHeaders(rest.simplifyUrl(options.route, options.method), response.headers);
             if (bucketId) options.bucketId = bucketId;
             if (response.status < 200 || response.status >= 400) {
                 logger.debug(`Request to ${url} failed.`);
-                if (response.status === 429) {
-                    logger.debug(`Request to ${url} was ratelimited.`);
-                    // Too many attempts, get rid of request from queue.
-                    if (options.retryCount++ >= rest.maxRetryCount) {
-                        logger.debug(`Request to ${url} exceeded the maximum allowed retries.`, 'with payload:', payload);
-                        // rest.debug(`[REST - RetriesMaxed] ${JSON.stringify(options)}`)
-                        // Remove item from queue to prevent retry
-                        return options.reject({
-                            ok: false,
-                            status: response.status,
-                            error: 'The options was rate limited and it maxed out the retries limit.'
-                        });
-                    }
-                    // Rate limited, add back to queue
-                    rest.invalidBucket.handleCompletedRequest(response.status, response.headers.get('X-RateLimit-Scope') === 'shared');
-                    const resetAfter = response.headers.get('x-ratelimit-reset-after');
-                    if (resetAfter) await delay(Number(resetAfter) * 1000);
-                    // process the response to prevent mem leak
-                    await response.json();
-                    return await options.retryRequest?.(options);
+                if (response.status !== 429) {
+                    options.reject({
+                        ok: false,
+                        status: response.status,
+                        body: await response.text()
+                    });
+                    return;
                 }
-                return options.reject({
-                    ok: false,
-                    status: response.status,
-                    body: JSON.stringify(await response.json())
-                });
+                logger.debug(`Request to ${url} was ratelimited.`);
+                // Too many attempts, get rid of request from queue.
+                if (options.retryCount >= rest.maxRetryCount) {
+                    logger.debug(`Request to ${url} exceeded the maximum allowed retries.`, 'with payload:', payload);
+                    // rest.debug(`[REST - RetriesMaxed] ${JSON.stringify(options)}`)
+                    options.reject({
+                        ok: false,
+                        status: response.status,
+                        error: 'The request was rate limited and it maxed out the retries limit.'
+                    });
+                    return;
+                }
+                options.retryCount += 1;
+                // Rate limited, add back to queue
+                rest.invalidBucket.handleCompletedRequest(response.status, response.headers.get(RATE_LIMIT_SCOPE_HEADER) === 'shared');
+                const resetAfter = response.headers.get(RATE_LIMIT_RESET_AFTER_HEADER);
+                if (resetAfter) await delay(Number(resetAfter) * 1000);
+                // process the response to prevent mem leak
+                await response.arrayBuffer();
+                return await options.retryRequest?.(options);
             }
-            const is204 = response.status === 204;
-            const json = is204 ? undefined : await response.json();
-            // Discord sometimes sends no response with 204 code
-            return options.resolve({
+            // Discord sometimes sends no response with no content.
+            options.resolve({
                 ok: true,
                 status: response.status,
-                body: JSON.stringify(json)
+                body: response.status === 204 ? undefined : await response.text()
             });
         },
-        // Credits: github.com/abalabahaha/eris lib/rest/RequestHandler.js#L397
-        // Modified for our use-case
         simplifyUrl (url, method) {
-            let route = url.replace(/\/([a-z-]+)\/(?:[0-9]{17,19})/g, function(match, p) {
-                return [
-                    'channels',
-                    'guilds'
-                ].includes(p) ? match : `/${p}/x`;
-            }).replace(/\/reactions\/[^/]+/g, '/reactions/x');
-            // GENERAL /reactions and /reactions/emoji/@me share the buckets
-            if (route.includes('/reactions')) {
-                route = route.substring(0, route.indexOf('/reactions') + '/reactions'.length);
+            const parts = url.split('/');
+            const secondLastPart = parts[parts.length - 2];
+            if (secondLastPart === 'channels' || secondLastPart === 'guilds') {
+                return url;
             }
-            // Delete Message endpoint has its own rate limit
-            if (method === 'DELETE' && route.endsWith('/messages/x')) {
-                route = method + route;
+            if (secondLastPart === 'reactions' || parts[parts.length - 1] === '@me') {
+                parts.splice(-2);
+                parts.push('reactions');
+            } else {
+                parts.splice(-1);
+                parts.push('x');
+            }
+            if (parts[parts.length - 3] === 'reactions') {
+                parts.splice(-2);
+            }
+            if (method === 'DELETE' && secondLastPart === 'messages') {
+                return `D${parts.join('/')}`;
+            }
+            return parts.join('/');
+        },
+        async processRequest (request) {
+            const url = rest.simplifyUrl(request.route, request.method);
+            if (request.runThroughQueue === false) {
+                await rest.sendRequest(request);
+                return;
             }
-            return route;
-        },
-        processRequest (request) {
-            const route = request.url.substring(request.url.indexOf('api/'));
-            const parts = route.split('/');
-            // Remove the api/
-            parts.shift();
-            // Removes the /v#/
-            if (parts[0]?.startsWith('v')) parts.shift();
-            // Set the full url to discord api in case it was recieved in a proxy rest
-            request.url = `${rest.baseUrl}/v${rest.version}/${parts.join('/')}`;
-            const url = rest.simplifyUrl(request.url, request.method);
             const queue = rest.queues.get(url);
             if (queue !== undefined) {
                 queue.makeRequest(request);
@@ -785,45 +303,65 @@ export function createRestManager(options) {
                 rest.queues.set(url, bucketQueue);
             }
         },
-        async makeRequest (method, url, body, options) {
-            return await new Promise((resolve, reject)=>{
+        async makeRequest (method, route, options) {
+            if (rest.isProxied) {
+                if (rest.authorization !== undefined) {
+                    options ??= {};
+                    options.headers ??= {};
+                    options.headers.authorization = rest.authorization;
+                }
+                const result = await fetch(`${rest.baseUrl}/v${rest.version}${route}`, rest.createRequestBody(method, options));
+                if (!result.ok) {
+                    const err = await result.json().catch(()=>{});
+                    // Legacy Handling to not break old code or when body is missing
+                    if (!err?.body) throw new Error(`Error: ${err.message ?? result.statusText}`);
+                    throw new Error(JSON.stringify(err));
+                }
+                return result.status !== 204 ? await result.json() : undefined;
+            }
+            // eslint-disable-next-line no-async-promise-executor
+            return await new Promise(async (resolve, reject)=>{
                 const payload = {
-                    url,
+                    route,
                     method,
-                    body,
+                    requestBodyOptions: options,
                     retryCount: 0,
-                    retryRequest: async function(options) {
-                        rest.processRequest(payload);
+                    retryRequest: async function(payload) {
+                        await rest.processRequest(payload);
+                    },
+                    resolve: (data)=>{
+                        resolve(data.status !== 204 ? JSON.parse(data.body ?? '{}') : undefined);
                     },
-                    resolve: (data)=>resolve(data.status !== 204 ? JSON.parse(data.body ?? '{}') : undefined),
                     reject,
-                    options
+                    runThroughQueue: options?.runThroughQueue
                 };
-                rest.processRequest(payload);
+                await rest.processRequest(payload);
             });
         },
-        async get (url) {
-            return camelize(await rest.makeRequest('GET', url));
+        async get (url, options) {
+            return camelize(await rest.makeRequest('GET', url, options));
         },
-        async post (url, body) {
-            return camelize(await rest.makeRequest('POST', url, body));
+        async post (url, options) {
+            return camelize(await rest.makeRequest('POST', url, options));
         },
-        async delete (url, body) {
-            return camelize(await rest.makeRequest('DELETE', url, body));
+        async delete (url, options) {
+            camelize(await rest.makeRequest('DELETE', url, options));
         },
-        async patch (url, body) {
-            return camelize(await rest.makeRequest('PATCH', url, body));
+        async patch (url, options) {
+            return camelize(await rest.makeRequest('PATCH', url, options));
         },
-        async put (url, body, options) {
-            return camelize(await rest.makeRequest('PUT', url, body, options));
+        async put (url, options) {
+            return camelize(await rest.makeRequest('PUT', url, options));
         },
         async addReaction (channelId, messageId, reaction) {
             reaction = processReactionString(reaction);
-            return await rest.put(rest.routes.channels.reactions.bot(channelId, messageId, reaction));
+            await rest.put(rest.routes.channels.reactions.bot(channelId, messageId, reaction));
         },
         async addReactions (channelId, messageId, reactions, ordered = false) {
             if (!ordered) {
-                await Promise.all(reactions.map(async (reaction)=>await rest.addReaction(channelId, messageId, reaction)));
+                await Promise.all(reactions.map(async (reaction)=>{
+                    await rest.addReaction(channelId, messageId, reaction);
+                }));
                 return;
             }
             for (const reaction of reactions){
@@ -831,283 +369,408 @@ export function createRestManager(options) {
             }
         },
         async addRole (guildId, userId, roleId, reason) {
-            return await rest.put(rest.routes.guilds.roles.member(guildId, userId, roleId), {
+            await rest.put(rest.routes.guilds.roles.member(guildId, userId, roleId), {
                 reason
             });
         },
         async addThreadMember (channelId, userId) {
-            return await rest.put(rest.routes.channels.threads.user(channelId, userId));
+            await rest.put(rest.routes.channels.threads.user(channelId, userId));
         },
-        async createAutomodRule (guildId, options) {
-            return await rest.post(rest.routes.guilds.automod.rules(guildId), options);
+        async createAutomodRule (guildId, body, reason) {
+            return await rest.post(rest.routes.guilds.automod.rules(guildId), {
+                body,
+                reason
+            });
         },
-        async createChannel (guildId, options) {
-            return await rest.post(rest.routes.guilds.channels(guildId), options);
+        async createChannel (guildId, body, reason) {
+            return await rest.post(rest.routes.guilds.channels(guildId), {
+                body,
+                reason
+            });
         },
-        async createEmoji (guildId, options) {
-            return await rest.post(rest.routes.guilds.emojis(guildId), options);
+        async createEmoji (guildId, body, reason) {
+            return await rest.post(rest.routes.guilds.emojis(guildId), {
+                body,
+                reason
+            });
         },
-        async createGlobalApplicationCommand (command) {
-            return await rest.post(rest.routes.interactions.commands.commands(rest.applicationId), command);
+        async createGlobalApplicationCommand (body) {
+            return await rest.post(rest.routes.interactions.commands.commands(rest.applicationId), {
+                body
+            });
         },
-        async createGuild (options) {
-            return await rest.post(rest.routes.guilds.all(), options);
+        async createGuild (body) {
+            return await rest.post(rest.routes.guilds.all(), {
+                body
+            });
         },
-        async createGuildApplicationCommand (command, guildId) {
-            return await rest.post(rest.routes.interactions.commands.guilds.all(rest.applicationId, guildId), command);
+        async createGuildApplicationCommand (body, guildId) {
+            return await rest.post(rest.routes.interactions.commands.guilds.all(rest.applicationId, guildId), {
+                body
+            });
         },
-        async createGuildFromTemplate (templateCode, options) {
-            if (options.icon) {
-                options.icon = await urlToBase64(options.icon);
+        async createGuildFromTemplate (templateCode, body) {
+            if (body.icon) {
+                body.icon = await urlToBase64(body.icon);
             }
-            return await rest.post(rest.routes.guilds.templates.code(templateCode), options);
+            return await rest.post(rest.routes.guilds.templates.code(templateCode), {
+                body
+            });
         },
-        async createGuildSticker (guildId, options) {
-            return await rest.post(rest.routes.guilds.stickers(guildId), options);
+        async createGuildSticker (guildId, options, reason) {
+            const form = new FormData();
+            form.append('file', options.file.blob, options.file.name);
+            form.append('name', options.name);
+            form.append('description', options.description);
+            form.append('tags', options.tags);
+            return await rest.post(rest.routes.guilds.stickers(guildId), {
+                body: form,
+                reason
+            });
         },
-        async createGuildTemplate (guildId, options) {
-            return await rest.post(rest.routes.guilds.templates.all(guildId), options);
+        async createGuildTemplate (guildId, body) {
+            return await rest.post(rest.routes.guilds.templates.all(guildId), {
+                body
+            });
         },
-        async createForumThread (channelId, options) {
-            return await rest.post(rest.routes.channels.forum(channelId), options);
+        async createForumThread (channelId, body, reason) {
+            return await rest.post(rest.routes.channels.forum(channelId), {
+                body,
+                files: body.files,
+                reason
+            });
         },
-        async createInvite (channelId, options = {}) {
-            return await rest.post(rest.routes.channels.invites(channelId), options);
+        async createInvite (channelId, body = {}, reason) {
+            return await rest.post(rest.routes.channels.invites(channelId), {
+                body,
+                reason
+            });
         },
-        async createRole (guildId, options, reason) {
+        async createRole (guildId, body, reason) {
             return await rest.post(rest.routes.guilds.roles.all(guildId), {
-                ...options,
+                body,
                 reason
             });
         },
-        async createScheduledEvent (guildId, options) {
-            return await rest.post(rest.routes.guilds.events.events(guildId), options);
+        async createScheduledEvent (guildId, body, reason) {
+            return await rest.post(rest.routes.guilds.events.events(guildId), {
+                body,
+                reason
+            });
         },
-        async createStageInstance (options) {
-            return await rest.post(rest.routes.channels.stages(), options);
+        async createStageInstance (body, reason) {
+            return await rest.post(rest.routes.channels.stages(), {
+                body,
+                reason
+            });
         },
-        async createWebhook (channelId, options) {
+        async createWebhook (channelId, options, reason) {
             return await rest.post(rest.routes.channels.webhooks(channelId), {
-                name: options.name,
-                avatar: options.avatar ? await urlToBase64(options.avatar) : undefined,
-                reason: options.reason
+                body: {
+                    name: options.name,
+                    avatar: options.avatar ? await urlToBase64(options.avatar) : undefined
+                },
+                reason
             });
         },
         async deleteAutomodRule (guildId, ruleId, reason) {
-            return await rest.delete(rest.routes.guilds.automod.rule(guildId, ruleId), {
+            await rest.delete(rest.routes.guilds.automod.rule(guildId, ruleId), {
                 reason
             });
         },
         async deleteChannel (channelId, reason) {
-            return await rest.delete(rest.routes.channels.channel(channelId), {
+            await rest.delete(rest.routes.channels.channel(channelId), {
                 reason
             });
         },
         async deleteChannelPermissionOverride (channelId, overwriteId, reason) {
-            return await rest.delete(rest.routes.channels.overwrite(channelId, overwriteId), reason ? {
+            await rest.delete(rest.routes.channels.overwrite(channelId, overwriteId), {
                 reason
-            } : undefined);
+            });
         },
         async deleteEmoji (guildId, id, reason) {
-            return await rest.delete(rest.routes.guilds.emoji(guildId, id), {
+            await rest.delete(rest.routes.guilds.emoji(guildId, id), {
                 reason
             });
         },
         async deleteFollowupMessage (token, messageId) {
-            return await rest.delete(rest.routes.interactions.responses.message(rest.applicationId, token, messageId));
+            await rest.delete(rest.routes.interactions.responses.message(rest.applicationId, token, messageId), {
+                unauthorized: true
+            });
         },
         async deleteGlobalApplicationCommand (commandId) {
-            return await rest.delete(rest.routes.interactions.commands.command(rest.applicationId, commandId));
+            await rest.delete(rest.routes.interactions.commands.command(rest.applicationId, commandId));
         },
         async deleteGuild (guildId) {
-            return await rest.delete(rest.routes.guilds.guild(guildId));
+            await rest.delete(rest.routes.guilds.guild(guildId));
         },
         async deleteGuildApplicationCommand (commandId, guildId) {
-            return await rest.delete(rest.routes.interactions.commands.guilds.one(rest.applicationId, guildId, commandId));
+            await rest.delete(rest.routes.interactions.commands.guilds.one(rest.applicationId, guildId, commandId));
         },
         async deleteGuildSticker (guildId, stickerId, reason) {
-            return await rest.delete(rest.routes.guilds.sticker(guildId, stickerId), reason ? {
+            await rest.delete(rest.routes.guilds.sticker(guildId, stickerId), {
                 reason
-            } : undefined);
+            });
         },
         async deleteGuildTemplate (guildId, templateCode) {
-            return await rest.delete(rest.routes.guilds.templates.guild(guildId, templateCode));
+            await rest.delete(rest.routes.guilds.templates.guild(guildId, templateCode));
         },
-        async deleteIntegration (guildId, integrationId) {
-            return await rest.delete(rest.routes.guilds.integration(guildId, integrationId));
+        async deleteIntegration (guildId, integrationId, reason) {
+            await rest.delete(rest.routes.guilds.integration(guildId, integrationId), {
+                reason
+            });
         },
         async deleteInvite (inviteCode, reason) {
-            return await rest.delete(rest.routes.guilds.invite(inviteCode), reason ? {
+            await rest.delete(rest.routes.guilds.invite(inviteCode), {
                 reason
-            } : undefined);
+            });
         },
         async deleteMessage (channelId, messageId, reason) {
-            return await rest.delete(rest.routes.channels.message(channelId, messageId), {
+            await rest.delete(rest.routes.channels.message(channelId, messageId), {
                 reason
             });
         },
         async deleteMessages (channelId, messageIds, reason) {
-            return await rest.post(rest.routes.channels.bulk(channelId), {
-                messages: messageIds.slice(0, 100).map((id)=>id.toString()),
+            await rest.post(rest.routes.channels.bulk(channelId), {
+                body: {
+                    messages: messageIds.slice(0, 100).map((id)=>id.toString())
+                },
                 reason
             });
         },
         async deleteOriginalInteractionResponse (token) {
-            return await rest.delete(rest.routes.interactions.responses.original(rest.applicationId, token));
+            await rest.delete(rest.routes.interactions.responses.original(rest.applicationId, token), {
+                unauthorized: true
+            });
         },
         async deleteOwnReaction (channelId, messageId, reaction) {
             reaction = processReactionString(reaction);
-            return await rest.delete(rest.routes.channels.reactions.bot(channelId, messageId, reaction));
+            await rest.delete(rest.routes.channels.reactions.bot(channelId, messageId, reaction));
         },
         async deleteReactionsAll (channelId, messageId) {
-            return await rest.delete(rest.routes.channels.reactions.all(channelId, messageId));
+            await rest.delete(rest.routes.channels.reactions.all(channelId, messageId));
         },
         async deleteReactionsEmoji (channelId, messageId, reaction) {
             reaction = processReactionString(reaction);
-            return await rest.delete(rest.routes.channels.reactions.emoji(channelId, messageId, reaction));
+            await rest.delete(rest.routes.channels.reactions.emoji(channelId, messageId, reaction));
         },
-        async deleteRole (guildId, roleId) {
-            return await rest.delete(rest.routes.guilds.roles.one(guildId, roleId));
+        async deleteRole (guildId, roleId, reason) {
+            await rest.delete(rest.routes.guilds.roles.one(guildId, roleId), {
+                reason
+            });
         },
         async deleteScheduledEvent (guildId, eventId) {
-            return await rest.delete(rest.routes.guilds.events.event(guildId, eventId));
+            await rest.delete(rest.routes.guilds.events.event(guildId, eventId));
         },
         async deleteStageInstance (channelId, reason) {
-            return await rest.delete(rest.routes.channels.stage(channelId), reason ? {
+            await rest.delete(rest.routes.channels.stage(channelId), {
                 reason
-            } : undefined);
+            });
         },
         async deleteUserReaction (channelId, messageId, userId, reaction) {
             reaction = processReactionString(reaction);
-            return await rest.delete(rest.routes.channels.reactions.user(channelId, messageId, reaction, userId));
+            await rest.delete(rest.routes.channels.reactions.user(channelId, messageId, reaction, userId));
         },
         async deleteWebhook (webhookId, reason) {
-            return await rest.delete(rest.routes.webhooks.id(webhookId), {
+            await rest.delete(rest.routes.webhooks.id(webhookId), {
                 reason
             });
         },
         async deleteWebhookMessage (webhookId, token, messageId, options) {
-            return await rest.delete(rest.routes.webhooks.message(webhookId, token, messageId, options));
+            await rest.delete(rest.routes.webhooks.message(webhookId, token, messageId, options));
         },
         async deleteWebhookWithToken (webhookId, token) {
-            return await rest.delete(rest.routes.webhooks.webhook(webhookId, token));
+            await rest.delete(rest.routes.webhooks.webhook(webhookId, token));
         },
-        async editApplicationCommandPermissions (guildId, commandId, bearerToken, options) {
+        async editApplicationCommandPermissions (guildId, commandId, bearerToken, permissions) {
             return await rest.put(rest.routes.interactions.commands.permission(rest.applicationId, guildId, commandId), {
-                permissions: options
-            }, {
+                body: {
+                    permissions
+                },
                 headers: {
                     authorization: `Bearer ${bearerToken}`
                 }
             });
         },
-        async editAutomodRule (guildId, ruleId, options) {
-            return await rest.patch(rest.routes.guilds.automod.rule(guildId, ruleId), options);
+        async editAutomodRule (guildId, ruleId, body, reason) {
+            return await rest.patch(rest.routes.guilds.automod.rule(guildId, ruleId), {
+                body,
+                reason
+            });
         },
         async editBotProfile (options) {
             const avatar = options?.botAvatarURL ? await urlToBase64(options?.botAvatarURL) : options?.botAvatarURL;
             return await rest.patch(rest.routes.userBot(), {
-                username: options.username?.trim(),
-                avatar
+                body: {
+                    username: options.username?.trim(),
+                    avatar
+                }
             });
         },
-        async editChannel (channelId, options) {
-            return await rest.patch(rest.routes.channels.channel(channelId), options);
+        async editChannel (channelId, body, reason) {
+            return await rest.patch(rest.routes.channels.channel(channelId), {
+                body,
+                reason
+            });
         },
-        async editChannelPermissionOverrides (channelId, options) {
-            return await rest.put(rest.routes.channels.overwrite(channelId, options.id), options);
+        async editChannelPermissionOverrides (channelId, body, reason) {
+            await rest.put(rest.routes.channels.overwrite(channelId, body.id), {
+                body,
+                reason
+            });
         },
-        async editChannelPositions (guildId, channelPositions) {
-            return await rest.patch(rest.routes.guilds.channels(guildId), channelPositions);
+        async editChannelPositions (guildId, body) {
+            await rest.patch(rest.routes.guilds.channels(guildId), {
+                body
+            });
         },
-        async editEmoji (guildId, id, options) {
-            return await rest.patch(rest.routes.guilds.emoji(guildId, id), options);
+        async editEmoji (guildId, id, body, reason) {
+            return await rest.patch(rest.routes.guilds.emoji(guildId, id), {
+                body,
+                reason
+            });
         },
-        async editFollowupMessage (token, messageId, options) {
-            return await rest.patch(rest.routes.interactions.responses.message(rest.applicationId, token, messageId), options);
+        async editFollowupMessage (token, messageId, body) {
+            return await rest.patch(rest.routes.interactions.responses.message(rest.applicationId, token, messageId), {
+                body,
+                files: body.files,
+                unauthorized: true
+            });
         },
-        async editGlobalApplicationCommand (commandId, options) {
-            return await rest.patch(rest.routes.interactions.commands.command(rest.applicationId, commandId), options);
+        async editGlobalApplicationCommand (commandId, body) {
+            return await rest.patch(rest.routes.interactions.commands.command(rest.applicationId, commandId), {
+                body
+            });
         },
-        async editGuild (guildId, options) {
-            return await rest.patch(rest.routes.guilds.guild(guildId), options);
+        async editGuild (guildId, body, reason) {
+            return await rest.patch(rest.routes.guilds.guild(guildId), {
+                body,
+                reason
+            });
         },
-        async editGuildApplicationCommand (commandId, guildId, options) {
-            return await rest.patch(rest.routes.interactions.commands.guilds.one(rest.applicationId, guildId, commandId), options);
+        async editGuildApplicationCommand (commandId, guildId, body) {
+            return await rest.patch(rest.routes.interactions.commands.guilds.one(rest.applicationId, guildId, commandId), {
+                body
+            });
         },
         async editGuildMfaLevel (guildId, mfaLevel, reason) {
-            return await rest.post(rest.routes.guilds.mfa(guildId), {
-                level: mfaLevel,
+            await rest.post(rest.routes.guilds.mfa(guildId), {
+                body: {
+                    level: mfaLevel
+                },
                 reason
             });
         },
-        async editGuildSticker (guildId, stickerId, options) {
-            return await rest.patch(rest.routes.guilds.sticker(guildId, stickerId), options);
+        async editGuildSticker (guildId, stickerId, body, reason) {
+            return await rest.patch(rest.routes.guilds.sticker(guildId, stickerId), {
+                body,
+                reason
+            });
         },
-        async editGuildTemplate (guildId, templateCode, options) {
-            return await rest.patch(rest.routes.guilds.templates.guild(guildId, templateCode), options);
+        async editGuildTemplate (guildId, templateCode, body) {
+            return await rest.patch(rest.routes.guilds.templates.guild(guildId, templateCode), {
+                body
+            });
         },
-        async editMessage (channelId, messageId, options) {
-            return await rest.patch(rest.routes.channels.message(channelId, messageId), options);
+        async editMessage (channelId, messageId, body) {
+            return await rest.patch(rest.routes.channels.message(channelId, messageId), {
+                body
+            });
         },
-        async editOriginalInteractionResponse (token, options) {
-            return await rest.patch(rest.routes.interactions.responses.original(rest.applicationId, token), options);
+        async editOriginalInteractionResponse (token, body) {
+            return await rest.patch(rest.routes.interactions.responses.original(rest.applicationId, token), {
+                body,
+                files: body.files
+            });
         },
         async editOriginalWebhookMessage (webhookId, token, options) {
             return await rest.patch(rest.routes.webhooks.original(webhookId, token, options), {
-                type: InteractionResponseTypes.UpdateMessage,
-                data: options
+                body: {
+                    type: InteractionResponseTypes.UpdateMessage,
+                    data: options
+                },
+                files: options.files,
+                unauthorized: true
             });
         },
         async editOwnVoiceState (guildId, options) {
-            return await rest.patch(rest.routes.guilds.voice(guildId), {
-                channel_id: options.channelId,
-                suppress: options.suppress,
-                request_to_speak_timestamp: options.requestToSpeakTimestamp ? new Date(options.requestToSpeakTimestamp).toISOString() : options.requestToSpeakTimestamp
+            await rest.patch(rest.routes.guilds.voice(guildId), {
+                body: {
+                    ...options,
+                    request_to_speak_timestamp: options.requestToSpeakTimestamp ? new Date(options.requestToSpeakTimestamp).toISOString() : options.requestToSpeakTimestamp
+                }
             });
         },
-        async editScheduledEvent (guildId, eventId, options) {
-            return await rest.patch(rest.routes.guilds.events.event(guildId, eventId), options);
+        async editScheduledEvent (guildId, eventId, body, reason) {
+            return await rest.patch(rest.routes.guilds.events.event(guildId, eventId), {
+                body,
+                reason
+            });
         },
-        async editRole (guildId, roleId, options) {
-            return await rest.patch(rest.routes.guilds.roles.one(guildId, roleId), options);
+        async editRole (guildId, roleId, body, reason) {
+            return await rest.patch(rest.routes.guilds.roles.one(guildId, roleId), {
+                body,
+                reason
+            });
         },
-        async editRolePositions (guildId, options) {
-            return await rest.patch(rest.routes.guilds.roles.all(guildId), options);
+        async editRolePositions (guildId, body, reason) {
+            return await rest.patch(rest.routes.guilds.roles.all(guildId), {
+                body,
+                reason
+            });
         },
-        async editStageInstance (channelId, data) {
+        async editStageInstance (channelId, topic, reason) {
             return await rest.patch(rest.routes.channels.stage(channelId), {
-                topic: data.topic
+                body: {
+                    topic
+                },
+                reason
             });
         },
         async editUserVoiceState (guildId, options) {
-            return await rest.patch(rest.routes.guilds.voice(guildId, options.userId), {
-                channel_id: options.channelId,
-                suppress: options.suppress,
-                user_id: options.userId
+            await rest.patch(rest.routes.guilds.voice(guildId, options.userId), {
+                body: options
             });
         },
-        async editWebhook (webhookId, options) {
-            return await rest.patch(rest.routes.webhooks.id(webhookId), options);
+        async editWebhook (webhookId, body, reason) {
+            return await rest.patch(rest.routes.webhooks.id(webhookId), {
+                body,
+                reason
+            });
         },
         async editWebhookMessage (webhookId, token, messageId, options) {
-            return await rest.patch(rest.routes.webhooks.message(webhookId, token, messageId, options), options);
+            return await rest.patch(rest.routes.webhooks.message(webhookId, token, messageId, options), {
+                body: options,
+                files: options.files
+            });
         },
-        async editWebhookWithToken (webhookId, token, options) {
-            return await rest.patch(rest.routes.webhooks.webhook(webhookId, token), options);
+        async editWebhookWithToken (webhookId, token, body) {
+            return await rest.patch(rest.routes.webhooks.webhook(webhookId, token), {
+                body
+            });
         },
-        async editWelcomeScreen (guildId, options) {
-            return await rest.patch(rest.routes.guilds.welcome(guildId), options);
+        async editWelcomeScreen (guildId, body, reason) {
+            return await rest.patch(rest.routes.guilds.welcome(guildId), {
+                body,
+                reason
+            });
         },
-        async editWidgetSettings (guildId, options) {
-            return await rest.patch(rest.routes.guilds.widget(guildId), options);
+        async editWidgetSettings (guildId, body, reason) {
+            return await rest.patch(rest.routes.guilds.widget(guildId), {
+                body,
+                reason
+            });
         },
         async executeWebhook (webhookId, token, options) {
-            return await rest.post(rest.routes.webhooks.webhook(webhookId, token, options), options);
+            return await rest.post(rest.routes.webhooks.webhook(webhookId, token, options), {
+                body: options
+            });
         },
         async followAnnouncement (sourceChannelId, targetChannelId) {
             return await rest.post(rest.routes.channels.follow(sourceChannelId), {
-                webhook_channel_id: targetChannelId
+                body: {
+                    webhook_channel_id: targetChannelId
+                }
             });
         },
         async getActiveThreads (guildId) {
@@ -1154,7 +817,9 @@ export function createRestManager(options) {
         },
         async getDmChannel (userId) {
             return await rest.post(rest.routes.channels.dm(), {
-                recipient_id: userId.toString()
+                body: {
+                    recipient_id: userId
+                }
             });
         },
         async getEmoji (guildId, emojiId) {
@@ -1164,7 +829,9 @@ export function createRestManager(options) {
             return await rest.get(rest.routes.guilds.emojis(guildId));
         },
         async getFollowupMessage (token, messageId) {
-            return await rest.get(rest.routes.interactions.responses.message(rest.applicationId, token, messageId));
+            return await rest.get(rest.routes.interactions.responses.message(rest.applicationId, token, messageId), {
+                unauthorized: true
+            });
         },
         async getGatewayBot () {
             return await rest.get(rest.routes.gatewayBot());
@@ -1217,7 +884,9 @@ export function createRestManager(options) {
             return await rest.get(rest.routes.nitroStickerPacks());
         },
         async getOriginalInteractionResponse (token) {
-            return await rest.get(rest.routes.interactions.responses.original(rest.applicationId, token));
+            return await rest.get(rest.routes.interactions.responses.original(rest.applicationId, token), {
+                unauthorized: true
+            });
         },
         async getPinnedMessages (channelId) {
             return await rest.get(rest.routes.channels.pins(channelId));
@@ -1298,77 +967,78 @@ export function createRestManager(options) {
             return await rest.get(rest.routes.guilds.widget(guildId));
         },
         async joinThread (channelId) {
-            return await rest.put(rest.routes.channels.threads.me(channelId));
+            await rest.put(rest.routes.channels.threads.me(channelId));
         },
         async leaveGuild (guildId) {
-            return await rest.delete(rest.routes.guilds.leave(guildId));
+            await rest.delete(rest.routes.guilds.leave(guildId));
         },
         async leaveThread (channelId) {
-            return await rest.delete(rest.routes.channels.threads.me(channelId));
+            await rest.delete(rest.routes.channels.threads.me(channelId));
         },
         async publishMessage (channelId, messageId) {
             return await rest.post(rest.routes.channels.crosspost(channelId, messageId));
         },
         async removeRole (guildId, userId, roleId, reason) {
-            return await rest.delete(rest.routes.guilds.roles.member(guildId, userId, roleId), {
+            await rest.delete(rest.routes.guilds.roles.member(guildId, userId, roleId), {
                 reason
             });
         },
         async removeThreadMember (channelId, userId) {
-            return await rest.delete(rest.routes.channels.threads.user(channelId, userId));
+            await rest.delete(rest.routes.channels.threads.user(channelId, userId));
         },
         async sendFollowupMessage (token, options) {
-            return await new Promise((resolve, reject)=>{
-                rest.sendRequest({
-                    url: rest.routes.webhooks.webhook(rest.applicationId, token),
-                    method: 'POST',
-                    body: options,
-                    retryCount: 0,
-                    retryRequest: async function(options) {
-                        // TODO: should change to reprocess queue item
-                        await rest.sendRequest(options);
-                    },
-                    resolve: (data)=>resolve(data.status !== 204 ? JSON.parse(data.body ?? '{}') : undefined),
-                    reject
-                });
+            return await rest.post(rest.routes.webhooks.webhook(rest.applicationId, token), {
+                body: options,
+                files: options.files,
+                unauthorized: true
             });
         },
         async sendInteractionResponse (interactionId, token, options) {
-            return await new Promise((resolve, reject)=>{
-                rest.sendRequest({
-                    url: rest.routes.interactions.responses.callback(interactionId, token),
-                    method: 'POST',
-                    body: options,
-                    retryCount: 0,
-                    retryRequest: async function(options) {
-                        // TODO: should change to reprocess queue item
-                        await rest.sendRequest(options);
-                    },
-                    resolve: (data)=>resolve(data.status !== 204 ? JSON.parse(data.body ?? '{}') : undefined),
-                    reject
-                });
+            return await rest.post(rest.routes.interactions.responses.callback(interactionId, token), {
+                body: options,
+                files: options.data?.files,
+                runThroughQueue: false,
+                unauthorized: true
             });
         },
-        async sendMessage (channelId, options) {
-            return await rest.post(rest.routes.channels.messages(channelId), options);
+        async sendMessage (channelId, body) {
+            return await rest.post(rest.routes.channels.messages(channelId), {
+                body,
+                files: body.files
+            });
         },
-        async startThreadWithMessage (channelId, messageId, options) {
-            return await rest.post(rest.routes.channels.threads.message(channelId, messageId), options);
+        async startThreadWithMessage (channelId, messageId, body, reason) {
+            return await rest.post(rest.routes.channels.threads.message(channelId, messageId), {
+                body,
+                reason
+            });
         },
-        async startThreadWithoutMessage (channelId, options) {
-            return await rest.post(rest.routes.channels.threads.all(channelId), options);
+        async startThreadWithoutMessage (channelId, body, reason) {
+            return await rest.post(rest.routes.channels.threads.all(channelId), {
+                body,
+                reason
+            });
         },
         async syncGuildTemplate (guildId) {
             return await rest.put(rest.routes.guilds.templates.all(guildId));
         },
-        async banMember (guildId, userId, options) {
-            return await rest.put(rest.routes.guilds.members.ban(guildId, userId), options);
+        async banMember (guildId, userId, body, reason) {
+            await rest.put(rest.routes.guilds.members.ban(guildId, userId), {
+                body,
+                reason
+            });
         },
-        async editBotMember (guildId, options) {
-            return await rest.patch(rest.routes.guilds.members.bot(guildId), options);
+        async editBotMember (guildId, body, reason) {
+            return await rest.patch(rest.routes.guilds.members.bot(guildId), {
+                body,
+                reason
+            });
         },
-        async editMember (guildId, userId, options) {
-            return await rest.patch(rest.routes.guilds.members.member(guildId, userId), options);
+        async editMember (guildId, userId, body, reason) {
+            return await rest.patch(rest.routes.guilds.members.member(guildId, userId), {
+                body,
+                reason
+            });
         },
         async getMember (guildId, userId) {
             return await rest.get(rest.routes.guilds.members.member(guildId, userId));
@@ -1377,40 +1047,56 @@ export function createRestManager(options) {
             return await rest.get(rest.routes.guilds.members.members(guildId, options));
         },
         async kickMember (guildId, userId, reason) {
-            return await rest.delete(rest.routes.guilds.members.member(guildId, userId), {
+            await rest.delete(rest.routes.guilds.members.member(guildId, userId), {
                 reason
             });
         },
         async pinMessage (channelId, messageId, reason) {
-            return await rest.put(rest.routes.channels.pin(channelId, messageId), reason ? {
+            await rest.put(rest.routes.channels.pin(channelId, messageId), {
                 reason
-            } : undefined);
+            });
         },
-        async pruneMembers (guildId, options) {
-            return await rest.post(rest.routes.guilds.members.prune(guildId), options);
+        async pruneMembers (guildId, body, reason) {
+            return await rest.post(rest.routes.guilds.members.prune(guildId), {
+                body,
+                reason
+            });
         },
         async searchMembers (guildId, query, options) {
             return await rest.get(rest.routes.guilds.members.search(guildId, query, options));
         },
-        async unbanMember (guildId, userId) {
-            return await rest.delete(rest.routes.guilds.members.ban(guildId, userId));
+        async unbanMember (guildId, userId, reason) {
+            await rest.delete(rest.routes.guilds.members.ban(guildId, userId), {
+                reason
+            });
         },
         async unpinMessage (channelId, messageId, reason) {
-            return await rest.delete(rest.routes.channels.pin(channelId, messageId), reason ? {
+            await rest.delete(rest.routes.channels.pin(channelId, messageId), {
                 reason
-            } : undefined);
+            });
         },
         async triggerTypingIndicator (channelId) {
-            return await rest.post(rest.routes.channels.typing(channelId));
+            await rest.post(rest.routes.channels.typing(channelId));
         },
-        async upsertGlobalApplicationCommands (commands) {
-            return await rest.put(rest.routes.interactions.commands.commands(rest.applicationId), commands);
+        async upsertGlobalApplicationCommands (body) {
+            return await rest.put(rest.routes.interactions.commands.commands(rest.applicationId), {
+                body
+            });
         },
-        async upsertGuildApplicationCommands (guildId, commands) {
-            return await rest.put(rest.routes.interactions.commands.guilds.all(rest.applicationId, guildId), commands);
+        async upsertGuildApplicationCommands (guildId, body) {
+            return await rest.put(rest.routes.interactions.commands.guilds.all(rest.applicationId, guildId), {
+                body
+            });
         }
     };
     return rest;
 }
+var HttpResponseCode;
+(function(HttpResponseCode) {
+    HttpResponseCode[HttpResponseCode[/** Minimum value of a code in oder to consider that it was successful. */ "Success"] = 200] = "Success";
+    HttpResponseCode[HttpResponseCode[/** Request completed successfully, but Discord returned an empty body. */ "NoContent"] = 204] = "NoContent";
+    HttpResponseCode[HttpResponseCode[/** Minimum value of a code in order to consider that something went wrong. */ "Error"] = 400] = "Error";
+    HttpResponseCode[HttpResponseCode[/** This request got rate limited. */ "TooManyRequests"] = 429] = "TooManyRequests";
+})(HttpResponseCode || (HttpResponseCode = {}));
 
 //# sourceMappingURL=manager.js.map