reciple 1.5.5 → 1.6.2

package/bin/bin.js

@@ -12,7 +12,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 var _a, _b;
 Object.defineProperty(exports, "__esModule", { value: true });
 const Config_1 = require("./reciple/classes/Config");
-const Client_1 = require("./reciple/classes/Client");
+const RecipleClient_1 = require("./reciple/classes/RecipleClient");
 const fs_1 = require("fs");
 const version_1 = require("./reciple/version");
 const flags_1 = require("./reciple/flags");
@@ -29,7 +29,7 @@ if ((0, fs_1.readdirSync)('./').filter(f => !f.startsWith('.') && allowedFiles.i
         process.exit(0);
 }
 const config = new Config_1.RecipleConfig((_b = flags_1.flags.config) !== null && _b !== void 0 ? _b : './reciple.yml').parseConfig().getConfig();
-const client = new Client_1.RecipleClient(Object.assign({ config: config }, config.client));
+const client = new RecipleClient_1.RecipleClient(Object.assign({ config: config }, config.client));
 (() => __awaiter(void 0, void 0, void 0, function* () {
     yield client.startModules();
     client.on('ready', () => __awaiter(void 0, void 0, void 0, function* () {

package/bin/index.d.ts

@@ -1,6 +1,6 @@
 import discord from 'discord.js';
 export declare const discordjs: typeof discord;
-export * from './reciple/classes/Client';
+export * from './reciple/classes/RecipleClient';
 export * from './reciple/classes/Config';
 export * from './reciple/classes/builders/InteractionCommandBuilder';
 export * from './reciple/classes/builders/MessageCommandBuilder';

package/bin/index.js

@@ -20,7 +20,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.discordjs = void 0;
 const discord_js_1 = __importDefault(require("discord.js"));
 exports.discordjs = discord_js_1.default;
-__exportStar(require("./reciple/classes/Client"), exports);
+__exportStar(require("./reciple/classes/RecipleClient"), exports);
 __exportStar(require("./reciple/classes/Config"), exports);
 __exportStar(require("./reciple/classes/builders/InteractionCommandBuilder"), exports);
 __exportStar(require("./reciple/classes/builders/MessageCommandBuilder"), exports);

package/bin/reciple/classes/Config.d.ts

@@ -10,6 +10,7 @@ export interface Config {
         messageCommand: {
             enabled: boolean;
             replyOnError: boolean;
+            allowCommandAlias: boolean;
             commandArgumentSeparator: string;
         };
         interactionCommand: {

package/bin/reciple/classes/{Client.d.ts → RecipleClient.d.ts}

@@ -3,8 +3,8 @@ import { interactionCommandBuilders } from '../registerInteractionCommands';
 import { MessageCommandBuilder, RecipleMessageCommandExecute } from './builders/MessageCommandBuilder';
 import { Logger as ILogger } from 'fallout-utility';
 import { Config } from './Config';
-import { ApplicationCommandDataResolvable, Awaitable, Client, ClientEvents, ClientOptions, Interaction, Message } from 'discord.js';
-import { recipleCommandBuilders, RecipleScript } from '../modules';
+import { ApplicationCommandDataResolvable, Awaitable, Client, ClientEvents, ClientOptions, CommandInteraction, Interaction, Message } from 'discord.js';
+import { recipleCommandBuilders, RecipleModule, RecipleScript } from '../modules';
 export interface RecipleClientOptions extends ClientOptions {
     config: Config;
 }
@@ -20,7 +20,7 @@ export interface RecipleClientEvents extends ClientEvents {
     recipleMessageCommandCreate: [command: RecipleMessageCommandExecute];
     recipleInteractionCommandCreate: [command: RecipleInteractionCommandExecute];
 }
-export interface RecipleClient extends Client {
+export interface RecipleClient<Ready extends boolean = boolean> extends Client<Ready> {
     on<E extends keyof RecipleClientEvents>(event: E, listener: (...args: RecipleClientEvents[E]) => Awaitable<void>): this;
     on<E extends string | symbol>(event: Exclude<E, keyof RecipleClientEvents>, listener: (...args: any) => Awaitable<void>): this;
     once<E extends keyof RecipleClientEvents>(event: E, listener: (...args: RecipleClientEvents[E]) => Awaitable<void>): this;
@@ -31,22 +31,23 @@ export interface RecipleClient extends Client {
     off<E extends string | symbol>(event: Exclude<E, keyof RecipleClientEvents>, listener: (...args: any) => Awaitable<void>): this;
     removeAllListeners<E extends keyof RecipleClientEvents>(event?: E): this;
     removeAllListeners(event?: string | symbol): this;
+    isReady(): this is RecipleClient<true>;
 }
-export declare class RecipleClient extends Client {
+export declare class RecipleClient<Ready extends boolean = boolean> extends Client<Ready> {
     config: Config;
     commands: RecipleClientCommands;
     otherApplicationCommandData: (interactionCommandBuilders | ApplicationCommandDataResolvable)[];
-    modules: RecipleScript[];
+    modules: RecipleModule[];
     logger: ILogger;
     version: string;
     constructor(options: RecipleClientOptions);
-    startModules(): Promise<RecipleClient>;
-    loadModules(): Promise<RecipleClient>;
+    startModules(): Promise<RecipleClient<Ready>>;
+    loadModules(): Promise<RecipleClient<Ready>>;
     addModule(script: RecipleScript, registerCommands?: boolean): Promise<void>;
-    addCommand(command: recipleCommandBuilders): RecipleClient;
-    addCommandListeners(): RecipleClient;
+    addCommand(command: recipleCommandBuilders): RecipleClient<Ready>;
+    addCommandListeners(): RecipleClient<Ready>;
     messageCommandExecute(message: Message, prefix?: string): Promise<void | RecipleMessageCommandExecute>;
-    interactionCommandExecute(interaction: Interaction): Promise<void | RecipleInteractionCommandExecute>;
+    interactionCommandExecute(interaction: Interaction | CommandInteraction): Promise<void | RecipleInteractionCommandExecute>;
     getMessage<T = unknown>(messageKey: string, defaultMessage?: T): T;
     private _commandExecuteError;
 }

package/bin/reciple/classes/{Client.js → RecipleClient.js}

@@ -46,24 +46,32 @@ class RecipleClient extends discord_js_1.Client {
             const modules = yield (0, modules_1.loadModules)(this);
             if (!modules)
                 throw new Error('Failed to load modules.');
-            this.modules = modules.modules.map(m => m.script);
-            for (const command of modules.commands) {
-                if (!command.name)
-                    continue;
-                this.addCommand(command);
-            }
-            this.logger.info(`${Object.keys(this.commands.MESSAGE_COMMANDS).length} message commands loaded.`);
-            this.logger.info(`${Object.keys(this.commands.INTERACTION_COMMANDS).length} interaction commands loaded.`);
+            this.modules = modules.modules;
             return this;
         });
     }
     loadModules() {
+        var _a, _b;
         return __awaiter(this, void 0, void 0, function* () {
-            for (const module_ of this.modules) {
-                if (typeof (module_ === null || module_ === void 0 ? void 0 : module_.onLoad) === 'function')
-                    yield Promise.resolve(module_.onLoad(this));
+            for (let m in this.modules) {
+                const module_ = this.modules[m];
+                if (typeof ((_a = module_.script) === null || _a === void 0 ? void 0 : _a.onLoad) === 'function') {
+                    yield Promise.resolve(module_.script.onLoad(this)).catch(err => {
+                        var _a;
+                        this.logger.error(`Error loading ${(_a = module_.info.filename) !== null && _a !== void 0 ? _a : 'unknown module'}:`);
+                        this.logger.error(err);
+                        this.modules = this.modules.filter((r, i) => i.toString() !== m.toString());
+                    });
+                }
+                if (typeof ((_b = module_.script) === null || _b === void 0 ? void 0 : _b.commands) !== 'undefined') {
+                    for (const command of module_.script.commands) {
+                        this.addCommand(command);
+                    }
+                }
             }
             this.logger.info(`${this.modules.length} modules loaded.`);
+            this.logger.info(`${Object.keys(this.commands.MESSAGE_COMMANDS).length} message commands loaded.`);
+            this.logger.info(`${Object.keys(this.commands.INTERACTION_COMMANDS).length} interaction commands loaded.`);
             if (!this.config.commands.interactionCommand.registerCommands)
                 return this;
             yield (0, registerInteractionCommands_1.registerInteractionCommands)(this, [...Object.values(this.commands.INTERACTION_COMMANDS), ...this.otherApplicationCommandData]);
@@ -73,7 +81,14 @@ class RecipleClient extends discord_js_1.Client {
     addModule(script, registerCommands = true) {
         var _a;
         return __awaiter(this, void 0, void 0, function* () {
-            this.modules.push(script);
+            this.modules.push({
+                script,
+                info: {
+                    filename: undefined,
+                    versions: typeof script.versions == 'string' ? [script.versions] : script.versions,
+                    path: undefined
+                }
+            });
             if (typeof (script === null || script === void 0 ? void 0 : script.onLoad) === 'function')
                 yield Promise.resolve(script.onLoad(this));
             this.logger.info(`${this.modules.length} modules loaded.`);
@@ -108,17 +123,19 @@ class RecipleClient extends discord_js_1.Client {
         return this;
     }
     messageCommandExecute(message, prefix) {
-        var _a;
+        var _a, _b;
         return __awaiter(this, void 0, void 0, function* () {
-            if (!message.content)
+            if (!message.content || !this.isReady())
                 return;
             const parseCommand = (0, fallout_utility_1.getCommand)(message.content, prefix || this.config.prefix || '!', this.config.commands.messageCommand.commandArgumentSeparator || ' ');
-            if (!(parseCommand === null || parseCommand === void 0 ? void 0 : parseCommand.command) || !parseCommand)
+            if (!parseCommand || !(parseCommand === null || parseCommand === void 0 ? void 0 : parseCommand.command))
                 return;
-            const command = this.commands.MESSAGE_COMMANDS[parseCommand.command.toLowerCase()];
+            const command = (_a = this.commands.MESSAGE_COMMANDS[parseCommand.command.toLowerCase()]) !== null && _a !== void 0 ? _a : (this.config.commands.messageCommand.allowCommandAlias
+                ? Object.values(this.commands.MESSAGE_COMMANDS).find(c => c.aliases.some(a => { var _a; return a == ((_a = parseCommand.command) === null || _a === void 0 ? void 0 : _a.toLowerCase()); }))
+                : undefined);
             if (!command)
                 return;
-            if ((0, hasPermissions_1.hasPermissions)(command.name, (_a = message.member) === null || _a === void 0 ? void 0 : _a.permissions, this.config.permissions.messageCommands, command)) {
+            if ((0, hasPermissions_1.hasPermissions)(command.name, (_b = message.member) === null || _b === void 0 ? void 0 : _b.permissions, this.config.permissions.messageCommands, command)) {
                 if (!command.allowExecuteInDM && message.channel.type === 'DM'
                     || !command.allowExecuteByBots
                         && (message.author.bot || message.author.system)
@@ -154,12 +171,13 @@ class RecipleClient extends discord_js_1.Client {
     interactionCommandExecute(interaction) {
         var _a;
         return __awaiter(this, void 0, void 0, function* () {
-            if (!interaction || !interaction.isCommand())
+            if (!interaction || !interaction.isCommand() || !this.isReady())
                 return;
             const command = this.commands.INTERACTION_COMMANDS[interaction.commandName];
             if (!command)
                 return;
             if ((0, hasPermissions_1.hasPermissions)(command.name, (_a = interaction.memberPermissions) !== null && _a !== void 0 ? _a : undefined, this.config.permissions.interactionCommands, command)) {
+                // TODO: Deprecated allowEcuteInDM
                 if (!command.allowExecuteInDM && !interaction.inCachedGuild() || (0, isIgnoredChannel_1.isIgnoredChannel)(interaction.channelId, this.config.ignoredChannels))
                     return;
                 if (!command)
@@ -192,12 +210,12 @@ class RecipleClient extends discord_js_1.Client {
             if (command === null || command === void 0 ? void 0 : command.message) {
                 if (!this.config.commands.messageCommand.replyOnError)
                     return;
-                yield command.message.reply(this.getMessage('error', 'An error occurred.')).catch(err => this.logger.debug(err));
+                yield command.message.reply(this.getMessage('error', 'An error occurred.')).catch(e => this.logger.debug(e));
             }
             else if (command === null || command === void 0 ? void 0 : command.interaction) {
                 if (!this.config.commands.interactionCommand.replyOnError)
                     return;
-                yield command.interaction.followUp(this.getMessage('error', 'An error occurred.')).catch(err => this.logger.debug(err));
+                yield command.interaction.followUp(this.getMessage('error', 'An error occurred.')).catch(e => this.logger.debug(e));
             }
         });
     }

package/bin/reciple/classes/builders/InteractionCommandBuilder.d.ts

@@ -1,18 +1,28 @@
 import { CommandInteraction, PermissionFlags, PermissionString } from 'discord.js';
 import { SlashCommandBuilder } from '@discordjs/builders';
-import { RecipleClient } from '../Client';
+import { RecipleClient } from '../RecipleClient';
 export interface RecipleInteractionCommandExecute {
     interaction: CommandInteraction;
     command: InteractionCommandBuilder;
     builder: InteractionCommandBuilder;
-    client: RecipleClient;
+    client: RecipleClient<true>;
 }
 export declare class InteractionCommandBuilder extends SlashCommandBuilder {
     readonly builder = "INTERACTION_COMMAND";
     requiredPermissions: (PermissionFlags | PermissionString)[];
     allowExecuteInDM: boolean;
     execute: (options: RecipleInteractionCommandExecute) => void;
+    /**
+     * Set required permissions before executing the command
+     */
     setRequiredPermissions(requiredPermissions: (keyof PermissionFlags)[]): InteractionCommandBuilder;
+    /**
+     * Set if command can be executed in dms
+     * @deprecated use `InteractionCommandBuilder.setDMPermission()` instead
+     */
     setAllowExecuteInDM(allowExecuteInDM: boolean): InteractionCommandBuilder;
+    /**
+     * Function when the command is executed
+     */
     setExecute(execute: (options: RecipleInteractionCommandExecute) => void): InteractionCommandBuilder;
 }

package/bin/reciple/classes/builders/InteractionCommandBuilder.js

@@ -10,18 +10,30 @@ class InteractionCommandBuilder extends builders_1.SlashCommandBuilder {
         this.allowExecuteInDM = true;
         this.execute = () => { };
     }
+    /**
+     * Set required permissions before executing the command
+     */
     setRequiredPermissions(requiredPermissions) {
         if (!requiredPermissions || !Array.isArray(requiredPermissions))
             throw new Error('requiredPermissions must be an array.');
         this.requiredPermissions = requiredPermissions;
         return this;
     }
+    /**
+     * Set if command can be executed in dms
+     * @deprecated use `InteractionCommandBuilder.setDMPermission()` instead
+     */
     setAllowExecuteInDM(allowExecuteInDM) {
+        // TODO: Deprecated this
         if (typeof allowExecuteInDM !== 'boolean')
             throw new Error('allowExecuteInDM must be a boolean.');
         this.allowExecuteInDM = allowExecuteInDM;
+        process.emitWarning('InteractionCommandBuilder#setAllowExecuteInDM() method is deprecated in favor of setting SlashCommandBuilder#setDMPermission()', 'Deprecation Warning');
         return this;
     }
+    /**
+     * Function when the command is executed
+     */
     setExecute(execute) {
         if (!execute || typeof execute !== 'function')
             throw new Error('execute must be a function.');

package/bin/reciple/classes/builders/MessageCommandBuilder.d.ts

@@ -1,7 +1,7 @@
 import { MessageCommandOptionBuilder } from './MessageCommandOptionBuilder';
 import { Message, PermissionFlags, PermissionString } from 'discord.js';
 import { Command } from 'fallout-utility';
-import { RecipleClient } from '../Client';
+import { RecipleClient } from '../RecipleClient';
 import { MessageCommandOptions } from './MessageCommandOptions';
 export declare type CommandMessage = Command;
 export interface RecipleMessageCommandExecute {
@@ -9,7 +9,7 @@ export interface RecipleMessageCommandExecute {
     options: MessageCommandOptions;
     command: CommandMessage;
     builder: MessageCommandBuilder;
-    client: RecipleClient;
+    client: RecipleClient<true>;
 }
 export interface MessageCommandValidatedOption {
     name: string;
@@ -22,19 +22,51 @@ export declare class MessageCommandBuilder {
     readonly builder = "MESSAGE_COMMAND";
     name: string;
     description: string;
+    aliases: string[];
     options: MessageCommandOptionBuilder[];
     validateOptions: boolean;
     requiredPermissions: (PermissionFlags | PermissionString)[];
     allowExecuteInDM: boolean;
     allowExecuteByBots: boolean;
     execute: (options: RecipleMessageCommandExecute) => void;
+    /**
+     * Sets the command name
+     */
     setName(name: string): MessageCommandBuilder;
+    /**
+     * Sets the command description
+     */
+    setDescription(description: string): MessageCommandBuilder;
+    /**
+     * Add aliases to the command
+     */
+    addAliases(...aliases: string[]): MessageCommandBuilder;
+    /**
+     * Sets the default required permissions to execute this command
+     */
     setRequiredPermissions(permissions: (PermissionFlags | PermissionString)[]): MessageCommandBuilder;
+    /**
+     * Set if command can be executed in dms
+     */
     setAllowExecuteInDM(allowExecuteInDM: boolean): MessageCommandBuilder;
+    /**
+     * Allow command to be executed by bots
+     */
     setAllowExecuteByBots(allowExecuteByBots: boolean): MessageCommandBuilder;
-    setDescription(description: string): MessageCommandBuilder;
+    /**
+     * Function when the command is executed
+     */
     setExecute(execute: (options: RecipleMessageCommandExecute) => void): MessageCommandBuilder;
+    /**
+     * Add option to the command
+     */
     addOption(option: MessageCommandOptionBuilder | ((constructor: MessageCommandOptionBuilder) => MessageCommandOptionBuilder)): MessageCommandBuilder;
+    /**
+     * Validate options before executing
+     */
     setValidateOptions(validateOptions: boolean): MessageCommandBuilder;
+    /**
+     * validate given command options
+     */
     getCommandOptionValues(options: CommandMessage): MessageCommandValidatedOption[];
 }

package/bin/reciple/classes/builders/MessageCommandBuilder.js

@@ -7,6 +7,7 @@ class MessageCommandBuilder {
         this.builder = 'MESSAGE_COMMAND';
         this.name = '';
         this.description = '';
+        this.aliases = [];
         this.options = [];
         this.validateOptions = false;
         this.requiredPermissions = [];
@@ -14,42 +15,76 @@ class MessageCommandBuilder {
         this.allowExecuteByBots = false;
         this.execute = () => { };
     }
+    /**
+     * Sets the command name
+     */
     setName(name) {
         if (!name || typeof name !== 'string' || !name.match(/^[\w-]{1,32}$/))
             throw new TypeError('name must be a string and match the regex /^[\\w-]{1,32}$/');
         this.name = name;
         return this;
     }
+    /**
+     * Sets the command description
+     */
+    setDescription(description) {
+        if (!description || typeof description !== 'string')
+            throw new TypeError('description must be a string.');
+        this.description = description;
+        return this;
+    }
+    /**
+     * Add aliases to the command
+     */
+    addAliases(...aliases) {
+        if (!aliases.length)
+            throw new TypeError('Provide atleast one alias');
+        if (aliases.some(a => !a || typeof a !== 'string' || !a.match(/^[\w-]{1,32}$/)))
+            throw new TypeError('aliases must be strings and match the regex /^[\\w-]{1,32}$/');
+        if (this.name && aliases.some(a => a == this.name))
+            throw new TypeError('alias cannot have same name to its real command name');
+        this.aliases = [...new Set(aliases)];
+        return this;
+    }
+    /**
+     * Sets the default required permissions to execute this command
+     */
     setRequiredPermissions(permissions) {
         if (!permissions || !Array.isArray(permissions))
             throw new TypeError('permissions must be an array.');
         this.requiredPermissions = permissions;
         return this;
     }
+    /**
+     * Set if command can be executed in dms
+     */
     setAllowExecuteInDM(allowExecuteInDM) {
         if (typeof allowExecuteInDM !== 'boolean')
             throw new TypeError('allowExecuteInDM must be a boolean.');
         this.allowExecuteInDM = allowExecuteInDM;
         return this;
     }
+    /**
+     * Allow command to be executed by bots
+     */
     setAllowExecuteByBots(allowExecuteByBots) {
         if (typeof allowExecuteByBots !== 'boolean')
             throw new TypeError('allowExecuteByBots must be a boolean.');
         this.allowExecuteByBots = allowExecuteByBots;
         return this;
     }
-    setDescription(description) {
-        if (!description || typeof description !== 'string')
-            throw new TypeError('description must be a string.');
-        this.description = description;
-        return this;
-    }
+    /**
+     * Function when the command is executed
+     */
     setExecute(execute) {
         if (!execute || typeof execute !== 'function')
             throw new TypeError('execute must be a function.');
         this.execute = execute;
         return this;
     }
+    /**
+     * Add option to the command
+     */
     addOption(option) {
         if (!option)
             throw new TypeError('option must be a MessageOption.');
@@ -61,12 +96,18 @@ class MessageCommandBuilder {
         this.options = [...this.options, option];
         return this;
     }
+    /**
+     * Validate options before executing
+     */
     setValidateOptions(validateOptions) {
         if (typeof validateOptions !== 'boolean')
             throw new TypeError('validateOptions must be a boolean.');
         this.validateOptions = validateOptions;
         return this;
     }
+    /**
+     * validate given command options
+     */
     getCommandOptionValues(options) {
         const args = options.args || [];
         const required = this.options.filter(o => o.required);

package/bin/reciple/classes/builders/MessageCommandOptionBuilder.d.ts

@@ -3,8 +3,20 @@ export declare class MessageCommandOptionBuilder {
     description: string;
     required: boolean;
     validator: (value: string) => boolean;
+    /**
+     * Set command option name
+     */
     setName(name: string): MessageCommandOptionBuilder;
+    /**
+     * Set command option description
+     */
     setDescription(description: string): MessageCommandOptionBuilder;
+    /**
+     * Set if this option is required
+     */
     setRequired(required: boolean): MessageCommandOptionBuilder;
+    /**
+     * Set your custom function to validate given value for this option
+     */
     setValidator(validator: (value: string) => boolean): MessageCommandOptionBuilder;
 }

package/bin/reciple/classes/builders/MessageCommandOptionBuilder.js

@@ -8,24 +8,36 @@ class MessageCommandOptionBuilder {
         this.required = false;
         this.validator = () => true;
     }
+    /**
+     * Set command option name
+     */
     setName(name) {
         if (typeof name !== 'string' || !name.match(/^[\w-]{1,32}$/))
             throw new TypeError('name must be a string and match the regex /^[\\w-]{1,32}$/.');
         this.name = name;
         return this;
     }
+    /**
+     * Set command option description
+     */
     setDescription(description) {
         if (!description || typeof description !== 'string')
             throw new TypeError('description must be a string.');
         this.description = description;
         return this;
     }
+    /**
+     * Set if this option is required
+     */
     setRequired(required) {
         if (typeof required !== 'boolean')
             throw new TypeError('required must be a boolean.');
         this.required = required;
         return this;
     }
+    /**
+     * Set your custom function to validate given value for this option
+     */
     setValidator(validator) {
         if (!validator || typeof validator !== 'function')
             throw new TypeError('validator must be a function.');

package/bin/reciple/classes/builders/MessageCommandOptions.d.ts

@@ -1,8 +1,14 @@
 import { MessageCommandValidatedOption } from './MessageCommandBuilder';
 export declare class MessageCommandOptions extends Array<MessageCommandValidatedOption> {
     constructor(options: MessageCommandValidatedOption[]);
+    /**
+     * Get the option info
+     */
     get(name: string, requied: true): MessageCommandValidatedOption;
     get(name: string, requied?: boolean): MessageCommandValidatedOption | null;
+    /**
+     * Get the option value
+     */
     getValue(name: string, requied: true): string;
     getValue(name: string, requied?: boolean): string | null;
 }

package/bin/reciple/modules.d.ts

@@ -1,6 +1,6 @@
 import { InteractionCommandBuilder, RecipleInteractionCommandExecute } from './classes/builders/InteractionCommandBuilder';
 import { MessageCommandBuilder, RecipleMessageCommandExecute } from './classes/builders/MessageCommandBuilder';
-import { RecipleClient } from './classes/Client';
+import { RecipleClient } from './classes/RecipleClient';
 export declare type recipleCommandBuilders = MessageCommandBuilder | InteractionCommandBuilder;
 export declare type recipleCommandBuildersExecute = RecipleInteractionCommandExecute | RecipleMessageCommandExecute;
 export declare type loadedModules = {
@@ -16,9 +16,9 @@ export declare class RecipleScript {
 export interface RecipleModule {
     script: RecipleScript;
     info: {
-        filename: string;
+        filename?: string;
         versions: string[];
-        path: string;
+        path?: string;
     };
 }
 export declare function loadModules(client: RecipleClient): Promise<loadedModules>;

package/bin/reciple/registerInteractionCommands.d.ts

@@ -1,6 +1,6 @@
 import { InteractionCommandBuilder } from './classes/builders/InteractionCommandBuilder';
 import { ApplicationCommandDataResolvable } from 'discord.js';
-import { RecipleClient } from './classes/Client';
+import { RecipleClient } from './classes/RecipleClient';
 import { ContextMenuCommandBuilder, SlashCommandBuilder, SlashCommandSubcommandBuilder, SlashCommandOptionsOnlyBuilder, SlashCommandSubcommandGroupBuilder, SlashCommandSubcommandsOnlyBuilder } from '@discordjs/builders';
 export declare type interactionCommandBuilders = InteractionCommandBuilder | ContextMenuCommandBuilder | SlashCommandBuilder | SlashCommandSubcommandBuilder | SlashCommandOptionsOnlyBuilder | SlashCommandSubcommandGroupBuilder | SlashCommandSubcommandsOnlyBuilder;
 export declare function registerInteractionCommands(client: RecipleClient, cmds?: (interactionCommandBuilders | ApplicationCommandDataResolvable)[], overwriteGuilds?: string | string[]): Promise<void>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "reciple",
-  "version": "1.5.5",
+  "version": "1.6.2",
   "description": "A Discord.js bot",
   "author": "FalloutStudios",
   "license": "GPL-3.0",
@@ -8,6 +8,9 @@
   "bin": {
     "reciple": "bin/bin.js"
   },
+  "engines": {
+    "node": ">=16.9.0"
+  },
   "files": [
     "bin",
     "resource",
@@ -16,12 +19,11 @@
     "README.md"
   ],
   "scripts": {
-    "clean": "rimraf bin",
-    "compile": "yarn clean && npx tsc",
-    "build": "yarn compile && npm un reciple -g && npm i ./ -g",
-    "build:publish": "yarn run build && yarn run changelog && yarn publish",
-    "test": "cd test && npx reciple",
-    "test:build": "yarn run build && yarn test:run"
+    "clean": "rm -rf bin",
+    "build": "yarn clean && npx tsc && npm un reciple -g && npm i ./ -g",
+    "build:publish": "yarn run build && yarn publish",
+    "test": "yarn run build && yarn test:start",
+    "test:start": "cd test && npx reciple"
   },
   "dependencies": {
     "commander": "^9.3.0",

package/resource/reciple.yml

@@ -13,6 +13,8 @@ commands:
     enabled: true
     # reply when an error occured
     replyOnError: false
+    # Allow executing commands via aliases
+    allowCommandAlias: false
     # command argument separator
     commandArgumentSeparator: ' '
   interactionCommand: