reciple 5.5.5 → 5.6.0

package/dist/cjs/reciple/classes/RecipleClient.js

@@ -12,14 +12,15 @@ const commands_1 = require("../types/commands");
 const permissions_1 = require("../permissions");
 const CommandCooldownManager_1 = require("./CommandCooldownManager");
 const MessageCommandOptionManager_1 = require("./MessageCommandOptionManager");
-const fallout_utility_1 = require("fallout-utility");
 const RecipleConfig_1 = require("./RecipleConfig");
 const modules_1 = require("../modules");
+const fallout_utility_1 = require("fallout-utility");
 const logger_1 = require("../logger");
 const version_1 = require("../version");
 const flags_1 = require("../flags");
 const path_1 = __importDefault(require("path"));
 const discord_js_1 = require("discord.js");
+const util_1 = require("../util");
 class RecipleClient extends discord_js_1.Client {
     /**
      * @param options Client options
@@ -33,15 +34,13 @@ class RecipleClient extends discord_js_1.Client {
         this.modules = [];
         this.version = version_1.version;
         this.logger = (0, logger_1.createLogger)(!!options.config?.fileLogging.stringifyLoggedJSON, options.config?.fileLogging.debugmode);
-        if (!options.config)
-            throw new Error('Config is not defined.');
         this.config = { ...this.config, ...(options.config ?? {}) };
         if (this.config.fileLogging.enabled)
             this.logger.logFile(path_1.default.join(flags_1.cwd, this.config.fileLogging.logFilePath ?? 'logs/latest.log'), false);
     }
     /**
-     * Load modules from modules folder
-     * @param folders List of folders that contains the modules you want to load
+     * Load and start modules from given folders
+     * @param folders folders that contains the modules you want to load
      */
     async startModules(...folders) {
         folders = (0, discord_js_1.normalizeArray)(folders).map(f => path_1.default.join(flags_1.cwd, f));
@@ -59,9 +58,11 @@ class RecipleClient extends discord_js_1.Client {
         return this;
     }
     /**
-     * Execute `onLoad()` from client modules and register application commands if enabled
+     * Execute {@link RecipleModule['onLoad']} from client modules and register application commands if enabled
      */
     async loadModules() {
+        if (!this.isReady())
+            throw new Error('Client is not ready');
         for (const m in this.modules) {
             const index = (m);
             const module_ = this.modules[index];
@@ -94,23 +95,23 @@ class RecipleClient extends discord_js_1.Client {
             this.logger.info(`${this.commands.messageCommands.size} message commands loaded.`);
             this.logger.info(`${this.commands.slashCommands.size} slash commands loaded.`);
         }
-        if (this.config.commands.slashCommand.registerCommands) {
-            await (0, registerApplicationCommands_1.registerApplicationCommands)({
-                client: this,
-                commands: [...this.commands.slashCommands.toJSON(), ...this.additionalApplicationCommands],
-                guilds: this.config.commands.slashCommand.guilds
-            });
-        }
+        if (this.config.commands.slashCommand.registerCommands)
+            await this.registerClientApplicationCommands();
         return this;
     }
     /**
      * Add module
      * @param options Module options
+     * @deprecated This is very stupid, Just add it manually
      */
     async addModule(options) {
+        (0, util_1.deprecationWarning)('Add modules manually It\'s not that hard');
+        // TODO: DEPRECATED!
         const { script } = options;
         const registerCommands = options.registerApplicationCommands;
         const info = options.moduleInfo;
+        if (!this.isReady())
+            throw new Error('Client is not ready');
         this.modules.push({
             script,
             info: {
@@ -130,11 +131,7 @@ class RecipleClient extends discord_js_1.Client {
             this.addCommand(command);
         }
         if (registerCommands)
-            await (0, registerApplicationCommands_1.registerApplicationCommands)({
-                client: this,
-                commands: [...this.commands.slashCommands.toJSON(), ...this.additionalApplicationCommands],
-                guilds: this.config.commands.slashCommand.guilds
-            });
+            await this.registerClientApplicationCommands();
     }
     /**
      * Add slash or message command to client
@@ -156,10 +153,14 @@ class RecipleClient extends discord_js_1.Client {
      * Listed to command executions
      */
     addCommandListeners() {
-        if (this.config.commands.messageCommand.enabled)
-            this.on('messageCreate', (message) => { this.messageCommandExecute(message); });
-        if (this.config.commands.slashCommand.enabled)
-            this.on('interactionCreate', (interaction) => { this.slashCommandExecute(interaction); });
+        this.on('messageCreate', (message) => {
+            if (this.config.commands.messageCommand.enabled)
+                this.messageCommandExecute(message);
+        });
+        this.on('interactionCreate', (interaction) => {
+            if (this.config.commands.slashCommand.enabled)
+                this.slashCommandExecute(interaction);
+        });
         return this;
     }
     /**
@@ -285,6 +286,17 @@ class RecipleClient extends discord_js_1.Client {
             message.reply(this.getConfigMessage('noPermissions', 'You do not have permission to use this command.')).catch(er => this._replyError(er));
         }
     }
+    /**
+     * Registers client slash commands and other application commands
+     */
+    async registerClientApplicationCommands() {
+        await (0, registerApplicationCommands_1.registerApplicationCommands)({
+            client: this,
+            commands: [...this.commands.slashCommands.toJSON(), ...this.additionalApplicationCommands],
+            guilds: this.config.commands.slashCommand.guilds
+        });
+        this.emit('recipleRegisterApplicationCommands');
+    }
     /**
      * Get a message from config
      * @param messageKey Config messages key
@@ -313,7 +325,7 @@ class RecipleClient extends discord_js_1.Client {
         return !!this.config.fileLogging.clientLogs;
     }
     /**
-     * Emits the "recipleReplyError" event
+     * Emits the {@link RecipleClientEvents["recipleReplyError"]} event
      * @param error Received Error
      */
     _replyError(error) {

package/dist/cjs/reciple/classes/builders/MessageCommandBuilder.js

@@ -116,7 +116,7 @@ class MessageCommandBuilder {
             throw new TypeError('option with name "' + option.name + '" already exists.');
         if (this.options.length > 0 && !this.options[this.options.length - 1 < 0 ? 0 : this.options.length - 1].required && option.required)
             throw new TypeError('All required options must be before optional options.');
-        this.options = [...this.options, option];
+        this.options.push(option);
         return this;
     }
     /**
@@ -176,23 +176,34 @@ class MessageCommandBuilder {
             options: this.options.map(o => o.toJSON()),
         };
     }
+    /**
+     * Resolve message command data/builder
+     * @param commandData Command data to resolve
+     */
     static resolveMessageCommand(commandData) {
         return this.isMessageCommandBuilder(commandData) ? commandData : new MessageCommandBuilder(commandData);
     }
     /**
      * Is a message command builder
+     * @param builder data to check
      */
     static isMessageCommandBuilder(builder) {
         return builder instanceof MessageCommandBuilder;
     }
     /**
      * Is a message command execute data
+     * @param executeData data to check
      */
     static isMessageCommandExecuteData(executeData) {
         return executeData.builder !== undefined && this.isMessageCommandBuilder(executeData.builder);
     }
 }
 exports.MessageCommandBuilder = MessageCommandBuilder;
+/**
+ * Validate message command options
+ * @param builder Command builder
+ * @param options Parsed command args
+ */
 async function validateMessageCommandOptions(builder, options) {
     const args = options.args || [];
     const required = builder.options.filter(o => o.required);

package/dist/cjs/reciple/classes/builders/MessageCommandOptionBuilder.js

@@ -67,5 +67,19 @@ class MessageCommandOptionBuilder {
             validator: this.validator,
         };
     }
+    /**
+     * Resolves message command option data/builder
+     * @param option Option data to resolve
+     */
+    static resolveMessageCommandOption(option) {
+        return this.isMessageCommandOption(option) ? option : new MessageCommandOptionBuilder(option);
+    }
+    /**
+     * Is a Message command option builder
+     * @param builder data to check
+     */
+    static isMessageCommandOption(builder) {
+        return builder instanceof MessageCommandOptionBuilder;
+    }
 }
 exports.MessageCommandOptionBuilder = MessageCommandOptionBuilder;

package/dist/cjs/reciple/classes/builders/SlashCommandBuilder.js

@@ -58,7 +58,9 @@ class SlashCommandBuilder extends discord_js_1.SlashCommandBuilder {
     }
     setRequiredMemberPermissions(...permissions) {
         this.requiredMemberPermissions = (0, discord_js_1.normalizeArray)(permissions);
-        this.setDefaultMemberPermissions(new discord_js_1.PermissionsBitField(this.requiredMemberPermissions).toArray().map(perm => discord_js_1.PermissionsBitField.resolve(perm)).reduce((prev, curr) => prev | curr));
+        this.setDefaultMemberPermissions(this.requiredMemberPermissions.length
+            ? new discord_js_1.PermissionsBitField(this.requiredMemberPermissions).bitfield
+            : undefined);
         return this;
     }
     setHalt(halt) {
@@ -77,6 +79,8 @@ class SlashCommandBuilder extends discord_js_1.SlashCommandBuilder {
     }
     /**
      * Add option builder to command builder
+     * @param builder Command/Subcommand builder
+     * @param option Option builder
      */
     static addOption(builder, option) {
         if (option instanceof discord_js_1.SlashCommandAttachmentOption) {
@@ -118,6 +122,7 @@ class SlashCommandBuilder extends discord_js_1.SlashCommandBuilder {
     }
     /**
      * Resolve option data
+     * @param option Option dara to resolve
      */
     static resolveOption(option) {
         let builder;
@@ -197,17 +202,23 @@ class SlashCommandBuilder extends discord_js_1.SlashCommandBuilder {
             .setNameLocalizations(option.nameLocalizations ?? null)
             .setDescriptionLocalizations(option.descriptionLocalizations ?? null);
     }
+    /**
+     * Resolve slash command data/builder
+     * @param commandData Command data to resolve
+     */
     static resolveSlashCommand(commandData) {
         return this.isSlashCommandBuilder(commandData) ? commandData : new SlashCommandBuilder(commandData);
     }
     /**
      * Is a slash command builder
+     * @param builder data to check
      */
     static isSlashCommandBuilder(builder) {
         return builder instanceof SlashCommandBuilder;
     }
     /**
      * Is a slash command execute data
+     * @param executeData data to check
      */
     static isSlashCommandExecuteData(executeData) {
         return executeData.builder !== undefined && this.isSlashCommandBuilder(executeData.builder);

package/dist/cjs/reciple/permissions.js

@@ -16,9 +16,6 @@ function userHasCommandPermissions(options) {
     return options.memberPermissions ? options.memberPermissions.has(command.permissions) : false;
 }
 exports.userHasCommandPermissions = userHasCommandPermissions;
-/**
- * @param guildOrChannel Check permission in a guild or channel
- */
 function botHasExecutePermissions(guildOrChannel, requiredPermissions) {
     if (!requiredPermissions?.length)
         return true;

package/dist/cjs/reciple/registerApplicationCommands.js

@@ -22,7 +22,6 @@ async function registerApplicationCommands(options) {
                 if (client.isClientLogsEnabled())
                     client.logger.debug(`Set required permissions for ${cmd.name}`);
             }
-            console.log(cmd);
         }
         return cmd.toJSON();
     }) ?? [];

package/dist/cjs/reciple/util.js

@@ -1,6 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isClass = void 0;
+exports.deprecationWarning = exports.isClass = void 0;
+/**
+ * Check if an object is a class
+ * @param object Object to identify
+ */
 function isClass(object) {
     const isClassConstructor = object.constructor && object.constructor.toString().substring(0, 5) === 'class';
     if (object.prototype === undefined)
@@ -9,3 +13,11 @@ function isClass(object) {
     return isClassConstructor || isPrototypeClassConstructor;
 }
 exports.isClass = isClass;
+/**
+ * Emit process warning about deprecated method/function
+ * @param content Warning content
+ */
+function deprecationWarning(content) {
+    process.emitWarning(content, 'DeprecationWarning');
+}
+exports.deprecationWarning = deprecationWarning;

package/dist/cjs/reciple/version.js

@@ -5,6 +5,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.isSupportedVersion = exports.parseVersion = exports.isValidVersion = exports.rawVersion = exports.version = void 0;
 const semver_1 = __importDefault(require("semver"));
+// TODO: ESM support
 /**
  * Current reciple version
  */

package/dist/types/reciple/classes/CommandCooldownManager.d.ts

@@ -4,11 +4,29 @@ import { CommandBuilderType } from '../types/builders';
  * cooled-down user object interface
  */
 export interface CooledDownUser {
+    /**
+     * Cooled-down user
+     */
     user: User;
+    /**
+     * Cooled-down command name
+     */
     command: string;
+    /**
+     * Command type
+     */
     type: CommandBuilderType;
+    /**
+     * In guild
+     */
     guild?: Guild | null;
+    /**
+     * Cooled-down channel
+     */
     channel?: TextBasedChannel;
+    /**
+     * Cooldown expiration
+     */
     expireTime: number;
 }
 /**

package/dist/types/reciple/classes/RecipleClient.d.ts

@@ -5,12 +5,12 @@ import { ApplicationCommandBuilder } from '../registerApplicationCommands';
 import { AnyCommandExecuteData, AnyCommandHaltData } from '../types/commands';
 import { CommandCooldownManager } from './CommandCooldownManager';
 import { RecipleClientAddModuleOptions } from '../types/paramOptions';
-import { Logger as ILogger } from 'fallout-utility';
 import { Config } from './RecipleConfig';
 import { RecipleModule } from '../modules';
+import { Logger } from 'fallout-utility';
 import { ApplicationCommandData, Awaitable, ChatInputCommandInteraction, Client, ClientEvents, ClientOptions, Collection, Interaction, Message, RestOrArray } from 'discord.js';
 /**
- * Options for Reciple client
+ * Options for {@link RecipleClient}
  */
 export interface RecipleClientOptions extends ClientOptions {
     config?: Config;
@@ -19,7 +19,13 @@ export interface RecipleClientOptions extends ClientOptions {
  * Reciple client commands
  */
 export interface RecipleClientCommands {
+    /**
+     * Collection of loaded slash commands
+     */
     slashCommands: Collection<string, AnySlashCommandBuilder>;
+    /**
+     * Collection of loaded message commands
+     */
     messageCommands: Collection<string, MessageCommandBuilder>;
 }
 /**
@@ -28,6 +34,7 @@ export interface RecipleClientCommands {
 export interface RecipleClientEvents extends ClientEvents {
     recipleCommandExecute: [executeData: AnyCommandExecuteData];
     recipleCommandHalt: [haltData: AnyCommandHaltData];
+    recipleRegisterApplicationCommands: [];
     recipleReplyError: [error: unknown];
 }
 /**
@@ -52,24 +59,25 @@ export declare class RecipleClient<Ready extends boolean = boolean> extends Clie
     additionalApplicationCommands: (ApplicationCommandBuilder | ApplicationCommandData)[];
     cooldowns: CommandCooldownManager;
     modules: RecipleModule[];
-    logger: ILogger;
+    logger: Logger;
     version: string;
     /**
      * @param options Client options
      */
     constructor(options: RecipleClientOptions);
     /**
-     * Load modules from modules folder
-     * @param folders List of folders that contains the modules you want to load
+     * Load and start modules from given folders
+     * @param folders folders that contains the modules you want to load
      */
-    startModules(...folders: RestOrArray<string>): Promise<RecipleClient<Ready>>;
+    startModules(...folders: RestOrArray<string>): Promise<this>;
     /**
-     * Execute `onLoad()` from client modules and register application commands if enabled
+     * Execute {@link RecipleModule['onLoad']} from client modules and register application commands if enabled
      */
-    loadModules(): Promise<RecipleClient<Ready>>;
+    loadModules(): Promise<this>;
     /**
      * Add module
      * @param options Module options
+     * @deprecated This is very stupid, Just add it manually
      */
     addModule(options: RecipleClientAddModuleOptions): Promise<void>;
     /**
@@ -92,6 +100,10 @@ export declare class RecipleClient<Ready extends boolean = boolean> extends Clie
      * @param prefix Message command prefix
      */
     messageCommandExecute(message: Message, prefix?: string): Promise<void | MessageCommandExecuteData>;
+    /**
+     * Registers client slash commands and other application commands
+     */
+    registerClientApplicationCommands(): Promise<void>;
     /**
      * Get a message from config
      * @param messageKey Config messages key
@@ -110,7 +122,7 @@ export declare class RecipleClient<Ready extends boolean = boolean> extends Clie
      */
     isClientLogsEnabled(): boolean;
     /**
-     * Emits the "recipleReplyError" event
+     * Emits the {@link RecipleClientEvents["recipleReplyError"]} event
      * @param error Received Error
      */
     protected _replyError(error: unknown): void;
@@ -122,7 +134,7 @@ export declare class RecipleClient<Ready extends boolean = boolean> extends Clie
     protected _haltCommand(command: SlashCommandBuilder, haltData: SlashCommandHaltData): Promise<boolean>;
     protected _haltCommand(command: MessageCommandBuilder, haltData: MessageCommandHaltData): Promise<boolean>;
     /**
-     * Executes a command through a commandBuilder#execute method
+     * Executes a command's {@link SharedCommandBuilderProperties["execute"]} method
      * @param command Command builder
      * @param executeData Command execute data
      */

package/dist/types/reciple/classes/RecipleConfig.d.ts

@@ -3,7 +3,13 @@ import { ClientOptions, PermissionResolvable } from 'discord.js';
  * Command permissions config object interface
  */
 export interface ConfigCommandPermissions {
+    /**
+     * Command name
+     */
     command: string;
+    /**
+     * Override command builder permissions
+     */
     permissions: PermissionResolvable[];
 }
 /**

package/dist/types/reciple/classes/builders/MessageCommandBuilder.d.ts

@@ -3,42 +3,69 @@ import { Message, PermissionResolvable, RestOrArray } from 'discord.js';
 import { BaseCommandExecuteData, CommandHaltData } from '../../types/commands';
 import { MessageCommandOptionManager } from '../MessageCommandOptionManager';
 import { MessageCommandOptionBuilder } from './MessageCommandOptionBuilder';
-import { Command as CommandMessage } from 'fallout-utility';
+import { Command } from 'fallout-utility';
 /**
  * Execute data for message command
  */
-export interface MessageCommandExecuteData<T extends unknown = any> extends BaseCommandExecuteData {
+export interface MessageCommandExecuteData<T = unknown> extends BaseCommandExecuteData {
+    /**
+     * Command message
+     */
     message: Message;
+    /**
+     * Command option args
+     */
     options: MessageCommandOptionManager;
-    command: CommandMessage;
+    /**
+     * Command parsed args
+     */
+    command: Command;
+    /**
+     * Command builder
+     */
     builder: MessageCommandBuilder<T>;
 }
 /**
  * Validated message command option
  */
 export interface MessageCommandValidatedOption {
+    /**
+     * Option name
+     */
     name: string;
-    value: string | undefined;
+    /**
+     * Option value
+     */
+    value?: string;
+    /**
+     * Is the option required
+     */
     required: boolean;
+    /**
+     * Is the option invalid
+     */
     invalid: boolean;
+    /**
+     * Is the option missing
+     */
     missing: boolean;
 }
 /**
  * Halt data for message command
  */
-export declare type MessageCommandHaltData = CommandHaltData<CommandBuilderType.MessageCommand>;
+export declare type MessageCommandHaltData<T = unknown> = CommandHaltData<CommandBuilderType.MessageCommand, T>;
 /**
  * Message command halt function
  */
-export declare type MessageCommandHaltFunction = CommandHaltFunction<CommandBuilderType.MessageCommand>;
+export declare type MessageCommandHaltFunction<T = unknown> = CommandHaltFunction<CommandBuilderType.MessageCommand, T>;
 /**
  * Message command execute function
  */
-export declare type MessageCommandExecuteFunction = CommandExecuteFunction<CommandBuilderType.MessageCommand>;
+export declare type MessageCommandExecuteFunction<T = unknown> = CommandExecuteFunction<CommandBuilderType.MessageCommand, T>;
 /**
  * Reciple builder for message command
  */
-export declare class MessageCommandBuilder<T extends unknown = any> implements SharedCommandBuilderProperties<T> {
+export declare class MessageCommandBuilder<T = unknown> implements SharedCommandBuilderProperties<T> {
     readonly type = CommandBuilderType.MessageCommand;
     name: string;
     description: string;
@@ -50,8 +77,8 @@ export declare class MessageCommandBuilder<T extends unknown = any> implements S
     requiredMemberPermissions: PermissionResolvable[];
     allowExecuteInDM: boolean;
     allowExecuteByBots: boolean;
-    halt?: MessageCommandHaltFunction;
-    execute: MessageCommandExecuteFunction;
+    halt?: MessageCommandHaltFunction<T>;
+    execute: MessageCommandExecuteFunction<T>;
     metadata?: T;
     constructor(data?: Partial<Omit<MessageCommandData<T>, "type">>);
     /**
@@ -92,21 +119,32 @@ export declare class MessageCommandBuilder<T extends unknown = any> implements S
     setCooldown(cooldown: number): this;
     setRequiredBotPermissions(...permissions: RestOrArray<PermissionResolvable>): this;
     setRequiredMemberPermissions(...permissions: RestOrArray<PermissionResolvable>): this;
-    setHalt(halt?: MessageCommandHaltFunction | null): this;
-    setExecute(execute: MessageCommandExecuteFunction): this;
+    setHalt(halt?: MessageCommandHaltFunction<T> | null): this;
+    setExecute(execute: MessageCommandExecuteFunction<T>): this;
     setMetadata(metadata?: T): this;
     /**
      * Returns JSON object of this builder
      */
     toJSON(): MessageCommandData<T>;
-    static resolveMessageCommand<T extends unknown = any>(commandData: MessageCommandData<T> | MessageCommandBuilder<T>): MessageCommandBuilder<T>;
+    /**
+     * Resolve message command data/builder
+     * @param commandData Command data to resolve
+     */
+    static resolveMessageCommand<T = unknown>(commandData: MessageCommandData<T> | MessageCommandBuilder<T>): MessageCommandBuilder<T>;
     /**
      * Is a message command builder
+     * @param builder data to check
      */
     static isMessageCommandBuilder<T>(builder: unknown): builder is MessageCommandBuilder<T>;
     /**
      * Is a message command execute data
+     * @param executeData data to check
      */
     static isMessageCommandExecuteData(executeData: unknown): executeData is MessageCommandExecuteData;
 }
-export declare function validateMessageCommandOptions(builder: MessageCommandBuilder, options: CommandMessage): Promise<MessageCommandOptionManager>;
+/**
+ * Validate message command options
+ * @param builder Command builder
+ * @param options Parsed command args
+ */
+export declare function validateMessageCommandOptions(builder: MessageCommandBuilder, options: Command): Promise<MessageCommandOptionManager>;

package/dist/types/reciple/classes/builders/MessageCommandOptionBuilder.d.ts

@@ -30,4 +30,14 @@ export declare class MessageCommandOptionBuilder {
      */
     setValidator(validator: (value: string) => Awaitable<boolean>): this;
     toJSON(): MessageCommandOptionData;
+    /**
+     * Resolves message command option data/builder
+     * @param option Option data to resolve
+     */
+    static resolveMessageCommandOption(option: MessageCommandOptionBuilder | MessageCommandOptionBuilder): MessageCommandOptionBuilder;
+    /**
+     * Is a Message command option builder
+     * @param builder data to check
+     */
+    static isMessageCommandOption(builder: unknown): builder is MessageCommandOptionBuilder;
 }

package/dist/types/reciple/classes/builders/SlashCommandBuilder.d.ts

@@ -4,25 +4,31 @@ import { ChatInputCommandInteraction, PermissionResolvable, RestOrArray, SlashCo
 /**
  * Execute data for slash command
  */
-export interface SlashCommandExecuteData<T extends unknown = any> extends BaseCommandExecuteData {
+export interface SlashCommandExecuteData<T = unknown> extends BaseCommandExecuteData {
+    /**
+     * Command interaction
+     */
     interaction: ChatInputCommandInteraction;
+    /**
+     * Command Builder
+     */
     builder: AnySlashCommandBuilder<T>;
 }
 /**
  * Slash command halt data
  */
-export declare type SlashCommandHaltData = CommandHaltData<CommandBuilderType.SlashCommand>;
+export declare type SlashCommandHaltData<T = unknown> = CommandHaltData<CommandBuilderType.SlashCommand, T>;
 /**
  * Slash command halt function
  */
-export declare type SlashCommandHaltFunction = CommandHaltFunction<CommandBuilderType.SlashCommand>;
+export declare type SlashCommandHaltFunction<T = unknown> = CommandHaltFunction<CommandBuilderType.SlashCommand, T>;
 /**
  * Slash command execute function
  */
-export declare type SlashCommandExecuteFunction = CommandExecuteFunction<CommandBuilderType.SlashCommand>;
-export declare type SlashCommandSubcommandsOnlyBuilder<T extends unknown = any> = Omit<SlashCommandBuilder<T>, "addBooleanOption" | "addUserOption" | "addChannelOption" | "addRoleOption" | "addAttachmentOption" | "addMentionableOption" | "addStringOption" | "addIntegerOption" | "addNumberOption">;
-export declare type SlashCommandOptionsOnlyBuilder<T extends unknown = any> = Omit<SlashCommandBuilder<T>, "addSubcommand" | "addSubcommandGroup">;
-export interface SlashCommandBuilder<T extends unknown = any> extends DiscordJsSlashCommandBuilder {
+export declare type SlashCommandExecuteFunction<T = unknown> = CommandExecuteFunction<CommandBuilderType.SlashCommand, T>;
+export declare type SlashCommandSubcommandsOnlyBuilder<T = unknown> = Omit<SlashCommandBuilder<T>, "addBooleanOption" | "addUserOption" | "addChannelOption" | "addRoleOption" | "addAttachmentOption" | "addMentionableOption" | "addStringOption" | "addIntegerOption" | "addNumberOption">;
+export declare type SlashCommandOptionsOnlyBuilder<T = unknown> = Omit<SlashCommandBuilder<T>, "addSubcommand" | "addSubcommandGroup">;
+export interface SlashCommandBuilder<T = unknown> extends DiscordJsSlashCommandBuilder {
     addSubcommandGroup(input: SlashCommandSubcommandGroupBuilder | ((subcommandGroup: SlashCommandSubcommandGroupBuilder) => SlashCommandSubcommandGroupBuilder)): SlashCommandSubcommandsOnlyBuilder;
     addSubcommand(input: SlashCommandSubcommandBuilder | ((subcommandGroup: SlashCommandSubcommandBuilder) => SlashCommandSubcommandBuilder)): SlashCommandSubcommandsOnlyBuilder;
     addBooleanOption(input: SlashCommandBooleanOption | ((builder: SlashCommandBooleanOption) => SlashCommandBooleanOption)): Omit<this, "addSubcommand" | "addSubcommandGroup">;
@@ -38,36 +44,45 @@ export interface SlashCommandBuilder<T extends unknown = any> extends DiscordJsS
 /**
  * Reciple builder for slash command
  */
-export declare class SlashCommandBuilder<T extends unknown = any> extends DiscordJsSlashCommandBuilder implements SharedCommandBuilderProperties<T> {
+export declare class SlashCommandBuilder<T = unknown> extends DiscordJsSlashCommandBuilder implements SharedCommandBuilderProperties<T> {
     readonly type = CommandBuilderType.SlashCommand;
     cooldown: number;
     requiredBotPermissions: PermissionResolvable[];
     requiredMemberPermissions: PermissionResolvable[];
-    halt?: SlashCommandHaltFunction;
-    execute: SlashCommandExecuteFunction;
+    halt?: SlashCommandHaltFunction<T>;
+    execute: SlashCommandExecuteFunction<T>;
     metadata?: T;
     constructor(data?: Partial<Omit<SlashCommandData<T>, "type">>);
     setCooldown(cooldown: number): this;
     setRequiredBotPermissions(...permissions: RestOrArray<PermissionResolvable>): this;
     setRequiredMemberPermissions(...permissions: RestOrArray<PermissionResolvable>): this;
-    setHalt(halt?: SlashCommandHaltFunction | null): this;
-    setExecute(execute: SlashCommandExecuteFunction): this;
+    setHalt(halt?: SlashCommandHaltFunction<T> | null): this;
+    setExecute(execute: SlashCommandExecuteFunction<T>): this;
     setMetadata(metadata?: T): this;
     /**
      * Add option builder to command builder
+     * @param builder Command/Subcommand builder
+     * @param option Option builder
      */
     static addOption(builder: SharedSlashCommandOptions | SlashCommandBuilder, option: AnySlashCommandOptionBuilder): SharedSlashCommandOptions;
     /**
      * Resolve option data
+     * @param option Option dara to resolve
      */
     static resolveOption<T extends AnySlashCommandOptionBuilder>(option: AnySlashCommandOptionData): T;
-    static resolveSlashCommand<T extends unknown = any>(commandData: SlashCommandData<T> | AnySlashCommandBuilder<T>): AnySlashCommandBuilder;
+    /**
+     * Resolve slash command data/builder
+     * @param commandData Command data to resolve
+     */
+    static resolveSlashCommand<T = unknown>(commandData: SlashCommandData<T> | AnySlashCommandBuilder<T>): AnySlashCommandBuilder<T>;
     /**
      * Is a slash command builder
+     * @param builder data to check
      */
-    static isSlashCommandBuilder<T extends unknown = any>(builder: unknown): builder is AnySlashCommandBuilder<T>;
+    static isSlashCommandBuilder<T = unknown>(builder: unknown): builder is AnySlashCommandBuilder<T>;
     /**
      * Is a slash command execute data
+     * @param executeData data to check
      */
     static isSlashCommandExecuteData(executeData: unknown): executeData is SlashCommandExecuteData;
 }

package/dist/types/reciple/modules.d.ts

@@ -1,26 +1,58 @@
 import { AnyCommandBuilder, AnyCommandData } from './types/builders';
 import { RecipleClient } from './classes/RecipleClient';
-export declare type LoadedModules = {
+/**
+ * Loaded modules and commands
+ */
+export interface LoadedModules {
     commands: AnyCommandBuilder[];
     modules: RecipleModule[];
-};
+}
 /**
  * Reciple script object
  */
 export interface RecipleScript {
+    /**
+     * Supported reciple versions
+     */
     versions: string | string[];
+    /**
+     * Module commands
+     */
     commands?: (AnyCommandBuilder | AnyCommandData)[];
-    onLoad?(client: RecipleClient): void | Promise<void>;
-    onStart(client: RecipleClient): boolean | Promise<boolean>;
+    /**
+     * Action on bot ready
+     * @param client Bot client
+     */
+    onLoad?(client: RecipleClient<true>): void | Promise<void>;
+    /**
+     * Action on module start
+     * @param client Bot client
+     */
+    onStart(client: RecipleClient<false>): boolean | Promise<boolean>;
 }
 /**
  * Reciple module object
  */
 export interface RecipleModule {
+    /**
+     * Module script
+     */
     script: RecipleScript;
+    /**
+     * Module local information
+     */
     info: {
+        /**
+         * Module file name
+         */
         filename?: string;
+        /**
+         * Supported reciple versions
+         */
         versions: string[];
+        /**
+         * Module local file path
+         */
         path?: string;
     };
 }

package/dist/types/reciple/permissions.d.ts

@@ -7,11 +7,13 @@ import { UserHasCommandPermissionsOptions } from './types/paramOptions';
 export declare function userHasCommandPermissions(options: UserHasCommandPermissionsOptions): boolean;
 /**
  * Check if the bot has the required permissions in a guild
- * @param guild Check if the bot has the required permissions in a guild
+ * @param guild Check if the bot has the required permissions in this guild
  * @param requiredPermissions Required guild bot permissions
  */
 export declare function botHasExecutePermissions(guild?: Guild, requiredPermissions?: PermissionResolvable[]): boolean;
 /**
- * @param channel Check if the bot has the required permissions in a channel
+ * Check if the bot has the required permissions in a channel
+ * @param channel Check if the bot has the required permissions in this channel
+ * @param requiredPermissions Required guild bot permissions
  */
 export declare function botHasExecutePermissions(channel?: GuildTextBasedChannel, requiredPermissions?: PermissionResolvable[]): boolean;

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

@@ -5,31 +5,31 @@ import { MessageCommandOptionBuilder } from '../classes/builders/MessageCommandO
 /**
  * Any command builders
  */
-export declare type AnyCommandBuilder<T extends unknown = any> = AnySlashCommandBuilder<T> | MessageCommandBuilder<T>;
+export declare type AnyCommandBuilder<T = unknown> = AnySlashCommandBuilder<T> | MessageCommandBuilder<T>;
 /**
  * Any command data
  */
-export declare type AnyCommandData<T extends unknown = any> = SlashCommandData<T> | MessageCommandData<T>;
+export declare type AnyCommandData<T = unknown> = SlashCommandData<T> | MessageCommandData<T>;
 /**
  * Any slash command builders
  */
-export declare type AnySlashCommandBuilder<T extends unknown = any> = SlashCommandBuilder<T> | SlashCommandOptionsOnlyBuilder<T> | SlashCommandSubcommandsOnlyBuilder<T>;
+export declare type AnySlashCommandBuilder<T = unknown> = SlashCommandBuilder<T> | SlashCommandOptionsOnlyBuilder<T> | SlashCommandSubcommandsOnlyBuilder<T>;
 /**
  * Any command halt functions
  */
-export declare type AnyCommandHaltFunction = SlashCommandHaltFunction | MessageCommandHaltFunction;
+export declare type AnyCommandHaltFunction<T = unknown> = SlashCommandHaltFunction<T> | MessageCommandHaltFunction<T>;
 /**
  * Any command execute function
  */
-export declare type AnyCommandExecuteFunction = SlashCommandExecuteFunction | MessageCommandExecuteFunction;
+export declare type AnyCommandExecuteFunction<T = unknown> = SlashCommandExecuteFunction<T> | MessageCommandExecuteFunction<T>;
 /**
  * Command halt function
  */
-export declare type CommandHaltFunction<T extends CommandBuilderType> = (haltData: T extends CommandBuilderType.SlashCommand ? SlashCommandHaltData : MessageCommandHaltData) => Awaitable<boolean | null | undefined | void>;
+export declare type CommandHaltFunction<T extends CommandBuilderType, M = unknown> = (haltData: T extends CommandBuilderType.SlashCommand ? SlashCommandHaltData<M> : T extends CommandBuilderType.MessageCommand ? MessageCommandHaltData<M> : SlashCommandHaltData<M> | MessageCommandHaltData<M>) => Awaitable<boolean | null | undefined | void>;
 /**
  * Command execute function
  */
-export declare type CommandExecuteFunction<T extends CommandBuilderType> = (executeData: T extends CommandBuilderType.SlashCommand ? SlashCommandExecuteData : MessageCommandExecuteData) => Awaitable<void>;
+export declare type CommandExecuteFunction<T extends CommandBuilderType, M = unknown> = (executeData: T extends CommandBuilderType.SlashCommand ? SlashCommandExecuteData<M> : T extends CommandBuilderType.MessageCommand ? MessageCommandExecuteData<M> : SlashCommandExecuteData<M> | MessageCommandExecuteData<M>) => Awaitable<void>;
 /**
  * Message command options resolvable
  */
@@ -60,13 +60,13 @@ export declare enum CommandBuilderType {
 /**
  * Shared command builder methods and properties
  */
-export interface SharedCommandBuilderProperties<T extends unknown> {
+export interface SharedCommandBuilderProperties<T = unknown> {
     readonly type: CommandBuilderType;
     cooldown: number;
     requiredBotPermissions: PermissionResolvable[];
     requiredMemberPermissions: PermissionResolvable[];
-    halt?: AnyCommandHaltFunction;
-    execute: AnyCommandExecuteFunction;
+    halt?: AnyCommandHaltFunction<T>;
+    execute: AnyCommandExecuteFunction<T>;
     metadata?: T;
     /**
      * Sets the execute cooldown for this command.
@@ -110,7 +110,7 @@ export interface SharedCommandDataProperties {
 /**
  * Slash command object data interface
  */
-export interface SlashCommandData<T extends unknown = any> extends SharedCommandDataProperties, Partial<Omit<SharedCommandBuilderProperties<T>, "setCooldown" | "setRequiredBotPermissions" | "setRequiredMemberPermissions" | "setHalt" | "setExecute" | "setMetadata" | "halt" | "execute">> {
+export interface SlashCommandData<T = unknown> extends SharedCommandDataProperties, Partial<Omit<SharedCommandBuilderProperties<T>, "setCooldown" | "setRequiredBotPermissions" | "setRequiredMemberPermissions" | "setHalt" | "setExecute" | "setMetadata" | "halt" | "execute">> {
     type: CommandBuilderType.SlashCommand;
     nameLocalizations?: LocalizationMap;
     descriptionLocalizations?: LocalizationMap;
@@ -121,8 +121,8 @@ export interface SlashCommandData<T extends unknown = any> extends SharedCommand
     defaultPermission?: boolean;
     defaultMemberPermissions?: string | null;
     dmPermission?: boolean;
-    halt?: SlashCommandHaltFunction;
-    execute: SlashCommandExecuteFunction;
+    halt?: SlashCommandHaltFunction<T>;
+    execute: SlashCommandExecuteFunction<T>;
 }
 export interface SharedSlashCommandOptionData<V = string | number> extends SharedCommandDataProperties, Pick<SlashCommandData, "nameLocalizations" | "descriptionLocalizations"> {
     choices?: {
@@ -178,14 +178,14 @@ export interface SlashCommandSubCommandGroupData extends SharedCommandDataProper
 /**
  * Message command object data interface
  */
-export interface MessageCommandData<T extends unknown = any> extends SharedCommandDataProperties, Partial<Omit<SharedCommandBuilderProperties<T>, "setCooldown" | "setRequiredBotPermissions" | "setRequiredMemberPermissions" | "setHalt" | "setExecute" | "setMetadata" | "halt" | "execute">> {
+export interface MessageCommandData<T = unknown> extends SharedCommandDataProperties, Partial<Omit<SharedCommandBuilderProperties<T>, "setCooldown" | "setRequiredBotPermissions" | "setRequiredMemberPermissions" | "setHalt" | "setExecute" | "setMetadata" | "halt" | "execute">> {
     type: CommandBuilderType.MessageCommand;
     aliases?: string[];
     validateOptions?: boolean;
     allowExecuteInDM?: boolean;
     allowExecuteByBots?: boolean;
-    halt?: MessageCommandHaltFunction;
-    execute: MessageCommandExecuteFunction;
+    halt?: MessageCommandHaltFunction<T>;
+    execute: MessageCommandExecuteFunction<T>;
     options?: MessageCommandOptionResolvable[];
 }
 /**

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

@@ -7,46 +7,65 @@ import { CommandBuilderType } from '../types/builders';
 /**
  * Any command halt data
  */
-export declare type AnyCommandHaltData = SlashCommandHaltData | MessageCommandHaltData;
+export declare type AnyCommandHaltData<T = unknown> = SlashCommandHaltData<T> | MessageCommandHaltData<T>;
 /**
  * command halt 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>;
+export declare type CommandHaltData<T extends CommandBuilderType, M = unknown> = CommandErrorData<T, M> | CommandCooldownData<T, M> | (T extends CommandBuilderType.SlashCommand ? never : CommandInvalidArguments<T, M> | CommandMissingArguments<T, M>) | CommandMissingMemberPermissions<T, M> | CommandMissingBotPermissions<T, M>;
 /**
  * Any command execute data
  */
-export declare type AnyCommandExecuteData = SlashCommandExecuteData | MessageCommandExecuteData;
+export declare type AnyCommandExecuteData<T = unknown> = SlashCommandExecuteData<T> | MessageCommandExecuteData<T>;
 /**
  * Command execute data
  */
 export interface BaseCommandExecuteData {
+    /**
+     * Bot client
+     */
     client: RecipleClient<true>;
 }
 /**
  * Command halt reason base
  */
-export interface BaseCommandHaltData<T extends CommandBuilderType> {
-    executeData: T extends CommandBuilderType.SlashCommand ? SlashCommandExecuteData : T extends CommandBuilderType.MessageCommand ? MessageCommandExecuteData : AnyCommandExecuteData;
+export interface BaseCommandHaltData<T extends CommandBuilderType, M = unknown> {
+    /**
+     * Halt reason
+     */
+    reason: CommandHaltReason;
+    /**
+     * Command execute da6a
+     */
+    executeData: T extends CommandBuilderType.SlashCommand ? SlashCommandExecuteData<M> : T extends CommandBuilderType.MessageCommand ? MessageCommandExecuteData<M> : AnyCommandExecuteData<M>;
 }
-export interface CommandErrorData<T extends CommandBuilderType> extends BaseCommandHaltData<T> {
+export interface CommandErrorData<T extends CommandBuilderType, M = unknown> extends BaseCommandHaltData<T, M> {
     reason: CommandHaltReason.Error;
+    /**
+     * Caught error
+     */
     error: any;
 }
-export interface CommandCooldownData<T extends CommandBuilderType> extends BaseCommandHaltData<T>, CooledDownUser {
+export interface CommandCooldownData<T extends CommandBuilderType, M = unknown> extends BaseCommandHaltData<T, M>, CooledDownUser {
     reason: CommandHaltReason.Cooldown;
 }
-export interface CommandInvalidArguments<T extends CommandBuilderType> extends BaseCommandHaltData<T> {
+export interface CommandInvalidArguments<T extends CommandBuilderType, M = unknown> extends BaseCommandHaltData<T, M> {
     reason: CommandHaltReason.InvalidArguments;
+    /**
+     * Arguments that are invalid
+     */
     invalidArguments: MessageCommandOptionManager;
 }
-export interface CommandMissingArguments<T extends CommandBuilderType> extends BaseCommandHaltData<T> {
+export interface CommandMissingArguments<T extends CommandBuilderType, M = unknown> extends BaseCommandHaltData<T, M> {
     reason: CommandHaltReason.MissingArguments;
+    /**
+     * Arguments that are missing
+     */
     missingArguments: MessageCommandOptionManager;
 }
-export interface CommandMissingMemberPermissions<T extends CommandBuilderType> extends BaseCommandHaltData<T> {
+export interface CommandMissingMemberPermissions<T extends CommandBuilderType, M = unknown> extends BaseCommandHaltData<T, M> {
     reason: CommandHaltReason.MissingMemberPermissions;
 }
-export interface CommandMissingBotPermissions<T extends CommandBuilderType> extends BaseCommandHaltData<T> {
+export interface CommandMissingBotPermissions<T extends CommandBuilderType, M = unknown> extends BaseCommandHaltData<T, M> {
     reason: CommandHaltReason.MissingBotPermissions;
 }
 /**

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

@@ -1,8 +1,8 @@
 import { ApplicationCommandBuilder } from '../registerApplicationCommands';
 import { ApplicationCommandData, PermissionsBitField } from 'discord.js';
+import { ConfigCommandPermissions } from '../classes/RecipleConfig';
 import { RecipleModule, RecipleScript } from '../modules';
 import { RecipleClient } from '../classes/RecipleClient';
-import { Config } from '../classes/RecipleConfig';
 import { AnyCommandBuilder } from './builders';
 export interface RecipleClientAddModuleOptions {
     /**
@@ -33,7 +33,19 @@ export interface RegisterApplicationCommandsOptions {
     guilds?: string | string[];
 }
 export interface UserHasCommandPermissionsOptions {
+    /**
+     * Command builder
+     */
     builder: AnyCommandBuilder;
+    /**
+     * Member permissions
+     */
     memberPermissions?: PermissionsBitField;
-    commandPermissions?: Config["commands"]["slashCommand"]["permissions"] | Config["commands"]["messageCommand"]["permissions"];
+    /***
+     * Required command config permissions
+     */
+    commandPermissions?: {
+        enabled: boolean;
+        commands: ConfigCommandPermissions[];
+    };
 }

package/dist/types/reciple/util.d.ts

@@ -1 +1,10 @@
-export declare function isClass<T extends any>(object: any): object is T;
+/**
+ * Check if an object is a class
+ * @param object Object to identify
+ */
+export declare function isClass<T = any>(object: any): object is T;
+/**
+ * Emit process warning about deprecated method/function
+ * @param content Warning content
+ */
+export declare function deprecationWarning(content: string | Error): void;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "reciple",
-  "version": "5.5.5",
+  "version": "5.6.0",
   "bin": "dist/cjs/bin.js",
   "license": "GPL-3.0",
   "main": "dist/cjs/index.js",
@@ -11,7 +11,9 @@
   "keywords": [
     "Discord",
     "Discord.js handler",
-    "Reciple"
+    "Reciple",
+    "Slash command handler",
+    "Message command handler"
   ],
   "contributors": [
     "GhexterCortes"
@@ -47,14 +49,14 @@
     "chalk": "4.1.2",
     "commander": "^9.4.1",
     "dotenv": "^16.0.3",
-    "fallout-utility": "^1.5.1",
-    "semver": "^7.3.7",
+    "fallout-utility": "^1.5.2",
+    "semver": "^7.3.8",
     "wildcard-match": "^5.1.2",
-    "yaml": "^2.1.1"
+    "yaml": "^2.1.3"
   },
   "devDependencies": {
     "@discordjs/docgen": "^0.12.1",
-    "@types/node": "^18.7.23",
+    "@types/node": "^18.8.3",
     "@types/semver": "^7.3.12",
     "discord.js": "^14.5.0",
     "rimraf": "^3.0.2",