reciple 6.0.0-dev.20 → 6.0.0-dev.22

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

@@ -1,8 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.RecipleClient = void 0;
-const MessageCommandBuilder_1 = require("./builders/MessageCommandBuilder");
 const discord_js_1 = require("discord.js");
+const MessageCommandBuilder_1 = require("./builders/MessageCommandBuilder");
 const SlashCommandBuilder_1 = require("./builders/SlashCommandBuilder");
 const commands_1 = require("../types/commands");
 const CommandCooldownManager_1 = require("./managers/CommandCooldownManager");
@@ -135,7 +135,7 @@ class RecipleClient extends discord_js_1.Client {
         const command = this.commands.get(parseCommand.command, builders_1.CommandType.MessageCommand);
         if (!command)
             return;
-        const commandOptions = await (0, MessageCommandBuilder_1.validateMessageCommandOptions)(command, parseCommand);
+        const commandOptions = await MessageCommandBuilder_1.MessageCommandBuilder.validateOptions(command, parseCommand);
         const executeData = {
             message: message,
             options: commandOptions,

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

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.validateMessageCommandOptions = exports.MessageCommandBuilder = void 0;
+exports.MessageCommandBuilder = void 0;
 const builders_1 = require("../../types/builders");
 const discord_js_1 = require("discord.js");
 const MessageCommandOptionManager_1 = require("../managers/MessageCommandOptionManager");
@@ -11,17 +11,17 @@ const MessageCommandOptionBuilder_1 = require("./MessageCommandOptionBuilder");
 class MessageCommandBuilder {
     constructor(data) {
         this.type = builders_1.CommandType.MessageCommand;
-        this.name = '';
-        this.description = '';
-        this.cooldown = 0;
-        this.aliases = [];
-        this.validateOptions = false;
-        this.options = [];
-        this.requiredBotPermissions = [];
-        this.requiredMemberPermissions = [];
-        this.allowExecuteInDM = true;
-        this.allowExecuteByBots = false;
-        this.execute = () => {
+        this._name = '';
+        this._description = '';
+        this._cooldown = 0;
+        this._aliases = [];
+        this._validateOptions = false;
+        this._options = [];
+        this._requiredBotPermissions = [];
+        this._requiredMemberPermissions = [];
+        this._allowExecuteInDM = true;
+        this._allowExecuteByBots = false;
+        this._execute = () => {
             /* Execute */
         };
         if (data?.name !== undefined)
@@ -51,14 +51,86 @@ class MessageCommandBuilder {
         if (data?.options !== undefined)
             this.options = data.options.map(o => (o instanceof MessageCommandOptionBuilder_1.MessageCommandOptionBuilder ? o : new MessageCommandOptionBuilder_1.MessageCommandOptionBuilder(o)));
     }
+    get name() {
+        return this._name;
+    }
+    get description() {
+        return this._description;
+    }
+    get cooldown() {
+        return this._cooldown;
+    }
+    get aliases() {
+        return this._aliases;
+    }
+    get validateOptions() {
+        return this._validateOptions;
+    }
+    get options() {
+        return this._options;
+    }
+    get requiredBotPermissions() {
+        return this._requiredBotPermissions;
+    }
+    get requiredMemberPermissions() {
+        return this._requiredMemberPermissions;
+    }
+    get allowExecuteInDM() {
+        return this._allowExecuteInDM;
+    }
+    get allowExecuteByBots() {
+        return this._allowExecuteByBots;
+    }
+    get halt() {
+        return this._halt;
+    }
+    get execute() {
+        return this._execute;
+    }
+    set name(name) {
+        this.setName(name);
+    }
+    set description(description) {
+        this.setDescription(description);
+    }
+    set cooldown(cooldown) {
+        this.setCooldown(cooldown);
+    }
+    set aliases(aliases) {
+        this.addAliases(aliases);
+    }
+    set validateOptions(validate) {
+        this.setValidateOptions(validate);
+    }
+    set options(options) {
+        this.setOptions(options);
+    }
+    set requiredBotPermissions(permissions) {
+        this.setRequiredBotPermissions(permissions);
+    }
+    set requiredMemberPermissions(permissions) {
+        this.setRequiredMemberPermissions(permissions);
+    }
+    set allowExecuteInDM(allow) {
+        this.setAllowExecuteInDM(allow);
+    }
+    set allowExecuteByBots(allow) {
+        this.setAllowExecuteByBots(allow);
+    }
+    set halt(halt) {
+        this.setHalt(halt);
+    }
+    set execute(execute) {
+        this.setExecute(execute);
+    }
     /**
      * Sets the command name
      * @param name Command name
      */
     setName(name) {
-        if (!name || typeof name !== 'string' || !name.match(/^[\w-]{1,32}$/))
+        if ((0, discord_js_1.isValidationEnabled)() && (!name || typeof name !== 'string' || !name.match(/^[\w-]{1,32}$/)))
             throw new TypeError('name must be a string and match the regex /^[\\w-]{1,32}$/');
-        this.name = name;
+        this._name = name;
         return this;
     }
     /**
@@ -66,9 +138,9 @@ class MessageCommandBuilder {
      * @param description Command description
      */
     setDescription(description) {
-        if (!description || typeof description !== 'string')
+        if ((0, discord_js_1.isValidationEnabled)() && (!description || typeof description !== 'string'))
             throw new TypeError('description must be a string.');
-        this.description = description;
+        this._description = description;
         return this;
     }
     /**
@@ -83,17 +155,23 @@ class MessageCommandBuilder {
             throw new TypeError('aliases must be strings and should not contain whitespaces');
         if (this.name && aliases.some(a => a == this.name))
             throw new TypeError('alias cannot have same name to its real command name');
-        this.aliases = [...new Set(aliases.map(s => s.toLowerCase()))];
+        this._aliases = [...new Set(aliases.map(s => s.toLowerCase()))];
         return this;
     }
+    /**
+     * Replace aliases from command builder
+     * @param aliases Command aliases
+     */
+    setAliases(...aliases) {
+        this._aliases = [];
+        return this.addAliases(...aliases);
+    }
     /**
      * Set if command can be executed in dms
      * @param allowExecuteInDM `true` if the command can execute in DMs
      */
     setAllowExecuteInDM(allowExecuteInDM) {
-        if (typeof allowExecuteInDM !== 'boolean')
-            throw new TypeError('allowExecuteInDM must be a boolean.');
-        this.allowExecuteInDM = allowExecuteInDM;
+        this._allowExecuteInDM = !!allowExecuteInDM;
         return this;
     }
     /**
@@ -101,56 +179,62 @@ class MessageCommandBuilder {
      * @param allowExecuteByBots `true` if the command can be executed by bots
      */
     setAllowExecuteByBots(allowExecuteByBots) {
-        if (typeof allowExecuteByBots !== 'boolean')
-            throw new TypeError('allowExecuteByBots must be a boolean.');
-        this.allowExecuteByBots = allowExecuteByBots;
+        this._allowExecuteByBots = !!allowExecuteByBots;
         return this;
     }
     /**
-     * Add option to the command
-     * @param option Message option builder
+     * Add options to command
+     * @param options Message options
      */
-    addOption(option) {
-        if (!option)
-            throw new TypeError('option must be a MessageOption.');
-        option = typeof option === 'function' ? option(new MessageCommandOptionBuilder_1.MessageCommandOptionBuilder()) : option;
-        if (this.options.find(o => o.name === option.name))
-            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.push(option);
+    addOptions(...options) {
+        for (const optionResolvable of (0, discord_js_1.normalizeArray)(options)) {
+            const option = typeof optionResolvable === 'function' ? optionResolvable(new MessageCommandOptionBuilder_1.MessageCommandOptionBuilder()) : optionResolvable instanceof MessageCommandOptionBuilder_1.MessageCommandOptionBuilder ? optionResolvable : MessageCommandOptionBuilder_1.MessageCommandOptionBuilder.resolveMessageCommandOption(optionResolvable);
+            if ((0, discord_js_1.isValidationEnabled)()) {
+                if (this.options.find(o => o.name === option.name))
+                    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.push(option);
+        }
         return this;
     }
+    /**
+     * Replace options from command
+     * @params options Message options
+     */
+    setOptions(...options) {
+        this._options = [];
+        return this.addOptions(...options);
+    }
     /**
      * Validate options before executing
      * @param validateOptions `true` if the command options needs to be validated before executing
      */
     setValidateOptions(validateOptions) {
-        if (typeof validateOptions !== 'boolean')
-            throw new TypeError('validateOptions must be a boolean.');
-        this.validateOptions = validateOptions;
+        this._validateOptions = !!validateOptions;
         return this;
     }
     setCooldown(cooldown) {
-        this.cooldown = cooldown;
+        this._cooldown = cooldown;
         return this;
     }
     setRequiredBotPermissions(...permissions) {
-        this.requiredBotPermissions = (0, discord_js_1.normalizeArray)(permissions);
+        this._requiredBotPermissions = (0, discord_js_1.normalizeArray)(permissions);
         return this;
     }
     setRequiredMemberPermissions(...permissions) {
-        this.requiredMemberPermissions = (0, discord_js_1.normalizeArray)(permissions);
+        this._requiredMemberPermissions = (0, discord_js_1.normalizeArray)(permissions);
         return this;
     }
     setHalt(halt) {
-        this.halt = halt ?? undefined;
+        this._halt = halt || undefined;
         return this;
     }
     setExecute(execute) {
-        if (!execute || typeof execute !== 'function')
+        if ((0, discord_js_1.isValidationEnabled)() && (!execute || typeof execute !== 'function'))
             throw new TypeError('execute must be a function.');
-        this.execute = execute;
+        this._execute = execute;
         return this;
     }
     setMetadata(metadata) {
@@ -175,7 +259,7 @@ class MessageCommandBuilder {
             allowExecuteByBots: this.allowExecuteByBots,
             allowExecuteInDM: this.allowExecuteInDM,
             validateOptions: this.validateOptions,
-            options: this.options.map(o => o.toJSON()),
+            options: this.options.map(o => (o instanceof MessageCommandOptionBuilder_1.MessageCommandOptionBuilder ? o.toJSON() : o)),
         };
     }
     /**
@@ -199,44 +283,43 @@ class MessageCommandBuilder {
     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);
-    const optional = builder.options.filter(o => !o.required);
-    const allOptions = [...required, ...optional];
-    const result = [];
-    let i = 0;
-    for (const option of allOptions) {
-        const arg = args[i];
-        const value = {
-            name: option.name,
-            value: arg ?? undefined,
-            required: option.required,
-            invalid: false,
-            missing: false,
-        };
-        if (arg == undefined && option.required) {
-            value.missing = true;
-            result.push(value);
-            continue;
-        }
-        if (arg == undefined && !option.required) {
+    /**
+     * Validate message command options
+     * @param builder Command builder
+     * @param options Parsed command args
+     */
+    static async validateOptions(builder, options) {
+        const args = options.args || [];
+        const required = builder.options.filter(o => o.required);
+        const optional = builder.options.filter(o => !o.required);
+        const allOptions = [...required, ...optional];
+        const result = [];
+        let i = 0;
+        for (const option of allOptions) {
+            const arg = args[i];
+            const value = {
+                name: option.name,
+                value: arg ?? undefined,
+                required: !!option.required,
+                invalid: false,
+                missing: false,
+            };
+            if (arg == undefined && option.required) {
+                value.missing = true;
+                result.push(value);
+                continue;
+            }
+            if (arg == undefined && !option.required) {
+                result.push(value);
+                continue;
+            }
+            const validate = option.validator ? await Promise.resolve(option.validator(arg)) : true;
+            if (!validate)
+                value.invalid = true;
             result.push(value);
-            continue;
+            i++;
         }
-        const validate = option.validator ? await Promise.resolve(option.validator(arg)) : true;
-        if (!validate)
-            value.invalid = true;
-        result.push(value);
-        i++;
+        return new MessageCommandOptionManager_1.MessageCommandOptionManager(...result);
     }
-    return new MessageCommandOptionManager_1.MessageCommandOptionManager(...result);
 }
-exports.validateMessageCommandOptions = validateMessageCommandOptions;
+exports.MessageCommandBuilder = MessageCommandBuilder;

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

@@ -1,15 +1,15 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MessageCommandOptionBuilder = void 0;
+const discord_js_1 = require("discord.js");
 /**
  * Option builder for MessageCommandBuilder
  */
 class MessageCommandOptionBuilder {
     constructor(data) {
-        this.name = '';
-        this.description = '';
-        this.required = false;
-        this.validator = () => true;
+        this._name = '';
+        this._description = '';
+        this._required = false;
         if (data?.name !== undefined)
             this.setName(data.name);
         if (data?.description !== undefined)
@@ -19,14 +19,38 @@ class MessageCommandOptionBuilder {
         if (data?.validator !== undefined)
             this.setValidator(data.validator);
     }
+    get name() {
+        return this._name;
+    }
+    get description() {
+        return this._description;
+    }
+    get required() {
+        return this._required;
+    }
+    get validator() {
+        return this._validator;
+    }
+    set name(name) {
+        this.setName(name);
+    }
+    set description(description) {
+        this.setDescription(description);
+    }
+    set required(required) {
+        this.setRequired(required);
+    }
+    set validator(validator) {
+        this.setValidator(validator);
+    }
     /**
      * Set command option name
      * @param name Option name
      */
     setName(name) {
-        if (typeof name !== 'string' || !name.match(/^[\w-]{1,32}$/))
+        if ((0, discord_js_1.isValidationEnabled)() && (typeof name !== 'string' || !name.match(/^[\w-]{1,32}$/)))
             throw new TypeError('name must be a string and match the regex /^[\\w-]{1,32}$/.');
-        this.name = name;
+        this._name = name;
         return this;
     }
     /**
@@ -34,9 +58,9 @@ class MessageCommandOptionBuilder {
      * @param description Option description
      */
     setDescription(description) {
-        if (!description || typeof description !== 'string')
+        if ((0, discord_js_1.isValidationEnabled)() && (!description || typeof description !== 'string'))
             throw new TypeError('description must be a string.');
-        this.description = description;
+        this._description = description;
         return this;
     }
     /**
@@ -44,9 +68,7 @@ class MessageCommandOptionBuilder {
      * @param required `true` if this option is required
      */
     setRequired(required) {
-        if (typeof required !== 'boolean')
-            throw new TypeError('required must be a boolean.');
-        this.required = required;
+        this._required = !!required;
         return this;
     }
     /**
@@ -54,9 +76,9 @@ class MessageCommandOptionBuilder {
      * @param validator Custom function to validate value given for this option
      */
     setValidator(validator) {
-        if (!validator || typeof validator !== 'function')
+        if ((0, discord_js_1.isValidationEnabled)() && validator !== undefined && typeof validator !== 'function')
             throw new TypeError('validator must be a function.');
-        this.validator = validator;
+        this._validator = validator;
         return this;
     }
     toJSON() {

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

@@ -11,10 +11,10 @@ class SlashCommandBuilder extends discord_js_1.SlashCommandBuilder {
     constructor(data) {
         super();
         this.type = builders_1.CommandType.SlashCommand;
-        this.cooldown = 0;
-        this.requiredBotPermissions = [];
-        this.requiredMemberPermissions = [];
-        this.execute = () => {
+        this._cooldown = 0;
+        this._requiredBotPermissions = [];
+        this._requiredMemberPermissions = [];
+        this._execute = () => {
             /* Execute */
         };
         // TODO: WTH
@@ -50,27 +50,57 @@ class SlashCommandBuilder extends discord_js_1.SlashCommandBuilder {
             }
         }
     }
+    get cooldown() {
+        return this._cooldown;
+    }
+    get requiredBotPermissions() {
+        return this._requiredBotPermissions;
+    }
+    get requiredMemberPermissions() {
+        return this._requiredMemberPermissions;
+    }
+    get halt() {
+        return this._halt;
+    }
+    get execute() {
+        return this._execute;
+    }
+    set cooldown(cooldown) {
+        this.setCooldown(cooldown);
+    }
+    set requiredBotPermissions(permissions) {
+        this.setRequiredBotPermissions(permissions);
+    }
+    set requiredMemberPermissions(permissions) {
+        this.setRequiredMemberPermissions(permissions);
+    }
+    set halt(halt) {
+        this.setHalt(halt);
+    }
+    set execute(execute) {
+        this.setExecute(execute);
+    }
     setCooldown(cooldown) {
-        this.cooldown = cooldown;
+        this._cooldown = cooldown;
         return this;
     }
     setRequiredBotPermissions(...permissions) {
-        this.requiredBotPermissions = (0, discord_js_1.normalizeArray)(permissions);
+        this._requiredBotPermissions = (0, discord_js_1.normalizeArray)(permissions);
         return this;
     }
     setRequiredMemberPermissions(...permissions) {
-        this.requiredMemberPermissions = (0, discord_js_1.normalizeArray)(permissions);
+        this._requiredMemberPermissions = (0, discord_js_1.normalizeArray)(permissions);
         this.setDefaultMemberPermissions(this.requiredMemberPermissions.length ? new discord_js_1.PermissionsBitField(this.requiredMemberPermissions).bitfield : undefined);
         return this;
     }
     setHalt(halt) {
-        this.halt = halt ?? undefined;
+        this._halt = halt || undefined;
         return this;
     }
     setExecute(execute) {
-        if (!execute || typeof execute !== 'function')
+        if ((0, discord_js_1.isValidationEnabled)() && (!execute || typeof execute !== 'function'))
             throw new Error('execute must be a function.');
-        this.execute = execute;
+        this._execute = execute;
         return this;
     }
     setMetadata(metadata) {

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

@@ -1,5 +1,5 @@
-import { MessageCommandBuilder, MessageCommandExecuteData, MessageCommandHaltData } from './builders/MessageCommandBuilder';
 import { Awaitable, ChatInputCommandInteraction, Client, ClientEvents, ClientOptions, Interaction, Message } from 'discord.js';
+import { MessageCommandBuilder, MessageCommandExecuteData, MessageCommandHaltData } from './builders/MessageCommandBuilder';
 import { SlashCommandBuilder, SlashCommandExecuteData, SlashCommandHaltData } from './builders/SlashCommandBuilder';
 import { AnyCommandExecuteData, AnyCommandHaltData } from '../types/commands';
 import { CommandCooldownManager } from './managers/CommandCooldownManager';

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

@@ -1,4 +1,4 @@
-import { CommandType, CommandHaltFunction, CommandExecuteFunction, SharedCommandBuilderProperties, MessageCommandData } from '../../types/builders';
+import { CommandType, CommandHaltFunction, CommandExecuteFunction, SharedCommandBuilderProperties, MessageCommandData, MessageCommandOptionResolvable } from '../../types/builders';
 import { Message, PermissionResolvable, RestOrArray } from 'discord.js';
 import { BaseCommandExecuteData, CommandHaltData } from '../../types/commands';
 import { MessageCommandOptionManager } from '../managers/MessageCommandOptionManager';
@@ -67,19 +67,43 @@ export declare type MessageCommandExecuteFunction<T = unknown> = CommandExecuteF
  */
 export declare class MessageCommandBuilder<T = unknown> implements SharedCommandBuilderProperties<T> {
     readonly type = CommandType.MessageCommand;
-    name: string;
-    description: string;
-    cooldown: number;
-    aliases: string[];
-    validateOptions: boolean;
-    options: MessageCommandOptionBuilder[];
-    requiredBotPermissions: PermissionResolvable[];
-    requiredMemberPermissions: PermissionResolvable[];
-    allowExecuteInDM: boolean;
-    allowExecuteByBots: boolean;
-    halt?: MessageCommandHaltFunction<T>;
-    execute: MessageCommandExecuteFunction<T>;
+    private _name;
+    private _description;
+    private _cooldown;
+    private _aliases;
+    private _validateOptions;
+    private _options;
+    private _requiredBotPermissions;
+    private _requiredMemberPermissions;
+    private _allowExecuteInDM;
+    private _allowExecuteByBots;
+    private _halt?;
+    private _execute;
     metadata?: T;
+    get name(): typeof this._name;
+    get description(): typeof this._description;
+    get cooldown(): typeof this._cooldown;
+    get aliases(): typeof this._aliases;
+    get validateOptions(): typeof this._validateOptions;
+    get options(): typeof this._options;
+    get requiredBotPermissions(): typeof this._requiredBotPermissions;
+    get requiredMemberPermissions(): typeof this._requiredMemberPermissions;
+    get allowExecuteInDM(): typeof this._allowExecuteInDM;
+    get allowExecuteByBots(): typeof this._allowExecuteByBots;
+    get halt(): typeof this._halt;
+    get execute(): typeof this._execute;
+    set name(name: typeof this._name);
+    set description(description: typeof this._description);
+    set cooldown(cooldown: typeof this._cooldown);
+    set aliases(aliases: typeof this._aliases);
+    set validateOptions(validate: typeof this._validateOptions);
+    set options(options: MessageCommandOptionResolvable[]);
+    set requiredBotPermissions(permissions: typeof this._requiredBotPermissions);
+    set requiredMemberPermissions(permissions: typeof this._requiredMemberPermissions);
+    set allowExecuteInDM(allow: typeof this._allowExecuteInDM);
+    set allowExecuteByBots(allow: typeof this._allowExecuteByBots);
+    set halt(halt: typeof this._halt);
+    set execute(execute: typeof this._execute);
     constructor(data?: Partial<Omit<MessageCommandData<T>, 'type'>>);
     /**
      * Sets the command name
@@ -96,6 +120,11 @@ export declare class MessageCommandBuilder<T = unknown> implements SharedCommand
      * @param aliases Command aliases
      */
     addAliases(...aliases: RestOrArray<string>): this;
+    /**
+     * Replace aliases from command builder
+     * @param aliases Command aliases
+     */
+    setAliases(...aliases: RestOrArray<string>): this;
     /**
      * Set if command can be executed in dms
      * @param allowExecuteInDM `true` if the command can execute in DMs
@@ -107,10 +136,15 @@ export declare class MessageCommandBuilder<T = unknown> implements SharedCommand
      */
     setAllowExecuteByBots(allowExecuteByBots: boolean): this;
     /**
-     * Add option to the command
-     * @param option Message option builder
+     * Add options to command
+     * @param options Message options
+     */
+    addOptions(...options: RestOrArray<MessageCommandOptionResolvable | ((builder: MessageCommandOptionBuilder) => MessageCommandOptionBuilder)>): this;
+    /**
+     * Replace options from command
+     * @params options Message options
      */
-    addOption(option: MessageCommandOptionBuilder | ((constructor: MessageCommandOptionBuilder) => MessageCommandOptionBuilder)): this;
+    setOptions(...options: RestOrArray<MessageCommandOptionResolvable | ((builder: MessageCommandOptionBuilder) => MessageCommandOptionBuilder)>): this;
     /**
      * Validate options before executing
      * @param validateOptions `true` if the command options needs to be validated before executing
@@ -141,10 +175,10 @@ export declare class MessageCommandBuilder<T = unknown> implements SharedCommand
      * @param executeData data to check
      */
     static isMessageCommandExecuteData(executeData: unknown): executeData is MessageCommandExecuteData;
+    /**
+     * Validate message command options
+     * @param builder Command builder
+     * @param options Parsed command args
+     */
+    static validateOptions(builder: MessageCommandBuilder, options: Command): 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

@@ -1,13 +1,21 @@
-import { MessageCommandOptionData } from '../../types/builders';
+import { MessageCommandOptionData, MessageCommandOptionResolvable } from '../../types/builders';
 import { Awaitable } from 'discord.js';
 /**
  * Option builder for MessageCommandBuilder
  */
 export declare class MessageCommandOptionBuilder {
-    name: string;
-    description: string;
-    required: boolean;
-    validator: (value: string) => Awaitable<boolean>;
+    private _name;
+    private _description;
+    private _required;
+    private _validator?;
+    get name(): typeof this._name;
+    get description(): typeof this._description;
+    get required(): typeof this._required;
+    get validator(): typeof this._validator;
+    set name(name: typeof this._name);
+    set description(description: typeof this._description);
+    set required(required: typeof this._required);
+    set validator(validator: typeof this._validator);
     constructor(data?: Partial<MessageCommandOptionData>);
     /**
      * Set command option name
@@ -28,13 +36,13 @@ export declare class MessageCommandOptionBuilder {
      * Set your custom function to validate given value for this option
      * @param validator Custom function to validate value given for this option
      */
-    setValidator(validator: (value: string) => Awaitable<boolean>): this;
+    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;
+    static resolveMessageCommandOption(option: MessageCommandOptionResolvable): MessageCommandOptionBuilder;
     /**
      * Is a Message command option builder
      * @param builder data to check

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

@@ -46,12 +46,22 @@ export interface SlashCommandBuilder<T = unknown> extends DiscordJsSlashCommandB
  */
 export declare class SlashCommandBuilder<T = unknown> extends DiscordJsSlashCommandBuilder implements SharedCommandBuilderProperties<T> {
     readonly type = CommandType.SlashCommand;
-    cooldown: number;
-    requiredBotPermissions: PermissionResolvable[];
-    requiredMemberPermissions: PermissionResolvable[];
-    halt?: SlashCommandHaltFunction<T>;
-    execute: SlashCommandExecuteFunction<T>;
+    private _cooldown;
+    private _requiredBotPermissions;
+    private _requiredMemberPermissions;
+    private _halt?;
+    private _execute;
     metadata?: T;
+    get cooldown(): typeof this._cooldown;
+    get requiredBotPermissions(): typeof this._requiredBotPermissions;
+    get requiredMemberPermissions(): typeof this._requiredMemberPermissions;
+    get halt(): typeof this._halt;
+    get execute(): typeof this._execute;
+    set cooldown(cooldown: typeof this._cooldown);
+    set requiredBotPermissions(permissions: typeof this._requiredBotPermissions);
+    set requiredMemberPermissions(permissions: typeof this._requiredMemberPermissions);
+    set halt(halt: typeof this._halt);
+    set execute(execute: typeof this._execute);
     constructor(data?: Partial<Omit<SlashCommandData<T>, 'type'>>);
     setCooldown(cooldown: number): this;
     setRequiredBotPermissions(...permissions: RestOrArray<PermissionResolvable>): this;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "reciple",
-  "version": "6.0.0-dev.20",
+  "version": "6.0.0-dev.22",
   "bin": "./dist/lib/bin.mjs",
   "license": "GPL-3.0",
   "type": "commonjs",
@@ -68,8 +68,8 @@
   },
   "devDependencies": {
     "@discordjs/docgen": "^0.12.1",
-    "@types/node": "^18.11.0",
-    "@types/semver": "^7.3.12",
+    "@types/node": "^18.11.7",
+    "@types/semver": "^7.3.13",
     "discord.js": "^14.6.0",
     "prettier": "2.7.1",
     "rimraf": "^3.0.2",