seyfert 1.2.2 → 1.3.0

package/lib/cache/resources/voice-states.d.ts

@@ -4,10 +4,11 @@ import { VoiceState } from '../../structures';
 import { GuildBasedResource } from './default/guild-based';
 export declare class VoiceStates extends GuildBasedResource {
     namespace: string;
+    filter(data: GatewayVoiceState, id: string, guild_id: string): boolean;
+    parse(data: any, id: string, guild_id: string): any;
     get(memberId: string, guildId: string): ReturnCache<VoiceState | undefined>;
     bulk(ids: string[], guild: string): ReturnCache<VoiceState[]>;
     values(guildId: string): ReturnCache<VoiceState[]>;
-    parse(data: any, id: string, guild_id: string): any;
 }
 export type VoiceStateResource = Omit<GatewayVoiceState, 'member'> & {
     guild_id: string;

package/lib/cache/resources/voice-states.js

@@ -6,6 +6,14 @@ const structures_1 = require("../../structures");
 const guild_based_1 = require("./default/guild-based");
 class VoiceStates extends guild_based_1.GuildBasedResource {
     namespace = 'voice_state';
+    //@ts-expect-error
+    filter(data, id, guild_id) {
+        return true;
+    }
+    parse(data, id, guild_id) {
+        const { member, ...rest } = super.parse(data, id, guild_id);
+        return rest;
+    }
     get(memberId, guildId) {
         return (0, common_1.fakePromise)(super.get(memberId, guildId)).then(state => state ? new structures_1.VoiceState(this.client, state) : undefined);
     }
@@ -15,9 +23,5 @@ class VoiceStates extends guild_based_1.GuildBasedResource {
     values(guildId) {
         return (0, common_1.fakePromise)(super.values(guildId)).then(states => states.map(state => new structures_1.VoiceState(this.client, state)));
     }
-    parse(data, id, guild_id) {
-        const { member, ...rest } = super.parse(data, id, guild_id);
-        return rest;
-    }
 }
 exports.VoiceStates = VoiceStates;

package/lib/client/base.d.ts

@@ -1,15 +1,14 @@
 import { ApiHandler } from '../api';
 import type { Adapter } from '../cache';
 import { Cache } from '../cache';
-import type { Command, ContextMenuCommand, RegisteredMiddlewares } from '../commands';
-import type { InferWithPrefix, MiddlewareContext } from '../commands/applications/shared';
-import { type CommandHandlerLike } from '../commands/handler';
-import { ChannelShorter, EmojiShorter, GuildShorter, Logger, MemberShorter, MessageShorter, ReactionShorter, RoleShorter, TemplateShorter, UsersShorter, WebhookShorter, type MakeRequired } from '../common';
+import type { Command, RegisteredMiddlewares } from '../commands';
+import { type InferWithPrefix, type MiddlewareContext } from '../commands/applications/shared';
+import { CommandHandler } from '../commands/handler';
+import { ChannelShorter, EmojiShorter, GuildShorter, InteractionShorter, Logger, MemberShorter, MessageShorter, ReactionShorter, RoleShorter, TemplateShorter, ThreadShorter, UsersShorter, WebhookShorter, type MakeRequired } from '../common';
 import type { LocaleString } from 'discord-api-types/rest/v10';
 import type { DeepPartial, IntentStrings, OmitInsert, When } from '../common/types/util';
-import type { ComponentCommand, ModalCommand } from '../components';
-import { type ComponentHandlerLike } from '../components/handler';
-import { type LangsHandlerLike } from '../langs/handler';
+import { ComponentHandler } from '../components/handler';
+import { LangsHandler } from '../langs/handler';
 import type { ChatInputCommandInteraction, ComponentInteraction, Message, MessageCommandInteraction, UserCommandInteraction } from '../structures';
 export declare class BaseClient {
     rest: ApiHandler;
@@ -24,11 +23,13 @@ export declare class BaseClient {
     roles: RoleShorter;
     reactions: ReactionShorter;
     emojis: EmojiShorter;
+    threads: ThreadShorter;
+    interactions: InteractionShorter;
     debugger?: Logger;
     logger: Logger;
-    langs?: LangsHandlerLike;
-    commands?: CommandHandlerLike;
-    components?: ComponentHandlerLike;
+    langs?: LangsHandler | undefined;
+    commands?: CommandHandler | undefined;
+    components?: ComponentHandler | undefined;
     private _applicationId?;
     private _botId?;
     middlewares?: Record<string, MiddlewareContext>;
@@ -54,7 +55,7 @@ export declare class BaseClient {
     };
     getRC<T extends InternalRuntimeConfigHTTP | InternalRuntimeConfig = InternalRuntimeConfigHTTP | InternalRuntimeConfig>(): Promise<{
         debug: boolean;
-    } & Omit<T, "debug" | "locations"> & {
+    } & Omit<T, "locations" | "debug"> & {
         templates: string | undefined;
         langs: string | undefined;
         events: string | undefined;
@@ -67,6 +68,17 @@ export declare class BaseClient {
 export interface BaseClientOptions {
     context?: (interaction: ChatInputCommandInteraction<boolean> | UserCommandInteraction<boolean> | MessageCommandInteraction<boolean> | ComponentInteraction | When<InferWithPrefix, Message, never>) => {};
     globalMiddlewares?: readonly (keyof RegisteredMiddlewares)[];
+    commands?: {
+        defaults?: {
+            onRunError?: Command['onRunError'];
+            onPermissionsFail?: Command['onPermissionsFail'];
+            onBotPermissionsFail?: Command['onBotPermissionsFail'];
+            onInternalError?: Command['onInternalError'];
+            onMiddlewaresError?: Command['onMiddlewaresError'];
+            onOptionsError?: Command['onOptionsError'];
+            onAfterRun?: Command['onAfterRun'];
+        };
+    };
 }
 export interface StartOptions {
     eventsDir: string;
@@ -123,9 +135,9 @@ export interface ServicesOptions {
     };
     middlewares?: Record<string, MiddlewareContext>;
     handlers?: {
-        components?: ComponentHandlerLike | ((component: ComponentCommand | ModalCommand) => any);
-        commands?: CommandHandlerLike | ((command: Command | ContextMenuCommand) => any);
-        langs?: LangsHandlerLike | ((locale: string, record: Record<string, unknown>) => any);
+        components?: ComponentHandler | ComponentHandler['callback'];
+        commands?: CommandHandler | Parameters<CommandHandler['setHandlers']>[0];
+        langs?: LangsHandler | LangsHandler['callback'];
     };
 }
 export {};

package/lib/client/base.js

@@ -4,6 +4,7 @@ exports.BaseClient = void 0;
 const node_path_1 = require("node:path");
 const api_1 = require("../api");
 const cache_1 = require("../cache");
+const shared_1 = require("../commands/applications/shared");
 const handler_1 = require("../commands/handler");
 const common_1 = require("../common");
 const handler_2 = require("../components/handler");
@@ -21,6 +22,8 @@ class BaseClient {
     roles = new common_1.RoleShorter(this);
     reactions = new common_1.ReactionShorter(this);
     emojis = new common_1.EmojiShorter(this);
+    threads = new common_1.ThreadShorter(this);
+    interactions = new common_1.InteractionShorter(this);
     debugger;
     logger = new common_1.Logger({
         name: '[Seyfert]',
@@ -41,7 +44,30 @@ class BaseClient {
     }
     options;
     constructor(options) {
-        this.options = options;
+        this.options = (0, common_1.MergeOptions)({
+            commands: {
+                defaults: {
+                    onRunError(context, error) {
+                        context.client.logger.fatal(`${context.command.name}.<onRunError>`, context.author.id, error);
+                    },
+                    onOptionsError(context, metadata) {
+                        context.client.logger.fatal(`${context.command.name}.<onOptionsError>`, context.author.id, metadata);
+                    },
+                    onMiddlewaresError(context, error) {
+                        context.client.logger.fatal(`${context.command.name}.<onMiddlewaresError>`, context.author.id, error);
+                    },
+                    onBotPermissionsFail(context, permissions) {
+                        context.client.logger.fatal(`${context.command.name}.<onBotPermissionsFail>`, context.author.id, permissions);
+                    },
+                    onPermissionsFail(context, permissions) {
+                        context.client.logger.fatal(`${context.command.name}.<onPermissionsFail>`, context.author.id, permissions);
+                    },
+                    onInternalError(client, command, error) {
+                        client.logger.fatal(`${command.name}.<onInternalError>`, error);
+                    },
+                },
+            },
+        }, options);
     }
     set botId(id) {
         this._botId = id;
@@ -74,8 +100,8 @@ class BaseClient {
                     this.components = undefined;
                 }
                 else if (typeof handlers.components === 'function') {
-                    this.components = new handler_2.ComponentHandler(this.logger, this);
-                    this.components.__callback = handlers.components;
+                    this.components ??= new handler_2.ComponentHandler(this.logger, this);
+                    this.components.setHandlers({ callback: handlers.components });
                 }
                 else {
                     this.components = handlers.components;
@@ -85,9 +111,9 @@ class BaseClient {
                 if (!handlers.commands) {
                     this.commands = undefined;
                 }
-                else if (typeof handlers.commands === 'function') {
-                    this.commands = new handler_1.CommandHandler(this.logger, this);
-                    this.commands.__callback = handlers.commands;
+                else if (typeof handlers.commands === 'object') {
+                    this.commands ??= new handler_1.CommandHandler(this.logger, this);
+                    this.commands.setHandlers(handlers.commands);
                 }
                 else {
                     this.commands = handlers.commands;
@@ -98,8 +124,8 @@ class BaseClient {
                     this.langs = undefined;
                 }
                 else if (typeof handlers.langs === 'function') {
-                    this.langs = new handler_3.LangsHandler(this.logger);
-                    this.langs.__callback = handlers.langs;
+                    this.langs ??= new handler_3.LangsHandler(this.logger);
+                    this.langs.setHandlers({ callback: handlers.langs });
                 }
                 else {
                     this.langs = handlers.langs;
@@ -155,14 +181,14 @@ class BaseClient {
     async uploadCommands(applicationId) {
         applicationId ??= await this.getRC().then(x => x.applicationId ?? this.applicationId);
         BaseClient.assertString(applicationId, 'applicationId is not a string');
-        const commands = this.commands.values.map(x => x.toJSON());
-        const filter = (0, common_1.filterSplit)(commands, command => !command.guild_id);
+        const commands = this.commands.values;
+        const filter = (0, common_1.filterSplit)(commands, command => !command.guildId);
         await this.proxy.applications(applicationId).commands.put({
-            body: filter.expect,
+            body: filter.expect.filter(cmd => !('ignore' in cmd) || cmd.ignore !== shared_1.IgnoreCommand.Slash).map(x => x.toJSON()),
         });
         const guilds = new Set();
         for (const command of filter.never) {
-            for (const guild_id of command.guild_id) {
+            for (const guild_id of command.guildId) {
                 guilds.add(guild_id);
             }
         }
@@ -171,7 +197,9 @@ class BaseClient {
                 .applications(applicationId)
                 .guilds(guild)
                 .commands.put({
-                body: filter.never.filter(x => x.guild_id?.includes(guild)),
+                body: filter.never
+                    .filter(cmd => cmd.guildId?.includes(guild) && (!('ignore' in cmd) || cmd.ignore !== shared_1.IgnoreCommand.Slash))
+                    .map(x => x.toJSON()),
             });
         }
     }

package/lib/client/client.d.ts

@@ -1,6 +1,7 @@
 import { type GatewayDispatchPayload, type GatewayPresenceUpdateData } from 'discord-api-types/v10';
-import type { ClientEvent, Command, CommandContext, EventHandlerLike, Message, SubCommand } from '..';
+import type { Command, CommandContext, Message, SubCommand } from '..';
 import type { DeepPartial, If } from '../common';
+import { EventHandler } from '../events';
 import { ClientUser } from '../structures';
 import { ShardManager, type ShardManagerOptions } from '../websocket';
 import { MemberUpdateHandler } from '../websocket/discord/events/memberUpdate';
@@ -10,7 +11,7 @@ import { BaseClient } from './base';
 export declare class Client<Ready extends boolean = boolean> extends BaseClient {
     private __handleGuilds?;
     gateway: ShardManager;
-    events?: EventHandlerLike;
+    events?: EventHandler | undefined;
     me: If<Ready, ClientUser>;
     options: ClientOptions | undefined;
     memberUpdateHandler: MemberUpdateHandler;
@@ -19,7 +20,7 @@ export declare class Client<Ready extends boolean = boolean> extends BaseClient
     setServices({ gateway, ...rest }: ServicesOptions & {
         gateway?: ShardManager;
         handlers?: ServicesOptions['handlers'] & {
-            events?: EventHandlerLike | ((event: ClientEvent) => any);
+            events?: EventHandler['callback'];
         };
     }): void;
     loadEvents(dir?: string): Promise<void>;
@@ -41,8 +42,8 @@ export interface ClientOptions extends BaseClientOptions {
         properties?: Partial<ShardManagerOptions['properties']>;
         compress?: ShardManagerOptions['compress'];
     };
-    commands?: {
-        prefix: (message: Message) => Promise<string[]> | string[];
+    commands?: BaseClientOptions['commands'] & {
+        prefix?: (message: Message) => Promise<string[]> | string[];
         deferReplyResponse?: (ctx: CommandContext) => Parameters<Message['write']>[0];
         reply?: (ctx: CommandContext) => boolean;
         argsParser?: (content: string, command: SubCommand | Command) => Record<string, string>;

package/lib/client/client.js

@@ -38,7 +38,9 @@ class Client extends base_1.BaseClient {
             }
             else if (typeof rest.handlers.events === 'function') {
                 this.events = new events_1.EventHandler(this.logger);
-                this.events.__callback = rest.handlers.events;
+                this.events.setHandlers({
+                    callback: rest.handlers.events,
+                });
             }
             else {
                 this.events = rest.handlers.events;
@@ -121,6 +123,16 @@ class Client extends base_1.BaseClient {
                 await this.events?.execute(packet.t, packet, this, shardId);
                 await this.cache.onPacket(packet);
                 break;
+            case 'MESSAGE_UPDATE':
+            case 'MESSAGE_DELETE_BULK':
+            case 'MESSAGE_DELETE':
+                await this.events?.execute(packet.t, packet, this, shardId);
+                await this.cache.onPacket(packet);
+                break;
+            case 'GUILD_DELETE':
+            case 'CHANNEL_UPDATE':
+                await this.events?.execute(packet.t, packet, this, shardId);
+                break;
             //rest of the events
             default: {
                 await this.cache.onPacket(packet);

package/lib/client/oninteractioncreate.js

@@ -33,7 +33,7 @@ async function onInteractionCreate(self, body, shardId, __reply) {
                 }
                 catch (error) {
                     try {
-                        await optionsResolver.getCommand()?.onInternalError?.(self, error);
+                        await optionsResolver.getCommand()?.onInternalError?.(self, optionsResolver.getCommand(), error);
                     }
                     catch {
                         // supress error
@@ -152,7 +152,7 @@ async function onInteractionCreate(self, body, shardId, __reply) {
                             }
                             catch (error) {
                                 try {
-                                    await command.onInternalError?.(self, error);
+                                    await command.onInternalError?.(self, context.command, error);
                                 }
                                 catch {
                                     // supress error

package/lib/client/onmessagecreate.js

@@ -5,18 +5,21 @@ const v10_1 = require("discord-api-types/v10");
 const __1 = require("..");
 const structures_1 = require("../structures");
 function getCommandFromContent(commandRaw, self) {
-    const parentName = commandRaw[0];
-    const groupName = commandRaw.length === 3 ? commandRaw[1] : undefined;
-    const subcommandName = groupName ? commandRaw[2] : commandRaw[1];
-    const parent = self.commands.values.find(x => x.name === parentName);
-    const fullCommandName = `${parentName}${groupName ? ` ${groupName} ${subcommandName}` : `${subcommandName ? ` ${subcommandName}` : ''}`}`;
+    const rawParentName = commandRaw[0];
+    const rawGroupName = commandRaw.length === 3 ? commandRaw[1] : undefined;
+    const rawSubcommandName = rawGroupName ? commandRaw[2] : commandRaw[1];
+    const parent = self.commands.values.find(x => (!('ignore' in x) || x.ignore !== __1.IgnoreCommand.Message) &&
+        (x.name === rawParentName || ('aliases' in x ? x.aliases?.includes(rawParentName) : false)));
+    const fullCommandName = `${rawParentName}${rawGroupName ? ` ${rawGroupName} ${rawSubcommandName}` : `${rawSubcommandName ? ` ${rawSubcommandName}` : ''}`}`;
     if (!(parent instanceof __1.Command))
         return { fullCommandName };
-    if (groupName && !parent.groups?.[groupName])
-        return getCommandFromContent([parentName, groupName], self);
-    if (subcommandName && !parent.options?.some(x => x instanceof __1.SubCommand && x.name === subcommandName))
-        return getCommandFromContent([parentName], self);
-    const command = groupName || subcommandName
+    if (rawGroupName && !parent.groups?.[rawGroupName] && !parent.groupsAliases?.[rawGroupName])
+        return getCommandFromContent([rawParentName, rawGroupName], self);
+    if (rawSubcommandName &&
+        !parent.options?.some(x => x instanceof __1.SubCommand && (x.name === rawSubcommandName || x.aliases?.includes(rawSubcommandName))))
+        return getCommandFromContent([rawParentName], self);
+    const groupName = rawGroupName ? parent.groupsAliases?.[rawGroupName] || rawGroupName : undefined;
+    const command = groupName || rawSubcommandName
         ? parent.options?.find(opt => {
             if (opt instanceof __1.SubCommand) {
                 if (groupName) {
@@ -25,7 +28,7 @@ function getCommandFromContent(commandRaw, self) {
                 }
                 if (opt.group && !groupName)
                     return false;
-                return subcommandName === opt.name;
+                return rawSubcommandName === opt.name || opt.aliases?.includes(rawSubcommandName);
             }
             return false;
         })
@@ -37,10 +40,10 @@ function getCommandFromContent(commandRaw, self) {
     };
 }
 async function onMessageCreate(self, rawMessage, shardId) {
-    if (!self.options?.commands)
+    if (!self.options?.commands?.prefix)
         return;
     const message = new structures_1.Message(self, rawMessage);
-    const prefixes = ((await self.options.commands.prefix?.(message)) ?? []).sort((a, b) => b.length - a.length);
+    const prefixes = (await self.options.commands.prefix(message)).sort((a, b) => b.length - a.length);
     const prefix = prefixes.find(x => message.content.startsWith(x));
     if (!prefix || !message.content.startsWith(prefix))
         return;
@@ -131,7 +134,7 @@ async function onMessageCreate(self, rawMessage, shardId) {
     }
     catch (error) {
         try {
-            await command.onInternalError?.(self, error);
+            await command.onInternalError?.(self, context.command, error);
         }
         catch {
             // supress error

package/lib/client/workerclient.d.ts

@@ -7,7 +7,7 @@ import { type GatewayDispatchPayload } from 'discord-api-types/v10';
 import { Logger } from '..';
 import type { Cache } from '../cache';
 import { type DeepPartial, type When } from '../common';
-import { type EventHandlerLike } from '../events';
+import { EventHandler } from '../events';
 import { ClientUser } from '../structures';
 import { Shard, type ShardManagerOptions } from '../websocket';
 import type { WorkerShardInfo } from '../websocket/discord/worker';
@@ -18,7 +18,7 @@ import type { Client } from './client';
 export declare class WorkerClient<Ready extends boolean = boolean> extends BaseClient {
     private __handleGuilds?;
     logger: Logger;
-    events?: EventHandlerLike;
+    events?: EventHandler | undefined;
     me: When<Ready, ClientUser>;
     promises: Map<string, {
         resolve: (value: any) => void;
@@ -31,7 +31,7 @@ export declare class WorkerClient<Ready extends boolean = boolean> extends BaseC
     get latency(): number;
     setServices({ ...rest }: ServicesOptions & {
         handlers?: ServicesOptions['handlers'] & {
-            events?: EventHandlerLike;
+            events?: EventHandler['callback'];
         };
     }): void;
     start(options?: Omit<DeepPartial<StartOptions>, 'httpConnection' | 'token' | 'connection'>): Promise<void>;

package/lib/client/workerclient.js

@@ -78,7 +78,18 @@ class WorkerClient extends base_1.BaseClient {
     setServices({ ...rest }) {
         super.setServices(rest);
         if (rest.handlers && 'events' in rest.handlers) {
-            this.events = rest.handlers.events;
+            if (!rest.handlers.events) {
+                this.events = undefined;
+            }
+            else if (typeof rest.handlers.events === 'function') {
+                this.events = new events_1.EventHandler(this.logger);
+                this.events.setHandlers({
+                    callback: rest.handlers.events,
+                });
+            }
+            else {
+                this.events = rest.handlers.events;
+            }
         }
     }
     async start(options = {}) {
@@ -216,8 +227,8 @@ class WorkerClient extends base_1.BaseClient {
                     let result;
                     try {
                         // biome-ignore lint/security/noGlobalEval: yes
-                        result = await eval(`
-					(${data.func})(this)
+                        result = await eval(`
+					(${data.func})(this)
 					`);
                     }
                     catch (e) {
@@ -251,19 +262,13 @@ class WorkerClient extends base_1.BaseClient {
         return nonce;
     }
     generateSendPromise(nonce, message = 'Timeout') {
-        let resolve = (_) => {
-            /**/
-        };
-        let timeout = -1;
-        const promise = new Promise((res, rej) => {
-            resolve = res;
-            timeout = setTimeout(() => {
+        return new Promise((res, rej) => {
+            const timeout = setTimeout(() => {
                 this.promises.delete(nonce);
                 rej(new Error(message));
             }, 60e3);
+            this.promises.set(nonce, { resolve: res, timeout });
         });
-        this.promises.set(nonce, { resolve, timeout });
-        return promise;
     }
     tellWorker(workerId, func) {
         const nonce = this.generateNonce();
@@ -280,12 +285,16 @@ class WorkerClient extends base_1.BaseClient {
         await this.events?.execute('RAW', packet, this, shardId);
         switch (packet.t) {
             case 'GUILD_MEMBER_UPDATE':
+            case 'PRESENCE_UPDATE':
+            case 'MESSAGE_UPDATE':
+            case 'MESSAGE_DELETE_BULK':
+            case 'MESSAGE_DELETE':
                 await this.events?.execute(packet.t, packet, this, shardId);
                 await this.cache.onPacket(packet);
                 break;
-            case 'PRESENCE_UPDATE':
+            case 'GUILD_DELETE':
+            case 'CHANNEL_UPDATE':
                 await this.events?.execute(packet.t, packet, this, shardId);
-                await this.cache.onPacket(packet);
                 break;
             //rest of the events
             default:

package/lib/collection.d.ts

@@ -119,9 +119,10 @@ type LimitedCollectionData<V> = {
     expireOn: number;
     value: V;
 };
-export interface LimitedCollectionOptions {
+export interface LimitedCollectionOptions<K, V> {
     limit: number;
     expire: number;
+    onDelete?: (key: K, value: V) => void;
     resetOnDemand: boolean;
 }
 /**
@@ -138,11 +139,11 @@ export interface LimitedCollectionOptions {
  * console.log(mappedArray); // Output: ['1: one', '2: two', '3: three']
  */
 export declare class LimitedCollection<K, V> {
-    static readonly default: LimitedCollectionOptions;
+    static readonly default: LimitedCollectionOptions<any, any>;
     private readonly data;
     private readonly options;
     private timeout;
-    constructor(options?: Partial<LimitedCollectionOptions>);
+    constructor(options?: Partial<LimitedCollectionOptions<K, V>>);
     /**
      * Adds an element to the limited collection.
      * @param key The key of the element.
@@ -228,6 +229,10 @@ export declare class LimitedCollection<K, V> {
     private resetTimeout;
     private stopTimeout;
     private startTimeout;
+    keys(): () => IterableIterator<K>;
+    values(): () => IterableIterator<LimitedCollectionData<V>>;
+    entries(): IterableIterator<[K, LimitedCollectionData<V>]>;
+    clear(): void;
     private clearExpired;
 }
 export {};

package/lib/collection.js

@@ -230,7 +230,8 @@ class LimitedCollection {
         if (this.size > this.options.limit) {
             const iter = this.data.keys();
             while (this.size > this.options.limit) {
-                this.delete(iter.next().value);
+                const keyValue = iter.next().value;
+                this.delete(keyValue);
             }
         }
         if (this.closer?.expireOn === expireOn) {
@@ -265,7 +266,7 @@ class LimitedCollection {
         if (this.options.resetOnDemand && data && data.expire !== -1) {
             const oldExpireOn = data.expireOn;
             data.expireOn = Date.now() + data.expire;
-            if (this.closer.expireOn === oldExpireOn) {
+            if (this.closer?.expireOn === oldExpireOn) {
                 this.resetTimeout();
             }
         }
@@ -296,8 +297,11 @@ class LimitedCollection {
      */
     delete(key) {
         const value = this.raw(key);
-        if (value && value.expireOn === this.closer.expireOn)
-            setImmediate(() => this.resetTimeout());
+        if (value) {
+            if (value.expireOn === this.closer?.expireOn)
+                setImmediate(() => this.resetTimeout());
+            this.options.onDelete?.(key, value.value);
+        }
         return this.data.delete(key);
     }
     /**
@@ -360,12 +364,26 @@ class LimitedCollection {
             this.resetTimeout();
         }, expireOn - Date.now());
     }
+    keys() {
+        return this.data.keys;
+    }
+    values() {
+        return this.data.values;
+    }
+    entries() {
+        return this.data.entries();
+    }
+    clear() {
+        this.data.clear();
+        this.resetTimeout();
+    }
     clearExpired() {
         for (const [key, value] of this.data) {
             if (value.expireOn === -1) {
                 continue;
             }
             if (Date.now() >= value.expireOn) {
+                this.options.onDelete?.(key, value.value);
                 this.data.delete(key);
             }
         }

package/lib/commands/applications/chat.d.ts

@@ -5,7 +5,7 @@ import { type FlatObjectKeys } from '../../common';
 import type { AllChannels, AutocompleteInteraction, GuildRole, InteractionGuildMember, User } from '../../structures';
 import type { Groups, IntegrationTypes, InteractionContextTypes, RegisteredMiddlewares } from '../decorators';
 import type { CommandContext } from './chatcontext';
-import type { DefaultLocale, OKFunction, OnOptionsReturnObject, StopFunction, UsingClient } from './shared';
+import type { DefaultLocale, IgnoreCommand, OKFunction, OnOptionsReturnObject, StopFunction, UsingClient } from './shared';
 export interface ReturnOptionsTypes {
     1: never;
     2: never;
@@ -72,11 +72,6 @@ declare class BaseCommand {
         description: string | undefined;
     };
     __autoload?: true;
-    __tGroups?: Record<string, {
-        name: string | undefined;
-        description: string | undefined;
-        defaultDescription: string;
-    }>;
     guildId?: string[];
     name: string;
     type: number;
@@ -89,6 +84,8 @@ declare class BaseCommand {
     name_localizations?: Partial<Record<LocaleString, string>>;
     description_localizations?: Partial<Record<LocaleString, string>>;
     options?: CommandOption[] | SubCommand[];
+    ignore?: IgnoreCommand;
+    aliases?: string[];
     toJSON(): {
         name: BaseCommand['name'];
         type: BaseCommand['type'];
@@ -102,18 +99,24 @@ declare class BaseCommand {
         integration_types: BaseCommand['integrationTypes'];
     };
     reload(): Promise<void>;
-    run?(context: CommandContext<any>): any;
-    onAfterRun?(context: CommandContext<any>, error: unknown | undefined): any;
-    onRunError?(context: CommandContext<any>, error: unknown): any;
-    onOptionsError?(context: CommandContext<{}, never>, metadata: OnOptionsReturnObject): any;
-    onMiddlewaresError?(context: CommandContext<{}, never>, error: string): any;
-    onBotPermissionsFail?(context: CommandContext<{}, never>, permissions: PermissionStrings): any;
-    onPermissionsFail?(context: CommandContext<{}, never>, permissions: PermissionStrings): any;
-    onInternalError?(client: UsingClient, error?: unknown): any;
+    run?(context: CommandContext): any;
+    onAfterRun?(context: CommandContext, error: unknown | undefined): any;
+    onRunError?(context: CommandContext, error: unknown): any;
+    onOptionsError?(context: CommandContext, metadata: OnOptionsReturnObject): any;
+    onMiddlewaresError?(context: CommandContext, error: string): any;
+    onBotPermissionsFail?(context: CommandContext, permissions: PermissionStrings): any;
+    onPermissionsFail?(context: CommandContext, permissions: PermissionStrings): any;
+    onInternalError?(client: UsingClient, command: Command | SubCommand, error?: unknown): any;
 }
 export declare class Command extends BaseCommand {
     type: ApplicationCommandType;
     groups?: Parameters<typeof Groups>[0];
+    groupsAliases?: Record<string, string>;
+    __tGroups?: Record<string, {
+        name: string | undefined;
+        description: string | undefined;
+        defaultDescription: string;
+    }>;
     toJSON(): {
         options: APIApplicationCommandOption[];
         name: string;
@@ -127,12 +130,6 @@ export declare class Command extends BaseCommand {
         contexts: InteractionContextTypes[] | undefined;
         integration_types: IntegrationTypes[] | undefined;
     };
-    onRunError(context: CommandContext<any>, error: unknown): any;
-    onOptionsError(context: CommandContext<{}, never>, metadata: OnOptionsReturnObject): any;
-    onMiddlewaresError(context: CommandContext<{}, never>, error: string): any;
-    onBotPermissionsFail(context: CommandContext<{}, never>, permissions: PermissionStrings): any;
-    onPermissionsFail(context: CommandContext<{}, never>, permissions: PermissionStrings): any;
-    onInternalError(client: UsingClient, error?: unknown): any;
 }
 export declare abstract class SubCommand extends BaseCommand {
     type: ApplicationCommandOptionType;