reciple 3.1.4 → 4.0.0-pre.3

package/bin/bin.js

@@ -12,7 +12,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
-var _a, _b;
+var _a, _b, _c;
 Object.defineProperty(exports, "__esModule", { value: true });
 const RecipleClient_1 = require("./reciple/classes/RecipleClient");
 const RecipleConfig_1 = require("./reciple/classes/RecipleConfig");
@@ -26,15 +26,15 @@ if (flags_1.flags.version) {
     console.log(`v${version_1.version}`);
     process.exit(0);
 }
-const allowedFiles = ['node_modules', 'reciple.yml', 'package.json', 'package.lock.json', 'modules.yml', '.rmmcache'];
-if ((0, fs_1.readdirSync)('./').filter(f => !f.startsWith('.') && allowedFiles.indexOf(f)).length > 0 && !(0, fs_1.existsSync)('./reciple.yml')) {
-    const ask = (_a = (0, fallout_utility_1.input)('This directory does not contain reciple.yml. Would you like to init axis here? [y/n] ')) !== null && _a !== void 0 ? _a : '';
+const allowedFiles = ['node_modules', 'reciple.yml', 'package.json'];
+if ((0, fs_1.readdirSync)('./').filter(f => !f.startsWith('.') && allowedFiles.indexOf(f)).length > 0 && !(0, fs_1.existsSync)((_a = flags_1.flags.config) !== null && _a !== void 0 ? _a : './reciple.yml')) {
+    const ask = (_b = (0, fallout_utility_1.input)('This directory does not contain reciple.yml. Would you like to init axis here? [y/n] ')) !== null && _b !== void 0 ? _b : '';
     if (ask.toString().toLowerCase() !== 'y')
         process.exit(0);
 }
 let configParser;
 try {
-    configParser = new RecipleConfig_1.RecipleConfig((_b = flags_1.flags.config) !== null && _b !== void 0 ? _b : './reciple.yml').parseConfig();
+    configParser = new RecipleConfig_1.RecipleConfig((_c = flags_1.flags.config) !== null && _c !== void 0 ? _c : './reciple.yml').parseConfig();
 }
 catch (err) {
     console.error(`${chalk_1.default.bold.red('Config Error')}: ${chalk_1.default.white(err.message)}`);
@@ -47,9 +47,9 @@ if (config.fileLogging.clientLogs)
 (() => __awaiter(void 0, void 0, void 0, function* () {
     yield client.startModules();
     client.on('ready', () => __awaiter(void 0, void 0, void 0, function* () {
-        var _c;
+        var _d;
         if (client.isClientLogsEnabled())
-            client.logger.warn(`Logged in as ${((_c = client.user) === null || _c === void 0 ? void 0 : _c.tag) || 'Unknown'}!`);
+            client.logger.warn(`Logged in as ${((_d = client.user) === null || _d === void 0 ? void 0 : _d.tag) || 'Unknown'}!`);
         yield client.loadModules();
         client.addCommandListeners();
     }));

package/bin/index.d.ts

@@ -2,9 +2,9 @@ export * from './reciple/classes/CommandCooldownManager';
 export * from './reciple/classes/MessageCommandOptionManager';
 export * from './reciple/classes/RecipleClient';
 export * from './reciple/classes/RecipleConfig';
-export * from './reciple/classes/builders/InteractionCommandBuilder';
 export * from './reciple/classes/builders/MessageCommandBuilder';
 export * from './reciple/classes/builders/MessageCommandOptionBuilder';
+export * from './reciple/classes/builders/SlashCommandBuilder';
 export * from './reciple/types/builders';
 export * from './reciple/types/commands';
 export * from './reciple/types/paramOptions';

package/bin/index.js

@@ -18,9 +18,9 @@ __exportStar(require("./reciple/classes/CommandCooldownManager"), exports);
 __exportStar(require("./reciple/classes/MessageCommandOptionManager"), exports);
 __exportStar(require("./reciple/classes/RecipleClient"), exports);
 __exportStar(require("./reciple/classes/RecipleConfig"), 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/SlashCommandBuilder"), exports);
 __exportStar(require("./reciple/types/builders"), exports);
 __exportStar(require("./reciple/types/commands"), exports);
 __exportStar(require("./reciple/types/paramOptions"), exports);

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

@@ -1,4 +1,4 @@
-import { RecipleCommandBuilderType } from '../types/builders';
+import { CommandBuilderType } from '../types/builders';
 import { Guild, TextBasedChannel, User } from 'discord.js';
 /**
  * Object interface for cooled-down user
@@ -6,7 +6,7 @@ import { Guild, TextBasedChannel, User } from 'discord.js';
 export interface CooledDownUser {
     user: User;
     command: string;
-    type: RecipleCommandBuilderType;
+    type: CommandBuilderType;
     guild?: Guild | null;
     channel?: TextBasedChannel;
     expireTime: number;

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

@@ -6,7 +6,7 @@ export declare class MessageCommandOptionManager extends Array<MessageCommandVal
     /**
      * @param options Validated options
      */
-    constructor(options: MessageCommandValidatedOption[]);
+    constructor(...options: MessageCommandValidatedOption[]);
     /**
      * Get the option info
      * @param name Option name

package/bin/reciple/classes/MessageCommandOptionManager.js

@@ -8,9 +8,8 @@ class MessageCommandOptionManager extends Array {
     /**
      * @param options Validated options
      */
-    constructor(options) {
-        super();
-        this.push(...options);
+    constructor(...options) {
+        super(...(options !== null && options !== void 0 ? options : []));
     }
     get(name, required) {
         const option = this.find(o => o.name == name);

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

@@ -1,9 +1,9 @@
 import { RecipleModule } from '../modules';
 import { ApplicationCommandBuilder } from '../registerInteractionCommands';
-import { RecipleCommandBuilder, RecipleCommandBuilderType } from '../types/builders';
-import { RecipleAddModuleOptions } from '../types/paramOptions';
-import { InteractionCommandBuilder, InteractionCommandExecuteData } from './builders/InteractionCommandBuilder';
+import { CommandBuilder, CommandBuilderType } from '../types/builders';
+import { RecipleClientAddModuleOptions } from '../types/paramOptions';
 import { MessageCommandBuilder, MessageCommandExecuteData } from './builders/MessageCommandBuilder';
+import { SlashCommandBuilder, SlashCommandExecuteData } from './builders/SlashCommandBuilder';
 import { CommandCooldownManager } from './CommandCooldownManager';
 import { Config } from './RecipleConfig';
 import { ApplicationCommandData, Awaitable, ChatInputCommandInteraction, Client, ClientEvents, ClientOptions, Interaction, Message } from 'discord.js';
@@ -21,8 +21,8 @@ export interface RecipleClientCommands {
     messageCommands: {
         [commandName: string]: MessageCommandBuilder;
     };
-    interactionCommands: {
-        [commandName: string]: InteractionCommandBuilder;
+    slashCommands: {
+        [commandName: string]: SlashCommandBuilder;
     };
 }
 /**
@@ -30,7 +30,7 @@ export interface RecipleClientCommands {
  */
 export interface RecipleClientEvents extends ClientEvents {
     recipleMessageCommandCreate: [executeData: MessageCommandExecuteData];
-    recipleInteractionCommandCreate: [executeData: InteractionCommandExecuteData];
+    recipleInteractionCommandCreate: [executeData: SlashCommandExecuteData];
     recipleReplyError: [error: unknown];
 }
 /**
@@ -49,6 +49,9 @@ export interface RecipleClient<Ready extends boolean = boolean> extends Client<R
     removeAllListeners(event?: string | symbol): this;
     isReady(): this is RecipleClient<true>;
 }
+/**
+ * The reciple client
+ */
 export declare class RecipleClient<Ready extends boolean = boolean> extends Client<Ready> {
     config: Config;
     commands: RecipleClientCommands;
@@ -67,19 +70,19 @@ export declare class RecipleClient<Ready extends boolean = boolean> extends Clie
      */
     startModules(folder?: string): Promise<RecipleClient<Ready>>;
     /**
-     * Execute `onLoad()` from client modules and register interaction commands if enabled
+     * Execute `onLoad()` from client modules and register application commands if enabled
      */
     loadModules(): Promise<RecipleClient<Ready>>;
     /**
      * Add module
      * @param options Module options
      */
-    addModule(options: RecipleAddModuleOptions): Promise<void>;
+    addModule(options: RecipleClientAddModuleOptions): Promise<void>;
     /**
-     * Add interaction or message command to client
-     * @param command Interaction/Message command builder
+     * Add slash or message command to client
+     * @param command Slash/Message command builder
      */
-    addCommand(command: RecipleCommandBuilder): RecipleClient<Ready>;
+    addCommand(command: CommandBuilder): RecipleClient<Ready>;
     /**
      * Listed to command executions
      */
@@ -91,10 +94,10 @@ export declare class RecipleClient<Ready extends boolean = boolean> extends Clie
      */
     messageCommandExecute(message: Message, prefix?: string): Promise<void | MessageCommandExecuteData>;
     /**
-     * Execute an Interaction command
-     * @param interaction Command Interaction
+     * Execute a slash command
+     * @param interaction Slash command interaction
      */
-    interactionCommandExecute(interaction: Interaction | ChatInputCommandInteraction): Promise<void | InteractionCommandExecuteData>;
+    slashCommandExecute(interaction: Interaction | ChatInputCommandInteraction): Promise<void | SlashCommandExecuteData>;
     /**
      * Get a message from config
      * @param messageKey Config messages key
@@ -106,8 +109,8 @@ export declare class RecipleClient<Ready extends boolean = boolean> extends Clie
      * @param command Command name
      * @param type Command type
      */
-    findCommand(command: string, type: RecipleCommandBuilderType.MessageCommand): MessageCommandBuilder | undefined;
-    findCommand(command: string, type: RecipleCommandBuilderType.InteractionCommand): InteractionCommandBuilder | undefined;
+    findCommand(command: string, type: CommandBuilderType.MessageCommand): MessageCommandBuilder | undefined;
+    findCommand(command: string, type: CommandBuilderType.SlashCommand): SlashCommandBuilder | undefined;
     /**
      * Returns true if client logs is enabled
      */
@@ -126,7 +129,7 @@ export declare class RecipleClient<Ready extends boolean = boolean> extends Clie
     /**
      * Error message when a command fails to execute
      * @param err Received error
-     * @param command Interaction/Message command execute data
+     * @param command Slash/Message command execute data
      */
     private _commandExecuteError;
 }

package/bin/reciple/classes/RecipleClient.js

@@ -24,6 +24,9 @@ const MessageCommandOptionManager_1 = require("./MessageCommandOptionManager");
 const RecipleConfig_1 = require("./RecipleConfig");
 const discord_js_1 = require("discord.js");
 const fallout_utility_1 = require("fallout-utility");
+/**
+ * The reciple client
+ */
 class RecipleClient extends discord_js_1.Client {
     /**
      * @param options Client options
@@ -32,7 +35,7 @@ class RecipleClient extends discord_js_1.Client {
         var _a, _b, _c;
         super(options);
         this.config = RecipleConfig_1.RecipleConfig.getDefaultConfig();
-        this.commands = { messageCommands: {}, interactionCommands: {} };
+        this.commands = { messageCommands: {}, slashCommands: {} };
         this.otherApplicationCommandData = [];
         this.commandCooldowns = new CommandCooldownManager_1.CommandCooldownManager();
         this.modules = [];
@@ -60,7 +63,7 @@ class RecipleClient extends discord_js_1.Client {
         });
     }
     /**
-     * Execute `onLoad()` from client modules and register interaction commands if enabled
+     * Execute `onLoad()` from client modules and register application commands if enabled
      */
     loadModules() {
         var _a, _b;
@@ -86,13 +89,13 @@ class RecipleClient extends discord_js_1.Client {
             if (this.isClientLogsEnabled()) {
                 this.logger.info(`${this.modules.length} modules loaded.`);
                 this.logger.info(`${Object.keys(this.commands.messageCommands).length} message commands loaded.`);
-                this.logger.info(`${Object.keys(this.commands.interactionCommands).length} interaction commands loaded.`);
+                this.logger.info(`${Object.keys(this.commands.slashCommands).length} slash commands loaded.`);
             }
-            if (this.config.commands.interactionCommand.registerCommands) {
-                yield (0, registerInteractionCommands_1.registerInteractionCommands)({
+            if (this.config.commands.slashCommand.registerCommands) {
+                yield (0, registerInteractionCommands_1.registerApplicationCommands)({
                     client: this,
-                    commands: [...Object.values(this.commands.interactionCommands), ...this.otherApplicationCommandData],
-                    guilds: this.config.commands.interactionCommand.guilds
+                    commands: [...Object.values(this.commands.slashCommands), ...this.otherApplicationCommandData],
+                    guilds: this.config.commands.slashCommand.guilds
                 });
             }
             return this;
@@ -106,7 +109,7 @@ class RecipleClient extends discord_js_1.Client {
         var _a;
         return __awaiter(this, void 0, void 0, function* () {
             const { script } = options;
-            const registerCommands = options.registerInteractionCommands;
+            const registerCommands = options.registerApplicationCommands;
             const info = options.moduleInfo;
             this.modules.push({
                 script,
@@ -122,24 +125,24 @@ class RecipleClient extends discord_js_1.Client {
                 this.addCommand(command);
             }
             if (registerCommands)
-                yield (0, registerInteractionCommands_1.registerInteractionCommands)({
+                yield (0, registerInteractionCommands_1.registerApplicationCommands)({
                     client: this,
-                    commands: [...Object.values(this.commands.interactionCommands), ...this.otherApplicationCommandData],
-                    guilds: this.config.commands.interactionCommand.guilds
+                    commands: [...Object.values(this.commands.slashCommands), ...this.otherApplicationCommandData],
+                    guilds: this.config.commands.slashCommand.guilds
                 });
         });
     }
     /**
-     * Add interaction or message command to client
-     * @param command Interaction/Message command builder
+     * Add slash or message command to client
+     * @param command Slash/Message command builder
      */
     addCommand(command) {
         var _a;
-        if (command.builder === builders_1.RecipleCommandBuilderType.MessageCommand) {
+        if (command.builder === builders_1.CommandBuilderType.MessageCommand) {
             this.commands.messageCommands[command.name] = command;
         }
-        else if (command.builder === builders_1.RecipleCommandBuilderType.InteractionCommand) {
-            this.commands.interactionCommands[command.name] = command;
+        else if (command.builder === builders_1.CommandBuilderType.SlashCommand) {
+            this.commands.slashCommands[command.name] = command;
         }
         else if (this.isClientLogsEnabled()) {
             this.logger.error(`Unknow command "${(_a = typeof command) !== null && _a !== void 0 ? _a : 'unknown'}".`);
@@ -152,8 +155,8 @@ class RecipleClient extends discord_js_1.Client {
     addCommandListeners() {
         if (this.config.commands.messageCommand.enabled)
             this.on('messageCreate', (message) => { this.messageCommandExecute(message); });
-        if (this.config.commands.interactionCommand.enabled)
-            this.on('interactionCreate', (interaction) => { this.interactionCommandExecute(interaction); });
+        if (this.config.commands.slashCommand.enabled)
+            this.on('interactionCreate', (interaction) => { this.slashCommandExecute(interaction); });
         return this;
     }
     /**
@@ -169,7 +172,7 @@ class RecipleClient extends discord_js_1.Client {
             const parseCommand = (0, fallout_utility_1.getCommand)(message.content, prefix || this.config.commands.messageCommand.prefix || '!', this.config.commands.messageCommand.commandArgumentSeparator || ' ');
             if (!parseCommand || !(parseCommand === null || parseCommand === void 0 ? void 0 : parseCommand.command))
                 return;
-            const command = this.findCommand(parseCommand.command, builders_1.RecipleCommandBuilderType.MessageCommand);
+            const command = this.findCommand(parseCommand.command, builders_1.CommandBuilderType.MessageCommand);
             if (!command)
                 return;
             const commandOptions = (0, MessageCommandBuilder_1.validateMessageCommandOptions)(command, parseCommand);
@@ -192,20 +195,20 @@ class RecipleClient extends discord_js_1.Client {
                     return;
                 if (command.validateOptions) {
                     if (commandOptions.some(o => o.invalid)) {
-                        if (!(yield this._haltCommand(command, { executeData, reason: commands_1.RecipleHaltedCommandReason.InvalidArguments, invalidArguments: new MessageCommandOptionManager_1.MessageCommandOptionManager(executeData.options.filter(o => o.invalid)) }))) {
+                        if (!(yield this._haltCommand(command, { executeData, reason: commands_1.HaltedCommandReason.InvalidArguments, 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)) {
-                        if (!(yield this._haltCommand(command, { executeData, reason: commands_1.RecipleHaltedCommandReason.MissingArguments, missingArguments: new MessageCommandOptionManager_1.MessageCommandOptionManager(executeData.options.filter(o => o.missing)) }))) {
+                        if (!(yield this._haltCommand(command, { executeData, reason: commands_1.HaltedCommandReason.MissingArguments, missingArguments: new MessageCommandOptionManager_1.MessageCommandOptionManager(...executeData.options.filter(o => o.missing)) }))) {
                             message.reply(this.getMessage('missingArguments', 'Not enough arguments.')).catch(er => this._replyError(er));
                         }
                         return;
                     }
                 }
                 if (message.guild && !(0, permissions_1.botHasExecutePermissions)(message.guild, command.requiredBotPermissions)) {
-                    if (!(yield this._haltCommand(command, { executeData, reason: commands_1.RecipleHaltedCommandReason.MissingBotPermissions }))) {
+                    if (!(yield this._haltCommand(command, { executeData, reason: commands_1.HaltedCommandReason.MissingBotPermissions }))) {
                         message.reply(this.getMessage('insufficientBotPerms', 'Insufficient bot permissions.')).catch(er => this._replyError(er));
                     }
                     return;
@@ -215,13 +218,13 @@ class RecipleClient extends discord_js_1.Client {
                     command: command.name,
                     channel: message.channel,
                     guild: message.guild,
-                    type: builders_1.RecipleCommandBuilderType.MessageCommand
+                    type: builders_1.CommandBuilderType.MessageCommand
                 };
                 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 (!(yield this._haltCommand(command, Object.assign({ executeData, reason: commands_1.RecipleHaltedCommandReason.Cooldown }, this.commandCooldowns.get(userCooldown))))) {
+                    if (!(yield this._haltCommand(command, Object.assign({ executeData, reason: commands_1.HaltedCommandReason.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;
@@ -229,46 +232,46 @@ class RecipleClient extends discord_js_1.Client {
                 try {
                     yield Promise.resolve(command.execute(executeData))
                         .then(() => this.emit('recipleMessageCommandCreate', executeData))
-                        .catch((err) => __awaiter(this, void 0, void 0, function* () { return (yield this._haltCommand(command, { executeData, reason: commands_1.RecipleHaltedCommandReason.Error, error: err })) ? this._commandExecuteError(err, executeData) : void 0; }));
+                        .catch((err) => __awaiter(this, void 0, void 0, function* () { return (yield this._haltCommand(command, { executeData, reason: commands_1.HaltedCommandReason.Error, error: err })) ? this._commandExecuteError(err, executeData) : void 0; }));
                     return executeData;
                 }
                 catch (err) {
-                    if (!(yield this._haltCommand(command, { executeData, reason: commands_1.RecipleHaltedCommandReason.Error, error: err }))) {
+                    if (!(yield this._haltCommand(command, { executeData, reason: commands_1.HaltedCommandReason.Error, error: err }))) {
                         this._commandExecuteError(err, executeData);
                     }
                 }
             }
-            else if (!(yield this._haltCommand(command, { executeData, reason: commands_1.RecipleHaltedCommandReason.MissingMemberPermissions }))) {
+            else if (!(yield this._haltCommand(command, { executeData, reason: commands_1.HaltedCommandReason.MissingMemberPermissions }))) {
                 message.reply(this.getMessage('noPermissions', 'You do not have permission to use this command.')).catch(er => this._replyError(er));
             }
         });
     }
     /**
-     * Execute an Interaction command
-     * @param interaction Command Interaction
+     * Execute a slash command
+     * @param interaction Slash command interaction
      */
-    interactionCommandExecute(interaction) {
+    slashCommandExecute(interaction) {
         var _a, _b;
         return __awaiter(this, void 0, void 0, function* () {
             if (!interaction || interaction.type !== discord_js_1.InteractionType.ApplicationCommand || !interaction.isChatInputCommand() || !this.isReady())
                 return;
-            const command = this.findCommand(interaction.commandName, builders_1.RecipleCommandBuilderType.InteractionCommand);
+            const command = this.findCommand(interaction.commandName, builders_1.CommandBuilderType.SlashCommand);
             if (!command)
                 return;
             const executeData = {
-                interaction: interaction,
+                interaction,
                 builder: command,
                 client: this
             };
             if ((0, permissions_1.userHasCommandPermissions)({
                 builder: command,
                 memberPermissions: (_a = interaction.memberPermissions) !== null && _a !== void 0 ? _a : undefined,
-                commandPermissions: this.config.commands.interactionCommand.permissions
+                commandPermissions: this.config.commands.slashCommand.permissions
             })) {
                 if (!command || (0, permissions_1.isIgnoredChannel)(interaction.channelId, this.config.ignoredChannels))
                     return;
                 if (interaction.guild && !(0, permissions_1.botHasExecutePermissions)(interaction.guild, command.requiredBotPermissions)) {
-                    if (!(yield this._haltCommand(command, { executeData, reason: commands_1.RecipleHaltedCommandReason.MissingBotPermissions }))) {
+                    if (!(yield this._haltCommand(command, { executeData, reason: commands_1.HaltedCommandReason.MissingBotPermissions }))) {
                         yield interaction.reply(this.getMessage('insufficientBotPerms', 'Insufficient bot permissions.')).catch(er => this._replyError(er));
                     }
                     return;
@@ -278,13 +281,13 @@ class RecipleClient extends discord_js_1.Client {
                     command: command.name,
                     channel: (_b = interaction.channel) !== null && _b !== void 0 ? _b : undefined,
                     guild: interaction.guild,
-                    type: builders_1.RecipleCommandBuilderType.InteractionCommand
+                    type: builders_1.CommandBuilderType.SlashCommand
                 };
-                if (this.config.commands.interactionCommand.enableCooldown && command.cooldown && !this.commandCooldowns.isCooledDown(userCooldown)) {
+                if (this.config.commands.slashCommand.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 (!(yield this._haltCommand(command, Object.assign({ executeData, reason: commands_1.RecipleHaltedCommandReason.Cooldown }, this.commandCooldowns.get(userCooldown))))) {
+                else if (this.config.commands.slashCommand.enableCooldown && command.cooldown) {
+                    if (!(yield this._haltCommand(command, Object.assign({ executeData, reason: commands_1.HaltedCommandReason.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;
@@ -292,16 +295,16 @@ class RecipleClient extends discord_js_1.Client {
                 try {
                     yield Promise.resolve(command.execute(executeData))
                         .then(() => this.emit('recipleInteractionCommandCreate', executeData))
-                        .catch((err) => __awaiter(this, void 0, void 0, function* () { return (yield this._haltCommand(command, { executeData, reason: commands_1.RecipleHaltedCommandReason.Error, error: err })) ? this._commandExecuteError(err, executeData) : void 0; }));
+                        .catch((err) => __awaiter(this, void 0, void 0, function* () { return (yield this._haltCommand(command, { executeData, reason: commands_1.HaltedCommandReason.Error, error: err })) ? this._commandExecuteError(err, executeData) : void 0; }));
                     return executeData;
                 }
                 catch (err) {
-                    if (!(yield this._haltCommand(command, { executeData, reason: commands_1.RecipleHaltedCommandReason.Error, error: err }))) {
+                    if (!(yield this._haltCommand(command, { executeData, reason: commands_1.HaltedCommandReason.Error, error: err }))) {
                         this._commandExecuteError(err, executeData);
                     }
                 }
             }
-            else if (!(yield this._haltCommand(command, { executeData, reason: commands_1.RecipleHaltedCommandReason.MissingMemberPermissions }))) {
+            else if (!(yield this._haltCommand(command, { executeData, reason: commands_1.HaltedCommandReason.MissingMemberPermissions }))) {
                 yield interaction.reply(this.getMessage('noPermissions', 'You do not have permission to use this command.')).catch(er => this._replyError(er));
             }
         });
@@ -318,9 +321,9 @@ class RecipleClient extends discord_js_1.Client {
     findCommand(command, type) {
         var _a;
         switch (type) {
-            case builders_1.RecipleCommandBuilderType.InteractionCommand:
-                return this.commands.interactionCommands[command];
-            case builders_1.RecipleCommandBuilderType.MessageCommand:
+            case builders_1.CommandBuilderType.SlashCommand:
+                return this.commands.slashCommands[command];
+            case builders_1.CommandBuilderType.MessageCommand:
                 return (_a = this.commands.messageCommands[command.toLowerCase()]) !== null && _a !== void 0 ? _a : (this.config.commands.messageCommand.allowCommandAlias
                     ? Object.values(this.commands.messageCommands).find(c => c.aliases.some(a => a == (command === null || command === void 0 ? void 0 : command.toLowerCase())))
                     : undefined);
@@ -346,7 +349,7 @@ class RecipleClient extends discord_js_1.Client {
         return __awaiter(this, void 0, void 0, function* () {
             try {
                 return (_a = (command.halt
-                    ? yield (command.builder == builders_1.RecipleCommandBuilderType.InteractionCommand
+                    ? yield (command.builder == builders_1.CommandBuilderType.SlashCommand
                         ? Promise.resolve(command.halt(haltData))
                         : Promise.resolve(command.halt(haltData))).catch(err => { throw err; })
                     : false)) !== null && _a !== void 0 ? _a : false;
@@ -363,12 +366,12 @@ class RecipleClient extends discord_js_1.Client {
     /**
      * Error message when a command fails to execute
      * @param err Received error
-     * @param command Interaction/Message command execute data
+     * @param command Slash/Message command execute data
      */
     _commandExecuteError(err, command) {
         return __awaiter(this, void 0, void 0, function* () {
             if (this.isClientLogsEnabled()) {
-                this.logger.error(`An error occured executing ${command.builder.builder == builders_1.RecipleCommandBuilderType.MessageCommand ? 'message' : 'interaction'} command "${command.builder.name}"`);
+                this.logger.error(`An error occured executing ${command.builder.builder == builders_1.CommandBuilderType.MessageCommand ? 'message' : 'slash'} command "${command.builder.name}"`);
                 this.logger.error(err);
             }
             if (!err || !command)
@@ -379,7 +382,7 @@ class RecipleClient extends discord_js_1.Client {
                 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)
+                if (!this.config.commands.slashCommand.replyOnError)
                     return;
                 yield command.interaction.followUp(this.getMessage('error', 'An error occurred.')).catch(er => this._replyError(er));
             }

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

@@ -24,7 +24,7 @@ export interface Config {
                 commands: ConfigCommandPermissions[];
             };
         };
-        interactionCommand: {
+        slashCommand: {
             enabled: boolean;
             replyOnError: boolean;
             registerCommands: boolean;
@@ -55,6 +55,7 @@ export interface Config {
     };
     ignoredFiles: string[];
     modulesFolder: string;
+    disableVersionCheck: boolean;
     version: string;
 }
 /**

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

@@ -1,5 +1,5 @@
-import { RecipleCommandBuilderType } from '../../types/builders';
-import { RecipleHaltedCommandData } from '../../types/commands';
+import { CommandBuilderType } from '../../types/builders';
+import { HaltedCommandData } from '../../types/commands';
 import { MessageCommandOptionManager } from '../MessageCommandOptionManager';
 import { RecipleClient } from '../RecipleClient';
 import { MessageCommandOptionBuilder } from './MessageCommandOptionBuilder';
@@ -29,7 +29,7 @@ export interface MessageCommandValidatedOption {
  * Reciple builder for message command
  */
 export declare class MessageCommandBuilder {
-    readonly builder = RecipleCommandBuilderType.MessageCommand;
+    readonly builder = CommandBuilderType.MessageCommand;
     name: string;
     cooldown: number;
     description: string;
@@ -40,7 +40,7 @@ export declare class MessageCommandBuilder {
     requiredMemberPermissions: PermissionResolvable[];
     allowExecuteInDM: boolean;
     allowExecuteByBots: boolean;
-    halt?: (haltData: RecipleHaltedCommandData<MessageCommandBuilder>) => Awaitable<boolean | void>;
+    halt?: (haltData: HaltedCommandData<MessageCommandBuilder>) => Awaitable<boolean | void>;
     execute: (executeData: MessageCommandExecuteData) => void;
     /**
      * Sets the command name
@@ -87,7 +87,7 @@ export declare class MessageCommandBuilder {
      * Function when the command is interupted
      * @param halt Function to execute when command is halted
      */
-    setHalt(halt?: (haltData: RecipleHaltedCommandData<MessageCommandBuilder>) => Awaitable<boolean | void>): MessageCommandBuilder;
+    setHalt(halt?: (haltData: HaltedCommandData<MessageCommandBuilder>) => Awaitable<boolean | void>): MessageCommandBuilder;
     /**
      * Function when the command is executed
      * @param execute Function to execute when the command is called
@@ -103,11 +103,5 @@ export declare class MessageCommandBuilder {
      * @param validateOptions `true` if the command options needs to be validated before executing
      */
     setValidateOptions(validateOptions: boolean): MessageCommandBuilder;
-    /**
-     * validate given command options
-     * @deprecated use `validateMessageCommandOptions()` instead
-     * @param options Parsed message command data
-     */
-    getCommandOptionValues(options: CommandMessage): MessageCommandOptionManager;
 }
 export declare function validateMessageCommandOptions(builder: MessageCommandBuilder, options: CommandMessage): MessageCommandOptionManager;

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

@@ -9,7 +9,7 @@ const MessageCommandOptionBuilder_1 = require("./MessageCommandOptionBuilder");
  */
 class MessageCommandBuilder {
     constructor() {
-        this.builder = builders_1.RecipleCommandBuilderType.MessageCommand;
+        this.builder = builders_1.CommandBuilderType.MessageCommand;
         this.name = '';
         this.cooldown = 0;
         this.description = '';
@@ -144,15 +144,6 @@ class MessageCommandBuilder {
         this.validateOptions = validateOptions;
         return this;
     }
-    /**
-     * validate given command options
-     * @deprecated use `validateMessageCommandOptions()` instead
-     * @param options Parsed message command data
-     */
-    // TODO: Remove this on the next major update
-    getCommandOptionValues(options) {
-        return validateMessageCommandOptions(this, options);
-    }
 }
 exports.MessageCommandBuilder = MessageCommandBuilder;
 function validateMessageCommandOptions(builder, options) {
@@ -186,6 +177,6 @@ function validateMessageCommandOptions(builder, options) {
         result.push(value);
         i++;
     }
-    return new MessageCommandOptionManager_1.MessageCommandOptionManager(result);
+    return new MessageCommandOptionManager_1.MessageCommandOptionManager(...result);
 }
 exports.validateMessageCommandOptions = validateMessageCommandOptions;

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

@@ -0,0 +1,56 @@
+import { CommandBuilderType } from '../../types/builders';
+import { HaltedCommandData } from '../../types/commands';
+import { RecipleClient } from '../RecipleClient';
+import { Awaitable, ChatInputCommandInteraction, PermissionResolvable, SlashCommandBuilder as DiscordJsSlashCommandBuilder, SlashCommandSubcommandBuilder, SlashCommandSubcommandGroupBuilder, SlashCommandSubcommandsOnlyBuilder as DiscordJsSlashCommandSubcommandsOnlyBuilder } from 'discord.js';
+/**
+ * Execute data for interaction command
+ */
+export interface SlashCommandExecuteData {
+    interaction: ChatInputCommandInteraction;
+    builder: SlashCommandBuilder;
+    client: RecipleClient<true>;
+}
+export interface SlashCommandSubcommandsOnlyBuilder extends DiscordJsSlashCommandSubcommandsOnlyBuilder, Pick<SlashCommandBuilder, "setCooldown" | "setRequiredBotPermissions" | "setRequiredMemberPermissions" | "setHalt" | "setExecute"> {
+}
+export interface SlashCommandBuilder extends DiscordJsSlashCommandBuilder {
+    addSubcommandGroup(input: SlashCommandSubcommandGroupBuilder | ((subcommandGroup: SlashCommandSubcommandGroupBuilder) => SlashCommandSubcommandGroupBuilder)): SlashCommandSubcommandsOnlyBuilder;
+    addSubcommand(input: SlashCommandSubcommandBuilder | ((subcommandGroup: SlashCommandSubcommandBuilder) => SlashCommandSubcommandBuilder)): SlashCommandSubcommandsOnlyBuilder;
+}
+/**
+ * Reciple builder for interaction/slash command
+ */
+export declare class SlashCommandBuilder extends DiscordJsSlashCommandBuilder {
+    readonly builder = CommandBuilderType.SlashCommand;
+    cooldown: number;
+    requiredBotPermissions: PermissionResolvable[];
+    requiredMemberPermissions: PermissionResolvable[];
+    allowExecuteInDM: boolean;
+    halt?: (haltData: HaltedCommandData<SlashCommandBuilder>) => Awaitable<boolean | void>;
+    execute: (executeData: SlashCommandExecuteData) => Awaitable<void>;
+    /**
+     * Sets the execute cooldown for this command.
+     * - `0` means no cooldown
+     * @param cooldown Command cooldown in milliseconds
+     */
+    setCooldown(cooldown: number): SlashCommandBuilder;
+    /**
+     * Set required bot permissions to execute the command
+     * @param permissions Bot's required permissions
+     */
+    setRequiredBotPermissions(...permissions: PermissionResolvable[]): SlashCommandBuilder;
+    /**
+     * Set required permissions to execute the command
+     * @param permissions User's return permissions
+     */
+    setRequiredMemberPermissions(...permissions: PermissionResolvable[]): SlashCommandBuilder;
+    /**
+     * Function when the command is interupted
+     * @param halt Function to execute when command is halted
+     */
+    setHalt(halt?: (haltData: HaltedCommandData<SlashCommandBuilder>) => Awaitable<boolean | void>): SlashCommandBuilder;
+    /**
+     * Function when the command is executed
+     * @param execute Function to execute when the command is called
+     */
+    setExecute(execute: (executeData: SlashCommandExecuteData) => void): SlashCommandBuilder;
+}

package/bin/reciple/classes/builders/{InteractionCommandBuilder.js → SlashCommandBuilder.js}

@@ -1,15 +1,15 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.InteractionCommandBuilder = void 0;
+exports.SlashCommandBuilder = void 0;
 const builders_1 = require("../../types/builders");
 const discord_js_1 = require("discord.js");
 /**
  * Reciple builder for interaction/slash command
  */
-class InteractionCommandBuilder extends discord_js_1.SlashCommandBuilder {
+class SlashCommandBuilder extends discord_js_1.SlashCommandBuilder {
     constructor() {
         super(...arguments);
-        this.builder = builders_1.RecipleCommandBuilderType.InteractionCommand;
+        this.builder = builders_1.CommandBuilderType.SlashCommand;
         this.cooldown = 0;
         this.requiredBotPermissions = [];
         this.requiredMemberPermissions = [];
@@ -60,4 +60,4 @@ class InteractionCommandBuilder extends discord_js_1.SlashCommandBuilder {
         return this;
     }
 }
-exports.InteractionCommandBuilder = InteractionCommandBuilder;
+exports.SlashCommandBuilder = SlashCommandBuilder;

package/bin/reciple/logger.d.ts

@@ -6,11 +6,3 @@ import { Logger } from 'fallout-utility';
  * @param colorizeMessage add logger colours to messages
  */
 export declare function createLogger(stringifyJSON: boolean, debugmode?: boolean, colorizeMessage?: boolean): Logger;
-/**
- * Create new logger
- * @deprecated Use `createLogger` instead
- * @param stringifyJSON stringify json objects in console
- * @param debugmode display debug messages
- * @param colorizeMessage add logger colours to messages
- */
-export declare function logger(stringifyJSON: boolean, debugmode?: boolean, colorizeMessage?: boolean): Logger;

package/bin/reciple/logger.js

@@ -3,7 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.logger = exports.createLogger = void 0;
+exports.createLogger = void 0;
 const flags_1 = require("./flags");
 const chalk_1 = __importDefault(require("chalk"));
 const fallout_utility_1 = require("fallout-utility");
@@ -34,16 +34,3 @@ function createLogger(stringifyJSON, debugmode = false, colorizeMessage = true)
     });
 }
 exports.createLogger = createLogger;
-/**
- * Create new logger
- * @deprecated Use `createLogger` instead
- * @param stringifyJSON stringify json objects in console
- * @param debugmode display debug messages
- * @param colorizeMessage add logger colours to messages
- */
-// TODO: Remove this on next major release
-function logger(stringifyJSON, debugmode = false, colorizeMessage = true) {
-    process.emitWarning('logger() is deprecated use createLogger() instead', 'DeprecationWarning');
-    return createLogger(stringifyJSON, debugmode, colorizeMessage);
-}
-exports.logger = logger;

package/bin/reciple/modules.d.ts

@@ -1,15 +1,15 @@
 import { RecipleClient } from './classes/RecipleClient';
-import { RecipleCommandBuilder } from './types/builders';
+import { CommandBuilder } from './types/builders';
 export declare type LoadedModules = {
-    commands: RecipleCommandBuilder[];
+    commands: CommandBuilder[];
     modules: RecipleModule[];
 };
 /**
  * Reciple script object interface
  */
-export declare class RecipleScript {
+export interface RecipleScript {
     versions: string | string[];
-    commands?: RecipleCommandBuilder[];
+    commands?: CommandBuilder[];
     onLoad?(reciple: RecipleClient): void | Promise<void>;
     onStart(reciple: RecipleClient): boolean | Promise<boolean>;
 }

package/bin/reciple/modules.js

@@ -44,13 +44,13 @@ function loadModules(client, folder) {
                 if (!((_a = module_.versions) === null || _a === void 0 ? void 0 : _a.length))
                     throw new Error('Module does not have supported versions.');
                 const versions = typeof module_.versions === 'object' ? module_.versions : [module_.versions];
-                if (!versions.some(v => (0, version_1.isSupportedVersion)(v, version_1.version)))
+                if (!client.config.disableVersionCheck && !versions.some(v => (0, version_1.isSupportedVersion)(v, version_1.version)))
                     throw new Error((_b = 'Module versions is not defined or unsupported; supported versions: ' + module_.versions) !== null && _b !== void 0 ? _b : 'none' + '; current version: ' + version_1.version);
                 if (!(yield Promise.resolve(module_.onStart(client))))
                     throw new Error(script + ' onStart is not defined or returned false.');
                 if (module_.commands) {
                     for (const command of module_.commands) {
-                        if (command.builder === builders_1.RecipleCommandBuilderType.MessageCommand || command.builder === builders_1.RecipleCommandBuilderType.InteractionCommand) {
+                        if (command.builder === builders_1.CommandBuilderType.MessageCommand || command.builder === builders_1.CommandBuilderType.SlashCommand) {
                             commands.push(command);
                         }
                     }
@@ -69,7 +69,7 @@ function loadModules(client, folder) {
                         client.logger.error(`A ${c.builder} command name is not defined in ${script}`);
                     return false;
                 }
-                if (c.builder === builders_1.RecipleCommandBuilderType.MessageCommand && c.options.length && c.options.some(o => !o.name)) {
+                if (c.builder === builders_1.CommandBuilderType.MessageCommand && c.options.length && c.options.some(o => !o.name)) {
                     if (client.isClientLogsEnabled())
                         client.logger.error(`A ${c.builder} option name is not defined in ${script}`);
                     return false;

package/bin/reciple/permissions.d.ts

@@ -1,11 +1,11 @@
 import { Config } from './classes/RecipleConfig';
-import { RecipleUserHasCommandPermissionsOptions } from './types/paramOptions';
+import { UserHasCommandPermissionsOptions } from './types/paramOptions';
 import { Guild, PermissionResolvable } from 'discord.js';
 /**
  * Check if the user has permissions to execute the given command name
  * @param options options
  */
-export declare function userHasCommandPermissions(options: RecipleUserHasCommandPermissionsOptions): boolean;
+export declare function userHasCommandPermissions(options: UserHasCommandPermissionsOptions): boolean;
 /**
  * Check if the bot has the required permissions in a guild
  * @param guild Guild

package/bin/reciple/registerInteractionCommands.d.ts

@@ -1,9 +1,9 @@
-import { InteractionCommandBuilder } from './classes/builders/InteractionCommandBuilder';
-import { RecipleRegisterInteractionCommandsOptions } from './types/paramOptions';
-import { ContextMenuCommandBuilder, SlashCommandBuilder } from '@discordjs/builders';
-export declare type ApplicationCommandBuilder = InteractionCommandBuilder | ContextMenuCommandBuilder | SlashCommandBuilder;
+import { SlashCommandBuilder } from './classes/builders/SlashCommandBuilder';
+import { RegisterApplicationCommandsOptions } from './types/paramOptions';
+import { ContextMenuCommandBuilder, SlashCommandBuilder as DiscordJsSlashCommandBuilder } from 'discord.js';
+export declare type ApplicationCommandBuilder = SlashCommandBuilder | ContextMenuCommandBuilder | DiscordJsSlashCommandBuilder;
 /**
- * Register interaction commands
- * @param options Register interaction commands options
+ * Register application commands
+ * @param options Register application commands options
  */
-export declare function registerInteractionCommands(options: RecipleRegisterInteractionCommandsOptions): Promise<void>;
+export declare function registerApplicationCommands(options: RegisterApplicationCommandsOptions): Promise<void>;

package/bin/reciple/registerInteractionCommands.js

@@ -9,31 +9,32 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.registerInteractionCommands = void 0;
-const InteractionCommandBuilder_1 = require("./classes/builders/InteractionCommandBuilder");
+exports.registerApplicationCommands = void 0;
+const SlashCommandBuilder_1 = require("./classes/builders/SlashCommandBuilder");
 /**
- * Register interaction commands
- * @param options Register interaction commands options
+ * Register application commands
+ * @param options Register application commands options
  */
-function registerInteractionCommands(options) {
+function registerApplicationCommands(options) {
     var _a, _b, _c, _d;
     return __awaiter(this, void 0, void 0, function* () {
         const client = options.client;
         const guilds = typeof options.guilds == 'string' ? [options.guilds] : options.guilds;
-        const commands = (_b = Object.values((_a = options.commands) !== null && _a !== void 0 ? _a : client.commands.interactionCommands).map(cmd => {
+        const commands = (_b = Object.values((_a = options.commands) !== null && _a !== void 0 ? _a : client.commands.slashCommands).map(cmd => {
             var _a;
             if (typeof (cmd === null || cmd === void 0 ? void 0 : cmd.toJSON) == 'undefined')
                 return cmd;
             cmd = cmd;
-            if (cmd instanceof InteractionCommandBuilder_1.InteractionCommandBuilder && client.config.commands.interactionCommand.setRequiredPermissions) {
-                const permissions = client.config.commands.interactionCommand.permissions.enabled
-                    ? (_a = client.config.commands.interactionCommand.permissions.commands.find(cmd_ => cmd_.command.toLowerCase() === cmd.name.toLowerCase())) === null || _a === void 0 ? void 0 : _a.permissions
+            if (cmd instanceof SlashCommandBuilder_1.SlashCommandBuilder && client.config.commands.slashCommand.setRequiredPermissions) {
+                const permissions = client.config.commands.slashCommand.permissions.enabled
+                    ? (_a = client.config.commands.slashCommand.permissions.commands.find(cmd_ => cmd_.command.toLowerCase() === cmd.name.toLowerCase())) === null || _a === void 0 ? void 0 : _a.permissions
                     : undefined;
-                if (permissions)
+                if (permissions) {
                     cmd.setRequiredMemberPermissions(...permissions);
-                client.commands.interactionCommands[cmd.name] = cmd;
-                if (client.isClientLogsEnabled())
-                    client.logger.debug(`Set required permissions for ${cmd.name}`);
+                    if (client.isClientLogsEnabled())
+                        client.logger.debug(`Set required permissions for ${cmd.name}`);
+                }
+                client.commands.slashCommands[cmd.name] = cmd;
                 return cmd.toJSON();
             }
             return cmd.toJSON();
@@ -43,21 +44,21 @@ function registerInteractionCommands(options) {
         if (!guilds || !(guilds === null || guilds === void 0 ? void 0 : guilds.length)) {
             (_c = client.application) === null || _c === void 0 ? void 0 : _c.commands.set(commands).then(() => {
                 if (client.isClientLogsEnabled())
-                    client.logger.warn('No guilds were specified for interaction commands. Registered interaction commands globally.');
+                    client.logger.warn('No guilds were specified for application commands. Registered application commands globally.');
             });
         }
         else {
             if (client.isClientLogsEnabled())
-                client.logger.warn(`Registering ${commands.length} interaction commands to ${guilds.length} guild(s).`);
+                client.logger.warn(`Registering ${commands.length} application commands to ${guilds.length} guild(s).`);
             for (const guild of guilds) {
                 if (!guild)
                     continue;
                 (_d = client.application) === null || _d === void 0 ? void 0 : _d.commands.set(commands, guild).then(() => {
                     if (client.isClientLogsEnabled())
-                        client.logger.warn(`Registered ${commands.length} interaction command(s) for ${guild}.`);
+                        client.logger.warn(`Registered ${commands.length} application command(s) for ${guild}.`);
                 });
             }
         }
     });
 }
-exports.registerInteractionCommands = registerInteractionCommands;
+exports.registerApplicationCommands = registerApplicationCommands;

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

@@ -1,17 +1,17 @@
-import { InteractionCommandBuilder, InteractionCommandExecuteData } from '../classes/builders/InteractionCommandBuilder';
 import { MessageCommandBuilder, MessageCommandExecuteData } from '../classes/builders/MessageCommandBuilder';
+import { SlashCommandBuilder, SlashCommandExecuteData } from '../classes/builders/SlashCommandBuilder';
 /**
  * Reciple command builders
  */
-export declare type RecipleCommandBuilder = MessageCommandBuilder | InteractionCommandBuilder;
+export declare type CommandBuilder = MessageCommandBuilder | SlashCommandBuilder;
 /**
  * Reciple command builders execute data
  */
-export declare type RecipleCommandBuildersExecuteData = InteractionCommandExecuteData | MessageCommandExecuteData;
+export declare type CommandBuilderExecuteData = SlashCommandExecuteData | MessageCommandExecuteData;
 /**
  * Types of Reciple command builders
  */
-export declare enum RecipleCommandBuilderType {
+export declare enum CommandBuilderType {
     MessageCommand = 0,
-    InteractionCommand = 1
+    SlashCommand = 1
 }

package/bin/reciple/types/builders.js

@@ -1,11 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.RecipleCommandBuilderType = void 0;
+exports.CommandBuilderType = void 0;
 /**
  * Types of Reciple command builders
  */
-var RecipleCommandBuilderType;
-(function (RecipleCommandBuilderType) {
-    RecipleCommandBuilderType[RecipleCommandBuilderType["MessageCommand"] = 0] = "MessageCommand";
-    RecipleCommandBuilderType[RecipleCommandBuilderType["InteractionCommand"] = 1] = "InteractionCommand";
-})(RecipleCommandBuilderType = exports.RecipleCommandBuilderType || (exports.RecipleCommandBuilderType = {}));
+var CommandBuilderType;
+(function (CommandBuilderType) {
+    CommandBuilderType[CommandBuilderType["MessageCommand"] = 0] = "MessageCommand";
+    CommandBuilderType[CommandBuilderType["SlashCommand"] = 1] = "SlashCommand";
+})(CommandBuilderType = exports.CommandBuilderType || (exports.CommandBuilderType = {}));

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

@@ -1,40 +1,40 @@
-import { InteractionCommandBuilder, InteractionCommandExecuteData } from '../classes/builders/InteractionCommandBuilder';
 import { MessageCommandExecuteData } from '../classes/builders/MessageCommandBuilder';
+import { SlashCommandBuilder, SlashCommandExecuteData } from '../classes/builders/SlashCommandBuilder';
 import { CooledDownUser } from '../classes/CommandCooldownManager';
 import { MessageCommandOptionManager } from '../classes/MessageCommandOptionManager';
-import { RecipleCommandBuilder } from '../types/builders';
+import { CommandBuilder } from '../types/builders';
 /**
  * Halted command's data
  */
-export declare type RecipleHaltedCommandData<Builder extends RecipleCommandBuilder = RecipleCommandBuilder> = RecipleCommandErrorData<Builder> | RecipleCommandCooldownData<Builder> | (Builder extends InteractionCommandBuilder ? never : RecipleCommandInvalidArguments<Builder> | RecipleCommandMissingArguments<Builder>) | RecipleCommandMissingMemberPermissions<Builder> | RecipleCommandMissingBotPermissions<Builder>;
-export interface RecipleCommandHaltBaseData<Builder extends RecipleCommandBuilder> {
-    executeData: Builder extends InteractionCommandBuilder ? InteractionCommandExecuteData : MessageCommandExecuteData;
+export declare type HaltedCommandData<Builder extends CommandBuilder = CommandBuilder> = CommandErrorData<Builder> | CommandCooldownData<Builder> | (Builder extends SlashCommandBuilder ? never : CommandInvalidArguments<Builder> | CommandMissingArguments<Builder>) | CommandMissingMemberPermissions<Builder> | CommandMissingBotPermissions<Builder>;
+export interface CommandHaltBaseData<Builder extends CommandBuilder> {
+    executeData: Builder extends SlashCommandBuilder ? SlashCommandExecuteData : MessageCommandExecuteData;
 }
-export interface RecipleCommandErrorData<Builder extends RecipleCommandBuilder> extends RecipleCommandHaltBaseData<Builder> {
-    reason: RecipleHaltedCommandReason.Error;
+export interface CommandErrorData<Builder extends CommandBuilder> extends CommandHaltBaseData<Builder> {
+    reason: HaltedCommandReason.Error;
     error: any;
 }
-export interface RecipleCommandCooldownData<Builder extends RecipleCommandBuilder> extends RecipleCommandHaltBaseData<Builder>, CooledDownUser {
-    reason: RecipleHaltedCommandReason.Cooldown;
+export interface CommandCooldownData<Builder extends CommandBuilder> extends CommandHaltBaseData<Builder>, CooledDownUser {
+    reason: HaltedCommandReason.Cooldown;
 }
-export interface RecipleCommandInvalidArguments<Builder extends RecipleCommandBuilder> extends RecipleCommandHaltBaseData<Builder> {
-    reason: RecipleHaltedCommandReason.InvalidArguments;
+export interface CommandInvalidArguments<Builder extends CommandBuilder> extends CommandHaltBaseData<Builder> {
+    reason: HaltedCommandReason.InvalidArguments;
     invalidArguments: MessageCommandOptionManager;
 }
-export interface RecipleCommandMissingArguments<Builder extends RecipleCommandBuilder> extends RecipleCommandHaltBaseData<Builder> {
-    reason: RecipleHaltedCommandReason.MissingArguments;
+export interface CommandMissingArguments<Builder extends CommandBuilder> extends CommandHaltBaseData<Builder> {
+    reason: HaltedCommandReason.MissingArguments;
     missingArguments: MessageCommandOptionManager;
 }
-export interface RecipleCommandMissingMemberPermissions<Builder extends RecipleCommandBuilder> extends RecipleCommandHaltBaseData<Builder> {
-    reason: RecipleHaltedCommandReason.MissingMemberPermissions;
+export interface CommandMissingMemberPermissions<Builder extends CommandBuilder> extends CommandHaltBaseData<Builder> {
+    reason: HaltedCommandReason.MissingMemberPermissions;
 }
-export interface RecipleCommandMissingBotPermissions<Builder extends RecipleCommandBuilder> extends RecipleCommandHaltBaseData<Builder> {
-    reason: RecipleHaltedCommandReason.MissingBotPermissions;
+export interface CommandMissingBotPermissions<Builder extends CommandBuilder> extends CommandHaltBaseData<Builder> {
+    reason: HaltedCommandReason.MissingBotPermissions;
 }
 /**
  * Command halt reasons
  */
-export declare enum RecipleHaltedCommandReason {
+export declare enum HaltedCommandReason {
     Error = 0,
     Cooldown = 1,
     InvalidArguments = 2,

package/bin/reciple/types/commands.js

@@ -1,15 +1,15 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.RecipleHaltedCommandReason = void 0;
+exports.HaltedCommandReason = void 0;
 /**
  * Command halt reasons
  */
-var RecipleHaltedCommandReason;
-(function (RecipleHaltedCommandReason) {
-    RecipleHaltedCommandReason[RecipleHaltedCommandReason["Error"] = 0] = "Error";
-    RecipleHaltedCommandReason[RecipleHaltedCommandReason["Cooldown"] = 1] = "Cooldown";
-    RecipleHaltedCommandReason[RecipleHaltedCommandReason["InvalidArguments"] = 2] = "InvalidArguments";
-    RecipleHaltedCommandReason[RecipleHaltedCommandReason["MissingArguments"] = 3] = "MissingArguments";
-    RecipleHaltedCommandReason[RecipleHaltedCommandReason["MissingMemberPermissions"] = 4] = "MissingMemberPermissions";
-    RecipleHaltedCommandReason[RecipleHaltedCommandReason["MissingBotPermissions"] = 5] = "MissingBotPermissions";
-})(RecipleHaltedCommandReason = exports.RecipleHaltedCommandReason || (exports.RecipleHaltedCommandReason = {}));
+var HaltedCommandReason;
+(function (HaltedCommandReason) {
+    HaltedCommandReason[HaltedCommandReason["Error"] = 0] = "Error";
+    HaltedCommandReason[HaltedCommandReason["Cooldown"] = 1] = "Cooldown";
+    HaltedCommandReason[HaltedCommandReason["InvalidArguments"] = 2] = "InvalidArguments";
+    HaltedCommandReason[HaltedCommandReason["MissingArguments"] = 3] = "MissingArguments";
+    HaltedCommandReason[HaltedCommandReason["MissingMemberPermissions"] = 4] = "MissingMemberPermissions";
+    HaltedCommandReason[HaltedCommandReason["MissingBotPermissions"] = 5] = "MissingBotPermissions";
+})(HaltedCommandReason = exports.HaltedCommandReason || (exports.HaltedCommandReason = {}));

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

@@ -2,23 +2,23 @@ import { RecipleClient } from '../classes/RecipleClient';
 import { Config } from '../classes/RecipleConfig';
 import { RecipleModule, RecipleScript } from '../modules';
 import { ApplicationCommandBuilder } from '../registerInteractionCommands';
-import { RecipleCommandBuilder } from './builders';
+import { CommandBuilder } from './builders';
 import { ApplicationCommandData, PermissionsBitField } from 'discord.js';
-export interface RecipleAddModuleOptions {
+export interface RecipleClientAddModuleOptions {
     /**
      * The Module script
      */
     script: RecipleScript;
     /**
-     * Register interaction commands if possible
+     * Register application commands if possible
      */
-    registerInteractionCommands?: boolean;
+    registerApplicationCommands?: boolean;
     /**
      * Module optional info
      */
     moduleInfo?: RecipleModule["info"];
 }
-export interface RecipleRegisterInteractionCommandsOptions {
+export interface RegisterApplicationCommandsOptions {
     /**
      * Bot client
      */
@@ -27,13 +27,13 @@ export interface RecipleRegisterInteractionCommandsOptions {
      * Commands to register
      */
     commands: (ApplicationCommandData | ApplicationCommandBuilder)[];
-    /**PermissionResolvable
+    /**
      * Set guild to not register commands globally
      */
     guilds?: string | string[];
 }
-export interface RecipleUserHasCommandPermissionsOptions {
-    builder: RecipleCommandBuilder;
+export interface UserHasCommandPermissionsOptions {
+    builder: CommandBuilder;
     memberPermissions?: PermissionsBitField;
-    commandPermissions?: Config["commands"]["interactionCommand"]["permissions"] | Config["commands"]["messageCommand"]["permissions"];
+    commandPermissions?: Config["commands"]["slashCommand"]["permissions"] | Config["commands"]["messageCommand"]["permissions"];
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "reciple",
-  "version": "3.1.4",
+  "version": "4.0.0-pre.3",
   "bin": "bin/bin.js",
   "license": "GPL-3.0",
   "main": "bin/index.js",
@@ -19,10 +19,10 @@
     "url": "https://github.com/FalloutStudios/reciple/issues"
   },
   "scripts": {
-    "clean": "rm -rf bin",
+    "clean": "yarn exec rimraf bin",
     "build": "yarn clean && yarn exec tsc",
     "build:publish": "yarn build && yarn npm publish && yarn build:docs && yarn publish:docs",
-    "build:pub-prerelease": "yarn build && yarn publish --tag pre",
+    "build:pub-prerelease": "yarn build && yarn npm publish --tag pre",
     "build:docs": "yarn exec typedoc --tsconfig ./docs/typedoc.json",
     "update:docs": "yarn workspace docs update",
     "test": "yarn build && yarn test:start",
@@ -58,8 +58,8 @@
   "devDependencies": {
     "@types/node": "^18.6.1",
     "@types/semver": "^7.3.10",
-    "better-docs": "^2.7.2",
     "discord.js": "^14.0.3",
+    "rimraf": "^3.0.2",
     "typedoc": "^0.23.9",
     "typedoc-plugin-discord-types": "^1.0.2",
     "typedoc-plugin-djs-links": "^1.2.0",
@@ -67,7 +67,7 @@
     "typescript": "^4.7.4"
   },
   "peerDependencies": {
-    "discord.js": "14.0.x"
+    "discord.js": "^14.0.3"
   },
   "packageManager": "yarn@3.2.2"
 }

package/resource/reciple.yml

@@ -27,7 +27,7 @@ commands:
           permissions: ['Administrator']
 
   # Interaction command options
-  interactionCommand:
+  slashCommand:
     # enable interaction commands
     enabled: true
     # reply when an error occured
@@ -116,5 +116,8 @@ ignoredFiles: []
 # Modules folder
 modulesFolder: 'modules'
 
+# Load modules regardless of its supported versions
+disableVersionCheck: false
+
 # Current version
 version: ^VERSION

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

@@ -1,50 +0,0 @@
-import { RecipleCommandBuilderType } from '../../types/builders';
-import { RecipleHaltedCommandData } from '../../types/commands';
-import { RecipleClient } from '../RecipleClient';
-import { Awaitable, ChatInputCommandInteraction, PermissionResolvable, SlashCommandBuilder } from 'discord.js';
-/**
- * Execute data for interaction command
- */
-export interface InteractionCommandExecuteData {
-    interaction: ChatInputCommandInteraction;
-    builder: InteractionCommandBuilder;
-    client: RecipleClient<true>;
-}
-/**
- * Reciple builder for interaction/slash command
- */
-export declare class InteractionCommandBuilder extends SlashCommandBuilder {
-    readonly builder = RecipleCommandBuilderType.InteractionCommand;
-    cooldown: number;
-    requiredBotPermissions: PermissionResolvable[];
-    requiredMemberPermissions: PermissionResolvable[];
-    allowExecuteInDM: boolean;
-    halt?: (haltData: RecipleHaltedCommandData<InteractionCommandBuilder>) => Awaitable<boolean | void>;
-    execute: (executeData: InteractionCommandExecuteData) => Awaitable<void>;
-    /**
-     * Sets the execute cooldown for this command.
-     * - `0` means no cooldown
-     * @param cooldown Command cooldown in milliseconds
-     */
-    setCooldown(cooldown: number): InteractionCommandBuilder;
-    /**
-     * Set required bot permissions to execute the command
-     * @param permissions Bot's required permissions
-     */
-    setRequiredBotPermissions(...permissions: PermissionResolvable[]): InteractionCommandBuilder;
-    /**
-     * Set required permissions to execute the command
-     * @param permissions User's return permissions
-     */
-    setRequiredMemberPermissions(...permissions: PermissionResolvable[]): InteractionCommandBuilder;
-    /**
-     * Function when the command is interupted
-     * @param halt Function to execute when command is halted
-     */
-    setHalt(halt?: (haltData: RecipleHaltedCommandData<InteractionCommandBuilder>) => Awaitable<boolean | void>): InteractionCommandBuilder;
-    /**
-     * Function when the command is executed
-     * @param execute Function to execute when the command is called
-     */
-    setExecute(execute: (executeData: InteractionCommandExecuteData) => void): InteractionCommandBuilder;
-}