reciple 4.1.0 → 5.0.0-pre.2

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

@@ -1,7 +1,7 @@
 import { MessageCommandBuilder, MessageCommandExecuteData } from './builders/MessageCommandBuilder';
-import { ApplicationCommandBuilder } from '../registerApplicationCommands';
-import { CommandBuilder, CommandBuilderType } from '../types/builders';
 import { SlashCommandBuilder, SlashCommandExecuteData } from './builders/SlashCommandBuilder';
+import { ApplicationCommandBuilder } from '../registerApplicationCommands';
+import { AnyCommandBuilder, CommandBuilderType } from '../types/builders';
 import { CommandCooldownManager } from './CommandCooldownManager';
 import { RecipleClientAddModuleOptions } from '../types/paramOptions';
 import { Logger as ILogger } from 'fallout-utility';
@@ -79,7 +79,7 @@ export declare class RecipleClient<Ready extends boolean = boolean> extends Clie
      * Add slash or message command to client
      * @param command Slash/Message command builder
      */
-    addCommand(command: CommandBuilder): RecipleClient<Ready>;
+    addCommand(command: AnyCommandBuilder): RecipleClient<Ready>;
     /**
      * Listed to command executions
      */

package/bin/reciple/classes/RecipleClient.js

@@ -11,8 +11,9 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.RecipleClient = void 0;
 const MessageCommandBuilder_1 = require("./builders/MessageCommandBuilder");
-const permissions_1 = require("../permissions");
+const SlashCommandBuilder_1 = require("./builders/SlashCommandBuilder");
 const registerApplicationCommands_1 = require("../registerApplicationCommands");
+const permissions_1 = require("../permissions");
 const builders_1 = require("../types/builders");
 const CommandCooldownManager_1 = require("./CommandCooldownManager");
 const MessageCommandOptionManager_1 = require("./MessageCommandOptionManager");
@@ -134,10 +135,10 @@ class RecipleClient extends discord_js_1.Client {
      */
     addCommand(command) {
         var _a;
-        if (command.builder === builders_1.CommandBuilderType.MessageCommand) {
+        if (command.type === builders_1.CommandBuilderType.MessageCommand) {
             this.commands.messageCommands[command.name] = command;
         }
-        else if (command.builder === builders_1.CommandBuilderType.SlashCommand) {
+        else if (command.type === builders_1.CommandBuilderType.SlashCommand) {
             this.commands.slashCommands[command.name] = command;
         }
         else if (this.isClientLogsEnabled()) {
@@ -191,20 +192,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.HaltedCommandReason.InvalidArguments, invalidArguments: new MessageCommandOptionManager_1.MessageCommandOptionManager(...executeData.options.filter(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.HaltedCommandReason.MissingArguments, missingArguments: new MessageCommandOptionManager_1.MessageCommandOptionManager(...executeData.options.filter(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 (!(yield this._haltCommand(command, { executeData, reason: commands_1.HaltedCommandReason.MissingBotPermissions }))) {
+                    if (!(yield this._haltCommand(command, { executeData, reason: commands_1.CommandHaltReason.MissingBotPermissions }))) {
                         message.reply(this.getMessage('insufficientBotPerms', 'Insufficient bot permissions.')).catch(er => this._replyError(er));
                     }
                     return;
@@ -220,7 +221,7 @@ class RecipleClient extends discord_js_1.Client {
                     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.HaltedCommandReason.Cooldown }, this.commandCooldowns.get(userCooldown))))) {
+                    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));
                     }
                     return;
@@ -228,16 +229,16 @@ 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.HaltedCommandReason.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.CommandHaltReason.Error, error: err })) ? this._commandExecuteError(err, executeData) : void 0; }));
                     return executeData;
                 }
                 catch (err) {
-                    if (!(yield this._haltCommand(command, { executeData, reason: commands_1.HaltedCommandReason.Error, error: err }))) {
+                    if (!(yield this._haltCommand(command, { executeData, reason: commands_1.CommandHaltReason.Error, error: err }))) {
                         this._commandExecuteError(err, executeData);
                     }
                 }
             }
-            else if (!(yield this._haltCommand(command, { executeData, reason: commands_1.HaltedCommandReason.MissingMemberPermissions }))) {
+            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));
             }
         });
@@ -249,7 +250,7 @@ class RecipleClient extends discord_js_1.Client {
     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())
+            if (!interaction || !interaction.isChatInputCommand() || !this.isReady())
                 return;
             const command = this.findCommand(interaction.commandName, builders_1.CommandBuilderType.SlashCommand);
             if (!command)
@@ -267,7 +268,7 @@ class RecipleClient extends discord_js_1.Client {
                 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.HaltedCommandReason.MissingBotPermissions }))) {
+                    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));
                     }
                     return;
@@ -283,7 +284,7 @@ class RecipleClient extends discord_js_1.Client {
                     this.commandCooldowns.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.HaltedCommandReason.Cooldown }, this.commandCooldowns.get(userCooldown))))) {
+                    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));
                     }
                     return;
@@ -291,16 +292,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.HaltedCommandReason.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.CommandHaltReason.Error, error: err })) ? this._commandExecuteError(err, executeData) : void 0; }));
                     return executeData;
                 }
                 catch (err) {
-                    if (!(yield this._haltCommand(command, { executeData, reason: commands_1.HaltedCommandReason.Error, error: err }))) {
+                    if (!(yield this._haltCommand(command, { executeData, reason: commands_1.CommandHaltReason.Error, error: err }))) {
                         this._commandExecuteError(err, executeData);
                     }
                 }
             }
-            else if (!(yield this._haltCommand(command, { executeData, reason: commands_1.HaltedCommandReason.MissingMemberPermissions }))) {
+            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));
             }
         });
@@ -345,7 +346,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.CommandBuilderType.SlashCommand
+                    ? 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;
@@ -367,17 +368,17 @@ class RecipleClient extends discord_js_1.Client {
     _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.CommandBuilderType.MessageCommand ? 'message' : 'slash'} command "${command.builder.name}"`);
+                this.logger.error(`An error occured executing ${command.builder.type == builders_1.CommandBuilderType.MessageCommand ? 'message' : 'slash'} command "${command.builder.name}"`);
                 this.logger.error(err);
             }
             if (!err || !command)
                 return;
-            if (command === null || command === void 0 ? void 0 : command.message) {
+            if (MessageCommandBuilder_1.MessageCommandBuilder.isMessageCommandExecuteData(command)) {
                 if (!this.config.commands.messageCommand.replyOnError)
                     return;
                 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) {
+            else if (SlashCommandBuilder_1.SlashCommandBuilder.isSlashCommandExecuteData(command)) {
                 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/builders/MessageCommandBuilder.d.ts

@@ -1,8 +1,9 @@
-import { CommandBuilderType, CommandExecuteFunction, CommandHaltFunction } from '../../types/builders';
+import { CommandBuilderType, AnyCommandExecuteData, CommandHaltFunction, CommandExecuteFunction } 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 { CommandHaltData } from '../../types/commands';
 import { RecipleClient } from '../RecipleClient';
 /**
  * Execute data for message command
@@ -24,11 +25,23 @@ export interface MessageCommandValidatedOption {
     invalid: boolean;
     missing: boolean;
 }
+/**
+ * Message command halt data
+ */
+export declare type MessageCommandHaltData = CommandHaltData<CommandBuilderType.MessageCommand>;
+/**
+ * Message command halt function
+ */
+export declare type MessageCommandHaltFunction = CommandHaltFunction<CommandBuilderType.MessageCommand>;
+/**
+ * Message command execute function
+ */
+export declare type MessageCommandExecuteFunction = CommandExecuteFunction<CommandBuilderType.MessageCommand>;
 /**
  * Reciple builder for message command
  */
 export declare class MessageCommandBuilder {
-    readonly builder = CommandBuilderType.MessageCommand;
+    readonly type = CommandBuilderType.MessageCommand;
     name: string;
     cooldown: number;
     description: string;
@@ -39,8 +52,8 @@ export declare class MessageCommandBuilder {
     requiredMemberPermissions: PermissionResolvable[];
     allowExecuteInDM: boolean;
     allowExecuteByBots: boolean;
-    halt?: CommandHaltFunction<this>;
-    execute: CommandExecuteFunction<this>;
+    halt?: MessageCommandHaltFunction;
+    execute: MessageCommandExecuteFunction;
     /**
      * Sets the command name
      * @param name Command name
@@ -86,12 +99,12 @@ export declare class MessageCommandBuilder {
      * Function when the command is interupted
      * @param halt Function to execute when command is halted
      */
-    setHalt(halt?: CommandHaltFunction<this>): this;
+    setHalt(halt?: this["halt"]): this;
     /**
      * Function when the command is executed
      * @param execute Function to execute when the command is called
      */
-    setExecute(execute: CommandExecuteFunction<this>): this;
+    setExecute(execute: this["execute"]): this;
     /**
      * Add option to the command
      * @param option Message option builder
@@ -102,5 +115,13 @@ export declare class MessageCommandBuilder {
      * @param validateOptions `true` if the command options needs to be validated before executing
      */
     setValidateOptions(validateOptions: boolean): this;
+    /**
+     * Is a message command builder
+     */
+    static isMessageCommandBuilder(builder: any): builder is MessageCommandBuilder;
+    /**
+     * Is a message command execute data
+     */
+    static isMessageCommandExecuteData(executeData: AnyCommandExecuteData): executeData is MessageCommandExecuteData;
 }
 export declare function validateMessageCommandOptions(builder: MessageCommandBuilder, options: CommandMessage): Promise<MessageCommandOptionManager>;

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

@@ -18,7 +18,7 @@ const MessageCommandOptionBuilder_1 = require("./MessageCommandOptionBuilder");
  */
 class MessageCommandBuilder {
     constructor() {
-        this.builder = builders_1.CommandBuilderType.MessageCommand;
+        this.type = builders_1.CommandBuilderType.MessageCommand;
         this.name = '';
         this.cooldown = 0;
         this.description = '';
@@ -153,6 +153,18 @@ class MessageCommandBuilder {
         this.validateOptions = validateOptions;
         return this;
     }
+    /**
+     * Is a message command builder
+     */
+    static isMessageCommandBuilder(builder) {
+        return builder instanceof MessageCommandBuilder;
+    }
+    /**
+     * Is a message command execute data
+     */
+    static isMessageCommandExecuteData(executeData) {
+        return executeData.builder !== undefined && this.isMessageCommandBuilder(executeData.builder);
+    }
 }
 exports.MessageCommandBuilder = MessageCommandBuilder;
 function validateMessageCommandOptions(builder, options) {

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

@@ -1,4 +1,5 @@
-import { CommandBuilderType, CommandExecuteFunction, CommandHaltFunction } from '../../types/builders';
+import { CommandBuilderType, AnyCommandExecuteData, CommandHaltFunction, CommandExecuteFunction } 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';
 /**
@@ -15,17 +16,29 @@ 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 = CommandHaltData<CommandBuilderType.SlashCommand>;
+/**
+ * Slash command halt function
+ */
+export declare type SlashCommandHaltFunction = CommandHaltFunction<CommandBuilderType.SlashCommand>;
+/**
+ * Slash command execute function
+ */
+export declare type SlashCommandExecuteFunction = CommandExecuteFunction<CommandBuilderType.SlashCommand>;
 /**
  * Reciple builder for interaction/slash command
  */
 export declare class SlashCommandBuilder extends DiscordJsSlashCommandBuilder {
-    readonly builder = CommandBuilderType.SlashCommand;
+    readonly type = CommandBuilderType.SlashCommand;
     cooldown: number;
     requiredBotPermissions: PermissionResolvable[];
     requiredMemberPermissions: PermissionResolvable[];
     allowExecuteInDM: boolean;
-    halt?: CommandHaltFunction<this>;
-    execute: CommandExecuteFunction<this>;
+    halt?: SlashCommandHaltFunction;
+    execute: SlashCommandExecuteFunction;
     /**
      * Sets the execute cooldown for this command.
      * - `0` means no cooldown
@@ -46,10 +59,18 @@ export declare class SlashCommandBuilder extends DiscordJsSlashCommandBuilder {
      * Function when the command is interupted
      * @param halt Function to execute when command is halted
      */
-    setHalt(halt?: CommandHaltFunction<this>): this;
+    setHalt(halt?: this["halt"]): this;
     /**
      * Function when the command is executed
      * @param execute Function to execute when the command is called
      */
-    setExecute(execute: CommandExecuteFunction<this>): this;
+    setExecute(execute: this["execute"]): this;
+    /**
+     * Is a slash command builder
+     */
+    static isSlashCommandBuilder(builder: any): builder is SlashCommandBuilder;
+    /**
+     * Is a slash command execute data
+     */
+    static isSlashCommandExecuteData(executeData: AnyCommandExecuteData): executeData is SlashCommandExecuteData;
 }

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

@@ -9,7 +9,7 @@ const discord_js_1 = require("discord.js");
 class SlashCommandBuilder extends discord_js_1.SlashCommandBuilder {
     constructor() {
         super(...arguments);
-        this.builder = builders_1.CommandBuilderType.SlashCommand;
+        this.type = builders_1.CommandBuilderType.SlashCommand;
         this.cooldown = 0;
         this.requiredBotPermissions = [];
         this.requiredMemberPermissions = [];
@@ -59,5 +59,17 @@ class SlashCommandBuilder extends discord_js_1.SlashCommandBuilder {
         this.execute = execute;
         return this;
     }
+    /**
+     * Is a slash command builder
+     */
+    static isSlashCommandBuilder(builder) {
+        return builder instanceof SlashCommandBuilder;
+    }
+    /**
+     * Is a slash command execute data
+     */
+    static isSlashCommandExecuteData(executeData) {
+        return executeData.builder !== undefined && this.isSlashCommandBuilder(executeData.builder);
+    }
 }
 exports.SlashCommandBuilder = SlashCommandBuilder;

package/bin/reciple/modules.d.ts

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

package/bin/reciple/modules.js

@@ -50,7 +50,7 @@ function loadModules(client, folder) {
                     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.CommandBuilderType.MessageCommand || command.builder === builders_1.CommandBuilderType.SlashCommand) {
+                        if (command.type === builders_1.CommandBuilderType.MessageCommand || command.type === builders_1.CommandBuilderType.SlashCommand) {
                             commands.push(command);
                         }
                     }
@@ -66,12 +66,12 @@ function loadModules(client, folder) {
             response.commands.push(...commands.filter((c) => {
                 if (!c.name) {
                     if (client.isClientLogsEnabled())
-                        client.logger.error(`A ${c.builder} command name is not defined in ${script}`);
+                        client.logger.error(`A ${builders_1.CommandBuilderType[c.type]} command name is not defined in ${script}`);
                     return false;
                 }
-                if (c.builder === builders_1.CommandBuilderType.MessageCommand && c.options.length && c.options.some(o => !o.name)) {
+                if (c.type === 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}`);
+                        client.logger.error(`A ${builders_1.CommandBuilderType[c.type]} option name is not defined in ${script}`);
                     return false;
                 }
                 return true;

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

@@ -1,23 +1,26 @@
+import { MessageCommandBuilder, MessageCommandExecuteData, MessageCommandHaltData, MessageCommandHaltFunction } from '../classes/builders/MessageCommandBuilder';
+import { SlashCommandBuilder, SlashCommandExecuteData, SlashCommandHaltData, SlashCommandHaltFunction } from '../classes/builders/SlashCommandBuilder';
 import { Awaitable } from 'discord.js';
-import { MessageCommandBuilder, MessageCommandExecuteData } from '../classes/builders/MessageCommandBuilder';
-import { SlashCommandBuilder, SlashCommandExecuteData } from '../classes/builders/SlashCommandBuilder';
-import { HaltedCommandData } from './commands';
 /**
- * Reciple command builders
+ * Any Reciple command builders
  */
-export declare type CommandBuilder = MessageCommandBuilder | SlashCommandBuilder;
+export declare type AnyCommandBuilder = SlashCommandBuilder | MessageCommandBuilder;
 /**
- * Reciple command builders execute data
+ * Any Reciple command execute data
  */
-export declare type CommandBuilderExecuteData = SlashCommandExecuteData | MessageCommandExecuteData;
+export declare type AnyCommandExecuteData = SlashCommandExecuteData | MessageCommandExecuteData;
+/**
+ * Any Reciple command halt functions
+ */
+export declare type AnyCommandHaltFunction = SlashCommandHaltFunction | MessageCommandHaltFunction;
 /**
  * Reciple command halt function
  */
-export declare type CommandHaltFunction<Builder extends CommandBuilder> = (haltData: HaltedCommandData<Builder>) => 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 CommandExecuteFunction<Builder extends CommandBuilder> = (executeData: Builder extends MessageCommandBuilder ? MessageCommandExecuteData : SlashCommandExecuteData) => Awaitable<void>;
+export declare type CommandExecuteFunction<T extends CommandBuilderType> = (executeData: T extends CommandBuilderType.SlashCommand ? SlashCommandExecuteData : MessageCommandExecuteData) => Awaitable<void>;
 /**
  * Types of Reciple command builders
  */

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

@@ -1,40 +1,47 @@
-import { MessageCommandExecuteData } from '../classes/builders/MessageCommandBuilder';
-import { SlashCommandBuilder, SlashCommandExecuteData } from '../classes/builders/SlashCommandBuilder';
+import { MessageCommandExecuteData, MessageCommandHaltData } from '../classes/builders/MessageCommandBuilder';
+import { SlashCommandExecuteData, SlashCommandHaltData } from '../classes/builders/SlashCommandBuilder';
 import { MessageCommandOptionManager } from '../classes/MessageCommandOptionManager';
+import { CommandBuilderType, AnyCommandExecuteData } from '../types/builders';
 import { CooledDownUser } from '../classes/CommandCooldownManager';
-import { CommandBuilder } from '../types/builders';
 /**
- * Halted command's data
+ * Any reciple halted command data
  */
-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 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
+ */
+export interface CommandHaltReasonBase<T extends CommandBuilderType> {
+    executeData: T extends CommandBuilderType.SlashCommand ? SlashCommandExecuteData : T extends CommandBuilderType.MessageCommand ? MessageCommandExecuteData : AnyCommandExecuteData;
 }
-export interface CommandErrorData<Builder extends CommandBuilder> extends CommandHaltBaseData<Builder> {
-    reason: HaltedCommandReason.Error;
+export interface CommandErrorData<T extends CommandBuilderType> extends CommandHaltReasonBase<T> {
+    reason: CommandHaltReason.Error;
     error: any;
 }
-export interface CommandCooldownData<Builder extends CommandBuilder> extends CommandHaltBaseData<Builder>, CooledDownUser {
-    reason: HaltedCommandReason.Cooldown;
+export interface CommandCooldownData<T extends CommandBuilderType> extends CommandHaltReasonBase<T>, CooledDownUser {
+    reason: CommandHaltReason.Cooldown;
 }
-export interface CommandInvalidArguments<Builder extends CommandBuilder> extends CommandHaltBaseData<Builder> {
-    reason: HaltedCommandReason.InvalidArguments;
+export interface CommandInvalidArguments<T extends CommandBuilderType> extends CommandHaltReasonBase<T> {
+    reason: CommandHaltReason.InvalidArguments;
     invalidArguments: MessageCommandOptionManager;
 }
-export interface CommandMissingArguments<Builder extends CommandBuilder> extends CommandHaltBaseData<Builder> {
-    reason: HaltedCommandReason.MissingArguments;
+export interface CommandMissingArguments<T extends CommandBuilderType> extends CommandHaltReasonBase<T> {
+    reason: CommandHaltReason.MissingArguments;
     missingArguments: MessageCommandOptionManager;
 }
-export interface CommandMissingMemberPermissions<Builder extends CommandBuilder> extends CommandHaltBaseData<Builder> {
-    reason: HaltedCommandReason.MissingMemberPermissions;
+export interface CommandMissingMemberPermissions<T extends CommandBuilderType> extends CommandHaltReasonBase<T> {
+    reason: CommandHaltReason.MissingMemberPermissions;
 }
-export interface CommandMissingBotPermissions<Builder extends CommandBuilder> extends CommandHaltBaseData<Builder> {
-    reason: HaltedCommandReason.MissingBotPermissions;
+export interface CommandMissingBotPermissions<T extends CommandBuilderType> extends CommandHaltReasonBase<T> {
+    reason: CommandHaltReason.MissingBotPermissions;
 }
 /**
  * Command halt reasons
  */
-export declare enum HaltedCommandReason {
+export declare enum CommandHaltReason {
     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.HaltedCommandReason = void 0;
+exports.CommandHaltReason = void 0;
 /**
  * Command halt reasons
  */
-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 = {}));
+var CommandHaltReason;
+(function (CommandHaltReason) {
+    CommandHaltReason[CommandHaltReason["Error"] = 0] = "Error";
+    CommandHaltReason[CommandHaltReason["Cooldown"] = 1] = "Cooldown";
+    CommandHaltReason[CommandHaltReason["InvalidArguments"] = 2] = "InvalidArguments";
+    CommandHaltReason[CommandHaltReason["MissingArguments"] = 3] = "MissingArguments";
+    CommandHaltReason[CommandHaltReason["MissingMemberPermissions"] = 4] = "MissingMemberPermissions";
+    CommandHaltReason[CommandHaltReason["MissingBotPermissions"] = 5] = "MissingBotPermissions";
+})(CommandHaltReason = exports.CommandHaltReason || (exports.CommandHaltReason = {}));

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

@@ -3,7 +3,7 @@ import { ApplicationCommandData, PermissionsBitField } from 'discord.js';
 import { RecipleModule, RecipleScript } from '../modules';
 import { RecipleClient } from '../classes/RecipleClient';
 import { Config } from '../classes/RecipleConfig';
-import { CommandBuilder } from './builders';
+import { AnyCommandBuilder } from './builders';
 export interface RecipleClientAddModuleOptions {
     /**
      * The Module script
@@ -33,7 +33,7 @@ export interface RegisterApplicationCommandsOptions {
     guilds?: string | string[];
 }
 export interface UserHasCommandPermissionsOptions {
-    builder: CommandBuilder;
+    builder: AnyCommandBuilder;
     memberPermissions?: PermissionsBitField;
     commandPermissions?: Config["commands"]["slashCommand"]["permissions"] | Config["commands"]["messageCommand"]["permissions"];
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "reciple",
-  "version": "4.1.0",
+  "version": "5.0.0-pre.2",
   "bin": "bin/bin.js",
   "license": "GPL-3.0",
   "main": "bin/index.js",
@@ -58,7 +58,7 @@
   "devDependencies": {
     "@types/node": "^18.6.1",
     "@types/semver": "^7.3.10",
-    "discord.js": "^14.0.3",
+    "discord.js": "^14.1.2",
     "rimraf": "^3.0.2",
     "typedoc": "^0.23.9",
     "typedoc-plugin-discord-types": "^1.0.2",
@@ -67,7 +67,7 @@
     "typescript": "^4.7.4"
   },
   "peerDependencies": {
-    "discord.js": "^14.0.3"
+    "discord.js": "^14.1.2"
   },
   "packageManager": "yarn@3.2.2"
 }