reciple 1.7.1 → 2.0.2

package/README.md

@@ -12,48 +12,54 @@ A simple Dicord.js command handler that just works.
 [![Discord Invite](https://i.imgur.com/GffJByO.png)](https://discord.gg/2CattJYNpw)
 
 ## Installation
-To install the bot, run the following command:
+To install the bot, run the following command in your terminal:
 
 ```bash
 npm i reciple
 ```
+```bash
+yarn add reciple
+```
+```bash
+pnpm add reciple
+```
 
-You can initialize the bot to the current directory with the following command:
+You can initialize the bot to the current directory with the following command in your terminal:
 
 ```bash
 npx reciple
 ```
 
-It will ask you to continue if the directory is not empty type `y` to continue after the bot has been initialized it will ask you for your bot token.
+It will ask you to continue if the directory is not empty. Type `y` to continue. After the bot has been initialized, it will ask you for your bot token.
 
-> You can always change the token later
+> You can change the token anytime you want
 
 ## Config
 
-You can configure the bot on `reciple.yml` in the bot root directory.
+You can configure the bot in `reciple.yml` located in the bot's root directory.
 
 ### Token
 
-You can directly change the token on `reciple.yml` like so:
+You can directly change the token in `reciple.yml`.
 
 ```yml
 token: "YOUR_TOKEN_HERE"
 ```
 
-Using environment variables is also supported:
+Using environment variables is also supported.
 
 ```yml
 token: "env:TOKEN_VARIABLE"
 ```
 
-You can override the token on the command line like so:
+You can override the given token using your terminal
 
 ```bash
 npx reciple --token "YOUR_TOKEN_HERE"
 ```
 
-## Running the bot
-To run the bot, run the following command:
+## Starting the bot
+To start the bot, run the following command:
 
 ```bash
 npx reciple
@@ -62,5 +68,4 @@ npx reciple
 > ## Fun Fact
 > The name reciple is from a minecraft bug. The bug was a misspelling of the word `recipe`. [View Mojang Bug Report](https://bugs.mojang.com/browse/MC-225837)
 
-# Save the Earth
 [#letTheEarthBreathe](https://rebellion.global/)

package/bin/index.d.ts

@@ -1,10 +1,12 @@
 export * from './reciple/classes/RecipleClient';
 export * from './reciple/classes/RecipleConfig';
+export * from './reciple/classes/MessageCommandOptionManager';
 export * from './reciple/classes/builders/InteractionCommandBuilder';
 export * from './reciple/classes/builders/MessageCommandBuilder';
 export * from './reciple/classes/builders/MessageCommandOptionBuilder';
-export * from './reciple/classes/builders/MessageCommandOptions';
-export * from './reciple/hasPermissions';
+export * from './reciple/types/builders';
+export * from './reciple/types/commands';
+export * from './reciple/permissions';
 export * from './reciple/flags';
 export * from './reciple/isIgnoredChannel';
 export * from './reciple/logger';

package/bin/index.js

@@ -16,11 +16,13 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./reciple/classes/RecipleClient"), exports);
 __exportStar(require("./reciple/classes/RecipleConfig"), exports);
+__exportStar(require("./reciple/classes/MessageCommandOptionManager"), exports);
 __exportStar(require("./reciple/classes/builders/InteractionCommandBuilder"), exports);
 __exportStar(require("./reciple/classes/builders/MessageCommandBuilder"), exports);
 __exportStar(require("./reciple/classes/builders/MessageCommandOptionBuilder"), exports);
-__exportStar(require("./reciple/classes/builders/MessageCommandOptions"), exports);
-__exportStar(require("./reciple/hasPermissions"), exports);
+__exportStar(require("./reciple/types/builders"), exports);
+__exportStar(require("./reciple/types/commands"), exports);
+__exportStar(require("./reciple/permissions"), exports);
 __exportStar(require("./reciple/flags"), exports);
 __exportStar(require("./reciple/isIgnoredChannel"), exports);
 __exportStar(require("./reciple/logger"), exports);

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

@@ -0,0 +1,36 @@
+import { Guild, TextBasedChannel, User } from 'discord.js';
+import { RecipleCommandBuilders } from '../types/builders';
+export interface CooledDownUser {
+    user: User;
+    command: string;
+    type: RecipleCommandBuilders["builder"];
+    guild?: Guild | null;
+    channel?: TextBasedChannel;
+    expireTime: number;
+}
+export declare class CommandCooldownManager extends Array<CooledDownUser> {
+    /**
+     * Alias for `CommandCooldownManager#push()`
+     */
+    add(...options: CooledDownUser[]): number;
+    /**
+     * Remove cooldown from specific user, channel or guild
+     */
+    remove(options: Partial<CooledDownUser>, limit?: number): void;
+    /**
+     * Check if the given user is cooled-down
+     */
+    isCooledDown(options: Partial<Omit<CooledDownUser, 'expireTime'>>): boolean;
+    /**
+     * Clear non cooled-down users from this array
+     */
+    clean(options?: Partial<Omit<CooledDownUser, 'expireTime'>>): void;
+    /**
+     * Get someone's cooldown data
+     */
+    get(options: Partial<Omit<CooledDownUser, 'expireTime'>>): CooledDownUser | undefined;
+    /**
+     * Check if the options are valid
+     */
+    static checkOptions(options: Partial<Omit<CooledDownUser, 'expireTime'>>, data: CooledDownUser): boolean;
+}

package/bin/reciple/classes/CommandCooldownManager.js

@@ -0,0 +1,77 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CommandCooldownManager = void 0;
+class CommandCooldownManager extends Array {
+    /**
+     * Alias for `CommandCooldownManager#push()`
+     */
+    add(...options) {
+        return this.push(...options);
+    }
+    /**
+     * Remove cooldown from specific user, channel or guild
+     */
+    remove(options, limit = 0) {
+        if (!Object.keys(options).length)
+            throw new TypeError('Provide atleast one option to remove cooldown data.');
+        let i = 0;
+        for (const index in this) {
+            if (!CommandCooldownManager.checkOptions(options, this[index]))
+                continue;
+            if (options.expireTime && this[index].expireTime > Date.now())
+                continue;
+            if (limit && i >= limit)
+                continue;
+            this.splice(Number(index));
+            i++;
+        }
+    }
+    /**
+     * Check if the given user is cooled-down
+     */
+    isCooledDown(options) {
+        const data = this.get(options);
+        if (!data)
+            return false;
+        this.remove(Object.assign(Object.assign({}, data), { channel: undefined, guild: undefined, type: undefined, command: undefined }));
+        if (data.expireTime < Date.now())
+            return false;
+        return true;
+    }
+    /**
+     * Clear non cooled-down users from this array
+     */
+    clean(options) {
+        for (const index in this) {
+            if (options && !CommandCooldownManager.checkOptions(options, this[index]))
+                return;
+            if (this[index].expireTime > Date.now())
+                return;
+            this.slice(Number(index));
+        }
+    }
+    /**
+     * Get someone's cooldown data
+     */
+    get(options) {
+        return this.find(data => CommandCooldownManager.checkOptions(options, data));
+    }
+    /**
+     * Check if the options are valid
+     */
+    static checkOptions(options, data) {
+        var _a, _b;
+        if ((options === null || options === void 0 ? void 0 : options.user) && options.user.id !== data.user.id)
+            return false;
+        if ((options === null || options === void 0 ? void 0 : options.guild) && options.guild.id !== ((_a = data.guild) === null || _a === void 0 ? void 0 : _a.id))
+            return false;
+        if ((options === null || options === void 0 ? void 0 : options.channel) && options.channel.id !== ((_b = data.channel) === null || _b === void 0 ? void 0 : _b.id))
+            return false;
+        if ((options === null || options === void 0 ? void 0 : options.command) && options.command !== data.command)
+            return false;
+        if ((options === null || options === void 0 ? void 0 : options.type) && options.type !== data.type)
+            return false;
+        return true;
+    }
+}
+exports.CommandCooldownManager = CommandCooldownManager;

package/bin/reciple/classes/{builders/MessageCommandOptions.d.ts → MessageCommandOptionManager.d.ts}

@@ -1,5 +1,5 @@
-import { MessageCommandValidatedOption } from './MessageCommandBuilder';
-export declare class MessageCommandOptions extends Array<MessageCommandValidatedOption> {
+import { MessageCommandValidatedOption } from './builders/MessageCommandBuilder';
+export declare class MessageCommandOptionManager extends Array<MessageCommandValidatedOption> {
     constructor(options: MessageCommandValidatedOption[]);
     /**
      * Get the option info

package/bin/reciple/classes/{builders/MessageCommandOptions.js → MessageCommandOptionManager.js}

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.MessageCommandOptions = void 0;
-class MessageCommandOptions extends Array {
+exports.MessageCommandOptionManager = void 0;
+class MessageCommandOptionManager extends Array {
     constructor(options) {
         super();
         this.push(...options);
@@ -20,4 +20,4 @@ class MessageCommandOptions extends Array {
         return (_a = option === null || option === void 0 ? void 0 : option.value) !== null && _a !== void 0 ? _a : null;
     }
 }
-exports.MessageCommandOptions = MessageCommandOptions;
+exports.MessageCommandOptionManager = MessageCommandOptionManager;

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

@@ -1,10 +1,12 @@
-import { InteractionCommandBuilder, RecipleInteractionCommandExecute } from './builders/InteractionCommandBuilder';
-import { interactionCommandBuilders } from '../registerInteractionCommands';
-import { MessageCommandBuilder, RecipleMessageCommandExecute } from './builders/MessageCommandBuilder';
+import { InteractionCommandBuilder, RecipleInteractionCommandExecuteData } from './builders/InteractionCommandBuilder';
+import { MessageCommandBuilder, RecipleMessageCommandExecuteData } from './builders/MessageCommandBuilder';
+import { InteractionBuilder } from '../registerInteractionCommands';
+import { RecipleCommandBuilders } from '../types/builders';
+import { CommandCooldownManager } from './CommandCooldownManager';
+import { RecipleModule, RecipleScript } from '../modules';
 import { Logger as ILogger } from 'fallout-utility';
 import { Config } from './RecipleConfig';
 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;
 }
@@ -17,8 +19,8 @@ export interface RecipleClientCommands {
     };
 }
 export interface RecipleClientEvents extends ClientEvents {
-    recipleMessageCommandCreate: [command: RecipleMessageCommandExecute];
-    recipleInteractionCommandCreate: [command: RecipleInteractionCommandExecute];
+    recipleMessageCommandCreate: [executeData: RecipleMessageCommandExecuteData];
+    recipleInteractionCommandCreate: [executeData: RecipleInteractionCommandExecuteData];
     recipleReplyError: [error: unknown];
 }
 export interface RecipleClient<Ready extends boolean = boolean> extends Client<Ready> {
@@ -37,7 +39,8 @@ export interface RecipleClient<Ready extends boolean = boolean> extends Client<R
 export declare class RecipleClient<Ready extends boolean = boolean> extends Client<Ready> {
     config: Config;
     commands: RecipleClientCommands;
-    otherApplicationCommandData: (interactionCommandBuilders | ApplicationCommandDataResolvable)[];
+    otherApplicationCommandData: (InteractionBuilder | ApplicationCommandDataResolvable)[];
+    commandCooldowns: CommandCooldownManager;
     modules: RecipleModule[];
     logger: ILogger;
     version: string;
@@ -57,7 +60,7 @@ export declare class RecipleClient<Ready extends boolean = boolean> extends Clie
     /**
      * Add interaction or message command to client
      */
-    addCommand(command: recipleCommandBuilders): RecipleClient<Ready>;
+    addCommand(command: RecipleCommandBuilders): RecipleClient<Ready>;
     /**
      * Listed to command executions
      */
@@ -65,11 +68,11 @@ export declare class RecipleClient<Ready extends boolean = boolean> extends Clie
     /**
      * Execute a Message command
      */
-    messageCommandExecute(message: Message, prefix?: string): Promise<void | RecipleMessageCommandExecute>;
+    messageCommandExecute(message: Message, prefix?: string): Promise<void | RecipleMessageCommandExecuteData>;
     /**
      * Execute an Interaction command
      */
-    interactionCommandExecute(interaction: Interaction | CommandInteraction): Promise<void | RecipleInteractionCommandExecute>;
+    interactionCommandExecute(interaction: Interaction | CommandInteraction): Promise<void | RecipleInteractionCommandExecuteData>;
     /**
      * Get a message from config
      */
@@ -86,7 +89,7 @@ export declare class RecipleClient<Ready extends boolean = boolean> extends Clie
     /**
      * Emits the "recipleReplyError" event
      */
-    private replyError;
+    private _replyError;
     /**
      * Error message when a command fails to execute
      */

package/bin/reciple/classes/RecipleClient.js

@@ -1,10 +1,5 @@
 "use strict";
-// Dear precious programmer,
-// If you're trying to understand this code, please, consider that
-// at the time of writing this code, It was written the way humans
-// can understand it but I transformed into a dog at Apr 12th 2022
-// and accidentally made it unreadable for humans. So, if you're
-// trying to understand this code, please, consider being a dog first.
+// Not cool code
 var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
     function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
     return new (P || (P = Promise))(function (resolve, reject) {
@@ -17,15 +12,16 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.RecipleClient = void 0;
 const registerInteractionCommands_1 = require("../registerInteractionCommands");
+const permissions_1 = require("../permissions");
+const CommandCooldownManager_1 = require("./CommandCooldownManager");
+const MessageCommandOptionManager_1 = require("./MessageCommandOptionManager");
+const modules_1 = require("../modules");
 const fallout_utility_1 = require("fallout-utility");
+const RecipleConfig_1 = require("./RecipleConfig");
 const isIgnoredChannel_1 = require("../isIgnoredChannel");
-const hasPermissions_1 = require("../hasPermissions");
 const version_1 = require("../version");
 const logger_1 = require("../logger");
-const RecipleConfig_1 = require("./RecipleConfig");
 const discord_js_1 = require("discord.js");
-const modules_1 = require("../modules");
-const MessageCommandOptions_1 = require("./builders/MessageCommandOptions");
 class RecipleClient extends discord_js_1.Client {
     constructor(options) {
         var _a, _b, _c;
@@ -33,6 +29,7 @@ class RecipleClient extends discord_js_1.Client {
         this.config = RecipleConfig_1.RecipleConfig.getDefaultConfig();
         this.commands = { MESSAGE_COMMANDS: {}, INTERACTION_COMMANDS: {} };
         this.otherApplicationCommandData = [];
+        this.commandCooldowns = new CommandCooldownManager_1.CommandCooldownManager();
         this.modules = [];
         this.version = version_1.version;
         this.logger = (0, logger_1.logger)(!!((_a = options.config) === null || _a === void 0 ? void 0 : _a.fileLogging.stringifyLoggedJSON), !!((_b = options.config) === null || _b === void 0 ? void 0 : _b.fileLogging.debugmode));
@@ -71,7 +68,7 @@ class RecipleClient extends discord_js_1.Client {
                             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());
+                        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') {
@@ -155,36 +152,69 @@ class RecipleClient extends discord_js_1.Client {
             const command = this.findCommand(parseCommand.command, 'MESSAGE_COMMAND');
             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)) {
+            const commandOptions = command.getCommandOptionValues(parseCommand);
+            const executeData = {
+                message: message,
+                options: new MessageCommandOptionManager_1.MessageCommandOptionManager(commandOptions),
+                command: parseCommand,
+                builder: command,
+                client: this
+            };
+            if ((0, permissions_1.userHasCommandPermissions)(command.name, (_a = message.member) === null || _a === void 0 ? void 0 : _a.permissions, this.config.permissions.messageCommands, command)) {
                 if (!command.allowExecuteInDM && message.channel.type === 'DM'
                     || !command.allowExecuteByBots
                         && (message.author.bot || message.author.system)
                     || (0, isIgnoredChannel_1.isIgnoredChannel)(message.channelId, this.config.ignoredChannels))
                     return;
-                const commandOptions = command.getCommandOptionValues(parseCommand);
                 if (command.validateOptions) {
                     if (commandOptions.some(o => o.invalid)) {
-                        yield message.reply(this.getMessage('invalidArguments', 'Invalid argument(s) given.')).catch(er => this.replyError(er));
+                        if (!(command === null || command === void 0 ? void 0 : command.halt) || !(yield command.halt({ executeData, reason: 'INVALID_ARGUMENTS', invalidArguments: new MessageCommandOptionManager_1.MessageCommandOptionManager(executeData.options.filter(o => o.invalid)) }))) {
+                            message.reply(this.getMessage('invalidArguments', 'Invalid argument(s) given.')).catch(er => this._replyError(er));
+                        }
                         return;
                     }
                     if (commandOptions.some(o => o.missing)) {
-                        yield message.reply(this.getMessage('notEnoughArguments', 'Not enough arguments.')).catch(er => this.replyError(er));
+                        if (!command.halt || !(yield command.halt({ executeData, reason: 'MISSING_ARGUMENTS', missingArguments: new MessageCommandOptionManager_1.MessageCommandOptionManager(executeData.options.filter(o => o.missing)) }))) {
+                            message.reply(this.getMessage('notEnoughArguments', 'Not enough arguments.')).catch(er => this._replyError(er));
+                        }
                         return;
                     }
                 }
-                const options = {
-                    message: message,
-                    options: new MessageCommandOptions_1.MessageCommandOptions(commandOptions),
-                    command: parseCommand,
-                    builder: command,
-                    client: this
+                if (message.guild && !(0, permissions_1.botHasExecutePermissions)(message.guild, command.requiredBotPermissions)) {
+                    if (!command.halt || !(yield command.halt({ executeData, reason: 'MISSING_BOT_PERMISSIONS' }))) {
+                        message.reply(this.getMessage('insufficientBotPerms', 'Insufficient bot permissions.')).catch(er => this._replyError(er));
+                    }
+                    return;
+                }
+                const userCooldown = {
+                    user: message.author,
+                    command: command.name,
+                    channel: message.channel,
+                    guild: message.guild,
+                    type: 'MESSAGE_COMMAND'
                 };
-                yield Promise.resolve(command.execute(options)).catch(err => this._commandExecuteError(err, options));
-                this.emit('recipleMessageCommandCreate', options);
-                return options;
+                if (this.config.commands.messageCommand.enableCooldown && command.cooldown && !this.commandCooldowns.isCooledDown(userCooldown)) {
+                    this.commandCooldowns.add(Object.assign(Object.assign({}, userCooldown), { expireTime: Date.now() + command.cooldown }));
+                }
+                else if (this.config.commands.messageCommand.enableCooldown && command.cooldown) {
+                    if (!command.halt || !(yield command.halt(Object.assign({ executeData, reason: 'COOLDOWN' }, this.commandCooldowns.get(userCooldown))))) {
+                        yield message.reply(this.getMessage('cooldown', 'You cannot execute this command right now due to the cooldown.')).catch(er => this._replyError(er));
+                    }
+                    return;
+                }
+                try {
+                    yield Promise.resolve(command.execute(executeData)).catch((err) => __awaiter(this, void 0, void 0, function* () { return !command.halt || !(yield command.halt({ executeData, reason: 'ERROR', error: err })) ? this._commandExecuteError(err, executeData) : void 0; }));
+                    this.emit('recipleMessageCommandCreate', executeData);
+                    return executeData;
+                }
+                catch (err) {
+                    if (!command.halt || !(yield command.halt({ executeData, reason: 'ERROR', error: err }))) {
+                        this._commandExecuteError(err, executeData);
+                    }
+                }
             }
-            else {
-                yield message.reply(this.getMessage('noPermissions', 'You do not have permission to use this command.')).catch(er => this.replyError(er));
+            else if (!command.halt || !(yield command.halt({ executeData, reason: 'MISSING_MEMBER_PERMISSIONS' }))) {
+                message.reply(this.getMessage('noPermissions', 'You do not have permission to use this command.')).catch(er => this._replyError(er));
             }
         });
     }
@@ -192,28 +222,56 @@ class RecipleClient extends discord_js_1.Client {
      * Execute an Interaction command
      */
     interactionCommandExecute(interaction) {
-        var _a;
+        var _a, _b;
         return __awaiter(this, void 0, void 0, function* () {
             if (!interaction || !interaction.isCommand() || !this.isReady())
                 return;
             const command = this.findCommand(interaction.commandName, 'INTERACTION_COMMAND');
             if (!command)
                 return;
-            if ((0, hasPermissions_1.hasPermissions)(command.name, (_a = interaction.memberPermissions) !== null && _a !== void 0 ? _a : undefined, this.config.permissions.interactionCommands, command)) {
+            const executeData = {
+                interaction: interaction,
+                builder: command,
+                client: this
+            };
+            if ((0, permissions_1.userHasCommandPermissions)(command.name, (_a = interaction.memberPermissions) !== null && _a !== void 0 ? _a : undefined, this.config.permissions.interactionCommands, command)) {
                 if (!command || (0, isIgnoredChannel_1.isIgnoredChannel)(interaction.channelId, this.config.ignoredChannels))
                     return;
-                const options = {
-                    interaction: interaction,
-                    command: command,
-                    builder: command,
-                    client: this
+                if (interaction.guild && !(0, permissions_1.botHasExecutePermissions)(interaction.guild, command.requiredBotPermissions)) {
+                    if (!command.halt || !(yield command.halt({ executeData, reason: 'MISSING_BOT_PERMISSIONS' }))) {
+                        yield interaction.reply(this.getMessage('insufficientBotPerms', 'Insufficient bot permissions.')).catch(er => this._replyError(er));
+                    }
+                    return;
+                }
+                const userCooldown = {
+                    user: interaction.user,
+                    command: command.name,
+                    channel: (_b = interaction.channel) !== null && _b !== void 0 ? _b : undefined,
+                    guild: interaction.guild,
+                    type: 'INTERACTION_COMMAND'
                 };
-                yield Promise.resolve(command.execute(options)).catch(err => this._commandExecuteError(err, options));
-                this.emit('recipleInteractionCommandCreate', options);
-                return options;
+                if (this.config.commands.interactionCommand.enableCooldown && command.cooldown && !this.commandCooldowns.isCooledDown(userCooldown)) {
+                    this.commandCooldowns.add(Object.assign(Object.assign({}, userCooldown), { expireTime: Date.now() + command.cooldown }));
+                }
+                else if (this.config.commands.interactionCommand.enableCooldown && command.cooldown) {
+                    if (!command.halt || !(yield command.halt(Object.assign({ executeData, reason: 'COOLDOWN' }, this.commandCooldowns.get(userCooldown))))) {
+                        yield interaction.reply(this.getMessage('cooldown', 'You cannot execute this command right now due to the cooldown.')).catch(er => this._replyError(er));
+                    }
+                    return;
+                }
+                try {
+                    yield Promise.resolve(command.execute(executeData)).catch((err) => __awaiter(this, void 0, void 0, function* () { return !command.halt || !(yield command.halt({ executeData, reason: 'ERROR', error: err })) ? this._commandExecuteError(err, executeData) : void 0; }));
+                    this.emit('recipleInteractionCommandCreate', executeData);
+                    return executeData;
+                }
+                catch (err) {
+                    if (!command.halt || !(yield command.halt({ executeData, reason: 'ERROR', error: err }))) {
+                        this._commandExecuteError(err, executeData);
+                    }
+                }
             }
-            else {
-                yield interaction.reply(this.getMessage('noPermissions', 'You do not have permission to use this command.')).catch(er => this.replyError(er));
+            else if (!command.halt || !(yield command.halt({ executeData, reason: 'MISSING_MEMBER_PERMISSIONS' }))) {
+                yield interaction.reply(this.getMessage('noPermissions', 'You do not have permission to use this command.')).catch(er => this._replyError(er));
             }
         });
     }
@@ -246,7 +304,7 @@ class RecipleClient extends discord_js_1.Client {
     /**
      * Emits the "recipleReplyError" event
      */
-    replyError(error) {
+    _replyError(error) {
         this.emit('recipleReplyError', error);
     }
     /**
@@ -263,12 +321,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(er => this.replyError(er));
+                yield command.message.reply(this.getMessage('error', 'An error occurred.')).catch(er => this._replyError(er));
             }
             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(er => this.replyError(er));
+                yield command.interaction.followUp(this.getMessage('error', 'An error occurred.')).catch(er => this._replyError(er));
             }
         });
     }

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

@@ -1,7 +1,7 @@
-import { ClientOptions, PermissionFlags, PermissionString } from 'discord.js';
+import { ClientOptions, PermissionResolvable } from 'discord.js';
 export interface ConfigCommandPermissions {
     command: string;
-    permissions: (PermissionFlags | PermissionString)[];
+    permissions: PermissionResolvable[];
 }
 export interface Config {
     token: string;
@@ -11,12 +11,14 @@ export interface Config {
             enabled: boolean;
             replyOnError: boolean;
             allowCommandAlias: boolean;
+            enableCooldown: boolean;
             commandArgumentSeparator: string;
         };
         interactionCommand: {
             enabled: boolean;
             replyOnError: boolean;
             registerCommands: boolean;
+            enableCooldown: boolean;
             setRequiredPermissions: boolean;
             guilds: string[] | string;
         };

package/bin/reciple/classes/RecipleConfig.js

@@ -33,7 +33,7 @@ class RecipleConfig {
             this.config = yaml_1.default.parse(defaultConfig);
             if (this.config && this.config.token === 'TOKEN') {
                 this.config.token = this.askToken() || this.config.token;
-                (0, fs_1.writeFileSync)(this.configPath, (0, fallout_utility_1.replaceAll)(defaultConfig, 'TOKEN', this.config.token), 'utf-8');
+                (0, fs_1.writeFileSync)(this.configPath, (0, fallout_utility_1.replaceAll)(defaultConfig, ' TOKEN', ` ${this.config.token}`), 'utf-8');
             }
             return this;
         }

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

@@ -1,23 +1,35 @@
-import { CommandInteraction, PermissionFlags, PermissionString } from 'discord.js';
+import { Awaitable, CommandInteraction, PermissionResolvable } from 'discord.js';
+import { RecipleHaltedCommandData } from '../../types/commands';
 import { SlashCommandBuilder } from '@discordjs/builders';
 import { RecipleClient } from '../RecipleClient';
-export interface RecipleInteractionCommandExecute {
+export interface RecipleInteractionCommandExecuteData {
     interaction: CommandInteraction;
-    command: InteractionCommandBuilder;
     builder: InteractionCommandBuilder;
     client: RecipleClient<true>;
 }
 export declare class InteractionCommandBuilder extends SlashCommandBuilder {
     readonly builder = "INTERACTION_COMMAND";
-    requiredPermissions: (PermissionFlags | PermissionString)[];
+    cooldown: number;
+    requiredBotPermissions: PermissionResolvable[];
+    RequiredUserPermissions: PermissionResolvable[];
     allowExecuteInDM: boolean;
-    execute: (options: RecipleInteractionCommandExecute) => void;
+    halt?: (haltData: RecipleHaltedCommandData<InteractionCommandBuilder>) => Awaitable<boolean>;
+    execute: (executeData: RecipleInteractionCommandExecuteData) => Awaitable<void>;
     /**
-     * Set required permissions before executing the command
+     * Sets the execute cooldown for this command.
+     * - `0` means no cooldown
      */
-    setRequiredPermissions(requiredPermissions: (keyof PermissionFlags)[]): InteractionCommandBuilder;
+    setCooldown(cooldown: number): InteractionCommandBuilder;
+    /**
+     * Set required permissions to execute the command
+     */
+    setRequiredMemberPermissions(...permissions: PermissionResolvable[]): InteractionCommandBuilder;
+    /**
+     * Function when the command is interupted before execution
+     */
+    setHalt(halt?: (haltData: RecipleHaltedCommandData<InteractionCommandBuilder>) => Awaitable<boolean>): InteractionCommandBuilder;
     /**
      * Function when the command is executed
      */
-    setExecute(execute: (options: RecipleInteractionCommandExecute) => void): InteractionCommandBuilder;
+    setExecute(execute: (executeData: RecipleInteractionCommandExecuteData) => void): InteractionCommandBuilder;
 }

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

@@ -6,17 +6,32 @@ class InteractionCommandBuilder extends builders_1.SlashCommandBuilder {
     constructor() {
         super(...arguments);
         this.builder = 'INTERACTION_COMMAND';
-        this.requiredPermissions = [];
+        this.cooldown = 0;
+        this.requiredBotPermissions = [];
+        this.RequiredUserPermissions = [];
         this.allowExecuteInDM = true;
         this.execute = () => { };
     }
     /**
-     * Set required permissions before executing the command
+     * Sets the execute cooldown for this command.
+     * - `0` means no cooldown
      */
-    setRequiredPermissions(requiredPermissions) {
-        if (!requiredPermissions || !Array.isArray(requiredPermissions))
-            throw new Error('requiredPermissions must be an array.');
-        this.requiredPermissions = requiredPermissions;
+    setCooldown(cooldown) {
+        this.cooldown = cooldown;
+        return this;
+    }
+    /**
+     * Set required permissions to execute the command
+     */
+    setRequiredMemberPermissions(...permissions) {
+        this.RequiredUserPermissions = permissions;
+        return this;
+    }
+    /**
+     * Function when the command is interupted before execution
+     */
+    setHalt(halt) {
+        this.halt = halt ? halt : undefined;
         return this;
     }
     /**

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

@@ -1,11 +1,12 @@
 import { MessageCommandOptionBuilder } from './MessageCommandOptionBuilder';
-import { Message, PermissionFlags, PermissionString } from 'discord.js';
+import { MessageCommandOptionManager } from '../MessageCommandOptionManager';
+import { Awaitable, Message, PermissionResolvable } from 'discord.js';
+import { RecipleHaltedCommandData } from '../../types/commands';
 import { Command as CommandMessage } from 'fallout-utility';
 import { RecipleClient } from '../RecipleClient';
-import { MessageCommandOptions } from './MessageCommandOptions';
-export interface RecipleMessageCommandExecute {
+export interface RecipleMessageCommandExecuteData {
     message: Message;
-    options: MessageCommandOptions;
+    options: MessageCommandOptionManager;
     command: CommandMessage;
     builder: MessageCommandBuilder;
     client: RecipleClient<true>;
@@ -20,14 +21,17 @@ export interface MessageCommandValidatedOption {
 export declare class MessageCommandBuilder {
     readonly builder = "MESSAGE_COMMAND";
     name: string;
+    cooldown: number;
     description: string;
     aliases: string[];
     options: MessageCommandOptionBuilder[];
     validateOptions: boolean;
-    requiredPermissions: (PermissionFlags | PermissionString)[];
+    requiredBotPermissions: PermissionResolvable[];
+    RequiredUserPermissions: PermissionResolvable[];
     allowExecuteInDM: boolean;
     allowExecuteByBots: boolean;
-    execute: (options: RecipleMessageCommandExecute) => void;
+    halt?: (haltData: RecipleHaltedCommandData<MessageCommandBuilder>) => Awaitable<boolean>;
+    execute: (executeData: RecipleMessageCommandExecuteData) => void;
     /**
      * Sets the command name
      */
@@ -36,14 +40,23 @@ export declare class MessageCommandBuilder {
      * Sets the command description
      */
     setDescription(description: string): MessageCommandBuilder;
+    /**
+     * Sets the execute cooldown for this command.
+     * - `0` means no cooldown
+     */
+    setCooldown(cooldown: number): MessageCommandBuilder;
     /**
      * Add aliases to the command
      */
     addAliases(...aliases: string[]): MessageCommandBuilder;
     /**
-     * Sets the default required permissions to execute this command
+     * Set required per
+     */
+    setRequiredBotPermissions(...permissions: PermissionResolvable[]): MessageCommandBuilder;
+    /**
+     * Set required user permissions to execute the command
      */
-    setRequiredPermissions(permissions: (PermissionFlags | PermissionString)[]): MessageCommandBuilder;
+    setRequiredMemberPermissions(...permissions: PermissionResolvable[]): MessageCommandBuilder;
     /**
      * Set if command can be executed in dms
      */
@@ -52,10 +65,14 @@ export declare class MessageCommandBuilder {
      * Allow command to be executed by bots
      */
     setAllowExecuteByBots(allowExecuteByBots: boolean): MessageCommandBuilder;
+    /**
+     * Function when the command is interupted before execution
+     */
+    setHalt(halt?: (haltData: RecipleHaltedCommandData<MessageCommandBuilder>) => Awaitable<boolean>): MessageCommandBuilder;
     /**
      * Function when the command is executed
      */
-    setExecute(execute: (options: RecipleMessageCommandExecute) => void): MessageCommandBuilder;
+    setExecute(execute: (executeData: RecipleMessageCommandExecuteData) => void): MessageCommandBuilder;
     /**
      * Add option to the command
      */

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

@@ -6,11 +6,13 @@ class MessageCommandBuilder {
     constructor() {
         this.builder = 'MESSAGE_COMMAND';
         this.name = '';
+        this.cooldown = 0;
         this.description = '';
         this.aliases = [];
         this.options = [];
         this.validateOptions = false;
-        this.requiredPermissions = [];
+        this.requiredBotPermissions = [];
+        this.RequiredUserPermissions = [];
         this.allowExecuteInDM = true;
         this.allowExecuteByBots = false;
         this.execute = () => { };
@@ -33,6 +35,14 @@ class MessageCommandBuilder {
         this.description = description;
         return this;
     }
+    /**
+     * Sets the execute cooldown for this command.
+     * - `0` means no cooldown
+     */
+    setCooldown(cooldown) {
+        this.cooldown = cooldown;
+        return this;
+    }
     /**
      * Add aliases to the command
      */
@@ -47,12 +57,17 @@ class MessageCommandBuilder {
         return this;
     }
     /**
-     * Sets the default required permissions to execute this command
+     * Set required per
+     */
+    setRequiredBotPermissions(...permissions) {
+        this.requiredBotPermissions = permissions;
+        return this;
+    }
+    /**
+     * Set required user permissions to execute the command
      */
-    setRequiredPermissions(permissions) {
-        if (!permissions || !Array.isArray(permissions))
-            throw new TypeError('permissions must be an array.');
-        this.requiredPermissions = permissions;
+    setRequiredMemberPermissions(...permissions) {
+        this.RequiredUserPermissions = permissions;
         return this;
     }
     /**
@@ -73,6 +88,13 @@ class MessageCommandBuilder {
         this.allowExecuteByBots = allowExecuteByBots;
         return this;
     }
+    /**
+     * Function when the command is interupted before execution
+     */
+    setHalt(halt) {
+        this.halt = halt ? halt : undefined;
+        return this;
+    }
     /**
      * Function when the command is executed
      */

package/bin/reciple/modules.d.ts

@@ -1,15 +1,12 @@
-import { InteractionCommandBuilder, RecipleInteractionCommandExecute } from './classes/builders/InteractionCommandBuilder';
-import { MessageCommandBuilder, RecipleMessageCommandExecute } from './classes/builders/MessageCommandBuilder';
+import { RecipleCommandBuilders } from './types/builders';
 import { RecipleClient } from './classes/RecipleClient';
-export declare type recipleCommandBuilders = MessageCommandBuilder | InteractionCommandBuilder;
-export declare type recipleCommandBuildersExecute = RecipleInteractionCommandExecute | RecipleMessageCommandExecute;
-export declare type loadedModules = {
-    commands: recipleCommandBuilders[];
+export declare type LoadedModules = {
+    commands: RecipleCommandBuilders[];
     modules: RecipleModule[];
 };
 export declare class RecipleScript {
     versions: string | string[];
-    commands?: recipleCommandBuilders[];
+    commands?: RecipleCommandBuilders[];
     onLoad?(reciple: RecipleClient): void | Promise<void>;
     onStart(reciple: RecipleClient): boolean | Promise<boolean>;
 }
@@ -24,4 +21,4 @@ export interface RecipleModule {
 /**
  * Load modules from folder
  */
-export declare function loadModules(client: RecipleClient, folder?: string): Promise<loadedModules>;
+export declare function loadModules(client: RecipleClient, folder?: string): Promise<LoadedModules>;

package/bin/reciple/permissions.d.ts

@@ -0,0 +1,8 @@
+import { Guild, PermissionResolvable, Permissions } from 'discord.js';
+import { RecipleCommandBuilders } from './types/builders';
+import { Config } from './classes/RecipleConfig';
+/**
+ * Check if the user has permissions to execute the given command name
+ */
+export declare function userHasCommandPermissions(commandName: string, memberPermissions?: Permissions, configConmmandPermissions?: Config['permissions']['messageCommands'] | Config['permissions']['interactionCommands'], builder?: RecipleCommandBuilders): boolean;
+export declare function botHasExecutePermissions(guild?: Guild, requiredPermissions?: PermissionResolvable[]): boolean;

package/bin/reciple/permissions.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.botHasExecutePermissions = exports.userHasCommandPermissions = void 0;
+/**
+ * Check if the user has permissions to execute the given command name
+ */
+function userHasCommandPermissions(commandName, memberPermissions, configConmmandPermissions, builder) {
+    var _a, _b;
+    if (!(configConmmandPermissions === null || configConmmandPermissions === void 0 ? void 0 : configConmmandPermissions.enabled))
+        return true;
+    const command = (_a = configConmmandPermissions.commands.find(c => c.command.toLowerCase() === commandName.toLowerCase())) !== null && _a !== void 0 ? _a : { permissions: (_b = builder === null || builder === void 0 ? void 0 : builder.RequiredUserPermissions) !== null && _b !== void 0 ? _b : [] };
+    if (!command.permissions.length)
+        return true;
+    return memberPermissions ? memberPermissions.has(command.permissions) : false;
+}
+exports.userHasCommandPermissions = userHasCommandPermissions;
+function botHasExecutePermissions(guild, requiredPermissions) {
+    var _a;
+    if (!(requiredPermissions === null || requiredPermissions === void 0 ? void 0 : requiredPermissions.length))
+        return true;
+    return (guild === null || guild === void 0 ? void 0 : guild.me) ? (_a = guild.me) === null || _a === void 0 ? void 0 : _a.permissions.has(requiredPermissions) : false;
+}
+exports.botHasExecutePermissions = botHasExecutePermissions;

package/bin/reciple/registerInteractionCommands.d.ts

@@ -2,8 +2,8 @@ import { InteractionCommandBuilder } from './classes/builders/InteractionCommand
 import { ApplicationCommandDataResolvable } from 'discord.js';
 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 type InteractionBuilder = InteractionCommandBuilder | ContextMenuCommandBuilder | SlashCommandBuilder | SlashCommandSubcommandBuilder | SlashCommandOptionsOnlyBuilder | SlashCommandSubcommandGroupBuilder | SlashCommandSubcommandsOnlyBuilder;
 /**
  * Register interaction commands
  */
-export declare function registerInteractionCommands(client: RecipleClient, cmds?: (interactionCommandBuilders | ApplicationCommandDataResolvable)[], overwriteGuilds?: string | string[]): Promise<void>;
+export declare function registerInteractionCommands(client: RecipleClient, cmds?: (InteractionBuilder | ApplicationCommandDataResolvable)[], overwriteGuilds?: string | string[]): Promise<void>;

package/bin/reciple/registerInteractionCommands.js

@@ -24,8 +24,8 @@ function registerInteractionCommands(client, cmds, overwriteGuilds) {
             if ((cmd === null || cmd === void 0 ? void 0 : cmd.builder) === 'INTERACTION_COMMAND' && client.config.commands.interactionCommand.setRequiredPermissions) {
                 const permissions = (_d = (((_a = client.config.permissions) === null || _a === void 0 ? void 0 : _a.interactionCommands.enabled) ?
                     (_c = (_b = client.config.permissions) === null || _b === void 0 ? void 0 : _b.interactionCommands.commands.find(cmd_ => cmd_.command.toLowerCase() === cmd.name.toLowerCase())) === null || _c === void 0 ? void 0 : _c.permissions :
-                    undefined)) !== null && _d !== void 0 ? _d : cmd.requiredPermissions;
-                cmd.setRequiredPermissions(permissions);
+                    undefined)) !== null && _d !== void 0 ? _d : cmd.requiredBotPermissions;
+                cmd.setRequiredMemberPermissions(permissions);
                 client.commands.INTERACTION_COMMANDS[cmd.name] = cmd;
                 if (client.isClientLogsEnabled())
                     client.logger.debug(`Set required permissions for ${cmd.name}`);

package/bin/reciple/types/builders.d.ts

@@ -0,0 +1,4 @@
+import { InteractionCommandBuilder, RecipleInteractionCommandExecuteData } from '../classes/builders/InteractionCommandBuilder';
+import { MessageCommandBuilder, RecipleMessageCommandExecuteData } from '../classes/builders/MessageCommandBuilder';
+export declare type RecipleCommandBuilders = MessageCommandBuilder | InteractionCommandBuilder;
+export declare type RecipleCommandBuildersExecuteData = RecipleInteractionCommandExecuteData | RecipleMessageCommandExecuteData;

package/bin/reciple/types/builders.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/bin/reciple/types/commands.d.ts

@@ -0,0 +1,31 @@
+import { InteractionCommandBuilder, RecipleInteractionCommandExecuteData } from '../classes/builders/InteractionCommandBuilder';
+import { RecipleMessageCommandExecuteData } from '../classes/builders/MessageCommandBuilder';
+import { MessageCommandOptionManager } from '../classes/MessageCommandOptionManager';
+import { CooledDownUser } from '../classes/CommandCooldownManager';
+import { RecipleCommandBuilders } from '../types/builders';
+export declare type CommandHaltReason<Builder extends RecipleCommandBuilders> = RecipleHaltedCommandData<Builder>["reason"];
+export declare type RecipleHaltedCommandData<Builder extends RecipleCommandBuilders> = CommandErrorData<Builder> | CommandCooldownData<Builder> | CommandInvalidArguments<Builder> | CommandMissingArguments<Builder> | CommandMissingMemberPermissions<Builder> | CommandMissingBotPermissions<Builder>;
+export interface CommandHaltBaseData<Builder extends RecipleCommandBuilders> {
+    executeData: Builder extends InteractionCommandBuilder ? RecipleInteractionCommandExecuteData : RecipleMessageCommandExecuteData;
+}
+export interface CommandErrorData<Builder extends RecipleCommandBuilders> extends CommandHaltBaseData<Builder> {
+    reason: 'ERROR';
+    error: any;
+}
+export interface CommandCooldownData<Builder extends RecipleCommandBuilders> extends CommandHaltBaseData<Builder>, CooledDownUser {
+    reason: 'COOLDOWN';
+}
+export interface CommandInvalidArguments<Builder extends RecipleCommandBuilders> extends CommandHaltBaseData<Builder> {
+    reason: 'INVALID_ARGUMENTS';
+    invalidArguments: MessageCommandOptionManager;
+}
+export interface CommandMissingArguments<Builder extends RecipleCommandBuilders> extends CommandHaltBaseData<Builder> {
+    reason: 'MISSING_ARGUMENTS';
+    missingArguments: MessageCommandOptionManager;
+}
+export interface CommandMissingMemberPermissions<Builder extends RecipleCommandBuilders> extends CommandHaltBaseData<Builder> {
+    reason: 'MISSING_MEMBER_PERMISSIONS';
+}
+export interface CommandMissingBotPermissions<Builder extends RecipleCommandBuilders> extends CommandHaltBaseData<Builder> {
+    reason: 'MISSING_BOT_PERMISSIONS';
+}

package/bin/reciple/types/commands.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/bin/reciple/version.js

@@ -8,7 +8,7 @@ const semver_1 = __importDefault(require("semver"));
 /**
  * Current reciple version
  */
-exports.version = require('../../package.json').version;
+exports.version = `${semver_1.default.coerce(require('../../package.json').version)}`;
 /**
  * Check if the version is valid
  */

package/package.json

@@ -1,9 +1,12 @@
 {
   "name": "reciple",
-  "version": "1.7.1",
-  "description": "A Discord.js bot",
+  "version": "2.0.2",
+  "description": "Handler for Discord.js",
   "author": "FalloutStudios",
-  "homepage": "https://falloutstudios.github.io/Reciple",
+  "homepage": "https://reciple.js.org",
+  "bugs": {
+    "url": "https://github.com/FalloutStudios/reciple/issues"
+  },
   "license": "GPL-3.0",
   "main": "bin/index.js",
   "bin": {
@@ -21,13 +24,15 @@
   ],
   "scripts": {
     "clean": "rm -rf bin",
-    "build": "yarn clean && npx tsc && npm un reciple -g && npm i ./ -g && yarn build:docs",
-    "build:publish": "yarn run build && yarn publish",
-    "test": "yarn run build && yarn test:start",
+    "build": "yarn run clean && npx tsc && yarn run reinstall",
+    "build:publish": "yarn run build && yarn publish && yarn run publish:docs",
+    "build:pub-prerelease": "yarn run build && yarn publish --tag pre",
+    "reinstall": "npm un reciple -g && npm i ./ -g",
+    "publish:docs": "yarn run build:docs && yarn run update:docs",
+    "test": "yarn run build && yarn run test:start",
     "test:start": "cd test && npx reciple",
-    "postpublish": "yarn build:docs && yarn update:docs",
-    "build:docs": "cd docs && yarn build",
-    "update:docs": "cd docs && yarn update"
+    "build:docs": "cd docs && yarn run build",
+    "update:docs": "cd docs && yarn run update"
   },
   "dependencies": {
     "chalk": "4.1.2",

package/resource/reciple.yml

@@ -13,8 +13,10 @@ commands:
     enabled: true
     # reply when an error occured
     replyOnError: false
+    # Enable the use of command cooldowns
+    enableCooldown: false
     # Allow executing commands via aliases
-    allowCommandAlias: false
+    allowCommandAlias: true
     # command argument separator
     commandArgumentSeparator: ' '
   interactionCommand:
@@ -22,6 +24,8 @@ commands:
     enabled: true
     # reply when an error occured
     replyOnError: false
+    # Enable the use of command cooldowns
+    enableCooldown: false
     # register interaction commands on bot ready
     registerCommands: true
     # set required permissions for interaction commands
@@ -80,9 +84,15 @@ client:
 messages:
   notEnoughArguments: 'Not enough arguments.'
   invalidArguments: 'Invalid argument(s) given.'
+  insufficientBotPerms:
+    content: 'Insufficient bot permissions.'
+    ephemeral: true
   noPermissions:
     content: 'You do not have permission to use this command.'
     ephemeral: true
+  cooldown:
+    content: 'You cannot execute this command right now due to the cooldown.'
+    ephemeral: true
   error:
     content: 'An error occurred.'
     ephemeral: true

package/bin/reciple/hasPermissions.d.ts

@@ -1,7 +0,0 @@
-import { Permissions } from 'discord.js';
-import { recipleCommandBuilders } from './modules';
-import { Config } from './classes/RecipleConfig';
-/**
- * Check if the user has permissions to execute the given command name
- */
-export declare function hasPermissions(commandName: string, memberPermissions?: Permissions, configConmmandPermissions?: Config['permissions']['messageCommands'] | Config['permissions']['interactionCommands'], builder?: recipleCommandBuilders): boolean;

package/bin/reciple/hasPermissions.js

@@ -1,16 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.hasPermissions = void 0;
-/**
- * Check if the user has permissions to execute the given command name
- */
-function hasPermissions(commandName, memberPermissions, configConmmandPermissions, builder) {
-    var _a, _b;
-    if (!(configConmmandPermissions === null || configConmmandPermissions === void 0 ? void 0 : configConmmandPermissions.enabled))
-        return true;
-    const command = (_a = configConmmandPermissions.commands.find(c => c.command.toLowerCase() === commandName.toLowerCase())) !== null && _a !== void 0 ? _a : { permissions: (_b = builder === null || builder === void 0 ? void 0 : builder.requiredPermissions) !== null && _b !== void 0 ? _b : [] };
-    if (!command.permissions.length)
-        return true;
-    return memberPermissions ? memberPermissions.has(command.permissions) : false;
-}
-exports.hasPermissions = hasPermissions;