diff --git a/index.ts b/index.ts
index f9f6709..106a08b 100644
--- a/index.ts
+++ b/index.ts
@@ -1,70 +1,73 @@
-import { Bot, Channel, Collection, Guild, Member, Role, User } from '@discordeno/bot';
+import { Bot, Channel, Collection, Guild, Member, Role, User, type DesiredPropertiesBehavior, type SetupDesiredProps, type TransformersDesiredProperties } from '@discordeno/bot';
 import { setupCacheEdits } from './setupCacheEdits.js';
 import { setupCacheRemovals } from './setupCacheRemovals.js';
 import { setupDummyEvents } from './setupDummyEvents.js';
 
 // Filter props from types of the objects based on the provided desired and undesired props
-type FilterProps<T, Desired extends keyof T, Undesired extends keyof T> = LastInteractedTimeTrackedRecord<Omit<Pick<T, Desired | ('id' extends keyof T ? 'id' : never)>, Undesired>>;
+type FilterProps<T, Desired extends keyof T, Undesired extends keyof T> = LastInteractedTimeTrackedRecord<Omit<Pick<T, Desired>, Undesired>>;
 
-type FilteredProxyCacheTypes<T extends ProxyCacheTypes, O extends CreateProxyCacheOptions<T> = CreateProxyCacheOptions<T>> = {
+type FilteredProxyCacheTypes<T extends ProxyCacheTypes<Props, Behavior>, Props extends TransformersDesiredProperties, Behavior extends DesiredPropertiesBehavior, O extends CreateProxyCacheOptions<T, Props, Behavior> = CreateProxyCacheOptions<T, Props, Behavior>> = {
     [P in keyof T]: P extends 'guild'
         ? LastInteractedTimeTrackedRecord<
               Omit<FilterProps<T[P], O['desiredProps'] extends Record<P, (keyof T[P])[]> ? O['desiredProps'][P][number] : keyof T[P], O['undesiredProps'] extends Record<P, (keyof T[P])[]> ? O['undesiredProps'][P][number] : never>, 'channels' | 'members' | 'roles' | 'lastInteractedTime'> & {
-                  channels?: Collection<bigint, FilteredProxyCacheTypes<T, O>['channel']>;
-                  members?: Collection<bigint, FilteredProxyCacheTypes<T, O>['member']>;
-                  roles?: Collection<bigint, FilteredProxyCacheTypes<T, O>['role']>;
+                  channels?: Collection<bigint, FilteredProxyCacheTypes<T, Props, Behavior, O>['channel']>;
+                  members?: Collection<bigint, FilteredProxyCacheTypes<T, Props, Behavior, O>['member']>;
+                  roles?: Collection<bigint, FilteredProxyCacheTypes<T, Props, Behavior, O>['role']>;
               }
           >
         : FilterProps<T[P], O['desiredProps'] extends Record<P, (keyof T[P])[]> ? O['desiredProps'][P][number] : keyof T[P], O['undesiredProps'] extends Record<P, (keyof T[P])[]> ? O['undesiredProps'][P][number] : never>;
 };
 
-export interface ProxyCacheProps<T extends ProxyCacheTypes, O extends CreateProxyCacheOptions<T>> {
+export interface ProxyCacheProps<T extends ProxyCacheTypes<DiscordenoDesiredProps, DiscordenoDesiredPropsBehavior>, DiscordenoDesiredProps extends TransformersDesiredProperties, DiscordenoDesiredPropsBehavior extends DesiredPropertiesBehavior, O extends CreateProxyCacheOptions<T, DiscordenoDesiredProps, DiscordenoDesiredPropsBehavior>> {
     cache: {
-        options: CreateProxyCacheOptions<T>;
+        options: CreateProxyCacheOptions<T, DiscordenoDesiredProps, DiscordenoDesiredPropsBehavior>;
         channels: {
             guildIds: Collection<bigint, bigint>;
-            memory: Collection<bigint, FilteredProxyCacheTypes<T, O>['channel']>;
-            get: (id: bigint) => Promise<FilteredProxyCacheTypes<T, O>['channel'] | undefined>;
-            set: (value: FilteredProxyCacheTypes<T, O>['channel']) => Promise<void>;
+            memory: Collection<bigint, FilteredProxyCacheTypes<T, DiscordenoDesiredProps, DiscordenoDesiredPropsBehavior, O>['channel']>;
+            get: (id: bigint) => Promise<FilteredProxyCacheTypes<T, DiscordenoDesiredProps, DiscordenoDesiredPropsBehavior, O>['channel'] | undefined>;
+            set: (value: FilteredProxyCacheTypes<T, DiscordenoDesiredProps, DiscordenoDesiredPropsBehavior, O>['channel']) => Promise<void>;
             delete: (id: bigint) => Promise<void>;
         };
         guilds: {
-            memory: Collection<bigint, FilteredProxyCacheTypes<T, O>['guild']>;
-            get: (id: bigint) => Promise<FilteredProxyCacheTypes<T, O>['guild'] | undefined>;
-            set: (value: FilteredProxyCacheTypes<T, O>['guild']) => Promise<void>;
+            memory: Collection<bigint, FilteredProxyCacheTypes<T, DiscordenoDesiredProps, DiscordenoDesiredPropsBehavior, O>['guild']>;
+            get: (id: bigint) => Promise<FilteredProxyCacheTypes<T, DiscordenoDesiredProps, DiscordenoDesiredPropsBehavior, O>['guild'] | undefined>;
+            set: (value: FilteredProxyCacheTypes<T, DiscordenoDesiredProps, DiscordenoDesiredPropsBehavior, O>['guild']) => Promise<void>;
             delete: (id: bigint) => Promise<void>;
         };
         members: {
-            get: (id: bigint, guildId: bigint) => Promise<FilteredProxyCacheTypes<T, O>['member'] | undefined>;
-            set: (value: FilteredProxyCacheTypes<T, O>['member']) => Promise<void>;
+            get: (id: bigint, guildId: bigint) => Promise<FilteredProxyCacheTypes<T, DiscordenoDesiredProps, DiscordenoDesiredPropsBehavior, O>['member'] | undefined>;
+            set: (value: FilteredProxyCacheTypes<T, DiscordenoDesiredProps, DiscordenoDesiredPropsBehavior, O>['member']) => Promise<void>;
             delete: (id: bigint, guildId: bigint) => Promise<void>;
         };
         roles: {
             guildIds: Collection<bigint, bigint>;
-            get: (id: bigint) => Promise<FilteredProxyCacheTypes<T, O>['role'] | undefined>;
-            set: (value: FilteredProxyCacheTypes<T, O>['role']) => Promise<void>;
+            get: (id: bigint) => Promise<FilteredProxyCacheTypes<T, DiscordenoDesiredProps, DiscordenoDesiredPropsBehavior, O>['role'] | undefined>;
+            set: (value: FilteredProxyCacheTypes<T, DiscordenoDesiredProps, DiscordenoDesiredPropsBehavior, O>['role']) => Promise<void>;
             delete: (id: bigint) => Promise<void>;
         };
         users: {
-            memory: Collection<bigint, FilteredProxyCacheTypes<T, O>['user']>;
-            get: (id: bigint) => Promise<FilteredProxyCacheTypes<T, O>['user'] | undefined>;
-            set: (value: FilteredProxyCacheTypes<T, O>['user']) => Promise<void>;
+            memory: Collection<bigint, FilteredProxyCacheTypes<T, DiscordenoDesiredProps, DiscordenoDesiredPropsBehavior, O>['user']>;
+            get: (id: bigint) => Promise<FilteredProxyCacheTypes<T, DiscordenoDesiredProps, DiscordenoDesiredPropsBehavior, O>['user'] | undefined>;
+            set: (value: FilteredProxyCacheTypes<T, DiscordenoDesiredProps, DiscordenoDesiredPropsBehavior, O>['user']) => Promise<void>;
             delete: (id: bigint) => Promise<void>;
         };
         $inferredTypes: {
-            channel: FilteredProxyCacheTypes<T, O>['channel'];
-            guild: FilteredProxyCacheTypes<T, O>['guild'];
-            member: FilteredProxyCacheTypes<T, O>['member'];
-            role: FilteredProxyCacheTypes<T, O>['role'];
-            user: FilteredProxyCacheTypes<T, O>['user'];
+            channel: FilteredProxyCacheTypes<T, DiscordenoDesiredProps, DiscordenoDesiredPropsBehavior, O>['channel'];
+            guild: FilteredProxyCacheTypes<T, DiscordenoDesiredProps, DiscordenoDesiredPropsBehavior, O>['guild'];
+            member: FilteredProxyCacheTypes<T, DiscordenoDesiredProps, DiscordenoDesiredPropsBehavior, O>['member'];
+            role: FilteredProxyCacheTypes<T, DiscordenoDesiredProps, DiscordenoDesiredPropsBehavior, O>['role'];
+            user: FilteredProxyCacheTypes<T, DiscordenoDesiredProps, DiscordenoDesiredPropsBehavior, O>['user'];
         };
     };
 }
 
-export type BotWithProxyCache<T extends ProxyCacheTypes, B extends Bot, O extends CreateProxyCacheOptions<T> = CreateProxyCacheOptions<T>> = B & ProxyCacheProps<T, O>;
+export type BotWithProxyCache<T extends ProxyCacheTypes<Props, Behavior>, Props extends TransformersDesiredProperties, Behavior extends DesiredPropertiesBehavior, B extends Bot<Props, Behavior>, O extends CreateProxyCacheOptions<T, Props, Behavior> = CreateProxyCacheOptions<T, Props, Behavior>> = B & ProxyCacheProps<T, Props, Behavior, O>;
 
-export const createProxyCache = <T extends ProxyCacheTypes = ProxyCacheTypes, B extends Bot = Bot, O extends CreateProxyCacheOptions<T> = CreateProxyCacheOptions<T>>(rawBot: B, options: O): BotWithProxyCache<T, B, O> => {
-    const bot = rawBot as BotWithProxyCache<T, B>;
+export const createProxyCache = <Props extends TransformersDesiredProperties, Behavior extends DesiredPropertiesBehavior, B extends Bot<Props, Behavior>, T extends ProxyCacheTypes<Props, Behavior> = ProxyCacheTypes<Props, Behavior>, O extends CreateProxyCacheOptions<T, Props, Behavior> = CreateProxyCacheOptions<T, Props, Behavior>>(
+    rawBot: Bot<Props, Behavior> & B,
+    options: O
+): BotWithProxyCache<T, Props, Behavior, B, O> => {
+    const bot = rawBot as BotWithProxyCache<T, Props, Behavior, B>;
 
     // @ts-ignore
     bot.cache = { options };
@@ -72,9 +75,9 @@ export const createProxyCache = <T extends ProxyCacheTypes = ProxyCacheTypes, B
     const pendingGuildsData = new Collection<
         bigint,
         {
-            channels?: Collection<bigint, FilteredProxyCacheTypes<T>['channel']>;
-            members?: Collection<bigint, FilteredProxyCacheTypes<T>['member']>;
-            roles?: Collection<bigint, FilteredProxyCacheTypes<T>['role']>;
+            channels?: Collection<bigint, FilteredProxyCacheTypes<T, Props, Behavior>['channel']>;
+            members?: Collection<bigint, FilteredProxyCacheTypes<T, Props, Behavior>['member']>;
+            roles?: Collection<bigint, FilteredProxyCacheTypes<T, Props, Behavior>['role']>;
         }
     >();
 
@@ -109,9 +112,9 @@ export const createProxyCache = <T extends ProxyCacheTypes = ProxyCacheTypes, B
 
             // Remove any associated channels
             bot.cache.channels.memory.forEach((channel) => {
-                if (channel.guildId === id) {
-                    bot.cache.channels.memory.delete(channel.id);
-                    bot.cache.channels.guildIds.delete(channel.id);
+                if ((channel as unknown as Channel).guildId === id) {
+                    bot.cache.channels.memory.delete((channel as unknown as Channel).id);
+                    bot.cache.channels.guildIds.delete((channel as unknown as Channel).id);
                 }
             });
         },
@@ -125,7 +128,7 @@ export const createProxyCache = <T extends ProxyCacheTypes = ProxyCacheTypes, B
                     guild.roles?.delete(id);
                     // Each mem who has this role needs to be edited and the role id removed
                     guild.members?.forEach((member) => {
-                        if (member.roles?.includes(id)) member.roles = member.roles.filter((roleId) => roleId !== id);
+                        if ((member as unknown as Member).roles?.includes(id)) (member as unknown as Member).roles = (member as unknown as Member).roles.filter((roleId) => roleId !== id);
                     });
                 }
             }
@@ -193,7 +196,7 @@ export const createProxyCache = <T extends ProxyCacheTypes = ProxyCacheTypes, B
             guild.lastInteractedTime = Date.now();
 
             // If user wants memory cache, we cache it
-            if (options.cacheInMemory?.guild) bot.cache.guilds.memory.set(guild.id, guild);
+            if (options.cacheInMemory?.guild) bot.cache.guilds.memory.set((guild as unknown as Guild).id, guild);
             // If user wants non-memory cache, we cache it
             if (options.cacheOutsideMemory?.guild && options.setItem) await options.setItem('guild', guild);
         },
@@ -238,7 +241,7 @@ export const createProxyCache = <T extends ProxyCacheTypes = ProxyCacheTypes, B
             user.lastInteractedTime = Date.now();
 
             // If user wants memory cache, we cache it
-            if (options.cacheInMemory?.user) bot.cache.users.memory.set(user.id, user);
+            if (options.cacheInMemory?.user) bot.cache.users.memory.set((user as unknown as User).id, user);
             // If user wants non-memory cache, we cache it
             if (options.cacheOutsideMemory?.user && options.setItem) await options.setItem('user', user);
         },
@@ -283,10 +286,12 @@ export const createProxyCache = <T extends ProxyCacheTypes = ProxyCacheTypes, B
 
             return stored;
         },
-        set: async (role) => {
-            if (options.shouldCache?.role && !(await options.shouldCache.role(role))) return;
+        set: async (internalRole) => {
+            if (options.shouldCache?.role && !(await options.shouldCache.role(internalRole))) return;
 
-            role.lastInteractedTime = Date.now();
+            internalRole.lastInteractedTime = Date.now();
+
+            const role = internalRole as unknown as Role;
 
             // If user wants memory cache, we cache it
             if (options.cacheInMemory?.role) {
@@ -299,18 +304,18 @@ export const createProxyCache = <T extends ProxyCacheTypes = ProxyCacheTypes, B
                         if (guild) {
                             if (!guild.roles) guild.roles = new Collection();
 
-                            guild.roles.set(role.id, role);
+                            guild.roles.set(role.id, internalRole);
                         } else {
                             const pendingGuild = pendingGuildsData.get(guildId);
                             if (!pendingGuild) pendingGuildsData.set(guildId, { channels: new Collection(), members: new Collection(), roles: new Collection() });
 
-                            pendingGuildsData.get(guildId)?.roles!.set(role.id, role);
+                            pendingGuildsData.get(guildId)?.roles!.set(role.id, internalRole);
                         }
                     } else console.warn(`[CACHE] Can't cache role(${role.id}) since guild.roles is enabled but a guild id was not found.`);
                 }
             }
             // If user wants non-memory cache, we cache it
-            if (options.cacheOutsideMemory?.role && options.setItem) await options.setItem('role', role);
+            if (options.cacheOutsideMemory?.role && options.setItem) await options.setItem('role', internalRole);
         },
         delete: async (roleId) => {
             // Remove from memory
@@ -350,10 +355,12 @@ export const createProxyCache = <T extends ProxyCacheTypes = ProxyCacheTypes, B
 
             return stored;
         },
-        set: async (member) => {
-            if (options.shouldCache?.member && !(await options.shouldCache.member(member))) return;
+        set: async (internalMember) => {
+            if (options.shouldCache?.member && !(await options.shouldCache.member(internalMember))) return;
+
+            internalMember.lastInteractedTime = Date.now();
 
-            member.lastInteractedTime = Date.now();
+            const member = internalMember as unknown as Member;
 
             // If user wants memory cache, we cache it
             if (options.cacheInMemory?.member) {
@@ -363,18 +370,18 @@ export const createProxyCache = <T extends ProxyCacheTypes = ProxyCacheTypes, B
                         if (guild) {
                             if (!guild.members) guild.members = new Collection();
 
-                            guild.members.set(member.id, member);
+                            guild.members.set(member.id, internalMember);
                         } else {
                             const pendingGuild = pendingGuildsData.get(member.guildId);
                             if (!pendingGuild) pendingGuildsData.set(member.guildId, { channels: new Collection(), members: new Collection(), roles: new Collection() });
 
-                            pendingGuildsData.get(member.guildId)?.members!.set(member.id, member);
+                            pendingGuildsData.get(member.guildId)?.members!.set(member.id, internalMember);
                         }
                     } else console.warn(`[CACHE] Can't cache member(${member.id}) since guild.members is enabled but a guild id was not found.`);
                 }
             }
             // If user wants non-memory cache, we cache it
-            if (options.cacheOutsideMemory?.member && options.setItem) await options.setItem('member', member);
+            if (options.cacheOutsideMemory?.member && options.setItem) await options.setItem('member', internalMember);
         },
         delete: async (memberId, guildId) => {
             // Remove from memory
@@ -433,14 +440,16 @@ export const createProxyCache = <T extends ProxyCacheTypes = ProxyCacheTypes, B
 
             return stored;
         },
-        set: async (channel) => {
-            if (options.shouldCache?.channel && !(await options.shouldCache.channel(channel))) return;
+        set: async (internalChannel) => {
+            if (options.shouldCache?.channel && !(await options.shouldCache.channel(internalChannel))) return;
 
-            channel.lastInteractedTime = Date.now();
+            internalChannel.lastInteractedTime = Date.now();
+
+            const channel = internalChannel as unknown as Channel;
 
             // If user wants memory cache, we cache it
             if (options.cacheInMemory?.channel) {
-                if (channel.guildId) bot.cache.channels.guildIds.set(channel.id, channel.guildId);
+                if (channel.guildId) bot.cache.channels.guildIds.set(channel.id, channel.guildId!);
 
                 if (options.cacheInMemory?.guild) {
                     const guildId = bot.cache.channels.guildIds.get(channel.id);
@@ -449,18 +458,18 @@ export const createProxyCache = <T extends ProxyCacheTypes = ProxyCacheTypes, B
                         if (guild) {
                             if (!guild.channels) guild.channels = new Collection();
 
-                            guild.channels.set(channel.id, channel);
+                            guild.channels.set(channel.id, internalChannel);
                         } else {
                             const pendingGuild = pendingGuildsData.get(guildId);
                             if (!pendingGuild) pendingGuildsData.set(guildId, { channels: new Collection(), members: new Collection(), roles: new Collection() });
 
-                            pendingGuildsData.get(guildId)?.channels!.set(channel.id, channel);
+                            pendingGuildsData.get(guildId)?.channels!.set(channel.id, internalChannel);
                         }
                     } else console.warn(`[CACHE] Can't cache channel(${channel.id}) since guild.channels is enabled but a guild id was not found.`);
-                } else bot.cache.channels.memory.set(channel.id, channel);
+                } else bot.cache.channels.memory.set(channel.id, internalChannel);
             }
             // If user wants non-memory cache, we cache it
-            if (options.cacheOutsideMemory?.channel && options.setItem) await options.setItem('channel', channel);
+            if (options.cacheOutsideMemory?.channel && options.setItem) await options.setItem('channel', internalChannel);
         },
         delete: async (channelId) => {
             // Remove from memory
@@ -475,19 +484,21 @@ export const createProxyCache = <T extends ProxyCacheTypes = ProxyCacheTypes, B
 
     // MAKE SURE TO NOT MOVE THIS BELOW GUILD CUSTOMIZER
     bot.transformers.customizers.member = (_, _payload, old) => {
+        if (!('id' in old)) return console.warn(`[CACHE] Can't cache member since id is missing.`);
+
         // Filter to desired args
         // @ts-ignore
-        const args: FilteredProxyCacheTypes<T>['member'] = {};
+        const args: FilteredProxyCacheTypes<T, Props, Behavior>['member'] = {};
 
-        const keys = Object.keys(old) as (keyof Member)[];
+        const keys = Object.keys(old) as (keyof typeof old)[];
 
         for (const key of keys) {
             // ID is required. Desired props take priority.
-            if (key === 'id' || options.desiredProps?.member?.includes(key)) args[key] = old[key] as never;
+            if (key === 'id' || options.desiredProps?.member?.includes(key)) (args as any)[key] = old[key];
             // If undesired we skip
             else if (options.undesiredProps?.member?.includes(key)) continue;
             // If member did not say this is undesired and did not provide any desired props we accept it
-            else if (!options.desiredProps?.member?.length) args[key] = old[key] as never;
+            else if (!options.desiredProps?.member?.length) (args as any)[key] = old[key];
         }
 
         // Add to memory
@@ -497,19 +508,21 @@ export const createProxyCache = <T extends ProxyCacheTypes = ProxyCacheTypes, B
     };
 
     bot.transformers.customizers.user = (_, _payload, old) => {
+        if (!('id' in old)) return console.warn(`[CACHE] Can't cache user since id is missing.`);
+
         // Filter to desired args
         // @ts-ignore
-        const args: FilteredProxyCacheTypes<T>['user'] = {};
+        const args: FilteredProxyCacheTypes<T, Props, Behavior>['user'] = {};
 
-        const keys = Object.keys(old) as (keyof User)[];
+        const keys = Object.keys(old) as (keyof typeof old)[];
 
         for (const key of keys) {
             // ID is required. Desired props take priority.
-            if (key === 'id' || options.desiredProps?.user?.includes(key)) args[key] = old[key] as never;
+            if (key === 'id' || options.desiredProps?.user?.includes(key)) (args as any)[key] = old[key];
             // If undesired we skip
             else if (options.undesiredProps?.user?.includes(key)) continue;
             // If user did not say this is undesired and did not provide any desired props we accept it
-            else if (!options.desiredProps?.user?.length) args[key] = old[key] as never;
+            else if (!options.desiredProps?.user?.length) (args as any)[key] = old[key];
         }
 
         // Add to memory
@@ -519,25 +532,27 @@ export const createProxyCache = <T extends ProxyCacheTypes = ProxyCacheTypes, B
     };
 
     bot.transformers.customizers.guild = (_, payload, old) => {
+        if (!('id' in old)) return console.warn(`[CACHE] Can't cache guild since id is missing.`);
+
         // Filter to desired args
         // @ts-ignore
-        const args: FilteredProxyCacheTypes<T>['guild'] = {};
+        const args: FilteredProxyCacheTypes<T, Props, Behavior>['guild'] = {};
 
-        const keys = Object.keys(old) as (keyof Guild)[];
+        const keys = Object.keys(old) as (keyof typeof old)[];
 
         for (const key of keys) {
             // ID is required. Desired props take priority.
-            if (key === 'id' || options.desiredProps?.guild?.includes(key)) args[key] = old[key] as never;
+            if (key === 'id' || options.desiredProps?.guild?.includes(key as any)) (args as any)[key] = old[key];
             // If undesired we skip
-            else if (options.undesiredProps?.guild?.includes(key)) continue;
+            else if (options.undesiredProps?.guild?.includes(key as any)) continue;
             // If guild did not say this is undesired and did not provide any desired props we accept it
-            else if (!options.desiredProps?.guild?.length) args[key] = old[key] as never;
+            else if (!options.desiredProps?.guild?.length) (args as any)[key] = old[key];
         }
 
-        const pendingGuildData = pendingGuildsData.get(old.id);
+        const pendingGuildData = pendingGuildsData.get(old.id as Guild['id']);
 
         if (pendingGuildData) {
-            pendingGuildsData.delete(old.id);
+            pendingGuildsData.delete(old.id as Guild['id']);
 
             if (pendingGuildData.channels?.size) args.channels = new Collection([...pendingGuildData.channels, ...(args.channels || [])]);
             if (pendingGuildData.members?.size) args.members = new Collection([...pendingGuildData.members, ...(args.members || [])]);
@@ -545,12 +560,12 @@ export const createProxyCache = <T extends ProxyCacheTypes = ProxyCacheTypes, B
         }
 
         // Update last interacted time for all channels, members and roles
-        if (args.channels) args.channels = new Collection(args.channels.array().map((channel) => [channel.id, { ...channel, lastInteractedTime: Date.now() }]));
-        if (args.members) args.members = new Collection(args.members.array().map((member) => [member.id, { ...member, lastInteractedTime: Date.now() }]));
-        if (args.roles) args.roles = new Collection(args.roles.array().map((role) => [role.id, { ...role, lastInteractedTime: Date.now() }]));
+        if (args.channels) args.channels = new Collection(args.channels.array().map((channel) => [(channel as unknown as Channel).id, { ...channel, lastInteractedTime: Date.now() }]));
+        if (args.members) args.members = new Collection(args.members.array().map((member) => [(member as unknown as Member).id, { ...member, lastInteractedTime: Date.now() }]));
+        if (args.roles) args.roles = new Collection(args.roles.array().map((role) => [(role as unknown as Role).id, { ...role, lastInteractedTime: Date.now() }]));
 
         // Set approximate member count as member count if payload is from API
-        if (payload.approximate_member_count && options.desiredProps?.guild?.includes('memberCount')) args.memberCount = payload.approximate_member_count;
+        if (payload.approximate_member_count && (options.desiredProps?.guild as (keyof Guild)[])?.includes('memberCount')) (args as unknown as Guild).memberCount = payload.approximate_member_count;
 
         // Add to memory
         bot.cache.guilds.set(args);
@@ -558,7 +573,7 @@ export const createProxyCache = <T extends ProxyCacheTypes = ProxyCacheTypes, B
         if (payload.members) {
             for (const member of payload.members) {
                 if (member.user) {
-                    bot.transformers.member(bot, member, old.id, BigInt(member.user.id));
+                    bot.transformers.member(bot, member, old.id as Guild['id'], BigInt(member.user.id));
                     bot.transformers.user(bot, member.user);
                 }
             }
@@ -568,19 +583,21 @@ export const createProxyCache = <T extends ProxyCacheTypes = ProxyCacheTypes, B
     };
 
     bot.transformers.customizers.channel = (_, _payload, old) => {
+        if (!('id' in old)) return console.warn(`[CACHE] Can't cache channel since id is missing.`);
+
         // Filter to desired args
         // @ts-ignore
-        const args: FilteredProxyCacheTypes<T>['channel'] = {};
+        const args: FilteredProxyCacheTypes<T, Props, Behavior>['channel'] = {};
 
-        const keys = Object.keys(old) as (keyof Channel)[];
+        const keys = Object.keys(old) as (keyof typeof old)[];
 
         for (const key of keys) {
             // ID is required. Desired props take priority.
-            if (key === 'id' || options.desiredProps?.channel?.includes(key)) args[key] = old[key] as never;
+            if (key === 'id' || options.desiredProps?.channel?.includes(key)) (args as any)[key] = old[key];
             // If undesired we skip
             else if (options.undesiredProps?.channel?.includes(key)) continue;
             // If channel did not say this is undesired and did not provide any desired props we accept it
-            else if (!options.desiredProps?.channel?.length) args[key] = old[key] as never;
+            else if (!options.desiredProps?.channel?.length) (args as any)[key] = old[key];
         }
 
         // Add to memory
@@ -590,19 +607,21 @@ export const createProxyCache = <T extends ProxyCacheTypes = ProxyCacheTypes, B
     };
 
     bot.transformers.customizers.role = (_, _payload, old) => {
+        if (!('id' in old)) return console.warn(`[CACHE] Can't cache role since id is missing.`);
+
         // Filter to desired args
         // @ts-ignore
-        const args: FilteredProxyCacheTypes<T>['role'] = {};
+        const args: FilteredProxyCacheTypes<T, Props, Behavior>['role'] = {};
 
-        const keys = Object.keys(old) as (keyof Role)[];
+        const keys = Object.keys(old) as (keyof typeof old)[];
 
         for (const key of keys) {
             // ID is required. Desired props take priority.
-            if (key === 'id' || options.desiredProps?.role?.includes(key)) args[key] = old[key] as never;
+            if (key === 'id' || options.desiredProps?.role?.includes(key)) (args as any)[key] = old[key];
             // If undesired we skip
             else if (options.undesiredProps?.role?.includes(key)) continue;
             // If role did not say this is undesired and did not provide any desired props we accept it
-            else if (!options.desiredProps?.role?.length) args[key] = old[key] as never;
+            else if (!options.desiredProps?.role?.length) (args as any)[key] = old[key];
         }
 
         // Add to memory
@@ -624,32 +643,32 @@ export const createProxyCache = <T extends ProxyCacheTypes = ProxyCacheTypes, B
         setInterval(() => {
             if (filter.channel)
                 bot.cache.channels.memory.forEach((channel) => {
-                    if (filter.channel?.(channel)) bot.cache.channels.memory.delete(channel.id);
+                    if (filter.channel?.(channel)) bot.cache.channels.memory.delete((channel as unknown as Channel).id);
                 });
 
             if (filter.guild || filter.channel || filter.member || filter.role)
                 bot.cache.guilds.memory.forEach((guild): boolean | void => {
-                    if (filter.guild?.(guild)) return bot.cache.guilds.memory.delete(guild.id);
+                    if (filter.guild?.(guild)) return bot.cache.guilds.memory.delete((guild as unknown as Guild).id);
 
                     if (guild.channels && filter.channel)
                         guild.channels.forEach((channel) => {
-                            if (filter.channel?.(channel)) guild.channels?.delete(channel.id);
+                            if (filter.channel?.(channel)) guild.channels?.delete((channel as unknown as Channel).id);
                         });
 
                     if (guild.members && filter.member)
                         guild.members.forEach((member) => {
-                            if (filter.member?.(member)) guild.members?.delete(member.id);
+                            if (filter.member?.(member)) guild.members?.delete((member as unknown as Member).id);
                         });
 
                     if (guild.roles && filter.role)
                         guild.roles.forEach((role) => {
-                            if (filter.role?.(role)) guild.roles?.delete(role.id);
+                            if (filter.role?.(role)) guild.roles?.delete((role as unknown as Role).id);
                         });
                 });
 
             if (filter.user)
                 bot.cache.users.memory.forEach((user) => {
-                    if (filter.user?.(user)) bot.cache.users.memory.delete(user.id);
+                    if (filter.user?.(user)) bot.cache.users.memory.delete((user as unknown as User).id);
                 });
         }, interval);
     }
@@ -657,47 +676,47 @@ export const createProxyCache = <T extends ProxyCacheTypes = ProxyCacheTypes, B
     return bot;
 };
 
-export type ProxyCacheTypes = {
-    channel: Channel;
-    guild: Omit<Guild, 'channels' | 'members' | 'roles'> & {
-        channels?: Collection<bigint, LastInteractedTimeTrackedRecord<Channel>>;
-        members?: Collection<bigint, LastInteractedTimeTrackedRecord<Member>>;
-        roles?: Collection<bigint, LastInteractedTimeTrackedRecord<Role>>;
+export type ProxyCacheTypes<Props extends TransformersDesiredProperties, Behavior extends DesiredPropertiesBehavior> = {
+    channel: SetupDesiredProps<Channel, Props, Behavior>;
+    guild: Omit<SetupDesiredProps<Guild, Props, Behavior>, 'channels' | 'members' | 'roles'> & {
+        channels?: Collection<bigint, LastInteractedTimeTrackedRecord<SetupDesiredProps<Channel, Props, Behavior>>>;
+        members?: Collection<bigint, LastInteractedTimeTrackedRecord<SetupDesiredProps<Member, Props, Behavior>>>;
+        roles?: Collection<bigint, LastInteractedTimeTrackedRecord<SetupDesiredProps<Role, Props, Behavior>>>;
     };
-    member: Member;
-    role: Role;
-    user: User;
+    member: SetupDesiredProps<Member, Props, Behavior>;
+    role: SetupDesiredProps<Role, Props, Behavior>;
+    user: SetupDesiredProps<User, Props, Behavior>;
 };
 
 // Note: Adding ProxyCacheTypes[K] because TS doesn't provide autocomplete on extends keyof generic, this trick will provide autocomplete
-type DesiredPropsArray<T extends ProxyCacheTypes, K extends keyof ProxyCacheTypes> = Array<keyof T[K] | keyof ProxyCacheTypes[K]>;
+type DesiredPropsArray<T extends ProxyCacheTypes<Props, Behavior>, K extends keyof ProxyCacheTypes<Props, Behavior>, Props extends TransformersDesiredProperties, Behavior extends DesiredPropertiesBehavior> = Array<keyof T[K] | keyof ProxyCacheTypes<Props, Behavior>[K]>;
 
-export interface CreateProxyCacheOptions<T extends ProxyCacheTypes> {
+export interface CreateProxyCacheOptions<T extends ProxyCacheTypes<Props, Behavior>, Props extends TransformersDesiredProperties, Behavior extends DesiredPropertiesBehavior> {
     /** Configure the exact properties you wish to have in each object. */
     desiredProps?: {
         /** The properties you want to keep in a channel object. */
-        channel?: DesiredPropsArray<T, 'channel'>;
+        channel?: DesiredPropsArray<T, 'channel', Props, Behavior>;
         /** The properties you want to keep in a guild object. */
-        guild?: DesiredPropsArray<T, 'guild'>;
+        guild?: DesiredPropsArray<T, 'guild', Props, Behavior>;
         /** The properties you want to keep in a member object. */
-        member?: DesiredPropsArray<T, 'member'>;
+        member?: DesiredPropsArray<T, 'member', Props, Behavior>;
         /** The properties you want to keep in a role object. */
-        role?: DesiredPropsArray<T, 'role'>;
+        role?: DesiredPropsArray<T, 'role', Props, Behavior>;
         /** The properties you want to keep in a user object. */
-        user?: DesiredPropsArray<T, 'user'>;
+        user?: DesiredPropsArray<T, 'user', Props, Behavior>;
     };
     /** Configure the properties you do NOT want in each object. */
     undesiredProps?: {
         /** The properties you do NOT want in a channel object. */
-        channel?: DesiredPropsArray<T, 'channel'>;
+        channel?: DesiredPropsArray<T, 'channel', Props, Behavior>;
         /** The properties you do NOT want in a guild object. */
-        guild?: DesiredPropsArray<T, 'guild'>;
+        guild?: DesiredPropsArray<T, 'guild', Props, Behavior>;
         /** The properties you do NOT want in a member object. */
-        member?: DesiredPropsArray<T, 'member'>;
+        member?: DesiredPropsArray<T, 'member', Props, Behavior>;
         /** The properties you do NOT want in a role object. */
-        role?: DesiredPropsArray<T, 'role'>;
+        role?: DesiredPropsArray<T, 'role', Props, Behavior>;
         /** The properties you do NOT want in a user object. */
-        user?: DesiredPropsArray<T, 'user'>;
+        user?: DesiredPropsArray<T, 'user', Props, Behavior>;
     };
     /**
      * Options to choose how the proxy will cache everything.
@@ -738,9 +757,9 @@ export interface CreateProxyCacheOptions<T extends ProxyCacheTypes> {
         default: boolean;
     };
     /** Handler to get an object from a specific table. */
-    getItem?: <K extends keyof T>(...args: [table: Exclude<K, 'member'>, id: bigint] | [table: Extract<K, 'member'>, id: bigint, guildId: bigint]) => Promise<FilteredProxyCacheTypes<T>[K]>;
+    getItem?: <K extends keyof T>(...args: [table: Exclude<K, 'member'>, id: bigint] | [table: Extract<K, 'member'>, id: bigint, guildId: bigint]) => Promise<FilteredProxyCacheTypes<T, Props, Behavior>[K]>;
     /** Handler to set an object in a specific table. */
-    setItem?: <K extends keyof T>(table: K, item: FilteredProxyCacheTypes<T>[K]) => Promise<FilteredProxyCacheTypes<T>[K]>;
+    setItem?: <K extends keyof T>(table: K, item: FilteredProxyCacheTypes<T, Props, Behavior>[K]) => Promise<FilteredProxyCacheTypes<T, Props, Behavior>[K]>;
     /** Handler to delete an object in a specific table. */
     removeItem?: <K extends keyof T>(...args: [table: Exclude<K, 'member'>, id: bigint] | [table: Extract<K, 'member'>, id: bigint, guildId: bigint]) => Promise<unknown>;
     /**
@@ -768,15 +787,15 @@ export interface CreateProxyCacheOptions<T extends ProxyCacheTypes> {
     /** Configure the handlers that should be ran whenever something is about to be cached to determine whether it should or should not be cached. */
     shouldCache?: {
         /** Handler to check whether or not to cache this channel. */
-        channel?: (channel: FilteredProxyCacheTypes<T>['channel']) => Promise<boolean>;
+        channel?: (channel: FilteredProxyCacheTypes<T, Props, Behavior>['channel']) => Promise<boolean>;
         /** Handler to check whether or not to cache this guild. */
-        guild?: (guild: FilteredProxyCacheTypes<T>['guild']) => Promise<boolean>;
+        guild?: (guild: FilteredProxyCacheTypes<T, Props, Behavior>['guild']) => Promise<boolean>;
         /** Handler to check whether or not to cache this member. */
-        member?: (member: FilteredProxyCacheTypes<T>['member']) => Promise<boolean>;
+        member?: (member: FilteredProxyCacheTypes<T, Props, Behavior>['member']) => Promise<boolean>;
         /** Handler to check whether or not to cache this role. */
-        role?: (role: FilteredProxyCacheTypes<T>['role']) => Promise<boolean>;
+        role?: (role: FilteredProxyCacheTypes<T, Props, Behavior>['role']) => Promise<boolean>;
         /** Handler to check whether or not to cache this user. */
-        user?: (user: FilteredProxyCacheTypes<T>['user']) => Promise<boolean>;
+        user?: (user: FilteredProxyCacheTypes<T, Props, Behavior>['user']) => Promise<boolean>;
     };
     /** Options for cache sweeper. This works for in-memory cache only. For outside memory cache, you should implement your own sweeper. */
     sweeper?: {
@@ -789,15 +808,15 @@ export interface CreateProxyCacheOptions<T extends ProxyCacheTypes> {
          */
         filter: {
             /** Filter to decide whether or not to remove a channel from the cache. */
-            channel?: (channel: FilteredProxyCacheTypes<T>['channel']) => boolean;
+            channel?: (channel: FilteredProxyCacheTypes<T, Props, Behavior>['channel']) => boolean;
             /** Filter to decide whether or not to remove a guild from the cache. */
-            guild?: (guild: FilteredProxyCacheTypes<T>['guild']) => boolean;
+            guild?: (guild: FilteredProxyCacheTypes<T, Props, Behavior>['guild']) => boolean;
             /** Filter to decide whether or not to remove a member from the cache. */
-            member?: (member: FilteredProxyCacheTypes<T>['member']) => boolean;
+            member?: (member: FilteredProxyCacheTypes<T, Props, Behavior>['member']) => boolean;
             /** Filter to decide whether or not to remove a role from the cache. */
-            role?: (role: FilteredProxyCacheTypes<T>['role']) => boolean;
+            role?: (role: FilteredProxyCacheTypes<T, Props, Behavior>['role']) => boolean;
             /** Filter to decide whether or not to remove a user from the cache. */
-            user?: (user: FilteredProxyCacheTypes<T>['user']) => boolean;
+            user?: (user: FilteredProxyCacheTypes<T, Props, Behavior>['user']) => boolean;
         };
     };
 }
diff --git a/setupCacheEdits.ts b/setupCacheEdits.ts
index d3f7512..6cc857b 100644
--- a/setupCacheEdits.ts
+++ b/setupCacheEdits.ts
@@ -1,7 +1,7 @@
-import { Bot, DiscordGuildMemberAdd, DiscordGuildMemberRemove } from '@discordeno/bot';
+import { Bot, DiscordGuildMemberAdd, DiscordGuildMemberRemove, Guild, type DesiredPropertiesBehavior, type TransformersDesiredProperties } from '@discordeno/bot';
 import { BotWithProxyCache, ProxyCacheTypes } from './index.js';
 
-export const setupCacheEdits = <T extends ProxyCacheTypes, B extends Bot>(bot: BotWithProxyCache<T, B>) => {
+export const setupCacheEdits = <T extends ProxyCacheTypes<Props, Behavior>, Props extends TransformersDesiredProperties, Behavior extends DesiredPropertiesBehavior, B extends Bot<Props, Behavior>>(bot: BotWithProxyCache<T, Props, Behavior, B>) => {
     const { GUILD_MEMBER_ADD, GUILD_MEMBER_REMOVE } = bot.handlers;
 
     bot.handlers.GUILD_MEMBER_ADD = async (_, data, shardId) => {
@@ -11,7 +11,7 @@ export const setupCacheEdits = <T extends ProxyCacheTypes, B extends Bot>(bot: B
         const guild = bot.cache.guilds.memory.get(guildID);
 
         if (guild) {
-            if (guild.memberCount) guild.memberCount++;
+            if ('memberCount' in guild) (guild.memberCount as Guild['memberCount'])++;
 
             await bot.cache.guilds.set(guild);
         }
@@ -26,7 +26,7 @@ export const setupCacheEdits = <T extends ProxyCacheTypes, B extends Bot>(bot: B
         const guild = bot.cache.guilds.memory.get(guildID);
 
         if (guild) {
-            if (guild.memberCount) guild.memberCount--;
+            if ('memberCount' in guild) (guild.memberCount as Guild['memberCount'])--;
 
             await bot.cache.guilds.set(guild);
         }
diff --git a/setupCacheRemovals.ts b/setupCacheRemovals.ts
index 7ba663a..769b720 100644
--- a/setupCacheRemovals.ts
+++ b/setupCacheRemovals.ts
@@ -1,7 +1,7 @@
-import { Bot, DiscordChannel, DiscordGuildBanAddRemove, DiscordGuildMemberRemove, DiscordGuildRoleDelete, DiscordUnavailableGuild } from '@discordeno/bot';
+import { Bot, DiscordChannel, DiscordGuildBanAddRemove, DiscordGuildMemberRemove, DiscordGuildRoleDelete, DiscordUnavailableGuild, type DesiredPropertiesBehavior, type TransformersDesiredProperties } from '@discordeno/bot';
 import { BotWithProxyCache, ProxyCacheTypes } from './index.js';
 
-export const setupCacheRemovals = <T extends ProxyCacheTypes, B extends Bot>(bot: BotWithProxyCache<T, B>) => {
+export const setupCacheRemovals = <T extends ProxyCacheTypes<Props, Behavior>, Props extends TransformersDesiredProperties, Behavior extends DesiredPropertiesBehavior, B extends Bot<Props, Behavior>>(bot: BotWithProxyCache<T, Props, Behavior, B>) => {
     const { CHANNEL_DELETE, GUILD_BAN_ADD, GUILD_DELETE, GUILD_MEMBER_REMOVE, GUILD_ROLE_DELETE, THREAD_DELETE } = bot.handlers;
 
     bot.handlers.CHANNEL_DELETE = (_, data, shardId) => {
diff --git a/setupDummyEvents.ts b/setupDummyEvents.ts
index 8f11573..14b7ab3 100644
--- a/setupDummyEvents.ts
+++ b/setupDummyEvents.ts
@@ -1,10 +1,12 @@
-import { Bot, EventHandlers } from '@discordeno/bot';
+import { Bot, DesiredPropertiesBehavior, EventHandlers, TransformersDesiredProperties } from '@discordeno/bot';
 import { BotWithProxyCache, ProxyCacheTypes } from './index.js';
 
 const ignore = () => {};
 
-export const setupDummyEvents = <T extends ProxyCacheTypes, B extends Bot>(bot: BotWithProxyCache<T, B>) => {
-    const eventsRequired = new Set<keyof EventHandlers>();
+type EventHandlersKeys = keyof EventHandlers<TransformersDesiredProperties, DesiredPropertiesBehavior>;
+
+export const setupDummyEvents = <T extends ProxyCacheTypes<Props, Behavior>, Props extends TransformersDesiredProperties, Behavior extends DesiredPropertiesBehavior, B extends Bot<Props, Behavior>>(bot: BotWithProxyCache<T, Props, Behavior, B>) => {
+    const eventsRequired = new Set<EventHandlersKeys>();
     const { cacheInMemory, cacheOutsideMemory } = bot.cache.options || {};
 
     // Guild
@@ -40,14 +42,14 @@ export const setupDummyEvents = <T extends ProxyCacheTypes, B extends Bot>(bot:
 
 // Handlers: GUILD_CREATE, GUILD_UPDATE
 // Transformers: None
-const setupDummyGuildEvents = (eventsRequired: Set<keyof EventHandlers>) => {
+const setupDummyGuildEvents = (eventsRequired: Set<EventHandlersKeys>) => {
     eventsRequired.add('guildCreate');
     eventsRequired.add('guildUpdate');
 };
 
 // Handlers: CHANNEL_CREATE, CHANNEL_DELETE, CHANNEL_UPDATE, THREAD_CREATE, THREAD_DELETE, THREAD_UPDATE, THREAD_LIST_SYNC
 // Transformers: Guild, Interaction, Message
-const setupDummyChannelEvents = (eventsRequired: Set<keyof EventHandlers>) => {
+const setupDummyChannelEvents = (eventsRequired: Set<EventHandlersKeys>) => {
     eventsRequired.add('channelCreate');
     eventsRequired.add('channelDelete');
     eventsRequired.add('channelUpdate');
@@ -63,7 +65,7 @@ const setupDummyChannelEvents = (eventsRequired: Set<keyof EventHandlers>) => {
 
 // Handlers: GUILD_ROLE_CREATE, GUILD_ROLE_UPDATE
 // Transformers: Guild, Interaction
-const setupDummyRoleEvents = (eventsRequired: Set<keyof EventHandlers>) => {
+const setupDummyRoleEvents = (eventsRequired: Set<EventHandlersKeys>) => {
     eventsRequired.add('roleCreate');
     eventsRequired.add('roleUpdate');
 
@@ -73,7 +75,7 @@ const setupDummyRoleEvents = (eventsRequired: Set<keyof EventHandlers>) => {
 
 // Handlers: GUILD_MEMBER_ADD, GUILD_MEMBER_UPDATE, MESSAGE_REACTION_ADD, TYPING_START
 // Transformers: Guild, Interaction, Message, Stage Invite Instance (Invite)
-const setupDummyMemberEvents = (eventsRequired: Set<keyof EventHandlers>) => {
+const setupDummyMemberEvents = (eventsRequired: Set<EventHandlersKeys>) => {
     eventsRequired.add('guildMemberAdd');
     eventsRequired.add('guildMemberUpdate');
     eventsRequired.add('reactionAdd');
@@ -87,7 +89,7 @@ const setupDummyMemberEvents = (eventsRequired: Set<keyof EventHandlers>) => {
 
 // Handlers: GUILD_BAN_ADD, GUILD_BAN_REMOVE, GUILD_MEMBER_ADD, GUILD_MEMBER_REMOVE, GUILD_MEMBER_UPDATE, MESSAGE_REACTION_ADD, READY, USER_UPDATE
 // Transformers: Application (Invite), Channel, Emoji, Integration, Interaction, Invite, Member, Message, Presence, Scheduled Event, Sticker    Pack (REST Only), Team (Application (Invite)), Template (REST Only), Webhook (REST Only)
-const setupDummyUserEvents = (eventsRequired: Set<keyof EventHandlers>) => {
+const setupDummyUserEvents = (eventsRequired: Set<EventHandlersKeys>) => {
     eventsRequired.add('guildBanAdd');
     eventsRequired.add('guildBanRemove');
     eventsRequired.add('guildMemberAdd');
@@ -110,7 +112,7 @@ const setupDummyUserEvents = (eventsRequired: Set<keyof EventHandlers>) => {
 
 // Handlers: GUILD_EMOJIS_UPDATE, MESSAGE_REACTION_ADD, MESSAGE_REACTION_REMOVE_EMOJI, MESSAGE_REACTION_REMOVE
 // Transformers: Guild, Message, Onboarding (REST Only), Poll (Message)
-const setupDummyEmojiEvents = (eventsRequired: Set<keyof EventHandlers>) => {
+const setupDummyEmojiEvents = (eventsRequired: Set<EventHandlersKeys>) => {
     eventsRequired.add('guildEmojisUpdate');
     eventsRequired.add('reactionAdd');
     eventsRequired.add('reactionRemoveEmoji');
@@ -122,26 +124,26 @@ const setupDummyEmojiEvents = (eventsRequired: Set<keyof EventHandlers>) => {
 
 // Handlers: INTEGRATION_CREATE, INTEGRATION_UPDATE
 // Transformers: None
-const setupDummyIntegrationEvents = (eventsRequired: Set<keyof EventHandlers>) => {
+const setupDummyIntegrationEvents = (eventsRequired: Set<EventHandlersKeys>) => {
     eventsRequired.add('integrationCreate');
     eventsRequired.add('integrationUpdate');
 };
 
 // Handlers: INTERACTION_CREATE
 // Transformers: None
-const setupDummyInteractionEvents = (eventsRequired: Set<keyof EventHandlers>) => {
+const setupDummyInteractionEvents = (eventsRequired: Set<EventHandlersKeys>) => {
     eventsRequired.add('interactionCreate');
 };
 
 // Handlers: INVITE_CREATE
 // Transformers: None
-const setupDummyInviteEvents = (eventsRequired: Set<keyof EventHandlers>) => {
+const setupDummyInviteEvents = (eventsRequired: Set<EventHandlersKeys>) => {
     eventsRequired.add('inviteCreate');
 };
 
 // Handlers: MESSAGE_CREATE, MESSAGE_UPDATE
 // Transformers: Interaction, Message (Self)
-const setupDummyMessageEvents = (eventsRequired: Set<keyof EventHandlers>) => {
+const setupDummyMessageEvents = (eventsRequired: Set<EventHandlersKeys>) => {
     eventsRequired.add('messageCreate');
     eventsRequired.add('messageUpdate');
 
@@ -150,7 +152,7 @@ const setupDummyMessageEvents = (eventsRequired: Set<keyof EventHandlers>) => {
 
 // Handlers: PRESENCE_UPDATE
 // Transformers: Guild
-const setupDummyPresenceEvents = (eventsRequired: Set<keyof EventHandlers>) => {
+const setupDummyPresenceEvents = (eventsRequired: Set<EventHandlersKeys>) => {
     eventsRequired.add('presenceUpdate');
 
     setupDummyGuildEvents(eventsRequired);
@@ -158,7 +160,7 @@ const setupDummyPresenceEvents = (eventsRequired: Set<keyof EventHandlers>) => {
 
 // Handlers: GUILD_SCHEDULED_EVENT_CREATE, GUILD_SCHEDULED_EVENT_DELETE, GUILD_SCHEDULED_EVENT_UPDATE
 // Transformers: Invite
-const setupDummyScheduledEventEvents = (eventsRequired: Set<keyof EventHandlers>) => {
+const setupDummyScheduledEventEvents = (eventsRequired: Set<EventHandlersKeys>) => {
     eventsRequired.add('scheduledEventCreate');
     eventsRequired.add('scheduledEventDelete');
     eventsRequired.add('scheduledEventUpdate');