diff --git a/.github/workflows/pr_tests.yml b/.github/workflows/pr_tests.yml
index bccd47892..505b8050d 100644
--- a/.github/workflows/pr_tests.yml
+++ b/.github/workflows/pr_tests.yml
@@ -8,22 +8,26 @@ jobs:
         deno: ["v1.x"]
     steps:
       - uses: actions/checkout@v2
+      - run: git submodule update --init --recursive
       - uses: denoland/setup-deno@main
         with:
           deno-version: ${{ matrix.deno }}
       - name: Cache dependencies
         run: deno cache mod.ts
+      - name: Prepare configs file
+        run: cp configs.example.ts configs.ts
       - name: Run tests if requested by maintainers
         if: ${{ github.event.issue.pull_request && github.event.comment.body == 'run-tests' && (github.actor == 'Skillz4Killz' || github.actor == 'itohatweb') }}
         run: DISCORD_TOKEN=${{ env.DISCORD_TOKEN }} deno test --unstable --coverage=coverage -A tests/mod.ts
         env:
           DISCORD_TOKEN: ${{ secrets.DISCORD_TOKEN }}
-    # TODO: add coverage back when it is stable
-    #      - name: Create coverage report
-    #        run: deno --unstable --exclude=test coverage ./coverage --lcov > coverage.lcov
-    #      - name: Collect and upload the coverage report
-    #        uses: codecov/codecov-action@v1.0.10
-    #        with:
-    #          file: ./coverage.lcov
+      - name: Create coverage report
+        if: github.ref == 'refs/heads/main'
+        run: deno coverage --exclude=tests ./coverage --lcov > coverage.lcov
+      - name: Collect and upload the coverage report
+        if: github.ref == 'refs/heads/main'
+        uses: codecov/codecov-action@v1.0.10
+        with:
+          file: ./coverage.lcov
     env:
       DISCORD_TOKEN: ${{ secrets.DISCORD_TOKEN }}
diff --git a/README.md b/README.md
index 408771c38..8bef0b858 100644
--- a/README.md
+++ b/README.md
@@ -33,36 +33,37 @@ TODO: add coverage back when it is stable
 
 ### REST
 
-- [x] Freedom from Invalid Request 1 Hour Downtimes
-  - [x] Discordeno will protect your bot from going down for an hour and will instead decrease the maximum downtime to 10 minutes.
-- [x] Freedom from global rate limit errors
-  - [x] As your bot grows, you want to handle global rate limits better. Shards don't communicate fast enough to truly handle it properly so this allows 1 rest handler across the entire bot.
-  - [x] In fact, you can host multiple instances of your bot and all connect to the same rest server.
-- [x] REST does not rest!
-  - [x] Separate rest means if your bot for whatever reason crashes, your requests that are queued will still keep going and will not be lost.
-  - [x] Seamless updates! When you want to update and reboot the bot, you could potentially lose tons of messages or responses that are in queue. Using this you could restart your bot without ever worrying about losing any responses.
-- [x] Single source of contact to Discord API
-  - [x] This will allow you to make requests to discord from anywhere including a bot dashboard. You no longer need to have to communicate to your bot processes just to make a request or anything. Free up your bot process for processing bot events.
-- [x] Scalability! Scalability! Scalability!
+- ✅ Freedom from Invalid Request 1 Hour Downtimes
+  - ✅ Discordeno will protect your bot from going down for an hour and will instead decrease the maximum downtime to 10 minutes.
+- ✅ Freedom from global rate limit errors
+  - ✅ As your bot grows, you want to handle global rate limits better. Shards don't communicate fast enough to truly handle it properly so this allows 1 rest handler across the entire bot.
+  - ✅ In fact, you can host multiple instances of your bot and all connect to the same rest server.
+- ✅ REST does not rest!
+  - ✅ Separate rest means if your bot for whatever reason crashes, your requests that are queued will still keep going and will not be lost.
+  - ✅ Seamless updates! When you want to update and reboot the bot, you could potentially lose tons of messages or responses that are in queue. Using this you could restart your bot without ever worrying about losing any responses.
+- ✅ Single source of contact to Discord API
+  - ✅ This will allow you to make requests to discord from anywhere including a bot dashboard. You no longer need to have to communicate to your bot processes just to make a request or anything. Free up your bot process for processing bot events.
+- ✅ Scalability! Scalability! Scalability!
 
 ### Gateway
 
-- [x] **Zero Downtime Updates:**
-  - [x] Your bot can be updated in a matter of seconds. With normal sharding, you have to restart which also has to process identifying all your shards with a 1/~5s rate limit. With WS handling moved to a proxy process, this allows you to instantly get the bot code restarted without any concerns of delays. If you have a bot on 200,000 servers normally this would mean a 20 minute delay to restart your bot if you made a small change and restarted.
-- [x] **Zero Downtime Resharding:**
-  - [x] Discord stops letting your bot get added to new servers at certain points in time. For example, suppose you had 150,000 servers running 150 shards. The maximum amount of servers your shards could hold is 150 \* 2500 = 375,000. If your bot reaches this, it can no longer join new servers until it re-shards.
-  - [x] DD proxy provides 2 types of re-sharding. Automated and manual. You can also have both.
-    - [x] Automated: This system will automatically begin a Zero-downtime resharding process behind the scenes when you reach 80% of your maximum servers allowed by your shards. For example, since 375,000 was the max, at 300,000 we would begin re-sharding behind the scenes with ZERO DOWNTIME.
-      - [x] 80% of maximum servers reached (The % of 80% is customizable.)
-      - [x] Identify limits have room to allow re-sharding. (Also customizable)
-    - [x] Manual: You can also trigger this manually should you choose.
-- [x] **Horizontal Scaling:**
-  - [x] The proxy system allows you to scale the bot horizontally. When you reach a huge size, you can either keep spending more money to keep beefing up your server or you can buy several cheaper servers and scale horizontally. The proxy means you can have WS handling on a completely separate system.
-- [x] **No Loss Restarts:** -[x] When you restart a bot without the proxy system, normally you would lose many events. Users may be using commands or messages are sent that will not be filtered. As your bot's grow this number rises dramatically. Users may join who wont get the auto-roles or any other actions your bot should take. With the proxy system, you can keep restarting your bot and never lose any events. Events will be put into a queue while your bot is down(max size of queue is customizable), once the bot is available the queue will begin processing all events.
-- [x] **Controllers:**
-  - [x] The controller aspect gives you full control over everything inside the proxy. You can provide a function to simply override the handler. For example, if you would like a certain function to do something different, instead of having to fork and maintain your fork, you can just provide a function to override.
-- [x] **Clustering With Workers:**
-  - [x] Take full advantage of all your CPU cores by using workers to spread the load. Control how many shards per worker and how many workers to maximize efficiency!
+- ✅ **Zero Downtime Updates:**
+  - ✅ Your bot can be updated in a matter of seconds. With normal sharding, you have to restart which also has to process identifying all your shards with a 1/~5s rate limit. With WS handling moved to a proxy process, this allows you to instantly get the bot code restarted without any concerns of delays. If you have a bot on 200,000 servers normally this would mean a 20 minute delay to restart your bot if you made a small change and restarted.
+- ✅ **Zero Downtime Resharding:**
+  - ✅ Discord stops letting your bot get added to new servers at certain points in time. For example, suppose you had 150,000 servers running 150 shards. The maximum amount of servers your shards could hold is 150 \* 2500 = 375,000. If your bot reaches this, it can no longer join new servers until it re-shards.
+  - ✅ DD proxy provides 2 types of re-sharding. Automated and manual. You can also have both.
+    - ✅ Automated: This system will automatically begin a Zero-downtime resharding process behind the scenes when you reach 80% of your maximum servers allowed by your shards. For example, since 375,000 was the max, at 300,000 we would begin re-sharding behind the scenes with ZERO DOWNTIME.
+      - ✅ 80% of maximum servers reached (The % of 80% is customizable.)
+      - ✅ Identify limits have room to allow re-sharding. (Also customizable)
+    - ✅ Manual: You can also trigger this manually should you choose.
+- ✅ **Horizontal Scaling:**
+  - ✅ The proxy system allows you to scale the bot horizontally. When you reach a huge size, you can either keep spending more money to keep beefing up your server or you can buy several cheaper servers and scale horizontally. The proxy means you can have WS handling on a completely separate system.
+- ✅ **No Loss Restarts:**
+  - ✅ When you restart a bot without the proxy system, normally you would lose many events. Users may be using commands or messages are sent that will not be filtered. As your bot's grow this number rises dramatically. Users may join who wont get the auto-roles or any other actions your bot should take. With the proxy system, you can keep restarting your bot and never lose any events. Events will be put into a queue while your bot is down(max size of queue is customizable), once the bot is available the queue will begin processing all events.
+- ✅ **Controllers:**
+  - ✅ The controller aspect gives you full control over everything inside the proxy. You can provide a function to simply override the handler. For example, if you would like a certain function to do something different, instead of having to fork and maintain your fork, you can just provide a function to override.
+- ✅ **Clustering With Workers:**
+  - ✅ Take full advantage of all your CPU cores by using workers to spread the load. Control how many shards per worker and how many workers to maximize efficiency!
 
 ### Custom Cache
 
@@ -75,10 +76,10 @@ Have your cache setup in any way you like. Redis, PGSQL or any cache layer you w
 Here is a minimal example to get started with:
 
 ```typescript
-import { createBot, startBot } from "https://deno.land/x/discordeno/mod.ts";
-import { enableCachePlugin, enableCacheSweepers } from "https://deno.land/x/discordeno_cache_plugin@0.0.9/mod.ts";
+import { createBot, startBot } from "https://deno.land/x/discordeno@13.0.0-rc15/mod.ts";
+import { enableCachePlugin, enableCacheSweepers } from "https://deno.land/x/discordeno_cache_plugin@0.0.18/mod.ts";
 
-const bot = createBot({
+const baseBot = createBot({
   token: Deno.env.get("DISCORD_TOKEN"),
   intents: ["Guilds", "GuildMessages"],
   botId: Deno.env.get("BOT_ID"),
@@ -90,11 +91,12 @@ const bot = createBot({
       // Process the message with your command handler here
     },
   },
-  cache: { isAsync: false },
 });
 
-enableCachePlugin(bot);
+const bot = enableCachePlugin(baseBot);
+
 enableCacheSweepers(bot);
+
 await startBot(bot);
 ```
 
diff --git a/mod.ts b/mod.ts
index 2c0531975..df3b4248f 100644
--- a/mod.ts
+++ b/mod.ts
@@ -6,4 +6,3 @@ export * from "./src/transformers/mod.ts";
 export * from "./src/types/mod.ts";
 export * from "./src/util/mod.ts";
 export * from "./src/ws/mod.ts";
-export * from "./src/cache.ts";
\ No newline at end of file
diff --git a/src/bot.ts b/src/bot.ts
index abe2482a9..a424d2717 100644
--- a/src/bot.ts
+++ b/src/bot.ts
@@ -49,10 +49,11 @@ import {
   resume,
   resharder,
   spawnShards,
+  prepareBuckets,
   createShard,
   identify,
   heartbeat,
-  tellClusterToIdentify,
+  tellWorkerToIdentify,
   sendShardMessage,
   DiscordenoShard,
   processGatewayQueue,
@@ -77,7 +78,6 @@ import { urlToBase64 } from "./util/urlToBase64.ts";
 import { transformAttachment } from "./transformers/attachment.ts";
 import { transformEmbed } from "./transformers/embed.ts";
 import { transformComponent } from "./transformers/component.ts";
-import { AsyncCache, AsyncCacheHandler, Cache, CacheHandler, createCache, TableNames } from "./cache.ts";
 import { transformWebhook } from "./transformers/webhook.ts";
 import { transformAuditlogEntry } from "./transformers/auditlogEntry.ts";
 import { transformApplicationCommandPermission } from "./transformers/applicationCommandPermission.ts";
@@ -86,22 +86,13 @@ import { calculateBits, calculatePermissions } from "./util/permissions.ts";
 import { transformScheduledEvent } from "./transformers/scheduledEvent.ts";
 import { DiscordenoScheduledEvent } from "./transformers/scheduledEvent.ts";
 import { transformThreadMember } from "./transformers/threadMember.ts";
+import { transformApplicationCommandOption } from "./transformers/applicationCommandOption.ts";
+import { transformApplicationCommand } from "./transformers/applicationCommand.ts";
+import { transformWelcomeScreen } from "./transformers/welcomeScreen.ts";
+import { transformVoiceRegion } from "./transformers/voiceRegion.ts";
+import { transformWidget } from "./transformers/widget.ts";
 
-type CacheOptions =
-  | {
-      isAsync: true;
-      // deno-lint-ignore no-explicit-any
-      tableCreator: (tableName: TableNames) => AsyncCacheHandler<any>;
-    }
-  | {
-      isAsync: false;
-      // deno-lint-ignore no-explicit-any
-      tableCreator?: (tableName: TableNames) => CacheHandler<any>;
-    };
-
-export function createBot<C extends CacheOptions = CacheOptions>(
-  options: CreateBotOptions<C>
-): Bot<C extends { isAsync: true } ? AsyncCache : Cache> {
+export function createBot(options: CreateBotOptions): Bot {
   const bot = {
     id: options.botId,
     applicationId: options.applicationId || options.botId,
@@ -116,13 +107,33 @@ export function createBot<C extends CacheOptions = CacheOptions>(
     transformers: createTransformers(options.transformers ?? {}),
     enabledPlugins: new Set(),
     handleDiscordPayload: options.handleDiscordPayload,
-  } as unknown as Bot<C extends { isAsync: true } ? AsyncCache : Cache>;
+    cache: {
+      unrepliedInteractions: new Set<bigint>(),
+      fetchAllMembersProcessingRequests: new Map(),
+    },
+    rest: createRestManager({ token: options.token, debug: options.events.debug }),
+  } as Bot;
 
-  // @ts-ignore itoh cache types plz
-  bot.cache = createCache(bot as Bot, options.cache);
-  bot.helpers = createHelpers(bot as Bot, options.helpers ?? {});
+  bot.helpers = createHelpers(bot, options.helpers ?? {});
+  bot.gateway = createGatewayManager({
+    token: bot.token,
+    intents: bot.intents,
+    debug: bot.events.debug,
+    handleDiscordPayload:
+      bot.handleDiscordPayload ??
+      async function (_, data: DiscordGatewayPayload, shardId: number) {
+        // TRIGGER RAW EVENT
+        bot.events.raw(bot as Bot, data, shardId);
 
-  return bot as unknown as Bot<C extends { isAsync: true } ? AsyncCache : Cache>;
+        if (!data.t) return;
+
+        // RUN DISPATCH CHECK
+        await bot.events.dispatchRequirements(bot as Bot, data, shardId);
+        bot.handlers[data.t as GatewayDispatchEventNames]?.(bot as Bot, data, shardId);
+      },
+  });
+
+  return bot as Bot;
 }
 
 export function createEventHandlers(events: Partial<EventHandlers>): EventHandlers {
@@ -262,36 +273,17 @@ export function createRestManager(options: CreateRestManagerOptions) {
 }
 
 export async function startBot(bot: Bot) {
-  // START REST
-  bot.rest = createRestManager({ token: bot.token, debug: bot.events.debug });
   if (!bot.botGatewayData) bot.botGatewayData = await bot.helpers.getGatewayBot();
 
-  // START WS
-  bot.gateway = createGatewayManager({
-    token: bot.token,
-    intents: bot.intents,
-    urlWSS: bot.botGatewayData.url,
-    shardsRecommended: bot.botGatewayData.shards,
-    sessionStartLimitTotal: bot.botGatewayData.sessionStartLimit.total,
-    sessionStartLimitRemaining: bot.botGatewayData.sessionStartLimit.remaining,
-    sessionStartLimitResetAfter: bot.botGatewayData.sessionStartLimit.resetAfter,
-    maxConcurrency: bot.botGatewayData.sessionStartLimit.maxConcurrency,
-    lastShardId: bot.botGatewayData.shards,
-    maxShards: bot.botGatewayData.shards,
-    debug: bot.events.debug,
-    handleDiscordPayload:
-      bot.handleDiscordPayload ??
-      async function (_, data: DiscordGatewayPayload, shardId: number) {
-        // TRIGGER RAW EVENT
-        bot.events.raw(bot as Bot, data, shardId);
-
-        if (!data.t) return;
-
-        // RUN DISPATCH CHECK
-        await bot.events.dispatchRequirements(bot as Bot, data, shardId);
-        bot.handlers[data.t as GatewayDispatchEventNames]?.(bot as Bot, data, shardId);
-      },
-  });
+  // SETUP GATEWAY LOGIN INFO
+  bot.gateway.urlWSS = bot.botGatewayData.url;
+  bot.gateway.shardsRecommended = bot.botGatewayData.shards;
+  bot.gateway.sessionStartLimitTotal = bot.botGatewayData.sessionStartLimit.total;
+  bot.gateway.sessionStartLimitRemaining = bot.botGatewayData.sessionStartLimit.remaining;
+  bot.gateway.sessionStartLimitResetAfter = bot.botGatewayData.sessionStartLimit.resetAfter;
+  bot.gateway.maxConcurrency = bot.botGatewayData.sessionStartLimit.maxConcurrency;
+  bot.gateway.lastShardId = bot.botGatewayData.shards;
+  bot.gateway.maxShards = bot.botGatewayData.shards;
 
   bot.gateway.spawnShards(bot.gateway);
 }
@@ -344,8 +336,8 @@ export function createGatewayManager(
     spawnShardDelay: options.spawnShardDelay ?? 2600,
     maxShards: options.maxShards ?? options.shardsRecommended ?? 0,
     useOptimalLargeBotSharding: options.useOptimalLargeBotSharding ?? true,
-    shardsPerCluster: options.shardsPerCluster ?? 25,
-    maxClusters: options.maxClusters ?? 4,
+    shardsPerWorker: options.shardsPerWorker ?? 25,
+    maxWorkers: options.maxWorkers ?? 4,
     firstShardId: options.firstShardId ?? 0,
     lastShardId: options.lastShardId ?? options.maxShards ?? options.shardsRecommended ?? 1,
     token: options.token ?? "",
@@ -369,11 +361,12 @@ export function createGatewayManager(
     buckets: new Collection(),
     utf8decoder: new TextDecoder(),
 
+    prepareBuckets: options.prepareBuckets ?? prepareBuckets,
     spawnShards: options.spawnShards ?? spawnShards,
     createShard: options.createShard ?? createShard,
     identify: options.identify ?? identify,
     heartbeat: options.heartbeat ?? heartbeat,
-    tellClusterToIdentify,
+    tellWorkerToIdentify,
     debug: options.debug || function () {},
     resharder: options.resharder ?? resharder,
     handleOnMessage: options.handleOnMessage ?? handleOnMessage,
@@ -397,7 +390,7 @@ export async function stopBot(bot: Bot) {
   return bot;
 }
 
-export interface CreateBotOptions<C extends CacheOptions = CacheOptions> {
+export interface CreateBotOptions {
   token: string;
   botId: bigint;
   applicationId?: bigint;
@@ -406,7 +399,6 @@ export interface CreateBotOptions<C extends CacheOptions = CacheOptions> {
   botGatewayData?: GetGatewayBot;
   rest?: Omit<CreateRestManagerOptions, "token">;
   handleDiscordPayload?: GatewayManager["handleDiscordPayload"];
-  cache: C;
   utils?: Partial<ReturnType<typeof createUtils>>;
   transformers?: Partial<ReturnType<typeof createTransformers>>;
   helpers?: Partial<Helpers>;
@@ -414,20 +406,9 @@ export interface CreateBotOptions<C extends CacheOptions = CacheOptions> {
 
 export type UnPromise<T extends Promise<unknown>> = T extends Promise<infer K> ? K : never;
 
-// export type CreatedBot = ReturnType<typeof createBot>;
-
-// export type Bot = CreatedBot & {
-//   utils: HelperUtils;
-//   rest: RestManager;
-//   gateway: GatewayManager;
-//   transformers: Transformers;
-//   helpers: Helpers;
-// };
-
-export interface Bot<C extends Cache | AsyncCache = AsyncCache | Cache> {
+export interface Bot {
   id: bigint;
   applicationId: bigint;
-
   token: string;
   intents: GatewayIntents;
   urlWSS: string;
@@ -441,163 +422,18 @@ export interface Bot<C extends Cache | AsyncCache = AsyncCache | Cache> {
   handlers: ReturnType<typeof createBotGatewayHandlers>;
   activeGuildIds: Set<bigint>;
   constants: ReturnType<typeof createBotConstants>;
-  cache: C;
+  cache: {
+    unrepliedInteractions: Set<bigint>;
+    fetchAllMembersProcessingRequests: Map<string, Function>;
+  };
   enabledPlugins: Set<string>;
   handleDiscordPayload?: GatewayManager["handleDiscordPayload"];
 }
 
-export interface Helpers {
-  addDiscoverySubcategory: typeof helpers.addDiscoverySubcategory;
-  addReaction: typeof helpers.addReaction;
-  addReactions: typeof helpers.addReactions;
-  addRole: typeof helpers.addRole;
-  avatarURL: typeof helpers.avatarURL;
-  banMember: typeof helpers.banMember;
-  batchEditApplicationCommandPermissions: typeof helpers.batchEditApplicationCommandPermissions;
-  channelOverwriteHasPermission: typeof helpers.channelOverwriteHasPermission;
-  cloneChannel: typeof helpers.cloneChannel;
-  connectToVoiceChannel: typeof helpers.connectToVoiceChannel;
-  createChannel: typeof helpers.createChannel;
-  createEmoji: typeof helpers.createEmoji;
-  createGuild: typeof helpers.createGuild;
-  createGuildFromTemplate: typeof helpers.createGuildFromTemplate;
-  createGuildTemplate: typeof helpers.createGuildTemplate;
-  createInvite: typeof helpers.createInvite;
-  createRole: typeof helpers.createRole;
-  createScheduledEvent: typeof helpers.createScheduledEvent;
-  createApplicationCommand: typeof helpers.createApplicationCommand;
-  createStageInstance: typeof helpers.createStageInstance;
-  createWebhook: typeof helpers.createWebhook;
-  deleteChannel: typeof helpers.deleteChannel;
-  deleteChannelOverwrite: typeof helpers.deleteChannelOverwrite;
-  deleteEmoji: typeof helpers.deleteEmoji;
-  deleteGuild: typeof helpers.deleteGuild;
-  deleteGuildTemplate: typeof helpers.deleteGuildTemplate;
-  deleteIntegration: typeof helpers.deleteIntegration;
-  deleteInvite: typeof helpers.deleteInvite;
-  deleteMessage: typeof helpers.deleteMessage;
-  deleteMessages: typeof helpers.deleteMessages;
-  deleteRole: typeof helpers.deleteRole;
-  deleteScheduledEvent: typeof helpers.deleteScheduledEvent;
-  deleteApplicationCommand: typeof helpers.deleteApplicationCommand;
-  deleteInteractionResponse: typeof helpers.deleteInteractionResponse;
-  deleteStageInstance: typeof helpers.deleteStageInstance;
-  deleteWebhook: typeof helpers.deleteWebhook;
-  deleteWebhookMessage: typeof helpers.deleteWebhookMessage;
-  deleteWebhookWithToken: typeof helpers.deleteWebhookWithToken;
-  disconnectMember: typeof helpers.disconnectMember;
-  editBotNickname: typeof helpers.editBotNickname;
-  editBotProfile: typeof helpers.editBotProfile;
-  editBotStatus: typeof helpers.editBotStatus;
-  editChannel: typeof helpers.editChannel;
-  editChannelOverwrite: typeof helpers.editChannelOverwrite;
-  editDiscovery: typeof helpers.editDiscovery;
-  editEmoji: typeof helpers.editEmoji;
-  editGuild: typeof helpers.editGuild;
-  editGuildTemplate: typeof helpers.editGuildTemplate;
-  editMember: typeof helpers.editMember;
-  editMessage: typeof helpers.editMessage;
-  editRole: typeof helpers.editRole;
-  editScheduledEvent: typeof helpers.editScheduledEvent;
-  editInteractionResponse: typeof helpers.editInteractionResponse;
-  editApplicationCommandPermissions: typeof helpers.editApplicationCommandPermissions;
-  editWebhook: typeof helpers.editWebhook;
-  editWebhookMessage: typeof helpers.editWebhookMessage;
-  editWebhookWithToken: typeof helpers.editWebhookWithToken;
-  editWelcomeScreen: typeof helpers.editWelcomeScreen;
-  editWidget: typeof helpers.editWidget;
-  emojiUrl: typeof helpers.emojiUrl;
-  fetchMembers: typeof helpers.fetchMembers;
-  followChannel: typeof helpers.followChannel;
-  getAuditLogs: typeof helpers.getAuditLogs;
-  getAvailableVoiceRegions: typeof helpers.getAvailableVoiceRegions;
-  getBan: typeof helpers.getBan;
-  getBans: typeof helpers.getBans;
-  getChannel: typeof helpers.getChannel;
-  getChannelInvites: typeof helpers.getChannelInvites;
-  getChannels: typeof helpers.getChannels;
-  getChannelWebhooks: typeof helpers.getChannelWebhooks;
-  getDiscoveryCategories: typeof helpers.getDiscoveryCategories;
-  getEmoji: typeof helpers.getEmoji;
-  getEmojis: typeof helpers.getEmojis;
-  getGatewayBot: typeof helpers.getGatewayBot;
-  getGuild: typeof helpers.getGuild;
-  getGuildPreview: typeof helpers.getGuildPreview;
-  getGuildTemplates: typeof helpers.getGuildTemplates;
-  getIntegrations: typeof helpers.getIntegrations;
-  getInvite: typeof helpers.getInvite;
-  getInvites: typeof helpers.getInvites;
-  getMember: typeof helpers.getMember;
-  getMembers: typeof helpers.getMembers;
-  getMessage: typeof helpers.getMessage;
-  getMessages: typeof helpers.getMessages;
-  getOriginalInteractionResponse: typeof helpers.getOriginalInteractionResponse;
-  getPins: typeof helpers.getPins;
-  getPruneCount: typeof helpers.getPruneCount;
-  getReactions: typeof helpers.getReactions;
-  getRoles: typeof helpers.getRoles;
-  getScheduledEvent: typeof helpers.getScheduledEvent;
-  getScheduledEvents: typeof helpers.getScheduledEvents;
-  getScheduledEventUsers: typeof helpers.getScheduledEventUsers;
-  getApplicationCommand: typeof helpers.getApplicationCommand;
-  getApplicationCommandPermission: typeof helpers.getApplicationCommandPermission;
-  getApplicationCommandPermissions: typeof helpers.getApplicationCommandPermissions;
-  getApplicationCommands: typeof helpers.getApplicationCommands;
-  getStageInstance: typeof helpers.getStageInstance;
-  getTemplate: typeof helpers.getTemplate;
-  getUser: typeof helpers.getUser;
-  getApplicationInfo: typeof helpers.getApplicationInfo;
-  getVanityURL: typeof helpers.getVanityURL;
-  getVoiceRegions: typeof helpers.getVoiceRegions;
-  getWebhook: typeof helpers.getWebhook;
-  getWebhookMessage: typeof helpers.getWebhookMessage;
-  getWebhooks: typeof helpers.getWebhooks;
-  getWebhookWithToken: typeof helpers.getWebhookWithToken;
-  getWelcomeScreen: typeof helpers.getWelcomeScreen;
-  getWidget: typeof helpers.getWidget;
-  getWidgetImageURL: typeof helpers.getWidgetImageURL;
-  getWidgetSettings: typeof helpers.getWidgetSettings;
-  guildBannerURL: typeof helpers.guildBannerURL;
-  guildIconURL: typeof helpers.guildIconURL;
-  guildSplashURL: typeof helpers.guildSplashURL;
-  kickMember: typeof helpers.kickMember;
-  leaveGuild: typeof helpers.leaveGuild;
-  moveMember: typeof helpers.moveMember;
-  pinMessage: typeof helpers.pinMessage;
-  pruneMembers: typeof helpers.pruneMembers;
-  publishMessage: typeof helpers.publishMessage;
-  removeAllReactions: typeof helpers.removeAllReactions;
-  removeDiscoverySubcategory: typeof helpers.removeDiscoverySubcategory;
-  removeReaction: typeof helpers.removeReaction;
-  removeReactionEmoji: typeof helpers.removeReactionEmoji;
-  removeRole: typeof helpers.removeRole;
-  getDmChannel: typeof helpers.getDmChannel;
-  sendInteractionResponse: typeof helpers.sendInteractionResponse;
-  sendMessage: typeof helpers.sendMessage;
-  sendWebhook: typeof helpers.sendWebhook;
-  startTyping: typeof helpers.startTyping;
-  swapChannels: typeof helpers.swapChannels;
-  syncGuildTemplate: typeof helpers.syncGuildTemplate;
-  unbanMember: typeof helpers.unbanMember;
-  unpinMessage: typeof helpers.unpinMessage;
-  updateBotVoiceState: typeof helpers.updateBotVoiceState;
-  updateStageInstance: typeof helpers.updateStageInstance;
-  upsertApplicationCommand: typeof helpers.upsertApplicationCommand;
-  upsertApplicationCommands: typeof helpers.upsertApplicationCommands;
-  validDiscoveryTerm: typeof helpers.validDiscoveryTerm;
-  addToThread: typeof helpers.addToThread;
-  deleteThread: typeof helpers.deleteThread;
-  editThread: typeof helpers.editThread;
-  getActiveThreads: typeof helpers.getActiveThreads;
-  getArchivedThreads: typeof helpers.getArchivedThreads;
-  getThreadMember: typeof helpers.getThreadMember;
-  getThreadMembers: typeof helpers.getThreadMembers;
-  joinThread: typeof helpers.joinThread;
-  leaveThread: typeof helpers.leaveThread;
-  removeThreadMember: typeof helpers.removeThreadMember;
-  startThreadWithoutMessage: typeof helpers.startThreadWithoutMessage;
-  startThreadWithMessage: typeof helpers.startThreadWithMessage;
-}
+export const defaultHelpers = { ...helpers };
+export type DefaultHelpers = typeof defaultHelpers;
+// deno-lint-ignore no-empty-interface
+export interface Helpers extends DefaultHelpers {} // Use interface for declaration merging
 
 export function createHelpers(bot: Bot, customHelpers?: Partial<Helpers>): FinalHelpers {
   const converted = {} as FinalHelpers;
@@ -613,159 +449,8 @@ export function createHelpers(bot: Bot, customHelpers?: Partial<Helpers>): Final
 
 export function createBaseHelpers(options: Partial<Helpers>) {
   return {
-    addDiscoverySubcategory: options.addDiscoverySubcategory || helpers.addDiscoverySubcategory,
-    addReaction: options.addReaction || helpers.addReaction,
-    addReactions: options.addReactions || helpers.addReactions,
-    addRole: options.addRole || helpers.addRole,
-    avatarURL: options.avatarURL || helpers.avatarURL,
-    banMember: options.banMember || helpers.banMember,
-    batchEditApplicationCommandPermissions:
-      options.batchEditApplicationCommandPermissions || helpers.batchEditApplicationCommandPermissions,
-    channelOverwriteHasPermission: options.channelOverwriteHasPermission || helpers.channelOverwriteHasPermission,
-    cloneChannel: options.cloneChannel || helpers.cloneChannel,
-    connectToVoiceChannel: options.connectToVoiceChannel || helpers.connectToVoiceChannel,
-    createChannel: options.createChannel || helpers.createChannel,
-    createEmoji: options.createEmoji || helpers.createEmoji,
-    createGuild: options.createGuild || helpers.createGuild,
-    createGuildFromTemplate: options.createGuildFromTemplate || helpers.createGuildFromTemplate,
-    createGuildTemplate: options.createGuildTemplate || helpers.createGuildTemplate,
-    createInvite: options.createInvite || helpers.createInvite,
-    createRole: options.createRole || helpers.createRole,
-    createScheduledEvent: options.createScheduledEvent || helpers.createScheduledEvent,
-    createApplicationCommand: options.createApplicationCommand || helpers.createApplicationCommand,
-    createStageInstance: options.createStageInstance || helpers.createStageInstance,
-    createWebhook: options.createWebhook || helpers.createWebhook,
-    deleteChannel: options.deleteChannel || helpers.deleteChannel,
-    deleteChannelOverwrite: options.deleteChannelOverwrite || helpers.deleteChannelOverwrite,
-    deleteEmoji: options.deleteEmoji || helpers.deleteEmoji,
-    deleteGuild: options.deleteGuild || helpers.deleteGuild,
-    deleteGuildTemplate: options.deleteGuildTemplate || helpers.deleteGuildTemplate,
-    deleteIntegration: options.deleteIntegration || helpers.deleteIntegration,
-    deleteInvite: options.deleteInvite || helpers.deleteInvite,
-    deleteMessage: options.deleteMessage || helpers.deleteMessage,
-    deleteMessages: options.deleteMessages || helpers.deleteMessages,
-    deleteRole: options.deleteRole || helpers.deleteRole,
-    deleteScheduledEvent: options.deleteScheduledEvent || helpers.deleteScheduledEvent,
-    deleteApplicationCommand: options.deleteApplicationCommand || helpers.deleteApplicationCommand,
-    deleteInteractionResponse: options.deleteInteractionResponse || helpers.deleteInteractionResponse,
-    deleteStageInstance: options.deleteStageInstance || helpers.deleteStageInstance,
-    deleteWebhook: options.deleteWebhook || helpers.deleteWebhook,
-    deleteWebhookMessage: options.deleteWebhookMessage || helpers.deleteWebhookMessage,
-    deleteWebhookWithToken: options.deleteWebhookWithToken || helpers.deleteWebhookWithToken,
-    disconnectMember: options.disconnectMember || helpers.disconnectMember,
-    editBotNickname: options.editBotNickname || helpers.editBotNickname,
-    editBotProfile: options.editBotProfile || helpers.editBotProfile,
-    editBotStatus: options.editBotStatus || helpers.editBotStatus,
-    editChannel: options.editChannel || helpers.editChannel,
-    editChannelOverwrite: options.editChannelOverwrite || helpers.editChannelOverwrite,
-    editDiscovery: options.editDiscovery || helpers.editDiscovery,
-    editEmoji: options.editEmoji || helpers.editEmoji,
-    editGuild: options.editGuild || helpers.editGuild,
-    editGuildTemplate: options.editGuildTemplate || helpers.editGuildTemplate,
-    editMember: options.editMember || helpers.editMember,
-    editMessage: options.editMessage || helpers.editMessage,
-    editRole: options.editRole || helpers.editRole,
-    editScheduledEvent: options.editScheduledEvent || helpers.editScheduledEvent,
-    editInteractionResponse: options.editInteractionResponse || helpers.editInteractionResponse,
-    editApplicationCommandPermissions:
-      options.editApplicationCommandPermissions || helpers.editApplicationCommandPermissions,
-    editWebhook: options.editWebhook || helpers.editWebhook,
-    editWebhookMessage: options.editWebhookMessage || helpers.editWebhookMessage,
-    editWebhookWithToken: options.editWebhookWithToken || helpers.editWebhookWithToken,
-    editWelcomeScreen: options.editWelcomeScreen || helpers.editWelcomeScreen,
-    editWidget: options.editWidget || helpers.editWidget,
-    emojiUrl: options.emojiUrl || helpers.emojiUrl,
-    fetchMembers: options.fetchMembers || helpers.fetchMembers,
-    followChannel: options.followChannel || helpers.followChannel,
-    getAuditLogs: options.getAuditLogs || helpers.getAuditLogs,
-    getAvailableVoiceRegions: options.getAvailableVoiceRegions || helpers.getAvailableVoiceRegions,
-    getBan: options.getBan || helpers.getBan,
-    getBans: options.getBans || helpers.getBans,
-    getChannel: options.getChannel || helpers.getChannel,
-    getChannelInvites: options.getChannelInvites || helpers.getChannelInvites,
-    getChannels: options.getChannels || helpers.getChannels,
-    getChannelWebhooks: options.getChannelWebhooks || helpers.getChannelWebhooks,
-    getDiscoveryCategories: options.getDiscoveryCategories || helpers.getDiscoveryCategories,
-    getEmoji: options.getEmoji || helpers.getEmoji,
-    getEmojis: options.getEmojis || helpers.getEmojis,
-    getGatewayBot: options.getGatewayBot || helpers.getGatewayBot,
-    getGuild: options.getGuild || helpers.getGuild,
-    getGuildPreview: options.getGuildPreview || helpers.getGuildPreview,
-    getGuildTemplates: options.getGuildTemplates || helpers.getGuildTemplates,
-    getIntegrations: options.getIntegrations || helpers.getIntegrations,
-    getInvite: options.getInvite || helpers.getInvite,
-    getInvites: options.getInvites || helpers.getInvites,
-    getMember: options.getMember || helpers.getMember,
-    getMembers: options.getMembers || helpers.getMembers,
-    getMessage: options.getMessage || helpers.getMessage,
-    getMessages: options.getMessages || helpers.getMessages,
-    getOriginalInteractionResponse: options.getOriginalInteractionResponse || helpers.getOriginalInteractionResponse,
-    getPins: options.getPins || helpers.getPins,
-    getPruneCount: options.getPruneCount || helpers.getPruneCount,
-    getReactions: options.getReactions || helpers.getReactions,
-    getRoles: options.getRoles || helpers.getRoles,
-    getScheduledEvent: options.getScheduledEvent || helpers.getScheduledEvent,
-    getScheduledEventUsers: options.getScheduledEventUsers || helpers.getScheduledEventUsers,
-    getScheduledEvents: options.getScheduledEvents || helpers.getScheduledEvents,
-    getApplicationCommand: options.getApplicationCommand || helpers.getApplicationCommand,
-    getApplicationCommandPermission: options.getApplicationCommandPermission || helpers.getApplicationCommandPermission,
-    getApplicationCommandPermissions:
-      options.getApplicationCommandPermissions || helpers.getApplicationCommandPermissions,
-    getApplicationCommands: options.getApplicationCommands || helpers.getApplicationCommands,
-    getStageInstance: options.getStageInstance || helpers.getStageInstance,
-    getTemplate: options.getTemplate || helpers.getTemplate,
-    getUser: options.getUser || helpers.getUser,
-    getApplicationInfo: options.getApplicationInfo || helpers.getApplicationInfo,
-    getVanityURL: options.getVanityURL || helpers.getVanityURL,
-    getVoiceRegions: options.getVoiceRegions || helpers.getVoiceRegions,
-    getWebhook: options.getWebhook || helpers.getWebhook,
-    getWebhookMessage: options.getWebhookMessage || helpers.getWebhookMessage,
-    getWebhooks: options.getWebhooks || helpers.getWebhooks,
-    getWebhookWithToken: options.getWebhookWithToken || helpers.getWebhookWithToken,
-    getWelcomeScreen: options.getWelcomeScreen || helpers.getWelcomeScreen,
-    getWidget: options.getWidget || helpers.getWidget,
-    getWidgetImageURL: options.getWidgetImageURL || helpers.getWidgetImageURL,
-    getWidgetSettings: options.getWidgetSettings || helpers.getWidgetSettings,
-    guildBannerURL: options.guildBannerURL || helpers.guildBannerURL,
-    guildIconURL: options.guildIconURL || helpers.guildIconURL,
-    guildSplashURL: options.guildSplashURL || helpers.guildSplashURL,
-    kickMember: options.kickMember || helpers.kickMember,
-    leaveGuild: options.leaveGuild || helpers.leaveGuild,
-    moveMember: options.moveMember || helpers.moveMember,
-    pinMessage: options.pinMessage || helpers.pinMessage,
-    pruneMembers: options.pruneMembers || helpers.pruneMembers,
-    publishMessage: options.publishMessage || helpers.publishMessage,
-    removeAllReactions: options.removeAllReactions || helpers.removeAllReactions,
-    removeDiscoverySubcategory: options.removeDiscoverySubcategory || helpers.removeDiscoverySubcategory,
-    removeReaction: options.removeReaction || helpers.removeReaction,
-    removeReactionEmoji: options.removeReactionEmoji || helpers.removeReactionEmoji,
-    removeRole: options.removeRole || helpers.removeRole,
-    getDmChannel: options.getDmChannel || helpers.getDmChannel,
-    sendInteractionResponse: options.sendInteractionResponse || helpers.sendInteractionResponse,
-    sendMessage: options.sendMessage || helpers.sendMessage,
-    sendWebhook: options.sendWebhook || helpers.sendWebhook,
-    startTyping: options.startTyping || helpers.startTyping,
-    swapChannels: options.swapChannels || helpers.swapChannels,
-    syncGuildTemplate: options.syncGuildTemplate || helpers.syncGuildTemplate,
-    unbanMember: options.unbanMember || helpers.unbanMember,
-    unpinMessage: options.unpinMessage || helpers.unpinMessage,
-    updateBotVoiceState: options.updateBotVoiceState || helpers.updateBotVoiceState,
-    updateStageInstance: options.updateStageInstance || helpers.updateStageInstance,
-    upsertApplicationCommand: options.upsertApplicationCommand || helpers.upsertApplicationCommand,
-    upsertApplicationCommands: options.upsertApplicationCommands || helpers.upsertApplicationCommands,
-    validDiscoveryTerm: options.validDiscoveryTerm || helpers.validDiscoveryTerm,
-    addToThread: options.addToThread || helpers.addToThread,
-    deleteThread: options.deleteThread || helpers.deleteThread,
-    editThread: options.editThread || helpers.editThread,
-    getActiveThreads: options.getActiveThreads || helpers.getActiveThreads,
-    getArchivedThreads: options.getArchivedThreads || helpers.getArchivedThreads,
-    getThreadMember: options.getThreadMember || helpers.getThreadMember,
-    getThreadMembers: options.getThreadMembers || helpers.getThreadMembers,
-    joinThread: options.joinThread || helpers.joinThread,
-    leaveThread: options.leaveThread || helpers.leaveThread,
-    removeThreadMember: options.removeThreadMember || helpers.removeThreadMember,
-    startThreadWithoutMessage: options.startThreadWithoutMessage || helpers.startThreadWithoutMessage,
-    startThreadWithMessage: options.startThreadWithMessage || helpers.startThreadWithMessage,
+    ...defaultHelpers,
+    ...options,
   };
 }
 
@@ -791,9 +476,14 @@ export interface Transformers {
   component: typeof transformComponent;
   webhook: typeof transformWebhook;
   auditlogEntry: typeof transformAuditlogEntry;
+  applicationCommand: typeof transformApplicationCommand;
+  applicationCommandOption: typeof transformApplicationCommandOption;
   applicationCommandPermission: typeof transformApplicationCommandPermission;
   scheduledEvent: typeof transformScheduledEvent;
   threadMember: typeof transformThreadMember;
+  welcomeScreen: typeof transformWelcomeScreen;
+  voiceRegion: typeof transformVoiceRegion;
+  widget: typeof transformWidget;
 }
 
 export function createTransformers(options: Partial<Transformers>) {
@@ -819,9 +509,14 @@ export function createTransformers(options: Partial<Transformers>) {
     snowflake: options.snowflake || snowflakeToBigint,
     webhook: options.webhook || transformWebhook,
     auditlogEntry: options.auditlogEntry || transformAuditlogEntry,
+    applicationCommand: options.applicationCommand || transformApplicationCommand,
+    applicationCommandOption: options.applicationCommandOption || transformApplicationCommandOption,
     applicationCommandPermission: options.applicationCommandPermission || transformApplicationCommandPermission,
     scheduledEvent: options.scheduledEvent || transformScheduledEvent,
     threadMember: options.threadMember || transformThreadMember,
+    welcomeScreen: options.welcomeScreen || transformWelcomeScreen,
+    voiceRegion: options.voiceRegion || transformVoiceRegion,
+    widget: options.widget || transformWidget,
   };
 }
 
@@ -843,9 +538,9 @@ export interface GatewayManager {
   /** Whether or not the resharder should automatically switch to LARGE BOT SHARDING when you are above 100K servers. */
   useOptimalLargeBotSharding: boolean;
   /** The amount of shards to load per worker. */
-  shardsPerCluster: number;
+  shardsPerWorker: number;
   /** The maximum amount of workers to use for your bot. */
-  maxClusters: number;
+  maxWorkers: number;
   /** The first shard Id to start spawning. */
   firstShardId: number;
   /** The last shard Id for this worker. */
@@ -880,7 +575,6 @@ export interface GatewayManager {
     {
       shardId: number;
       resolve: (value: unknown) => void;
-      startedAt: number;
     }
   >;
   /** Stored as bucketId: { workers: [workerId, [ShardIds]], createNextShard: boolean } */
@@ -901,6 +595,8 @@ export interface GatewayManager {
 
   // METHODS
 
+  /** Prepares the buckets for identifying */
+  prepareBuckets: typeof prepareBuckets;
   /** The handler for spawning ALL the shards. */
   spawnShards: typeof spawnShards;
   /** Create the websocket and adds the proper handlers to the websocket. */
@@ -912,7 +608,7 @@ export interface GatewayManager {
   /** Sends the discord payload to another server. */
   handleDiscordPayload: (gateway: GatewayManager, data: GatewayPayload, shardId: number) => any;
   /** Tell the worker to begin identifying this shard  */
-  tellClusterToIdentify: typeof tellClusterToIdentify;
+  tellWorkerToIdentify: typeof tellWorkerToIdentify;
   /** Handle the different logs. Used for debugging. */
   debug: (text: string, ...args: any[]) => unknown;
   /** Handles resharding the bot when necessary. */
diff --git a/src/cache.ts b/src/cache.ts
deleted file mode 100644
index a7b1b834b..000000000
--- a/src/cache.ts
+++ /dev/null
@@ -1,296 +0,0 @@
-import type { Bot } from "./bot.ts";
-import type { DiscordenoChannel } from "./transformers/channel.ts";
-import type { DiscordenoGuild } from "./transformers/guild.ts";
-import type { DiscordenoMember, DiscordenoUser } from "./transformers/member.ts";
-import type { DiscordenoMessage } from "./transformers/message.ts";
-import { DiscordenoPresence } from "./transformers/presence.ts";
-import { GuildMember } from "./types/members/guildMember.ts";
-import { Collection } from "./util/collection.ts";
-
-function messageSweeper(bot: Bot, message: DiscordenoMessage) {
-  // DM messages aren't needed
-  if (!message.guildId) return true;
-
-  // Only delete messages older than 10 minutes
-  return Date.now() - message.timestamp > 600000;
-}
-
-function memberSweeper(bot: Bot, member: DiscordenoMember) {
-  // Don't sweep the bot else strange things will happen
-  if (member.id === bot.id) return false;
-
-  // Only sweep members who were not active the last 30 minutes
-  return Date.now() - member.cachedAt > 1800000;
-}
-
-function guildSweeper(bot: Bot<Cache>, guild: DiscordenoGuild) {
-  // Reset activity for next interval
-  if (bot.cache.activeGuildIds.delete(guild.id)) return false;
-
-  // This is inactive guild. Not a single thing has happened for atleast 30 minutes.
-  // Not a reaction, not a message, not any event!
-  bot.cache.dispatchedGuildIds.add(guild.id);
-
-  return true;
-}
-
-function channelSweeper(bot: Bot<Cache>, channel: DiscordenoChannel, key: bigint) {
-  // If this is in a guild and the guild was dispatched, then we can dispatch the channel
-  if (channel.guildId && bot.cache.dispatchedGuildIds.has(channel.guildId)) {
-    bot.cache.dispatchedChannelIds.add(channel.id);
-    return true;
-  }
-
-  // THE KEY DM CHANNELS ARE STORED BY IS THE USER ID. If the user is not cached, we dont need to cache their dm channel.
-  if (!channel.guildId && !bot.cache.members.has(key)) return true;
-
-  return false;
-}
-
-export function createCache(
-  bot: Bot,
-  options: {
-    isAsync: true;
-    tableCreator: (bot: Bot, tableName: TableNames) => AsyncCacheHandler<any>;
-  }
-): AsyncCache;
-export function createCache(
-  bot: Bot,
-  options: {
-    isAsync: false;
-    tableCreator?: (bot: Bot, tableName: TableNames) => CacheHandler<any>;
-  }
-): Cache;
-export function createCache(
-  bot: Bot,
-  options: {
-    isAsync: boolean;
-    tableCreator?: (bot: Bot, tableName: TableNames) => CacheHandler<any> | AsyncCacheHandler<any>;
-  }
-): Omit<Cache, "execute"> | Omit<AsyncCache, "execute"> {
-  let cache: Cache | AsyncCache;
-
-  if (options.isAsync) {
-    if (!options.tableCreator) {
-      throw new Error("Async cache requires a tableCreator to be passed.");
-    }
-
-    cache = {
-      guilds: options.tableCreator(bot, "guilds"),
-      users: options.tableCreator(bot, "users"),
-      members: options.tableCreator(bot, "members"),
-      channels: options.tableCreator(bot, "channels"),
-      messages: options.tableCreator(bot, "messages"),
-      presences: options.tableCreator(bot, "presences"),
-      // threads: options.tableCreator(bot, "threads"),
-      unavailableGuilds: options.tableCreator(bot, "unavailableGuilds"),
-      dispatchedGuildIds: options.tableCreator(bot, "dispatchedGuildIds"),
-      dispatchedChannelIds: options.tableCreator(bot, "dispatchedChannelIds"),
-      activeGuildIds: options.tableCreator(bot, "activeGuildIds"),
-      unrepliedInteractions: new Set<bigint>(),
-      fetchAllMembersProcessingRequests: new Map(),
-      execute: async function () {
-        throw new Error("Async Cache requires a custom execute function to be implemented.");
-      },
-    } as AsyncCache;
-  } else {
-    if (!options.tableCreator) options.tableCreator = createTable;
-
-    cache = {
-      guilds: options.tableCreator(bot, "guilds"),
-      users: options.tableCreator(bot, "users"),
-      members: options.tableCreator(bot, "members"),
-      channels: options.tableCreator(bot, "channels"),
-      messages: options.tableCreator(bot, "messages"),
-      presences: options.tableCreator(bot, "presences"),
-      // threads: options.tableCreator(bot, "threads"),
-      unavailableGuilds: options.tableCreator(bot, "unavailableGuilds"),
-      dispatchedGuildIds: new Set(),
-      dispatchedChannelIds: new Set(),
-      activeGuildIds: new Set(),
-      unrepliedInteractions: new Set<bigint>(),
-      fetchAllMembersProcessingRequests: new Map(),
-    } as Cache;
-
-    cache.execute = createExecute(cache);
-  }
-
-  // Interaction sweeper in case users don't reply do slash commands
-  // PS: always reply .-. its good practise
-  // setInterval(() => {
-  //   const values = cache.unrepliedInteractions.values();
-  //   const now = Date.now();
-  //   for (let val; (val = values.next().value); ) {
-  //     // Interaction is older than 15 minutes
-  //     // and a reply has never been send
-  //     // so remove it from cache
-  //     // PS: DON'T USE THIS CODE TO CONVERT DC SNOWFLAKES TO UNIX
-  //     // SINCE U WILL GET AN INVALID RESULT
-  //     if ((val >> 22n) + 1420071300000n < now) {
-  //       cache.unrepliedInteractions.delete(val);
-  //     }
-  //   }
-  // }, 300000);
-
-  return cache;
-}
-
-export type CachedDiscordenoUser = DiscordenoUser & { guilds: Map<bigint, GuildMember> };
-
-export interface Cache {
-  guilds: CacheHandler<DiscordenoGuild>;
-  users: CacheHandler<DiscordenoUser>;
-  members: CacheHandler<DiscordenoMember>;
-  channels: CacheHandler<DiscordenoChannel>;
-  messages: CacheHandler<DiscordenoMessage>;
-  presences: CacheHandler<DiscordenoPresence>;
-  // threads: CacheHandler<DiscordenoThread>;
-  unavailableGuilds: CacheHandler<CachedUnavailableGuild>;
-  dispatchedGuildIds: Set<bigint>;
-  dispatchedChannelIds: Set<bigint>;
-  activeGuildIds: Set<bigint>;
-  unrepliedInteractions: Set<bigint>;
-  fetchAllMembersProcessingRequests: Map<string, Function>;
-  execute: CacheExecutor;
-}
-
-export interface CachedUnavailableGuild {
-  shardId: number;
-  since: number;
-  dispatched?: true;
-}
-
-export interface AsyncCache {
-  guilds: AsyncCacheHandler<DiscordenoGuild>;
-  users: AsyncCacheHandler<DiscordenoUser>;
-  members: CacheHandler<DiscordenoMember>;
-  channels: AsyncCacheHandler<DiscordenoChannel>;
-  messages: AsyncCacheHandler<DiscordenoMessage>;
-  presences: AsyncCacheHandler<DiscordenoPresence>;
-  // threads: AsyncCacheHandler<DiscordenoThread>;
-  unavailableGuilds: AsyncCacheHandler<CachedUnavailableGuild>;
-  dispatchedGuildIds: AsyncCacheHandler<bigint>;
-  dispatchedChannelIds: AsyncCacheHandler<bigint>;
-  activeGuildIds: AsyncCacheHandler<bigint>;
-  unrepliedInteractions: Set<bigint>;
-  fetchAllMembersProcessingRequests: Map<string, Function>;
-  execute: CacheExecutor;
-}
-
-function createTable<T>(bot: Bot, _table: TableNames): CacheHandler<T> {
-  const table = new Collection<bigint, T>();
-
-  // @ts-ignore TODO: fix type error itoh pwease
-  if (_table === "guilds") table.startSweeper({ filter: guildSweeper, interval: 3660000, bot });
-  // @ts-ignore TODO: fix type error itoh pwease
-  if (_table === "channels") table.startSweeper({ filter: channelSweeper, interval: 3660000, bot });
-  // @ts-ignore TODO: fix type error itoh pwease
-  if (_table === "messages") table.startSweeper({ filter: messageSweeper, interval: 300000, bot });
-  // @ts-ignore TODO: fix type error itoh pwease
-  if (_table === "members") table.startSweeper({ filter: memberSweeper, interval: 300000, bot });
-  if (_table === "presences") table.startSweeper({ filter: () => true, interval: 300000, bot });
-
-  return {
-    clear: () => table.clear(),
-    delete: (key) => table.delete(key),
-    has: (key) => table.has(key),
-    size: () => table.size,
-    set: (key, data) => !!table.set(key, data),
-    get: (key) => table.get(key),
-    forEach: (callback) => table.forEach(callback),
-    filter: (callback) => table.filter(callback),
-  };
-}
-
-export interface CacheHandler<T> {
-  /** Completely empty this table. */
-  clear(): void;
-  /** Delete the data related to this key from table. */
-  delete(key: bigint): boolean;
-  /** Check if there is data assigned to this key. */
-  has(key: bigint): boolean;
-  /** Check how many items are stored in this table. */
-  size(): number;
-  /** Store new data to this table. */
-  set(key: bigint, data: T): boolean;
-  /** Get a stored item from the table. */
-  get(key: bigint): T | undefined;
-  // TODO: maybe its possible to stringify the function and send it to the custom cache handler :thinking:
-  /**
-   * Loop over each entry and execute callback function.
-   * @important This function NOT optimised and will force load everything when using custom cache.
-   */
-  forEach(callback: (value: T, key: bigint) => unknown): void;
-  // TODO: maybe its possible to stringify the function and send it to the custom cache handler :thinking:
-  /**
-   * Loop over each entry and execute callback function.
-   * @important This function NOT optimised and will force load everything when using custom cache.
-   */
-  filter(callback: (value: T, key: bigint) => boolean): Collection<bigint, T>;
-}
-
-export type AsyncCacheHandler<T> = {
-  [K in keyof CacheHandler<T>]: (...args: Parameters<CacheHandler<T>[K]>) => Promise<ReturnType<CacheHandler<T>[K]>>;
-};
-
-export type CacheExecutor = (
-  type:
-    | "GET_ALL_MEMBERS"
-    | "DELETE_MESSAGES_FROM_CHANNEL"
-    | "DELETE_ROLE_FROM_MEMBER"
-    | "BULK_DELETE_MESSAGES"
-    | "GUILD_MEMBER_CHUNK"
-    | "GUILD_MEMBER_COUNT_DECREMENT"
-    | "GUILD_MEMBER_COUNT_INCREMENT"
-    | "DELETE_MESSAGES_FROM_GUILD"
-    | "DELETE_CHANNELS_FROM_GUILD"
-    | "DELETE_GUILD_FROM_MEMBER",
-  options: Record<string, any>
-) => Promise<any>;
-
-export function createExecute(cache: Cache): CacheExecutor {
-  return function (type, options) {
-    switch (type) {
-      case "DELETE_MESSAGES_FROM_CHANNEL":
-        cache.messages.forEach((message) => {
-          if (message.channelId === options.channelId) {
-            cache.messages.delete(message.id);
-          }
-        });
-        return;
-      case "BULK_DELETE_MESSAGES":
-        return options.messageIds
-          .map((id: bigint) => {
-            const cached = cache.messages.get(id);
-            if (!cached) return;
-
-            cache.messages.delete(id);
-
-            return cached;
-          })
-          .filter((m: DiscordenoMessage) => m);
-      case "GUILD_MEMBER_CHUNK":
-        options.users.forEach((user: DiscordenoUser) => {
-          cache.users.set(user.id, user);
-        });
-        // TODO: FIND A GOOD WAY FOR MEMBERS CACHE (GUILD ID)
-        // options.members.forEach((member) => {
-        //   cache.members.set(member.id, member);
-        // });
-        return;
-    }
-  };
-}
-
-export type TableNames =
-  | "channels"
-  | "users"
-  | "guilds"
-  | "messages"
-  | "presences"
-  | "threads"
-  | "unavailableGuilds"
-  | "members"
-  | "dispatchedGuildIds"
-  | "dispatchedChannelIds"
-  | "activeGuildIds";
diff --git a/src/handlers/channels/THREAD_DELETE.ts b/src/handlers/channels/THREAD_DELETE.ts
index 82e41d922..763b52218 100644
--- a/src/handlers/channels/THREAD_DELETE.ts
+++ b/src/handlers/channels/THREAD_DELETE.ts
@@ -1,5 +1,3 @@
-// import { eventHandlers } from "../../bot.ts";
-// import { cacheHandlers } from "../../cache.ts";
 import { Channel } from "../../types/channels/channel.ts";
 import { DiscordGatewayPayload } from "../../types/gateway/gatewayPayload.ts";
 import { snowflakeToBigint } from "../../util/bigint.ts";
diff --git a/src/handlers/channels/THREAD_LIST_SYNC.ts b/src/handlers/channels/THREAD_LIST_SYNC.ts
index 407b2e4b5..7ef76ed53 100644
--- a/src/handlers/channels/THREAD_LIST_SYNC.ts
+++ b/src/handlers/channels/THREAD_LIST_SYNC.ts
@@ -1,11 +1,7 @@
-// import { eventHandlers } from "../../bot.ts";
-// import { cacheHandlers } from "../../cache.ts";
 import { ThreadListSync } from "../../types/channels/threads/threadListSync.ts";
 import { DiscordGatewayPayload } from "../../types/gateway/gatewayPayload.ts";
 import { snowflakeToBigint } from "../../util/bigint.ts";
-// import { channelToThread } from "../../util/transformers/channel_to_thread.ts";
 import { Collection } from "../../util/collection.ts";
-// import { threadMemberModified } from "../../util/transformers/thread_member_modified.ts";
 
 export async function handleThreadListSync(data: DiscordGatewayPayload) {
   // const payload = data.d as ThreadListSync;
diff --git a/src/handlers/channels/THREAD_MEMBERS_UPDATE.ts b/src/handlers/channels/THREAD_MEMBERS_UPDATE.ts
index ef2a7a139..bb6649510 100644
--- a/src/handlers/channels/THREAD_MEMBERS_UPDATE.ts
+++ b/src/handlers/channels/THREAD_MEMBERS_UPDATE.ts
@@ -1,9 +1,6 @@
-// import { eventHandlers } from "../../bot.ts";
-// import { cacheHandlers } from "../../cache.ts";
 import { ThreadMembersUpdate } from "../../types/channels/threads/threadMembersUpdate.ts";
 import { DiscordGatewayPayload } from "../../types/gateway/gatewayPayload.ts";
 import { snowflakeToBigint } from "../../util/bigint.ts";
-// import { threadMembersUpdateModified } from "../../util/transformers/thread_members_update_modified.ts";
 
 export async function handleThreadMembersUpdate(data: DiscordGatewayPayload) {
   //   const payload = data.d as ThreadMembersUpdate;
diff --git a/src/handlers/channels/THREAD_MEMBER_UPDATE.ts b/src/handlers/channels/THREAD_MEMBER_UPDATE.ts
index be696bb7e..52dd7877c 100644
--- a/src/handlers/channels/THREAD_MEMBER_UPDATE.ts
+++ b/src/handlers/channels/THREAD_MEMBER_UPDATE.ts
@@ -1,5 +1,3 @@
-// import { eventHandlers } from "../../bot.ts";
-// import { cacheHandlers } from "../../cache.ts";
 import { ThreadMember } from "../../types/channels/threads/threadMember.ts";
 import { DiscordGatewayPayload } from "../../types/gateway/gatewayPayload.ts";
 import { snowflakeToBigint } from "../../util/bigint.ts";
diff --git a/src/handlers/channels/THREAD_UPDATE.ts b/src/handlers/channels/THREAD_UPDATE.ts
index 41a61727a..d46e98153 100644
--- a/src/handlers/channels/THREAD_UPDATE.ts
+++ b/src/handlers/channels/THREAD_UPDATE.ts
@@ -1,9 +1,6 @@
-// import { eventHandlers } from "../../bot.ts";
-// import { cacheHandlers } from "../../cache.ts";
 import { Channel } from "../../types/channels/channel.ts";
 import { DiscordGatewayPayload } from "../../types/gateway/gatewayPayload.ts";
 import { snowflakeToBigint } from "../../util/bigint.ts";
-// import { channelToThread } from "../../util/transformers/channel_to_thread.ts";
 
 export async function handleThreadUpdate(data: DiscordGatewayPayload) {
   // const payload = data.d as Channel;
diff --git a/src/handlers/members/GUILD_MEMBER_ADD.ts b/src/handlers/members/GUILD_MEMBER_ADD.ts
index 68e5aa38d..7ef44c978 100644
--- a/src/handlers/members/GUILD_MEMBER_ADD.ts
+++ b/src/handlers/members/GUILD_MEMBER_ADD.ts
@@ -8,12 +8,5 @@ export async function handleGuildMemberAdd(bot: Bot, data: DiscordGatewayPayload
   const guildId = bot.transformers.snowflake(payload.guild_id);
   const user = bot.transformers.user(bot, payload.user);
   const member = bot.transformers.member(bot, payload, guildId, user.id);
-
-  await Promise.all([
-    bot.cache.members.set(member.id, member),
-    bot.cache.users.set(user.id, user),
-    bot.cache.execute("GUILD_MEMBER_COUNT_INCREMENT", { guildId }),
-  ]);
-
   bot.events.guildMemberAdd(bot, member, user);
 }
diff --git a/src/handlers/members/GUILD_MEMBER_REMOVE.ts b/src/handlers/members/GUILD_MEMBER_REMOVE.ts
index 3d1b6e39d..9d1eab357 100644
--- a/src/handlers/members/GUILD_MEMBER_REMOVE.ts
+++ b/src/handlers/members/GUILD_MEMBER_REMOVE.ts
@@ -2,17 +2,11 @@ import { Bot } from "../../bot.ts";
 import type { DiscordGatewayPayload } from "../../types/gateway/gatewayPayload.ts";
 import type { GuildMemberRemove } from "../../types/members/guildMemberRemove.ts";
 import { SnakeCasedPropertiesDeep } from "../../types/util.ts";
-import { snowflakeToBigint } from "../../util/bigint.ts";
 
 export async function handleGuildMemberRemove(bot: Bot, data: DiscordGatewayPayload) {
   const payload = data.d as SnakeCasedPropertiesDeep<GuildMemberRemove>;
   const guildId = bot.transformers.snowflake(payload.guild_id);
   const user = bot.transformers.user(bot, payload.user);
 
-  await Promise.all([
-    bot.cache.members.delete(user.id),
-    bot.cache.execute("GUILD_MEMBER_COUNT_DECREMENT", { guildId }),
-  ]);
-
   bot.events.guildMemberRemove(bot, user, guildId);
 }
diff --git a/src/helpers/channels/channelOverwriteHasPermission.ts b/src/helpers/channels/channelOverwriteHasPermission.ts
deleted file mode 100644
index 429d6aeb0..000000000
--- a/src/helpers/channels/channelOverwriteHasPermission.ts
+++ /dev/null
@@ -1,34 +0,0 @@
-import { separateOverwrites } from "../../transformers/channel.ts";
-import type { DiscordOverwrite } from "../../types/channels/overwrite.ts";
-import { BitwisePermissionFlags } from "../../types/permissions/bitwisePermissionFlags.ts";
-import type { PermissionStrings } from "../../types/permissions/permissionStrings.ts";
-
-/** Checks if a channel overwrite for a user id or a role id has permission in this channel */
-export function channelOverwriteHasPermission(
-  guildId: bigint,
-  id: bigint,
-  overwrites: bigint[],
-  permissions: PermissionStrings[]
-) {
-  const overwrite =
-    overwrites.find((perm) => {
-      const [_, bitID] = separateOverwrites(perm);
-      return id === bitID;
-    }) ||
-    overwrites.find((perm) => {
-      const [_, bitID] = separateOverwrites(perm);
-      return bitID === guildId;
-    });
-
-  if (!overwrite) return false;
-
-  return permissions.every((perm) => {
-    const [type, id, allowBits, denyBits] = separateOverwrites(overwrite);
-    if (BigInt(denyBits) & BigInt(BitwisePermissionFlags[perm])) {
-      return false;
-    }
-    if (BigInt(allowBits) & BigInt(BitwisePermissionFlags[perm])) {
-      return true;
-    }
-  });
-}
diff --git a/src/helpers/channels/cloneChannel.ts b/src/helpers/channels/cloneChannel.ts
deleted file mode 100644
index 5eb14825a..000000000
--- a/src/helpers/channels/cloneChannel.ts
+++ /dev/null
@@ -1,33 +0,0 @@
-import type { Bot } from "../../bot.ts";
-import { DiscordenoChannel, separateOverwrites } from "../../transformers/channel.ts";
-import type { CreateGuildChannel } from "../../types/guilds/createGuildChannel.ts";
-
-/** Create a copy of a channel */
-export async function cloneChannel(bot: Bot, channel: DiscordenoChannel, reason?: string) {
-  if (!channel.guildId) throw new Error(`Cannot clone a channel outside a guild`);
-
-  const createChannelOptions: CreateGuildChannel = {
-    type: channel.type,
-    bitrate: channel.bitrate,
-    userLimit: channel.userLimit,
-    rateLimitPerUser: channel.rateLimitPerUser,
-    position: channel.position,
-    parentId: channel.parentId,
-    nsfw: channel.nsfw,
-    name: channel.name!,
-    topic: channel.topic || undefined,
-    permissionOverwrites: channel.permissionOverwrites.map((overwrite) => {
-      const [type, id, allow, deny] = separateOverwrites(overwrite);
-
-      return {
-        id,
-        type,
-        allow: bot.utils.calculatePermissions(BigInt(allow)),
-        deny: bot.utils.calculatePermissions(BigInt(deny)),
-      };
-    }),
-  };
-
-  //Create the channel (also handles permissions)
-  return await bot.helpers.createChannel(channel.guildId!, createChannelOptions, reason);
-}
diff --git a/src/helpers/channels/createStageInstance.ts b/src/helpers/channels/createStageInstance.ts
index abbedc881..685d6249b 100644
--- a/src/helpers/channels/createStageInstance.ts
+++ b/src/helpers/channels/createStageInstance.ts
@@ -4,10 +4,6 @@ import { PrivacyLevel } from "../../types/channels/privacyLevel.ts";
 
 /** Creates a new Stage instance associated to a Stage channel. Requires the user to be a moderator of the Stage channel. */
 export async function createStageInstance(bot: Bot, channelId: bigint, topic: string, privacyLevel?: PrivacyLevel) {
-  if (!bot.utils.validateLength(topic, { max: 120, min: 1 })) {
-    throw new Error(bot.constants.Errors.INVALID_TOPIC_LENGTH);
-  }
-
   const result = await bot.rest.runMethod<StageInstance>(bot.rest, "post", bot.constants.endpoints.STAGE_INSTANCES, {
     channel_id: channelId.toString(),
     topic,
diff --git a/src/helpers/channels/deleteChannel.ts b/src/helpers/channels/deleteChannel.ts
index 3766d4e80..d047582f4 100644
--- a/src/helpers/channels/deleteChannel.ts
+++ b/src/helpers/channels/deleteChannel.ts
@@ -1,8 +1,14 @@
 import type { Bot } from "../../bot.ts";
+import { Channel } from "../../types/channels/channel.ts";
 
-/** Delete a channel in your server. Bot needs MANAGE_CHANNEL permissions in the server. */
+/** Delete a channel in your server. Bot needs MANAGE_CHANNEL permissions in the server. Bot needs MANAGE_THREADS permissions in the server if deleting thread. */
 export async function deleteChannel(bot: Bot, channelId: bigint, reason?: string) {
-  return await bot.rest.runMethod<undefined>(bot.rest, "delete", bot.constants.endpoints.CHANNEL_BASE(channelId), {
-    reason,
-  });
+  await bot.rest.runMethod<Channel>(
+    bot.rest,
+    "delete",
+    bot.constants.endpoints.CHANNEL_BASE(channelId),
+    {
+      reason,
+    }
+  );
 }
diff --git a/src/helpers/channels/deleteChannelOverwrite.ts b/src/helpers/channels/deleteChannelOverwrite.ts
index e3adb4ffa..fa0298d85 100644
--- a/src/helpers/channels/deleteChannelOverwrite.ts
+++ b/src/helpers/channels/deleteChannelOverwrite.ts
@@ -1,8 +1,8 @@
 import type { Bot } from "../../bot.ts";
 
 /** Delete the channel permission overwrites for a user or role in this channel. Requires `MANAGE_ROLES` permission. */
-export async function deleteChannelOverwrite(bot: Bot, channelId: bigint, overwriteId: bigint): Promise<undefined> {
-  return await bot.rest.runMethod<undefined>(
+export async function deleteChannelOverwrite(bot: Bot, channelId: bigint, overwriteId: bigint) {
+  await bot.rest.runMethod<undefined>(
     bot.rest,
     "delete",
     bot.constants.endpoints.CHANNEL_OVERWRITE(channelId, overwriteId)
diff --git a/src/helpers/channels/deleteStageInstance.ts b/src/helpers/channels/deleteStageInstance.ts
index b2594e572..f359f2088 100644
--- a/src/helpers/channels/deleteStageInstance.ts
+++ b/src/helpers/channels/deleteStageInstance.ts
@@ -2,5 +2,5 @@ import type { Bot } from "../../bot.ts";
 
 /** Deletes the Stage instance. Requires the user to be a moderator of the Stage channel. */
 export async function deleteStageInstance(bot: Bot, channelId: bigint) {
-  return await bot.rest.runMethod<undefined>(bot.rest, "delete", bot.constants.endpoints.STAGE_INSTANCE(channelId));
+  await bot.rest.runMethod<undefined>(bot.rest, "delete", bot.constants.endpoints.STAGE_INSTANCE(channelId));
 }
diff --git a/src/helpers/channels/editChannel.ts b/src/helpers/channels/editChannel.ts
index 68b3fc494..063d8ae94 100644
--- a/src/helpers/channels/editChannel.ts
+++ b/src/helpers/channels/editChannel.ts
@@ -35,13 +35,17 @@ export async function editChannel(bot: Bot, channelId: bigint, options: ModifyCh
     name: options.name,
     topic: options.topic,
     bitrate: options.bitrate,
-    userLimit: options.userLimit,
-    rateLimitPerUser: options.rateLimitPerUser,
+    user_limit: options.userLimit,
+    rate_limit_per_user: options.rateLimitPerUser,
     position: options.position,
-    parentId: options.parentId,
+    parent_id: options.parentId === null ? null : options.parentId?.toString(),
     nsfw: options.nsfw,
     type: options.type,
-    permissionOverwrites: options.permissionOverwrites
+    archived: options.archived,
+    auto_archive_duration: options.autoArchiveDuration,
+    locked: options.locked,
+    invitable: options.invitable,
+    permission_overwrites: options.permissionOverwrites
       ? options.permissionOverwrites?.map((overwrite) => {
           return {
             ...overwrite,
diff --git a/src/helpers/channels/editChannelOverwrite.ts b/src/helpers/channels/editChannelOverwrite.ts
index 3fac722c7..b44bdb259 100644
--- a/src/helpers/channels/editChannelOverwrite.ts
+++ b/src/helpers/channels/editChannelOverwrite.ts
@@ -7,8 +7,8 @@ export async function editChannelOverwrite(
   channelId: bigint,
   overwriteId: bigint,
   options: Omit<Overwrite, "id">
-): Promise<undefined> {
-  return await bot.rest.runMethod<undefined>(
+) {
+  await bot.rest.runMethod<undefined>(
     bot.rest,
     "put",
     bot.constants.endpoints.CHANNEL_OVERWRITE(channelId, overwriteId),
diff --git a/src/helpers/channels/getChannel.ts b/src/helpers/channels/getChannel.ts
index ea671e630..23f025acb 100644
--- a/src/helpers/channels/getChannel.ts
+++ b/src/helpers/channels/getChannel.ts
@@ -1,10 +1,7 @@
 import type { Bot } from "../../bot.ts";
 import type { Channel } from "../../types/channels/channel.ts";
 
-/** Fetches a single channel object from the api.
- *
- * ⚠️ **If you need this, you are probably doing something wrong. This is not intended for use. Your channels will be cached in your guild.**
- */
+/** Fetches a single channel object from the api. */
 export async function getChannel(bot: Bot, channelId: bigint) {
   const result = await bot.rest.runMethod<Channel>(bot.rest, "get", bot.constants.endpoints.CHANNEL_BASE(channelId));
 
diff --git a/src/helpers/channels/getChannels.ts b/src/helpers/channels/getChannels.ts
index 518ef6eb9..d196083c7 100644
--- a/src/helpers/channels/getChannels.ts
+++ b/src/helpers/channels/getChannels.ts
@@ -2,10 +2,7 @@ import type { Channel } from "../../types/channels/channel.ts";
 import { Collection } from "../../util/collection.ts";
 import type { Bot } from "../../bot.ts";
 
-/** Returns a list of guild channel objects.
- *
- * ⚠️ **If you need this, you are probably doing something wrong. This is not intended for use. Your channels will be cached in your guild.**
- */
+/** Returns a list of guild channel objects. */
 export async function getChannels(bot: Bot, guildId: bigint) {
   const result = await bot.rest.runMethod<Channel[]>(bot.rest, "get", bot.constants.endpoints.GUILD_CHANNELS(guildId));
 
diff --git a/src/helpers/channels/getStageInstance.ts b/src/helpers/channels/getStageInstance.ts
index 6cded1faa..4f9d41c92 100644
--- a/src/helpers/channels/getStageInstance.ts
+++ b/src/helpers/channels/getStageInstance.ts
@@ -3,5 +3,16 @@ import type { Bot } from "../../bot.ts";
 
 /** Gets the stage instance associated with the Stage channel, if it exists. */
 export async function getStageInstance(bot: Bot, channelId: bigint) {
-  return await bot.rest.runMethod<StageInstance>(bot.rest, "get", bot.constants.endpoints.STAGE_INSTANCE(channelId));
+  const result = await bot.rest.runMethod<StageInstance>(
+    bot.rest,
+    "get",
+    bot.constants.endpoints.STAGE_INSTANCE(channelId)
+  );
+
+  return {
+    id: bot.transformers.snowflake(result.id),
+    guildId: bot.transformers.snowflake(result.guild_id),
+    channelId: bot.transformers.snowflake(result.channel_id),
+    topic: result.topic,
+  };
 }
diff --git a/src/helpers/channels/startTyping.ts b/src/helpers/channels/startTyping.ts
index b33a21563..688c7b0eb 100644
--- a/src/helpers/channels/startTyping.ts
+++ b/src/helpers/channels/startTyping.ts
@@ -7,5 +7,5 @@ import type { Bot } from "../../bot.ts";
  * this endpoint may be called to let the user know that the bot is processing their message.
  */
 export async function startTyping(bot: Bot, channelId: bigint) {
-  return await bot.rest.runMethod<undefined>(bot.rest, "post", bot.constants.endpoints.CHANNEL_TYPING(channelId));
+  await bot.rest.runMethod<undefined>(bot.rest, "post", bot.constants.endpoints.CHANNEL_TYPING(channelId));
 }
diff --git a/src/helpers/channels/swapChannels.ts b/src/helpers/channels/swapChannels.ts
index d6725d39d..aec44f2ea 100644
--- a/src/helpers/channels/swapChannels.ts
+++ b/src/helpers/channels/swapChannels.ts
@@ -1,13 +1,13 @@
 import type { ModifyGuildChannelPositions } from "../../types/guilds/modifyGuildChannelPosition.ts";
 import type { Bot } from "../../bot.ts";
 
-/** Modify the positions of channels on the guild. Requires MANAGE_CHANNELS permission. */
+/** Modify the positions of channels on the guild. Requires MANAGE_CHANNELS permission. Only channels to be modified are required. */
 export async function swapChannels(bot: Bot, guildId: bigint, channelPositions: ModifyGuildChannelPositions[]) {
   if (!channelPositions.length) {
     throw "You must provide at least one channels to be moved.";
   }
 
-  return await bot.rest.runMethod<undefined>(
+  await bot.rest.runMethod<undefined>(
     bot.rest,
     "patch",
     bot.constants.endpoints.GUILD_CHANNELS(guildId),
diff --git a/src/helpers/channels/threads/addToThread.ts b/src/helpers/channels/threads/addToThread.ts
index 05bc89af4..a146e48bc 100644
--- a/src/helpers/channels/threads/addToThread.ts
+++ b/src/helpers/channels/threads/addToThread.ts
@@ -2,5 +2,5 @@ import type { Bot } from "../../../bot.ts";
 
 /** Adds a user to a thread. Requires the ability to send messages in the thread. Requires the thread is not archived. */
 export async function addToThread(bot: Bot, threadId: bigint, userId: bigint) {
-  return await bot.rest.runMethod<undefined>(bot.rest, "put", bot.constants.endpoints.THREAD_USER(threadId, userId));
+  await bot.rest.runMethod<undefined>(bot.rest, "put", bot.constants.endpoints.THREAD_USER(threadId, userId));
 }
diff --git a/src/helpers/channels/threads/deleteThread.ts b/src/helpers/channels/threads/deleteThread.ts
deleted file mode 100644
index d1876251f..000000000
--- a/src/helpers/channels/threads/deleteThread.ts
+++ /dev/null
@@ -1,8 +0,0 @@
-import type { Bot } from "../../../bot.ts";
-
-/** Delete a thread in your server. Bot needs MANAGE_THREADS permissions in the server. */
-export async function deleteThread(bot: Bot, threadId: bigint, reason?: string) {
-  return await bot.rest.runMethod<undefined>(bot.rest, "delete", bot.constants.endpoints.CHANNEL_BASE(threadId), {
-    reason,
-  });
-}
diff --git a/src/helpers/channels/threads/editThread.ts b/src/helpers/channels/threads/editThread.ts
deleted file mode 100644
index 72c93811c..000000000
--- a/src/helpers/channels/threads/editThread.ts
+++ /dev/null
@@ -1,21 +0,0 @@
-import type { ModifyThread } from "../../../types/channels/threads/modifyThread.ts";
-import type { Bot } from "../../../bot.ts";
-import { Channel } from "../../../types/channels/channel.ts";
-// import { channelToThread } from "../../../util/transformers/channel_to_thread.ts";
-
-/** Update a thread's settings. Requires the `MANAGE_CHANNELS` permission for the guild. */
-export async function editThread(bot: Bot, threadId: bigint, options: ModifyThread, reason?: string) {
-  const result = await bot.rest.runMethod<Channel>(bot.rest, "patch", bot.constants.endpoints.CHANNEL_BASE(threadId), {
-    name: options.name,
-    archived: options.archived,
-    auto_archive_duration: options.autoArchiveDuration,
-    locked: options.locked,
-    rate_limit_per_user: options.rateLimitPerUser,
-    reason,
-  });
-
-  return bot.transformers.channel(bot, {
-    channel: result,
-    guildId: result.guild_id ? bot.transformers.snowflake(result.guild_id) : undefined,
-  });
-}
diff --git a/src/helpers/channels/threads/joinThread.ts b/src/helpers/channels/threads/joinThread.ts
index 0a8ec5967..17429e042 100644
--- a/src/helpers/channels/threads/joinThread.ts
+++ b/src/helpers/channels/threads/joinThread.ts
@@ -2,5 +2,5 @@ import type { Bot } from "../../../bot.ts";
 
 /** Adds the bot to the thread. Cannot join an archived thread. */
 export async function joinThread(bot: Bot, threadId: bigint) {
-  return await bot.rest.runMethod<undefined>(bot.rest, "put", bot.constants.endpoints.THREAD_ME(threadId));
+  await bot.rest.runMethod<undefined>(bot.rest, "put", bot.constants.endpoints.THREAD_ME(threadId));
 }
diff --git a/src/helpers/channels/threads/leaveThread.ts b/src/helpers/channels/threads/leaveThread.ts
index 6792dd31b..1fe3a611a 100644
--- a/src/helpers/channels/threads/leaveThread.ts
+++ b/src/helpers/channels/threads/leaveThread.ts
@@ -2,5 +2,5 @@ import type { Bot } from "../../../bot.ts";
 
 /** Removes the bot from a thread. Requires the thread is not archived. */
 export async function leaveThread(bot: Bot, threadId: bigint) {
-  return await bot.rest.runMethod<undefined>(bot.rest, "delete", bot.constants.endpoints.THREAD_ME(threadId));
+  await bot.rest.runMethod<undefined>(bot.rest, "delete", bot.constants.endpoints.THREAD_ME(threadId));
 }
diff --git a/src/helpers/channels/threads/mod.ts b/src/helpers/channels/threads/mod.ts
index 741b603d6..e348276f4 100644
--- a/src/helpers/channels/threads/mod.ts
+++ b/src/helpers/channels/threads/mod.ts
@@ -1,6 +1,4 @@
 export * from "./addToThread.ts";
-export * from "./deleteThread.ts";
-export * from "./editThread.ts";
 export * from "./getActiveThreads.ts";
 export * from "./getArchivedThreads.ts";
 export * from "./getThreadMembers.ts";
diff --git a/src/helpers/channels/threads/removeThreadMember.ts b/src/helpers/channels/threads/removeThreadMember.ts
index 1dc30c5e8..3cd128a00 100644
--- a/src/helpers/channels/threads/removeThreadMember.ts
+++ b/src/helpers/channels/threads/removeThreadMember.ts
@@ -2,5 +2,5 @@ import type { Bot } from "../../../bot.ts";
 
 /** Removes a user from a thread. Requires the MANAGE_THREADS permission or that you are the creator of the thread. Also requires the thread is not archived. */
 export async function removeThreadMember(bot: Bot, threadId: bigint, userId: bigint) {
-  return await bot.rest.runMethod<undefined>(bot.rest, "delete", bot.constants.endpoints.THREAD_USER(threadId, userId));
+  await bot.rest.runMethod<undefined>(bot.rest, "delete", bot.constants.endpoints.THREAD_USER(threadId, userId));
 }
diff --git a/src/helpers/channels/threads/startThreadWithoutMessage.ts b/src/helpers/channels/threads/startThreadWithoutMessage.ts
index 8498239a0..94584f5ae 100644
--- a/src/helpers/channels/threads/startThreadWithoutMessage.ts
+++ b/src/helpers/channels/threads/startThreadWithoutMessage.ts
@@ -4,8 +4,18 @@ import type { Bot } from "../../../bot.ts";
 
 /** Creates a new private thread. Returns a thread channel. */
 export async function startThreadWithoutMessage(bot: Bot, channelId: bigint, options: StartThreadWithoutMessage) {
-  return await bot.rest.runMethod<Channel>(bot.rest, "post", bot.constants.endpoints.THREAD_START_PRIVATE(channelId), {
-    name: options.name,
-    auto_archive_duration: options.autoArchiveDuration,
+  const result = await bot.rest.runMethod<Channel>(
+    bot.rest,
+    "post",
+    bot.constants.endpoints.THREAD_START_PRIVATE(channelId),
+    {
+      name: options.name,
+      auto_archive_duration: options.autoArchiveDuration,
+    }
+  );
+
+  return bot.transformers.channel(bot, {
+    channel: result,
+    guildId: result.guild_id ? bot.transformers.snowflake(result.guild_id) : undefined,
   });
 }
diff --git a/src/helpers/channels/updateBotVoiceState.ts b/src/helpers/channels/updateBotVoiceState.ts
deleted file mode 100644
index c03756206..000000000
--- a/src/helpers/channels/updateBotVoiceState.ts
+++ /dev/null
@@ -1,37 +0,0 @@
-import type { UpdateOthersVoiceState } from "../../types/guilds/updateOthersVoiceState.ts";
-import type { UpdateSelfVoiceState } from "../../types/guilds/updateSelfVoiceState.ts";
-import type { Bot } from "../../bot.ts";
-
-/**
- * Updates the a user's voice state, defaults to the current user
- * Caveats:
- *  - `channel_id` must currently point to a stage channel.
- *  - User must already have joined `channel_id`.
- *  - You must have the `MUTE_MEMBERS` permission. But can always suppress yourself.
- *  - When unsuppressed, non-bot users will have their `request_to_speak_timestamp` set to the current time. Bot users will not.
- *  - You must have the `REQUEST_TO_SPEAK` permission to request to speak. You can always clear your own request to speak.
- *  - You are able to set `request_to_speak_timestamp` to any present or future time.
- *  - When suppressed, the user will have their `request_to_speak_timestamp` removed.
- */
-export async function updateBotVoiceState(
-  bot: Bot,
-  guildId: bigint,
-  options: UpdateSelfVoiceState | ({ userId: bigint } & UpdateOthersVoiceState)
-) {
-  return await bot.rest.runMethod(
-    bot.rest,
-    "patch",
-    bot.constants.endpoints.UPDATE_VOICE_STATE(
-      guildId,
-      bot.utils.hasProperty(options, "userId") ? options.userId : undefined
-    ),
-    {
-      channel_id: options.channelId,
-      suppress: options.suppress,
-      request_to_speak_timestamp: bot.utils.hasProperty(options, "requestToSpeakTimestamp")
-        ? options.requestToSpeakTimestamp
-        : undefined,
-      user_id: bot.utils.hasProperty(options, "userId") ? options.userId : undefined,
-    }
-  );
-}
diff --git a/src/helpers/channels/updateStageInstance.ts b/src/helpers/channels/updateStageInstance.ts
index ecd330794..9559840c9 100644
--- a/src/helpers/channels/updateStageInstance.ts
+++ b/src/helpers/channels/updateStageInstance.ts
@@ -4,16 +4,6 @@ import { AtLeastOne } from "../../types/util.ts";
 
 /** Updates fields of an existing Stage instance. Requires the user to be a moderator of the Stage channel. */
 export async function updateStageInstance(bot: Bot, channelId: bigint, data: AtLeastOne<Pick<StageInstance, "topic">>) {
-  if (
-    data.topic &&
-    !bot.utils.validateLength(data.topic, {
-      min: 1,
-      max: 120,
-    })
-  ) {
-    throw new Error(bot.constants.Errors.INVALID_TOPIC_LENGTH);
-  }
-
   const result = await bot.rest.runMethod<StageInstance>(
     bot.rest,
     "patch",
diff --git a/src/helpers/channels/updateVoiceState.ts b/src/helpers/channels/updateVoiceState.ts
new file mode 100644
index 000000000..55fb15f3b
--- /dev/null
+++ b/src/helpers/channels/updateVoiceState.ts
@@ -0,0 +1,47 @@
+import type { UpdateOthersVoiceState } from "../../types/guilds/updateOthersVoiceState.ts";
+import type { UpdateSelfVoiceState } from "../../types/guilds/updateSelfVoiceState.ts";
+import type { Bot } from "../../bot.ts";
+
+/**
+ * Updates the bot's voice state
+ * Caveats:
+ *  - `channel_id` must currently point to a stage channel.
+ *  - Bot must already have joined `channel_id`.
+ *  - You must have the `MUTE_MEMBERS` permission. But can always suppress yourself.
+ *  - You must have the `REQUEST_TO_SPEAK` permission to request to speak. You can always clear your own request to speak.
+ *  - You are able to set `request_to_speak_timestamp` to any present or future time.
+ *  - When suppressed, the user will have their `request_to_speak_timestamp` removed.
+ */
+export async function updateBotVoiceState(bot: Bot, guildId: bigint, options: UpdateSelfVoiceState) {
+  await bot.rest.runMethod(bot.rest, "patch", bot.constants.endpoints.UPDATE_VOICE_STATE(guildId), {
+    channel_id: options.channelId,
+    suppress: options.suppress,
+    request_to_speak_timestamp: options.requestToSpeakTimestamp
+      ? new Date(options.requestToSpeakTimestamp).toISOString()
+      : options.requestToSpeakTimestamp,
+  });
+}
+
+/**
+ * Updates the a user's voice state
+ * Caveats:
+ *  - `channel_id` must currently point to a stage channel.
+ *  - User must already have joined `channel_id`.
+ *  - You must have the `MUTE_MEMBERS` permission. But can always suppress yourself.
+ *  - When unsuppressed, non-bot users will have their `request_to_speak_timestamp` set to the current time. Bot users will not.
+ *  - You must have the `REQUEST_TO_SPEAK` permission to request to speak. You can always clear your own request to speak.
+ *  - You are able to set `request_to_speak_timestamp` to any present or future time.
+ *  - When suppressed, the user will have their `request_to_speak_timestamp` removed.
+ */
+export async function updateUserVoiceState(bot: Bot, guildId: bigint, options: UpdateOthersVoiceState) {
+  await bot.rest.runMethod(
+    bot.rest,
+    "patch",
+    bot.constants.endpoints.UPDATE_VOICE_STATE(guildId, options.userId),
+    {
+      channel_id: options.channelId,
+      suppress: options.suppress,
+      user_id: options.userId,
+    }
+  );
+}
diff --git a/src/helpers/discovery/addDiscoverySubcategory.ts b/src/helpers/discovery/addDiscoverySubcategory.ts
index 226bb6b57..0107c863b 100644
--- a/src/helpers/discovery/addDiscoverySubcategory.ts
+++ b/src/helpers/discovery/addDiscoverySubcategory.ts
@@ -3,7 +3,7 @@ import type { Bot } from "../../bot.ts";
 
 /** Add a discovery subcategory to the guild. Requires the `MANAGE_GUILD` permission. */
 export async function addDiscoverySubcategory(bot: Bot, guildId: bigint, categoryId: number) {
-  return await bot.rest.runMethod<AddGuildDiscoverySubcategory>(
+  await bot.rest.runMethod<AddGuildDiscoverySubcategory>(
     bot.rest,
     "post",
     bot.constants.endpoints.DISCOVERY_SUBCATEGORY(guildId, categoryId)
diff --git a/src/helpers/discovery/editDiscovery.ts b/src/helpers/discovery/editDiscovery.ts
index 1480f29d6..f00027f24 100644
--- a/src/helpers/discovery/editDiscovery.ts
+++ b/src/helpers/discovery/editDiscovery.ts
@@ -4,7 +4,7 @@ import type { Bot } from "../../bot.ts";
 
 /** Modify the discovery metadata for the guild. Requires the MANAGE_GUILD permission. Returns the updated discovery metadata object on success. */
 export async function editDiscovery(bot: Bot, guildId: bigint, data: ModifyGuildDiscoveryMetadata) {
-  return await bot.rest.runMethod<DiscoveryMetadata>(
+  const result = await bot.rest.runMethod<DiscoveryMetadata>(
     bot.rest,
     "patch",
     bot.constants.endpoints.DISCOVERY_METADATA(guildId),
@@ -14,4 +14,18 @@ export async function editDiscovery(bot: Bot, guildId: bigint, data: ModifyGuild
       emoji_discoverability_enabled: data.emojiDiscoverabilityEnabled,
     }
   );
+
+  return {
+    guildId,
+    primaryCategoryId: result.primary_category_id,
+    keywords: result.keywords ?? undefined,
+    emojiDiscoverabilityEnabled: result.emoji_discoverability_enabled,
+    partnerActionedTimestamp: result.partner_actioned_timestamp
+      ? Date.parse(result.partner_actioned_timestamp)
+      : undefined,
+    partnerApplicationTimestamp: result.partner_application_timestamp
+      ? Date.parse(result.partner_application_timestamp)
+      : undefined,
+    categoryIds: result.category_ids,
+  };
 }
diff --git a/src/helpers/discovery/getDiscovery.ts b/src/helpers/discovery/getDiscovery.ts
new file mode 100644
index 000000000..3bcce91db
--- /dev/null
+++ b/src/helpers/discovery/getDiscovery.ts
@@ -0,0 +1,25 @@
+import type { DiscoveryMetadata } from "../../types/discovery/discoveryMetadata.ts";
+import type { Bot } from "../../bot.ts";
+
+/** Returns the discovery metadata object for the guild. Requires the `MANAGE_GUILD` permission. */
+export async function getDiscovery(bot: Bot, guildId: bigint) {
+  const result = await bot.rest.runMethod<DiscoveryMetadata>(
+    bot.rest,
+    "get",
+    bot.constants.endpoints.DISCOVERY_METADATA(guildId)
+  );
+
+  return {
+    guildId,
+    primaryCategoryId: result.primary_category_id,
+    keywords: result.keywords ?? undefined,
+    emojiDiscoverabilityEnabled: result.emoji_discoverability_enabled,
+    partnerActionedTimestamp: result.partner_actioned_timestamp
+      ? Date.parse(result.partner_actioned_timestamp)
+      : undefined,
+    partnerApplicationTimestamp: result.partner_application_timestamp
+      ? Date.parse(result.partner_application_timestamp)
+      : undefined,
+    categoryIds: result.category_ids,
+  };
+}
diff --git a/src/helpers/discovery/get_discovery.ts b/src/helpers/discovery/get_discovery.ts
deleted file mode 100644
index 224837df3..000000000
--- a/src/helpers/discovery/get_discovery.ts
+++ /dev/null
@@ -1,11 +0,0 @@
-import type { DiscoveryMetadata } from "../../types/discovery/discoveryMetadata.ts";
-import type { Bot } from "../../bot.ts";
-
-/** Returns the discovery metadata object for the guild. Requires the `MANAGE_GUILD` permission. */
-export async function getDiscovery(bot: Bot, guildId: bigint) {
-  return await bot.rest.runMethod<DiscoveryMetadata>(
-    bot.rest,
-    "get",
-    bot.constants.endpoints.DISCOVERY_METADATA(guildId)
-  );
-}
diff --git a/src/helpers/discovery/removeDiscoverySubcategory.ts b/src/helpers/discovery/removeDiscoverySubcategory.ts
index 7aec290c4..f25b35d90 100644
--- a/src/helpers/discovery/removeDiscoverySubcategory.ts
+++ b/src/helpers/discovery/removeDiscoverySubcategory.ts
@@ -2,7 +2,7 @@ import type { Bot } from "../../bot.ts";
 
 /** Removes a discovery subcategory from the guild. Requires the MANAGE_GUILD permission. Returns a 204 No Content on success. */
 export async function removeDiscoverySubcategory(bot: Bot, guildId: bigint, categoryId: number) {
-  return await bot.rest.runMethod<undefined>(
+  await bot.rest.runMethod<undefined>(
     bot.rest,
     "delete",
     bot.constants.endpoints.DISCOVERY_SUBCATEGORY(guildId, categoryId)
diff --git a/src/helpers/emojis/deleteEmoji.ts b/src/helpers/emojis/deleteEmoji.ts
index e9c63446f..cc77e6c88 100644
--- a/src/helpers/emojis/deleteEmoji.ts
+++ b/src/helpers/emojis/deleteEmoji.ts
@@ -2,7 +2,7 @@ import type { Bot } from "../../bot.ts";
 
 /** Delete the given emoji. Requires the MANAGE_EMOJIS permission. Returns 204 No Content on success. */
 export async function deleteEmoji(bot: Bot, guildId: bigint, id: bigint, reason?: string) {
-  return await bot.rest.runMethod<undefined>(bot.rest, "delete", bot.constants.endpoints.GUILD_EMOJI(guildId, id), {
+  await bot.rest.runMethod<undefined>(bot.rest, "delete", bot.constants.endpoints.GUILD_EMOJI(guildId, id), {
     reason,
   });
 }
diff --git a/src/helpers/emojis/editEmoji.ts b/src/helpers/emojis/editEmoji.ts
index b08ecf300..c371ba16d 100644
--- a/src/helpers/emojis/editEmoji.ts
+++ b/src/helpers/emojis/editEmoji.ts
@@ -4,5 +4,12 @@ import type { Bot } from "../../bot.ts";
 
 /** Modify the given emoji. Requires the MANAGE_EMOJIS permission. */
 export async function editEmoji(bot: Bot, guildId: bigint, id: bigint, options: ModifyGuildEmoji) {
-  return await bot.rest.runMethod<Emoji>(bot.rest, "patch", bot.constants.endpoints.GUILD_EMOJI(guildId, id), options);
+  const result = await bot.rest.runMethod<Emoji>(
+    bot.rest,
+    "patch",
+    bot.constants.endpoints.GUILD_EMOJI(guildId, id),
+    options
+  );
+
+  return bot.transformers.emoji(bot, result);
 }
diff --git a/src/helpers/emojis/getEmoji.ts b/src/helpers/emojis/getEmoji.ts
index 4b7b66e64..17287b174 100644
--- a/src/helpers/emojis/getEmoji.ts
+++ b/src/helpers/emojis/getEmoji.ts
@@ -4,9 +4,13 @@ import type { Bot } from "../../bot.ts";
 
 /**
  * Returns an emoji for the given guild and emoji Id.
- *
- * ⚠️ **If you need this, you are probably doing something wrong. Always use cache.guilds.get()?.emojis
  */
-export async function getEmoji(bot: Bot, guildId: bigint, emojiId: bigint, addToCache = true) {
-  return await bot.rest.runMethod<Emoji>(bot.rest, "get", bot.constants.endpoints.GUILD_EMOJI(guildId, emojiId));
+export async function getEmoji(bot: Bot, guildId: bigint, emojiId: bigint) {
+  const result = await bot.rest.runMethod<Emoji>(
+    bot.rest,
+    "get",
+    bot.constants.endpoints.GUILD_EMOJI(guildId, emojiId)
+  );
+
+  return bot.transformers.emoji(bot, result);
 }
diff --git a/src/helpers/emojis/getEmojis.ts b/src/helpers/emojis/getEmojis.ts
index 6e229869e..2e0274476 100644
--- a/src/helpers/emojis/getEmojis.ts
+++ b/src/helpers/emojis/getEmojis.ts
@@ -5,10 +5,8 @@ import { Collection } from "../../util/collection.ts";
 
 /**
  * Returns a list of emojis for the given guild.
- *
- * ⚠️ **If you need this, you are probably doing something wrong. Always use cache.guilds.get()?.emojis
  */
-export async function getEmojis(bot: Bot, guildId: bigint, addToCache = true) {
+export async function getEmojis(bot: Bot, guildId: bigint) {
   const result = await bot.rest.runMethod<Emoji[]>(bot.rest, "get", bot.constants.endpoints.GUILD_EMOJIS(guildId));
 
   return new Collection(result.map((e) => [bot.transformers.snowflake(e.id!), bot.transformers.emoji(bot, e)]));
diff --git a/src/helpers/guilds/deleteGuild.ts b/src/helpers/guilds/deleteGuild.ts
index c1c4d359b..45b0e1fb5 100644
--- a/src/helpers/guilds/deleteGuild.ts
+++ b/src/helpers/guilds/deleteGuild.ts
@@ -2,5 +2,5 @@ import type { Bot } from "../../bot.ts";
 
 /** Delete a guild permanently. User must be owner. Returns 204 No Content on success. Fires a Guild Delete Gateway event. */
 export async function deleteGuild(bot: Bot, guildId: bigint) {
-  return await bot.rest.runMethod<undefined>(bot.rest, "delete", bot.constants.endpoints.GUILDS_BASE(guildId));
+  await bot.rest.runMethod<undefined>(bot.rest, "delete", bot.constants.endpoints.GUILDS_BASE(guildId));
 }
diff --git a/src/helpers/guilds/editWelcomeScreen.ts b/src/helpers/guilds/editWelcomeScreen.ts
index 0508738ff..9d7601fc7 100644
--- a/src/helpers/guilds/editWelcomeScreen.ts
+++ b/src/helpers/guilds/editWelcomeScreen.ts
@@ -3,21 +3,21 @@ import type { WelcomeScreen } from "../../types/guilds/welcomeScreen.ts";
 import type { Bot } from "../../bot.ts";
 
 export async function editWelcomeScreen(bot: Bot, guildId: bigint, options: ModifyGuildWelcomeScreen) {
-  return await bot.rest.runMethod<WelcomeScreen>(
+  const result = await bot.rest.runMethod<WelcomeScreen>(
     bot.rest,
     "patch",
     bot.constants.endpoints.GUILD_WELCOME_SCREEN(guildId),
     {
       enabled: options.enabled,
-      welcomeScreen: options.welcomeScreen?.map((welcomeScreen) => {
-        return {
-          channel_id: welcomeScreen.channelId,
-          description: welcomeScreen.description,
-          emoji_id: welcomeScreen.emojiId,
-          emoji_name: welcomeScreen.emojiName,
-        };
-      }),
+      welcome_screen: options.welcomeScreen?.map((welcomeScreen) => ({
+        channel_id: welcomeScreen.channelId,
+        description: welcomeScreen.description,
+        emoji_id: welcomeScreen.emojiId,
+        emoji_name: welcomeScreen.emojiName,
+      })),
       description: options.description,
     }
   );
+
+  return bot.transformers.welcomeScreen(bot, result);
 }
diff --git a/src/helpers/guilds/editWidget.ts b/src/helpers/guilds/editWidget.ts
index ec99f7d03..0135f2722 100644
--- a/src/helpers/guilds/editWidget.ts
+++ b/src/helpers/guilds/editWidget.ts
@@ -3,8 +3,10 @@ import type { Bot } from "../../bot.ts";
 
 /** Modify a guild widget object for the guild. Requires the MANAGE_GUILD permission. */
 export async function editWidget(bot: Bot, guildId: bigint, enabled: boolean, channelId?: string | null) {
-  return await bot.rest.runMethod<GuildWidget>(bot.rest, "patch", bot.constants.endpoints.GUILD_WIDGET(guildId), {
+  const result = await bot.rest.runMethod<GuildWidget>(bot.rest, "patch", bot.constants.endpoints.GUILD_WIDGET(guildId), {
     enabled,
     channel_id: channelId,
   });
+
+  return bot.transformers.widget(bot, result);
 }
diff --git a/src/helpers/guilds/getAuditLogs.ts b/src/helpers/guilds/getAuditLogs.ts
index ed4788956..d1ee34f13 100644
--- a/src/helpers/guilds/getAuditLogs.ts
+++ b/src/helpers/guilds/getAuditLogs.ts
@@ -48,5 +48,7 @@ export async function getAuditLogs(bot: Bot, guildId: bigint, options?: GetGuild
           }
         : undefined,
     })),
+    threads: auditlog.threads.map((thread) => bot.transformers.channel(bot, { channel: thread, guildId })),
+    scheduledEvents: auditlog.scheduled_events.map((event) => bot.transformers.scheduledEvent(bot, event)),
   };
 }
diff --git a/src/helpers/guilds/getAvailableVoiceRegions.ts b/src/helpers/guilds/getAvailableVoiceRegions.ts
index 781742b02..d1541582f 100644
--- a/src/helpers/guilds/getAvailableVoiceRegions.ts
+++ b/src/helpers/guilds/getAvailableVoiceRegions.ts
@@ -1,7 +1,15 @@
 import type { VoiceRegion } from "../../types/voice/voiceRegion.ts";
 import type { Bot } from "../../bot.ts";
+import { Collection } from "../../util/collection.ts";
 
 /** Returns an array of voice regions that can be used when creating servers. */
 export async function getAvailableVoiceRegions(bot: Bot) {
-  return await bot.rest.runMethod<VoiceRegion>(bot.rest, "get", bot.constants.endpoints.VOICE_REGIONS);
+  const result = await bot.rest.runMethod<VoiceRegion[]>(bot.rest, "get", bot.constants.endpoints.VOICE_REGIONS);
+
+  return new Collection(
+    result.map((region) => {
+      const voiceRegion = bot.transformers.voiceRegion(bot, region);
+      return [voiceRegion.id, voiceRegion];
+    })
+  );
 }
diff --git a/src/helpers/guilds/getBans.ts b/src/helpers/guilds/getBans.ts
index 2b1b2af56..ef4dcbab9 100644
--- a/src/helpers/guilds/getBans.ts
+++ b/src/helpers/guilds/getBans.ts
@@ -1,10 +1,19 @@
 import type { Ban } from "../../types/guilds/ban.ts";
 import type { Bot } from "../../bot.ts";
 import { Collection } from "../../util/collection.ts";
+import { DiscordenoUser } from "../../transformers/member.ts";
 
 /** Returns a list of ban objects for the users banned from this guild. Requires the BAN_MEMBERS permission. */
 export async function getBans(bot: Bot, guildId: bigint) {
   const results = await bot.rest.runMethod<Ban[]>(bot.rest, "get", bot.constants.endpoints.GUILD_BANS(guildId));
 
-  return new Collection<bigint, Ban>(results.map((res) => [bot.transformers.snowflake(res.user.id), res]));
+  return new Collection<bigint, { reason?: string; user: DiscordenoUser }>(
+    results.map((res) => [
+      bot.transformers.snowflake(res.user.id),
+      {
+        reason: res.reason ?? undefined,
+        user: bot.transformers.user(bot, res.user),
+      },
+    ])
+  );
 }
diff --git a/src/helpers/guilds/getGuild.ts b/src/helpers/guilds/getGuild.ts
index 2ab3ac409..d377319f2 100644
--- a/src/helpers/guilds/getGuild.ts
+++ b/src/helpers/guilds/getGuild.ts
@@ -2,16 +2,13 @@ import type { Guild } from "../../types/guilds/guild.ts";
 import type { Bot } from "../../bot.ts";
 
 /**
- * ⚠️ **If you need this, you are probably doing something wrong. Always use cache.guilds.get()
- *
- * Advanced Devs:
  * This function fetches a guild's data. This is not the same data as a GUILD_CREATE.
  * So it does not cache the guild, you must do it manually.
  * */
 export async function getGuild(
   bot: Bot,
   guildId: bigint,
-  options: { counts?: boolean; addToCache?: boolean } = {
+  options: { counts?: boolean } = {
     counts: true,
   }
 ) {
@@ -19,10 +16,8 @@ export async function getGuild(
     with_counts: options.counts,
   });
 
-  const guild = bot.transformers.guild(bot, {
+  return bot.transformers.guild(bot, {
     guild: result,
     shardId: bot.utils.calculateShardId(bot.gateway, guildId),
   });
-
-  return guild;
 }
diff --git a/src/helpers/guilds/getGuildPreview.ts b/src/helpers/guilds/getGuildPreview.ts
index d552d6720..90905f8b8 100644
--- a/src/helpers/guilds/getGuildPreview.ts
+++ b/src/helpers/guilds/getGuildPreview.ts
@@ -3,5 +3,22 @@ import type { Bot } from "../../bot.ts";
 
 /** Returns the guild preview object for the given id. If the bot is not in the guild, then the guild must be Discoverable. */
 export async function getGuildPreview(bot: Bot, guildId: bigint) {
-  return await bot.rest.runMethod<GuildPreview>(bot.rest, "get", bot.constants.endpoints.GUILD_PREVIEW(guildId));
+  const result = await bot.rest.runMethod<GuildPreview>(
+    bot.rest,
+    "get",
+    bot.constants.endpoints.GUILD_PREVIEW(guildId)
+  );
+
+  return {
+    id: bot.transformers.snowflake(result.id),
+    name: result.name,
+    icon: result.icon ?? undefined,
+    splash: result.splash ?? undefined,
+    discoverySplash: result.discovery_splash ?? undefined,
+    emojis: result.emojis.map((emoji) => bot.transformers.emoji(bot, emoji)),
+    features: result.features,
+    approximateMemberCount: result.approximate_member_count,
+    approximatePresenceCount: result.approximate_presence_count,
+    description: result.description ?? undefined,
+  };
 }
diff --git a/src/helpers/guilds/getVanityUrl.ts b/src/helpers/guilds/getVanityUrl.ts
index 3edba9272..1ee1e0b86 100644
--- a/src/helpers/guilds/getVanityUrl.ts
+++ b/src/helpers/guilds/getVanityUrl.ts
@@ -2,11 +2,15 @@ import type { InviteMetadata } from "../../types/invites/inviteMetadata.ts";
 import type { Bot } from "../../bot.ts";
 
 /** Returns the code and uses of the vanity url for this server if it is enabled else `code` will be null. Requires the `MANAGE_GUILD` permission. */
-export async function getVanityURL(bot: Bot, guildId: bigint) {
-  return await bot.rest.runMethod<
-    | (Partial<InviteMetadata> & Pick<InviteMetadata, "uses" | "code">)
-    | {
-        code: null;
-      }
-  >(bot.rest, "get", bot.constants.endpoints.GUILD_VANITY_URL(guildId));
+export async function getVanityUrl(bot: Bot, guildId: bigint) {
+  const result = await bot.rest.runMethod<Partial<InviteMetadata>>(
+    bot.rest,
+    "get",
+    bot.constants.endpoints.GUILD_VANITY_URL(guildId)
+  );
+
+  return {
+    uses: result.uses,
+    code: result.code,
+  };
 }
diff --git a/src/helpers/guilds/getVoiceRegions.ts b/src/helpers/guilds/getVoiceRegions.ts
index 53b090266..36f016665 100644
--- a/src/helpers/guilds/getVoiceRegions.ts
+++ b/src/helpers/guilds/getVoiceRegions.ts
@@ -10,5 +10,10 @@ export async function getVoiceRegions(bot: Bot, guildId: bigint) {
     bot.constants.endpoints.GUILD_REGIONS(guildId)
   );
 
-  return new Collection<string, VoiceRegion>(result.map((region) => [region.id, region]));
+  return new Collection(
+    result.map((reg) => {
+      const region = bot.transformers.voiceRegion(bot, reg);
+      return [region.id, region];
+    })
+  );
 }
diff --git a/src/helpers/guilds/getWelcomeScreen.ts b/src/helpers/guilds/getWelcomeScreen.ts
index d40145d1b..06e6e0fdc 100644
--- a/src/helpers/guilds/getWelcomeScreen.ts
+++ b/src/helpers/guilds/getWelcomeScreen.ts
@@ -2,9 +2,11 @@ import type { WelcomeScreen } from "../../types/guilds/welcomeScreen.ts";
 import type { Bot } from "../../bot.ts";
 
 export async function getWelcomeScreen(bot: Bot, guildId: bigint) {
-  return await bot.rest.runMethod<WelcomeScreen>(
+  const result = await bot.rest.runMethod<WelcomeScreen>(
     bot.rest,
     "get",
     bot.constants.endpoints.GUILD_WELCOME_SCREEN(guildId)
   );
+
+  return bot.transformers.welcomeScreen(bot, result);
 }
diff --git a/src/helpers/guilds/getWidget.ts b/src/helpers/guilds/getWidget.ts
index deb1b1e34..c51cc0a58 100644
--- a/src/helpers/guilds/getWidget.ts
+++ b/src/helpers/guilds/getWidget.ts
@@ -3,9 +3,28 @@ import type { Bot } from "../../bot.ts";
 
 /** Returns the widget for the guild. */
 export async function getWidget(bot: Bot, guildId: bigint) {
-  return await bot.rest.runMethod<GuildWidgetDetails>(
+  const result = await bot.rest.runMethod<GuildWidgetDetails>(
     bot.rest,
     "get",
     `${bot.constants.endpoints.GUILD_WIDGET(guildId)}.json`
   );
+
+  return {
+    id: bot.transformers.snowflake(result.id),
+    name: result.name,
+    instantInvite: result.instant_invite,
+    channels: result.channels.map((channel) => ({
+      id: bot.transformers.snowflake(channel.id),
+      name: channel.name,
+      position: channel.position,
+    })),
+    members: result.members.map((member) => ({
+      id: bot.transformers.snowflake(member.id),
+      username: member.username,
+      discriminator: Number(member.discriminator),
+      avatar: member.avatar ? bot.utils.iconHashToBigInt(member.avatar) : undefined,
+      status: member.status,
+    })),
+    presenceCount: result.presence_count,
+  };
 }
diff --git a/src/helpers/guilds/getWidgetSettings.ts b/src/helpers/guilds/getWidgetSettings.ts
index 4131916b1..5d6c49bf5 100644
--- a/src/helpers/guilds/getWidgetSettings.ts
+++ b/src/helpers/guilds/getWidgetSettings.ts
@@ -3,5 +3,7 @@ import type { Bot } from "../../bot.ts";
 
 /** Returns the guild widget object. Requires the MANAGE_GUILD permission. */
 export async function getWidgetSettings(bot: Bot, guildId: bigint) {
-  return await bot.rest.runMethod<GuildWidget>(bot.rest, "get", bot.constants.endpoints.GUILD_WIDGET(guildId));
+  const result = await bot.rest.runMethod<GuildWidget>(bot.rest, "get", bot.constants.endpoints.GUILD_WIDGET(guildId));
+
+  return bot.transformers.widget(bot, result);
 }
diff --git a/src/helpers/guilds/guildIconUrl.ts b/src/helpers/guilds/guildIconUrl.ts
index ca7a29c76..fcd4d89c5 100644
--- a/src/helpers/guilds/guildIconUrl.ts
+++ b/src/helpers/guilds/guildIconUrl.ts
@@ -6,20 +6,20 @@ import type { Bot } from "../../bot.ts";
 export function guildIconURL(
   bot: Bot,
   id: bigint,
-  options: {
-    icon?: string | bigint;
+  icon: bigint | undefined,
+  options?: {
     size?: ImageSize;
     format?: ImageFormat;
   }
 ) {
-  return options.icon
+  return icon
     ? bot.utils.formatImageURL(
         bot.constants.endpoints.GUILD_ICON(
           id,
-          typeof options.icon === "string" ? options.icon : bot.utils.iconBigintToHash(options.icon)
+          typeof icon === "string" ? icon : bot.utils.iconBigintToHash(icon)
         ),
-        options.size || 128,
-        options.format
+        options?.size || 128,
+        options?.format
       )
     : undefined;
 }
diff --git a/src/helpers/guilds/guildSplashUrl.ts b/src/helpers/guilds/guildSplashUrl.ts
index d9f28209b..defaa4930 100644
--- a/src/helpers/guilds/guildSplashUrl.ts
+++ b/src/helpers/guilds/guildSplashUrl.ts
@@ -6,20 +6,20 @@ import type { Bot } from "../../bot.ts";
 export function guildSplashURL(
   bot: Bot,
   id: bigint,
-  options: {
-    splash?: string | bigint;
+  splash: bigint | undefined,
+  options?: {
     size?: ImageSize;
     format?: ImageFormat;
   }
 ) {
-  return options.splash
+  return splash
     ? bot.utils.formatImageURL(
         bot.constants.endpoints.GUILD_SPLASH(
           id,
-          typeof options.splash === "string" ? options.splash : bot.utils.iconBigintToHash(options.splash)
+          typeof splash === "string" ? splash : bot.utils.iconBigintToHash(splash)
         ),
-        options.size || 128,
-        options.format
+        options?.size || 128,
+        options?.format
       )
     : undefined;
 }
diff --git a/src/helpers/guilds/leaveGuild.ts b/src/helpers/guilds/leaveGuild.ts
index 06d6f1756..fade59ee2 100644
--- a/src/helpers/guilds/leaveGuild.ts
+++ b/src/helpers/guilds/leaveGuild.ts
@@ -2,5 +2,5 @@ import type { Bot } from "../../bot.ts";
 
 /** Leave a guild */
 export async function leaveGuild(bot: Bot, guildId: bigint) {
-  return await bot.rest.runMethod<undefined>(bot.rest, "delete", bot.constants.endpoints.GUILD_LEAVE(guildId));
+  await bot.rest.runMethod<undefined>(bot.rest, "delete", bot.constants.endpoints.GUILD_LEAVE(guildId));
 }
diff --git a/src/helpers/integrations/deleteIntegration.ts b/src/helpers/integrations/deleteIntegration.ts
index 10d420230..5be3de2af 100644
--- a/src/helpers/integrations/deleteIntegration.ts
+++ b/src/helpers/integrations/deleteIntegration.ts
@@ -2,9 +2,5 @@ import type { Bot } from "../../bot.ts";
 
 /** Delete the attached integration object for the guild with this id. Requires MANAGE_GUILD permission. */
 export async function deleteIntegration(bot: Bot, guildId: bigint, id: bigint) {
-  return await bot.rest.runMethod<undefined>(
-    bot.rest,
-    "delete",
-    bot.constants.endpoints.GUILD_INTEGRATION(guildId, id)
-  );
+  await bot.rest.runMethod<undefined>(bot.rest, "delete", bot.constants.endpoints.GUILD_INTEGRATION(guildId, id));
 }
diff --git a/src/helpers/integrations/getIntegrations.ts b/src/helpers/integrations/getIntegrations.ts
index fb0d2fec2..4736d3d0e 100644
--- a/src/helpers/integrations/getIntegrations.ts
+++ b/src/helpers/integrations/getIntegrations.ts
@@ -1,7 +1,36 @@
 import type { Integration } from "../../types/integrations/integration.ts";
 import type { Bot } from "../../bot.ts";
+import { Collection } from "../../util/collection.ts";
 
 /** Returns a list of integrations for the guild. Requires the MANAGE_GUILD permission. */
 export async function getIntegrations(bot: Bot, guildId: bigint) {
-  return await bot.rest.runMethod<Integration>(bot.rest, "get", bot.constants.endpoints.GUILD_INTEGRATIONS(guildId));
+  const result = await bot.rest.runMethod<Integration[]>(
+    bot.rest,
+    "get",
+    bot.constants.endpoints.GUILD_INTEGRATIONS(guildId)
+  );
+
+  return new Collection(
+    result.map((res) => {
+      const integration = bot.transformers.integration(bot, {
+        guild_id: guildId.toString(),
+        id: res.id,
+        name: res.name,
+        type: res.type,
+        enabled: res.enabled,
+        syncing: res.syncing,
+        role_id: res.role_id,
+        enable_emoticons: res.enable_emoticons,
+        expire_behavior: res.expire_behavior,
+        expire_grace_period: res.expire_grace_period,
+        user: res.user,
+        account: res.account,
+        synced_at: res.synced_at,
+        subscriber_count: res.subscriber_count,
+        revoked: res.revoked,
+        application: res.application,
+      });
+      return [integration.id, integration];
+    })
+  );
 }
diff --git a/src/helpers/interactions/commands/createApplicationCommand.ts b/src/helpers/interactions/commands/createApplicationCommand.ts
index 7697739ca..fea31422c 100644
--- a/src/helpers/interactions/commands/createApplicationCommand.ts
+++ b/src/helpers/interactions/commands/createApplicationCommand.ts
@@ -1,5 +1,5 @@
 import type { ApplicationCommand } from "../../../types/interactions/commands/applicationCommand.ts";
-import type { CreateGlobalApplicationCommand } from "../../../types/interactions/commands/createGlobalApplicationCommand.ts";
+import type { CreateApplicationCommand } from "../../../types/interactions/commands/createGlobalApplicationCommand.ts";
 import type { Bot } from "../../../bot.ts";
 import { ApplicationCommandOption } from "../../../types/interactions/commands/applicationCommandOption.ts";
 
@@ -14,8 +14,8 @@ import { ApplicationCommandOption } from "../../../types/interactions/commands/a
  * Global commands are cached for **1 hour**. That means that new global commands will fan out slowly across all guilds, and will be guaranteed to be updated in an hour.
  * Guild commands update **instantly**. We recommend you use guild commands for quick testing, and global commands when they're ready for public use.
  */
-export async function createApplicationCommand(bot: Bot, options: CreateGlobalApplicationCommand, guildId?: bigint) {
-  return await bot.rest.runMethod<ApplicationCommand>(
+export async function createApplicationCommand(bot: Bot, options: CreateApplicationCommand, guildId?: bigint) {
+  const result = await bot.rest.runMethod<ApplicationCommand>(
     bot.rest,
     "post",
     guildId
@@ -28,6 +28,8 @@ export async function createApplicationCommand(bot: Bot, options: CreateGlobalAp
       options: options.options ? makeOptionsForCommand(options.options) : undefined,
     }
   );
+
+  return bot.transformers.applicationCommand(bot, result);
 }
 
 // @ts-ignore TODO: see if we can make this not circular
@@ -40,5 +42,8 @@ export function makeOptionsForCommand(options: ApplicationCommandOption[]) {
     choices: option.choices,
     options: option.options ? makeOptionsForCommand(option.options) : undefined,
     channel_types: option.channelTypes,
+    autocomplete: option.autocomplete,
+    min_value: option.minValue,
+    max_value: option.maxValue,
   }));
 }
diff --git a/src/helpers/interactions/commands/deleteApplicationCommand.ts b/src/helpers/interactions/commands/deleteApplicationCommand.ts
index d72b7cb68..073727b2d 100644
--- a/src/helpers/interactions/commands/deleteApplicationCommand.ts
+++ b/src/helpers/interactions/commands/deleteApplicationCommand.ts
@@ -1,8 +1,8 @@
 import type { Bot } from "../../../bot.ts";
 
-/** Deletes a slash command. */
+/** Deletes a application command. */
 export async function deleteApplicationCommand(bot: Bot, id: bigint, guildId?: bigint) {
-  return await bot.rest.runMethod<undefined>(
+  await bot.rest.runMethod<undefined>(
     bot.rest,
     "delete",
     guildId
diff --git a/src/helpers/interactions/commands/deleteInteractionResponse.ts b/src/helpers/interactions/commands/deleteInteractionResponse.ts
index 65b8b1a93..353cdd58a 100644
--- a/src/helpers/interactions/commands/deleteInteractionResponse.ts
+++ b/src/helpers/interactions/commands/deleteInteractionResponse.ts
@@ -1,8 +1,8 @@
 import type { Bot } from "../../../bot.ts";
 
-/** To delete your response to a slash command. If a message id is not provided, it will default to deleting the original response. */
+/** To delete your response to a application command. If a message id is not provided, it will default to deleting the original response. */
 export async function deleteInteractionResponse(bot: Bot, token: string, messageId?: bigint) {
-  return await bot.rest.runMethod<undefined>(
+  await bot.rest.runMethod<undefined>(
     bot.rest,
     "delete",
     messageId
diff --git a/src/helpers/interactions/commands/editInteractionResponse.ts b/src/helpers/interactions/commands/editInteractionResponse.ts
index 6c688dde1..b4c32c347 100644
--- a/src/helpers/interactions/commands/editInteractionResponse.ts
+++ b/src/helpers/interactions/commands/editInteractionResponse.ts
@@ -3,38 +3,8 @@ import type { Bot } from "../../../bot.ts";
 import { AllowedMentionsTypes } from "../../../types/messages/allowedMentionsTypes.ts";
 import { MessageComponentTypes } from "../../../types/messages/components/messageComponentTypes.ts";
 
-/** To edit your response to a slash command. If a messageId is not provided it will default to editing the original response. */
+/** To edit your response to a application command. If a messageId is not provided it will default to editing the original response. */
 export async function editInteractionResponse(bot: Bot, token: string, options: DiscordenoEditWebhookMessage) {
-  if (options.content && options.content.length > 2000) {
-    throw Error(bot.constants.Errors.MESSAGE_MAX_LENGTH);
-  }
-
-  if (options.embeds && options.embeds.length > 10) {
-    options.embeds.splice(10);
-  }
-
-  if (options.allowedMentions) {
-    if (options.allowedMentions.users?.length) {
-      if (options.allowedMentions.parse?.includes(AllowedMentionsTypes.UserMentions)) {
-        options.allowedMentions.parse = options.allowedMentions.parse.filter((p) => p !== "users");
-      }
-
-      if (options.allowedMentions.users.length > 100) {
-        options.allowedMentions.users = options.allowedMentions.users.slice(0, 100);
-      }
-    }
-
-    if (options.allowedMentions.roles?.length) {
-      if (options.allowedMentions.parse?.includes(AllowedMentionsTypes.RoleMentions)) {
-        options.allowedMentions.parse = options.allowedMentions.parse.filter((p) => p !== "roles");
-      }
-
-      if (options.allowedMentions.roles.length > 100) {
-        options.allowedMentions.roles = options.allowedMentions.roles.slice(0, 100);
-      }
-    }
-  }
-
   const result = await bot.rest.runMethod(
     bot.rest,
     "patch",
@@ -57,6 +27,18 @@ export async function editInteractionResponse(bot: Bot, token: string, options:
       components: options.components?.map((component) => ({
         type: component.type,
         components: component.components.map((subcomponent) => {
+          if (subcomponent.type === MessageComponentTypes.InputText) {
+            return {
+              type: subcomponent.type,
+              style: subcomponent.style,
+              custom_id: subcomponent.customId,
+              label: subcomponent.label,
+              placeholder: subcomponent.placeholder,
+              min_length: subcomponent.minLength ?? subcomponent.required === false ? 0 : subcomponent.minLength,
+              max_length: subcomponent.maxLength,
+            };
+          }
+
           if (subcomponent.type === MessageComponentTypes.SelectMenu)
             return {
               type: subcomponent.type,
@@ -84,15 +66,16 @@ export async function editInteractionResponse(bot: Bot, token: string, options:
             custom_id: subcomponent.customId,
             label: subcomponent.label,
             style: subcomponent.style,
-            emoji: subcomponent.emoji
-              ? {
-                  id: subcomponent.emoji.id?.toString(),
-                  name: subcomponent.emoji.name,
-                  animated: subcomponent.emoji.animated,
-                }
-              : undefined,
-            url: subcomponent.url,
-            disabled: subcomponent.disabled,
+            emoji:
+              "emoji" in subcomponent && subcomponent.emoji
+                ? {
+                    id: subcomponent.emoji.id?.toString(),
+                    name: subcomponent.emoji.name,
+                    animated: subcomponent.emoji.animated,
+                  }
+                : undefined,
+            url: "url" in subcomponent ? subcomponent.url : undefined,
+            disabled: "disabled" in subcomponent ? subcomponent.disabled : undefined,
           };
         }),
       })),
diff --git a/src/helpers/interactions/commands/getApplicationCommand.ts b/src/helpers/interactions/commands/getApplicationCommand.ts
index 5078307d5..6622a02cb 100644
--- a/src/helpers/interactions/commands/getApplicationCommand.ts
+++ b/src/helpers/interactions/commands/getApplicationCommand.ts
@@ -11,9 +11,5 @@ export async function getApplicationCommand(bot: Bot, commandId: bigint, guildId
       : bot.constants.endpoints.COMMANDS_ID(bot.applicationId, commandId)
   );
 
-  return {
-    ...result,
-    id: bot.transformers.snowflake(result.id),
-    applicationId: bot.transformers.snowflake(result.application_id),
-  };
+  return bot.transformers.applicationCommand(bot, result);
 }
diff --git a/src/helpers/interactions/commands/getApplicationCommandPermission.ts b/src/helpers/interactions/commands/getApplicationCommandPermission.ts
index 52374b2b3..86e2ed419 100644
--- a/src/helpers/interactions/commands/getApplicationCommandPermission.ts
+++ b/src/helpers/interactions/commands/getApplicationCommandPermission.ts
@@ -3,9 +3,11 @@ import type { Bot } from "../../../bot.ts";
 
 /** Fetches command permissions for a specific command for your application in a guild. Returns a GuildApplicationCommandPermissions object. */
 export async function getApplicationCommandPermission(bot: Bot, guildId: bigint, commandId: bigint) {
-  return await bot.rest.runMethod<GuildApplicationCommandPermissions>(
+  const result = await bot.rest.runMethod<GuildApplicationCommandPermissions>(
     bot.rest,
     "get",
     bot.constants.endpoints.COMMANDS_PERMISSION(bot.applicationId, guildId, commandId)
   );
+
+  return bot.transformers.applicationCommandPermission(bot, result);
 }
diff --git a/src/helpers/interactions/commands/getApplicationCommandPermissions.ts b/src/helpers/interactions/commands/getApplicationCommandPermissions.ts
index 2b9c4c015..adac57736 100644
--- a/src/helpers/interactions/commands/getApplicationCommandPermissions.ts
+++ b/src/helpers/interactions/commands/getApplicationCommandPermissions.ts
@@ -1,11 +1,19 @@
 import type { Bot } from "../../../bot.ts";
 import type { GuildApplicationCommandPermissions } from "../../../types/interactions/commands/guildApplicationCommandPermissions.ts";
+import { Collection } from "../../../util/collection.ts";
 
 /** Fetches command permissions for all commands for your application in a guild. Returns an array of GuildApplicationCommandPermissions objects. */
 export async function getApplicationCommandPermissions(bot: Bot, guildId: bigint) {
-  return await bot.rest.runMethod<GuildApplicationCommandPermissions[]>(
+  const result = await bot.rest.runMethod<GuildApplicationCommandPermissions[]>(
     bot.rest,
     "get",
     bot.constants.endpoints.COMMANDS_PERMISSIONS(bot.applicationId, guildId)
   );
+
+  return new Collection(
+    result.map((res) => {
+      const perms = bot.transformers.applicationCommandPermission(bot, res);
+      return [perms.id, perms];
+    })
+  );
 }
diff --git a/src/helpers/interactions/commands/getApplicationCommands.ts b/src/helpers/interactions/commands/getApplicationCommands.ts
index 004873678..4af891a24 100644
--- a/src/helpers/interactions/commands/getApplicationCommands.ts
+++ b/src/helpers/interactions/commands/getApplicationCommands.ts
@@ -2,7 +2,7 @@ import type { ApplicationCommand } from "../../../types/interactions/commands/ap
 import { Collection } from "../../../util/collection.ts";
 import type { Bot } from "../../../bot.ts";
 
-/** Fetch all the global commands for your application. */
+/** Fetch all the commands for your application. If a guild id is not provided, it will fetch global commands. */
 export async function getApplicationCommands(bot: Bot, guildId?: bigint) {
   const result = await bot.rest.runMethod<ApplicationCommand[]>(
     bot.rest,
@@ -13,13 +13,9 @@ export async function getApplicationCommands(bot: Bot, guildId?: bigint) {
   );
 
   return new Collection(
-    result.map((command) => [
-      command.name,
-      {
-        ...command,
-        id: bot.transformers.snowflake(command.id),
-        applicationId: bot.transformers.snowflake(command.application_id),
-      },
-    ])
+    result.map((res) => {
+      const command = bot.transformers.applicationCommand(bot, res);
+      return [command.id, command];
+    })
   );
 }
diff --git a/src/helpers/interactions/commands/upsertApplicationCommand.ts b/src/helpers/interactions/commands/upsertApplicationCommand.ts
index d2f868533..0d00b715b 100644
--- a/src/helpers/interactions/commands/upsertApplicationCommand.ts
+++ b/src/helpers/interactions/commands/upsertApplicationCommand.ts
@@ -4,7 +4,7 @@ import type { Bot } from "../../../bot.ts";
 import { makeOptionsForCommand } from "./createApplicationCommand.ts";
 
 /**
- * Edit an existing slash command. If this command did not exist, it will create it.
+ * Edit an existing application command. If this command did not exist, it will create it.
  */
 export async function upsertApplicationCommand(
   bot: Bot,
@@ -12,7 +12,7 @@ export async function upsertApplicationCommand(
   options: EditGlobalApplicationCommand,
   guildId?: bigint
 ) {
-  return await bot.rest.runMethod<ApplicationCommand>(
+  const result = await bot.rest.runMethod<ApplicationCommand>(
     bot.rest,
     "patch",
     guildId
@@ -25,4 +25,6 @@ export async function upsertApplicationCommand(
       options: options.options ? makeOptionsForCommand(options.options) : undefined,
     }
   );
+
+  return bot.transformers.applicationCommand(bot, result);
 }
diff --git a/src/helpers/interactions/commands/upsertApplicationCommands.ts b/src/helpers/interactions/commands/upsertApplicationCommands.ts
index 0667890b4..b47f668e3 100644
--- a/src/helpers/interactions/commands/upsertApplicationCommands.ts
+++ b/src/helpers/interactions/commands/upsertApplicationCommands.ts
@@ -2,23 +2,39 @@ import type { ApplicationCommand } from "../../../types/interactions/commands/ap
 import type { EditGlobalApplicationCommand } from "../../../types/interactions/commands/editGlobalApplicationCommand.ts";
 import type { MakeRequired } from "../../../types/util.ts";
 import type { Bot } from "../../../bot.ts";
+import { Collection } from "../../../util/collection.ts";
+import { ApplicationCommandOption } from "../../../types/interactions/commands/applicationCommandOption.ts";
+import { makeOptionsForCommand } from "./createApplicationCommand.ts";
 
 /**
- * Bulk edit existing slash commands. If a command does not exist, it will create it.
+ * Bulk edit existing application commands. If a command does not exist, it will create it.
  *
- * **NOTE:** Any slash commands that are not specified in this function will be **deleted**. If you don't provide the commandId and rename your command, the command gets a new Id.
+ * **NOTE:** Any application commands that are not specified in this function will be **deleted**. If you don't provide the commandId and rename your command, the command gets a new Id.
  */
 export async function upsertApplicationCommands(
   bot: Bot,
   options: MakeRequired<EditGlobalApplicationCommand, "name">[],
   guildId?: bigint
 ) {
-  return await bot.rest.runMethod<ApplicationCommand[]>(
+  const result = await bot.rest.runMethod<ApplicationCommand[]>(
     bot.rest,
     "put",
     guildId
       ? bot.constants.endpoints.COMMANDS_GUILD(bot.applicationId, guildId)
       : bot.constants.endpoints.COMMANDS(bot.applicationId),
-    options
+    options.map((option) => ({
+      name: option.name,
+      description: option.description,
+      type: option.type,
+      options: option.options ? makeOptionsForCommand(option.options) : undefined,
+      default_permission: option.defaultPermission,
+    }))
+  );
+
+  return new Collection(
+    result.map((res) => {
+      const command = bot.transformers.applicationCommand(bot, res);
+      return [command.id, command];
+    })
   );
 }
diff --git a/src/helpers/interactions/followups/editFollowupMessage.ts b/src/helpers/interactions/followups/editFollowupMessage.ts
index f3dcdfd86..173e64927 100644
--- a/src/helpers/interactions/followups/editFollowupMessage.ts
+++ b/src/helpers/interactions/followups/editFollowupMessage.ts
@@ -11,36 +11,6 @@ export async function editFollowupMessage(
   messageId: bigint,
   options: EditWebhookMessage
 ) {
-  if (options.content && options.content.length > 2000) {
-    throw Error(bot.constants.Errors.MESSAGE_MAX_LENGTH);
-  }
-
-  if (options.embeds && options.embeds.length > 10) {
-    options.embeds.splice(10);
-  }
-
-  if (options.allowedMentions) {
-    if (options.allowedMentions.users?.length) {
-      if (options.allowedMentions.parse?.includes(AllowedMentionsTypes.UserMentions)) {
-        options.allowedMentions.parse = options.allowedMentions.parse.filter((p) => p !== "users");
-      }
-
-      if (options.allowedMentions.users.length > 100) {
-        options.allowedMentions.users = options.allowedMentions.users.slice(0, 100);
-      }
-    }
-
-    if (options.allowedMentions.roles?.length) {
-      if (options.allowedMentions.parse?.includes(AllowedMentionsTypes.RoleMentions)) {
-        options.allowedMentions.parse = options.allowedMentions.parse.filter((p) => p !== "roles");
-      }
-
-      if (options.allowedMentions.roles.length > 100) {
-        options.allowedMentions.roles = options.allowedMentions.roles.slice(0, 100);
-      }
-    }
-  }
-
   const result = await bot.rest.runMethod<Message>(
     bot.rest,
     "patch",
@@ -61,6 +31,18 @@ export async function editFollowupMessage(
       components: options.components?.map((component) => ({
         type: component.type,
         components: component.components.map((subcomponent) => {
+          if (subcomponent.type === MessageComponentTypes.InputText) {
+            return {
+              type: subcomponent.type,
+              style: subcomponent.style,
+              custom_id: subcomponent.customId,
+              label: subcomponent.label,
+              placeholder: subcomponent.placeholder,
+              min_length: subcomponent.minLength ?? subcomponent.required === false ? 0 : subcomponent.minLength,
+              max_length: subcomponent.maxLength,
+            };
+          }
+
           if (subcomponent.type === MessageComponentTypes.SelectMenu)
             return {
               type: subcomponent.type,
diff --git a/src/helpers/interactions/sendInteractionResponse.ts b/src/helpers/interactions/sendInteractionResponse.ts
index af99c741a..c81848bec 100644
--- a/src/helpers/interactions/sendInteractionResponse.ts
+++ b/src/helpers/interactions/sendInteractionResponse.ts
@@ -1,10 +1,10 @@
 import type { DiscordenoInteractionResponse } from "../../types/discordeno/interactionResponse.ts";
 import type { Bot } from "../../bot.ts";
-import { AllowedMentions } from "../../types/messages/allowedMentions.ts";
 import { MessageComponentTypes } from "../../types/messages/components/messageComponentTypes.ts";
+import { Message } from "../../types/messages/message.ts";
 
 /**
- * Send a response to a users slash command. The command data will have the id and token necessary to respond.
+ * Send a response to a users application command. The command data will have the id and token necessary to respond.
  * Interaction `tokens` are valid for **15 minutes** and can be used to send followup messages.
  *
  * NOTE: By default we will suppress mentions. To enable mentions, just pass any mentions object.
@@ -85,9 +85,23 @@ export async function sendInteractionResponse(
       roles: options.data.allowedMentions!.roles?.map((id) => id.toString()),
     },
     file: options.data.file,
+    custom_id: options.data.customId,
+    title: options.data.title,
     components: options.data.components?.map((component) => ({
       type: component.type,
       components: component.components.map((subcomponent) => {
+        if (subcomponent.type === MessageComponentTypes.InputText) {
+          return {
+            type: subcomponent.type,
+            style: subcomponent.style,
+            custom_id: subcomponent.customId,
+            label: subcomponent.label,
+            placeholder: subcomponent.placeholder,
+            min_length: subcomponent.minLength ?? subcomponent.required === false ? 0 : subcomponent.minLength,
+            max_length: subcomponent.maxLength,
+          };
+        }
+
         if (subcomponent.type === MessageComponentTypes.SelectMenu)
           return {
             type: subcomponent.type,
@@ -115,29 +129,33 @@ export async function sendInteractionResponse(
           custom_id: subcomponent.customId,
           label: subcomponent.label,
           style: subcomponent.style,
-          emoji: subcomponent.emoji
-            ? {
-                id: subcomponent.emoji.id?.toString(),
-                name: subcomponent.emoji.name,
-                animated: subcomponent.emoji.animated,
-              }
-            : undefined,
-          url: subcomponent.url,
-          disabled: subcomponent.disabled,
+          emoji:
+            "emoji" in subcomponent && subcomponent.emoji
+              ? {
+                  id: subcomponent.emoji.id?.toString(),
+                  name: subcomponent.emoji.name,
+                  animated: subcomponent.emoji.animated,
+                }
+              : undefined,
+          url: "url" in subcomponent ? subcomponent.url : undefined,
+          disabled: "disabled" in subcomponent ? subcomponent.disabled : undefined,
         };
       }),
     })),
     flags: options.data.flags,
+    choices: options.data.choices,
   };
 
   // A reply has never been send
   if (bot.cache.unrepliedInteractions.delete(id)) {
-    return await bot.rest.runMethod(bot.rest, "post", bot.constants.endpoints.INTERACTION_ID_TOKEN(id, token), {
+    return await bot.rest.runMethod<undefined>(bot.rest, "post", bot.constants.endpoints.INTERACTION_ID_TOKEN(id, token), {
       type: options.type,
       data,
     });
   }
 
   // If its already been executed, we need to send a followup response
-  return await bot.rest.runMethod(bot.rest, "post", bot.constants.endpoints.WEBHOOK(bot.applicationId, token), data);
+  const result = await bot.rest.runMethod<Message>(bot.rest, "post", bot.constants.endpoints.WEBHOOK(bot.applicationId, token), data);
+
+  return bot.transformers.message(bot, result);
 }
diff --git a/src/helpers/interactions/verifySignature.ts b/src/helpers/interactions/verifySignature.ts
index f6f4a1806..f062d6be0 100644
--- a/src/helpers/interactions/verifySignature.ts
+++ b/src/helpers/interactions/verifySignature.ts
@@ -1,4 +1,4 @@
-import { verify } from "https://unpkg.com/@evan/wasm@0.0.87/target/ed25519/deno.js";
+import { verify } from "https://unpkg.com/@evan/wasm@0.0.93/target/ed25519/deno.js";
 
 export function verifySignature({ publicKey, signature, timestamp, body }: VerifySignatureOptions): {
   isValid: boolean;
diff --git a/src/helpers/invites/createInvite.ts b/src/helpers/invites/createInvite.ts
index 077110979..7ba836210 100644
--- a/src/helpers/invites/createInvite.ts
+++ b/src/helpers/invites/createInvite.ts
@@ -6,14 +6,7 @@ import { SnakeCasedPropertiesDeep } from "../../types/util.ts";
 
 /** Creates a new invite for this channel. Requires CREATE_INSTANT_INVITE */
 export async function createInvite(bot: Bot, channelId: bigint, options: CreateChannelInvite = {}) {
-  if (options.maxAge && (options.maxAge < 0 || options.maxAge > 604800)) {
-    throw new Error(Errors.INVITE_MAX_AGE_INVALID);
-  }
-  if (options.maxUses && (options.maxUses < 0 || options.maxUses > 100)) {
-    throw new Error(Errors.INVITE_MAX_USES_INVALID);
-  }
-
-  return await bot.rest.runMethod<InviteMetadata>(
+  const result = await bot.rest.runMethod<InviteMetadata>(
     bot.rest,
     "post",
     bot.constants.endpoints.CHANNEL_INVITES(channelId),
@@ -27,4 +20,12 @@ export async function createInvite(bot: Bot, channelId: bigint, options: CreateC
       target_application_id: options.targetUserId,
     }
   );
+
+  return {
+    uses: result.uses,
+    maxUses: result.max_uses,
+    maxAge: result.max_age,
+    temporary: result.temporary,
+    createdAt: result.created_at,
+  };
 }
diff --git a/src/helpers/invites/deleteInvite.ts b/src/helpers/invites/deleteInvite.ts
index 3fa82a88b..76d923a29 100644
--- a/src/helpers/invites/deleteInvite.ts
+++ b/src/helpers/invites/deleteInvite.ts
@@ -3,5 +3,5 @@ import type { Bot } from "../../bot.ts";
 
 /** Deletes an invite for the given code. Requires `MANAGE_CHANNELS` or `MANAGE_GUILD` permission */
 export async function deleteInvite(bot: Bot, inviteCode: string) {
-  return await bot.rest.runMethod<InviteMetadata>(bot.rest, "delete", bot.constants.endpoints.INVITE(inviteCode));
+  await bot.rest.runMethod<InviteMetadata>(bot.rest, "delete", bot.constants.endpoints.INVITE(inviteCode));
 }
diff --git a/src/helpers/invites/getChannelInvites.ts b/src/helpers/invites/getChannelInvites.ts
index 6ad0f7cd6..4341416ec 100644
--- a/src/helpers/invites/getChannelInvites.ts
+++ b/src/helpers/invites/getChannelInvites.ts
@@ -1,7 +1,6 @@
 import type { InviteMetadata } from "../../types/invites/inviteMetadata.ts";
 import { Collection } from "../../util/collection.ts";
 import type { Bot } from "../../bot.ts";
-import { SnakeCasedPropertiesDeep } from "../../types/util.ts";
 
 /** Gets the invites for this channel. Requires MANAGE_CHANNEL */
 export async function getChannelInvites(bot: Bot, channelId: bigint) {
@@ -11,5 +10,16 @@ export async function getChannelInvites(bot: Bot, channelId: bigint) {
     bot.constants.endpoints.CHANNEL_INVITES(channelId)
   );
 
-  return new Collection(result.map((invite) => [invite.code, invite]));
+  return new Collection(
+    result.map((invite) => [
+      invite.code,
+      {
+        uses: invite.uses,
+        maxUses: invite.max_uses,
+        maxAge: invite.max_age,
+        temporary: invite.temporary,
+        createdAt: Date.parse(invite.created_at),
+      },
+    ])
+  );
 }
diff --git a/src/helpers/invites/getInvite.ts b/src/helpers/invites/getInvite.ts
index 654c6d7bd..5eb3b5caa 100644
--- a/src/helpers/invites/getInvite.ts
+++ b/src/helpers/invites/getInvite.ts
@@ -4,9 +4,17 @@ import type { Bot } from "../../bot.ts";
 
 /** Returns an invite for the given code or throws an error if the invite doesn't exists. */
 export async function getInvite(bot: Bot, inviteCode: string, options?: GetInvite) {
-  return await bot.rest.runMethod<InviteMetadata>(bot.rest, "get", bot.constants.endpoints.INVITE(inviteCode), {
+  const result = await bot.rest.runMethod<InviteMetadata>(bot.rest, "get", bot.constants.endpoints.INVITE(inviteCode), {
     with_counts: options?.withCounts || false,
     with_expiration: options?.withExpiration || false,
     guild_scheduled_event_id: options?.scheduledEventId?.toString(),
   });
+
+  return {
+    uses: result.uses,
+    maxUses: result.max_uses,
+    maxAge: result.max_age,
+    temporary: result.temporary,
+    createdAt: result.created_at,
+  };
 }
diff --git a/src/helpers/invites/getInvites.ts b/src/helpers/invites/getInvites.ts
index 07a64588b..a828fcde9 100644
--- a/src/helpers/invites/getInvites.ts
+++ b/src/helpers/invites/getInvites.ts
@@ -11,5 +11,16 @@ export async function getInvites(bot: Bot, guildId: bigint) {
     bot.constants.endpoints.GUILD_INVITES(guildId)
   );
 
-  return new Collection(result.map((invite) => [invite.code, invite]));
+  return new Collection(
+    result.map((invite) => [
+      invite.code,
+      {
+        uses: invite.uses,
+        maxUses: invite.max_uses,
+        maxAge: invite.max_age,
+        temporary: invite.temporary,
+        createdAt: Date.parse(invite.created_at),
+      },
+    ])
+  );
 }
diff --git a/src/helpers/members/avatarUrl.ts b/src/helpers/members/avatarUrl.ts
index 0114d497a..4bbd15d87 100644
--- a/src/helpers/members/avatarUrl.ts
+++ b/src/helpers/members/avatarUrl.ts
@@ -7,20 +7,20 @@ export function avatarURL(
   bot: Bot,
   userId: bigint,
   discriminator: number,
-  options: {
-    avatar?: string | bigint;
+  options?: {
+    avatar: bigint | undefined;
     size?: ImageSize;
     format?: ImageFormat;
   }
 ) {
-  return options.avatar
+  return options?.avatar
     ? bot.utils.formatImageURL(
         bot.constants.endpoints.USER_AVATAR(
           userId,
-          typeof options.avatar === "string" ? options.avatar : bot.utils.iconBigintToHash(options.avatar)
+          typeof options?.avatar === "string" ? options.avatar : bot.utils.iconBigintToHash(options?.avatar)
         ),
-        options.size || 128,
-        options.format
+        options?.size || 128,
+        options?.format
       )
     : bot.constants.endpoints.USER_DEFAULT_AVATAR(Number(discriminator) % 5);
 }
diff --git a/src/helpers/members/banMember.ts b/src/helpers/members/banMember.ts
index fe4bc9655..e0e7cad44 100644
--- a/src/helpers/members/banMember.ts
+++ b/src/helpers/members/banMember.ts
@@ -3,7 +3,7 @@ import type { Bot } from "../../bot.ts";
 
 /** Ban a user from the guild and optionally delete previous messages sent by the user. Requires the BAN_MEMBERS permission. */
 export async function banMember(bot: Bot, guildId: bigint, id: bigint, options?: CreateGuildBan) {
-  return await bot.rest.runMethod<undefined>(
+  await bot.rest.runMethod<undefined>(
     bot.rest,
     "put",
     bot.constants.endpoints.GUILD_BAN(guildId, id),
diff --git a/src/helpers/members/disconnectMember.ts b/src/helpers/members/disconnectMember.ts
deleted file mode 100644
index 3eadbc25a..000000000
--- a/src/helpers/members/disconnectMember.ts
+++ /dev/null
@@ -1,6 +0,0 @@
-import type { Bot } from "../../bot.ts";
-
-/** Kicks a member from a voice channel */
-export function disconnectMember(bot: Bot, guildId: bigint, memberId: bigint) {
-  return bot.helpers.editMember(guildId, memberId, { channelId: null });
-}
diff --git a/src/helpers/members/editMember.ts b/src/helpers/members/editMember.ts
index fc7b6d8e3..721bc1a4d 100644
--- a/src/helpers/members/editMember.ts
+++ b/src/helpers/members/editMember.ts
@@ -1,6 +1,5 @@
 import type { ModifyGuildMember } from "../../types/guilds/modifyGuildMember.ts";
 import type { GuildMemberWithUser } from "../../types/members/guildMember.ts";
-import type { PermissionStrings } from "../../types/permissions/permissionStrings.ts";
 import type { Bot } from "../../bot.ts";
 
 /** Edit the member */
diff --git a/src/helpers/members/fetchMembers.ts b/src/helpers/members/fetchMembers.ts
index eaa38ef08..f941bdcdd 100644
--- a/src/helpers/members/fetchMembers.ts
+++ b/src/helpers/members/fetchMembers.ts
@@ -6,9 +6,6 @@ import { GatewayOpcodes } from "../../types/codes/gatewayOpcodes.ts";
 import type { DiscordenoMember } from "../../transformers/member.ts";
 
 /**
- * ⚠️ BEGINNER DEVS!! YOU SHOULD ALMOST NEVER NEED THIS AND YOU CAN GET FROM cache.members.get()
- *
- * ADVANCED:
  * Highly recommended to use this function to fetch members instead of getMember from REST.
  * REST: 50/s global(across all shards) rate limit with ALL requests this included
  * GW(this function): 120/m(PER shard) rate limit. Meaning if you have 8 shards your limit is now 960/m.
diff --git a/src/helpers/members/getDmChannel.ts b/src/helpers/members/getDmChannel.ts
index 177e03d84..8411c8ea2 100644
--- a/src/helpers/members/getDmChannel.ts
+++ b/src/helpers/members/getDmChannel.ts
@@ -1,12 +1,13 @@
 import type { Channel } from "../../types/channels/channel.ts";
 import type { Bot } from "../../bot.ts";
 
-/** Get a user's dm channel. This is required in order to send a DM.  */
+/** Get a user's dm channel. This is required in order to send a DM. */
 export async function getDmChannel(bot: Bot, userId: bigint) {
   if (userId === bot.id) throw new Error(bot.constants.Errors.YOU_CAN_NOT_DM_THE_BOT_ITSELF);
 
   const dmChannelData = await bot.rest.runMethod<Channel>(bot.rest, "post", bot.constants.endpoints.USER_DM, {
     recipient_id: userId.toString(),
   });
+  
   return bot.transformers.channel(bot, { channel: dmChannelData });
 }
diff --git a/src/helpers/members/getMembers.ts b/src/helpers/members/getMembers.ts
index 0da8fc150..a4c14ea90 100644
--- a/src/helpers/members/getMembers.ts
+++ b/src/helpers/members/getMembers.ts
@@ -5,54 +5,25 @@ import { Collection } from "../../util/collection.ts";
 import type { DiscordenoMember } from "../../transformers/member.ts";
 
 /**
- * ⚠️ BEGINNER DEVS!! YOU SHOULD ALMOST NEVER NEED THIS AND YOU CAN GET FROM cache.members.get()
- *
- * ADVANCED:
  * Highly recommended to **NOT** use this function to get members instead use fetchMembers().
  * REST(this function): 50/s global(across all shards) rate limit with ALL requests this included
  * GW(fetchMembers): 120/m(PER shard) rate limit. Meaning if you have 8 shards your limit is 960/m.
  */
 export async function getMembers(bot: Bot, guildId: bigint, options: ListGuildMembers & { memberCount: number }) {
-  const members = new Collection<bigint, DiscordenoMember>();
-
-  let membersLeft = options?.limit ?? options.memberCount;
-  let loops = 1;
-  while ((options?.limit ?? options.memberCount) > members.size && membersLeft > 0) {
-    bot.events.debug("Running while loop in getMembers function.");
-
-    if (options?.limit && options.limit > 1000) {
-      console.log(`Paginating get members from REST. #${loops} / ${Math.ceil((options?.limit ?? 1) / 1000)}`);
+  const result = await bot.rest.runMethod<GuildMemberWithUser[]>(
+    bot.rest,
+    "get",
+    bot.constants.endpoints.GUILD_MEMBERS(guildId),
+    {
+      limit: options?.limit ?? options.memberCount,
+      after: options?.after,
     }
+  );
 
-    const result = await bot.rest.runMethod<GuildMemberWithUser[]>(
-      bot.rest,
-      "get",
-      `${bot.constants.endpoints.GUILD_MEMBERS(guildId)}?limit=${membersLeft > 1000 ? 1000 : membersLeft}${
-        options?.after ? `&after=${options.after}` : ""
-      }`
-    );
-
-    const discordenoMembers = result.map((member) =>
-      bot.transformers.member(bot, member, guildId, bot.transformers.snowflake(member.user.id))
-    );
-
-    if (!discordenoMembers.length) break;
-
-    discordenoMembers.forEach((member) => {
-      bot.events.debug(`Running forEach loop in get_members file.`);
-      members.set(member.id, member);
-    });
-
-    options = {
-      limit: options?.limit,
-      after: discordenoMembers[discordenoMembers.length - 1].id.toString(),
-      memberCount: options.memberCount,
-    };
-
-    membersLeft -= 1000;
-
-    loops++;
-  }
-
-  return members;
+  return new Collection(
+    result.map((res) => {
+      const member = bot.transformers.member(bot, res, guildId, bot.transformers.snowflake(res.user.id));
+      return [member.id, member];
+    })
+  );
 }
diff --git a/src/helpers/members/kickMember.ts b/src/helpers/members/kickMember.ts
index c2dd61543..d6145521b 100644
--- a/src/helpers/members/kickMember.ts
+++ b/src/helpers/members/kickMember.ts
@@ -2,10 +2,7 @@ import { Bot } from "../../bot.ts";
 
 /** Kick a member from the server */
 export async function kickMember(bot: Bot, guildId: bigint, memberId: bigint, reason?: string) {
-  return await bot.rest.runMethod<undefined>(
-    bot.rest,
-    "delete",
-    bot.constants.endpoints.GUILD_MEMBER(guildId, memberId),
-    { reason }
-  );
+  await bot.rest.runMethod<undefined>(bot.rest, "delete", bot.constants.endpoints.GUILD_MEMBER(guildId, memberId), {
+    reason,
+  });
 }
diff --git a/src/helpers/members/moveMember.ts b/src/helpers/members/moveMember.ts
deleted file mode 100644
index 55a5b0e47..000000000
--- a/src/helpers/members/moveMember.ts
+++ /dev/null
@@ -1,12 +0,0 @@
-import type { Bot } from "../../bot.ts";
-
-/**
- * Move a member from a voice channel to another.
- * @param bot the bot
- * @param guildId the id of the guild which the channel exists in
- * @param memberId the id of the member to move.
- * @param channelId id of channel to move user to (if they are connected to voice)
- */
-export function moveMember(bot: Bot, guildId: bigint, memberId: bigint, channelId: bigint) {
-  return bot.helpers.editMember(guildId, memberId, { channelId });
-}
diff --git a/src/helpers/members/searchMembers.ts b/src/helpers/members/searchMembers.ts
index 96d83bd1c..913f902a3 100644
--- a/src/helpers/members/searchMembers.ts
+++ b/src/helpers/members/searchMembers.ts
@@ -4,17 +4,13 @@ import { Collection } from "../../util/collection.ts";
 import { Bot } from "../../bot.ts";
 
 /**
- * ⚠️ BEGINNER DEVS!! YOU SHOULD ALMOST NEVER NEED THIS AND YOU CAN GET FROM cache.members.filter()
- * @param bot
- * @param guildId
- * @param query Query string to match username(s) and nickname(s) against
- * @param options
+ * Query string to match username(s) and nickname(s) against
  */
 export async function searchMembers(
   bot: Bot,
   guildId: bigint,
   query: string,
-  options?: Omit<SearchGuildMembers, "query"> & { cache?: boolean }
+  options?: Omit<SearchGuildMembers, "query">
 ) {
   if (options?.limit) {
     if (options.limit < 1) throw new Error(bot.constants.Errors.MEMBER_SEARCH_LIMIT_TOO_LOW);
diff --git a/src/helpers/members/unbanMember.ts b/src/helpers/members/unbanMember.ts
index 71bc569c5..2dd874620 100644
--- a/src/helpers/members/unbanMember.ts
+++ b/src/helpers/members/unbanMember.ts
@@ -2,5 +2,5 @@ import type { Bot } from "../../bot.ts";
 
 /** Remove the ban for a user. Requires BAN_MEMBERS permission */
 export async function unbanMember(bot: Bot, guildId: bigint, id: bigint) {
-  return await bot.rest.runMethod<undefined>(bot.rest, "delete", bot.constants.endpoints.GUILD_BAN(guildId, id));
+  await bot.rest.runMethod<undefined>(bot.rest, "delete", bot.constants.endpoints.GUILD_BAN(guildId, id));
 }
diff --git a/src/helpers/messages/addReaction.ts b/src/helpers/messages/addReaction.ts
index 1f4390a49..855f00e70 100644
--- a/src/helpers/messages/addReaction.ts
+++ b/src/helpers/messages/addReaction.ts
@@ -8,7 +8,7 @@ export async function addReaction(bot: Bot, channelId: bigint, messageId: bigint
     reaction = reaction.substring(3, reaction.length - 1);
   }
 
-  return await bot.rest.runMethod<undefined>(
+  await bot.rest.runMethod<undefined>(
     bot.rest,
     "put",
     bot.constants.endpoints.CHANNEL_MESSAGE_REACTION_ME(channelId, messageId, encodeURIComponent(reaction)),
diff --git a/src/helpers/messages/deleteMessage.ts b/src/helpers/messages/deleteMessage.ts
index 043361767..875e404ea 100644
--- a/src/helpers/messages/deleteMessage.ts
+++ b/src/helpers/messages/deleteMessage.ts
@@ -1,4 +1,3 @@
-// import { cacheHandlers } from "../../cache.ts";
 import type { Bot } from "../../bot.ts";
 
 /** Delete a message with the channel id and message id only. */
@@ -11,7 +10,7 @@ export async function deleteMessage(
 ) {
   if (delayMilliseconds) await bot.utils.delay(delayMilliseconds);
 
-  return await bot.rest.runMethod<undefined>(
+  await bot.rest.runMethod<undefined>(
     bot.rest,
     "delete",
     bot.constants.endpoints.CHANNEL_MESSAGE(channelId, messageId),
diff --git a/src/helpers/messages/deleteMessages.ts b/src/helpers/messages/deleteMessages.ts
index c7c8a9249..591ad79a8 100644
--- a/src/helpers/messages/deleteMessages.ts
+++ b/src/helpers/messages/deleteMessages.ts
@@ -10,7 +10,7 @@ export async function deleteMessages(bot: Bot, channelId: bigint, ids: bigint[],
     console.warn(`This endpoint only accepts a maximum of 100 messages. Deleting the first 100 message ids provided.`);
   }
 
-  return await bot.rest.runMethod<undefined>(bot.rest, "post", bot.constants.endpoints.CHANNEL_BULK_DELETE(channelId), {
+  await bot.rest.runMethod<undefined>(bot.rest, "post", bot.constants.endpoints.CHANNEL_BULK_DELETE(channelId), {
     messages: ids.splice(0, 100).map((id) => id.toString()),
     reason,
   });
diff --git a/src/helpers/messages/editMessage.ts b/src/helpers/messages/editMessage.ts
index f77efec96..05feb4360 100644
--- a/src/helpers/messages/editMessage.ts
+++ b/src/helpers/messages/editMessage.ts
@@ -88,6 +88,18 @@ export async function editMessage(bot: Bot, channelId: bigint, messageId: bigint
       components: content.components?.map((component) => ({
         type: component.type,
         components: component.components.map((subcomponent) => {
+          if (subcomponent.type === MessageComponentTypes.InputText) {
+            return {
+              type: subcomponent.type,
+              style: subcomponent.style,
+              custom_id: subcomponent.customId,
+              label: subcomponent.label,
+              placeholder: subcomponent.placeholder,
+              min_length: subcomponent.minLength ?? subcomponent.required === false ? 0 : subcomponent.minLength,
+              max_length: subcomponent.maxLength,
+            };
+          }
+          
           if (subcomponent.type === MessageComponentTypes.SelectMenu)
             return {
               type: subcomponent.type,
@@ -115,15 +127,16 @@ export async function editMessage(bot: Bot, channelId: bigint, messageId: bigint
             custom_id: subcomponent.customId,
             label: subcomponent.label,
             style: subcomponent.style,
-            emoji: subcomponent.emoji
-              ? {
-                  id: subcomponent.emoji.id?.toString(),
-                  name: subcomponent.emoji.name,
-                  animated: subcomponent.emoji.animated,
-                }
-              : undefined,
-            url: subcomponent.url,
-            disabled: subcomponent.disabled,
+            emoji:
+              "emoji" in subcomponent && subcomponent.emoji
+                ? {
+                    id: subcomponent.emoji.id?.toString(),
+                    name: subcomponent.emoji.name,
+                    animated: subcomponent.emoji.animated,
+                  }
+                : undefined,
+            url: "url" in subcomponent ? subcomponent.url : undefined,
+            disabled: "disabled" in subcomponent ? subcomponent.disabled : undefined,
           };
         }),
       })),
diff --git a/src/helpers/messages/pinMessage.ts b/src/helpers/messages/pinMessage.ts
index cf5eff916..8421c2ebd 100644
--- a/src/helpers/messages/pinMessage.ts
+++ b/src/helpers/messages/pinMessage.ts
@@ -2,9 +2,5 @@ import type { Bot } from "../../bot.ts";
 
 /** Pin a message in a channel. Requires MANAGE_MESSAGES. Max pins allowed in a channel = 50. */
 export async function pinMessage(bot: Bot, channelId: bigint, messageId: bigint) {
-  return await bot.rest.runMethod<undefined>(
-    bot.rest,
-    "put",
-    bot.constants.endpoints.CHANNEL_PIN(channelId, messageId)
-  );
+  await bot.rest.runMethod<undefined>(bot.rest, "put", bot.constants.endpoints.CHANNEL_PIN(channelId, messageId));
 }
diff --git a/src/helpers/messages/removeAllReactions.ts b/src/helpers/messages/removeAllReactions.ts
index d4f18e13a..3a58c4729 100644
--- a/src/helpers/messages/removeAllReactions.ts
+++ b/src/helpers/messages/removeAllReactions.ts
@@ -2,7 +2,7 @@ import type { Bot } from "../../bot.ts";
 
 /** Removes all reactions for all emojis on this message. */
 export async function removeAllReactions(bot: Bot, channelId: bigint, messageId: bigint) {
-  return await bot.rest.runMethod<undefined>(
+  await bot.rest.runMethod<undefined>(
     bot.rest,
     "delete",
     bot.constants.endpoints.CHANNEL_MESSAGE_REACTIONS(channelId, messageId)
diff --git a/src/helpers/messages/removeReaction.ts b/src/helpers/messages/removeReaction.ts
index e15274565..4dbe2b362 100644
--- a/src/helpers/messages/removeReaction.ts
+++ b/src/helpers/messages/removeReaction.ts
@@ -14,7 +14,7 @@ export async function removeReaction(
     reaction = reaction.substring(3, reaction.length - 1);
   }
 
-  return await bot.rest.runMethod<undefined>(
+  await bot.rest.runMethod<undefined>(
     bot.rest,
     "delete",
     options?.userId
diff --git a/src/helpers/messages/removeReactionEmoji.ts b/src/helpers/messages/removeReactionEmoji.ts
index 252b02d80..590876429 100644
--- a/src/helpers/messages/removeReactionEmoji.ts
+++ b/src/helpers/messages/removeReactionEmoji.ts
@@ -8,7 +8,7 @@ export async function removeReactionEmoji(bot: Bot, channelId: bigint, messageId
     reaction = reaction.substring(3, reaction.length - 1);
   }
 
-  return await bot.rest.runMethod<undefined>(
+  await bot.rest.runMethod<undefined>(
     bot.rest,
     "delete",
     bot.constants.endpoints.CHANNEL_MESSAGE_REACTION(channelId, messageId, reaction)
diff --git a/src/helpers/messages/sendMessage.ts b/src/helpers/messages/sendMessage.ts
index 26b2e7eba..fbc498223 100644
--- a/src/helpers/messages/sendMessage.ts
+++ b/src/helpers/messages/sendMessage.ts
@@ -103,6 +103,18 @@ export async function sendMessage(bot: Bot, channelId: bigint, content: string |
       components: content.components?.map((component) => ({
         type: component.type,
         components: component.components.map((subcomponent) => {
+          if (subcomponent.type === MessageComponentTypes.InputText) {
+            return {
+              type: subcomponent.type,
+              style: subcomponent.style,
+              custom_id: subcomponent.customId,
+              label: subcomponent.label,
+              placeholder: subcomponent.placeholder,
+              min_length: subcomponent.minLength ?? subcomponent.required === false ? 0 : subcomponent.minLength,
+              max_length: subcomponent.maxLength,
+            };
+          }
+          
           if (subcomponent.type === MessageComponentTypes.SelectMenu)
             return {
               type: subcomponent.type,
@@ -130,15 +142,16 @@ export async function sendMessage(bot: Bot, channelId: bigint, content: string |
             custom_id: subcomponent.customId,
             label: subcomponent.label,
             style: subcomponent.style,
-            emoji: subcomponent.emoji
-              ? {
-                  id: subcomponent.emoji.id?.toString(),
-                  name: subcomponent.emoji.name,
-                  animated: subcomponent.emoji.animated,
-                }
-              : undefined,
-            url: subcomponent.url,
-            disabled: subcomponent.disabled,
+            emoji:
+              "emoji" in subcomponent && subcomponent.emoji
+                ? {
+                    id: subcomponent.emoji.id?.toString(),
+                    name: subcomponent.emoji.name,
+                    animated: subcomponent.emoji.animated,
+                  }
+                : undefined,
+            url: "url" in subcomponent ? subcomponent.url : undefined,
+            disabled: "disabled" in subcomponent ? subcomponent.disabled : undefined,
           };
         }),
       })),
diff --git a/src/helpers/messages/unpinMessage.ts b/src/helpers/messages/unpinMessage.ts
index 6962f6d70..8e9f628c7 100644
--- a/src/helpers/messages/unpinMessage.ts
+++ b/src/helpers/messages/unpinMessage.ts
@@ -1,10 +1,6 @@
 /** Unpin a message in a channel. Requires MANAGE_MESSAGES. */
 import type { Bot } from "../../bot.ts";
 
-export async function unpinMessage(bot: Bot, channelId: bigint, messageId: bigint): Promise<undefined> {
-  return await bot.rest.runMethod<undefined>(
-    bot.rest,
-    "delete",
-    bot.constants.endpoints.CHANNEL_PIN(channelId, messageId)
-  );
+export async function unpinMessage(bot: Bot, channelId: bigint, messageId: bigint) {
+  await bot.rest.runMethod<undefined>(bot.rest, "delete", bot.constants.endpoints.CHANNEL_PIN(channelId, messageId));
 }
diff --git a/src/helpers/misc/editBotProfile.ts b/src/helpers/misc/editBotProfile.ts
index 8e26d42a7..eb55b1a2e 100644
--- a/src/helpers/misc/editBotProfile.ts
+++ b/src/helpers/misc/editBotProfile.ts
@@ -26,8 +26,10 @@ export async function editBotProfile(bot: Bot, options: { username?: string; bot
 
   const avatar = options?.botAvatarURL ? await bot.utils.urlToBase64(options?.botAvatarURL) : options?.botAvatarURL;
 
-  return await bot.rest.runMethod<User>(bot.rest, "patch", bot.constants.endpoints.USER_BOT, {
+  const result = await bot.rest.runMethod<User>(bot.rest, "patch", bot.constants.endpoints.USER_BOT, {
     username: options.username?.trim(),
     avatar,
   });
+
+  return bot.transformers.user(bot, result);
 }
diff --git a/src/helpers/misc/editBotStatus.ts b/src/helpers/misc/editBotStatus.ts
index c45edfc38..b2c38fb12 100644
--- a/src/helpers/misc/editBotStatus.ts
+++ b/src/helpers/misc/editBotStatus.ts
@@ -7,11 +7,50 @@ export function editBotStatus(bot: Bot, data: Omit<StatusUpdate, "afk" | "since"
     bot.events.debug(`Running forEach loop in editBotStatus function.`);
 
     bot.gateway.sendShardMessage(bot.gateway, shard, {
-      op: GatewayOpcodes.StatusUpdate,
+      op: GatewayOpcodes.PresenceUpdate,
       d: {
         since: null,
         afk: false,
-        activities: data.activities,
+        activities: data.activities.map((activity) => ({
+          name: activity.name,
+          type: activity.type,
+          url: activity.url,
+          created_at: activity.createdAt,
+          timestamps: activity.timestamps
+            ? {
+                start: activity.timestamps.start,
+                end: activity.timestamps.end,
+              }
+            : undefined,
+          applicationId: activity.applicationId?.toString(),
+          details: activity.details,
+          state: activity.state,
+          emoji: activity.emoji
+            ? {
+                name: activity.emoji.name,
+                id: activity.emoji.id?.toString(),
+                animated: activity.emoji.animated,
+              }
+            : undefined,
+          party: activity.party
+            ? {
+                id: activity.party.id?.toString(),
+                size: activity.party.size,
+              }
+            : undefined,
+          assets: activity.assets
+            ? {
+                large_image: activity.assets.largeImage,
+                large_text: activity.assets.largeText,
+                small_image: activity.assets.smallImage,
+                small_text: activity.assets.smallText,
+              }
+            : undefined,
+          secrets: activity.secrets,
+          instance: activity.instance,
+          flags: activity.flags,
+          buttons: activity.buttons,
+        })),
         status: data.status,
       },
     });
diff --git a/src/helpers/misc/getUser.ts b/src/helpers/misc/getUser.ts
index 8b6a170c6..c56638fc0 100644
--- a/src/helpers/misc/getUser.ts
+++ b/src/helpers/misc/getUser.ts
@@ -4,5 +4,7 @@ import { SnakeCasedPropertiesDeep } from "../../types/util.ts";
 
 /** This function will return the raw user payload in the rare cases you need to fetch a user directly from the API. */
 export async function getUser(bot: Bot, userId: bigint) {
-  return await bot.rest.runMethod<User>(bot.rest, "get", bot.constants.endpoints.USER(userId));
+  const result = await bot.rest.runMethod<User>(bot.rest, "get", bot.constants.endpoints.USER(userId));
+
+  return bot.transformers.user(bot, result);
 }
diff --git a/src/helpers/mod.ts b/src/helpers/mod.ts
index 523aa4b60..25d374eef 100644
--- a/src/helpers/mod.ts
+++ b/src/helpers/mod.ts
@@ -1,5 +1,4 @@
 //channels
-export * from "./channels/channelOverwriteHasPermission.ts";
 export * from "./channels/createChannel.ts";
 export * from "./channels/deleteChannel.ts";
 export * from "./channels/deleteChannelOverwrite.ts";
@@ -12,11 +11,12 @@ export * from "./channels/getChannelWebhooks.ts";
 export * from "./channels/getPins.ts";
 export * from "./channels/startTyping.ts";
 export * from "./channels/swapChannels.ts";
-export * from "./channels/updateBotVoiceState.ts";
+export * from "./channels/updateVoiceState.ts";
 
 //discovery
 export * from "./discovery/addDiscoverySubcategory.ts";
 export * from "./discovery/editDiscovery.ts";
+export * from "./discovery/getDiscovery.ts";
 export * from "./discovery/getDiscoveryCategories.ts";
 export * from "./discovery/removeDiscoverySubcategory.ts";
 export * from "./discovery/validDiscoveryTerm.ts";
@@ -70,6 +70,9 @@ export * from "./interactions/commands/getApplicationCommandPermission.ts";
 export * from "./interactions/commands/getApplicationCommandPermissions.ts";
 export * from "./interactions/commands/upsertApplicationCommand.ts";
 export * from "./interactions/commands/upsertApplicationCommands.ts";
+export * from "./interactions/followups/deleteFollowupMessage.ts";
+export * from "./interactions/followups/editFollowupMessage.ts";
+export * from "./interactions/followups/getFollowupMessage.ts";
 export * from "./interactions/getOriginalInteractionResponse.ts";
 export * from "./interactions/sendInteractionResponse.ts";
 
@@ -83,14 +86,12 @@ export * from "./invites/getInvites.ts";
 //members
 export * from "./members/avatarUrl.ts";
 export * from "./members/banMember.ts";
-export * from "./members/disconnectMember.ts";
 export * from "./members/editBotNickname.ts";
 export * from "./members/editMember.ts";
 export * from "./members/fetchMembers.ts";
 export * from "./members/getMember.ts";
 export * from "./members/getMembers.ts";
 export * from "./members/kickMember.ts";
-export * from "./members/moveMember.ts";
 export * from "./members/pruneMembers.ts";
 export * from "./members/getDmChannel.ts";
 export * from "./members/unbanMember.ts";
@@ -159,8 +160,6 @@ export * from "./channels/getStageInstance.ts";
 export * from "./channels/deleteStageInstance.ts";
 export * from "./voice/connectToVoiceChannel.ts";
 export * from "./channels/threads/addToThread.ts";
-export * from "./channels/threads/deleteThread.ts";
-export * from "./channels/threads/editThread.ts";
 export * from "./channels/threads/getActiveThreads.ts";
 export * from "./channels/threads/getArchivedThreads.ts";
 export * from "./channels/threads/getThreadMember.ts";
@@ -170,7 +169,6 @@ export * from "./channels/threads/leaveThread.ts";
 export * from "./channels/threads/removeThreadMember.ts";
 export * from "./channels/threads/startThreadWithMessage.ts";
 export * from "./channels/threads/startThreadWithoutMessage.ts";
-export * from "./channels/cloneChannel.ts";
 
 //guilds
 export * from "./guilds/scheduledEvents/createScheduledEvent.ts";
diff --git a/src/helpers/roles/addRole.ts b/src/helpers/roles/addRole.ts
index 2e1a618f2..e668c2b66 100644
--- a/src/helpers/roles/addRole.ts
+++ b/src/helpers/roles/addRole.ts
@@ -2,7 +2,7 @@ import type { Bot } from "../../bot.ts";
 
 /** Add a role to the member */
 export async function addRole(bot: Bot, guildId: bigint, memberId: bigint, roleId: bigint, reason?: string) {
-  return await bot.rest.runMethod<undefined>(
+  await bot.rest.runMethod<undefined>(
     bot.rest,
     "put",
     bot.constants.endpoints.GUILD_MEMBER_ROLE(guildId, memberId, roleId),
diff --git a/src/helpers/roles/deleteRole.ts b/src/helpers/roles/deleteRole.ts
index af217256a..7cb8cb24b 100644
--- a/src/helpers/roles/deleteRole.ts
+++ b/src/helpers/roles/deleteRole.ts
@@ -2,5 +2,5 @@ import type { Bot } from "../../bot.ts";
 
 /** Delete a guild role. Requires the MANAGE_ROLES permission. */
 export async function deleteRole(bot: Bot, guildId: bigint, id: bigint) {
-  return await bot.rest.runMethod<undefined>(bot.rest, "delete", bot.constants.endpoints.GUILD_ROLE(guildId, id));
+  await bot.rest.runMethod<undefined>(bot.rest, "delete", bot.constants.endpoints.GUILD_ROLE(guildId, id));
 }
diff --git a/src/helpers/roles/removeRole.ts b/src/helpers/roles/removeRole.ts
index b45a7a788..f724691ae 100644
--- a/src/helpers/roles/removeRole.ts
+++ b/src/helpers/roles/removeRole.ts
@@ -2,7 +2,7 @@ import type { Bot } from "../../bot.ts";
 
 /** Remove a role from the member */
 export async function removeRole(bot: Bot, guildId: bigint, memberId: bigint, roleId: bigint, reason?: string) {
-  return await bot.rest.runMethod<undefined>(
+  await bot.rest.runMethod<undefined>(
     bot.rest,
     "delete",
     bot.constants.endpoints.GUILD_MEMBER_ROLE(guildId, memberId, roleId),
diff --git a/src/helpers/templates/deleteGuildTemplate.ts b/src/helpers/templates/deleteGuildTemplate.ts
index 720b34c27..ac297ecee 100644
--- a/src/helpers/templates/deleteGuildTemplate.ts
+++ b/src/helpers/templates/deleteGuildTemplate.ts
@@ -6,7 +6,7 @@ import type { Bot } from "../../bot.ts";
  * Requires the `MANAGE_GUILD` permission.
  */
 export async function deleteGuildTemplate(bot: Bot, guildId: bigint, templateCode: string) {
-  return await bot.rest.runMethod<Template>(
+  await bot.rest.runMethod<Template>(
     bot.rest,
     "delete",
     `${bot.constants.endpoints.GUILD_TEMPLATES(guildId)}/${templateCode}`
diff --git a/src/helpers/webhooks/deleteWebhook.ts b/src/helpers/webhooks/deleteWebhook.ts
index 15b8e1e62..d4b8d4470 100644
--- a/src/helpers/webhooks/deleteWebhook.ts
+++ b/src/helpers/webhooks/deleteWebhook.ts
@@ -2,5 +2,5 @@ import type { Bot } from "../../bot.ts";
 
 /** Delete a webhook permanently. Requires the `MANAGE_WEBHOOKS` permission. Returns a undefined on success */
 export async function deleteWebhook(bot: Bot, channelId: bigint, webhookId: bigint) {
-  return await bot.rest.runMethod<undefined>(bot.rest, "delete", bot.constants.endpoints.WEBHOOK_ID(webhookId));
+  await bot.rest.runMethod<undefined>(bot.rest, "delete", bot.constants.endpoints.WEBHOOK_ID(webhookId));
 }
diff --git a/src/helpers/webhooks/deleteWebhookMessage.ts b/src/helpers/webhooks/deleteWebhookMessage.ts
index 608d780b8..6303811ca 100644
--- a/src/helpers/webhooks/deleteWebhookMessage.ts
+++ b/src/helpers/webhooks/deleteWebhookMessage.ts
@@ -1,7 +1,7 @@
 import type { Bot } from "../../bot.ts";
 
 export async function deleteWebhookMessage(bot: Bot, webhookId: bigint, webhookToken: string, messageId: bigint) {
-  return await bot.rest.runMethod<undefined>(
+  await bot.rest.runMethod<undefined>(
     bot.rest,
     "delete",
     bot.constants.endpoints.WEBHOOK_MESSAGE(webhookId, webhookToken, messageId)
diff --git a/src/helpers/webhooks/deleteWebhookWithToken.ts b/src/helpers/webhooks/deleteWebhookWithToken.ts
index 2a98aecd6..0591a212c 100644
--- a/src/helpers/webhooks/deleteWebhookWithToken.ts
+++ b/src/helpers/webhooks/deleteWebhookWithToken.ts
@@ -2,9 +2,5 @@ import type { Bot } from "../../bot.ts";
 
 /** Delete a webhook permanently. Returns a undefined on success */
 export async function deleteWebhookWithToken(bot: Bot, webhookId: bigint, webhookToken: string) {
-  return await bot.rest.runMethod<undefined>(
-    bot.rest,
-    "delete",
-    bot.constants.endpoints.WEBHOOK(webhookId, webhookToken)
-  );
+  await bot.rest.runMethod<undefined>(bot.rest, "delete", bot.constants.endpoints.WEBHOOK(webhookId, webhookToken));
 }
diff --git a/src/helpers/webhooks/editWebhookMessage.ts b/src/helpers/webhooks/editWebhookMessage.ts
index 2cc59cae7..4cc4ddb48 100644
--- a/src/helpers/webhooks/editWebhookMessage.ts
+++ b/src/helpers/webhooks/editWebhookMessage.ts
@@ -3,6 +3,8 @@ import type { EditWebhookMessage } from "../../types/webhooks/editWebhookMessage
 import type { Bot } from "../../bot.ts";
 import { AllowedMentionsTypes } from "../../types/messages/allowedMentionsTypes.ts";
 import { MessageComponentTypes } from "../../types/messages/components/messageComponentTypes.ts";
+import { hasProperty } from "../../util/utils.ts";
+import { ButtonComponent } from "../../types/messages/components/buttonComponent.ts";
 
 export async function editWebhookMessage(
   bot: Bot,
@@ -62,6 +64,18 @@ export async function editWebhookMessage(
       components: options.components?.map((component) => ({
         type: component.type,
         components: component.components.map((subcomponent) => {
+          if (subcomponent.type === MessageComponentTypes.InputText) {
+            return {
+              type: subcomponent.type,
+              style: subcomponent.style,
+              custom_id: subcomponent.customId,
+              label: subcomponent.label,
+              placeholder: subcomponent.placeholder,
+              min_length: subcomponent.minLength ?? subcomponent.required === false ? 0 : subcomponent.minLength,
+              max_length: subcomponent.maxLength,
+            };
+          }
+          
           if (subcomponent.type === MessageComponentTypes.SelectMenu)
             return {
               type: subcomponent.type,
@@ -89,15 +103,16 @@ export async function editWebhookMessage(
             custom_id: subcomponent.customId,
             label: subcomponent.label,
             style: subcomponent.style,
-            emoji: subcomponent.emoji
-              ? {
-                  id: subcomponent.emoji.id?.toString(),
-                  name: subcomponent.emoji.name,
-                  animated: subcomponent.emoji.animated,
-                }
-              : undefined,
-            url: subcomponent.url,
-            disabled: subcomponent.disabled,
+            emoji:
+              "emoji" in subcomponent && subcomponent.emoji
+                ? {
+                    id: subcomponent.emoji.id?.toString(),
+                    name: subcomponent.emoji.name,
+                    animated: subcomponent.emoji.animated,
+                  }
+                : undefined,
+            url: "url" in subcomponent ? subcomponent.url : undefined,
+            disabled: "disabled" in subcomponent ? subcomponent.disabled : undefined,
           };
         }),
       })),
diff --git a/src/transformers/applicationCommand.ts b/src/transformers/applicationCommand.ts
new file mode 100644
index 000000000..143b53811
--- /dev/null
+++ b/src/transformers/applicationCommand.ts
@@ -0,0 +1,44 @@
+import { Bot } from "../bot.ts";
+import { ApplicationCommand } from "../types/interactions/commands/applicationCommand.ts";
+import { ApplicationCommandTypes } from "../types/interactions/commands/applicationCommandTypes.ts";
+import { SnakeCasedPropertiesDeep } from "../types/util.ts";
+import { DiscordenoApplicationCommandOption } from "./applicationCommandOption.ts";
+
+export function transformApplicationCommand(
+  bot: Bot,
+  payload: SnakeCasedPropertiesDeep<ApplicationCommand>
+): DiscordenoApplicationCommand {
+  return {
+    id: bot.transformers.snowflake(payload.id),
+    applicationId: bot.transformers.snowflake(payload.application_id),
+    guildId: payload.guild_id ? bot.transformers.snowflake(payload.guild_id) : undefined,
+    name: payload.name,
+    description: payload.description,
+    defaultPermission: payload.default_permission ?? false,
+    type: payload.type,
+    version: payload.version,
+
+    options: payload.options?.map((option) => bot.transformers.applicationCommandOption(bot, option)),
+  };
+}
+
+export interface DiscordenoApplicationCommand {
+  /** Unique id of the command */
+  id: bigint;
+  /** Unique id of the parent application */
+  applicationId: bigint;
+  /** Guild id of the command, if not global */
+  guildId?: bigint;
+  /** 1-32 character name matching */
+  name: string;
+  /** 1-100 character description */
+  description?: string;
+  /** The parameters for the command */
+  options?: DiscordenoApplicationCommandOption[];
+  /** Whether the command is enbaled by default when the app is added to a guild */
+  defaultPermission?: boolean;
+  /** The type of command. By default this is a application command(ChatInput). */
+  type?: ApplicationCommandTypes;
+  /** Autoincrementing version identifier updated during substantial record changes */
+  version: string;
+}
diff --git a/src/transformers/applicationCommandOption.ts b/src/transformers/applicationCommandOption.ts
new file mode 100644
index 000000000..f32072afd
--- /dev/null
+++ b/src/transformers/applicationCommandOption.ts
@@ -0,0 +1,48 @@
+import { Bot } from "../bot.ts";
+import { ChannelTypes } from "../types/channels/channelTypes.ts";
+import { ApplicationCommandOption } from "../types/interactions/commands/applicationCommandOption.ts";
+import { ApplicationCommandOptionChoice } from "../types/interactions/commands/applicationCommandOptionChoice.ts";
+import { ApplicationCommandOptionTypes } from "../types/interactions/commands/applicationCommandOptionTypes.ts";
+import { SnakeCasedPropertiesDeep } from "../types/util.ts";
+
+export function transformApplicationCommandOption(
+  bot: Bot,
+  payload: SnakeCasedPropertiesDeep<ApplicationCommandOption>
+): DiscordenoApplicationCommandOption {
+  return {
+    type: payload.type,
+    name: payload.name,
+    description: payload.description,
+    required: payload.required ?? false,
+    choices: payload.choices,
+    autocomplete: payload.autocomplete,
+    channelTypes: payload.channel_types,
+    minValue: payload.min_value,
+    maxValue: payload.max_value,
+
+    options: payload.options?.map((option) => bot.transformers.applicationCommandOption(bot, option)),
+  };
+}
+
+export interface DiscordenoApplicationCommandOption {
+  /** Value of Application Command Option Type */
+  type: ApplicationCommandOptionTypes;
+  /** 1-32 character name matching lowercase `^[\w-]{1,32}$` */
+  name: string;
+  /** 1-100 character description */
+  description: string;
+  /** If the parameter is required or optional--default `false` */
+  required?: boolean;
+  /** Choices for `string` and `int` types for the user to pick from */
+  choices?: ApplicationCommandOptionChoice[];
+  /** If the option is a subcommand or subcommand group type, this nested options will be the parameters */
+  options?: ApplicationCommandOption[];
+  /** Whether this option should make autocomplete interactions. */
+  autocomplete?: boolean;
+  /** If the option is a channel type, the channels shown will be restricted to these types */
+  channelTypes?: ChannelTypes[];
+  /** Minimum number desired. */
+  minValue?: number;
+  /** Maximum number desired. */
+  maxValue?: number;
+}
diff --git a/src/transformers/channel.ts b/src/transformers/channel.ts
index a74edcb88..e91c31a1c 100644
--- a/src/transformers/channel.ts
+++ b/src/transformers/channel.ts
@@ -125,7 +125,7 @@ export interface DiscordenoChannel {
   defaultAutoArchiveDuration?: number;
   /** Whether or not the bot is part of this channel thread. */
   botIsMember: boolean;
-  /** computed permissions for the invoking user in the channel, including overwrites, only included when part of the resolved data received on a slash command interaction */
+  /** computed permissions for the invoking user in the channel, including overwrites, only included when part of the resolved data received on a application command interaction */
   permissions?: bigint;
 
   permissionOverwrites: bigint[];
@@ -135,7 +135,7 @@ export interface DiscordenoChannel {
   guildId: bigint;
   /** The id of the last message sent in this channel (may not point to an existing or valid message) */
   lastMessageId?: bigint;
-  /** id of the DM creator */
+  /** id of the DM creator or thread */
   ownerId?: bigint;
   /** Application id of the group DM creator if it is bot-created */
   applicationId?: bigint;
diff --git a/src/transformers/component.ts b/src/transformers/component.ts
index 449078db7..7f0ca4b2a 100644
--- a/src/transformers/component.ts
+++ b/src/transformers/component.ts
@@ -3,6 +3,7 @@ import { ButtonStyles } from "../types/messages/components/buttonStyles.ts";
 import { MessageComponentTypes } from "../types/messages/components/messageComponentTypes.ts";
 import { SnakeCasedPropertiesDeep } from "../types/util.ts";
 import { SelectOption } from "../types/messages/components/selectOption.ts";
+import { TextStyles } from "../types/messages/components/textStyles.ts";
 
 export function transformComponent(bot: Bot, payload: SnakeCasedPropertiesDeep<Component>): DiscordenoComponent {
   return {
@@ -47,7 +48,7 @@ export interface Component {
   /** whether the component is disabled, default false */
   disabled?: boolean;
   /** For different styles/colors of the buttons */
-  style?: ButtonStyles;
+  style?: ButtonStyles | TextStyles;
   /** text that appears on the button (max 80 characters) */
   label?: string;
   /** Emoji object that includes fields of name, id, and animated supporting unicode and custom emojis. */
@@ -80,8 +81,8 @@ export interface DiscordenoComponent {
   customId?: string;
   /** whether the component is disabled, default false */
   disabled?: boolean;
-  /** For different styles/colors of the buttons */
-  style?: ButtonStyles;
+  /** For different styles/colors of the buttons or TextInput */
+  style?: ButtonStyles | TextStyles;
   /** text that appears on the button (max 80 characters) */
   label?: string;
   /** Emoji object that includes fields of name, id, and animated supporting unicode and custom emojis. */
diff --git a/src/transformers/guild.ts b/src/transformers/guild.ts
index 5cf9c208e..a2dbe29e7 100644
--- a/src/transformers/guild.ts
+++ b/src/transformers/guild.ts
@@ -5,6 +5,7 @@ import { Collection } from "../util/collection.ts";
 import { DiscordenoRole } from "./role.ts";
 import { DiscordenoVoiceState } from "./voiceState.ts";
 import { SnakeCasedPropertiesDeep } from "../types/util.ts";
+import { DiscordenoEmoji } from "./emoji.ts";
 
 export function transformGuild(
   bot: Bot,
@@ -77,7 +78,12 @@ export function transformGuild(
         return [result.id, result];
       })
     ),
-    emojis: new Collection((payload.guild.emojis || []).map((emoji) => [bot.transformers.snowflake(emoji.id!), emoji])),
+    emojis: new Collection(
+      (payload.guild.emojis || []).map((emoji) => {
+        const em = bot.transformers.emoji(bot, emoji);
+        return [em.id!, em];
+      })
+    ),
     voiceStates: new Collection(
       (payload.guild.voice_states || [])
         .map((vs) => bot.transformers.voiceState(bot, { voiceState: vs, guildId }))
@@ -102,6 +108,7 @@ export function transformGuild(
     publicUpdatesChannelId: payload.guild.public_updates_channel_id
       ? bot.transformers.snowflake(payload.guild.public_updates_channel_id)
       : undefined,
+    premiumProgressBarEnabled: payload.guild.premium_progress_bar_enabled,
   };
 }
 
@@ -162,7 +169,7 @@ export interface DiscordenoGuild
   /** The Voice State data for each user in a voice channel in this server. */
   voiceStates: Collection<bigint, DiscordenoVoiceState>;
   /** Custom guild emojis */
-  emojis: Collection<bigint, Emoji>;
+  emojis: Collection<bigint, DiscordenoEmoji>;
   /** Holds all the boolean toggles. */
   bitfield: bigint;
   /** When this guild was joined at */
diff --git a/src/transformers/interaction.ts b/src/transformers/interaction.ts
index 3ca707f9d..402fbdee0 100644
--- a/src/transformers/interaction.ts
+++ b/src/transformers/interaction.ts
@@ -9,6 +9,7 @@ import {
   InteractionDataResolved,
   MessageComponentTypes,
   InteractionDataOption,
+  MessageComponents,
 } from "../types/mod.ts";
 import { SnakeCasedPropertiesDeep } from "../types/util.ts";
 import { Collection } from "../util/collection.ts";
@@ -41,6 +42,7 @@ export function transformInteraction(bot: Bot, payload: SnakeCasedPropertiesDeep
       ? {
           componentType: payload.data.component_type,
           customId: payload.data.custom_id,
+          components: payload.data.components,
           values: payload.data.values,
           id: payload.data.id ? bot.transformers.snowflake(payload.data.id) : undefined,
           name: payload.data.name,
@@ -152,6 +154,8 @@ export interface DiscordenoInteraction {
     componentType?: MessageComponentTypes;
     /** The custom id provided for this component. */
     customId?: string;
+    /** The components if its a Modal Submit interaction. */
+    components?: MessageComponents;
     /** The values chosen by the user. */
     values?: string[];
     /** The Id of the invoked command */
diff --git a/src/transformers/mod.ts b/src/transformers/mod.ts
index fb2e55756..9ea7fecb0 100644
--- a/src/transformers/mod.ts
+++ b/src/transformers/mod.ts
@@ -1,5 +1,7 @@
 export * from "./activity.ts";
 export * from "./application.ts";
+export * from "./applicationCommand.ts";
+export * from "./applicationCommandOption.ts";
 export * from "./applicationCommandPermission.ts";
 export * from "./attachment.ts";
 export * from "./auditlogEntry.ts";
@@ -15,6 +17,8 @@ export * from "./member.ts";
 export * from "./message.ts";
 export * from "./presence.ts";
 export * from "./role.ts";
+export * from "./scheduledEvent.ts";
 export * from "./team.ts";
+export * from "./threadMember.ts";
 export * from "./voiceState.ts";
 export * from "./webhook.ts";
diff --git a/src/transformers/voiceRegion.ts b/src/transformers/voiceRegion.ts
new file mode 100644
index 000000000..7424d95d7
--- /dev/null
+++ b/src/transformers/voiceRegion.ts
@@ -0,0 +1,26 @@
+import { Bot } from "../bot.ts";
+import { SnakeCasedPropertiesDeep } from "../types/util.ts";
+import { VoiceRegion } from "../types/voice/voiceRegion.ts";
+
+export function transformVoiceRegion(bot: Bot, payload: SnakeCasedPropertiesDeep<VoiceRegion>): DiscordenoVoiceRegion {
+  return {
+    id: bot.transformers.snowflake(payload.id),
+    name: payload.name,
+    optimal: payload.optimal,
+    deprecated: payload.deprecated,
+    custom: payload.custom,
+  };
+}
+
+export interface DiscordenoVoiceRegion {
+  /** Unique Id for the region */
+  id: bigint;
+  /** Name of the region */
+  name: string;
+  /** true for a single server that is closest to the current user's client */
+  optimal: boolean;
+  /** Whether this is a deprecated voice region (avoid swithing to these) */
+  deprecated: boolean;
+  /** Whether this is a custom voice region (used for events/etc) */
+  custom: boolean;
+}
diff --git a/src/transformers/welcomeScreen.ts b/src/transformers/welcomeScreen.ts
new file mode 100644
index 000000000..5046d1b82
--- /dev/null
+++ b/src/transformers/welcomeScreen.ts
@@ -0,0 +1,34 @@
+import { Bot } from "../bot.ts";
+import { SnakeCasedPropertiesDeep } from "../types/util.ts";
+import { WelcomeScreen } from "../types/guilds/welcomeScreen.ts";
+
+export function transformWelcomeScreen(
+  bot: Bot,
+  payload: SnakeCasedPropertiesDeep<WelcomeScreen>
+): DiscordenoWelcomeScreen {
+  return {
+    description: payload.description ?? undefined,
+    welcomeChannels: payload.welcome_channels.map((channel) => ({
+      channelId: bot.transformers.snowflake(channel.channel_id),
+      description: channel.description,
+      emojiId: channel.emoji_id ? bot.transformers.snowflake(channel.emoji_id) : undefined,
+      emojiName: channel.emoji_name ?? undefined,
+    })),
+  };
+}
+
+export interface DiscordenoWelcomeScreen {
+  /** The server description shown in the welcome screen */
+  description?: string;
+  /** The channels shown in the welcome screen, up to 5 */
+  welcomeChannels: {
+    /** The channel's id */
+    channelId: bigint;
+    /** The descriptino schown for the channel */
+    description: string;
+    /** The emoji id, if the emoji is custom */
+    emojiId?: bigint;
+    /** The emoji name if custom, the unicode character if standard, or `null` if no emoji is set */
+    emojiName?: string;
+  }[];
+}
diff --git a/src/transformers/widget.ts b/src/transformers/widget.ts
new file mode 100644
index 000000000..d3478044d
--- /dev/null
+++ b/src/transformers/widget.ts
@@ -0,0 +1,17 @@
+import { Bot } from "../bot.ts";
+import { GuildWidget } from "../types/guilds/guildWidget.ts";
+import { SnakeCasedPropertiesDeep } from "../types/util.ts";
+
+export function transformWidget(bot: Bot, payload: SnakeCasedPropertiesDeep<GuildWidget>): DiscordenoWidget {
+  return {
+    channelId: payload.channel_id ? bot.transformers.snowflake(payload.channel_id) : undefined,
+    enabled: payload.enabled,
+  };
+}
+
+export interface DiscordenoWidget {
+  /** Whether the widget is enabled */
+  enabled: boolean;
+  /** The widget channel id */
+  channelId?: bigint;
+}
diff --git a/src/types/auditLog/auditLog.ts b/src/types/auditLog/auditLog.ts
index 5e7b5cb40..39dac4957 100644
--- a/src/types/auditLog/auditLog.ts
+++ b/src/types/auditLog/auditLog.ts
@@ -3,6 +3,7 @@ import { Integration } from "../integrations/integration.ts";
 import { User } from "../users/user.ts";
 import { Webhook } from "../webhooks/webhook.ts";
 import { AuditLogEntry } from "./auditLogEntry.ts";
+import { ScheduledEvent } from "../guilds/scheduledEvents.ts";
 
 /** https://discord.com/developers/docs/resources/audit-log#audit-log-object */
 export interface AuditLog {
@@ -16,4 +17,6 @@ export interface AuditLog {
   integrations: Partial<Integration>[];
   /** List of threads found in the audit log. */
   threads: Channel[];
+  /** List of guild scheduled events found in the audit log */
+  scheduledEvents: ScheduledEvent[];
 }
diff --git a/src/types/channels/channel.ts b/src/types/channels/channel.ts
index 5289d642b..022a86b9b 100644
--- a/src/types/channels/channel.ts
+++ b/src/types/channels/channel.ts
@@ -58,6 +58,6 @@ export interface Channel {
   member?: ThreadMember;
   /** Default duration for newly created threads, in minutes, to automatically archive the thread after recent activity, can be set to: 60, 1440, 4320, 10080 */
   defaultAutoArchiveDuration?: number;
-  /** computed permissions for the invoking user in the channel, including overwrites, only included when part of the resolved data received on a slash command interaction */
+  /** computed permissions for the invoking user in the channel, including overwrites, only included when part of the resolved data received on a application command interaction */
   permissions?: string;
 }
diff --git a/src/types/channels/modifyChannel.ts b/src/types/channels/modifyChannel.ts
index 82d3f0b11..72658ae4a 100644
--- a/src/types/channels/modifyChannel.ts
+++ b/src/types/channels/modifyChannel.ts
@@ -1,6 +1,5 @@
-import { SnakeCasedPropertiesDeep } from "../util.ts";
 import { ChannelTypes } from "./channelTypes.ts";
-import { DiscordOverwrite, Overwrite } from "./overwrite.ts";
+import { Overwrite } from "./overwrite.ts";
 import { VideoQualityModes } from "./videoQualityModes.ts";
 
 export interface ModifyChannel {
@@ -23,15 +22,17 @@ export interface ModifyChannel {
   /** Channel or category-specific permissions */
   permissionOverwrites?: Overwrite[] | null;
   /** Id of the new parent category for a channel */
-  parentId?: string | null;
+  parentId?: bigint | null;
   /** Voice region id for the voice channel, automatic when set to null */
   rtcRegion?: string | null;
   /** The camera video quality mode of the voice channel */
   videoQualityMode?: VideoQualityModes;
-}
-
-/** https://discord.com/developers/docs/resources/channel#modify-channel */
-export interface DiscordModifyChannel extends SnakeCasedPropertiesDeep<Omit<ModifyChannel, "permissionOverwrites">> {
-  // deno-lint-ignore camelcase
-  permission_overwrites?: DiscordOverwrite[];
+  /** Whether the thread is archived */
+  archived?: boolean;
+  /** Duration in minutes to automatically archive the thread after recent activity */
+  autoArchiveDuration?: 60 | 1440 | 4320 | 10080;
+  /** When a thread is locked, only users with `MANAGE_THREADS` can unarchive it */
+  locked?: boolean;
+  /** whether non-moderators can add other non-moderators to a thread; only available on private threads */
+  invitable?: boolean;
 }
diff --git a/src/types/codes/gatewayCloseEventCodes.ts b/src/types/codes/gatewayCloseEventCodes.ts
index 94f4dfebf..65292cf0f 100644
--- a/src/types/codes/gatewayCloseEventCodes.ts
+++ b/src/types/codes/gatewayCloseEventCodes.ts
@@ -1,17 +1,31 @@
 /** https://discord.com/developers/docs/topics/opcodes-and-status-codes#opcodes-and-status-codes */
 export enum GatewayCloseEventCodes {
+  /** We're not sure what went wrong. Try reconnecting? */
   UnknownError = 4000,
+  /** You sent an invalid [Gateway opcode](https://discord.com/developers/docs/topics/opcodes-and-status-codes#gateway-gateway-opcodes) or an invalid payload for an opcode. Don't do that! */
   UnknownOpcode,
+  /** You sent an invalid [payload](https://discord.com/developers/docs/topics/gateway#sending-payloads) to us. Don't do that! */
   DecodeError,
+  /** You sent us a payload prior to [identifying](https://discord.com/developers/docs/topics/gateway#identify). */
   NotAuthenticated,
+  /** The account token sent with your [identify payload](https://discord.com/developers/docs/topics/gateway#identify) is incorrect. */
   AuthenticationFailed,
+  /** You sent more than one identify payload. Don't do that! */
   AlreadyAuthenticated,
+  /** The sequence sent when [resuming](https://discord.com/developers/docs/topics/gateway#resume) the session was invalid. Reconnect and start a new session. */
   InvalidSeq = 4007,
+  /** Woah nelly! You're sending payloads to us too quickly. Slow it down! You will be disconnected on receiving this. */
   RateLimited,
+  /** Your session timed out. Reconnect and start a new one. */
   SessionTimedOut,
+  /** You sent us an invalid [shard when identifying](https://discord.com/developers/docs/topics/gateway#sharding). */
   InvalidShard,
+  /** The session would have handled too many guilds - you are required to [shard](https://discord.com/developers/docs/topics/gateway#sharding) your connection in order to connect. */
   ShardingRequired,
+  /** You sent an invalid version for the gateway. */
   InvalidApiVersion,
+  /** You sent an invalid intent for a [Gateway Intent](https://discord.com/developers/docs/topics/gateway#gateway-intents). You may have incorrectly calculated the bitwise value. */
   InvalidIntents,
+  /** You sent a disallowed intent for a [Gateway Intent](https://discord.com/developers/docs/topics/gateway#gateway-intents). You may have tried to specify an intent that you [have not enabled or are not approved for](https://discord.com/developers/docs/topics/gateway#privileged-intents). */
   DisallowedIntents,
 }
diff --git a/src/types/codes/gatewayOpcodes.ts b/src/types/codes/gatewayOpcodes.ts
index 6768a050e..ca575019e 100644
--- a/src/types/codes/gatewayOpcodes.ts
+++ b/src/types/codes/gatewayOpcodes.ts
@@ -1,14 +1,26 @@
 /** https://discord.com/developers/docs/topics/opcodes-and-status-codes#gateway-gateway-opcodes */
 export enum GatewayOpcodes {
+  /** An event was dispatched. */
   Dispatch,
+  /** Fired periodically by the client to keep the connection alive. */
   Heartbeat,
+  /** Starts a new session during the initial handshake. */
   Identify,
-  StatusUpdate,
+  /** Update the client's presence. */
+  PresenceUpdate,
+  /** Used to join/leave or move between voice channels. */
+
   VoiceStateUpdate,
+  /** Resume a previous session that was disconnected. */
   Resume = 6,
+  /** You should attempt to reconnect and resume immediately. */
   Reconnect,
+  /** Request information about offline guild members in a large guild. */
   RequestGuildMembers,
+  /** The session has been invalidated. You should reconnect and identify/resume accordingly. */
   InvalidSession,
+  /** Sent immediately after connecting, contains the `heartbeat_interval` to use. */
   Hello,
+  /** Sent in response to receiving a heartbeat to acknowledge that it has been received. */
   HeartbeatACK,
 }
diff --git a/src/types/codes/httpResponseCodes.ts b/src/types/codes/httpResponseCodes.ts
index cc8242a0a..b6117460b 100644
--- a/src/types/codes/httpResponseCodes.ts
+++ b/src/types/codes/httpResponseCodes.ts
@@ -1,14 +1,25 @@
 /** https://discord.com/developers/docs/topics/opcodes-and-status-codes#http */
 export enum HTTPResponseCodes {
+  /** The request completed successfully. */
   Ok = 200,
+  /** The entity was created successfully. */
   Created,
+  /** The request completed successfully but returned no content. */
   NoContent = 204,
+  /** The entity was not modified (no action was taken). */
   NotModified = 304,
+  /** The request was improperly formatted, or the server couldn't understand it. */
   BadRequest = 400,
+  /** The `Authorization` header was missing or invalid. */
   Unauthorized,
+  /** The `Authorization` token you passed did not have permission to the resource. */
   Forbidden = 403,
+  /** The resource at the location specified doesn't exist. */
   NotFound,
+  /** The HTTP method used is not valid for the location specified. */
   MethodNotAllowed,
+  /** You are being rate limited, see [Rate Limits](https://discord.com/developers/docs/topics/rate-limits). */
   TooManyRequests = 429,
+  /** There was not a gateway available to process your request. Wait a bit and retry. */
   GatewayUnavailable = 502,
 }
diff --git a/src/types/codes/jsonErrorCodes.ts b/src/types/codes/jsonErrorCodes.ts
index a797642a5..1243fe4c0 100644
--- a/src/types/codes/jsonErrorCodes.ts
+++ b/src/types/codes/jsonErrorCodes.ts
@@ -1,5 +1,6 @@
 /** https://discord.com/developers/docs/topics/opcodes-and-status-codes#json */
 export enum JsonErrorCodes {
+  /** General error (such as a malformed request body, amongst other things) */
   GeneralError,
   UnknownAccount = 10001,
   UnknownApplication,
@@ -49,6 +50,7 @@ export enum JsonErrorCodes {
   OnlyTheOwnerOfThisAccountCanPerformThisAction = 20018,
   ThisMessageCannotBeEditedDueToAnnouncementRateLimits = 20022,
   TheChannelYouAreWritingHasHitTheWriteRateLimit = 20028,
+  TheWriteActionYouArePerformingOnTheServerHasHitTheWriteRateLimit,
   YourStageTopicOrServerNameOrServerDescriptionOrChannelNamesContainsWordsThatAreNotAllowedForPublicStages = 20031,
   GuildPremiumSubscriptionLevelTooLow = 20035,
   MaximumNumberOfGuildsReached = 30001,
@@ -66,6 +68,7 @@ export enum JsonErrorCodes {
   MaximumNumberOfServerMembersReached,
   MaximumNumberOfServerCategoriesHasBeenReached = 30030,
   GuildAlreadyHasTemplate = 30031,
+  MaxNumberOfThreadParticipantsHasBeenReached = 30033,
   MaximumNumberOfBansForNonGuildMembersHaveBeenExceeded = 30035,
   MaximumNumberOfBansFetchesHasBeenReached = 30037,
   MaximumNumberOfUncompletedGuildScheduledEventsReached = 30038,
@@ -107,10 +110,14 @@ export enum JsonErrorCodes {
   InvalidRole,
   InvalidRecipients = 50033,
   AMessageProvidedWasTooOldToBulkDelete,
+  /** Invalid form body (returned for both `application/json` and `multipart/form-data` bodies), or invalid `Content-Type` provided */
   InvalidFormBodyOrContentTypeProvided,
   AnInviteWasAcceptedToAGuildTheApplicationsBotIsNotIn,
   InvalidApiVersionProvided = 50041,
+  FileUploadedExceedsTheMaximumSize = 50045,
+  InvalidFileUploaded,
   CannotSelfRedeemThisGift = 50054,
+  InvalidGuild,
   PaymentSourceRequiredToRedeemGift = 50070,
   CannotDeleteAChannelRequiredForCommunityGuilds = 50074,
   InvalidStickerSent = 50081,
@@ -120,9 +127,10 @@ export enum JsonErrorCodes {
   ThisServerIsNotAvailableInYourLocation = 50095,
   ThisServerNeedsMonetizationEnabledInOrderToPerformThisAction = 50097,
   ThisServerNeedsMoreBoostsToPerformThisAction = 50101,
+  TheRequestBodyContainsInvalidJSON = 50109,
   TwoFactorIsRequiredForThisOperation = 60003,
   NoUsersWithDiscordTagExist = 80004,
-  ReqctionWasBlocked = 90001,
+  ReactionWasBlocked = 90001,
   ApiResourceIsCurrentlyOverloadedTryAgainALittleLater = 130000,
   TheStageIsAlreadyOpen = 150006,
   CannotReplyWithoutPermissionToReadMessageHistory = 160002,
@@ -130,4 +138,13 @@ export enum JsonErrorCodes {
   ThreadIsLocked = 160005,
   MaximumNumberOfActiveThreadsReached = 160006,
   MaximumNumberOfActiveAnnouncementThreadsReached = 160007,
+  InvalidJsonForUploadedLottieFile = 170001,
+  UploadedLottiesCannotContainRasterizedImagesSuchAsPngOrJpeg,
+  StickerMaximumFramerateExceeded,
+  StickerFrameCountExceedsMaximumOf1000Frames,
+  LottieAnimationMaximumDimensionsExceeded,
+  StickerFrameRateIsEitherTooSmallOrTooLarge,
+  StickerAnimationDurationExceedsMaximumOf5Seconds,
+  CannotUpdateAFinishedEvent = 180000,
+  FailedToCreateStageNeededForStageEvent = 180002,
 }
diff --git a/src/types/codes/rpcCloseEventCodes.ts b/src/types/codes/rpcCloseEventCodes.ts
index c7075f6d2..9f1c951c7 100644
--- a/src/types/codes/rpcCloseEventCodes.ts
+++ b/src/types/codes/rpcCloseEventCodes.ts
@@ -1,9 +1,15 @@
 /** https://discord.com/developers/docs/topics/opcodes-and-status-codes#rpc */
 export enum RpcCloseEventCodes {
+  /** You connected to the RPC server with an invalid client ID. */
   InvalidClientId = 4000,
+  /** You connected to the RPC server with an invalid origin. */
   InvalidOrigin,
+  /** You are being rate limited. */
   RateLimited,
+  /** The OAuth2 token associated with a connection was revoked, get a new one! */
   TokenRevoked,
+  /** The RPC Server version specified in the connection string was not valid. */
   InvalidVersion,
+  /** The encoding specified in the connection string was not valid. */
   InvalidEncoding,
 }
diff --git a/src/types/codes/rpcErrorCodes.ts b/src/types/codes/rpcErrorCodes.ts
index 76cdc38f0..414f15e36 100644
--- a/src/types/codes/rpcErrorCodes.ts
+++ b/src/types/codes/rpcErrorCodes.ts
@@ -1,19 +1,35 @@
 /** https://discord.com/developers/docs/topics/opcodes-and-status-codes#rpc */
 export enum RpcErrorCodes {
+  /** An unknown error occurred. */
   UnknownError = 1000,
+  /** You sent an invalid payload. */
   InvalidPayload = 4000,
+  /** Invalid command name specified. */
   InvalidCommand = 4002,
+  /** Invalid guild ID specified. */
   InvalidGuild,
+  /** Invalid event name specified. */
   InvalidEvent,
+  /** Invalid channel ID specified. */
   InvalidChannel,
+  /** You lack permissions to access the given resource. */
   InvalidPermissions,
+  /** An invalid OAuth2 application ID was used to authorize or authenticate with. */
   InvalidClientId,
+  /** An invalid OAuth2 application origin was used to authorize or authenticate with. */
   InvalidOrigin,
+  /** An invalid OAuth2 token was used to authorize or authenticate with. */
   InvalidToken,
+  /** The specified user ID was invalid. */
   InvalidUser,
+  /** A standard OAuth2 error occurred; check the data object for the OAuth2 error details. */
   OAuth2Error = 5000,
+  /** An asynchronous `SELECT_TEXT_CHANNEL`/`SELECT_VOICE_CHANNEL` command timed out. */
   SelectChannelTimedOut,
+  /** An asynchronous `GET_GUILD` command timed out. */
   GetGuildTimedOut,
+  /** You tried to join a user to a voice channel but the user was already in one. */
   SelectVoiceForceRequired,
+  /** You tried to capture more than one shortcut key at once. */
   CaptureShortcutAlreadyListening,
 }
diff --git a/src/types/codes/voiceCloseEventCodes.ts b/src/types/codes/voiceCloseEventCodes.ts
index 414a69e2d..c4027c39e 100644
--- a/src/types/codes/voiceCloseEventCodes.ts
+++ b/src/types/codes/voiceCloseEventCodes.ts
@@ -1,16 +1,27 @@
 /** https://discord.com/developers/docs/topics/opcodes-and-status-codes#voice */
 export enum VoiceCloseEventCodes {
+  /** You sent an invalid [opcode](https://discord.com/developers/docs/topics/opcodes-and-status-codes#voice-voice-opcodes). */
   UnknownOpcode = 4001,
+  /** You sent a invalid payload in your [identifying](https://discord.com/developers/docs/topics/gateway#identify) to the Gateway. */
   FailedToDecodePayload,
+  /** You sent a payload before [identifying](https://discord.com/developers/docs/topics/gateway#identify) with the Gateway. */
   NotAuthenticated,
+  /** The token you sent in your [identify](https://discord.com/developers/docs/topics/gateway#identify) payload is incorrect. */
   AuthenticationFailed,
+  /** You sent more than one [identify](https://discord.com/developers/docs/topics/gateway#identify) payload. Stahp. */
   AlreadyAuthenticated,
+  /** Your session is no longer valid. */
   SessionNoLongerValid,
+  /** Your session has timed out. */
   SessionTimedOut = 4009,
+  /** We can't find the server you're trying to connect to. */
   ServerNotFound = 4011,
+  /** We didn't recognize the [protocol](https://discord.com/developers/docs/topics/voice-connections#establishing-a-voice-udp-connection-example-select-protocol-payload) you sent. */
   UnknownProtocol,
   /** Channel was deleted, you were kicked, voice server changed, or the main gateway session was dropped. Should not reconnect. */
   Disconnect = 4014,
+  /** The server crashed. Our bad! Try [resuming](https://discord.com/developers/docs/topics/voice-connections#resuming-voice-connection). */
   VoiceServerCrashed,
+  /** We didn't recognize your [encryption](https://discord.com/developers/docs/topics/voice-connections#encrypting-and-sending-voice). */
   UnknownEncryptionMode,
 }
diff --git a/src/types/codes/voiceOpcodes.ts b/src/types/codes/voiceOpcodes.ts
index e1f15ddb8..8fb942428 100644
--- a/src/types/codes/voiceOpcodes.ts
+++ b/src/types/codes/voiceOpcodes.ts
@@ -1,14 +1,25 @@
 /** https://discord.com/developers/docs/topics/opcodes-and-status-codes#voice */
 export enum VoiceOpcodes {
+  /** Begin a voice websocket connection. */
   Identify,
+  /** Select the voice protocol. */
   SelectProtocol,
+  /** Complete the websocket handshake. */
   Ready,
+  /** Keep the websocket connection alive. */
   Heartbeat,
+  /** Describe the session. */
   SessionDescription,
+  /** Indicate which users are speaking. */
   Speaking,
+  /** Sent to acknowledge a received client heartbeat. */
   HeartbeatACK,
+  /** Resume a connection. */
   Resume,
+  /** Time to wait between sending heartbeats in milliseconds. */
   Hello,
+  /** Acknowledge a successful session resume. */
   Resumed,
+  /** A client has disconnected from the voice channel */
   ClientDisconnect = 13,
 }
diff --git a/src/types/discordeno/createApplicationCommand.ts b/src/types/discordeno/createApplicationCommand.ts
index 813ed7bb1..2e4c3f628 100644
--- a/src/types/discordeno/createApplicationCommand.ts
+++ b/src/types/discordeno/createApplicationCommand.ts
@@ -1,6 +1,6 @@
-import { CreateGlobalApplicationCommand } from "../interactions/commands/createGlobalApplicationCommand.ts";
+import { CreateApplicationCommand } from "../interactions/commands/createGlobalApplicationCommand.ts";
 
-export interface DiscordenoCreateApplicationCommand extends CreateGlobalApplicationCommand {
+export interface DiscordenoCreateApplicationCommand extends CreateApplicationCommand {
   /** Id of the guild to create a guild only application command */
   guildId: string;
 }
diff --git a/src/types/guilds/guild.ts b/src/types/guilds/guild.ts
index f0470eb87..9c9465026 100644
--- a/src/types/guilds/guild.ts
+++ b/src/types/guilds/guild.ts
@@ -114,4 +114,6 @@ export interface Guild {
   nsfwLevel: GuildNsfwLevel;
   /** Stage instances in the guild */
   stageInstances?: StageInstance[];
+  /** Whether the guild has the boost progress bar enabled */
+  premiumProgressBarEnabled: boolean;
 }
diff --git a/src/types/guilds/mod.ts b/src/types/guilds/mod.ts
index 503571df9..b7c33427f 100644
--- a/src/types/guilds/mod.ts
+++ b/src/types/guilds/mod.ts
@@ -29,6 +29,7 @@ export * from "./modifyGuildRole.ts";
 export * from "./modifyGuildRolePositions.ts";
 export * from "./modifyGuildWelcomeScreen.ts";
 export * from "./premiumTiers.ts";
+export * from "./scheduledEvents.ts";
 export * from "./systemChannelFlags.ts";
 export * from "./unavailableGuild.ts";
 export * from "./updateOthersVoiceState.ts";
diff --git a/src/types/guilds/modifyGuild.ts b/src/types/guilds/modifyGuild.ts
index e8e044edf..48dc94785 100644
--- a/src/types/guilds/modifyGuild.ts
+++ b/src/types/guilds/modifyGuild.ts
@@ -40,4 +40,6 @@ export interface ModifyGuild {
   preferredLocale?: string | null;
   /** Enabled guild features */
   features?: GuildFeatures[];
+  /** Whether the guild's boost progress bar should be enabled */
+  premiumProgressBarEnabled?: boolean;
 }
diff --git a/src/types/guilds/updateOthersVoiceState.ts b/src/types/guilds/updateOthersVoiceState.ts
index 87f524582..f4ac66227 100644
--- a/src/types/guilds/updateOthersVoiceState.ts
+++ b/src/types/guilds/updateOthersVoiceState.ts
@@ -1,7 +1,9 @@
 /** https://discord.com/developers/docs/resources/guild#update-user-voice-state */
 export interface UpdateOthersVoiceState {
   /** The id of the channel the user is currently in */
-  channelId: string;
+  channelId: bigint;
   /** Toggles the user's suppress state */
   suppress?: boolean;
+  /** The user id to target */
+  userId: bigint;
 }
diff --git a/src/types/guilds/updateSelfVoiceState.ts b/src/types/guilds/updateSelfVoiceState.ts
index 475a55a75..11ae4696c 100644
--- a/src/types/guilds/updateSelfVoiceState.ts
+++ b/src/types/guilds/updateSelfVoiceState.ts
@@ -1,9 +1,9 @@
 /** https://discord.com/developers/docs/resources/guild#update-current-user-voice-state */
 export interface UpdateSelfVoiceState {
   /** The id of the channel the user is currently in */
-  channelId: string;
+  channelId: bigint;
   /** Toggles the user's suppress state */
   suppress?: boolean;
   /** Sets the user's request to speak */
-  requestToSpeakTimestamp?: string | null;
+  requestToSpeakTimestamp?: number | null;
 }
diff --git a/src/types/interactions/commands/applicationCommand.ts b/src/types/interactions/commands/applicationCommand.ts
index 2236a0fc1..a634aeb6f 100644
--- a/src/types/interactions/commands/applicationCommand.ts
+++ b/src/types/interactions/commands/applicationCommand.ts
@@ -17,7 +17,7 @@ export interface ApplicationCommand {
   options?: ApplicationCommandOption[];
   /** Whether the command is enbaled by default when the app is added to a guild */
   defaultPermission?: boolean;
-  /** The type of command. By default this is a slash command(ChatInput). */
+  /** The type of command. By default this is a application command(ChatInput). */
   type?: ApplicationCommandTypes;
   /** Autoincrementing version identifier updated during substantial record changes */
   version: string;
diff --git a/src/types/interactions/commands/applicationCommandCallbackData.ts b/src/types/interactions/commands/applicationCommandCallbackData.ts
index caa741d9a..e19621e2d 100644
--- a/src/types/interactions/commands/applicationCommandCallbackData.ts
+++ b/src/types/interactions/commands/applicationCommandCallbackData.ts
@@ -1,7 +1,35 @@
+import { FileContent } from "../../discordeno/fileContent.ts";
+import { Embed } from "../../embeds/embed.ts";
+import { AllowedMentions } from "../../messages/allowedMentions.ts";
+import { MessageComponents } from "../../messages/components/messageComponents.ts";
 import { CreateMessage } from "../../messages/createMessage.ts";
+import { ApplicationCommandOptionChoice } from "./applicationCommandOptionChoice.ts";
 
 /** https://discord.com/developers/docs/interactions/slash-commands#interaction-response-interactionapplicationcommandcallbackdata */
-export interface InteractionApplicationCommandCallbackData extends Omit<CreateMessage, "messageReference"> {
+export interface InteractionApplicationCommandCallbackData {
+  /** The message contents (up to 2000 characters) */
+  content?: string;
+  /** true if this is a TTS message */
+  tts?: boolean;
+  /** Embedded `rich` content (up to 6000 characters) */
+  embeds?: Embed[];
+  /** Allowed mentions for the message */
+  allowedMentions?: Omit<AllowedMentions, "users" | "roles"> & {
+    /** Array of role_ids to mention (Max size of 100) */
+    roles?: bigint[];
+    /** Array of user_ids to mention (Max size of 100) */
+    users?: bigint[];
+  };
+  /** The contents of the file being sent */
+  file?: FileContent | FileContent[];
+  /** The customId you want to use for this modal response. */
+  customId?: string;
+  /** The title you want to use for this modal response. */
+  title?: string;
+  /** The components you would like to have sent in this message */
+  components?: MessageComponents;
   /** Set to `64` to make your response ephemeral */
   flags?: number;
+  /** autocomplete choices (max of 25 choices) */
+  choices?: ApplicationCommandOptionChoice[];
 }
diff --git a/src/types/interactions/commands/applicationCommandInteractionData.ts b/src/types/interactions/commands/applicationCommandInteractionData.ts
index 42dae700a..9f91ce1db 100644
--- a/src/types/interactions/commands/applicationCommandInteractionData.ts
+++ b/src/types/interactions/commands/applicationCommandInteractionData.ts
@@ -1,4 +1,4 @@
-import { Message, User, Role, Channel, MessageComponentTypes } from "../../mod.ts";
+import { Message, User, Role, Channel, MessageComponentTypes, MessageComponents } from "../../mod.ts";
 import { InteractionGuildMember } from "../interactionGuildMember.ts";
 import { InteractionDataOption } from "./applicationCommandInteractionDataOption.ts";
 
@@ -7,6 +7,8 @@ export interface InteractionData {
   componentType?: MessageComponentTypes;
   /** The custom id provided for this component. */
   customId?: string;
+  /** The components if its a Modal Submit interaction. */
+  components?: MessageComponents;
   /** The values chosen by the user. */
   values?: string[];
   /** The Id of the invoked command */
diff --git a/src/types/interactions/commands/createGlobalApplicationCommand.ts b/src/types/interactions/commands/createGlobalApplicationCommand.ts
index e3884a639..25d317949 100644
--- a/src/types/interactions/commands/createGlobalApplicationCommand.ts
+++ b/src/types/interactions/commands/createGlobalApplicationCommand.ts
@@ -2,7 +2,7 @@ import { ApplicationCommandOption } from "./applicationCommandOption.ts";
 import { ApplicationCommandTypes } from "./applicationCommandTypes.ts";
 
 /** https://discord.com/developers/docs/interactions/slash-commands#create-global-application-command-json-params */
-export interface CreateGlobalApplicationCommand {
+export interface CreateApplicationCommand {
   /** 1-31 character name matching lowercase `^[\w-]{1,32}$` */
   name: string;
   /** 1-100 character description */
diff --git a/src/types/interactions/interactionResponseTypes.ts b/src/types/interactions/interactionResponseTypes.ts
index f1db5aacc..c7484ad70 100644
--- a/src/types/interactions/interactionResponseTypes.ts
+++ b/src/types/interactions/interactionResponseTypes.ts
@@ -7,9 +7,11 @@ export enum InteractionResponseTypes {
   /** ACK an interaction and edit a response later, the user sees a loading state */
   DeferredChannelMessageWithSource = 5,
   /** For components, ACK an interaction and edit the original message later; the user does not see a loading state */
-  DeferredUpdateMessage,
+  DeferredUpdateMessage = 6,
   /** For components, edit the message the component was attached to */
-  UpdateMessage,
+  UpdateMessage = 7,
   /** For Application Command Options, send an autocomplete result */
-  ApplicationCommandAutocompleteResult,
+  ApplicationCommandAutocompleteResult = 8,
+  /** For Command or Component interactions, send a Modal response */
+  Modal = 9,
 }
diff --git a/src/types/interactions/interactionTypes.ts b/src/types/interactions/interactionTypes.ts
index 6ebf2b674..6148d35fc 100644
--- a/src/types/interactions/interactionTypes.ts
+++ b/src/types/interactions/interactionTypes.ts
@@ -1,7 +1,8 @@
 /** https://discord.com/developers/docs/interactions/slash-commands#interaction-interactiontype */
 export enum InteractionTypes {
   Ping = 1,
-  ApplicationCommand,
-  MessageComponent,
-  ApplicationCommandAutocomplete,
+  ApplicationCommand = 2,
+  MessageComponent = 3,
+  ApplicationCommandAutocomplete = 4,
+  ModalSubmit = 5,
 }
diff --git a/src/types/invites/invite.ts b/src/types/invites/invite.ts
index a795158ec..f8cea227d 100644
--- a/src/types/invites/invite.ts
+++ b/src/types/invites/invite.ts
@@ -13,7 +13,7 @@ export interface Invite {
   /** The guild this invite is for */
   guild?: Partial<Guild>;
   /** The channel this invite is for */
-  channel: Partial<Channel>;
+  channel: Partial<Channel> | null;
   /** The user who created the invite */
   inviter?: User;
   /** The type of target for this voice channel invite */
diff --git a/src/types/messages/components/actionRow.ts b/src/types/messages/components/actionRow.ts
index 5b592d2e2..5196050fc 100644
--- a/src/types/messages/components/actionRow.ts
+++ b/src/types/messages/components/actionRow.ts
@@ -1,4 +1,5 @@
 import { ButtonComponent } from "./buttonComponent.ts";
+import { InputTextComponent } from "./inputTextComponent.ts";
 import { SelectMenuComponent } from "./selectMenu.ts";
 
 /** https://discord.com/developers/docs/interactions/message-components#actionrow */
@@ -7,7 +8,7 @@ export interface ActionRow {
   type: 1;
   /** The components in this row */
   components:
-    | [SelectMenuComponent | ButtonComponent]
+    | [SelectMenuComponent | ButtonComponent | InputTextComponent]
     | [ButtonComponent, ButtonComponent]
     | [ButtonComponent, ButtonComponent, ButtonComponent]
     | [ButtonComponent, ButtonComponent, ButtonComponent, ButtonComponent]
diff --git a/src/types/messages/components/inputTextComponent.ts b/src/types/messages/components/inputTextComponent.ts
new file mode 100644
index 000000000..9c6d87b5e
--- /dev/null
+++ b/src/types/messages/components/inputTextComponent.ts
@@ -0,0 +1,22 @@
+import { MessageComponentTypes } from "./messageComponentTypes.ts";
+import { TextStyles } from "./textStyles.ts";
+
+// TODO: docs link
+export interface InputTextComponent {
+  /** InputText Component is of type 3 */
+  type: MessageComponentTypes.InputText;
+  /** The style of the InputText */
+  style: TextStyles;
+  /** The customId of the InputText */
+  customId: string;
+  /** The label of the InputText */
+  label: string;
+  /** The placeholder of the InputText */
+  placeholder?: string;
+  /** The minimum length of the text the user has to provide */
+  minLength?: number;
+  /** The maximum length of the text the user has to provide */
+  maxLength?: number;
+  /** Whether or not this input is required. */
+  required?: boolean;
+}
diff --git a/src/types/messages/components/messageComponentTypes.ts b/src/types/messages/components/messageComponentTypes.ts
index 0f329c631..d1f04df1b 100644
--- a/src/types/messages/components/messageComponentTypes.ts
+++ b/src/types/messages/components/messageComponentTypes.ts
@@ -3,7 +3,9 @@ export enum MessageComponentTypes {
   /** A row of components at the bottom of a message */
   ActionRow = 1,
   /** A button! */
-  Button,
+  Button = 2,
   /** A select menu. */
-  SelectMenu,
+  SelectMenu = 3,
+  /** An Input Text. */
+  InputText = 4,
 }
diff --git a/src/types/messages/components/textStyles.ts b/src/types/messages/components/textStyles.ts
new file mode 100644
index 000000000..54ab43c7b
--- /dev/null
+++ b/src/types/messages/components/textStyles.ts
@@ -0,0 +1,6 @@
+export enum TextStyles {
+  /** Intended for short single-line text */
+  Short = 1,
+  /** Intended for much longer inputs */
+  Paragraph = 2,
+}
diff --git a/src/types/messages/message.ts b/src/types/messages/message.ts
index 09eb12c1b..64cca34b3 100644
--- a/src/types/messages/message.ts
+++ b/src/types/messages/message.ts
@@ -73,7 +73,7 @@ export interface Message {
   activity?: MessageActivity;
   /** Sent with Rich Presence-related chat embeds */
   application?: Partial<Application>;
-  /** If the message is a response to an Interaction, this is the id of the interaction's application */
+  /** if the message is an Interaction or application-owned webhook, this is the id of the application */
   applicationId?: string;
   /** Data showing the source of a crossposted channel follow add, pin or reply message */
   messageReference?: Omit<MessageReference, "failIfNotExists">;
diff --git a/src/types/messages/messageSticker.ts b/src/types/messages/messageSticker.ts
deleted file mode 100644
index aec976292..000000000
--- a/src/types/messages/messageSticker.ts
+++ /dev/null
@@ -1,26 +0,0 @@
-import { MessageStickerFormatTypes } from "./messageStickerFormatTypes.ts";
-import type { User } from "../users/user.ts";
-
-/** https://discord.com/developers/docs/resources/channel#message-object-message-sticker-structure */
-export interface MessageSticker {
-  /** Id of the sticker */
-  id: string;
-  /** Id of the pack the sticker is from */
-  packId?: string;
-  /** Name of the sticker */
-  name: string;
-  /** Description of the sticker */
-  description: string;
-  /** a unicode emoji representing the sticker's expression */
-  tags: string;
-  /** Type of sticker format */
-  formatType: MessageStickerFormatTypes;
-  /**  Whether or not the sticker is available */
-  available?: boolean;
-  /** Id of the guild that owns this sticker */
-  guildId?: string;
-  /** The user that uploaded the sticker */
-  user?: User;
-  /** A sticker's sort order within a pack */
-  sortValue?: number;
-}
diff --git a/src/types/messages/messageStickerFormatTypes.ts b/src/types/messages/messageStickerFormatTypes.ts
deleted file mode 100644
index 3da89b3a9..000000000
--- a/src/types/messages/messageStickerFormatTypes.ts
+++ /dev/null
@@ -1,6 +0,0 @@
-/** https://discord.com/developers/docs/resources/channel#message-object-message-sticker-format-types */
-export enum MessageStickerFormatTypes {
-  Png = 1,
-  Apng,
-  Lottie,
-}
diff --git a/src/types/messages/messageStickerItem.ts b/src/types/messages/messageStickerItem.ts
deleted file mode 100644
index f61ae1b13..000000000
--- a/src/types/messages/messageStickerItem.ts
+++ /dev/null
@@ -1,10 +0,0 @@
-import { MessageStickerFormatTypes } from "./messageStickerFormatTypes.ts";
-
-export interface MessageStickerItem {
-  /** Id of the sticker */
-  id: string;
-  /** Name of the sticker */
-  name: string;
-  /** Type of sticker format */
-  formatType: MessageStickerFormatTypes;
-}
diff --git a/src/types/permissions/bitwisePermissionFlags.ts b/src/types/permissions/bitwisePermissionFlags.ts
index 81a864294..74e0b0c9d 100644
--- a/src/types/permissions/bitwisePermissionFlags.ts
+++ b/src/types/permissions/bitwisePermissionFlags.ts
@@ -62,7 +62,7 @@ export enum BitwisePermissionFlags {
   MANAGE_WEBHOOKS = 0x20000000,
   /** Allows management and editing of emojis */
   MANAGE_EMOJIS = 0x40000000,
-  /** Allows members to use slash commands in text channels */
+  /** Allows members to use application commands in text channels */
   USE_SLASH_COMMANDS = 0x80000000,
   /** Allows for requesting to speak in stage channels. */
   REQUEST_TO_SPEAK = 0x0100000000,
diff --git a/src/types/stickers/sticker.ts b/src/types/stickers/sticker.ts
new file mode 100644
index 000000000..73c628cb1
--- /dev/null
+++ b/src/types/stickers/sticker.ts
@@ -0,0 +1,29 @@
+import type { StickerFormatTypes } from "./stickerFormatTypes.ts";
+import type { StickerTypes } from "./stickerTypes.ts";
+import type { User } from "../users/user.ts";
+
+/** https://discord.com/developers/docs/resources/sticker#sticker-object-sticker-structure */
+export interface Sticker {
+  /** [Id of the sticker](https://discord.com/developers/docs/reference#image-formatting) */
+  id: string;
+  /** Id of the pack the sticker is from */
+  packId?: string;
+  /** Name of the sticker */
+  name: string;
+  /** Description of the sticker */
+  description: string;
+  /** a unicode emoji representing the sticker's expression */
+  tags: string;
+  /** [type of sticker](https://discord.com/developers/docs/resources/sticker#sticker-object-sticker-types) */
+  type: StickerTypes;
+  /** [Type of sticker format](https://discord.com/developers/docs/resources/sticker#sticker-object-sticker-format-types) */
+  formatType: StickerFormatTypes;
+  /**  Whether or not the sticker is available */
+  available?: boolean;
+  /** Id of the guild that owns this sticker */
+  guildId?: string;
+  /** The user that uploaded the sticker */
+  user?: User;
+  /** A sticker's sort order within a pack */
+  sortValue?: number;
+}
diff --git a/src/types/stickers/stickerFormatTypes.ts b/src/types/stickers/stickerFormatTypes.ts
new file mode 100644
index 000000000..791342ad9
--- /dev/null
+++ b/src/types/stickers/stickerFormatTypes.ts
@@ -0,0 +1,6 @@
+/** https://discord.com/developers/docs/resources/sticker#sticker-object-sticker-format-types */
+export enum StickerFormatTypes {
+  Png = 1,
+  Apng,
+  Lottie,
+}
diff --git a/src/types/stickers/stickerItem.ts b/src/types/stickers/stickerItem.ts
new file mode 100644
index 000000000..adc396a1f
--- /dev/null
+++ b/src/types/stickers/stickerItem.ts
@@ -0,0 +1,11 @@
+import { StickerFormatTypes } from "./stickerFormatTypes.ts";
+
+/** https://discord.com/developers/docs/resources/sticker#sticker-item-object-sticker-item-structure */
+export interface StickerItem {
+  /** Id of the sticker */
+  id: string;
+  /** Name of the sticker */
+  name: string;
+  /** [Type of sticker format](https://discord.com/developers/docs/resources/sticker#sticker-object-sticker-format-types) */
+  formatType: StickerFormatTypes;
+}
diff --git a/src/types/stickers/stickerPack.ts b/src/types/stickers/stickerPack.ts
new file mode 100644
index 000000000..cdf03fa0d
--- /dev/null
+++ b/src/types/stickers/stickerPack.ts
@@ -0,0 +1,19 @@
+import { Sticker } from "./sticker.ts";
+
+/** https://discord.com/developers/docs/resources/sticker#sticker-pack-object-sticker-pack-structure */
+export interface StickerPack {
+  /** id of the sticker pack */
+  id: string;
+  /** the stickers in the pack */
+  stickers: Sticker[];
+  /** name of the sticker pack */
+  name: string;
+  /** id of the pack's SKU */
+  sku_id: string;
+  /** id of a sticker in the pack which is shown as the pack's icon */
+  cover_sticker_id?: string;
+  /** description of the sticker pack */
+  description: string;
+  /** id of the sticker pack's [banner image](https://discord.com/developers/docs/reference#image-formatting) */
+  banner_asset_id?: string;
+}
diff --git a/src/types/stickers/stickerTypes.ts b/src/types/stickers/stickerTypes.ts
new file mode 100644
index 000000000..ac039c274
--- /dev/null
+++ b/src/types/stickers/stickerTypes.ts
@@ -0,0 +1,7 @@
+/** https://discord.com/developers/docs/resources/sticker#sticker-object-sticker-types */
+export enum StickerTypes {
+  /** an official sticker in a pack, part of Nitro or in a removed purchasable pack */
+  Standard = 1,
+  /** a sticker uploaded to a Boosted guild for the guild's members */
+  Guild,
+}
diff --git a/src/util/collection.ts b/src/util/collection.ts
index daad789cc..2a98de938 100644
--- a/src/util/collection.ts
+++ b/src/util/collection.ts
@@ -2,7 +2,7 @@ import { Bot } from "../bot.ts";
 
 export class Collection<K, V> extends Map<K, V> {
   maxSize?: number;
-  private sweeper?: CollectionSweeper<K, V> & { intervalId?: number };
+  sweeper?: CollectionSweeper<K, V> & { intervalId?: number };
 
   constructor(entries?: (readonly (readonly [K, V])[] | null) | Map<K, V>, options?: CollectionOptions<K, V>) {
     super(entries ?? []);
@@ -18,8 +18,8 @@ export class Collection<K, V> extends Map<K, V> {
 
     this.sweeper = options;
     this.sweeper.intervalId = setInterval(() => {
-      this.map(async (value, key) => {
-        if (!(await this.sweeper?.filter(options.bot!, value, key))) return;
+      this.forEach((value, key) => {
+        if (!this.sweeper?.filter(value, key, options.bot)) return;
 
         this.delete(key);
         return key;
@@ -39,7 +39,7 @@ export class Collection<K, V> extends Map<K, V> {
     this.startSweeper({ filter: this.sweeper.filter, interval: newInterval });
   }
 
-  changeSweeperFilter(newFilter: (bot: Bot, value: V, key: K) => boolean | Promise<boolean>) {
+  changeSweeperFilter(newFilter: (value: V, key: K, bot: Bot) => boolean) {
     if (!this.sweeper) return;
 
     this.startSweeper({ filter: newFilter, interval: this.sweeper.interval });
@@ -129,14 +129,14 @@ export class Collection<K, V> extends Map<K, V> {
   }
 }
 
-interface CollectionOptions<K, V> {
+export interface CollectionOptions<K, V> {
   sweeper?: CollectionSweeper<K, V>;
   maxSize?: number;
 }
 
-interface CollectionSweeper<K, V> {
+export interface CollectionSweeper<K, V> {
   /** The filter to determine whether an element should be deleted or not */
-  filter: (bot: Bot, value: V, key: K) => boolean | Promise<boolean>;
+  filter: (value: V, key: K, ...args: any[]) => boolean;
   /** The interval in which the sweeper should run */
   interval: number;
   /** The bot object itself */
diff --git a/src/util/constants.ts b/src/util/constants.ts
index 8d979b6b5..64a3e2647 100644
--- a/src/util/constants.ts
+++ b/src/util/constants.ts
@@ -9,7 +9,7 @@ export const GATEWAY_VERSION = 9;
 
 // TODO: update this version
 /** https://github.com/discordeno/discordeno/releases */
-export const DISCORDENO_VERSION = "13.0.0-rc6";
+export const DISCORDENO_VERSION = "13.0.0-rc15";
 
 /** https://discord.com/developers/docs/reference#user-agent */
 export const USER_AGENT = `DiscordBot (https://github.com/discordeno/discordeno, v${DISCORDENO_VERSION})`;
diff --git a/src/ws/createShard.ts b/src/ws/createShard.ts
index d2a2558ef..1b8c21fb6 100644
--- a/src/ws/createShard.ts
+++ b/src/ws/createShard.ts
@@ -4,8 +4,6 @@ import { GatewayManager } from "../bot.ts";
 export function createShard(gateway: GatewayManager, shardId: number) {
   const socket = new WebSocket(`${gateway.urlWSS}/?v=9&encoding=json`);
 
-  socket.binaryType = "arraybuffer";
-
   socket.onerror = (errorEvent) => {
     gateway.debug("GW ERROR", { shardId, error: errorEvent });
   };
diff --git a/src/ws/handleOnMessage.ts b/src/ws/handleOnMessage.ts
index 933f0deff..f99454104 100644
--- a/src/ws/handleOnMessage.ts
+++ b/src/ws/handleOnMessage.ts
@@ -14,12 +14,10 @@ import { decompressWith } from "./deps.ts";
 /** Handler for handling every message event from websocket. */
 // deno-lint-ignore no-explicit-any
 export async function handleOnMessage(gateway: GatewayManager, message: any, shardId: number) {
-  if (message instanceof ArrayBuffer) {
-    message = new Uint8Array(message);
-  }
-
-  if (message instanceof Uint8Array) {
-    message = decompressWith(message, 0, (slice: Uint8Array) => gateway.utf8decoder.decode(slice));
+  if (gateway.compress && message instanceof Blob) {
+    message = decompressWith(new Uint8Array(await message.arrayBuffer()), 0, (slice: Uint8Array) =>
+      gateway.utf8decoder.decode(slice)
+    );
   }
 
   if (typeof message !== "string") return;
diff --git a/src/ws/identify.ts b/src/ws/identify.ts
index 0b724b168..b6d89881e 100644
--- a/src/ws/identify.ts
+++ b/src/ws/identify.ts
@@ -61,18 +61,10 @@ export function identify(gateway: GatewayManager, shardId: number, maxShards: nu
     );
   };
 
-  return new Promise((resolve, reject) => {
-    const timeout = setTimeout(() => {
-      reject(`[Identify Failure] Shard ${shardId} has not received READY event in over a minute.`);
-    }, 600000);
-
+  return new Promise((resolve) => {
     gateway.loadingShards.set(shardId, {
       shardId,
-      resolve: (args) => {
-        clearTimeout(timeout);
-        resolve(args);
-      },
-      startedAt: Date.now(),
+      resolve
     });
   });
 }
diff --git a/src/ws/mod.ts b/src/ws/mod.ts
index 1d12b8724..2f80e518b 100644
--- a/src/ws/mod.ts
+++ b/src/ws/mod.ts
@@ -9,5 +9,5 @@ export * from "./resume.ts";
 export * from "./spawnShards.ts";
 export * from "./sendShardMessage.ts";
 export * from "./startGatewayOptions.ts";
-export * from "./tellClusterToIdentify.ts";
+export * from "./tellWorkerToIdentify.ts";
 export * from "./ws.ts";
diff --git a/src/ws/spawnShards.ts b/src/ws/spawnShards.ts
index e79edbcb1..4b3d0ca85 100644
--- a/src/ws/spawnShards.ts
+++ b/src/ws/spawnShards.ts
@@ -1,9 +1,8 @@
 /** Begin spawning shards. */
 import { GatewayManager } from "../bot.ts";
 
-export function spawnShards(gateway: GatewayManager, firstShardId = 0) {
-  /** Stored as bucketId: [clusterId, [ShardIds]] */
-  const maxShards = gateway.lastShardId || gateway.maxShards;
+export function prepareBuckets(gateway: GatewayManager, firstShardId: number, lastShardId: number) {
+  /** Stored as bucketId: [workerId, [ShardIds]] */
   let worker = 0;
 
   for (let i = 0; i < gateway.maxConcurrency; i++) {
@@ -14,37 +13,45 @@ export function spawnShards(gateway: GatewayManager, firstShardId = 0) {
   }
 
   // ORGANIZE ALL SHARDS INTO THEIR OWN BUCKETS
-  for (let i = firstShardId; i < maxShards; i++) {
+  for (let i = firstShardId; i < lastShardId; i++) {
     gateway.debug(`1. Running for loop in spawnShards function.`);
+    if (i >= gateway.maxShards) {
+      continue;
+    }
+    
     const bucketId = i % gateway.maxConcurrency;
     const bucket = gateway.buckets.get(bucketId);
     if (!bucket) throw new Error("Bucket not found when spawning shards.");
 
     // FIND A QUEUE IN THIS BUCKET THAT HAS SPACE
-    const queue = bucket.workers.find((q) => q.length < gateway.shardsPerCluster + 1);
+    const queue = bucket.workers.find((q) => q.length < gateway.shardsPerWorker + 1);
     if (queue) {
       // IF THE QUEUE HAS SPACE JUST ADD IT TO THIS QUEUE
       queue.push(i);
     } else {
-      if (worker + 1 <= gateway.maxClusters) worker++;
+      if (worker + 1 <= gateway.maxWorkers) worker++;
       // ADD A NEW QUEUE FOR THIS SHARD
       bucket.workers.push([worker, i]);
     }
   }
+}
 
-  // SPREAD THIS OUT TO DIFFERENT CLUSTERS TO BEGIN STARTING UP
+export function spawnShards(gateway: GatewayManager, firstShardId = 0) {
+  // PREPARES ALL SHARDS IN SPECIFIC BUCKETS
+  prepareBuckets(gateway, firstShardId, gateway.lastShardId ? gateway.lastShardId + 1 : gateway.maxShards);
+
+  // SPREAD THIS OUT TO DIFFERENT WORKERS TO BEGIN STARTING UP
   gateway.buckets.forEach(async (bucket, bucketId) => {
     gateway.debug(`2. Running forEach loop in spawnShards function.`);
     for (const [workerId, ...queue] of bucket.workers) {
       gateway.debug(`3. Running for of loop in spawnShards function.`);
 
-      queue.forEach((shardId) => {
+      for (const shardId of queue) {
         bucket.createNextShard.push(async () => {
-          await gateway.tellClusterToIdentify(gateway, workerId, shardId, bucketId);
+          await gateway.tellWorkerToIdentify(gateway, workerId, shardId, bucketId);
         });
-      });
-
-      await bucket.createNextShard.shift()?.();
+      }
     }
+    await bucket.createNextShard.shift()?.();
   });
 }
diff --git a/src/ws/startGatewayOptions.ts b/src/ws/startGatewayOptions.ts
index 6a68ff670..e8078bc1c 100644
--- a/src/ws/startGatewayOptions.ts
+++ b/src/ws/startGatewayOptions.ts
@@ -15,10 +15,10 @@ export interface StartGatewayOptions {
   lastShardId?: number;
   /** The url to forward all payloads to. */
   url: string;
-  /** The amount of shards per cluster. By default this is 25. Use this to spread the load from shards to different CPU cores. */
-  shardsPerCluster?: number;
-  /** The maximum amount of clusters available. By default this is 4. Another way to think of cluster is how many CPU cores does your server/machine have. */
-  maxClusters?: number;
+  /** The amount of shards per worker. By default this is 25. Use this to spread the load from shards to different CPU cores. */
+  shardsPerWorker?: number;
+  /** The maximum amount of workers available. By default this is 4. Another way to think of worker is how many CPU cores does your server/machine have. */
+  maxWorkers?: number;
   /** Whether or not you want to allow automated sharding. By default this is true. */
   reshard?: boolean;
   /** The authorization key that the bot http server will expect. */
diff --git a/src/ws/tellClusterToIdentify.ts b/src/ws/tellWorkerToIdentify.ts
similarity index 61%
rename from src/ws/tellClusterToIdentify.ts
rename to src/ws/tellWorkerToIdentify.ts
index b9f6d1f4f..36f7291e0 100644
--- a/src/ws/tellClusterToIdentify.ts
+++ b/src/ws/tellWorkerToIdentify.ts
@@ -1,7 +1,7 @@
 import { GatewayManager } from "../bot.ts";
-/** Allows users to hook in and change to communicate to different clusters across different servers or anything they like. For example using redis pubsub to talk to other servers. */
 
-export async function tellClusterToIdentify(
+/** Allows users to hook in and change to communicate to different workers across different servers or anything they like. For example using redis pubsub to talk to other servers. */
+export async function tellWorkerToIdentify(
   gateway: GatewayManager,
   _workerId: number,
   shardId: number,
diff --git a/tests/benchmark.ts b/tests/benchmark.ts
index 5b9be3850..090122742 100644
--- a/tests/benchmark.ts
+++ b/tests/benchmark.ts
@@ -5,7 +5,10 @@ import { sanitizeMode } from "./constants.ts";
 Deno.test({
   name: "[Memory] Benchmark memory tests",
   fn: async (t) => {
-    await memoryBenchmarks(bot, true);
+    await memoryBenchmarks(bot, {
+      log: true,
+      table: true,
+    });
   },
   ...sanitizeMode,
 });
diff --git a/tests/channels/connectToVoice.ts b/tests/channels/connectToVoice.ts
index eca96051d..621739c35 100644
--- a/tests/channels/connectToVoice.ts
+++ b/tests/channels/connectToVoice.ts
@@ -3,7 +3,7 @@ import { assertEquals } from "../deps.ts";
 import { bot, guild } from "../mod.ts";
 import { delayUntil } from "../utils.ts";
 
-Deno.test("[channel] Connect to voice channel and disconnect.", async () => {
+Deno.test("[channel] Connect to voice channel.", async () => {
   const channel = await bot.helpers.createChannel(guild.id, {
     name: "lumap",
     type: ChannelTypes.GuildVoice,
@@ -22,11 +22,4 @@ Deno.test("[channel] Connect to voice channel and disconnect.", async () => {
   await delayUntil(10000, () => joined);
 
   assertEquals(joined, true);
-
-  // DISCONNECT BOT
-  await bot.helpers.disconnectMember(guild.id, bot.id);
-  // WAIT FOR EVENT TO ARRIVE
-  await delayUntil(10000, () => !joined);
-
-  assertEquals(joined, false);
 });
diff --git a/tests/channels/createChannel.ts b/tests/channels/createChannel.ts
new file mode 100644
index 000000000..c6f48f90b
--- /dev/null
+++ b/tests/channels/createChannel.ts
@@ -0,0 +1,148 @@
+import { ChannelTypes, CreateGuildChannel, OverwriteTypes } from "../../mod.ts";
+import { CACHED_COMMUNITY_GUILD_ID } from "../constants.ts";
+import { assertExists, assertEquals } from "../deps.ts";
+import { bot, guild } from "../mod.ts";
+import { delayUntil } from "../utils.ts";
+
+async function createChannelTests(guildId: bigint, options: CreateGuildChannel, autoDelete: boolean) {
+  const channel = await bot.helpers.createChannel(guildId, options);
+
+  // Assertions
+  assertExists(channel);
+  assertEquals(channel.type, options.type || ChannelTypes.GuildText);
+
+  // Delay the execution to allow event to be processed
+  await delayUntil(10000, () => bot.channels.has(channel.id));
+
+  if (!bot.channels.has(channel.id)) {
+    throw new Error("The channel seemed to be created but it was not cached.");
+  }
+
+  if (options.topic && channel.topic !== options.topic) {
+    throw new Error("The channel was supposed to have a topic but it does not appear to be the same topic.");
+  }
+
+  if (options.bitrate && channel.bitrate !== options.bitrate) {
+    throw new Error("The channel was supposed to have a bitrate but it does not appear to be the same bitrate.");
+  }
+
+  if (options.permissionOverwrites && channel.permissionOverwrites?.length !== options.permissionOverwrites.length) {
+    throw new Error(
+      "The channel was supposed to have a permissionOverwrites but it does not appear to be the same permissionOverwrites."
+    );
+  }
+
+  if (autoDelete) {
+    await bot.helpers.deleteChannel(channel.id);
+  }
+}
+
+Deno.test({
+  name: "[channel] create a new text channel",
+  async fn(t) {
+    await createChannelTests(guild.id, { name: "Discordeno-test" }, false);
+  },
+});
+Deno.test({
+  name: "[channel] create a new category channel",
+  async fn(t) {
+    await createChannelTests(
+      guild.id,
+      {
+        name: "Discordeno-test",
+        type: ChannelTypes.GuildCategory,
+      },
+      false
+    );
+  },
+});
+Deno.test({
+  name: "[channel] create a new news channel",
+  async fn(t) {
+    await createChannelTests(
+      CACHED_COMMUNITY_GUILD_ID,
+      { name: "Discordeno-test", type: ChannelTypes.GuildNews },
+      true
+    );
+  },
+});
+Deno.test({
+  name: "[channel] create a new voice channel",
+  async fn(t) {
+    await createChannelTests(
+      guild.id,
+      {
+        name: "Discordeno-test",
+        type: ChannelTypes.GuildVoice,
+      },
+      false
+    );
+  },
+});
+Deno.test({
+  name: "[channel] create a new voice channel with a bitrate",
+  async fn(t) {
+    await createChannelTests(
+      guild.id,
+      {
+        name: "discordeno-test",
+        type: ChannelTypes.GuildVoice,
+        bitrate: 32000,
+      },
+      false
+    );
+  },
+});
+Deno.test({
+  name: "[channel] create a new voice channel with a user limit",
+  async fn(t) {
+    await createChannelTests(
+      guild.id,
+      {
+        name: "Discordeno-test",
+        type: ChannelTypes.GuildVoice,
+        userLimit: 32,
+      },
+      false
+    );
+  },
+});
+Deno.test({
+  name: "[channel] create a new text channel with a rate limit per user",
+  async fn(t) {
+    await createChannelTests(
+      guild.id,
+      {
+        name: "Discordeno-test",
+        rateLimitPerUser: 2423,
+      },
+      false
+    );
+  },
+});
+Deno.test({
+  name: "[channel] create a new text channel with NSFW",
+  async fn(t) {
+    await createChannelTests(guild.id, { name: "Discordeno-test", nsfw: true }, false);
+  },
+});
+Deno.test({
+  name: "[channel] create a new text channel with permission overwrites",
+  async fn(t) {
+    await createChannelTests(
+      guild.id,
+      {
+        name: "Discordeno-test",
+        permissionOverwrites: [
+          {
+            id: bot.id,
+            type: OverwriteTypes.Member,
+            allow: ["VIEW_CHANNEL"],
+            deny: [],
+          },
+        ],
+      },
+      false
+    );
+  },
+});
diff --git a/tests/channels/deleteChannel.ts b/tests/channels/deleteChannel.ts
new file mode 100644
index 000000000..a297aa358
--- /dev/null
+++ b/tests/channels/deleteChannel.ts
@@ -0,0 +1,40 @@
+import { bot, guild } from "../mod.ts";
+import { delayUntil } from "../utils.ts";
+
+async function deleteChannelTests(guildId: bigint, options: { reason?: string }) {
+  // Create the necessary channels
+  const channel = await bot.helpers.createChannel(guildId, {
+    name: "delete-channel",
+  });
+
+  await delayUntil(10000, () => bot.channels.has(channel.id));
+  // Make sure the channel was created.
+  if (!bot.channels.has(channel.id)) {
+    throw new Error("The channel should have been created but it is not in the cache.");
+  }
+
+  // Delete the channel now without a reason
+  await bot.helpers.deleteChannel(channel.id, options.reason);
+  // wait to give it time for event
+  await delayUntil(10000, () => !bot.channels.has(channel.id));
+
+  // Make sure it is gone from cache
+  if (bot.channels.has(channel.id)) {
+    throw new Error("The channel should have been deleted but it is still in cache.");
+  }
+}
+
+Deno.test({
+  name: "[channel] delete a channel with a reason",
+  async fn(t) {
+    await deleteChannelTests(guild.id, {
+      reason: "with a reason",
+    });
+  },
+});
+Deno.test({
+  name: "[channel] delete a channel without a reason",
+  async fn(t) {
+    await deleteChannelTests(guild.id, {});
+  },
+});
diff --git a/tests/channels/threads.ts b/tests/channels/threads.ts
index 9173d524a..7faffad8f 100644
--- a/tests/channels/threads.ts
+++ b/tests/channels/threads.ts
@@ -1,4 +1,4 @@
-import { assertEquals, assertExists, assertNotEquals, assertThrows } from "../deps.ts";
+import { assertEquals, assertExists, assertNotEquals } from "../deps.ts";
 import { bot, guild } from "../mod.ts";
 
 Deno.test("[thread] Start a thread", async (t) => {
@@ -34,7 +34,8 @@ Deno.test("[thread] Start a thread", async (t) => {
     assertEquals(archived.members.size, 0);
 
     await t.step("[thread] Edit and archive a thread", async () => {
-      const edited = await bot.helpers.editThread(thread.id, {
+      const edited = await bot.helpers.editChannel(thread.id, {
+        // @ts-ignore
         archived: true,
         name: "new name",
         autoArchiveDuration: 1440,
@@ -54,6 +55,6 @@ Deno.test("[thread] Start a thread", async (t) => {
   });
 
   await t.step("[thread] Delete a thread", async () => {
-    await bot.helpers.deleteThread(thread.id);
+    await bot.helpers.deleteChannel(thread.id);
   });
 });
diff --git a/tests/constants.ts b/tests/constants.ts
index 1a26d2f5a..8759a3bef 100644
--- a/tests/constants.ts
+++ b/tests/constants.ts
@@ -9,5 +9,5 @@ export const sanitizeMode = {
 
 // USED FOR ROLE CHANGE EVENTS
 export const roleChanges = new Map<bigint, bigint[]>();
-
 export const banCounters = new Map<bigint, boolean>();
+export const reactionCounters = new Map<bigint, number>();
diff --git a/tests/deps.ts b/tests/deps.ts
index c9506d36d..8e9b98d7a 100644
--- a/tests/deps.ts
+++ b/tests/deps.ts
@@ -6,4 +6,5 @@ export {
   assertThrows,
   assertThrowsAsync
 } from "https://deno.land/std@0.115.1/testing/asserts.ts";
-export * from "https://deno.land/x/discordeno_cache_plugin@0.0.9/mod.ts";
+export * from "https://deno.land/x/discordeno_cache_plugin@0.0.13/mod.ts";
+export * from "https://deno.land/x/discordeno_permissions_plugin@0.0.7/mod.ts";
diff --git a/tests/emoji/createEmoji.ts b/tests/emoji/createEmoji.ts
index da7f8ca32..595fb4140 100644
--- a/tests/emoji/createEmoji.ts
+++ b/tests/emoji/createEmoji.ts
@@ -1,5 +1,5 @@
 import { assertExists } from "../deps.ts";
-import { bot,guild } from "../mod.ts";
+import { bot, guild } from "../mod.ts";
 import { delayUntil } from "../utils.ts";
 
 Deno.test({
@@ -10,14 +10,14 @@ Deno.test({
       image: "https://cdn.discordapp.com/emojis/814955268123000832.png",
       roles: [],
     });
-  
+
     // Assertions
     assertExists(emoji);
-  
+
     // Delay the execution to allow event to be processed
-    await delayUntil(10000, async () => bot.cache.guilds.get(guild.id)?.emojis?.has(emoji.id));
-  
-    if (!bot.cache.guilds.get(guild.id)?.emojis?.has(emoji.id)) {
+    await delayUntil(10000, async () => bot.guilds.get(guild.id)?.emojis?.has(emoji.id));
+
+    if (!bot.guilds.get(guild.id)?.emojis?.has(emoji.id)) {
       throw new Error("The emoji seemed to be created but it was not cached.");
     }
   },
diff --git a/tests/emoji/deleteEmojiWithReason.ts b/tests/emoji/deleteEmojiWithReason.ts
index c95bb1ba4..b54549541 100644
--- a/tests/emoji/deleteEmojiWithReason.ts
+++ b/tests/emoji/deleteEmojiWithReason.ts
@@ -15,17 +15,17 @@ Deno.test({
     assertExists(emoji);
 
     // Delay the execution to allow event to be processed
-    await delayUntil(10000, async () => bot.cache.guilds.get(guild.id)?.emojis?.has(emoji.id));
+    await delayUntil(10000, async () => bot.guilds.get(guild.id)?.emojis?.has(emoji.id));
 
-    if (!bot.cache.guilds.get(guild.id)?.emojis?.has(emoji.id)) {
+    if (!bot.guilds.get(guild.id)?.emojis?.has(emoji.id)) {
       throw new Error("The emoji seemed to be created but it was not cached.");
     }
 
     await bot.helpers.deleteEmoji(guild.id, emoji.id, "with a reason");
 
-    await delayUntil(10000, async () => !bot.cache.guilds.get(guild.id)?.emojis?.has(emoji.id));
+    await delayUntil(10000, async () => !bot.guilds.get(guild.id)?.emojis?.has(emoji.id));
 
-    if (bot.cache.guilds.get(guild.id)?.emojis?.has(emoji.id)) {
+    if (bot.guilds.get(guild.id)?.emojis?.has(emoji.id)) {
       throw new Error("The emoji seemed to be deleted but it's still cached.");
     }
   },
diff --git a/tests/emoji/deleteEmojiWithoutReason.ts b/tests/emoji/deleteEmojiWithoutReason.ts
index 75c91c10a..341ff180a 100644
--- a/tests/emoji/deleteEmojiWithoutReason.ts
+++ b/tests/emoji/deleteEmojiWithoutReason.ts
@@ -10,22 +10,22 @@ Deno.test({
       image: "https://cdn.discordapp.com/emojis/814955268123000832.png",
       roles: [],
     });
-  
+
     // Assertions
     assertExists(emoji);
-  
+
     // Delay the execution to allow event to be processed
-    await delayUntil(10000, async () => bot.cache.guilds.get(guild.id)?.emojis?.has(emoji.id));
-  
-    if (!bot.cache.guilds.get(guild.id)?.emojis?.has(emoji.id)) {
+    await delayUntil(10000, async () => bot.guilds.get(guild.id)?.emojis?.has(emoji.id));
+
+    if (!bot.guilds.get(guild.id)?.emojis?.has(emoji.id)) {
       throw new Error("The emoji seemed to be created but it was not cached.");
     }
-  
+
     await bot.helpers.deleteEmoji(guild.id, emoji.id);
-  
-    await delayUntil(10000, async () => !bot.cache.guilds.get(guild.id)?.emojis?.has(emoji.id));
-  
-    if (bot.cache.guilds.get(guild.id)?.emojis?.has(emoji.id)) {
+
+    await delayUntil(10000, async () => !bot.guilds.get(guild.id)?.emojis?.has(emoji.id));
+
+    if (bot.guilds.get(guild.id)?.emojis?.has(emoji.id)) {
       throw new Error("The emoji seemed to be deleted but it's still cached.");
     }
   },
diff --git a/tests/emoji/editEmoji.ts b/tests/emoji/editEmoji.ts
index fd226138d..0351e5dad 100644
--- a/tests/emoji/editEmoji.ts
+++ b/tests/emoji/editEmoji.ts
@@ -15,9 +15,9 @@ Deno.test({
     assertExists(emoji);
 
     // Delay the execution to allow event to be processed
-    await delayUntil(10000, async () => bot.cache.guilds.get(guild.id)?.emojis?.has(emoji.id));
+    await delayUntil(10000, async () => bot.guilds.get(guild.id)?.emojis?.has(emoji.id));
 
-    if (!bot.cache.guilds.get(guild.id)?.emojis?.has(emoji.id)) {
+    if (!bot.guilds.get(guild.id)?.emojis?.has(emoji.id)) {
       throw new Error("The emoji seemed to be created but it was not cached.");
     }
 
@@ -25,12 +25,9 @@ Deno.test({
       name: "blamewolf_infinite",
     });
 
-    await delayUntil(
-      10000,
-      async () => bot.cache.guilds.get(guild.id)?.emojis?.get(emoji.id)?.name === "blamewolf_infinite"
-    );
+    await delayUntil(10000, async () => bot.guilds.get(guild.id)?.emojis?.get(emoji.id)?.name === "blamewolf_infinite");
 
-    if (bot.cache.guilds.get(guild.id)?.emojis?.get(emoji.id)?.name !== "blamewolf_infinite") {
+    if (bot.guilds.get(guild.id)?.emojis?.get(emoji.id)?.name !== "blamewolf_infinite") {
       throw new Error("The emoji seemed to be edited but the cache was not updated.");
     }
   },
diff --git a/tests/emoji/getEmoji.ts b/tests/emoji/getEmoji.ts
index 2f93849a1..cf3c1fd5e 100644
--- a/tests/emoji/getEmoji.ts
+++ b/tests/emoji/getEmoji.ts
@@ -15,13 +15,13 @@ Deno.test({
     assertExists(emoji);
 
     // Delay the execution to allow event to be processed
-    await delayUntil(10000, async () => bot.cache.guilds.get(guild.id)?.emojis?.has(emoji.id));
+    await delayUntil(10000, async () => bot.guilds.get(guild.id)?.emojis?.has(emoji.id));
 
-    if (!bot.cache.guilds.get(guild.id)?.emojis?.has(emoji.id)) {
+    if (!bot.guilds.get(guild.id)?.emojis?.has(emoji.id)) {
       throw new Error("The emoji seemed to be created but it was not cached.");
     }
 
-    bot.cache.guilds.get(guild.id)?.emojis?.delete(emoji.id);
+    bot.guilds.get(guild.id)?.emojis?.delete(emoji.id);
 
     const getEmoji = await bot.helpers.getEmoji(guild.id, emoji.id, true);
 
diff --git a/tests/emoji/getMultipleEmojis.ts b/tests/emoji/getMultipleEmojis.ts
index abdf01131..14d8baefd 100644
--- a/tests/emoji/getMultipleEmojis.ts
+++ b/tests/emoji/getMultipleEmojis.ts
@@ -15,9 +15,9 @@ Deno.test({
     assertExists(emoji);
 
     // Delay the execution to allow event to be processed
-    await delayUntil(10000, async () => bot.cache.guilds.get(guild.id)?.emojis?.has(emoji.id));
+    await delayUntil(10000, async () => bot.guilds.get(guild.id)?.emojis?.has(emoji.id));
 
-    if (!bot.cache.guilds.get(guild.id)?.emojis?.has(emoji.id)) {
+    if (!bot.guilds.get(guild.id)?.emojis?.has(emoji.id)) {
       throw new Error("The emoji seemed to be created but it was not cached.");
     }
 
diff --git a/tests/guilds/urls.ts b/tests/guilds/urls.ts
new file mode 100644
index 000000000..b37d3aa6c
--- /dev/null
+++ b/tests/guilds/urls.ts
@@ -0,0 +1,41 @@
+import { assertEquals } from "../deps.ts";
+import { bot, guild } from "../mod.ts";
+
+Deno.test({
+  name: "[guild] format a guild's icon url",
+  fn: () => {
+    assertEquals(bot.helpers.guildIconURL(guild.id, { icon: guild.icon }), undefined);
+    assertEquals(
+      bot.helpers.guildIconURL(785384884197392384n, {
+        icon: 3837424427068676005442449262648382018748n,
+      }),
+      "https://cdn.discordapp.com/icons/785384884197392384/46f50fb412eab14ec455d5cf777154bc.jpg?size=128"
+    );
+  },
+});
+
+Deno.test({
+  name: "[guild] format a guild's banner url",
+  fn: () => {
+    assertEquals(bot.helpers.guildBannerURL(guild.id, { banner: guild.banner }), undefined);
+    assertEquals(
+      bot.helpers.guildBannerURL(613425648685547541n, {
+        banner: 3919584870146358272366452115178209474142n,
+      }),
+      "https://cdn.discordapp.com/banners/613425648685547541/84c4964c115c128fb9100952c3b4f65e.jpg?size=128"
+    );
+  },
+});
+
+Deno.test({
+  name: "[guild] format a guild's splash url",
+  fn: () => {
+    assertEquals(bot.helpers.guildSplashURL(guild.id, { splash: guild.splash }), undefined);
+    assertEquals(
+      bot.helpers.guildSplashURL(785384884197392384n, {
+        splash: 3837424427068676005442449262648382018748n,
+      }),
+      "https://cdn.discordapp.com/splashes/785384884197392384/46f50fb412eab14ec455d5cf777154bc.jpg?size=128"
+    );
+  },
+});
diff --git a/tests/helpers/channels/categoryChannels.ts b/tests/helpers/channels/categoryChannels.ts
index d6d3c4bb4..ff2272ab6 100644
--- a/tests/helpers/channels/categoryChannels.ts
+++ b/tests/helpers/channels/categoryChannels.ts
@@ -1,9 +1,9 @@
-import { Bot } from "../../../src/bot.ts";
 import { ChannelTypes } from "../../../src/types/channels/channelTypes.ts";
 import { assertExists } from "../../deps.ts";
+import { bot } from "../../mod.ts";
 import { delayUntil } from "../../utils.ts";
 
-export async function categoryChildrenTest(bot: Bot, guildId: bigint, t: Deno.TestContext) {
+export async function categoryChildrenTest(guildId: bigint) {
   const category = await bot.helpers.createChannel(guildId, {
     name: "Discordeno-test",
     type: ChannelTypes.GuildCategory,
@@ -12,9 +12,9 @@ export async function categoryChildrenTest(bot: Bot, guildId: bigint, t: Deno.Te
   // Assertions
   assertExists(category);
   // Delay the execution to allow event to be processed
-  await delayUntil(10000, () => bot.cache.channels.has(category.id));
+  await delayUntil(10000, () => bot.channels.has(category.id));
 
-  assertExists(bot.cache.channels.has(category.id));
+  assertExists(bot.channels.has(category.id));
 
   const channelsToCreate = [1, 2, 3, 4, 5];
   const channels = await Promise.all(
@@ -26,14 +26,14 @@ export async function categoryChildrenTest(bot: Bot, guildId: bigint, t: Deno.Te
     )
   );
   // Delay the execution to allow event to be processed
-  await delayUntil(10000, () => channels.every((c) => bot.cache.channels.has(c.id)));
+  await delayUntil(10000, () => channels.every((c) => bot.channels.has(c.id)));
 
   // If every channel is not present in the cache, error out
-  if (!channels.every((c) => bot.cache.channels.has(c.id))) {
+  if (!channels.every((c) => bot.channels.has(c.id))) {
     throw new Error("The channels seemed to be created but it was not cached.");
   }
 
-  // const ids = bot.cache.channels.filter((c) => c.parentId === category.id);
+  // const ids = bot.channels.filter((c) => c.parentId === category.id);
   // if (ids.size !== channels.length || !channels.every((c) => ids.has(c.id))) {
   //   console.log("cccc 1", ids.size, channels.length);
   //   console.log(
diff --git a/tests/helpers/channels/channelOverwriteHasPermission.ts b/tests/helpers/channels/channelOverwriteHasPermission.ts
deleted file mode 100644
index d7d2b3f64..000000000
--- a/tests/helpers/channels/channelOverwriteHasPermission.ts
+++ /dev/null
@@ -1,41 +0,0 @@
-import { Bot, createChannel, ChannelTypes, channelOverwriteHasPermission, OverwriteTypes } from "../../../mod.ts";
-import { Cache } from "../../../src/cache.ts";
-import { assertExists, assertEquals } from "../../deps.ts";
-import { delayUntil } from "../../utils.ts";
-
-export async function channelOverwriteHasPermissionTest(bot: Bot<Cache>, guildId: bigint, t: Deno.TestContext) {
-  const channel = await bot.helpers.createChannel(guildId, {
-    name: "Discordeno-test",
-    permissionOverwrites: [
-      {
-        id: bot.id,
-        type: OverwriteTypes.Member,
-        allow: ["VIEW_CHANNEL"],
-        deny: [],
-      },
-    ],
-  });
-
-  // Assertions
-  assertExists(channel);
-  assertEquals(channel.type, ChannelTypes.GuildText);
-
-  // Delay the execution to allow event to be processed
-  await delayUntil(10000, () => bot.cache.channels.has(channel.id));
-
-  if (!bot.cache.channels.has(channel.id)) {
-    throw new Error("The channel seemed to be created but it was not cached.");
-  }
-
-  assertEquals(channel.permissionOverwrites.length, 1);
-
-  assertEquals(
-    channelOverwriteHasPermission(
-      channel.guildId,
-      bot.id,
-      bot.cache.channels.get(channel.id)?.permissionOverwrites || [],
-      ["VIEW_CHANNEL"]
-    ),
-    true
-  );
-}
diff --git a/tests/helpers/channels/cloneChannel.ts b/tests/helpers/channels/cloneChannel.ts
deleted file mode 100644
index 4958d183e..000000000
--- a/tests/helpers/channels/cloneChannel.ts
+++ /dev/null
@@ -1,26 +0,0 @@
-import { Bot } from "../../../src/bot.ts";
-import { DiscordenoChannel } from "../../../src/transformers/channel.ts";
-import { assertExists, assertEquals } from "../../deps.ts";
-import { delayUntil } from "../../utils.ts";
-
-export async function cloneChannelTests(
-  bot: Bot,
-  guildId: bigint,
-  channel: DiscordenoChannel,
-  options: { reason?: string },
-  t: Deno.TestContext
-) {
-  const cloned = await bot.helpers.cloneChannel(channel, options.reason);
-
-  //Assertations
-  assertExists(cloned);
-  assertEquals(cloned.type, channel.type);
-
-  // Delay the execution to allow CHANNEL_CREATE event to be processed
-  await delayUntil(10000, () => bot.cache.channels.has(cloned.id));
-
-  assertExists(bot.cache.channels.has(cloned.id));
-  assertEquals(channel.topic, cloned.topic);
-  assertEquals(channel.bitrate, cloned.bitrate);
-  assertEquals(channel.permissionOverwrites.length, cloned.permissionOverwrites.length);
-}
diff --git a/tests/helpers/channels/createChannel.ts b/tests/helpers/channels/createChannel.ts
index 5c89244a1..4e94ee5be 100644
--- a/tests/helpers/channels/createChannel.ts
+++ b/tests/helpers/channels/createChannel.ts
@@ -1,10 +1,14 @@
-import { Bot } from "../../../src/bot.ts";
 import { CreateGuildChannel } from "../../../src/types/guilds/createGuildChannel.ts";
 import { ChannelTypes } from "../../../src/types/mod.ts";
 import { assertExists, assertEquals } from "../../deps.ts";
+import { bot } from "../../mod.ts";
 import { delayUntil } from "../../utils.ts";
 
-export async function createChannelTests(bot: Bot, guildId: bigint, options: CreateGuildChannel, autoDelete: boolean, t: Deno.TestContext) {
+export async function createChannelTests(
+  guildId: bigint,
+  options: CreateGuildChannel,
+  autoDelete: boolean,
+) {
   const channel = await bot.helpers.createChannel(guildId, options);
 
   // Assertions
@@ -12,9 +16,9 @@ export async function createChannelTests(bot: Bot, guildId: bigint, options: Cre
   assertEquals(channel.type, options.type || ChannelTypes.GuildText);
 
   // Delay the execution to allow event to be processed
-  await delayUntil(10000, () => bot.cache.channels.has(channel.id));
+  await delayUntil(10000, () => bot.channels.has(channel.id));
 
-  if (!bot.cache.channels.has(channel.id)) {
+  if (!bot.channels.has(channel.id)) {
     throw new Error("The channel seemed to be created but it was not cached.");
   }
 
diff --git a/tests/helpers/channels/deleteChannel.ts b/tests/helpers/channels/deleteChannel.ts
index 6ea30597b..40edb4bb3 100644
--- a/tests/helpers/channels/deleteChannel.ts
+++ b/tests/helpers/channels/deleteChannel.ts
@@ -1,28 +1,25 @@
-import { Bot } from "../../../src/bot.ts";
-import { Channel } from "../../../src/types/channels/channel.ts";
-import { SnakeCasedPropertiesDeep } from "../../../src/types/util.ts";
+import { bot } from "../../mod.ts";
 import { delayUntil } from "../../utils.ts";
 
-export async function deleteChannelTests(bot: Bot, guildId: bigint, options: { reason?: string }, t: Deno.TestContext) {
+export async function deleteChannelTests(guildId: bigint, options: { reason?: string }) {
   // Create the necessary channels
   const channel = await bot.helpers.createChannel(guildId, {
     name: "delete-channel",
   });
 
-  await delayUntil(10000, () => bot.cache.channels.has(channel.id));
+  await delayUntil(10000, () => bot.channels.has(channel.id));
   // Make sure the channel was created.
-  if (!bot.cache.channels.has(channel.id)) {
+  if (!bot.channels.has(channel.id)) {
     throw new Error("The channel should have been created but it is not in the cache.");
   }
 
-  const CHANNEL_DELETE = bot.handlers.CHANNEL_DELETE;
-  
   // Delete the channel now without a reason
   await bot.helpers.deleteChannel(channel.id, options.reason);
   // wait to give it time for event
-  await delayUntil(10000, () => !bot.cache.channels.has(channel.id));
+  await delayUntil(10000, () => !bot.channels.has(channel.id));
+
   // Make sure it is gone from cache
-  if (bot.cache.channels.has(channel.id)) {
+  if (bot.channels.has(channel.id)) {
     throw new Error("The channel should have been deleted but it is still in cache.");
   }
 }
diff --git a/tests/helpers/channels/deleteChannelOverwrite.ts b/tests/helpers/channels/deleteChannelOverwrite.ts
index c4ce441b4..4faa4ef25 100644
--- a/tests/helpers/channels/deleteChannelOverwrite.ts
+++ b/tests/helpers/channels/deleteChannelOverwrite.ts
@@ -1,9 +1,9 @@
-import { Bot, createChannel, ChannelTypes, channelOverwriteHasPermission, OverwriteTypes } from "../../../mod.ts";
-import { Cache } from "../../../src/cache.ts";
-import { assertExists, assertEquals } from "../../deps.ts";
+import { ChannelTypes, OverwriteTypes } from "../../../mod.ts";
+import { assertExists, assertEquals, channelOverwriteHasPermission } from "../../deps.ts";
+import { bot } from "../../mod.ts";
 import { delayUntil } from "../../utils.ts";
 
-export async function deleteChannelOverwriteTests(bot: Bot<Cache>, guildId: bigint, t: Deno.TestContext) {
+export async function deleteChannelOverwriteTests(guildId: bigint) {
   const channel = await bot.helpers.createChannel(guildId, {
     name: "Discordeno-test",
     permissionOverwrites: [
@@ -21,29 +21,26 @@ export async function deleteChannelOverwriteTests(bot: Bot<Cache>, guildId: bigi
   assertEquals(channel.type, ChannelTypes.GuildText);
 
   // Delay the execution to allow event to be processed
-  await delayUntil(10000, () => bot.cache.channels.has(channel.id));
+  await delayUntil(10000, () => bot.channels.has(channel.id));
 
-  if (!bot.cache.channels.has(channel.id)) {
+  if (!bot.channels.has(channel.id)) {
     throw new Error("The channel seemed to be created but it was not cached.");
   }
 
   assertEquals(channel.permissionOverwrites.length, 1);
 
   assertEquals(
-    channelOverwriteHasPermission(
-      channel.guildId,
-      bot.id,
-      bot.cache.channels.get(channel.id)?.permissionOverwrites || [],
-      ["VIEW_CHANNEL"]
-    ),
+    channelOverwriteHasPermission(channel.guildId, bot.id, bot.channels.get(channel.id)?.permissionOverwrites || [], [
+      "VIEW_CHANNEL",
+    ]),
     true
   );
 
   await bot.helpers.deleteChannelOverwrite(channel.id, bot.id);
 
-  await delayUntil(10000, () => bot.cache.channels.get(channel.id)?.permissionOverwrites?.length === 0);
+  await delayUntil(10000, () => bot.channels.get(channel.id)?.permissionOverwrites?.length === 0);
 
-  if (bot.cache.channels.get(channel.id)?.permissionOverwrites?.length !== 0) {
+  if (bot.channels.get(channel.id)?.permissionOverwrites?.length !== 0) {
     throw new Error("The channel permission overwrite was supposed to be deleted but it does not appear to be.");
   }
 }
diff --git a/tests/helpers/channels/editChannel.ts b/tests/helpers/channels/editChannel.ts
index 4f9008712..2aac35c7c 100644
--- a/tests/helpers/channels/editChannel.ts
+++ b/tests/helpers/channels/editChannel.ts
@@ -1,22 +1,16 @@
-import { Bot } from "../../../src/bot.ts";
-import { Cache } from "../../../src/cache.ts";
 import { assertEquals } from "../../deps.ts";
+import { bot } from "../../mod.ts";
 import { delayUntil } from "../../utils.ts";
 
-export async function editChannelTests(
-  bot: Bot<Cache>,
-  guildId: bigint,
-  options: { reason?: string },
-  t: Deno.TestContext
-) {
+export async function editChannelTests(guildId: bigint, options: { reason?: string }) {
   // Create the necessary channels
   const channel = await bot.helpers.createChannel(guildId, {
     name: "edit-channel",
   });
   // wait to give it time for events to process
-  await delayUntil(3000, () => bot.cache.channels.has(channel.id));
+  await delayUntil(3000, () => bot.channels.has(channel.id));
   // Make sure the channel was created.
-  if (!bot.cache.channels.has(channel.id)) {
+  if (!bot.channels.has(channel.id)) {
     throw new Error("The channel should have been created but it is not in the cache.");
   }
 
@@ -31,6 +25,6 @@ export async function editChannelTests(
   );
 
   // wait to give it time for events to process
-  await delayUntil(3000, () => bot.cache.channels.get(channel.id)?.name === "new-name");
-  assertEquals(bot.cache.channels.get(channel.id)?.name, "new-name");
+  await delayUntil(3000, () => bot.channels.get(channel.id)?.name === "new-name");
+  assertEquals(bot.channels.get(channel.id)?.name, "new-name");
 }
diff --git a/tests/helpers/emojis/createEmoji.ts b/tests/helpers/emojis/createEmoji.ts
index 438693988..ffa9cc99e 100644
--- a/tests/helpers/emojis/createEmoji.ts
+++ b/tests/helpers/emojis/createEmoji.ts
@@ -2,7 +2,7 @@ import { Bot } from "../../../src/bot.ts";
 import { assertExists } from "../../deps.ts";
 import { delayUntil } from "../../utils.ts";
 
-export async function createEmojiTest(bot: Bot, guildId: bigint, t: Deno.TestContext) {
+export async function createEmojiTest(guildId: bigint) {
   const emoji = await bot.helpers.createEmoji(guildId, {
     name: "blamewolf",
     image: "https://cdn.discordapp.com/emojis/814955268123000832.png",
@@ -13,9 +13,9 @@ export async function createEmojiTest(bot: Bot, guildId: bigint, t: Deno.TestCon
   assertExists(emoji);
 
   // // Delay the execution to allow event to be processed
-  // await delayUntil(10000, async () => bot.cache.guilds.get(guildId)?.emojis?.has(emoji.id));
+  // await delayUntil(10000, async () => bot.guilds.get(guildId)?.emojis?.has(emoji.id));
 
-  // if (!bot.cache.guilds.get(guildId)?.emojis?.has(emoji.id)) {
+  // if (!bot.guilds.get(guildId)?.emojis?.has(emoji.id)) {
   //   throw new Error("The emoji seemed to be created but it was not cached.");
   // }
 }
diff --git a/tests/helpers/emojis/deleteEmoji.ts b/tests/helpers/emojis/deleteEmoji.ts
index 02d148ef4..dcdea4c26 100644
--- a/tests/helpers/emojis/deleteEmoji.ts
+++ b/tests/helpers/emojis/deleteEmoji.ts
@@ -13,25 +13,25 @@ export async function ifItFailsBlameWolf(bot: Bot, guildId: bigint, reason?: str
   assertExists(emoji);
 
   // Delay the execution to allow event to be processed
-  // await delayUntil(10000, async () => bot.cache.guilds.get(guildId)?.emojis?.has(emoji.id));
+  // await delayUntil(10000, async () => bot.guilds.get(guildId)?.emojis?.has(emoji.id));
 
-  // if (!bot.cache.guilds.get(guildId)?.emojis?.has(emoji.id)) {
+  // if (!bot.guilds.get(guildId)?.emojis?.has(emoji.id)) {
   //   throw new Error("The emoji seemed to be created but it was not cached.");
   // }
 
   await bot.helpers.deleteEmoji(guildId, emoji.id, reason);
 
-  // await delayUntil(10000, async () => !bot.cache.guilds.get(guildId)?.emojis?.has(emoji.id));
+  // await delayUntil(10000, async () => !bot.guilds.get(guildId)?.emojis?.has(emoji.id));
 
-  // if (bot.cache.guilds.get(guildId)?.emojis?.has(emoji.id)) {
+  // if (bot.guilds.get(guildId)?.emojis?.has(emoji.id)) {
   //   throw new Error("The emoji seemed to be deleted but it's still cached.");
   // }
 }
 
-export async function deleteEmojiWithReasonTest(bot: Bot, guildId: bigint, t: Deno.TestContext) {
+export async function deleteEmojiWithReasonTest(guildId: bigint) {
   await ifItFailsBlameWolf(bot, guildId);
 }
 
-export async function deleteEmojiWithoutReasonTest(bot: Bot, guildId: bigint, t: Deno.TestContext) {
+export async function deleteEmojiWithoutReasonTest(guildId: bigint) {
   await ifItFailsBlameWolf(bot, guildId, "with a reason");
 }
diff --git a/tests/helpers/emojis/editEmoji.ts b/tests/helpers/emojis/editEmoji.ts
index 95b0a7491..38b99c4de 100644
--- a/tests/helpers/emojis/editEmoji.ts
+++ b/tests/helpers/emojis/editEmoji.ts
@@ -2,6 +2,4 @@ import { Bot } from "../../../src/bot.ts";
 import { assertExists } from "../../deps.ts";
 import { delayUntil } from "../../utils.ts";
 
-export async function editEmojiTest(bot: Bot, guildId: bigint, t: Deno.TestContext) {
-  
-}
+export async function editEmojiTest(guildId: bigint) {}
diff --git a/tests/helpers/emojis/getEmoji.ts b/tests/helpers/emojis/getEmoji.ts
index 2bf498239..58fa842ce 100644
--- a/tests/helpers/emojis/getEmoji.ts
+++ b/tests/helpers/emojis/getEmoji.ts
@@ -2,7 +2,7 @@ import { Bot } from "../../../src/bot.ts";
 import { assertExists } from "../../deps.ts";
 import { delayUntil } from "../../utils.ts";
 
-export async function getEmojiTest(bot: Bot, guildId: bigint, t: Deno.TestContext) {
+export async function getEmojiTest(guildId: bigint) {
   const emoji = await bot.helpers.createEmoji(guildId, {
     name: "blamewolf",
     image: "https://cdn.discordapp.com/emojis/814955268123000832.png",
@@ -13,13 +13,13 @@ export async function getEmojiTest(bot: Bot, guildId: bigint, t: Deno.TestContex
   assertExists(emoji);
 
   // // Delay the execution to allow event to be processed
-  // await delayUntil(10000, async () => bot.cache.guilds.get(guildId)?.emojis?.has(emoji.id));
+  // await delayUntil(10000, async () => bot.guilds.get(guildId)?.emojis?.has(emoji.id));
 
-  // if (!bot.cache.guilds.get(guildId)?.emojis?.has(emoji.id)) {
+  // if (!bot.guilds.get(guildId)?.emojis?.has(emoji.id)) {
   //   throw new Error("The emoji seemed to be created but it was not cached.");
   // }
 
-  // bot.cache.guilds.get(guildId)?.emojis?.delete(emoji.id);
+  // bot.guilds.get(guildId)?.emojis?.delete(emoji.id);
 
   // const getEmoji = await bot.helpers.getEmoji(guildId, emoji.id, true);
 
@@ -27,9 +27,9 @@ export async function getEmojiTest(bot: Bot, guildId: bigint, t: Deno.TestContex
   // assertExists(getEmoji);
 
   // // Delay the execution to allow event to be processed
-  // await delayUntil(10000, async () => bot.cache.guilds.get(guildId)?.emojis?.has(emoji.id));
+  // await delayUntil(10000, async () => bot.guilds.get(guildId)?.emojis?.has(emoji.id));
 
-  // if (!bot.cache.guilds.get(guildId)?.emojis?.has(emoji.id)) {
+  // if (!bot.guilds.get(guildId)?.emojis?.has(emoji.id)) {
   //   throw new Error("The emoji didn't got added to cache after using the getEmoji function.");
   // }
 }
diff --git a/tests/helpers/emojis/getEmojis.ts b/tests/helpers/emojis/getEmojis.ts
index 6affd6184..062e0ce4e 100644
--- a/tests/helpers/emojis/getEmojis.ts
+++ b/tests/helpers/emojis/getEmojis.ts
@@ -2,7 +2,7 @@ import { Bot } from "../../../src/bot.ts";
 import { assertExists } from "../../deps.ts";
 import { delayUntil } from "../../utils.ts";
 
-export async function getEmojisTest(bot: Bot, guildId: bigint, t: Deno.TestContext) {
+export async function getEmojisTest(guildId: bigint) {
   const emoji = await bot.helpers.createEmoji(guildId, {
     name: "blamewolf",
     image: "https://cdn.discordapp.com/emojis/814955268123000832.png",
@@ -13,9 +13,9 @@ export async function getEmojisTest(bot: Bot, guildId: bigint, t: Deno.TestConte
   assertExists(emoji);
 
   // // Delay the execution to allow event to be processed
-  // await delayUntil(10000, async () => bot.cache.guilds.get(guildId)?.emojis?.has(emoji.id));
+  // await delayUntil(10000, async () => bot.guilds.get(guildId)?.emojis?.has(emoji.id));
 
-  // if (!bot.cache.guilds.get(guildId)?.emojis?.has(emoji.id)) {
+  // if (!bot.guilds.get(guildId)?.emojis?.has(emoji.id)) {
   //   throw new Error("The emoji seemed to be created but it was not cached.");
   // }
 
diff --git a/tests/helpers/guilds/createGuild.ts b/tests/helpers/guilds/createGuild.ts
index f9f31dd8b..f38e55679 100644
--- a/tests/helpers/guilds/createGuild.ts
+++ b/tests/helpers/guilds/createGuild.ts
@@ -1,10 +1,8 @@
-import { Bot } from "../../../src/bot.ts";
-import { CreateGuildChannel } from "../../../src/types/guilds/createGuildChannel.ts";
-import { ChannelTypes } from "../../../src/types/mod.ts";
 import { assertExists, assertEquals } from "../../deps.ts";
+import { bot } from "../../mod.ts";
 import { delayUntil } from "../../utils.ts";
 
-export async function createGuildTests(bot: Bot, t: Deno.TestContext) {
+export async function createGuildTests() {
   const guild = await bot.helpers.createGuild({
     name: "Isekai Maid Fake Server",
   });
@@ -13,9 +11,9 @@ export async function createGuildTests(bot: Bot, t: Deno.TestContext) {
   assertExists(guild);
 
   // Delay the execution to allow event to be processed
-  await delayUntil(10000, () => bot.cache.guilds.has(guild.id));
+  await delayUntil(10000, () => bot.guilds.has(guild.id));
 
-  if (!bot.cache.guilds.has(guild.id)) {
+  if (!bot.guilds.has(guild.id)) {
     throw new Error(`The guild seemed to be created but it was not cached.`);
   }
 }
diff --git a/tests/helpers/guilds/deleteGuild.ts b/tests/helpers/guilds/deleteGuild.ts
index 3ef7383e7..ab5ac70af 100644
--- a/tests/helpers/guilds/deleteGuild.ts
+++ b/tests/helpers/guilds/deleteGuild.ts
@@ -1,8 +1,8 @@
-import { Bot } from "../../../src/bot.ts";
-import { assertExists, assertEquals } from "../../deps.ts";
+import { assertExists } from "../../deps.ts";
+import { bot } from "../../mod.ts";
 import { delayUntil } from "../../utils.ts";
 
-export async function deleteGuildTests(bot: Bot, t: Deno.TestContext) {
+export async function deleteGuildTests() {
   const guild = await bot.helpers.createGuild({
     name: "Isekai Maid Fake Server",
   });
@@ -11,18 +11,18 @@ export async function deleteGuildTests(bot: Bot, t: Deno.TestContext) {
   assertExists(guild);
 
   // Delay the execution to allow event to be processed
-  await delayUntil(10000, () => bot.cache.guilds.has(guild.id));
+  await delayUntil(10000, () => bot.guilds.has(guild.id));
 
-  if (!bot.cache.guilds.has(guild.id)) {
+  if (!bot.guilds.has(guild.id)) {
     throw new Error(`The guild seemed to be created but it was not cached.`);
   }
 
   await bot.helpers.deleteGuild(guild.id);
 
   // Delay the execution to allow event to be processed
-  await delayUntil(10000, () => !bot.cache.guilds.has(guild.id));
+  await delayUntil(10000, () => !bot.guilds.has(guild.id));
 
-  if (bot.cache.guilds.has(guild.id)) {
+  if (bot.guilds.has(guild.id)) {
     throw new Error(`The guild seemed to be deleted but it's still cached.`);
   }
 }
diff --git a/tests/helpers/guilds/editGuild.ts b/tests/helpers/guilds/editGuild.ts
index 6eb562d95..10abc63da 100644
--- a/tests/helpers/guilds/editGuild.ts
+++ b/tests/helpers/guilds/editGuild.ts
@@ -1,8 +1,7 @@
-import { Bot } from "../../../src/bot.ts";
-import { assertExists, assertEquals } from "../../deps.ts";
-import { delayUntil } from "../../utils.ts";
+import { assertExists } from "../../deps.ts";
+import { bot } from "../../mod.ts";
 
-export async function editGuildTests(bot: Bot, guildId: bigint, t: Deno.TestContext) {
+export async function editGuildTests(guildId: bigint) {
   const guild = await bot.helpers.editGuild(
     guildId,
     {
@@ -15,9 +14,9 @@ export async function editGuildTests(bot: Bot, guildId: bigint, t: Deno.TestCont
   assertExists(guild);
 
   // Delay the execution to allow event to be processed
-  // await delayUntil(10000, async () => bot.cache.guilds.get(guild.id)?.name === "Discordeno Test 1.0");
+  // await delayUntil(10000, async () => bot.guilds.get(guild.id)?.name === "Discordeno Test 1.0");
 
-  // if (!bot.cache.guilds.has(guild.id)) {
+  // if (!bot.guilds.has(guild.id)) {
   // throw new Error(`The guild seemed to be edited but the cache didn't got updated.`);
   // }
 }
diff --git a/tests/helpers/guilds/getAuditLogs.ts b/tests/helpers/guilds/getAuditLogs.ts
index 4c5b3c942..c238ec818 100644
--- a/tests/helpers/guilds/getAuditLogs.ts
+++ b/tests/helpers/guilds/getAuditLogs.ts
@@ -1,7 +1,7 @@
-import { Bot } from "../../../src/bot.ts";
 import { assertExists } from "../../deps.ts";
+import { bot } from "../../mod.ts";
 
-export async function getAuditLogsTests(bot: Bot, guildId: bigint, t: Deno.TestContext) {
+export async function getAuditLogsTests(guildId: bigint) {
   const logs = await bot.helpers.getAuditLogs(guildId);
 
   // Assertions
diff --git a/tests/helpers/guilds/getAvailableVoiceRegions.ts b/tests/helpers/guilds/getAvailableVoiceRegions.ts
index d63fa61c1..84f00a8e3 100644
--- a/tests/helpers/guilds/getAvailableVoiceRegions.ts
+++ b/tests/helpers/guilds/getAvailableVoiceRegions.ts
@@ -1,7 +1,7 @@
-import { Bot } from "../../../src/bot.ts";
-import { assertExists, assertEquals } from "../../deps.ts";
+import { assertExists } from "../../deps.ts";
+import { bot } from "../../mod.ts";
 
-export async function getAvailableVoiceRegionsTests(bot: Bot, t: Deno.TestContext) {
+export async function getAvailableVoiceRegionsTests() {
   const regions = await bot.helpers.getAvailableVoiceRegions();
 
   // Assertions
diff --git a/tests/helpers/guilds/getBan.ts b/tests/helpers/guilds/getBan.ts
index c8f31f5f0..222035b55 100644
--- a/tests/helpers/guilds/getBan.ts
+++ b/tests/helpers/guilds/getBan.ts
@@ -1,8 +1,7 @@
-import { Bot } from "../../../src/bot.ts";
 import { assertExists, assertEquals } from "../../deps.ts";
-import { delayUntil } from "../../utils.ts";
+import { bot } from "../../mod.ts";
 
-export async function getBanTests(bot: Bot, guildId: bigint, t: Deno.TestContext) {
+export async function getBanTests(guildId: bigint) {
   await bot.helpers.banMember(guildId, 379643682984296448n);
 
   const fetchedBan = await bot.helpers.getBan(guildId, 379643682984296448n);
diff --git a/tests/helpers/guilds/getBans.ts b/tests/helpers/guilds/getBans.ts
index ac1ca7061..672a9e5f4 100644
--- a/tests/helpers/guilds/getBans.ts
+++ b/tests/helpers/guilds/getBans.ts
@@ -1,11 +1,7 @@
-import { Bot } from "../../../src/bot.ts";
-import { CreateGuildChannel } from "../../../src/types/guilds/createGuildChannel.ts";
-import { ChannelTypes } from "../../../src/types/mod.ts";
-import { assertExists, assertEquals } from "../../deps.ts";
-import { delayUntil } from "../../utils.ts";
-import { getAvailableVoiceRegions } from "../../../src/helpers/guilds/getAvailableVoiceRegions.ts";
+import { assertExists } from "../../deps.ts";
+import { bot } from "../../mod.ts";
 
-export async function getBansTests(bot: Bot, guildId: bigint, t: Deno.TestContext) {
+export async function getBansTests(guildId: bigint) {
   await bot.helpers.banMember(guildId, 416477607966670869n);
   await bot.helpers.banMember(guildId, 635383782576357407n);
 
diff --git a/tests/helpers/guilds/getGuild.ts b/tests/helpers/guilds/getGuild.ts
index e604ccb95..daa4acc83 100644
--- a/tests/helpers/guilds/getGuild.ts
+++ b/tests/helpers/guilds/getGuild.ts
@@ -1,8 +1,7 @@
-import { Bot } from "../../../src/bot.ts";
 import { assertExists, assertEquals } from "../../deps.ts";
-import { delayUntil } from "../../utils.ts";
+import { bot } from "../../mod.ts";
 
-export async function getGuildTests(bot: Bot, guildId: bigint, t: Deno.TestContext) {
+export async function getGuildTests(guildId: bigint) {
   const fetchedGuild = await bot.helpers.getGuild(guildId);
 
   // Assertions
diff --git a/tests/helpers/guilds/getVanityUrl.ts b/tests/helpers/guilds/getVanityUrl.ts
index ee80a5dab..dfd4cbabc 100644
--- a/tests/helpers/guilds/getVanityUrl.ts
+++ b/tests/helpers/guilds/getVanityUrl.ts
@@ -1,7 +1,7 @@
 import { Bot } from "../../../src/bot.ts";
 import { assertExists, assertEquals } from "../../deps.ts";
 
-export async function getVanityURLTests(bot: Bot, guildId: bigint, t: Deno.TestContext) {
+export async function getVanityURLTests(guildId: bigint) {
   // TODO: VANITY IS BROKEN ATM FROM DISCORDS SIDE
   return;
   // const fetchedVanityURL = await bot.helpers.getVanityURL(guildId);
diff --git a/tests/helpers/guilds/scheduledEvents/deleteScheduledEvent.ts b/tests/helpers/guilds/scheduledEvents/deleteScheduledEvent.ts
index 2d29f35b7..40ba5d230 100644
--- a/tests/helpers/guilds/scheduledEvents/deleteScheduledEvent.ts
+++ b/tests/helpers/guilds/scheduledEvents/deleteScheduledEvent.ts
@@ -1,6 +1,4 @@
 import { Bot } from "../../../../src/bot.ts";
 import { ScheduledEventEntityType, ScheduledEventPrivacyLevel } from "../../../../src/types/guilds/scheduledEvents.ts";
 
-export async function deleteScheduledEventTests(bot: Bot, guildId: bigint, t: Deno.TestContext) {
-  
-}
+export async function deleteScheduledEventTests(guildId: bigint) {}
diff --git a/tests/helpers/guilds/scheduledEvents/editScheduledEvent.ts b/tests/helpers/guilds/scheduledEvents/editScheduledEvent.ts
index 1530caf40..416af9591 100644
--- a/tests/helpers/guilds/scheduledEvents/editScheduledEvent.ts
+++ b/tests/helpers/guilds/scheduledEvents/editScheduledEvent.ts
@@ -1,9 +1,12 @@
-import { Bot } from "../../../../src/bot.ts";
 import { ChannelTypes } from "../../../../src/types/channels/channelTypes.ts";
-import { CreateScheduledEvent, ScheduledEventEntityType, ScheduledEventPrivacyLevel } from "../../../../src/types/guilds/scheduledEvents.ts";
+import {
+  ScheduledEventEntityType,
+  ScheduledEventPrivacyLevel,
+} from "../../../../src/types/guilds/scheduledEvents.ts";
 import { assertEquals } from "../../../deps.ts";
+import { bot } from "../../../mod.ts";
 
-export async function editScheduledEventTests(bot: Bot, guildId: bigint, t: Deno.TestContext) {
+export async function editScheduledEventTests(guildId: bigint) {
   const channel = await bot.helpers.createChannel(guildId, {
     name: "entity",
     type: ChannelTypes.GuildStageVoice,
diff --git a/tests/helpers/invites/createInvite.ts b/tests/helpers/invites/createInvite.ts
index f8864779e..b5f444e2a 100644
--- a/tests/helpers/invites/createInvite.ts
+++ b/tests/helpers/invites/createInvite.ts
@@ -1,7 +1,7 @@
 import { Bot } from "../../../src/bot.ts";
 import { assertExists } from "../../deps.ts";
 
-export async function createInviteTest(bot: Bot, channelId: bigint, t: Deno.TestContext) {
+export async function createInviteTest(channelId: bigint) {
   const invite = await bot.helpers.createInvite(channelId, {
     maxAge: 86400,
     maxUses: 0,
diff --git a/tests/helpers/invites/deleteInvite.ts b/tests/helpers/invites/deleteInvite.ts
index 8f0db9724..9c6a51746 100644
--- a/tests/helpers/invites/deleteInvite.ts
+++ b/tests/helpers/invites/deleteInvite.ts
@@ -1,7 +1,7 @@
 import { Bot } from "../../../src/bot.ts";
 import { assertExists } from "../../deps.ts";
 
-export async function deleteInviteTest(bot: Bot, channelId: bigint, t: Deno.TestContext) {
+export async function deleteInviteTest(channelId: bigint) {
   const invite = await bot.helpers.createInvite(channelId, {
     maxAge: 86400,
     maxUses: 0,
diff --git a/tests/helpers/invites/getChannelInvites.ts b/tests/helpers/invites/getChannelInvites.ts
index cb7f97db2..59dc44484 100644
--- a/tests/helpers/invites/getChannelInvites.ts
+++ b/tests/helpers/invites/getChannelInvites.ts
@@ -1,7 +1,7 @@
 import { Bot } from "../../../src/bot.ts";
 import { assertExists } from "../../deps.ts";
 
-export async function getChannelInvitesTest(bot: Bot, channelId: bigint, t: Deno.TestContext) {
+export async function getChannelInvitesTest(channelId: bigint) {
   const invite = await bot.helpers.createInvite(channelId, {
     maxAge: 86400,
     maxUses: 0,
diff --git a/tests/helpers/invites/getInvite.ts b/tests/helpers/invites/getInvite.ts
index b78854093..2242e5af2 100644
--- a/tests/helpers/invites/getInvite.ts
+++ b/tests/helpers/invites/getInvite.ts
@@ -1,7 +1,7 @@
 import { Bot } from "../../../src/bot.ts";
 import { assertEquals, assertExists } from "../../deps.ts";
 
-export async function getInviteTest(bot: Bot, channelId: bigint, t: Deno.TestContext) {
+export async function getInviteTest(channelId: bigint) {
   const invite = await bot.helpers.createInvite(channelId, {
     maxAge: 86400,
     maxUses: 0,
diff --git a/tests/helpers/members/fetchMembers.ts b/tests/helpers/members/fetchMembers.ts
index 1bf018a87..9900fd272 100644
--- a/tests/helpers/members/fetchMembers.ts
+++ b/tests/helpers/members/fetchMembers.ts
@@ -1,6 +1,4 @@
 import { Bot } from "../../../src/bot.ts";
 import { assertExists } from "../../deps.ts";
 
-export async function fetchSingleMemberTest(bot: Bot, guildId: bigint, t: Deno.TestContext) {
- 
-}
+export async function fetchSingleMemberTest(guildId: bigint) {}
diff --git a/tests/helpers/messages/deleteMessage.ts b/tests/helpers/messages/deleteMessage.ts
index cfd7a617d..a6a718e55 100644
--- a/tests/helpers/messages/deleteMessage.ts
+++ b/tests/helpers/messages/deleteMessage.ts
@@ -1,16 +1,16 @@
-import { Bot } from "../../../src/bot.ts";
 import { assertExists } from "../../deps.ts";
+import { bot } from "../../mod.ts";
 import { delayUntil } from "../../utils.ts";
 
-async function ifItFailsBlameWolf(bot: Bot, channelId: bigint, reason?: string) {
+async function ifItFailsBlameWolf(channelId: bigint, reason?: string) {
   const message = await bot.helpers.sendMessage(channelId, "Hello World!");
 
   // Assertions
   assertExists(message);
   // Delay the execution by to allow MESSAGE_CREATE event to be processed
-  await delayUntil(10000, () => bot.cache.messages.has(message.id));
+  await delayUntil(10000, () => bot.messages.has(message.id));
   // Make sure the message was created.
-  if (!bot.cache.messages.has(message.id)) {
+  if (!bot.messages.has(message.id)) {
     throw new Error("The message seemed to be sent but it was not cached. Reason: ${reason}");
   }
 
@@ -18,17 +18,17 @@ async function ifItFailsBlameWolf(bot: Bot, channelId: bigint, reason?: string)
   await bot.helpers.deleteMessage(channelId, message.id, reason);
 
   // Wait to give it time for MESSAGE_DELETE event
-  await delayUntil(10000, () => !bot.cache.messages.has(message.id));
+  await delayUntil(10000, () => !bot.messages.has(message.id));
   // Make sure it is gone from cache
-  if (bot.cache.messages.has(message.id)) {
+  if (bot.messages.has(message.id)) {
     throw new Error("The message should have been deleted but it is still in cache.");
   }
 }
 
-export async function deleteMessageWithoutReasonTest(bot: Bot, channelId: bigint, t: Deno.TestContext) {
-  await ifItFailsBlameWolf(bot, channelId);
+export async function deleteMessageWithoutReasonTest(channelId: bigint) {
+  await ifItFailsBlameWolf(channelId);
 }
 
-export async function deleteMessageWithReasonTest(bot: Bot, channelId: bigint, t: Deno.TestContext) {
-  await ifItFailsBlameWolf(bot, channelId, "with a reason");
+export async function deleteMessageWithReasonTest(channelId: bigint) {
+  await ifItFailsBlameWolf(channelId, "with a reason");
 }
diff --git a/tests/helpers/messages/deleteMessages.ts b/tests/helpers/messages/deleteMessages.ts
index 592417057..a285c6b5f 100644
--- a/tests/helpers/messages/deleteMessages.ts
+++ b/tests/helpers/messages/deleteMessages.ts
@@ -1,8 +1,8 @@
-import { Bot } from "../../../src/bot.ts";
 import { assertExists } from "../../deps.ts";
+import { bot } from "../../mod.ts";
 import { delayUntil } from "../../utils.ts";
 
-async function ifItFailsBlameWolf(bot: Bot, channelId: bigint, reason?: string) {
+async function ifItFailsBlameWolf(channelId: bigint, reason?: string) {
   const message = await bot.helpers.sendMessage(channelId, "Hello World!");
   const secondMessage = await bot.helpers.sendMessage(channelId, "Hello World 2!");
 
@@ -10,9 +10,9 @@ async function ifItFailsBlameWolf(bot: Bot, channelId: bigint, reason?: string)
   assertExists(message);
   assertExists(secondMessage);
   // Delay the execution by to allow MESSAGE_CREATE event to be processed
-  await delayUntil(10000, () => bot.cache.messages.has(message.id) && bot.cache.messages.has(secondMessage.id));
+  await delayUntil(10000, () => bot.messages.has(message.id) && bot.messages.has(secondMessage.id));
   // Make sure the message was created.
-  if (!bot.cache.messages.has(message.id) || !bot.cache.messages.has(secondMessage.id)) {
+  if (!bot.messages.has(message.id) || !bot.messages.has(secondMessage.id)) {
     throw new Error(`The message seemed to be sent but it was not cached. Reason: ${reason}`);
   }
 
@@ -20,17 +20,17 @@ async function ifItFailsBlameWolf(bot: Bot, channelId: bigint, reason?: string)
   await bot.helpers.deleteMessages(channelId, [message.id, secondMessage.id], reason);
 
   // Wait to give it time for MESSAGE_DELETE event
-  await delayUntil(10000, () => !bot.cache.messages.has(message.id) && !bot.cache.messages.has(secondMessage.id));
+  await delayUntil(10000, () => !bot.messages.has(message.id) && !bot.messages.has(secondMessage.id));
   // Make sure they are gone from cache
-  if (bot.cache.messages.has(message.id) || bot.cache.messages.has(secondMessage.id)) {
+  if (bot.messages.has(message.id) || bot.messages.has(secondMessage.id)) {
     throw new Error("The messages should have been deleted but they are still in cache.");
   }
 }
 
-export async function deleteMessagesWithoutReasonTest(bot: Bot, channelId: bigint, t: Deno.TestContext) {
-  await ifItFailsBlameWolf(bot, channelId);
+export async function deleteMessagesWithoutReasonTest(channelId: bigint) {
+  await ifItFailsBlameWolf(channelId);
 }
 
-export async function deleteMessagesWithReasonTest(bot: Bot, channelId: bigint, t: Deno.TestContext) {
-  await ifItFailsBlameWolf(bot, channelId, "with a reason");
+export async function deleteMessagesWithReasonTest(channelId: bigint) {
+  await ifItFailsBlameWolf(channelId, "with a reason");
 }
diff --git a/tests/helpers/messages/editMessage.ts b/tests/helpers/messages/editMessage.ts
index 137b79c44..91100fb8e 100644
--- a/tests/helpers/messages/editMessage.ts
+++ b/tests/helpers/messages/editMessage.ts
@@ -1,16 +1,16 @@
-import { Bot } from "../../../src/bot.ts";
 import { assertExists } from "../../deps.ts";
+import { bot } from "../../mod.ts";
 import { delayUntil } from "../../utils.ts";
 
-export async function editMessageTest(bot: Bot, channelId: bigint, t: Deno.TestContext) {
+export async function editMessageTest(channelId: bigint) {
   const message = await bot.helpers.sendMessage(channelId, "Hello World!");
 
   // Assertions
   assertExists(message);
   // Delay the execution by to allow MESSAGE_CREATE event to be processed
-  await delayUntil(10000, () => bot.cache.messages.has(message.id));
+  await delayUntil(10000, () => bot.messages.has(message.id));
   // Make sure the message was created.
-  if (!bot.cache.messages.has(message.id)) {
+  if (!bot.messages.has(message.id)) {
     throw new Error("The message seemed to be sent but it was not cached. Reason: ${reason}");
   }
 
@@ -18,9 +18,9 @@ export async function editMessageTest(bot: Bot, channelId: bigint, t: Deno.TestC
   await bot.helpers.editMessage(channelId, message.id, "Goodbye World!");
 
   // Wait to give it time for MESSAGE_UPDATE event
-  // await delayUntil(10000, async () => bot.cache.messages.get(message.id)?.content === "Goodbye World!");
+  // await delayUntil(10000, async () => bot.messages.get(message.id)?.content === "Goodbye World!");
   // Make sure it was edited
-  // if (bot.cache.messages.get(message.id)?.content !== "Goodbye World!") {
+  // if (bot.messages.get(message.id)?.content !== "Goodbye World!") {
   // throw new Error("The message should have been edited but it was not.");
   // }
 }
diff --git a/tests/helpers/messages/getMessage.ts b/tests/helpers/messages/getMessage.ts
index 58c037322..578cc3982 100644
--- a/tests/helpers/messages/getMessage.ts
+++ b/tests/helpers/messages/getMessage.ts
@@ -1,16 +1,17 @@
 import { Bot } from "../../../src/bot.ts";
 import { assertEquals, assertExists } from "../../deps.ts";
+import { bot } from "../../mod.ts";
 import { delayUntil } from "../../utils.ts";
 
-export async function getMessageTest(bot: Bot, channelId: bigint, t: Deno.TestContext) {
+export async function getMessageTest(channelId: bigint) {
   const message = await bot.helpers.sendMessage(channelId, "Hello World!");
 
   // Assertions
   assertExists(message);
   // Delay the execution by to allow MESSAGE_CREATE event to be processed
-  await delayUntil(10000, () => bot.cache.messages.has(message.id));
+  await delayUntil(10000, () => bot.messages.has(message.id));
   // Make sure the message was created.
-  if (!bot.cache.messages.has(message.id)) {
+  if (!bot.messages.has(message.id)) {
     throw new Error("The message seemed to be sent but it was not cached. Reason: ${reason}");
   }
 
diff --git a/tests/helpers/messages/getMessages.ts b/tests/helpers/messages/getMessages.ts
index 187a044a3..c719eb271 100644
--- a/tests/helpers/messages/getMessages.ts
+++ b/tests/helpers/messages/getMessages.ts
@@ -1,8 +1,8 @@
-import { Bot } from "../../../src/bot.ts";
 import { assertEquals, assertExists } from "../../deps.ts";
+import { bot } from "../../mod.ts";
 import { delayUntil } from "../../utils.ts";
 
-export async function getMessagesTest(bot: Bot, channelId: bigint, t: Deno.TestContext) {
+export async function getMessagesTest(channelId: bigint) {
   const message = await bot.helpers.sendMessage(channelId, "Hello World!");
   const secondMessage = await bot.helpers.sendMessage(channelId, "Hello World 2!");
   const thirdMessage = await bot.helpers.sendMessage(channelId, "Hello World 3!");
@@ -14,17 +14,10 @@ export async function getMessagesTest(bot: Bot, channelId: bigint, t: Deno.TestC
   // Delay the execution by to allow MESSAGE_CREATE event to be processed
   await delayUntil(
     10000,
-    () =>
-      bot.cache.messages.has(message.id) &&
-      bot.cache.messages.has(secondMessage.id) &&
-      bot.cache.messages.has(thirdMessage.id)
+    () => bot.messages.has(message.id) && bot.messages.has(secondMessage.id) && bot.messages.has(thirdMessage.id)
   );
   // Make sure the messages was created.
-  if (
-    !bot.cache.messages.has(message.id) ||
-    !bot.cache.messages.has(secondMessage.id) ||
-    !bot.cache.messages.has(thirdMessage.id)
-  ) {
+  if (!bot.messages.has(message.id) || !bot.messages.has(secondMessage.id) || !bot.messages.has(thirdMessage.id)) {
     throw new Error("The message seemed to be sent but it was not cached.");
   }
 
diff --git a/tests/helpers/messages/pin.ts b/tests/helpers/messages/pin.ts
index a3bdec9de..dfafc6db5 100644
--- a/tests/helpers/messages/pin.ts
+++ b/tests/helpers/messages/pin.ts
@@ -1,11 +1,11 @@
-import { Bot } from "../../../src/bot.ts";
 import { assertEquals } from "../../deps.ts";
+import { bot } from "../../mod.ts";
 import { delayUntil } from "../../utils.ts";
 
-export async function pinMessageTests(bot: Bot, channelId: bigint, messageId: bigint, t: Deno.TestContext) {
+export async function pinMessageTests(channelId: bigint, messageId: bigint) {
   let pinned = false;
 
-  bot.events.channelPinsUpdate = function (bot, payload) {
+  bot.events.channelPinsUpdate = function (_, payload) {
     if (payload.channelId === channelId) pinned = !pinned;
   };
 
diff --git a/tests/helpers/messages/reactions.ts b/tests/helpers/messages/reactions.ts
index 16e0585d0..c891f96cd 100644
--- a/tests/helpers/messages/reactions.ts
+++ b/tests/helpers/messages/reactions.ts
@@ -1,15 +1,14 @@
 import { Bot } from "../../../src/bot.ts";
 import { assertEquals, assertExists } from "../../deps.ts";
+import { bot } from "../../mod.ts";
 import { delayUntil } from "../../utils.ts";
 
 const reactionCounters = new Map<bigint, number>();
 
 export async function addReactionTest(
-  bot: Bot,
   guildId: bigint,
   channelId: bigint,
-  options: { custom: boolean; single: boolean; ordered: boolean },
-  t: Deno.TestContext
+  options: { custom: boolean; single: boolean; ordered: boolean }
 ) {
   const message = await bot.helpers.sendMessage(channelId, "Hello World!");
 
@@ -17,9 +16,9 @@ export async function addReactionTest(
   assertExists(message);
 
   // Delay the execution to allow event to be processed
-  await delayUntil(10000, () => bot.cache.messages.has(message.id));
+  await delayUntil(10000, () => bot.messages.has(message.id));
 
-  if (!bot.cache.messages.has(message.id)) {
+  if (!bot.messages.has(message.id)) {
     throw new Error("The message seemed to be sent but it was not cached.");
   }
 
@@ -76,16 +75,16 @@ export async function addReactionTest(
   assertEquals(reactionCounters.get(message.id), options.single ? 1 : emojiIds.length);
 }
 
-export async function removeAllReactionTests(bot: Bot, channelId: bigint, t: Deno.TestContext) {
+export async function removeAllReactionTests(channelId: bigint) {
   const message = await bot.helpers.sendMessage(channelId, "Hello World!");
 
   // Assertions
   assertExists(message);
 
   // Delay the execution to allow event to be processed
-  await delayUntil(10000, () => bot.cache.messages.has(message.id));
+  await delayUntil(10000, () => bot.messages.has(message.id));
 
-  if (!bot.cache.messages.has(message.id)) {
+  if (!bot.messages.has(message.id)) {
     throw new Error("The message seemed to be sent but it was not cached.");
   }
 
@@ -117,16 +116,16 @@ export async function removeAllReactionTests(bot: Bot, channelId: bigint, t: Den
   assertEquals(reactionCounters.get(message.id), 0);
 }
 
-export async function removeReactionTest(bot: Bot, channelId: bigint, t: Deno.TestContext) {
+export async function removeReactionTest(channelId: bigint) {
   const message = await bot.helpers.sendMessage(channelId, "Hello World!");
 
   // Assertions
   assertExists(message);
 
   // Delay the execution to allow event to be processed
-  await delayUntil(10000, () => bot.cache.messages.has(message.id));
+  await delayUntil(10000, () => bot.messages.has(message.id));
 
-  if (!bot.cache.messages.has(message.id)) {
+  if (!bot.messages.has(message.id)) {
     throw new Error("The message seemed to be sent but it was not cached.");
   }
 
@@ -159,22 +158,22 @@ export async function removeReactionTest(bot: Bot, channelId: bigint, t: Deno.Te
   assertEquals(reactionCounters.get(message.id), 2);
 }
 
-export async function removeReactionEmojiTest(bot: Bot, channelId: bigint, t: Deno.TestContext) {
+export async function removeReactionEmojiTest(channelId: bigint) {
   const message = await bot.helpers.sendMessage(channelId, "Hello World!");
 
   // Assertions
   assertExists(message);
 
   // Delay the execution to allow event to be processed
-  await delayUntil(10000, () => bot.cache.messages.has(message.id));
+  await delayUntil(10000, () => bot.messages.has(message.id));
 
-  if (!bot.cache.messages.has(message.id)) {
+  if (!bot.messages.has(message.id)) {
     throw new Error("The message seemed to be sent but it was not cached.");
   }
 
   reactionCounters.set(message.id, 0);
 
-  bot.events.reactionAdd
+  bot.events.reactionAdd;
 
   bot.events.reactionRemoveEmoji = function (bot, payload) {
     reactionCounters.set(payload.messageId, 0);
diff --git a/tests/helpers/messages/sendMessage.ts b/tests/helpers/messages/sendMessage.ts
index 8035aeff6..05792e0c4 100644
--- a/tests/helpers/messages/sendMessage.ts
+++ b/tests/helpers/messages/sendMessage.ts
@@ -1,28 +1,28 @@
-import { Bot } from "../../../src/bot.ts";
 import { assertExists } from "../../deps.ts";
 import { delayUntil } from "../../utils.ts";
 import { CreateMessage } from "../../../src/types/messages/createMessage.ts";
 import { MessageComponentTypes } from "../../../src/types/messages/components/messageComponentTypes.ts";
 import { ButtonStyles } from "../../../src/types/messages/components/buttonStyles.ts";
+import { bot } from "../../mod.ts";
 
-async function ifItFailsBlameWolf(bot: Bot, channelId: bigint, content: string | CreateMessage) {
+async function ifItFailsBlameWolf(channelId: bigint, content: string | CreateMessage) {
   const message = await bot.helpers.sendMessage(channelId, content);
   // Assertions
   assertExists(message);
   // Delay the execution by to allow MESSAGE_CREATE event to be processed
-  await delayUntil(10000, () => bot.cache.messages.has(message.id));
+  await delayUntil(10000, () => bot.messages.has(message.id));
   // Make sure the message was created.
-  if (!bot.cache.messages.has(message.id)) {
+  if (!bot.messages.has(message.id)) {
     throw new Error("The message seemed to be sent but it was not cached.");
   }
 }
 
-export async function sendMessageWithTextTest(bot: Bot, channelId: bigint, t: Deno.TestContext) {
-  await ifItFailsBlameWolf(bot, channelId, "Hello World!");
+export async function sendMessageWithTextTest(channelId: bigint) {
+  await ifItFailsBlameWolf(channelId, "Hello World!");
 }
 
-export async function sendMessageWithComponents(bot: Bot, channelId: bigint, t: Deno.TestContext) {
-  await ifItFailsBlameWolf(bot, channelId, {
+export async function sendMessageWithComponents(channelId: bigint) {
+  await ifItFailsBlameWolf(channelId, {
     content: "Hello World!",
     components: [
       {
@@ -57,8 +57,8 @@ export async function sendMessageWithComponents(bot: Bot, channelId: bigint, t:
   });
 }
 
-export async function sendMessageWithEmbedsTest(bot: Bot, channelId: bigint, t: Deno.TestContext) {
-  await ifItFailsBlameWolf(bot, channelId, {
+export async function sendMessageWithEmbedsTest(channelId: bigint) {
+  await ifItFailsBlameWolf(channelId, {
     embeds: [
       {
         title: "Hello World",
diff --git a/tests/helpers/misc/user.ts b/tests/helpers/misc/user.ts
index 1937bd024..f66dc2c3a 100644
--- a/tests/helpers/misc/user.ts
+++ b/tests/helpers/misc/user.ts
@@ -1,6 +1,6 @@
 import { Bot } from "../../../src/bot.ts";
 import { assertExists } from "../../deps.ts";
 
-export async function getUserTests(bot: Bot, t: Deno.TestContext) {
+export async function getUserTests() {
   
 }
diff --git a/tests/helpers/roles/createRole.ts b/tests/helpers/roles/createRole.ts
index 297da9370..f38ab2600 100644
--- a/tests/helpers/roles/createRole.ts
+++ b/tests/helpers/roles/createRole.ts
@@ -1,20 +1,14 @@
-import { Bot } from "../../../src/bot.ts";
-import { Cache } from "../../../src/cache.ts";
 import { assertExists } from "../../deps.ts";
+import { bot } from "../../mod.ts";
 import { delayUntil } from "../../utils.ts";
 
-export async function createRoleTests(
-  bot: Bot<Cache>,
-  guildId: bigint,
-  options: { reason?: string },
-  t: Deno.TestContext
-) {
+export async function createRoleTests(guildId: bigint, options: { reason?: string }) {
   const role = await bot.helpers.createRole(guildId, { name: "hoti" }, options.reason);
 
   assertExists(role);
 
   // Delay the execution to allow event to be processed
-  await delayUntil(10000, () => bot.cache.guilds.get(guildId)?.roles.has(role.id));
+  await delayUntil(10000, () => bot.guilds.get(guildId)?.roles.has(role.id));
 
-  assertExists(bot.cache.guilds.get(guildId)?.roles.has(role.id));
+  assertExists(bot.guilds.get(guildId)?.roles.has(role.id));
 }
diff --git a/tests/helpers/roles/deleteRole.ts b/tests/helpers/roles/deleteRole.ts
index fb47054cc..dc8b92c37 100644
--- a/tests/helpers/roles/deleteRole.ts
+++ b/tests/helpers/roles/deleteRole.ts
@@ -1,29 +1,23 @@
 import { Bot } from "../../../src/bot.ts";
-import { Cache } from "../../../src/cache.ts";
 import { assertExists } from "../../deps.ts";
 import { delayUntil } from "../../utils.ts";
 
-export async function deleteRoleTests(
-  bot: Bot<Cache>,
-  guildId: bigint,
-  options: { reason?: string },
-  t: Deno.TestContext
-) {
+export async function deleteRoleTests(bot: Bot, guildId: bigint, options: { reason?: string }, t: Deno.TestContext) {
   const role = await bot.helpers.createRole(guildId, { name: "hoti" }, options.reason);
 
   assertExists(role);
 
   // Delay the execution to allow event to be processed
-  await delayUntil(10000, () => bot.cache.guilds.get(guildId)?.roles.has(role.id));
+  await delayUntil(10000, () => bot.guilds.get(guildId)?.roles.has(role.id));
 
-  assertExists(bot.cache.guilds.get(guildId)?.roles.has(role.id));
+  assertExists(bot.guilds.get(guildId)?.roles.has(role.id));
 
   await bot.helpers.deleteRole(guildId, role.id);
 
   // Delay the execution to allow event to be processed
-  await delayUntil(10000, () => !bot.cache.guilds.get(guildId)?.roles.has(role.id));
+  await delayUntil(10000, () => !bot.guilds.get(guildId)?.roles.has(role.id));
 
-  if (bot.cache.guilds.get(guildId)?.roles.has(role.id)) {
+  if (bot.guilds.get(guildId)?.roles.has(role.id)) {
     throw new Error(`The role should have been deleted but it is still in cache.`);
   }
 }
diff --git a/tests/helpers/roles/editRole.ts b/tests/helpers/roles/editRole.ts
index d0f3c5d6c..85044631d 100644
--- a/tests/helpers/roles/editRole.ts
+++ b/tests/helpers/roles/editRole.ts
@@ -1,9 +1,8 @@
 import { Bot } from "../../../src/bot.ts";
-import { Cache } from "../../../src/cache.ts";
 import { assertEquals, assertExists } from "../../deps.ts";
 import { delayUntil } from "../../utils.ts";
 
-export async function editRoleTests(bot: Bot<Cache>, guildId: bigint, t: Deno.TestContext) {
+export async function editRoleTests(guildId: bigint) {
   const role = await bot.helpers.createRole(guildId, {
     name: "hoti",
   });
@@ -11,9 +10,9 @@ export async function editRoleTests(bot: Bot<Cache>, guildId: bigint, t: Deno.Te
   assertExists(role);
 
   // Delay the execution to allow event to be processed
-  await delayUntil(10000, () => bot.cache.guilds.get(guildId)?.roles.has(role.id));
+  await delayUntil(10000, () => bot.guilds.get(guildId)?.roles.has(role.id));
 
-  if (!bot.cache.guilds.get(guildId)?.roles.has(role.id)) {
+  if (!bot.guilds.get(guildId)?.roles.has(role.id)) {
     throw new Error(`The role seemed to be created but it was not cached.`);
   }
 
@@ -22,7 +21,7 @@ export async function editRoleTests(bot: Bot<Cache>, guildId: bigint, t: Deno.Te
   });
 
   // Delay the execution to allow event to be processed
-  await delayUntil(10000, () => bot.cache.guilds.get(guildId)?.roles.get(role.id)?.name === "#rememberAyntee");
+  await delayUntil(10000, () => bot.guilds.get(guildId)?.roles.get(role.id)?.name === "#rememberAyntee");
 
-  assertEquals(bot.cache.guilds.get(guildId)?.roles.get(role.id)?.name === "#rememberAyntee", true);
+  assertEquals(bot.guilds.get(guildId)?.roles.get(role.id)?.name === "#rememberAyntee", true);
 }
diff --git a/tests/helpers/roles/getRoles.ts b/tests/helpers/roles/getRoles.ts
index abe1d77fd..edb381500 100644
--- a/tests/helpers/roles/getRoles.ts
+++ b/tests/helpers/roles/getRoles.ts
@@ -1,9 +1,8 @@
 import { Bot } from "../../../src/bot.ts";
-import { Cache } from "../../../src/cache.ts";
 import { assertEquals } from "../../deps.ts";
 
-export async function getRolesTest(bot: Bot<Cache>, guildId: bigint, t: Deno.TestContext) {
+export async function getRolesTest(guildId: bigint) {
   const roles = await bot.helpers.getRoles(guildId);
 
-  assertEquals(bot.cache.guilds.get(guildId)?.roles.size, roles.size);
+  assertEquals(bot.guilds.get(guildId)?.roles.size, roles.size);
 }
diff --git a/tests/helpers/roles/roleChanges.ts b/tests/helpers/roles/roleChanges.ts
index 85111936b..affa2e511 100644
--- a/tests/helpers/roles/roleChanges.ts
+++ b/tests/helpers/roles/roleChanges.ts
@@ -1,11 +1,10 @@
 import { Bot } from "../../../src/bot.ts";
-import { Cache } from "../../../src/cache.ts";
 import { assertEquals, assertExists } from "../../deps.ts";
 import { delayUntil } from "../../utils.ts";
 
 const roleChanges = new Map<bigint, bigint[]>();
 
-export async function addRoleTest(bot: Bot<Cache>, guildId: bigint, options: { reason?: string }, t: Deno.TestContext) {
+export async function addRoleTest(bot: Bot, guildId: bigint, options: { reason?: string }, t: Deno.TestContext) {
   const role = await bot.helpers.createRole(guildId, {
     name: "hoti",
   });
@@ -13,9 +12,9 @@ export async function addRoleTest(bot: Bot<Cache>, guildId: bigint, options: { r
   assertExists(role);
 
   // Delay the execution to allow event to be processed
-  await delayUntil(10000, () => bot.cache.guilds.get(guildId)?.roles.has(role.id));
+  await delayUntil(10000, () => bot.guilds.get(guildId)?.roles.has(role.id));
 
-  assertExists(bot.cache.guilds.get(guildId)?.roles.has(role.id));
+  assertExists(bot.guilds.get(guildId)?.roles.has(role.id));
 
   bot.events.guildMemberUpdate = function (bot, member, user) {
     roleChanges.set(user.id, member.roles);
@@ -29,11 +28,4 @@ export async function addRoleTest(bot: Bot<Cache>, guildId: bigint, options: { r
   assertEquals(roleChanges.get(bot.id)?.includes(role.id), true);
 }
 
-export async function removeRoleTest(
-  bot: Bot<Cache>,
-  guildId: bigint,
-  options: { reason?: string },
-  t: Deno.TestContext
-) {
-  
-}
+export async function removeRoleTest(bot: Bot, guildId: bigint, options: { reason?: string }, t: Deno.TestContext) {}
diff --git a/tests/members/ban.ts b/tests/members/ban.ts
index 59deb143d..c745a8850 100644
--- a/tests/members/ban.ts
+++ b/tests/members/ban.ts
@@ -66,7 +66,7 @@ Deno.test({
         });
     
         // Assertions
-        assertExists(bot.cache.members.get(BigInt(`${bot.id}${guild.id}`)));
+        assertExists(bot.members.get(BigInt(`${bot.id}${guild.id}`)));
       },
     });
     
diff --git a/tests/members/editBotNickname.ts b/tests/members/editBotNickname.ts
new file mode 100644
index 000000000..7efd93edd
--- /dev/null
+++ b/tests/members/editBotNickname.ts
@@ -0,0 +1,8 @@
+import { assertEquals } from "../deps.ts";
+import { bot, guild } from "../mod.ts";
+
+Deno.test("[misc] edit a bot's nickname", async function () {
+  const nick = "lts20050703";
+  const nickname = await bot.helpers.editBotNickname(guild.id, { nick });
+  assertEquals(nickname, nick);
+});
diff --git a/tests/members/getDmChannel.ts b/tests/members/getDmChannel.ts
index f1809db14..fd6e4b232 100644
--- a/tests/members/getDmChannel.ts
+++ b/tests/members/getDmChannel.ts
@@ -1,7 +1,7 @@
 import { bot } from "../mod.ts";
 
 Deno.test("[member] get dm channel and send a message", async () => {
-  // Skillz ID
-  const channel = await bot.helpers.getDmChannel(130136895395987456n);
+  // Itoh Alt ID
+  const channel = await bot.helpers.getDmChannel(750661528360845322n);
   await bot.helpers.sendMessage(channel.id, "https://i.imgur.com/doG55NR.png");
 });
diff --git a/tests/messages/reactions.ts b/tests/messages/reactions.ts
new file mode 100644
index 000000000..7bd762fdd
--- /dev/null
+++ b/tests/messages/reactions.ts
@@ -0,0 +1,262 @@
+import { Bot } from "../../mod.ts";
+import { reactionCounters } from "../constants.ts";
+import { assertExists, assertEquals } from "../deps.ts";
+// import {
+//   addReactionTest,
+//   removeReactionTest,
+//   removeAllReactionTests,
+//   removeReactionEmojiTest,
+// } from "../helpers/messages/reactions.ts";
+import { bot, guild, channel } from "../mod.ts";
+import { delayUntil } from "../utils.ts";
+
+export async function addReactionTest(
+  guildId: bigint,
+  channelId: bigint,
+  options: { custom: boolean; single: boolean; ordered: boolean },
+) {
+  const message = await bot.helpers.sendMessage(channelId, "Hello World!");
+
+  // Assertions
+  assertExists(message);
+
+  // Delay the execution to allow event to be processed
+  await delayUntil(10000, () => bot.messages.has(message.id));
+
+  if (!bot.messages.has(message.id)) {
+    throw new Error("The message seemed to be sent but it was not cached.");
+  }
+
+  let emojiId = "❤";
+  let emojiIds = ["❤", "😃"];
+
+  if (options.custom) {
+    if (options.single) {
+      emojiId = `<:blamewolf:${
+        (
+          await bot.helpers.createEmoji(guildId, {
+            name: "blamewolf",
+            image: "https://cdn.discordapp.com/emojis/814955268123000832.png",
+            // roles: [],
+          })
+        ).id
+      }>`;
+    } else {
+      emojiIds = [
+        `<:blamewolf:${
+          (
+            await bot.helpers.createEmoji(guildId, {
+              name: "blamewolf",
+              image: "https://cdn.discordapp.com/emojis/814955268123000832.png",
+              // roles: [],
+            })
+          ).id
+        }>`,
+        `<:blamewolf2:${
+          (
+            await bot.helpers.createEmoji(guildId, {
+              name: "blamewolf2",
+              image: "https://cdn.discordapp.com/emojis/814955268123000832.png",
+              // roles: [],
+            })
+          ).id
+        }>`,
+      ];
+    }
+  }
+
+  reactionCounters.set(message.id, 0);
+
+  bot.events.reactionAdd = function (bot, payload) {
+    const current = reactionCounters.get(payload.messageId) || 0;
+    reactionCounters.set(payload.messageId, current + 1);
+  };
+
+  if (options.single) await bot.helpers.addReaction(message.channelId, message.id, emojiId);
+  else await bot.helpers.addReactions(message.channelId, message.id, emojiIds, options.ordered);
+
+  await delayUntil(10000, () => reactionCounters.get(message.id) === (options.single ? 1 : emojiIds.length));
+
+  assertEquals(reactionCounters.get(message.id), options.single ? 1 : emojiIds.length);
+}
+
+export async function removeAllReactionTests(channelId: bigint) {
+  const message = await bot.helpers.sendMessage(channelId, "Hello World!");
+
+  // Assertions
+  assertExists(message);
+
+  // Delay the execution to allow event to be processed
+  await delayUntil(10000, () => bot.messages.has(message.id));
+
+  if (!bot.messages.has(message.id)) {
+    throw new Error("The message seemed to be sent but it was not cached.");
+  }
+
+  reactionCounters.set(message.id, 0);
+
+  bot.events.reactionRemoveAll = function (_, payload) {
+    reactionCounters.set(payload.messageId, 0);
+  };
+
+  bot.events.reactionAdd = function (_, payload) {
+    const current = reactionCounters.get(payload.messageId) || 0;
+    reactionCounters.set(payload.messageId, current + 1);
+  };
+
+  // Add reactions to the message
+  await bot.helpers.addReactions(message.channelId, message.id, ["❤", "😃", "🤫"]);
+  // Delay the execution to allow event to be processed
+  await delayUntil(10000, () => reactionCounters.get(message.id) === 3);
+
+  // Be sure that the message has the reactions
+  assertEquals(reactionCounters.get(message.id), 3);
+
+  await bot.helpers.removeAllReactions(message.channelId, message.id);
+
+  // Delay the execution to allow event to be processed
+  await delayUntil(10000, () => reactionCounters.get(message.id) === 0);
+
+  // Check if the reactions has been deleted
+  assertEquals(reactionCounters.get(message.id), 0);
+}
+
+export async function removeReactionTest(channelId: bigint) {
+  const message = await bot.helpers.sendMessage(channelId, "Hello World!");
+
+  // Assertions
+  assertExists(message);
+
+  // Delay the execution to allow event to be processed
+  await delayUntil(10000, () => bot.messages.has(message.id));
+
+  if (!bot.messages.has(message.id)) {
+    throw new Error("The message seemed to be sent but it was not cached.");
+  }
+
+  reactionCounters.set(message.id, 0);
+
+  bot.events.reactionRemove = function (bot, payload) {
+    const current = reactionCounters.get(message.id);
+    reactionCounters.set(payload.messageId, (current || 0) - 1);
+  };
+
+  bot.events.reactionAdd = function (bot, payload) {
+    const current = reactionCounters.get(payload.messageId) || 0;
+    reactionCounters.set(payload.messageId, current + 1);
+  };
+
+  // Add reactions to the message
+  await bot.helpers.addReactions(message.channelId, message.id, ["❤", "😃", "🤫"]);
+  // Delay the execution to allow event to be processed
+  await delayUntil(10000, () => reactionCounters.get(message.id) === 3);
+
+  // Be sure that the message has the reactions
+  assertEquals(reactionCounters.get(message.id), 3);
+
+  await bot.helpers.removeReaction(message.channelId, message.id, "😃");
+
+  // Delay the execution to allow event to be processed
+  await delayUntil(10000, () => reactionCounters.get(message.id) === 2);
+
+  // Check if the reactions has been deleted
+  assertEquals(reactionCounters.get(message.id), 2);
+}
+
+export async function removeReactionEmojiTest(channelId: bigint) {
+  const message = await bot.helpers.sendMessage(channelId, "Hello World!");
+
+  // Assertions
+  assertExists(message);
+
+  // Delay the execution to allow event to be processed
+  await delayUntil(10000, () => bot.messages.has(message.id));
+
+  if (!bot.messages.has(message.id)) {
+    throw new Error("The message seemed to be sent but it was not cached.");
+  }
+
+  reactionCounters.set(message.id, 0);
+
+  bot.events.reactionAdd;
+
+  bot.events.reactionRemoveEmoji = function (bot, payload) {
+    reactionCounters.set(payload.messageId, 0);
+  };
+
+  bot.events.reactionAdd = function (bot, payload) {
+    const current = reactionCounters.get(payload.messageId) || 0;
+    reactionCounters.set(payload.messageId, current + 1);
+  };
+
+  // Add reactions to the message
+  await bot.helpers.addReactions(message.channelId, message.id, ["❤", "😃"]);
+  // Delay the execution to allow event to be processed
+  await delayUntil(10000, () => reactionCounters.get(message.id) === 2);
+
+  // Be sure that the message has the reactions
+  assertEquals(reactionCounters.get(message.id), 2);
+
+  await bot.helpers.removeReactionEmoji(message.channelId, message.id, "😃");
+
+  // Delay the execution to allow event to be processed
+  await delayUntil(10000, () => reactionCounters.get(message.id) === 0);
+
+  // Check if the reactions has been deleted
+  assertEquals(reactionCounters.get(message.id), 0);
+}
+
+Deno.test({
+  name: "[message] add a reaction",
+  fn: async (t) => {
+    await addReactionTest(guild.id, channel.id, { custom: false, single: true, ordered: false });
+  },
+});
+Deno.test({
+  name: "[message] add a custom reaction",
+  fn: async (t) => {
+    await addReactionTest(guild.id, channel.id, { custom: true, single: true, ordered: false });
+  },
+});
+Deno.test({
+  name: "[message] add multiple reactions",
+  fn: async (t) => {
+    await addReactionTest(guild.id, channel.id, { custom: false, single: false, ordered: false });
+  },
+});
+Deno.test({
+  name: "[message] add multiple custom reactions",
+  fn: async (t) => {
+    await addReactionTest(guild.id, channel.id, { custom: true, single: false, ordered: false });
+  },
+});
+Deno.test({
+  name: "[message] add multiple reactions in order",
+  fn: async (t) => {
+    await addReactionTest(guild.id, channel.id, { custom: false, single: false, ordered: true });
+  },
+});
+Deno.test({
+  name: "[message] add multiple custom reactions in order",
+  fn: async (t) => {
+    await addReactionTest(guild.id, channel.id, { custom: true, single: false, ordered: true });
+  },
+});
+Deno.test({
+  name: "[message] remove a reaction.",
+  fn: async (t) => {
+    await removeReactionTest(channel.id);
+  },
+});
+Deno.test({
+  name: "[message] remove all reactions.",
+  fn: async (t) => {
+    await removeAllReactionTests(channel.id);
+  },
+});
+Deno.test({
+  name: "[message] remove emoji reactions.",
+  fn: async (t) => {
+    await removeReactionEmojiTest(channel.id);
+  },
+});
diff --git a/tests/misc/editBotStatus.ts b/tests/misc/editBotStatus.ts
new file mode 100644
index 000000000..c066fc033
--- /dev/null
+++ b/tests/misc/editBotStatus.ts
@@ -0,0 +1,24 @@
+import { assertExists } from "../deps.ts";
+import { bot } from "../mod.ts";
+import { ActivityTypes } from "../../src/types/activity/activityTypes.ts";
+import { delayUntil } from "../utils.ts";
+
+Deno.test("[misc] edit the bot's status", async function () {
+  bot.events.presenceUpdate = function (_bot, presense, _oldPresense) {
+    console.log('in pu')
+    console.log('in pu')
+    assertExists(presense);
+  };
+
+  bot.events.botUpdate = function (bot, user) {
+    console.log('in bu')
+    console.log('in bu')
+  }
+  
+  bot.helpers.editBotStatus({
+    status: "dnd",
+    activities: [{ name: "lts20050703", type: ActivityTypes.Game, createdAt: Date.now() }],
+  });
+
+  await delayUntil(10000, () => false)
+});
diff --git a/tests/mod.ts b/tests/mod.ts
index 843443b94..c22c7c893 100644
--- a/tests/mod.ts
+++ b/tests/mod.ts
@@ -30,8 +30,6 @@ import { getBansTests } from "./helpers/guilds/getBans.ts";
 import { getGuildTests } from "./helpers/guilds/getGuild.ts";
 import { getVanityURLTests } from "./helpers/guilds/getVanityUrl.ts";
 import { categoryChildrenTest } from "./helpers/channels/categoryChannels.ts";
-import { channelOverwriteHasPermissionTest } from "./helpers/channels/channelOverwriteHasPermission.ts";
-import { cloneChannelTests } from "./helpers/channels/cloneChannel.ts";
 import { deleteChannelOverwriteTests } from "./helpers/channels/deleteChannelOverwrite.ts";
 import { editChannelTests } from "./helpers/channels/editChannel.ts";
 import { CACHED_COMMUNITY_GUILD_ID, sanitizeMode } from "./constants.ts";
@@ -41,7 +39,7 @@ if (!UNITTEST_TOKEN) throw new Error("Token was not provided.");
 const botId = BigInt(atob(UNITTEST_TOKEN.split(".")[0]));
 
 let startedAt = 0;
-export const bot = createBot({
+const baseBot = createBot({
   token: UNITTEST_TOKEN,
   botId,
   events: createEventHandlers({
@@ -59,14 +57,13 @@ export const bot = createBot({
     "GuildMembers",
     "GuildScheduledEvents",
     "GuildVoiceStates",
+    "GuildPresences",
   ],
-  cache: {
-    isAsync: false,
-  },
 });
 
 // @ts-ignore
-enableCachePlugin(bot);
+export const bot = enableCachePlugin(baseBot);
+// @ts-ignore
 await startBot(bot);
 
 // Delay the execution to allow READY events to be processed
@@ -74,8 +71,8 @@ await delayUntil(10000, () => Boolean(startedAt));
 console.log("Bot online");
 
 // DELETE GUILDS IF LESS THAN 10 SERVERS AS SAFETY MEASURE
-if (bot.cache.guilds.size() <= 10) {
-  bot.cache.guilds.forEach(async (guild) => {
+if (bot.guilds.size <= 10) {
+  bot.guilds.forEach(async (guild) => {
     // DO NOT DELETE OUR CACHED TEST SERVER FOR COMMUNITY FEATURES
     if (guild.id === CACHED_COMMUNITY_GUILD_ID) return;
     if (guild.ownerId === bot.id) await bot.helpers.deleteGuild(guild.id);
@@ -93,10 +90,10 @@ assertExists(guild);
 assertExists(guild.id);
 
 // Delay the execution to allow GUILD_CREATE event to be processed
-await delayUntil(10000, () => bot.cache.guilds.has(guild.id));
+await delayUntil(10000, () => bot.guilds.has(guild.id));
 
 // FINAL CHECK TO THROW IF MISSING STILL
-if (!bot.cache.guilds.has(guild.id)) {
+if (!bot.guilds.has(guild.id)) {
   throw new Error(`The guild seemed to be created but it was not cached. ${guild.id.toString()}`);
 }
 
@@ -110,105 +107,66 @@ export const message = await bot.helpers.sendMessage(channel.id, "Hello Skillz")
 
 import "./benchmark.ts";
 
-Deno.test({
-  name: "[guild] format a guild's icon url",
-  fn: async (t) => {
-    assertEquals(bot.helpers.guildIconURL(guild.id, { icon: guild.icon }), undefined);
-    assertEquals(
-      bot.helpers.guildIconURL(785384884197392384n, {
-        icon: 3837424427068676005442449262648382018748n,
-      }),
-      "https://cdn.discordapp.com/icons/785384884197392384/46f50fb412eab14ec455d5cf777154bc.jpg?size=128"
-    );
-  },
-  ...sanitizeMode,
-});
-Deno.test({
-  name: "[guild] format a guild's banner url",
-  fn: async (t) => {
-    assertEquals(bot.helpers.guildBannerURL(guild.id, { banner: guild.banner }), undefined);
-    assertEquals(
-      bot.helpers.guildBannerURL(613425648685547541n, {
-        banner: 3919584870146358272366452115178209474142n,
-      }),
-      "https://cdn.discordapp.com/banners/613425648685547541/84c4964c115c128fb9100952c3b4f65e.jpg?size=128"
-    );
-  },
-  ...sanitizeMode,
-});
-Deno.test({
-  name: "[guild] format a guild's splash url",
-  fn: async (t) => {
-    assertEquals(bot.helpers.guildSplashURL(guild.id, { splash: guild.splash }), undefined);
-    assertEquals(
-      bot.helpers.guildSplashURL(785384884197392384n, {
-        splash: 3837424427068676005442449262648382018748n,
-      }),
-      "https://cdn.discordapp.com/splashes/785384884197392384/46f50fb412eab14ec455d5cf777154bc.jpg?size=128"
-    );
-  },
-  ...sanitizeMode,
-});
 Deno.test({
   name: "[guild] create a guild",
   fn: async (t) => {
-    await createGuildTests(bot, t);
+    await createGuildTests();
   },
   ...sanitizeMode,
 });
 Deno.test({
   name: "[guild] delete a guild",
   fn: async (t) => {
-    await deleteGuildTests(bot, t);
+    await deleteGuildTests();
   },
   ...sanitizeMode,
 });
 Deno.test({
   name: "[guild] edit a guild",
   fn: async (t) => {
-    await editGuildTests(bot, guild.id, t);
+    await editGuildTests(guild.id);
   },
   ...sanitizeMode,
 });
 Deno.test({
   name: "[guild] get audit logs",
   fn: async (t) => {
-    await getAuditLogsTests(bot, guild.id, t);
+    await getAuditLogsTests(guild.id);
   },
   ...sanitizeMode,
 });
 Deno.test({
   name: "[guild] get available voice regions",
   fn: async (t) => {
-    await getAvailableVoiceRegionsTests(bot, t);
+    await getAvailableVoiceRegionsTests();
   },
   ...sanitizeMode,
 });
 Deno.test({
   name: "[guild] get a ban",
   fn: async (t) => {
-    await getBanTests(bot, guild.id, t);
+    await getBanTests(guild.id);
   },
   ...sanitizeMode,
 });
 Deno.test({
   name: "[guild] get bans",
   fn: async (t) => {
-    await getBansTests(bot, guild.id, t);
+    await getBansTests(guild.id);
   },
   ...sanitizeMode,
 });
 Deno.test({
   name: "[guild] get guilds",
   fn: async (t) => {
-    await getGuildTests(bot, guild.id, t);
+    await getGuildTests(guild.id);
   },
   ...sanitizeMode,
 });
 Deno.test({
   name: "[guild] get vanity url",
   fn: async (t) => {
-    await getVanityURLTests(bot, guild.id, t);
+    await getVanityURLTests(guild.id);
   },
   ...sanitizeMode,
 });
@@ -216,140 +174,78 @@ Deno.test({
 Deno.test({
   name: "[message] send message with text",
   fn: async (t) => {
-    await sendMessageWithTextTest(bot, channel.id, t);
+    await sendMessageWithTextTest(channel.id);
   },
   ...sanitizeMode,
 });
 Deno.test({
   name: "[message] send message with embeds",
   fn: async (t) => {
-    await sendMessageWithEmbedsTest(bot, channel.id, t);
+    await sendMessageWithEmbedsTest(channel.id);
   },
   ...sanitizeMode,
 });
 Deno.test({
   name: "[message] send message with components",
   fn: async (t) => {
-    await sendMessageWithComponents(bot, channel.id, t);
+    await sendMessageWithComponents(channel.id);
   },
   ...sanitizeMode,
 });
 Deno.test({
   name: "[message] edit message",
   fn: async (t) => {
-    await editMessageTest(bot, channel.id, t);
+    await editMessageTest(channel.id);
   },
   ...sanitizeMode,
 });
 Deno.test({
   name: "[message] delete message without a reason",
   fn: async (t) => {
-    await deleteMessageWithoutReasonTest(bot, channel.id, t);
+    await deleteMessageWithoutReasonTest(channel.id);
   },
   ...sanitizeMode,
 });
 Deno.test({
   name: "[message] delete message with a reason",
   fn: async (t) => {
-    await deleteMessageWithReasonTest(bot, channel.id, t);
+    await deleteMessageWithReasonTest(channel.id);
   },
   ...sanitizeMode,
 });
 Deno.test({
   name: "[message] delete messages without a reason",
   fn: async (t) => {
-    await deleteMessagesWithoutReasonTest(bot, channel.id, t);
+    await deleteMessagesWithoutReasonTest(channel.id);
   },
   ...sanitizeMode,
 });
 Deno.test({
   name: "[message] delete messages with a reason",
   fn: async (t) => {
-    await deleteMessagesWithReasonTest(bot, channel.id, t);
+    await deleteMessagesWithReasonTest(channel.id);
   },
   ...sanitizeMode,
 });
 Deno.test({
   name: "[message] fetch a message",
   fn: async (t) => {
-    await getMessageTest(bot, channel.id, t);
+    await getMessageTest(channel.id);
   },
   ...sanitizeMode,
 });
 Deno.test({
   name: "[message] fetch messages",
   fn: async (t) => {
-    await getMessagesTest(bot, channel.id, t);
-  },
-  ...sanitizeMode,
-});
-Deno.test({
-  name: "[message] add a reaction",
-  fn: async (t) => {
-    await addReactionTest(bot, guild.id, channel.id, { custom: false, single: true, ordered: false }, t);
-  },
-  ...sanitizeMode,
-});
-Deno.test({
-  name: "[message] add a custom reaction",
-  fn: async (t) => {
-    await addReactionTest(bot, guild.id, channel.id, { custom: true, single: true, ordered: false }, t);
-  },
-  ...sanitizeMode,
-});
-Deno.test({
-  name: "[message] add multiple reactions",
-  fn: async (t) => {
-    await addReactionTest(bot, guild.id, channel.id, { custom: false, single: false, ordered: false }, t);
-  },
-  ...sanitizeMode,
-});
-Deno.test({
-  name: "[message] add multiple custom reactions",
-  fn: async (t) => {
-    await addReactionTest(bot, guild.id, channel.id, { custom: true, single: false, ordered: false }, t);
-  },
-  ...sanitizeMode,
-});
-Deno.test({
-  name: "[message] add multiple reactions in order",
-  fn: async (t) => {
-    await addReactionTest(bot, guild.id, channel.id, { custom: false, single: false, ordered: true }, t);
-  },
-  ...sanitizeMode,
-});
-Deno.test({
-  name: "[message] add multiple custom reactions in order",
-  fn: async (t) => {
-    await addReactionTest(bot, guild.id, channel.id, { custom: true, single: false, ordered: true }, t);
-  },
-  ...sanitizeMode,
-});
-Deno.test({
-  name: "[message] remove a reaction.",
-  fn: async (t) => {
-    await removeReactionTest(bot, channel.id, t);
-  },
-  ...sanitizeMode,
-});
-Deno.test({
-  name: "[message] remove all reactions.",
-  fn: async (t) => {
-    await removeAllReactionTests(bot, channel.id, t);
-  },
-  ...sanitizeMode,
-});
-Deno.test({
-  name: "[message] remove emoji reactions.",
-  fn: async (t) => {
-    await removeReactionEmojiTest(bot, channel.id, t);
+    await getMessagesTest(channel.id);
   },
   ...sanitizeMode,
 });
+
 Deno.test({
   name: "[message] pin a message",
   fn: async (t) => {
-    await pinMessageTests(bot, channel.id, message.id, t);
+    await pinMessageTests(channel.id, message.id);
   },
   ...sanitizeMode,
 });
@@ -357,218 +253,51 @@ Deno.test({
 Deno.test({
   name: "[channel] send message with text",
   fn: async (t) => {
-    await sendMessageWithTextTest(bot, channel.id, t);
-  },
-  ...sanitizeMode,
-});
-Deno.test({
-  name: "[channel] create a new text channel",
-  async fn(t) {
-    await createChannelTests(bot, guild.id, { name: "Discordeno-test" }, false, t);
-  },
-  ...sanitizeMode,
-});
-Deno.test({
-  name: "[channel] create a new category channel",
-  async fn(t) {
-    await createChannelTests(
-      bot,
-      guild.id,
-      {
-        name: "Discordeno-test",
-        type: ChannelTypes.GuildCategory,
-      },
-      false,
-      t
-    );
-  },
-  ...sanitizeMode,
-});
-Deno.test({
-  name: "[channel] create a new news channel",
-  async fn(t) {
-    await createChannelTests(
-      bot,
-      CACHED_COMMUNITY_GUILD_ID,
-      { name: "Discordeno-test", type: ChannelTypes.GuildNews },
-      true,
-      t
-    );
-  },
-  ...sanitizeMode,
-});
-Deno.test({
-  name: "[channel] create a new voice channel",
-  async fn(t) {
-    await createChannelTests(
-      bot,
-      guild.id,
-      {
-        name: "Discordeno-test",
-        type: ChannelTypes.GuildVoice,
-      },
-      false,
-      t
-    );
-  },
-  ...sanitizeMode,
-});
-Deno.test({
-  name: "[channel] create a new voice channel with a bitrate",
-  async fn(t) {
-    await createChannelTests(
-      bot,
-      guild.id,
-      {
-        name: "discordeno-test",
-        type: ChannelTypes.GuildVoice,
-        bitrate: 32000,
-      },
-      false,
-      t
-    );
-  },
-  ...sanitizeMode,
-});
-Deno.test({
-  name: "[channel] create a new voice channel with a user limit",
-  async fn(t) {
-    await createChannelTests(
-      bot,
-      guild.id,
-      {
-        name: "Discordeno-test",
-        type: ChannelTypes.GuildVoice,
-        userLimit: 32,
-      },
-      false,
-      t
-    );
-  },
-  ...sanitizeMode,
-});
-Deno.test({
-  name: "[channel] create a new text channel with a rate limit per user",
-  async fn(t) {
-    await createChannelTests(
-      bot,
-      guild.id,
-      {
-        name: "Discordeno-test",
-        rateLimitPerUser: 2423,
-      },
-      false,
-      t
-    );
-  },
-  ...sanitizeMode,
-});
-Deno.test({
-  name: "[channel] create a new text channel with NSFW",
-  async fn(t) {
-    await createChannelTests(bot, guild.id, { name: "Discordeno-test", nsfw: true }, false, t);
-  },
-  ...sanitizeMode,
-});
-Deno.test({
-  name: "[channel] create a new text channel with permission overwrites",
-  async fn(t) {
-    await createChannelTests(
-      bot,
-      guild.id,
-      {
-        name: "Discordeno-test",
-        permissionOverwrites: [
-          {
-            id: bot.id,
-            type: OverwriteTypes.Member,
-            allow: ["VIEW_CHANNEL"],
-            deny: [],
-          },
-        ],
-      },
-      false,
-      t
-    );
-  },
-  ...sanitizeMode,
-});
-Deno.test({
-  name: "[channel] delete a channel with a reason",
-  async fn(t) {
-    await deleteChannelTests(
-      bot,
-      guild.id,
-      {
-        reason: "with a reason",
-      },
-      t
-    );
-  },
-  ...sanitizeMode,
-});
-Deno.test({
-  name: "[channel] delete a channel without a reason",
-  async fn(t) {
-    await deleteChannelTests(bot, guild.id, {}, t);
+    await sendMessageWithTextTest(channel.id);
   },
   ...sanitizeMode,
 });
+
+
 Deno.test({
   name: "[channel] filter all category channels",
   async fn(t) {
-    await categoryChildrenTest(bot, guild.id, t);
-  },
-  ...sanitizeMode,
-});
-Deno.test({
-  name: "[channel] edit a channel permission overwrite",
-  async fn(t) {
-    await channelOverwriteHasPermissionTest(bot, guild.id, t);
-  },
-  ...sanitizeMode,
-});
-Deno.test({
-  name: "[channel] clone a channel w/o a reason",
-  async fn(t) {
-    await cloneChannelTests(bot, guild.id, channel, {}, t);
-  },
-  ...sanitizeMode,
-});
-Deno.test({
-  name: "[channel] clone a channel w/ a reason",
-  async fn(t) {
-    await cloneChannelTests(bot, guild.id, channel, { reason: "Blame wolf" }, t);
+    await categoryChildrenTest(guild.id);
   },
   ...sanitizeMode,
 });
 Deno.test({
   name: "[channel] delete a channel overwrite",
   async fn(t) {
-    await deleteChannelOverwriteTests(bot, guild.id, t);
+    await deleteChannelOverwriteTests(guild.id);
   },
   ...sanitizeMode,
 });
 Deno.test({
   name: "[channel] edit a channel w/o a reason",
   async fn(t) {
-    await editChannelTests(bot, guild.id, {}, t);
+    await editChannelTests(guild.id, {});
   },
   ...sanitizeMode,
 });
 Deno.test({
   name: "[channel] edit a channel w/ a reason",
   async fn(t) {
-    await editChannelTests(bot, guild.id, { reason: "Blame wolf" }, t);
+    await editChannelTests(guild.id, { reason: "Blame wolf" });
   },
   ...sanitizeMode,
 });
 
+// channels
 import "./channels/connectToVoice.ts";
+import "./channels/createChannel.ts";
+import "./channels/deleteChannel.ts";
 import "./channels/getChannel.ts";
 import "./channels/getChannels.ts";
 import "./channels/stageInstances.ts";
 import "./channels/threads.ts";
+
+// emoji
 import "./emoji/createEmoji.ts";
 import "./emoji/deleteEmojiWithReason.ts";
 import "./emoji/deleteEmojiWithoutReason.ts";
@@ -576,15 +305,28 @@ import "./emoji/editEmoji.ts";
 import "./emoji/emojiUrl.ts";
 import "./emoji/getEmoji.ts";
 import "./emoji/getMultipleEmojis.ts";
+
+// guilds
+import "./guilds/urls.ts";
+
+// invite
 import "./invite/createInvite.ts";
 import "./invite/deleteInvite.ts";
 import "./invite/getChannelInvites.ts";
 import "./invite/getInvite.ts";
 import "./invite/getInvites.ts";
+
+// members
 import "./members/avatarlUrl.ts";
 import "./members/ban.ts";
+import "./members/editBotNickname.ts";
 import "./members/getDmChannel.ts";
 import "./members/getMember.ts";
+
+// messages
+import "./messages/reactions.ts";
+
+// misc
 import "./misc/getApplicationInfo.ts";
 import "./misc/getDiscoveryCategories.ts";
 import "./misc/getUser.ts";
@@ -592,6 +334,9 @@ import "./misc/getVoiceRegions.ts";
 import "./misc/snowflake.ts";
 import "./misc/typing.ts";
 import "./misc/validateDiscovery.ts";
+import "./misc/editBotStatus.ts";
+
+// role
 import "./role/addRole.ts";
 import "./role/createRoleWithoutReason.ts";
 import "./role/createRoleWithReason.ts";
@@ -600,6 +345,8 @@ import "./role/deleteRoleWithReason.ts";
 import "./role/editRole.ts";
 import "./role/getAllRoles.ts";
 import "./role/removeRole.ts";
+
+// scheduledEvents
 import "./scheduledEvents/createExternalEventWithEndtime.ts";
 import "./scheduledEvents/createExternalEventWithoutEndtime.ts";
 import "./scheduledEvents/createStageEventWithEndtime.ts";
@@ -608,10 +355,10 @@ import "./scheduledEvents/createVoiceEventWithEndtime.ts";
 import "./scheduledEvents/createVoiceEventWithoutEndtime.ts";
 import "./scheduledEvents/deleteEvent.ts";
 import "./scheduledEvents/editEvent.ts";
+
+// webhooks
 import "./webhooks/deleteWebhook.ts";
 import "./webhooks/deleteWebhookWithToken.ts";
 import "./webhooks/sendWebhook.ts";
 import "./webhooks/webhooks.ts";
-// await bot.helpers.deleteGuild(guild.id);
 
-// await stopBot(bot);
diff --git a/tests/role/addRole.ts b/tests/role/addRole.ts
index 678aae02a..0ed7128bb 100644
--- a/tests/role/addRole.ts
+++ b/tests/role/addRole.ts
@@ -3,7 +3,6 @@ import { assertExists, assertEquals } from "../deps.ts";
 import { bot, guild } from "../mod.ts";
 import { delayUntil } from "../utils.ts";
 
-
 Deno.test({
   name: "[Role] add a role to a member",
   fn: async (t) => {
@@ -14,9 +13,9 @@ Deno.test({
     assertExists(role);
 
     // Delay the execution to allow event to be processed
-    await delayUntil(10000, () => bot.cache.guilds.get(guild.id)?.roles.has(role.id));
+    await delayUntil(10000, () => bot.guilds.get(guild.id)?.roles.has(role.id));
 
-    assertExists(bot.cache.guilds.get(guild.id)?.roles.has(role.id));
+    assertExists(bot.guilds.get(guild.id)?.roles.has(role.id));
 
     bot.events.guildMemberUpdate = function (bot, member, user) {
       roleChanges.set(user.id, member.roles);
diff --git a/tests/role/createRoleWithReason.ts b/tests/role/createRoleWithReason.ts
index 0f6ffee79..34066d80d 100644
--- a/tests/role/createRoleWithReason.ts
+++ b/tests/role/createRoleWithReason.ts
@@ -6,15 +6,15 @@ import { delayUntil } from "../utils.ts";
 Deno.test({
   name: "[Role] create a role with a reason",
   fn: async (t) => {
-    await createRoleTests(bot, guild.id, { reason: "Blame wolfy" }, t);
+    await createRoleTests(guild.id, { reason: "Blame wolfy" });
 
     const role = await bot.helpers.createRole(guild.id, { name: "hoti" }, "Blame wolfy");
 
     assertExists(role);
 
     // Delay the execution to allow event to be processed
-    await delayUntil(10000, () => bot.cache.guilds.get(guild.id)?.roles.has(role.id));
+    await delayUntil(10000, () => bot.guilds.get(guild.id)?.roles.has(role.id));
 
-    assertExists(bot.cache.guilds.get(guild.id)?.roles.has(role.id));
+    assertExists(bot.guilds.get(guild.id)?.roles.has(role.id));
   },
 });
diff --git a/tests/role/createRoleWithoutReason.ts b/tests/role/createRoleWithoutReason.ts
index 5ea9b7483..079831ab2 100644
--- a/tests/role/createRoleWithoutReason.ts
+++ b/tests/role/createRoleWithoutReason.ts
@@ -6,15 +6,15 @@ import { delayUntil } from "../utils.ts";
 Deno.test({
   name: "[Role] create a role without a reason",
   fn: async (t) => {
-    await createRoleTests(bot, guild.id, {}, t);
+    await createRoleTests(guild.id, {});
 
     const role = await bot.helpers.createRole(guild.id, { name: "hoti" });
 
     assertExists(role);
 
     // Delay the execution to allow event to be processed
-    await delayUntil(10000, () => bot.cache.guilds.get(guild.id)?.roles.has(role.id));
+    await delayUntil(10000, () => bot.guilds.get(guild.id)?.roles.has(role.id));
 
-    assertExists(bot.cache.guilds.get(guild.id)?.roles.has(role.id));
+    assertExists(bot.guilds.get(guild.id)?.roles.has(role.id));
   },
 });
diff --git a/tests/role/deleteRoleWithReason.ts b/tests/role/deleteRoleWithReason.ts
index b61c56590..1d974e008 100644
--- a/tests/role/deleteRoleWithReason.ts
+++ b/tests/role/deleteRoleWithReason.ts
@@ -10,16 +10,16 @@ Deno.test({
     assertExists(role);
 
     // Delay the execution to allow event to be processed
-    await delayUntil(10000, () => bot.cache.guilds.get(guild.id)?.roles.has(role.id));
+    await delayUntil(10000, () => bot.guilds.get(guild.id)?.roles.has(role.id));
 
-    assertExists(bot.cache.guilds.get(guild.id)?.roles.has(role.id));
+    assertExists(bot.guilds.get(guild.id)?.roles.has(role.id));
 
     await bot.helpers.deleteRole(guild.id, role.id);
 
     // Delay the execution to allow event to be processed
-    await delayUntil(10000, () => !bot.cache.guilds.get(guild.id)?.roles.has(role.id));
+    await delayUntil(10000, () => !bot.guilds.get(guild.id)?.roles.has(role.id));
 
-    if (bot.cache.guilds.get(guild.id)?.roles.has(role.id)) {
+    if (bot.guilds.get(guild.id)?.roles.has(role.id)) {
       throw new Error(`The role should have been deleted but it is still in cache.`);
     }
   },
diff --git a/tests/role/deleteRoleWithoutReason.ts b/tests/role/deleteRoleWithoutReason.ts
index 82017215a..3bad61389 100644
--- a/tests/role/deleteRoleWithoutReason.ts
+++ b/tests/role/deleteRoleWithoutReason.ts
@@ -10,16 +10,16 @@ Deno.test({
     assertExists(role);
 
     // Delay the execution to allow event to be processed
-    await delayUntil(10000, () => bot.cache.guilds.get(guild.id)?.roles.has(role.id));
+    await delayUntil(10000, () => bot.guilds.get(guild.id)?.roles.has(role.id));
 
-    assertExists(bot.cache.guilds.get(guild.id)?.roles.has(role.id));
+    assertExists(bot.guilds.get(guild.id)?.roles.has(role.id));
 
     await bot.helpers.deleteRole(guild.id, role.id);
 
     // Delay the execution to allow event to be processed
-    await delayUntil(10000, () => !bot.cache.guilds.get(guild.id)?.roles.has(role.id));
+    await delayUntil(10000, () => !bot.guilds.get(guild.id)?.roles.has(role.id));
 
-    if (bot.cache.guilds.get(guild.id)?.roles.has(role.id)) {
+    if (bot.guilds.get(guild.id)?.roles.has(role.id)) {
       throw new Error(`The role should have been deleted but it is still in cache.`);
     }
   },
diff --git a/tests/role/editRole.ts b/tests/role/editRole.ts
index a4aa83455..c89c2eceb 100644
--- a/tests/role/editRole.ts
+++ b/tests/role/editRole.ts
@@ -1,4 +1,4 @@
-import { assertExists,assertEquals } from "../deps.ts";
+import { assertExists, assertEquals } from "../deps.ts";
 import { bot, guild } from "../mod.ts";
 import { delayUntil } from "../utils.ts";
 
@@ -12,9 +12,9 @@ Deno.test({
     assertExists(role);
 
     // Delay the execution to allow event to be processed
-    await delayUntil(10000, () => bot.cache.guilds.get(guild.id)?.roles.has(role.id));
+    await delayUntil(10000, () => bot.guilds.get(guild.id)?.roles.has(role.id));
 
-    if (!bot.cache.guilds.get(guild.id)?.roles.has(role.id)) {
+    if (!bot.guilds.get(guild.id)?.roles.has(role.id)) {
       throw new Error(`The role seemed to be created but it was not cached.`);
     }
 
@@ -23,8 +23,8 @@ Deno.test({
     });
 
     // Delay the execution to allow event to be processed
-    await delayUntil(10000, () => bot.cache.guilds.get(guild.id)?.roles.get(role.id)?.name === "#rememberAyntee");
+    await delayUntil(10000, () => bot.guilds.get(guild.id)?.roles.get(role.id)?.name === "#rememberAyntee");
 
-    assertEquals(bot.cache.guilds.get(guild.id)?.roles.get(role.id)?.name === "#rememberAyntee", true);
+    assertEquals(bot.guilds.get(guild.id)?.roles.get(role.id)?.name === "#rememberAyntee", true);
   },
 });
diff --git a/tests/role/getAllRoles.ts b/tests/role/getAllRoles.ts
index 876a2bc42..7a893df3d 100644
--- a/tests/role/getAllRoles.ts
+++ b/tests/role/getAllRoles.ts
@@ -6,6 +6,6 @@ Deno.test({
   fn: async (t) => {
     const roles = await bot.helpers.getRoles(guild.id);
 
-    assertEquals(bot.cache.guilds.get(guild.id)?.roles.size, roles.size);
+    assertEquals(bot.guilds.get(guild.id)?.roles.size, roles.size);
   },
 });
diff --git a/tests/role/removeRole.ts b/tests/role/removeRole.ts
index f2f38073a..c03de7524 100644
--- a/tests/role/removeRole.ts
+++ b/tests/role/removeRole.ts
@@ -13,9 +13,9 @@ Deno.test({
     assertExists(role);
 
     // Delay the execution to allow event to be processed
-    await delayUntil(10000, () => bot.cache.guilds.get(guild.id)?.roles.has(role.id));
+    await delayUntil(10000, () => bot.guilds.get(guild.id)?.roles.has(role.id));
 
-    assertExists(bot.cache.guilds.get(guild.id)?.roles.has(role.id));
+    assertExists(bot.guilds.get(guild.id)?.roles.has(role.id));
 
     bot.events.guildMemberUpdate = function (bot, member, user) {
       roleChanges.set(user.id, member.roles);