seyfert 4.4.1 → 5.0.0

package/lib/commands/handle.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.HandleCommand = void 0;
+const plugins_1 = require("../client/plugins");
 const transformers_1 = require("../client/transformers");
 const constants_1 = require("../common/it/constants");
 const components_1 = require("../components");
@@ -13,6 +14,9 @@ class HandleCommand {
         this.client = client;
     }
     async autocomplete(interaction, optionsResolver, command) {
+        return (0, plugins_1.runPluginAutocompleteWrappers)(this.client, { client: this.client, command, interaction, optionsResolver }, () => this.runAutocomplete(interaction, optionsResolver, command));
+    }
+    async runAutocomplete(interaction, optionsResolver, command) {
         // idc, is a YOU problem
         if (!command?.autocomplete) {
             return this.client.logger.warn(`${optionsResolver.fullCommandName} ${command?.name} command does not have 'autocomplete' callback`);
@@ -37,36 +41,43 @@ class HandleCommand {
         }
     }
     async contextMenu(command, interaction, context) {
-        try {
-            if (context.guildId && command.botPermissions) {
-                const permissions = this.checkPermissions(interaction.appPermissions, command.botPermissions);
-                if (permissions)
-                    return await command.onBotPermissionsFail?.(context, permissions);
-            }
-            await command.onBeforeMiddlewares?.(context);
-            const resultGlobal = await this.runGlobalMiddlewares(command, context);
-            if (typeof resultGlobal === 'boolean')
-                return;
-            const resultMiddle = await this.runMiddlewares(command, context);
-            if (typeof resultMiddle === 'boolean')
-                return;
+        return (0, plugins_1.runContextScopes)(this.client.options.contextScopes, context, async () => {
             try {
-                await command.run(context);
-                await command.onAfterRun?.(context, undefined);
+                if (context.guildId && command.botPermissions) {
+                    const permissions = this.checkPermissions(interaction.appPermissions, command.botPermissions);
+                    if (permissions)
+                        return await command.onBotPermissionsFail?.(context, permissions);
+                }
+                await command.onBeforeMiddlewares?.(context);
+                await (0, plugins_1.runPluginCommandObservers)(this.client, 'onBeforeMiddlewares', context);
+                const resultGlobal = await this.runGlobalMiddlewares(command, context);
+                if (typeof resultGlobal === 'boolean')
+                    return;
+                const resultMiddle = await this.runMiddlewares(command, context);
+                if (typeof resultMiddle === 'boolean')
+                    return;
+                try {
+                    await command.run(context);
+                    await command.onAfterRun?.(context, undefined);
+                    await (0, plugins_1.runPluginCommandObservers)(this.client, 'onAfterRun', context, undefined);
+                }
+                catch (error) {
+                    await command.onRunError?.(context, error);
+                    await (0, plugins_1.runPluginCommandObservers)(this.client, 'onRunError', context, error);
+                    await command.onAfterRun?.(context, error);
+                    await (0, plugins_1.runPluginCommandObservers)(this.client, 'onAfterRun', context, error);
+                }
             }
             catch (error) {
-                await command.onRunError?.(context, error);
-                await command.onAfterRun?.(context, error);
-            }
-        }
-        catch (error) {
-            try {
-                await command.onInternalError?.(this.client, command, error);
-            }
-            catch (err) {
-                this.client.logger.error(`[${command.name}] Internal error:`, err);
+                try {
+                    await command.onInternalError?.(this.client, command, error);
+                    await (0, plugins_1.runPluginCommandObservers)(this.client, 'onInternalError', this.client, command, error);
+                }
+                catch (err) {
+                    this.client.logger.error(`[${command.name}] Internal error:`, err);
+                }
             }
-        }
+        });
     }
     contextMenuMessage(command, interaction, context) {
         return this.contextMenu(command, interaction, context);
@@ -75,78 +86,93 @@ class HandleCommand {
         return this.contextMenu(command, interaction, context);
     }
     async entryPoint(command, interaction, context) {
-        try {
-            if (context.guildId && command.botPermissions) {
-                const permissions = this.checkPermissions(interaction.appPermissions, command.botPermissions);
-                if (permissions)
-                    return await command.onBotPermissionsFail(context, permissions);
-            }
-            await command.onBeforeMiddlewares?.(context);
-            const resultGlobal = await this.runGlobalMiddlewares(command, context);
-            if (typeof resultGlobal === 'boolean')
-                return;
-            const resultMiddle = await this.runMiddlewares(command, context);
-            if (typeof resultMiddle === 'boolean')
-                return;
-            try {
-                await command.run(context);
-                await command.onAfterRun?.(context, undefined);
-            }
-            catch (error) {
-                await command.onRunError(context, error);
-                await command.onAfterRun?.(context, error);
-            }
-        }
-        catch (error) {
+        return (0, plugins_1.runContextScopes)(this.client.options.contextScopes, context, async () => {
             try {
-                await command.onInternalError(this.client, command, error);
-            }
-            catch (err) {
-                this.client.logger.error(`[${command.name}] Internal error:`, err);
-            }
-        }
-    }
-    async chatInput(command, interaction, resolver, context) {
-        try {
-            if (context.guildId) {
-                if (command.botPermissions) {
+                if (context.guildId && command.botPermissions) {
                     const permissions = this.checkPermissions(interaction.appPermissions, command.botPermissions);
                     if (permissions)
-                        return await command.onBotPermissionsFail?.(context, permissions);
+                        return await command.onBotPermissionsFail(context, permissions);
                 }
-                if (command.defaultMemberPermissions) {
-                    const permissions = this.checkPermissions(interaction.member.permissions, command.defaultMemberPermissions);
-                    if (permissions)
-                        return await command.onPermissionsFail?.(context, permissions);
+                await command.onBeforeMiddlewares?.(context);
+                await (0, plugins_1.runPluginCommandObservers)(this.client, 'onBeforeMiddlewares', context);
+                const resultGlobal = await this.runGlobalMiddlewares(command, context);
+                if (typeof resultGlobal === 'boolean')
+                    return;
+                const resultMiddle = await this.runMiddlewares(command, context);
+                if (typeof resultMiddle === 'boolean')
+                    return;
+                try {
+                    await command.run(context);
+                    await command.onAfterRun?.(context, undefined);
+                    await (0, plugins_1.runPluginCommandObservers)(this.client, 'onAfterRun', context, undefined);
+                }
+                catch (error) {
+                    await command.onRunError(context, error);
+                    await (0, plugins_1.runPluginCommandObservers)(this.client, 'onRunError', context, error);
+                    await command.onAfterRun?.(context, error);
+                    await (0, plugins_1.runPluginCommandObservers)(this.client, 'onAfterRun', context, error);
                 }
-            }
-            await command.onBeforeOptions?.(context);
-            if (!(await this.runOptions(command, context, resolver)))
-                return;
-            await command.onBeforeMiddlewares?.(context);
-            const resultGlobal = await this.runGlobalMiddlewares(command, context);
-            if (typeof resultGlobal === 'boolean')
-                return;
-            const resultMiddle = await this.runMiddlewares(command, context);
-            if (typeof resultMiddle === 'boolean')
-                return;
-            try {
-                await command.run(context);
-                await command.onAfterRun?.(context, undefined);
             }
             catch (error) {
-                await command.onRunError?.(context, error);
-                await command.onAfterRun?.(context, error);
+                try {
+                    await command.onInternalError(this.client, command, error);
+                    await (0, plugins_1.runPluginCommandObservers)(this.client, 'onInternalError', this.client, command, error);
+                }
+                catch (err) {
+                    this.client.logger.error(`[${command.name}] Internal error:`, err);
+                }
             }
-        }
-        catch (error) {
+        });
+    }
+    async chatInput(command, interaction, resolver, context) {
+        return (0, plugins_1.runContextScopes)(this.client.options.contextScopes, context, async () => {
             try {
-                await command.onInternalError?.(this.client, command, error);
+                if (context.guildId) {
+                    if (command.botPermissions) {
+                        const permissions = this.checkPermissions(interaction.appPermissions, command.botPermissions);
+                        if (permissions)
+                            return await command.onBotPermissionsFail?.(context, permissions);
+                    }
+                    if (command.defaultMemberPermissions) {
+                        const permissions = this.checkPermissions(interaction.member.permissions, command.defaultMemberPermissions);
+                        if (permissions)
+                            return await command.onPermissionsFail?.(context, permissions);
+                    }
+                }
+                await command.onBeforeOptions?.(context);
+                await (0, plugins_1.runPluginCommandObservers)(this.client, 'onBeforeOptions', context);
+                if (!(await this.runOptions(command, context, resolver)))
+                    return;
+                await command.onBeforeMiddlewares?.(context);
+                await (0, plugins_1.runPluginCommandObservers)(this.client, 'onBeforeMiddlewares', context);
+                const resultGlobal = await this.runGlobalMiddlewares(command, context);
+                if (typeof resultGlobal === 'boolean')
+                    return;
+                const resultMiddle = await this.runMiddlewares(command, context);
+                if (typeof resultMiddle === 'boolean')
+                    return;
+                try {
+                    await command.run(context);
+                    await command.onAfterRun?.(context, undefined);
+                    await (0, plugins_1.runPluginCommandObservers)(this.client, 'onAfterRun', context, undefined);
+                }
+                catch (error) {
+                    await command.onRunError?.(context, error);
+                    await (0, plugins_1.runPluginCommandObservers)(this.client, 'onRunError', context, error);
+                    await command.onAfterRun?.(context, error);
+                    await (0, plugins_1.runPluginCommandObservers)(this.client, 'onAfterRun', context, error);
+                }
             }
-            catch (err) {
-                this.client.logger.error(`[${command.name}] Internal error:`, err);
+            catch (error) {
+                try {
+                    await command.onInternalError?.(this.client, command, error);
+                    await (0, plugins_1.runPluginCommandObservers)(this.client, 'onInternalError', this.client, command, error);
+                }
+                catch (err) {
+                    this.client.logger.error(`[${command.name}] Internal error:`, err);
+                }
             }
-        }
+        });
     }
     async modal(interaction) {
         const context = new components_1.ModalContext(this.client, interaction);
@@ -268,62 +294,81 @@ class HandleCommand {
         try {
             const args = this.argsParser(argsContent, command, message);
             const { options, errors } = await this.argsOptionsParser(command, rawMessage, args, resolved);
-            const optionsResolver = this.makeResolver(self, options, parent, rawMessage.guild_id, resolved);
+            const resolverOptions = command instanceof _1.SubCommand
+                ? [
+                    command.group
+                        ? {
+                            type: types_1.ApplicationCommandOptionType.SubcommandGroup,
+                            name: command.group,
+                            options: [{ type: types_1.ApplicationCommandOptionType.Subcommand, name: command.name, options }],
+                        }
+                        : { type: types_1.ApplicationCommandOptionType.Subcommand, name: command.name, options },
+                ]
+                : options;
+            const optionsResolver = this.makeResolver(self, resolverOptions, parent, rawMessage.guild_id, resolved);
             const context = new _1.CommandContext(self, message, optionsResolver, shardId, command);
             //@ts-expect-error
             const extendContext = self.options?.context?.(message) ?? {};
             Object.assign(context, extendContext);
-            if (errors.length) {
-                return await command.onOptionsError?.(context, Object.fromEntries(errors.map(x => {
-                    return [
-                        x.name,
-                        {
-                            failed: true,
-                            value: x.error,
-                            parseError: x.fullError,
-                        },
-                    ];
-                })));
-            }
-            if (rawMessage.guild_id) {
-                if (command.defaultMemberPermissions) {
-                    const memberPermissions = await self.members.permissions(rawMessage.guild_id, rawMessage.author.id);
-                    const permissions = this.checkPermissions(memberPermissions, command.defaultMemberPermissions);
-                    const guild = await this.client.guilds.raw(rawMessage.guild_id);
-                    if (permissions && guild.owner_id !== rawMessage.author.id) {
-                        return await command.onPermissionsFail?.(context, memberPermissions.keys(permissions));
-                    }
+            return await (0, plugins_1.runContextScopes)(self.options.contextScopes, context, async () => {
+                if (errors.length) {
+                    return await command.onOptionsError?.(context, Object.fromEntries(errors.map(x => {
+                        return [
+                            x.name,
+                            {
+                                failed: true,
+                                value: x.error,
+                                parseError: x.fullError,
+                            },
+                        ];
+                    })));
                 }
-                if (command.botPermissions) {
-                    const appPermissions = await self.members.permissions(rawMessage.guild_id, self.botId);
-                    const permissions = this.checkPermissions(appPermissions, command.botPermissions);
-                    if (permissions) {
-                        return await command.onBotPermissionsFail?.(context, permissions);
+                if (rawMessage.guild_id) {
+                    if (command.defaultMemberPermissions) {
+                        const memberPermissions = await self.members.permissions(rawMessage.guild_id, rawMessage.author.id);
+                        const permissions = this.checkPermissions(memberPermissions, command.defaultMemberPermissions);
+                        const guild = await this.client.guilds.raw(rawMessage.guild_id);
+                        if (permissions && guild.owner_id !== rawMessage.author.id) {
+                            return await command.onPermissionsFail?.(context, permissions);
+                        }
+                    }
+                    if (command.botPermissions) {
+                        const appPermissions = await self.members.permissions(rawMessage.guild_id, self.botId);
+                        const permissions = this.checkPermissions(appPermissions, command.botPermissions);
+                        if (permissions) {
+                            return await command.onBotPermissionsFail?.(context, permissions);
+                        }
                     }
                 }
-            }
-            await command.onBeforeOptions?.(context);
-            if (!(await this.runOptions(command, context, optionsResolver)))
-                return;
-            await command.onBeforeMiddlewares?.(context);
-            const resultGlobal = await this.runGlobalMiddlewares(command, context);
-            if (typeof resultGlobal === 'boolean')
-                return;
-            const resultMiddle = await this.runMiddlewares(command, context);
-            if (typeof resultMiddle === 'boolean')
-                return;
-            try {
-                await command.run(context);
-                await command.onAfterRun?.(context, undefined);
-            }
-            catch (error) {
-                await command.onRunError?.(context, error);
-                await command.onAfterRun?.(context, error);
-            }
+                await command.onBeforeOptions?.(context);
+                await (0, plugins_1.runPluginCommandObservers)(this.client, 'onBeforeOptions', context);
+                if (!(await this.runOptions(command, context, optionsResolver)))
+                    return;
+                await command.onBeforeMiddlewares?.(context);
+                await (0, plugins_1.runPluginCommandObservers)(this.client, 'onBeforeMiddlewares', context);
+                const resultGlobal = await this.runGlobalMiddlewares(command, context);
+                if (typeof resultGlobal === 'boolean')
+                    return;
+                const resultMiddle = await this.runMiddlewares(command, context);
+                if (typeof resultMiddle === 'boolean')
+                    return;
+                try {
+                    await command.run(context);
+                    await command.onAfterRun?.(context, undefined);
+                    await (0, plugins_1.runPluginCommandObservers)(this.client, 'onAfterRun', context, undefined);
+                }
+                catch (error) {
+                    await command.onRunError?.(context, error);
+                    await (0, plugins_1.runPluginCommandObservers)(this.client, 'onRunError', context, error);
+                    await command.onAfterRun?.(context, error);
+                    await (0, plugins_1.runPluginCommandObservers)(this.client, 'onAfterRun', context, error);
+                }
+            });
         }
         catch (error) {
             try {
                 await command.onInternalError?.(this.client, command, error);
+                await (0, plugins_1.runPluginCommandObservers)(this.client, 'onInternalError', this.client, command, error);
             }
             catch (err) {
                 this.client.logger.error(`[${command.name}] Internal error:`, err);
@@ -341,7 +386,7 @@ class HandleCommand {
         const result = this.getCommandFromContent(content
             .split(' ')
             .filter(x => x)
-            .slice(0, 3));
+            .slice(0, 3), _message.guild_id);
         if (!result.command)
             return result;
         let newContent = content;
@@ -353,19 +398,44 @@ class HandleCommand {
             argsContent: newContent.slice(1),
         };
     }
-    getCommandFromContent(commandRaw) {
+    getCommandFromContent(commandRaw, guildId) {
+        return this.resolveCommandFromNameParts(commandRaw, guildId);
+    }
+    /**
+     * Resolves a message command by its full name.
+     *
+     * Guild-scoped commands require a matching `guildId`; without one, they intentionally resolve to `undefined`.
+     */
+    resolveByName(fullName, guildId) {
+        const parts = fullName
+            .trim()
+            .split(/\s+/)
+            .filter(x => x)
+            .slice(0, 3);
+        if (!parts.length)
+            return undefined;
+        const resolved = this.resolveCommandFromNameParts(parts, guildId, false);
+        return resolved.command ? resolved : undefined;
+    }
+    resolveCommandFromNameParts(commandRaw, guildId, allowFallback = true) {
         const rawParentName = commandRaw[0];
         const rawGroupName = commandRaw.length === 3 ? commandRaw[1] : undefined;
         const rawSubcommandName = rawGroupName ? commandRaw[2] : commandRaw[1];
-        const parent = this.getParentMessageCommand(rawParentName);
+        const parent = this.getParentMessageCommand(rawParentName, guildId);
         const fullCommandName = `${rawParentName}${rawGroupName ? ` ${rawGroupName} ${rawSubcommandName}` : `${rawSubcommandName ? ` ${rawSubcommandName}` : ''}`}`;
         if (!(parent instanceof _1.Command))
             return { fullCommandName };
-        if (rawGroupName && !parent.groups?.[rawGroupName] && !parent.groupsAliases?.[rawGroupName])
-            return this.getCommandFromContent([rawParentName, rawGroupName]);
+        if (rawGroupName && !parent.groups?.[rawGroupName] && !parent.groupsAliases?.[rawGroupName]) {
+            if (!allowFallback)
+                return { fullCommandName };
+            return this.resolveCommandFromNameParts([rawParentName, rawGroupName], guildId);
+        }
         if (rawSubcommandName &&
-            !parent.options?.some(x => x instanceof _1.SubCommand && (x.name === rawSubcommandName || x.aliases?.includes(rawSubcommandName))))
-            return this.getCommandFromContent([rawParentName]);
+            !parent.options?.some(x => x instanceof _1.SubCommand && (x.name === rawSubcommandName || x.aliases?.includes(rawSubcommandName)))) {
+            if (!allowFallback)
+                return { fullCommandName };
+            return this.resolveCommandFromNameParts([rawParentName], guildId);
+        }
         const groupName = rawGroupName ? parent.groupsAliases?.[rawGroupName] || rawGroupName : undefined;
         const command = groupName || rawSubcommandName
             ? parent.options?.find(opt => {
@@ -390,10 +460,16 @@ class HandleCommand {
     makeResolver(...args) {
         return transformers_1.Transformers.OptionResolver(...args);
     }
-    getParentMessageCommand(rawParentName) {
+    getParentMessageCommand(rawParentName, guildId) {
         return this.client.commands.values.find(x => (!('ignore' in x) || x.ignore !== _1.IgnoreCommand.Message) &&
+            this.commandCanRunInGuild(x, guildId) &&
             (x.name === rawParentName || ('aliases' in x ? x.aliases?.includes(rawParentName) : false)));
     }
+    commandCanRunInGuild(command, guildId) {
+        if (!command.guildId?.length)
+            return true;
+        return guildId ? command.guildId.includes(guildId) : false;
+    }
     getCommand(data) {
         return this.client.commands.values.find(command => {
             if (data.guild_id) {
@@ -442,7 +518,9 @@ class HandleCommand {
                 return false;
             }
             if ('error' in resultRunGlobalMiddlewares) {
-                await command.onMiddlewaresError?.(context, resultRunGlobalMiddlewares.error ?? 'Unknown error');
+                const metadata = resultRunGlobalMiddlewares.metadata ?? { middleware: 'unknown', scope: 'global' };
+                await command.onMiddlewaresError?.(context, resultRunGlobalMiddlewares.error ?? 'Unknown error', metadata);
+                await (0, plugins_1.runPluginCommandObservers)(this.client, 'onMiddlewaresError', context, resultRunGlobalMiddlewares.error ?? 'Unknown error', metadata);
                 return false;
             }
             return resultRunGlobalMiddlewares;
@@ -450,6 +528,7 @@ class HandleCommand {
         catch (e) {
             try {
                 await command.onInternalError?.(this.client, command, e);
+                await (0, plugins_1.runPluginCommandObservers)(this.client, 'onInternalError', this.client, command, e);
             }
             catch (err) {
                 this.client.logger.error(`[${command.name}] Internal error:`, err);
@@ -464,7 +543,9 @@ class HandleCommand {
                 return false;
             }
             if ('error' in resultRunMiddlewares) {
-                await command.onMiddlewaresError?.(context, resultRunMiddlewares.error ?? 'Unknown error');
+                const metadata = resultRunMiddlewares.metadata ?? { middleware: 'unknown', scope: 'command' };
+                await command.onMiddlewaresError?.(context, resultRunMiddlewares.error ?? 'Unknown error', metadata);
+                await (0, plugins_1.runPluginCommandObservers)(this.client, 'onMiddlewaresError', context, resultRunMiddlewares.error ?? 'Unknown error', metadata);
                 return false;
             }
             return resultRunMiddlewares;
@@ -472,6 +553,7 @@ class HandleCommand {
         catch (e) {
             try {
                 await command.onInternalError?.(this.client, command, e);
+                await (0, plugins_1.runPluginCommandObservers)(this.client, 'onInternalError', this.client, command, e);
             }
             catch (err) {
                 this.client.logger.error(`[${command.name}] Internal error:`, err);
@@ -709,7 +791,6 @@ class HandleCommand {
                                     });
                                     break;
                                 }
-                                break;
                             }
                         }
                         break;

package/lib/commands/handler.d.ts

@@ -12,17 +12,22 @@ export declare class CommandHandler extends BaseHandler {
     entryPoint: EntryPointCommand | null;
     filter: (path: string) => boolean;
     constructor(logger: Logger, client: UsingClient);
-    reload(resolve: string | Command): Promise<void>;
+    reload(resolve: string | Command): Promise<Command | EntryPointCommand | ContextMenuCommand | null>;
     reloadAll(stopIfFail?: boolean): Promise<void>;
     protected shouldUploadLocales(locales?: LocalizationMap | null, cachedLocales?: LocalizationMap | null): boolean;
-    protected shoudUploadChoices(option: APIApplicationCommandOption, cached: APIApplicationCommandOption): boolean;
+    protected shouldUploadChoices(option: APIApplicationCommandOption, cached: APIApplicationCommandOption): boolean;
     protected shouldUploadOption(option: APIApplicationCommandOption, cached: APIApplicationCommandOption): boolean;
     shouldUpload(file: string, guildId?: string): Promise<boolean>;
-    set(commands: SeteableCommand[]): void;
-    load(commandsDir: string, client: UsingClient): Promise<(Command | ContextMenuCommand)[]>;
-    parseLocales(command: InstanceType<HandleableCommand>): Command | ContextMenuCommand | SubCommand | EntryPointCommand;
+    private prepareCommand;
+    checkSubCommandsLimit(command: Command): void;
+    private normalizeLoadOptions;
+    set(commands: SeteableCommand[], optionsOrTransform?: CommandLoadTransformer | CommandLoadOptions): (Command | EntryPointCommand | ContextMenuCommand)[];
+    load(commandsDir: string, client: UsingClient, options?: CommandLoadOptions): Promise<(Command | ContextMenuCommand)[]>;
+    parseLocales(command: InstanceType<HandleableCommand>): Command | EntryPointCommand | ContextMenuCommand | SubCommand;
+    protected getLocales(locale: string): ("id" | "en-US" | "en-GB" | "bg" | "zh-CN" | "zh-TW" | "hr" | "cs" | "da" | "nl" | "fi" | "fr" | "de" | "el" | "hi" | "hu" | "it" | "ja" | "ko" | "lt" | "no" | "pl" | "pt-BR" | "ro" | "ru" | "es-ES" | "es-419" | "sv-SE" | "th" | "tr" | "uk" | "vi")[];
+    protected getLocaleKey(locale: string, key: string, context: string): string | undefined;
     parseGlobalLocales(command: InstanceType<HandleableCommand>): void;
-    parseCommandOptionLocales(option: CommandOption): void;
+    parseCommandOptionLocales(option: CommandOption, commandName?: string): void;
     parseCommandLocales(command: Command): void;
     parseContextMenuLocales(command: ContextMenuCommand): ContextMenuCommand;
     parseSubCommandLocales(command: SubCommand): SubCommand;
@@ -32,12 +37,20 @@ export declare class CommandHandler extends BaseHandler {
     }> | false;
     stablishSubCommandDefaults(commandInstance: Command, option: SubCommand): SubCommand;
     onFile(file: FileLoaded): HandleableCommand[] | undefined;
-    onCommand(file: HandleableCommand): InstanceType<HandleableCommand> | false;
+    onCommand(file: SeteableCommand, create?: CommandLoadCreator): HandleableCommandInstance | false;
     onSubCommand(file: HandleableSubCommand): SubCommand | false;
 }
 export type FileLoaded<T = null> = {
     default?: NulleableCoalising<T, HandleableCommand>;
 } & Record<string, NulleableCoalising<T, HandleableCommand>>;
 export type HandleableCommand = new () => Command | SubCommand | ContextMenuCommand | EntryPointCommand;
-export type SeteableCommand = new () => Extract<InstanceType<HandleableCommand>, SubCommand>;
+export type SettableCommand = new () => Exclude<InstanceType<HandleableCommand>, SubCommand>;
+export type HandleableCommandInstance = Command | SubCommand | ContextMenuCommand | EntryPointCommand;
+export type SeteableCommand = HandleableCommand | HandleableCommandInstance;
 export type HandleableSubCommand = new () => SubCommand;
+export type CommandLoadCreator = <T extends HandleableCommand>(constructor: T, next: () => InstanceType<T>) => InstanceType<T>;
+export type CommandLoadTransformer = (command: HandleableCommandInstance) => HandleableCommandInstance | false | void;
+export interface CommandLoadOptions {
+    create?: CommandLoadCreator;
+    transform?: CommandLoadTransformer;
+}