reciple 5.0.0-pre.1 → 5.0.0-pre.4

package/bin/bin.js

@@ -46,6 +46,9 @@ if (config.fileLogging.clientLogs)
         var _e;
         if (client.isClientLogsEnabled())
             client.logger.warn(`Logged in as ${((_e = client.user) === null || _e === void 0 ? void 0 : _e.tag) || 'Unknown'}!`);
+        client.on('cacheSweep', () => {
+            client.cooldowns.clean();
+        });
         yield client.loadModules();
         client.addCommandListeners();
     }));

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

@@ -1,8 +1,9 @@
 import { MessageCommandBuilder, MessageCommandExecuteData } from './builders/MessageCommandBuilder';
 import { SlashCommandBuilder, SlashCommandExecuteData } from './builders/SlashCommandBuilder';
 import { ApplicationCommandBuilder } from '../registerApplicationCommands';
-import { AnyCommandBuilder, CommandBuilderType } from '../types/builders';
+import { AnyCommandBuilder, CommandBuilderType, AnyCommandExecuteData } from '../types/builders';
 import { CommandCooldownManager } from './CommandCooldownManager';
+import { AnyCommandHaltData } from '../types/commands';
 import { RecipleClientAddModuleOptions } from '../types/paramOptions';
 import { Logger as ILogger } from 'fallout-utility';
 import { Config } from './RecipleConfig';
@@ -18,19 +19,19 @@ export interface RecipleClientOptions extends ClientOptions {
  * Reciple client commands object interface
  */
 export interface RecipleClientCommands {
-    messageCommands: {
-        [commandName: string]: MessageCommandBuilder;
-    };
     slashCommands: {
         [commandName: string]: SlashCommandBuilder;
     };
+    messageCommands: {
+        [commandName: string]: MessageCommandBuilder;
+    };
 }
 /**
  * Reciple client events
  */
 export interface RecipleClientEvents extends ClientEvents {
-    recipleMessageCommandCreate: [executeData: MessageCommandExecuteData];
-    recipleInteractionCommandCreate: [executeData: SlashCommandExecuteData];
+    recipleCommandExecute: [executeData: AnyCommandExecuteData];
+    recipleCommandHalt: [haltData: AnyCommandHaltData];
     recipleReplyError: [error: unknown];
 }
 /**
@@ -52,8 +53,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: (ApplicationCommandBuilder | ApplicationCommandData)[];
-    commandCooldowns: CommandCooldownManager;
+    additionalApplicationCommands: (ApplicationCommandBuilder | ApplicationCommandData)[];
+    cooldowns: CommandCooldownManager;
     modules: RecipleModule[];
     logger: ILogger;
     version: string;
@@ -84,23 +85,23 @@ export declare class RecipleClient<Ready extends boolean = boolean> extends Clie
      * Listed to command executions
      */
     addCommandListeners(): RecipleClient<Ready>;
+    /**
+     * Execute a slash command
+     * @param interaction Slash command interaction
+     */
+    slashCommandExecute(interaction: Interaction | ChatInputCommandInteraction): Promise<void | SlashCommandExecuteData>;
     /**
      * Execute a Message command
      * @param message Message command executor
      * @param prefix Message command prefix
      */
     messageCommandExecute(message: Message, prefix?: string): Promise<void | MessageCommandExecuteData>;
-    /**
-     * Execute a slash command
-     * @param interaction Slash command interaction
-     */
-    slashCommandExecute(interaction: Interaction | ChatInputCommandInteraction): Promise<void | SlashCommandExecuteData>;
     /**
      * Get a message from config
      * @param messageKey Config messages key
      * @param defaultMessage Default message when the key does not exists
      */
-    getMessage<T = unknown>(messageKey: string, defaultMessage?: T): T;
+    getConfigMessage<T = unknown>(messageKey: string, defaultMessage?: T): T;
     /**
      * Get command builder by name or alias if it's a message command
      * @param command Command name

package/bin/reciple/classes/RecipleClient.js

@@ -13,8 +13,8 @@ exports.RecipleClient = void 0;
 const MessageCommandBuilder_1 = require("./builders/MessageCommandBuilder");
 const SlashCommandBuilder_1 = require("./builders/SlashCommandBuilder");
 const registerApplicationCommands_1 = require("../registerApplicationCommands");
-const permissions_1 = require("../permissions");
 const builders_1 = require("../types/builders");
+const permissions_1 = require("../permissions");
 const CommandCooldownManager_1 = require("./CommandCooldownManager");
 const MessageCommandOptionManager_1 = require("./MessageCommandOptionManager");
 const commands_1 = require("../types/commands");
@@ -32,9 +32,9 @@ class RecipleClient extends discord_js_1.Client {
         var _a, _b, _c;
         super(options);
         this.config = RecipleConfig_1.RecipleConfig.getDefaultConfig();
-        this.commands = { messageCommands: {}, slashCommands: {} };
-        this.otherApplicationCommandData = [];
-        this.commandCooldowns = new CommandCooldownManager_1.CommandCooldownManager();
+        this.commands = { slashCommands: {}, messageCommands: {} };
+        this.additionalApplicationCommands = [];
+        this.cooldowns = new CommandCooldownManager_1.CommandCooldownManager();
         this.modules = [];
         this.version = version_1.version;
         this.logger = (0, logger_1.createLogger)(!!((_a = options.config) === null || _a === void 0 ? void 0 : _a.fileLogging.stringifyLoggedJSON), (_b = options.config) === null || _b === void 0 ? void 0 : _b.fileLogging.debugmode);
@@ -91,7 +91,7 @@ class RecipleClient extends discord_js_1.Client {
             if (this.config.commands.slashCommand.registerCommands) {
                 yield (0, registerApplicationCommands_1.registerApplicationCommands)({
                     client: this,
-                    commands: [...Object.values(this.commands.slashCommands), ...this.otherApplicationCommandData],
+                    commands: [...Object.values(this.commands.slashCommands), ...this.additionalApplicationCommands],
                     guilds: this.config.commands.slashCommand.guilds
                 });
             }
@@ -124,7 +124,7 @@ class RecipleClient extends discord_js_1.Client {
             if (registerCommands)
                 yield (0, registerApplicationCommands_1.registerApplicationCommands)({
                     client: this,
-                    commands: [...Object.values(this.commands.slashCommands), ...this.otherApplicationCommandData],
+                    commands: [...Object.values(this.commands.slashCommands), ...this.additionalApplicationCommands],
                     guilds: this.config.commands.slashCommand.guilds
                 });
         });
@@ -157,78 +157,54 @@ class RecipleClient extends discord_js_1.Client {
         return this;
     }
     /**
-     * Execute a Message command
-     * @param message Message command executor
-     * @param prefix Message command prefix
+     * Execute a slash command
+     * @param interaction Slash command interaction
      */
-    messageCommandExecute(message, prefix) {
-        var _a;
+    slashCommandExecute(interaction) {
+        var _a, _b;
         return __awaiter(this, void 0, void 0, function* () {
-            if (!message.content || !this.isReady())
-                return;
-            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))
+            if (!interaction || !interaction.isChatInputCommand() || !this.isReady())
                 return;
-            const command = this.findCommand(parseCommand.command, builders_1.CommandBuilderType.MessageCommand);
+            const command = this.findCommand(interaction.commandName, builders_1.CommandBuilderType.SlashCommand);
             if (!command)
                 return;
-            const commandOptions = yield (0, MessageCommandBuilder_1.validateMessageCommandOptions)(command, parseCommand);
             const executeData = {
-                message: message,
-                options: commandOptions,
-                command: parseCommand,
+                interaction,
                 builder: command,
                 client: this
             };
             if ((0, permissions_1.userHasCommandPermissions)({
                 builder: command,
-                memberPermissions: (_a = message.member) === null || _a === void 0 ? void 0 : _a.permissions,
-                commandPermissions: this.config.commands.messageCommand.permissions
+                memberPermissions: (_a = interaction.memberPermissions) !== null && _a !== void 0 ? _a : undefined,
+                commandPermissions: this.config.commands.slashCommand.permissions
             })) {
-                if (!command.allowExecuteInDM && message.channel.type === discord_js_1.ChannelType.DM
-                    || !command.allowExecuteByBots
-                        && (message.author.bot || message.author.system)
-                    || (0, permissions_1.isIgnoredChannel)(message.channelId, this.config.ignoredChannels))
+                if (!command)
                     return;
-                if (command.validateOptions) {
-                    if (commandOptions.some(o => o.invalid)) {
-                        if (!(yield this._haltCommand(command, { executeData, reason: commands_1.CommandHaltReason.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.CommandHaltReason.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 (interaction.guild && !(0, permissions_1.botHasExecutePermissions)(interaction.guild, command.requiredBotPermissions)) {
                     if (!(yield this._haltCommand(command, { executeData, reason: commands_1.CommandHaltReason.MissingBotPermissions }))) {
-                        message.reply(this.getMessage('insufficientBotPerms', 'Insufficient bot permissions.')).catch(er => this._replyError(er));
+                        yield interaction.reply(this.getConfigMessage('insufficientBotPerms', 'Insufficient bot permissions.')).catch(er => this._replyError(er));
                     }
                     return;
                 }
                 const userCooldown = {
-                    user: message.author,
+                    user: interaction.user,
                     command: command.name,
-                    channel: message.channel,
-                    guild: message.guild,
-                    type: builders_1.CommandBuilderType.MessageCommand
+                    channel: (_b = interaction.channel) !== null && _b !== void 0 ? _b : undefined,
+                    guild: interaction.guild,
+                    type: builders_1.CommandBuilderType.SlashCommand
                 };
-                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 }));
+                if (this.config.commands.slashCommand.enableCooldown && command.cooldown && !this.cooldowns.isCooledDown(userCooldown)) {
+                    this.cooldowns.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.CommandHaltReason.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));
+                else if (this.config.commands.slashCommand.enableCooldown && command.cooldown) {
+                    if (!(yield this._haltCommand(command, Object.assign({ executeData, reason: commands_1.CommandHaltReason.Cooldown }, this.cooldowns.get(userCooldown))))) {
+                        yield interaction.reply(this.getConfigMessage('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))
-                        .then(() => this.emit('recipleMessageCommandCreate', executeData))
+                        .then(() => this.emit('recipleCommandExecute', executeData))
                         .catch((err) => __awaiter(this, void 0, void 0, function* () { return (yield this._haltCommand(command, { executeData, reason: commands_1.CommandHaltReason.Error, error: err })) ? this._commandExecuteError(err, executeData) : void 0; }));
                     return executeData;
                 }
@@ -239,59 +215,80 @@ class RecipleClient extends discord_js_1.Client {
                 }
             }
             else if (!(yield this._haltCommand(command, { executeData, reason: commands_1.CommandHaltReason.MissingMemberPermissions }))) {
-                message.reply(this.getMessage('noPermissions', 'You do not have permission to use this command.')).catch(er => this._replyError(er));
+                yield interaction.reply(this.getConfigMessage('noPermissions', 'You do not have permission to use this command.')).catch(er => this._replyError(er));
             }
         });
     }
     /**
-     * Execute a slash command
-     * @param interaction Slash command interaction
+     * Execute a Message command
+     * @param message Message command executor
+     * @param prefix Message command prefix
      */
-    slashCommandExecute(interaction) {
-        var _a, _b;
+    messageCommandExecute(message, prefix) {
+        var _a;
         return __awaiter(this, void 0, void 0, function* () {
-            if (!interaction || !interaction.isChatInputCommand() || !this.isReady())
+            if (!message.content || !this.isReady())
                 return;
-            const command = this.findCommand(interaction.commandName, builders_1.CommandBuilderType.SlashCommand);
+            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.CommandBuilderType.MessageCommand);
             if (!command)
                 return;
+            const commandOptions = yield (0, MessageCommandBuilder_1.validateMessageCommandOptions)(command, parseCommand);
             const executeData = {
-                interaction,
+                message: message,
+                options: commandOptions,
+                command: parseCommand,
                 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.slashCommand.permissions
+                memberPermissions: (_a = message.member) === null || _a === void 0 ? void 0 : _a.permissions,
+                commandPermissions: this.config.commands.messageCommand.permissions
             })) {
-                if (!command || (0, permissions_1.isIgnoredChannel)(interaction.channelId, this.config.ignoredChannels))
+                if (!command.allowExecuteInDM && message.channel.type === discord_js_1.ChannelType.DM || !command.allowExecuteByBots && (message.author.bot || message.author.system))
                     return;
-                if (interaction.guild && !(0, permissions_1.botHasExecutePermissions)(interaction.guild, command.requiredBotPermissions)) {
+                if (command.validateOptions) {
+                    if (commandOptions.some(o => o.invalid)) {
+                        if (!(yield this._haltCommand(command, { executeData, reason: commands_1.CommandHaltReason.InvalidArguments, invalidArguments: new MessageCommandOptionManager_1.MessageCommandOptionManager(...executeData.options.filter(o => o.invalid)) }))) {
+                            message.reply(this.getConfigMessage('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.CommandHaltReason.MissingArguments, missingArguments: new MessageCommandOptionManager_1.MessageCommandOptionManager(...executeData.options.filter(o => o.missing)) }))) {
+                            message.reply(this.getConfigMessage('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.CommandHaltReason.MissingBotPermissions }))) {
-                        yield interaction.reply(this.getMessage('insufficientBotPerms', 'Insufficient bot permissions.')).catch(er => this._replyError(er));
+                        message.reply(this.getConfigMessage('insufficientBotPerms', 'Insufficient bot permissions.')).catch(er => this._replyError(er));
                     }
                     return;
                 }
                 const userCooldown = {
-                    user: interaction.user,
+                    user: message.author,
                     command: command.name,
-                    channel: (_b = interaction.channel) !== null && _b !== void 0 ? _b : undefined,
-                    guild: interaction.guild,
-                    type: builders_1.CommandBuilderType.SlashCommand
+                    channel: message.channel,
+                    guild: message.guild,
+                    type: builders_1.CommandBuilderType.MessageCommand
                 };
-                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 }));
+                if (this.config.commands.messageCommand.enableCooldown && command.cooldown && !this.cooldowns.isCooledDown(userCooldown)) {
+                    this.cooldowns.add(Object.assign(Object.assign({}, userCooldown), { expireTime: Date.now() + command.cooldown }));
                 }
-                else if (this.config.commands.slashCommand.enableCooldown && command.cooldown) {
-                    if (!(yield this._haltCommand(command, Object.assign({ executeData, reason: commands_1.CommandHaltReason.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));
+                else if (this.config.commands.messageCommand.enableCooldown && command.cooldown) {
+                    if (!(yield this._haltCommand(command, Object.assign({ executeData, reason: commands_1.CommandHaltReason.Cooldown }, this.cooldowns.get(userCooldown))))) {
+                        yield message.reply(this.getConfigMessage('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))
-                        .then(() => this.emit('recipleInteractionCommandCreate', executeData))
+                        .then(() => this.emit('recipleCommandExecute', executeData))
                         .catch((err) => __awaiter(this, void 0, void 0, function* () { return (yield this._haltCommand(command, { executeData, reason: commands_1.CommandHaltReason.Error, error: err })) ? this._commandExecuteError(err, executeData) : void 0; }));
                     return executeData;
                 }
@@ -302,7 +299,7 @@ class RecipleClient extends discord_js_1.Client {
                 }
             }
             else if (!(yield this._haltCommand(command, { executeData, reason: commands_1.CommandHaltReason.MissingMemberPermissions }))) {
-                yield interaction.reply(this.getMessage('noPermissions', 'You do not have permission to use this command.')).catch(er => this._replyError(er));
+                message.reply(this.getConfigMessage('noPermissions', 'You do not have permission to use this command.')).catch(er => this._replyError(er));
             }
         });
     }
@@ -311,7 +308,7 @@ class RecipleClient extends discord_js_1.Client {
      * @param messageKey Config messages key
      * @param defaultMessage Default message when the key does not exists
      */
-    getMessage(messageKey, defaultMessage) {
+    getConfigMessage(messageKey, defaultMessage) {
         var _a, _b;
         return (_b = (_a = this.config.messages[messageKey]) !== null && _a !== void 0 ? _a : defaultMessage) !== null && _b !== void 0 ? _b : messageKey;
     }
@@ -345,11 +342,13 @@ class RecipleClient extends discord_js_1.Client {
         var _a;
         return __awaiter(this, void 0, void 0, function* () {
             try {
-                return (_a = (command.halt
+                const haltResolved = (_a = (command.halt
                     ? yield (command.type == 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;
+                this.emit('recipleCommandHalt', haltData);
+                return haltResolved;
             }
             catch (err) {
                 if (this.isClientLogsEnabled()) {
@@ -373,15 +372,15 @@ class RecipleClient extends discord_js_1.Client {
             }
             if (!err || !command)
                 return;
-            if (MessageCommandBuilder_1.MessageCommandBuilder.isMessageCommandExecuteData(command)) {
-                if (!this.config.commands.messageCommand.replyOnError)
+            if (SlashCommandBuilder_1.SlashCommandBuilder.isSlashCommandExecuteData(command)) {
+                if (!this.config.commands.slashCommand.replyOnError)
                     return;
-                yield command.message.reply(this.getMessage('error', 'An error occurred.')).catch(er => this._replyError(er));
+                yield command.interaction.followUp(this.getConfigMessage('error', 'An error occurred.')).catch(er => this._replyError(er));
             }
-            else if (SlashCommandBuilder_1.SlashCommandBuilder.isSlashCommandExecuteData(command)) {
-                if (!this.config.commands.slashCommand.replyOnError)
+            else if (MessageCommandBuilder_1.MessageCommandBuilder.isMessageCommandExecuteData(command)) {
+                if (!this.config.commands.messageCommand.replyOnError)
                     return;
-                yield command.interaction.followUp(this.getMessage('error', 'An error occurred.')).catch(er => this._replyError(er));
+                yield command.message.reply(this.getConfigMessage('error', 'An error occurred.')).catch(er => this._replyError(er));
             }
         });
     }

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

@@ -12,36 +12,31 @@ export interface ConfigCommandPermissions {
 export interface Config {
     token: string;
     commands: {
-        messageCommand: {
+        slashCommand: {
             enabled: boolean;
-            prefix?: string;
             replyOnError: boolean;
-            allowCommandAlias: boolean;
+            registerCommands: boolean;
             enableCooldown: boolean;
-            commandArgumentSeparator: string;
+            setRequiredPermissions: boolean;
+            guilds?: string[] | string;
             permissions: {
                 enabled: boolean;
                 commands: ConfigCommandPermissions[];
             };
         };
-        slashCommand: {
+        messageCommand: {
             enabled: boolean;
+            prefix?: string;
             replyOnError: boolean;
-            registerCommands: boolean;
+            allowCommandAlias: boolean;
             enableCooldown: boolean;
-            setRequiredPermissions: boolean;
-            guilds?: string[] | string;
+            commandArgumentSeparator: string;
             permissions: {
                 enabled: boolean;
                 commands: ConfigCommandPermissions[];
             };
         };
     };
-    ignoredChannels: {
-        enabled: boolean;
-        convertToAllowList: boolean;
-        channels: string[];
-    };
     fileLogging: {
         enabled: boolean;
         debugmode: boolean;

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

@@ -1,9 +1,9 @@
-import { CommandBuilderType, AnyCommandExecuteData, AnyCommandExecuteFunction, AnyCommandHaltFunction } from '../../types/builders';
+import { CommandBuilderType, AnyCommandExecuteData, CommandHaltFunction, CommandExecuteFunction, SharedCommandBuilderProperties } from '../../types/builders';
 import { MessageCommandOptionManager } from '../MessageCommandOptionManager';
 import { MessageCommandOptionBuilder } from './MessageCommandOptionBuilder';
 import { Command as CommandMessage } from 'fallout-utility';
-import { Message, PermissionResolvable } from 'discord.js';
-import { AnyCommandHaltData } from '../../types/commands';
+import { Message, PermissionResolvable, RestOrArray } from 'discord.js';
+import { CommandHaltData } from '../../types/commands';
 import { RecipleClient } from '../RecipleClient';
 /**
  * Execute data for message command
@@ -28,26 +28,26 @@ export interface MessageCommandValidatedOption {
 /**
  * Message command halt data
  */
-export declare type MessageCommandHaltData = AnyCommandHaltData<CommandBuilderType.MessageCommand>;
+export declare type MessageCommandHaltData = CommandHaltData<CommandBuilderType.MessageCommand>;
 /**
  * Message command halt function
  */
-export declare type MessageCommandHaltFunction = AnyCommandHaltFunction<CommandBuilderType.MessageCommand>;
+export declare type MessageCommandHaltFunction = CommandHaltFunction<CommandBuilderType.MessageCommand>;
 /**
  * Message command execute function
  */
-export declare type MessageCommandExecuteFunction = AnyCommandExecuteFunction<CommandBuilderType.MessageCommand>;
+export declare type MessageCommandExecuteFunction = CommandExecuteFunction<CommandBuilderType.MessageCommand>;
 /**
  * Reciple builder for message command
  */
-export declare class MessageCommandBuilder {
+export declare class MessageCommandBuilder implements SharedCommandBuilderProperties {
     readonly type = CommandBuilderType.MessageCommand;
     name: string;
-    cooldown: number;
     description: string;
+    cooldown: number;
     aliases: string[];
-    options: MessageCommandOptionBuilder[];
     validateOptions: boolean;
+    options: MessageCommandOptionBuilder[];
     requiredBotPermissions: PermissionResolvable[];
     requiredMemberPermissions: PermissionResolvable[];
     allowExecuteInDM: boolean;
@@ -64,27 +64,11 @@ export declare class MessageCommandBuilder {
      * @param description Command description
      */
     setDescription(description: string): this;
-    /**
-     * Sets the execute cooldown for this command.
-     * - `0` means no cooldown
-     * @param cooldown Command cooldown in milliseconds
-     */
-    setCooldown(cooldown: number): this;
     /**
      * Add aliases to the command
      * @param aliases Command aliases
      */
-    addAliases(...aliases: string[]): this;
-    /**
-     * Set required bot permissions to execute the command
-     * @param permissions Bot's required permissions
-     */
-    setRequiredBotPermissions(...permissions: PermissionResolvable[]): this;
-    /**
-     * Set required permissions to execute the command
-     * @param permissions User's return permissions
-     */
-    setRequiredMemberPermissions(...permissions: PermissionResolvable[]): this;
+    addAliases(...aliases: RestOrArray<string>): this;
     /**
      * Set if command can be executed in dms
      * @param allowExecuteInDM `true` if the command can execute in DMs
@@ -95,16 +79,6 @@ export declare class MessageCommandBuilder {
      * @param allowExecuteByBots `true` if the command can be executed by bots
      */
     setAllowExecuteByBots(allowExecuteByBots: boolean): this;
-    /**
-     * Function when the command is interupted
-     * @param halt Function to execute when command is halted
-     */
-    setHalt(halt?: this["halt"]): this;
-    /**
-     * Function when the command is executed
-     * @param execute Function to execute when the command is called
-     */
-    setExecute(execute: this["execute"]): this;
     /**
      * Add option to the command
      * @param option Message option builder
@@ -115,10 +89,11 @@ export declare class MessageCommandBuilder {
      * @param validateOptions `true` if the command options needs to be validated before executing
      */
     setValidateOptions(validateOptions: boolean): this;
-    /**
-     * True if this is a message command builder
-     */
-    isMessageCommand(): this is MessageCommandBuilder;
+    setCooldown(cooldown: number): this;
+    setRequiredBotPermissions(...permissions: RestOrArray<PermissionResolvable>): this;
+    setRequiredMemberPermissions(...permissions: RestOrArray<PermissionResolvable>): this;
+    setHalt(halt?: this["halt"]): this;
+    setExecute(execute: this["execute"]): this;
     /**
      * Is a message command builder
      */

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

@@ -13,6 +13,7 @@ exports.validateMessageCommandOptions = exports.MessageCommandBuilder = void 0;
 const builders_1 = require("../../types/builders");
 const MessageCommandOptionManager_1 = require("../MessageCommandOptionManager");
 const MessageCommandOptionBuilder_1 = require("./MessageCommandOptionBuilder");
+const discord_js_1 = require("discord.js");
 /**
  * Reciple builder for message command
  */
@@ -20,11 +21,11 @@ class MessageCommandBuilder {
     constructor() {
         this.type = builders_1.CommandBuilderType.MessageCommand;
         this.name = '';
-        this.cooldown = 0;
         this.description = '';
+        this.cooldown = 0;
         this.aliases = [];
-        this.options = [];
         this.validateOptions = false;
+        this.options = [];
         this.requiredBotPermissions = [];
         this.requiredMemberPermissions = [];
         this.allowExecuteInDM = true;
@@ -51,20 +52,12 @@ class MessageCommandBuilder {
         this.description = description;
         return this;
     }
-    /**
-     * Sets the execute cooldown for this command.
-     * - `0` means no cooldown
-     * @param cooldown Command cooldown in milliseconds
-     */
-    setCooldown(cooldown) {
-        this.cooldown = cooldown;
-        return this;
-    }
     /**
      * Add aliases to the command
      * @param aliases Command aliases
      */
     addAliases(...aliases) {
+        aliases = (0, discord_js_1.normalizeArray)(aliases);
         if (!aliases.length)
             throw new TypeError('Provide atleast one alias');
         if (aliases.some(a => !a || typeof a !== 'string' || !a.match(/^[\w-]{1,32}$/)))
@@ -74,22 +67,6 @@ class MessageCommandBuilder {
         this.aliases = [...new Set(aliases)];
         return this;
     }
-    /**
-     * Set required bot permissions to execute the command
-     * @param permissions Bot's required permissions
-     */
-    setRequiredBotPermissions(...permissions) {
-        this.requiredBotPermissions = permissions;
-        return this;
-    }
-    /**
-     * Set required permissions to execute the command
-     * @param permissions User's return permissions
-     */
-    setRequiredMemberPermissions(...permissions) {
-        this.requiredMemberPermissions = permissions;
-        return this;
-    }
     /**
      * Set if command can be executed in dms
      * @param allowExecuteInDM `true` if the command can execute in DMs
@@ -110,24 +87,6 @@ class MessageCommandBuilder {
         this.allowExecuteByBots = allowExecuteByBots;
         return this;
     }
-    /**
-     * Function when the command is interupted
-     * @param halt Function to execute when command is halted
-     */
-    setHalt(halt) {
-        this.halt = halt ? halt : undefined;
-        return this;
-    }
-    /**
-     * Function when the command is executed
-     * @param execute Function to execute when the command is called
-     */
-    setExecute(execute) {
-        if (!execute || typeof execute !== 'function')
-            throw new TypeError('execute must be a function.');
-        this.execute = execute;
-        return this;
-    }
     /**
      * Add option to the command
      * @param option Message option builder
@@ -153,11 +112,27 @@ class MessageCommandBuilder {
         this.validateOptions = validateOptions;
         return this;
     }
-    /**
-     * True if this is a message command builder
-     */
-    isMessageCommand() {
-        return this instanceof MessageCommandBuilder;
+    setCooldown(cooldown) {
+        this.cooldown = cooldown;
+        return this;
+    }
+    setRequiredBotPermissions(...permissions) {
+        this.requiredBotPermissions = (0, discord_js_1.normalizeArray)(permissions);
+        return this;
+    }
+    setRequiredMemberPermissions(...permissions) {
+        this.requiredMemberPermissions = (0, discord_js_1.normalizeArray)(permissions);
+        return this;
+    }
+    setHalt(halt) {
+        this.halt = halt ? halt : undefined;
+        return this;
+    }
+    setExecute(execute) {
+        if (!execute || typeof execute !== 'function')
+            throw new TypeError('execute must be a function.');
+        this.execute = execute;
+        return this;
     }
     /**
      * Is a message command builder

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

@@ -1,7 +1,7 @@
-import { CommandBuilderType, AnyCommandExecuteData, AnyCommandExecuteFunction, AnyCommandHaltFunction } from '../../types/builders';
-import { AnyCommandHaltData } from '../../types/commands';
+import { CommandBuilderType, AnyCommandExecuteData, CommandHaltFunction, CommandExecuteFunction, SharedCommandBuilderProperties } from '../../types/builders';
+import { CommandHaltData } from '../../types/commands';
 import { RecipleClient } from '../RecipleClient';
-import { ChatInputCommandInteraction, PermissionResolvable, SlashCommandBuilder as DiscordJsSlashCommandBuilder, SlashCommandSubcommandBuilder, SlashCommandSubcommandGroupBuilder, SlashCommandSubcommandsOnlyBuilder as DiscordJsSlashCommandSubcommandsOnlyBuilder } from 'discord.js';
+import { ChatInputCommandInteraction, PermissionResolvable, RestOrArray, SlashCommandBuilder as DiscordJsSlashCommandBuilder, SlashCommandSubcommandBuilder, SlashCommandSubcommandGroupBuilder, SlashCommandSubcommandsOnlyBuilder as DiscordJsSlashCommandSubcommandsOnlyBuilder } from 'discord.js';
 /**
  * Execute data for interaction command
  */
@@ -10,28 +10,28 @@ export interface SlashCommandExecuteData {
     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;
-}
 /**
  * Slash command halt data
  */
-export declare type SlashCommandHaltData = AnyCommandHaltData<CommandBuilderType.SlashCommand>;
+export declare type SlashCommandHaltData = CommandHaltData<CommandBuilderType.SlashCommand>;
 /**
  * Slash command halt function
  */
-export declare type SlashCommandHaltFunction = AnyCommandHaltFunction<CommandBuilderType.SlashCommand>;
+export declare type SlashCommandHaltFunction = CommandHaltFunction<CommandBuilderType.SlashCommand>;
 /**
  * Slash command execute function
  */
-export declare type SlashCommandExecuteFunction = AnyCommandExecuteFunction<CommandBuilderType.SlashCommand>;
+export declare type SlashCommandExecuteFunction = CommandExecuteFunction<CommandBuilderType.SlashCommand>;
+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 {
+export declare class SlashCommandBuilder extends DiscordJsSlashCommandBuilder implements SharedCommandBuilderProperties {
     readonly type = CommandBuilderType.SlashCommand;
     cooldown: number;
     requiredBotPermissions: PermissionResolvable[];
@@ -39,36 +39,11 @@ export declare class SlashCommandBuilder extends DiscordJsSlashCommandBuilder {
     allowExecuteInDM: boolean;
     halt?: SlashCommandHaltFunction;
     execute: SlashCommandExecuteFunction;
-    /**
-     * Sets the execute cooldown for this command.
-     * - `0` means no cooldown
-     * @param cooldown Command cooldown in milliseconds
-     */
     setCooldown(cooldown: number): this;
-    /**
-     * Set required bot permissions to execute the command
-     * @param permissions Bot's required permissions
-     */
-    setRequiredBotPermissions(...permissions: PermissionResolvable[]): this;
-    /**
-     * Set required permissions to execute the command
-     * @param permissions User's return permissions
-     */
-    setRequiredMemberPermissions(...permissions: PermissionResolvable[]): this;
-    /**
-     * Function when the command is interupted
-     * @param halt Function to execute when command is halted
-     */
+    setRequiredBotPermissions(...permissions: RestOrArray<PermissionResolvable>): this;
+    setRequiredMemberPermissions(...permissions: RestOrArray<PermissionResolvable>): this;
     setHalt(halt?: this["halt"]): this;
-    /**
-     * Function when the command is executed
-     * @param execute Function to execute when the command is called
-     */
     setExecute(execute: this["execute"]): this;
-    /**
-     * True if this is a slash command builder
-     */
-    isSlashCommand(): this is SlashCommandBuilder;
     /**
      * Is a slash command builder
      */

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

@@ -16,55 +16,28 @@ class SlashCommandBuilder extends discord_js_1.SlashCommandBuilder {
         this.allowExecuteInDM = true;
         this.execute = () => { };
     }
-    /**
-     * Sets the execute cooldown for this command.
-     * - `0` means no cooldown
-     * @param cooldown Command cooldown in milliseconds
-     */
     setCooldown(cooldown) {
         this.cooldown = cooldown;
         return this;
     }
-    /**
-     * Set required bot permissions to execute the command
-     * @param permissions Bot's required permissions
-     */
     setRequiredBotPermissions(...permissions) {
-        this.requiredBotPermissions = permissions;
+        this.requiredBotPermissions = (0, discord_js_1.normalizeArray)(permissions);
         return this;
     }
-    /**
-     * Set required permissions to execute the command
-     * @param permissions User's return permissions
-     */
     setRequiredMemberPermissions(...permissions) {
-        this.requiredMemberPermissions = permissions;
+        this.requiredMemberPermissions = (0, discord_js_1.normalizeArray)(permissions);
         return this;
     }
-    /**
-     * Function when the command is interupted
-     * @param halt Function to execute when command is halted
-     */
     setHalt(halt) {
         this.halt = halt ? halt : undefined;
         return this;
     }
-    /**
-     * Function when the command is executed
-     * @param execute Function to execute when the command is called
-     */
     setExecute(execute) {
         if (!execute || typeof execute !== 'function')
             throw new Error('execute must be a function.');
         this.execute = execute;
         return this;
     }
-    /**
-     * True if this is a slash command builder
-     */
-    isSlashCommand() {
-        return this instanceof SlashCommandBuilder;
-    }
     /**
      * Is a slash command builder
      */

package/bin/reciple/flags.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.token = exports.flags = void 0;
+const version_1 = require("./version");
 const commander_1 = require("commander");
 /**
  * Used flags
@@ -8,7 +9,7 @@ const commander_1 = require("commander");
 exports.flags = new commander_1.Command()
     .name('reciple')
     .description('Reciple.js - Discord.js handler cli')
-    .version(`v${require('../../package.json').version}`, '-v, --version')
+    .version(`v${version_1.rawVersion}`, '-v, --version')
     .option('-t, --token <token>', 'Replace used bot token')
     .option('-c, --config <config>', 'Change path to config file')
     .option('-D, --debugmode', 'Enabled debug mode')

package/bin/reciple/modules.js

@@ -18,6 +18,7 @@ const version_1 = require("./version");
 const fs_1 = require("fs");
 const wildcard_match_1 = __importDefault(require("wildcard-match"));
 const path_1 = __importDefault(require("path"));
+const discord_js_1 = require("discord.js");
 /**
  * Load modules from folder
  * @param client Reciple client
@@ -40,14 +41,14 @@ function loadModules(client, folder) {
             let module_;
             try {
                 const reqMod = require(modulePath);
-                module_ = typeof (reqMod === null || reqMod === void 0 ? void 0 : reqMod.default) != 'undefined' ? reqMod.default : reqMod;
+                module_ = (reqMod === null || reqMod === void 0 ? void 0 : reqMod.default) === undefined ? reqMod.default : reqMod;
+                const versions = (0, discord_js_1.normalizeArray)([module_.versions]);
                 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];
+                    throw new Error(`${modulePath} does not have supported versions.`);
                 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.');
+                    throw new Error((_b = `${modulePath} is unsupported; current version: ${version_1.version}; module supported versions: ` + versions.join(', ')) !== null && _b !== void 0 ? _b : 'none');
+                if (!(yield Promise.resolve(module_.onStart(client)).catch(() => null)))
+                    throw new Error(script + ' onStart returned false or undefined.');
                 if (module_.commands) {
                     for (const command of module_.commands) {
                         if (command.type === builders_1.CommandBuilderType.MessageCommand || command.type === builders_1.CommandBuilderType.SlashCommand) {
@@ -66,12 +67,12 @@ function loadModules(client, folder) {
             response.commands.push(...commands.filter((c) => {
                 if (!c.name) {
                     if (client.isClientLogsEnabled())
-                        client.logger.error(`A ${builders_1.CommandBuilderType[c.type]} command name is not defined in ${script}`);
+                        client.logger.error(`A ${builders_1.CommandBuilderType[c.type]} command name is not defined in ${modulePath}`);
                     return false;
                 }
                 if (c.type === builders_1.CommandBuilderType.MessageCommand && c.options.length && c.options.some(o => !o.name)) {
                     if (client.isClientLogsEnabled())
-                        client.logger.error(`A ${builders_1.CommandBuilderType[c.type]} option name is not defined in ${script}`);
+                        client.logger.error(`A ${builders_1.CommandBuilderType[c.type]} option name is not defined in ${modulePath}`);
                     return false;
                 }
                 return true;
@@ -80,12 +81,12 @@ function loadModules(client, folder) {
                 script: module_,
                 info: {
                     filename: script,
-                    versions: typeof module_.versions === 'string' ? [module_.versions] : module_.versions,
+                    versions: (0, discord_js_1.normalizeArray)(module_.versions),
                     path: modulePath
                 }
             });
             if (client.isClientLogsEnabled())
-                client.logger.info(`Loaded module ${script}`);
+                client.logger.info(`Loaded module ${modulePath}`);
         }
         return response;
     });

package/bin/reciple/permissions.d.ts

@@ -1,6 +1,5 @@
 import { UserHasCommandPermissionsOptions } from './types/paramOptions';
 import { Guild, PermissionResolvable } from 'discord.js';
-import { Config } from './classes/RecipleConfig';
 /**
  * Check if the user has permissions to execute the given command name
  * @param options options
@@ -12,9 +11,3 @@ export declare function userHasCommandPermissions(options: UserHasCommandPermiss
  * @param requiredPermissions Required guild bot permissions
  */
 export declare function botHasExecutePermissions(guild?: Guild, requiredPermissions?: PermissionResolvable[]): boolean;
-/**
- * Check if the channel id is ignored in config file
- * @param channelId Check if channel id is in ignore list
- * @param ignoredChannelsConfig Ignored channels config
- */
-export declare function isIgnoredChannel(channelId: string, ignoredChannelsConfig?: Config["ignoredChannels"]): boolean;

package/bin/reciple/permissions.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isIgnoredChannel = exports.botHasExecutePermissions = exports.userHasCommandPermissions = void 0;
+exports.botHasExecutePermissions = exports.userHasCommandPermissions = void 0;
 /**
  * Check if the user has permissions to execute the given command name
  * @param options options
@@ -26,18 +26,3 @@ function botHasExecutePermissions(guild, requiredPermissions) {
     return (guild === null || guild === void 0 ? void 0 : guild.members.me) ? guild.members.me.permissions.has(requiredPermissions) : false;
 }
 exports.botHasExecutePermissions = botHasExecutePermissions;
-/**
- * Check if the channel id is ignored in config file
- * @param channelId Check if channel id is in ignore list
- * @param ignoredChannelsConfig Ignored channels config
- */
-function isIgnoredChannel(channelId, ignoredChannelsConfig) {
-    if (!(ignoredChannelsConfig === null || ignoredChannelsConfig === void 0 ? void 0 : ignoredChannelsConfig.enabled))
-        return false;
-    if (ignoredChannelsConfig.channels.includes(channelId) && !ignoredChannelsConfig.convertToAllowList)
-        return true;
-    if (!ignoredChannelsConfig.channels.includes(channelId) && ignoredChannelsConfig.convertToAllowList)
-        return true;
-    return false;
-}
-exports.isIgnoredChannel = isIgnoredChannel;

package/bin/reciple/registerApplicationCommands.js

@@ -25,7 +25,7 @@ function registerApplicationCommands(options) {
             if (typeof (cmd === null || cmd === void 0 ? void 0 : cmd.toJSON) == 'undefined')
                 return cmd;
             cmd = cmd;
-            if (cmd instanceof SlashCommandBuilder_1.SlashCommandBuilder && client.config.commands.slashCommand.setRequiredPermissions) {
+            if (SlashCommandBuilder_1.SlashCommandBuilder.isSlashCommandBuilder(cmd) && 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;
@@ -35,7 +35,6 @@ function registerApplicationCommands(options) {
                         client.logger.debug(`Set required permissions for ${cmd.name}`);
                 }
                 client.commands.slashCommands[cmd.name] = cmd;
-                return cmd.toJSON();
             }
             return cmd.toJSON();
         })) !== null && _b !== void 0 ? _b : [];

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

@@ -1,22 +1,30 @@
-import { MessageCommandBuilder, MessageCommandExecuteData, MessageCommandHaltData } from '../classes/builders/MessageCommandBuilder';
-import { SlashCommandBuilder, SlashCommandExecuteData, SlashCommandHaltData } from '../classes/builders/SlashCommandBuilder';
-import { Awaitable } from 'discord.js';
+import { MessageCommandBuilder, MessageCommandExecuteData, MessageCommandExecuteFunction, MessageCommandHaltData, MessageCommandHaltFunction } from '../classes/builders/MessageCommandBuilder';
+import { SlashCommandBuilder, SlashCommandExecuteData, SlashCommandExecuteFunction, SlashCommandHaltData, SlashCommandHaltFunction } from '../classes/builders/SlashCommandBuilder';
+import { Awaitable, PermissionResolvable, RestOrArray } from 'discord.js';
 /**
- * Reciple command builders
+ * Any Reciple command builders
  */
-export declare type AnyCommandBuilder = MessageCommandBuilder | SlashCommandBuilder;
+export declare type AnyCommandBuilder = SlashCommandBuilder | MessageCommandBuilder;
 /**
- * Reciple command execute data
+ * Any Reciple command execute data
  */
 export declare type AnyCommandExecuteData = SlashCommandExecuteData | MessageCommandExecuteData;
+/**
+ * Any Reciple command halt functions
+ */
+export declare type AnyCommandHaltFunction = SlashCommandHaltFunction | MessageCommandHaltFunction;
+/**
+ * Any reciple command execute function
+ */
+export declare type AnyCommandExecuteFunction = SlashCommandExecuteFunction | MessageCommandExecuteFunction;
 /**
  * Reciple command halt function
  */
-export declare type AnyCommandHaltFunction<T extends CommandBuilderType> = (haltData: T extends CommandBuilderType.SlashCommand ? SlashCommandHaltData : MessageCommandHaltData) => Awaitable<boolean | null | undefined | void>;
+export declare type CommandHaltFunction<T extends CommandBuilderType> = (haltData: T extends CommandBuilderType.SlashCommand ? SlashCommandHaltData : MessageCommandHaltData) => Awaitable<boolean | null | undefined | void>;
 /**
  * Reciple command execute function
  */
-export declare type AnyCommandExecuteFunction<T extends CommandBuilderType> = (executeData: T extends CommandBuilderType.SlashCommand ? SlashCommandExecuteData : MessageCommandExecuteData) => Awaitable<void>;
+export declare type CommandExecuteFunction<T extends CommandBuilderType> = (executeData: T extends CommandBuilderType.SlashCommand ? SlashCommandExecuteData : MessageCommandExecuteData) => Awaitable<void>;
 /**
  * Types of Reciple command builders
  */
@@ -24,3 +32,41 @@ export declare enum CommandBuilderType {
     MessageCommand = 0,
     SlashCommand = 1
 }
+/**
+ * Shared command builder methods
+ */
+export interface SharedCommandBuilderProperties {
+    readonly type: CommandBuilderType;
+    cooldown: number;
+    requiredBotPermissions: PermissionResolvable[];
+    requiredMemberPermissions: PermissionResolvable[];
+    allowExecuteInDM: boolean;
+    halt?: AnyCommandHaltFunction;
+    execute: AnyCommandExecuteFunction;
+    /**
+     * Sets the execute cooldown for this command.
+     * - `0` means no cooldown
+     * @param cooldown Command cooldown in milliseconds
+     */
+    setCooldown(cooldown: number): this;
+    /**
+     * Set required bot permissions to execute the command
+     * @param permissions Bot's required permissions
+     */
+    setRequiredBotPermissions(...permissions: RestOrArray<PermissionResolvable>): this;
+    /**
+     * Set required permissions to execute the command
+     * @param permissions User's return permissions
+     */
+    setRequiredMemberPermissions(...permissions: RestOrArray<PermissionResolvable>): this;
+    /**
+     * Function when the command is interupted
+     * @param halt Function to execute when command is halted
+     */
+    setHalt(halt?: this["halt"]): this;
+    /**
+     * Function when the command is executed
+     * @param execute Function to execute when the command is called
+     */
+    setExecute(execute: this["execute"]): this;
+}

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

@@ -1,12 +1,16 @@
-import { MessageCommandExecuteData } from '../classes/builders/MessageCommandBuilder';
+import { MessageCommandExecuteData, MessageCommandHaltData } from '../classes/builders/MessageCommandBuilder';
+import { SlashCommandExecuteData, SlashCommandHaltData } from '../classes/builders/SlashCommandBuilder';
 import { MessageCommandOptionManager } from '../classes/MessageCommandOptionManager';
-import { SlashCommandExecuteData } from '../classes/builders/SlashCommandBuilder';
 import { CommandBuilderType, AnyCommandExecuteData } from '../types/builders';
 import { CooledDownUser } from '../classes/CommandCooldownManager';
 /**
- * Any Halted command's data
+ * Any reciple halted command data
  */
-export declare type AnyCommandHaltData<T extends CommandBuilderType = CommandBuilderType> = CommandErrorData<T> | CommandCooldownData<T> | (T extends CommandBuilderType.SlashCommand ? never : CommandInvalidArguments<T> | CommandMissingArguments<T>) | CommandMissingMemberPermissions<T> | CommandMissingBotPermissions<T>;
+export declare type AnyCommandHaltData = SlashCommandHaltData | MessageCommandHaltData;
+/**
+ * Halted command data
+ */
+export declare type CommandHaltData<T extends CommandBuilderType> = CommandErrorData<T> | CommandCooldownData<T> | (T extends CommandBuilderType.SlashCommand ? never : CommandInvalidArguments<T> | CommandMissingArguments<T>) | CommandMissingMemberPermissions<T> | CommandMissingBotPermissions<T>;
 /**
  * Command halt reason base interface
  */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "reciple",
-  "version": "5.0.0-pre.1",
+  "version": "5.0.0-pre.4",
   "bin": "bin/bin.js",
   "license": "GPL-3.0",
   "main": "bin/index.js",

package/resource/reciple.yml

@@ -49,16 +49,6 @@ commands:
           permissions: ['Administrator']
 
 
-# Ignored channel IDs
-ignoredChannels:
-  # enable ignored channels
-  enabled: false
-  # convert to only allowed channels
-  convertToAllowList: false
-  # channel IDs
-  channels: []
-
-
 # Logger options
 fileLogging:
   # enable console output to file