reciple 5.5.6 → 6.0.0-dev.1

package/dist/cjs/reciple/classes/managers/ClientModuleManager.js

@@ -0,0 +1,189 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ClientModuleManager = void 0;
+const crypto_1 = require("crypto");
+const discord_js_1 = require("discord.js");
+const fs_1 = require("fs");
+const path_1 = __importDefault(require("path"));
+const wildcard_match_1 = __importDefault(require("wildcard-match"));
+const flags_1 = require("../../flags");
+const builders_1 = require("../../types/builders");
+const util_1 = require("../../util");
+const version_1 = require("../../version");
+const MessageCommandBuilder_1 = require("../builders/MessageCommandBuilder");
+const SlashCommandBuilder_1 = require("../builders/SlashCommandBuilder");
+class ClientModuleManager {
+    constructor(options) {
+        this.modules = new discord_js_1.Collection();
+        this.client = options.client;
+        options.modules?.forEach(m => {
+            if (!m.id)
+                m.id = (0, crypto_1.randomUUID)();
+            this.modules.set(m.id, this.resolveModule(m));
+        });
+    }
+    async startModulesFromFiles(options) {
+        const modules = await this.resolveModulesFromFiles(options);
+        for (const module_ of modules) {
+            try {
+                await this.startModule(module_);
+            }
+            catch (err) {
+                if (options.dontSkipError)
+                    throw err;
+                if (this.client.isClientLogsEnabled())
+                    this.client.logger.err(`Cannot start module ${ClientModuleManager.getModuleDisplayId(module_)}:`, err);
+            }
+        }
+        return modules;
+    }
+    async resolveModulesFromFiles(options) {
+        const modules = [];
+        const isVersionCheckDisabled = (options.disabeVersionCheck || this.client.config.disableVersionCheck);
+        for (const file of options.files) {
+            const moduleFileName = path_1.default.basename(file);
+            const moduleDirPath = path_1.default.dirname(file);
+            const id = (0, crypto_1.randomUUID)();
+            let script;
+            try {
+                const resolveModuleFile = await Promise.resolve().then(() => __importStar(require(file)));
+                script = resolveModuleFile?.default ?? resolveModuleFile;
+                const module_ = this.resolveModule({
+                    id,
+                    script,
+                    info: {
+                        filename: moduleFileName,
+                        path: moduleDirPath
+                    }
+                }, isVersionCheckDisabled);
+                modules.push(module_);
+                if (this.client.isClientLogsEnabled())
+                    this.client.logger.log(`Resolved ${file}`);
+            }
+            catch (err) {
+                if (options.dontSkipError)
+                    throw err;
+                if (this.client.isClientLogsEnabled())
+                    this.client.logger.err(`Cannot resolve module file ${file}:`, err);
+            }
+        }
+        return modules;
+    }
+    resolveScriptCommands(...modules) {
+        const resolvedCommands = [];
+        for (const script of (0, discord_js_1.normalizeArray)(modules)) {
+            const commands = [];
+            if (Array.isArray(script?.commands)) {
+                for (const command of script.commands) {
+                    if (command.type === builders_1.CommandBuilderType.MessageCommand) {
+                        commands.push(MessageCommandBuilder_1.MessageCommandBuilder.resolveMessageCommand(command));
+                    }
+                    else if (command.type === builders_1.CommandBuilderType.SlashCommand) {
+                        commands.push(SlashCommandBuilder_1.SlashCommandBuilder.resolveSlashCommand(command));
+                    }
+                }
+            }
+            const invalidBuilders = commands.some(c => !(0, util_1.validateCommandBuilder)(c));
+            if (invalidBuilders)
+                throw new Error(`Module script commands contains a command builder without name or option name`);
+            resolvedCommands.push({
+                script,
+                commands
+            });
+        }
+        return resolvedCommands;
+    }
+    async loadAll(registerApplicationCommands, ...registerApplicationCommandsGuilds) {
+        await Promise.all(this.modules.map(async (m) => {
+            if (typeof m.script?.onLoad === 'function') {
+                try {
+                    await Promise.resolve(m.script.onLoad(this.client)).catch(err => { throw err; });
+                }
+                catch (err) {
+                    this.modules.delete(m.id);
+                    if (this.client.isClientLogsEnabled())
+                        this.client.logger.error(`Error loading ${m.info.filename ?? 'unknown module'}:`, err);
+                    return;
+                }
+            }
+            this.client.commands.add(m.commands);
+            if (this.client.isClientLogsEnabled())
+                this.client.logger.log(`Loaded module: ${ClientModuleManager.getModuleDisplayId(m)}`);
+        }));
+        if (this.client.isClientLogsEnabled()) {
+            this.client.logger.info(`${this.modules.size} modules loaded.`);
+            this.client.logger.info(`${this.client.commands.messageCommands.size} message commands loaded.`);
+            this.client.logger.info(`${this.client.commands.slashCommands.size} slash commands loaded.`);
+        }
+        if (registerApplicationCommands)
+            this.client.commands.registerApplicationCommands((0, discord_js_1.normalizeArray)(registerApplicationCommandsGuilds));
+    }
+    async startModule(mod) {
+        let err;
+        const identifier = ClientModuleManager.getModuleDisplayId(mod);
+        if (this.client.isClientLogsEnabled())
+            this.client.logger.log(`Starting Module: ${identifier}`);
+        const start = await Promise.resolve(mod.script.onStart(this.client)).catch(e => err = e);
+        if (err)
+            throw err;
+        if (!start)
+            throw new Error(`Module ${identifier} returned 'false' on start`);
+        this.modules.set(mod.id, mod);
+    }
+    resolveModule(mod, disabeVersionCheck) {
+        const identifier = ClientModuleManager.getModuleDisplayId(mod);
+        if (!disabeVersionCheck && !mod?.script?.versions?.length)
+            throw new Error(`Module ${identifier} does not contain supported versions`);
+        if (typeof mod.script?.onStart !== 'function')
+            throw new Error(`Module ${identifier} does not have a valid 'onStart' method`);
+        const versions = (0, discord_js_1.normalizeArray)([mod.script.versions]);
+        const commands = this.resolveScriptCommands(mod.script)[0].commands;
+        if (!disabeVersionCheck && !versions.some(v => (0, version_1.isSupportedVersion)(v, version_1.version)))
+            throw new Error(`Module ${identifier} does not support 'reciple@${version_1.rawVersion}'`);
+        return {
+            ...mod,
+            commands,
+        };
+    }
+    async getModuleFiles(...folders) {
+        const modules = [];
+        for (const dir of ((0, discord_js_1.normalizeArray)(folders).length ? (0, discord_js_1.normalizeArray)(folders) : (0, discord_js_1.normalizeArray)([this.client.config.modulesFolder]))) {
+            if (!(0, fs_1.existsSync)(dir))
+                (0, fs_1.mkdirSync)(dir, { recursive: true });
+            if (!(0, fs_1.lstatSync)(dir).isDirectory())
+                continue;
+            modules.push(...(0, fs_1.readdirSync)(dir).map(file => path_1.default.join(flags_1.cwd, dir, file)).filter(file => file.endsWith('.js') || file.endsWith('.cjs')));
+        }
+        return modules.filter(file => !this.client.config.ignoredFiles.some(ignored => (0, wildcard_match_1.default)(ignored, path_1.default.basename(file))));
+    }
+    static getModuleDisplayId(mod) {
+        return mod.info.path && mod.info.filename ? path_1.default.join(mod.info.path, mod.info.filename) : mod.id;
+    }
+}
+exports.ClientModuleManager = ClientModuleManager;

package/dist/cjs/reciple/classes/{CommandCooldownManager.js → managers/CommandCooldownManager.js}

@@ -20,21 +20,24 @@ class CommandCooldownManager extends Array {
      * Remove cooldown from specific user, channel or guild
      * @param options Remove cooldown data options
      * @param limit Remove cooldown data limit
+     * @returns Returns the removed values
      */
     remove(options, limit = 0) {
         if (!Object.keys(options).length)
             throw new TypeError('Provide atleast one option to remove cooldown data.');
+        const removed = [];
         let i = 0;
-        for (const index in this) {
-            if (!CommandCooldownManager.checkOptions(options, this[index]))
+        for (let i = 0; i < this.length; i++) {
+            if (!CommandCooldownManager.checkOptions(options, this[i]))
                 continue;
-            if (options.expireTime && this[index].expireTime > Date.now())
+            if (options.expireTime && this[i].expireTime > Date.now())
                 continue;
             if (limit && i >= limit)
                 continue;
-            this.splice(Number(index));
-            i++;
+            removed.push(this[i]);
+            this.splice(Number(i));
         }
+        return removed;
     }
     /**
      * Check if the given user is cooled-down

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/util.js

@@ -1,6 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isClass = void 0;
+exports.validateCommandBuilder = exports.deprecationWarning = exports.isClass = void 0;
+const builders_1 = require("./types/builders");
+/**
+ * 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 +14,19 @@ 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;
+function validateCommandBuilder(command) {
+    if (!command.name)
+        return false;
+    if (command.type === builders_1.CommandBuilderType.MessageCommand && command.options.length && command.options.some(o => !o.name))
+        return false;
+    return true;
+}
+exports.validateCommandBuilder = validateCommandBuilder;

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/index.d.ts

@@ -1,10 +1,12 @@
-export * from './reciple/classes/CommandCooldownManager';
-export * from './reciple/classes/MessageCommandOptionManager';
-export * from './reciple/classes/RecipleClient';
-export * from './reciple/classes/RecipleConfig';
 export * from './reciple/classes/builders/MessageCommandBuilder';
 export * from './reciple/classes/builders/MessageCommandOptionBuilder';
 export * from './reciple/classes/builders/SlashCommandBuilder';
+export * from './reciple/classes/managers/ApplicationCommandManager';
+export * from './reciple/classes/managers/CommandCooldownManager';
+export * from './reciple/classes/managers/ClientCommandManager';
+export * from './reciple/classes/managers/MessageCommandOptionManager';
+export * from './reciple/classes/RecipleClient';
+export * from './reciple/classes/RecipleConfig';
 export * from './reciple/types/builders';
 export * from './reciple/types/commands';
 export * from './reciple/types/paramOptions';
@@ -12,6 +14,5 @@ export * from './reciple/flags';
 export * from './reciple/logger';
 export * from './reciple/modules';
 export * from './reciple/permissions';
-export * from './reciple/registerApplicationCommands';
 export * from './reciple/util';
 export * from './reciple/version';

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

@@ -1,33 +1,26 @@
 import { MessageCommandBuilder, MessageCommandExecuteData, MessageCommandHaltData } from './builders/MessageCommandBuilder';
 import { SlashCommandBuilder, SlashCommandExecuteData, SlashCommandHaltData } from './builders/SlashCommandBuilder';
-import { AnyCommandBuilder, AnyCommandData, AnySlashCommandBuilder, CommandBuilderType } from '../types/builders';
-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 { CommandCooldownManager } from './managers/CommandCooldownManager';
+import { ApplicationCommandManager } from './managers/ApplicationCommandManager';
+import { ClientCommandManager } from './managers/ClientCommandManager';
 import { Config } from './RecipleConfig';
-import { RecipleModule } from '../modules';
-import { ApplicationCommandData, Awaitable, ChatInputCommandInteraction, Client, ClientEvents, ClientOptions, Collection, Interaction, Message, RestOrArray } from 'discord.js';
+import { Logger } from 'fallout-utility';
+import { Awaitable, ChatInputCommandInteraction, Client, ClientEvents, ClientOptions, Interaction, Message } from 'discord.js';
+import { ClientModuleManager } from './managers/ClientModuleManager';
 /**
- * Options for Reciple client
+ * Options for {@link RecipleClient}
  */
 export interface RecipleClientOptions extends ClientOptions {
     config?: Config;
 }
-/**
- * Reciple client commands
- */
-export interface RecipleClientCommands {
-    slashCommands: Collection<string, AnySlashCommandBuilder>;
-    messageCommands: Collection<string, MessageCommandBuilder>;
-}
 /**
  * Reciple client events
  */
 export interface RecipleClientEvents extends ClientEvents {
     recipleCommandExecute: [executeData: AnyCommandExecuteData];
     recipleCommandHalt: [haltData: AnyCommandHaltData];
+    recipleRegisterApplicationCommands: [];
     recipleReplyError: [error: unknown];
 }
 /**
@@ -47,36 +40,17 @@ export interface RecipleClient<Ready extends boolean = boolean> extends Client<R
     isReady(): this is RecipleClient<true>;
 }
 export declare class RecipleClient<Ready extends boolean = boolean> extends Client<Ready> {
-    config: Config;
-    commands: RecipleClientCommands;
-    additionalApplicationCommands: (ApplicationCommandBuilder | ApplicationCommandData)[];
-    cooldowns: CommandCooldownManager;
-    modules: RecipleModule[];
-    logger: ILogger;
-    version: string;
+    readonly config: Config;
+    readonly commands: ClientCommandManager;
+    readonly applicationCommands: ApplicationCommandManager;
+    readonly cooldowns: CommandCooldownManager;
+    readonly modules: ClientModuleManager;
+    readonly logger: Logger;
+    readonly 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
-     */
-    startModules(...folders: RestOrArray<string>): Promise<RecipleClient<Ready>>;
-    /**
-     * Execute `onLoad()` from client modules and register application commands if enabled
-     */
-    loadModules(): Promise<RecipleClient<Ready>>;
-    /**
-     * Add module
-     * @param options Module options
-     */
-    addModule(options: RecipleClientAddModuleOptions): Promise<void>;
-    /**
-     * Add slash or message command to client
-     * @param command Slash/Message command builder
-     */
-    addCommand(command: AnyCommandData | AnyCommandBuilder): RecipleClient<Ready>;
     /**
      * Listed to command executions
      */
@@ -85,32 +59,25 @@ export declare class RecipleClient<Ready extends boolean = boolean> extends Clie
      * Execute a slash command
      * @param interaction Slash command interaction
      */
-    slashCommandExecute(interaction: Interaction | ChatInputCommandInteraction): Promise<void | SlashCommandExecuteData>;
+    slashCommandExecute(interaction: Interaction | ChatInputCommandInteraction): Promise<undefined | SlashCommandExecuteData>;
     /**
      * Execute a Message command
      * @param message Message command executor
      * @param prefix Message command prefix
      */
-    messageCommandExecute(message: Message, prefix?: string): Promise<void | MessageCommandExecuteData>;
+    messageCommandExecute(message: Message, prefix?: string): Promise<undefined | MessageCommandExecuteData>;
     /**
      * Get a message from config
      * @param messageKey Config messages key
      * @param defaultMessage Default message when the key does not exists
      */
     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
-     * @param type Command type
-     */
-    findCommand(command: string, type: CommandBuilderType.MessageCommand): MessageCommandBuilder | undefined;
-    findCommand(command: string, type: CommandBuilderType.SlashCommand): SlashCommandBuilder | undefined;
     /**
      * Returns true if client logs is enabled
      */
     isClientLogsEnabled(): boolean;
     /**
-     * Emits the "recipleReplyError" event
+     * Emits the {@link RecipleClientEvents["recipleReplyError"]} event
      * @param error Received Error
      */
     protected _replyError(error: unknown): void;
@@ -122,12 +89,12 @@ 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
      */
-    protected _executeCommand(command: SlashCommandBuilder, executeData: SlashCommandExecuteData): Promise<SlashCommandExecuteData | void>;
-    protected _executeCommand(command: MessageCommandBuilder, executeData: MessageCommandExecuteData): Promise<MessageCommandExecuteData | void>;
+    protected _executeCommand(command: SlashCommandBuilder, executeData: SlashCommandExecuteData): Promise<SlashCommandExecuteData | undefined>;
+    protected _executeCommand(command: MessageCommandBuilder, executeData: MessageCommandExecuteData): Promise<MessageCommandExecuteData | undefined>;
     /**
      * Error message when a command fails to execute
      * @param err Received error

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

@@ -1,44 +1,71 @@
 import { CommandBuilderType, CommandHaltFunction, CommandExecuteFunction, SharedCommandBuilderProperties, MessageCommandData } from '../../types/builders';
 import { Message, PermissionResolvable, RestOrArray } from 'discord.js';
 import { BaseCommandExecuteData, CommandHaltData } from '../../types/commands';
-import { MessageCommandOptionManager } from '../MessageCommandOptionManager';
+import { MessageCommandOptionManager } from '../managers/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;
 }