reciple 3.0.3 → 3.1.0

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

@@ -3,38 +3,49 @@ import { RecipleHaltedCommandData } from '../../types/commands';
 import { RecipleClient } from '../RecipleClient';
 import { SlashCommandBuilder } from '@discordjs/builders';
 import { Awaitable, ChatInputCommandInteraction, PermissionResolvable } from 'discord.js';
-export interface RecipleInteractionCommandExecuteData {
+/**
+ * Execute data for interaction command
+ */
+export interface InteractionCommandExecuteData {
     interaction: ChatInputCommandInteraction;
     builder: InteractionCommandBuilder;
     client: RecipleClient<true>;
 }
+/**
+ * Reciple builder for interaction/slash command
+ */
 export declare class InteractionCommandBuilder extends SlashCommandBuilder {
     readonly builder = RecipleCommandBuilderType.InteractionCommand;
     cooldown: number;
     requiredBotPermissions: PermissionResolvable[];
-    RequiredUserPermissions: PermissionResolvable[];
+    requiredMemberPermissions: PermissionResolvable[];
     allowExecuteInDM: boolean;
     halt?: (haltData: RecipleHaltedCommandData<InteractionCommandBuilder>) => Awaitable<boolean | void>;
-    execute: (executeData: RecipleInteractionCommandExecuteData) => Awaitable<void>;
+    execute: (executeData: InteractionCommandExecuteData) => Awaitable<void>;
     /**
      * Sets the execute cooldown for this command.
      * - `0` means no cooldown
+     * @param cooldown Command cooldown in milliseconds
      */
     setCooldown(cooldown: number): InteractionCommandBuilder;
     /**
      * Set required bot permissions to execute the command
+     * @param permissions Bot's required permissions
      */
     setRequiredBotPermissions(...permissions: PermissionResolvable[]): InteractionCommandBuilder;
     /**
      * Set required permissions to execute the command
+     * @param permissions User's return permissions
      */
     setRequiredMemberPermissions(...permissions: PermissionResolvable[]): InteractionCommandBuilder;
     /**
-     * Function when the command is interupted before execution
+     * Function when the command is interupted
+     * @param halt Function to execute when command is halted
      */
     setHalt(halt?: (haltData: RecipleHaltedCommandData<InteractionCommandBuilder>) => Awaitable<boolean | void>): InteractionCommandBuilder;
     /**
      * Function when the command is executed
+     * @param execute Function to execute when the command is called
      */
-    setExecute(execute: (executeData: RecipleInteractionCommandExecuteData) => void): InteractionCommandBuilder;
+    setExecute(execute: (executeData: InteractionCommandExecuteData) => void): InteractionCommandBuilder;
 }

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

@@ -3,19 +3,23 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.InteractionCommandBuilder = void 0;
 const builders_1 = require("../../types/builders");
 const builders_2 = require("@discordjs/builders");
+/**
+ * Reciple builder for interaction/slash command
+ */
 class InteractionCommandBuilder extends builders_2.SlashCommandBuilder {
     constructor() {
         super(...arguments);
         this.builder = builders_1.RecipleCommandBuilderType.InteractionCommand;
         this.cooldown = 0;
         this.requiredBotPermissions = [];
-        this.RequiredUserPermissions = [];
+        this.requiredMemberPermissions = [];
         this.allowExecuteInDM = true;
         this.execute = () => { };
     }
     /**
      * Sets the execute cooldown for this command.
      * - `0` means no cooldown
+     * @param cooldown Command cooldown in milliseconds
      */
     setCooldown(cooldown) {
         this.cooldown = cooldown;
@@ -23,6 +27,7 @@ class InteractionCommandBuilder extends builders_2.SlashCommandBuilder {
     }
     /**
      * Set required bot permissions to execute the command
+     * @param permissions Bot's required permissions
      */
     setRequiredBotPermissions(...permissions) {
         this.requiredBotPermissions = permissions;
@@ -30,13 +35,15 @@ class InteractionCommandBuilder extends builders_2.SlashCommandBuilder {
     }
     /**
      * Set required permissions to execute the command
+     * @param permissions User's return permissions
      */
     setRequiredMemberPermissions(...permissions) {
-        this.RequiredUserPermissions = permissions;
+        this.requiredMemberPermissions = permissions;
         return this;
     }
     /**
-     * Function when the command is interupted before execution
+     * Function when the command is interupted
+     * @param halt Function to execute when command is halted
      */
     setHalt(halt) {
         this.halt = halt ? halt : undefined;
@@ -44,6 +51,7 @@ class InteractionCommandBuilder extends builders_2.SlashCommandBuilder {
     }
     /**
      * Function when the command is executed
+     * @param execute Function to execute when the command is called
      */
     setExecute(execute) {
         if (!execute || typeof execute !== 'function')

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

@@ -5,13 +5,19 @@ import { RecipleClient } from '../RecipleClient';
 import { MessageCommandOptionBuilder } from './MessageCommandOptionBuilder';
 import { Awaitable, Message, PermissionResolvable } from 'discord.js';
 import { Command as CommandMessage } from 'fallout-utility';
-export interface RecipleMessageCommandExecuteData {
+/**
+ * Execute data for message command
+ */
+export interface MessageCommandExecuteData {
     message: Message;
     options: MessageCommandOptionManager;
     command: CommandMessage;
     builder: MessageCommandBuilder;
     client: RecipleClient<true>;
 }
+/**
+ * Validated message command option
+ */
 export interface MessageCommandValidatedOption {
     name: string;
     value: string | undefined;
@@ -19,6 +25,9 @@ export interface MessageCommandValidatedOption {
     invalid: boolean;
     missing: boolean;
 }
+/**
+ * Reciple builder for message command
+ */
 export declare class MessageCommandBuilder {
     readonly builder = RecipleCommandBuilderType.MessageCommand;
     name: string;
@@ -28,62 +37,77 @@ export declare class MessageCommandBuilder {
     options: MessageCommandOptionBuilder[];
     validateOptions: boolean;
     requiredBotPermissions: PermissionResolvable[];
-    RequiredUserPermissions: PermissionResolvable[];
+    requiredMemberPermissions: PermissionResolvable[];
     allowExecuteInDM: boolean;
     allowExecuteByBots: boolean;
     halt?: (haltData: RecipleHaltedCommandData<MessageCommandBuilder>) => Awaitable<boolean | void>;
-    execute: (executeData: RecipleMessageCommandExecuteData) => void;
+    execute: (executeData: MessageCommandExecuteData) => void;
     /**
      * Sets the command name
+     * @param name Command name
      */
     setName(name: string): MessageCommandBuilder;
     /**
      * Sets the command description
+     * @param description Command description
      */
     setDescription(description: string): MessageCommandBuilder;
     /**
      * Sets the execute cooldown for this command.
      * - `0` means no cooldown
+     * @param cooldown Command cooldown in milliseconds
      */
     setCooldown(cooldown: number): MessageCommandBuilder;
     /**
      * Add aliases to the command
+     * @param aliases Command aliases
      */
     addAliases(...aliases: string[]): MessageCommandBuilder;
     /**
      * Set required bot permissions to execute the command
+     * @param permissions Bot's required permissions
      */
     setRequiredBotPermissions(...permissions: PermissionResolvable[]): MessageCommandBuilder;
     /**
-     * Set required user permissions to execute the command
+     * Set required permissions to execute the command
+     * @param permissions User's return permissions
      */
     setRequiredMemberPermissions(...permissions: PermissionResolvable[]): MessageCommandBuilder;
     /**
      * Set if command can be executed in dms
+     * @param allowExecuteInDM `true` if the command can execute in DMs
      */
     setAllowExecuteInDM(allowExecuteInDM: boolean): MessageCommandBuilder;
     /**
      * Allow command to be executed by bots
+     * @param allowExecuteByBots `true` if the command can be executed by bots
      */
     setAllowExecuteByBots(allowExecuteByBots: boolean): MessageCommandBuilder;
     /**
-     * Function when the command is interupted before execution
+     * Function when the command is interupted
+     * @param halt Function to execute when command is halted
      */
     setHalt(halt?: (haltData: RecipleHaltedCommandData<MessageCommandBuilder>) => Awaitable<boolean | void>): MessageCommandBuilder;
     /**
      * Function when the command is executed
+     * @param execute Function to execute when the command is called
      */
-    setExecute(execute: (executeData: RecipleMessageCommandExecuteData) => void): MessageCommandBuilder;
+    setExecute(execute: (executeData: MessageCommandExecuteData) => void): MessageCommandBuilder;
     /**
      * Add option to the command
+     * @param option Message option builder
      */
     addOption(option: MessageCommandOptionBuilder | ((constructor: MessageCommandOptionBuilder) => MessageCommandOptionBuilder)): MessageCommandBuilder;
     /**
      * Validate options before executing
+     * @param validateOptions `true` if the command options needs to be validated before executing
      */
     setValidateOptions(validateOptions: boolean): MessageCommandBuilder;
     /**
      * validate given command options
+     * @deprecated use `validateMessageCommandOptions()` instead
+     * @param options Parsed message command data
      */
-    getCommandOptionValues(options: CommandMessage): MessageCommandValidatedOption[];
+    getCommandOptionValues(options: CommandMessage): MessageCommandOptionManager;
 }
+export declare function validateMessageCommandOptions(builder: MessageCommandBuilder, options: CommandMessage): MessageCommandOptionManager;

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

@@ -1,8 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.MessageCommandBuilder = void 0;
+exports.validateMessageCommandOptions = exports.MessageCommandBuilder = void 0;
 const builders_1 = require("../../types/builders");
+const MessageCommandOptionManager_1 = require("../MessageCommandOptionManager");
 const MessageCommandOptionBuilder_1 = require("./MessageCommandOptionBuilder");
+/**
+ * Reciple builder for message command
+ */
 class MessageCommandBuilder {
     constructor() {
         this.builder = builders_1.RecipleCommandBuilderType.MessageCommand;
@@ -13,13 +17,14 @@ class MessageCommandBuilder {
         this.options = [];
         this.validateOptions = false;
         this.requiredBotPermissions = [];
-        this.RequiredUserPermissions = [];
+        this.requiredMemberPermissions = [];
         this.allowExecuteInDM = true;
         this.allowExecuteByBots = false;
         this.execute = () => { };
     }
     /**
      * Sets the command name
+     * @param name Command name
      */
     setName(name) {
         if (!name || typeof name !== 'string' || !name.match(/^[\w-]{1,32}$/))
@@ -29,6 +34,7 @@ class MessageCommandBuilder {
     }
     /**
      * Sets the command description
+     * @param description Command description
      */
     setDescription(description) {
         if (!description || typeof description !== 'string')
@@ -39,6 +45,7 @@ class MessageCommandBuilder {
     /**
      * Sets the execute cooldown for this command.
      * - `0` means no cooldown
+     * @param cooldown Command cooldown in milliseconds
      */
     setCooldown(cooldown) {
         this.cooldown = cooldown;
@@ -46,6 +53,7 @@ class MessageCommandBuilder {
     }
     /**
      * Add aliases to the command
+     * @param aliases Command aliases
      */
     addAliases(...aliases) {
         if (!aliases.length)
@@ -59,20 +67,23 @@ class MessageCommandBuilder {
     }
     /**
      * Set required bot permissions to execute the command
+     * @param permissions Bot's required permissions
      */
     setRequiredBotPermissions(...permissions) {
         this.requiredBotPermissions = permissions;
         return this;
     }
     /**
-     * Set required user permissions to execute the command
+     * Set required permissions to execute the command
+     * @param permissions User's return permissions
      */
     setRequiredMemberPermissions(...permissions) {
-        this.RequiredUserPermissions = permissions;
+        this.requiredMemberPermissions = permissions;
         return this;
     }
     /**
      * Set if command can be executed in dms
+     * @param allowExecuteInDM `true` if the command can execute in DMs
      */
     setAllowExecuteInDM(allowExecuteInDM) {
         if (typeof allowExecuteInDM !== 'boolean')
@@ -82,6 +93,7 @@ class MessageCommandBuilder {
     }
     /**
      * Allow command to be executed by bots
+     * @param allowExecuteByBots `true` if the command can be executed by bots
      */
     setAllowExecuteByBots(allowExecuteByBots) {
         if (typeof allowExecuteByBots !== 'boolean')
@@ -90,7 +102,8 @@ class MessageCommandBuilder {
         return this;
     }
     /**
-     * Function when the command is interupted before execution
+     * Function when the command is interupted
+     * @param halt Function to execute when command is halted
      */
     setHalt(halt) {
         this.halt = halt ? halt : undefined;
@@ -98,6 +111,7 @@ class MessageCommandBuilder {
     }
     /**
      * Function when the command is executed
+     * @param execute Function to execute when the command is called
      */
     setExecute(execute) {
         if (!execute || typeof execute !== 'function')
@@ -107,6 +121,7 @@ class MessageCommandBuilder {
     }
     /**
      * Add option to the command
+     * @param option Message option builder
      */
     addOption(option) {
         if (!option)
@@ -121,6 +136,7 @@ class MessageCommandBuilder {
     }
     /**
      * Validate options before executing
+     * @param validateOptions `true` if the command options needs to be validated before executing
      */
     setValidateOptions(validateOptions) {
         if (typeof validateOptions !== 'boolean')
@@ -130,39 +146,46 @@ class MessageCommandBuilder {
     }
     /**
      * validate given command options
+     * @deprecated use `validateMessageCommandOptions()` instead
+     * @param options Parsed message command data
      */
+    // TODO: Remove this on the next major update
     getCommandOptionValues(options) {
-        const args = options.args || [];
-        const required = this.options.filter(o => o.required);
-        const optional = this.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 !== null && arg !== void 0 ? 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 ? option.validator(arg) : true;
-            if (!validate)
-                value.invalid = true;
+        return validateMessageCommandOptions(this, options);
+    }
+}
+exports.MessageCommandBuilder = MessageCommandBuilder;
+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 !== null && arg !== void 0 ? arg : undefined,
+            required: option.required,
+            invalid: false,
+            missing: false
+        };
+        if (arg == undefined && option.required) {
+            value.missing = true;
             result.push(value);
-            i++;
+            continue;
         }
-        return result;
+        if (arg == undefined && !option.required) {
+            result.push(value);
+            continue;
+        }
+        const validate = option.validator ? option.validator(arg) : true;
+        if (!validate)
+            value.invalid = true;
+        result.push(value);
+        i++;
     }
+    return new MessageCommandOptionManager_1.MessageCommandOptionManager(result);
 }
-exports.MessageCommandBuilder = MessageCommandBuilder;
+exports.validateMessageCommandOptions = validateMessageCommandOptions;

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

@@ -1,3 +1,6 @@
+/**
+ * Option builder for MessageCommandBuilder
+ */
 export declare class MessageCommandOptionBuilder {
     name: string;
     description: string;
@@ -5,18 +8,22 @@ export declare class MessageCommandOptionBuilder {
     validator: (value: string) => boolean;
     /**
      * Set command option name
+     * @param name Option name
      */
     setName(name: string): MessageCommandOptionBuilder;
     /**
      * Set command option description
+     * @param description Option description
      */
     setDescription(description: string): MessageCommandOptionBuilder;
     /**
      * Set if this option is required
+     * @param required `true` if this option is required
      */
     setRequired(required: boolean): 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) => boolean): MessageCommandOptionBuilder;
 }

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

@@ -1,6 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MessageCommandOptionBuilder = void 0;
+/**
+ * Option builder for MessageCommandBuilder
+ */
 class MessageCommandOptionBuilder {
     constructor() {
         this.name = '';
@@ -10,6 +13,7 @@ class MessageCommandOptionBuilder {
     }
     /**
      * Set command option name
+     * @param name Option name
      */
     setName(name) {
         if (typeof name !== 'string' || !name.match(/^[\w-]{1,32}$/))
@@ -19,6 +23,7 @@ class MessageCommandOptionBuilder {
     }
     /**
      * Set command option description
+     * @param description Option description
      */
     setDescription(description) {
         if (!description || typeof description !== 'string')
@@ -28,6 +33,7 @@ class MessageCommandOptionBuilder {
     }
     /**
      * Set if this option is required
+     * @param required `true` if this option is required
      */
     setRequired(required) {
         if (typeof required !== 'boolean')
@@ -37,6 +43,7 @@ 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) {
         if (!validator || typeof validator !== 'function')

package/bin/reciple/logger.d.ts

@@ -1,5 +1,16 @@
 import { Logger } from 'fallout-utility';
 /**
  * Create new logger
+ * @param stringifyJSON stringify json objects in console
+ * @param debugmode display debug messages
+ * @param colorizeMessage add logger colours to messages
+ */
+export declare function createLogger(stringifyJSON: boolean, debugmode?: boolean, colorizeMessage?: boolean): Logger;
+/**
+ * Create new logger
+ * @deprecated Use `createLogger` instead
+ * @param stringifyJSON stringify json objects in console
+ * @param debugmode display debug messages
+ * @param colorizeMessage add logger colours to messages
  */
 export declare function logger(stringifyJSON: boolean, debugmode?: boolean, colorizeMessage?: boolean): Logger;

package/bin/reciple/logger.js

@@ -3,14 +3,17 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.logger = void 0;
+exports.logger = exports.createLogger = void 0;
 const flags_1 = require("./flags");
 const chalk_1 = __importDefault(require("chalk"));
 const fallout_utility_1 = require("fallout-utility");
 /**
  * Create new logger
+ * @param stringifyJSON stringify json objects in console
+ * @param debugmode display debug messages
+ * @param colorizeMessage add logger colours to messages
  */
-function logger(stringifyJSON, debugmode = false, colorizeMessage = true) {
+function createLogger(stringifyJSON, debugmode = false, colorizeMessage = true) {
     var _a;
     return new fallout_utility_1.Logger({
         stringifyJSON: stringifyJSON,
@@ -30,4 +33,17 @@ function logger(stringifyJSON, debugmode = false, colorizeMessage = true) {
         }
     });
 }
+exports.createLogger = createLogger;
+/**
+ * Create new logger
+ * @deprecated Use `createLogger` instead
+ * @param stringifyJSON stringify json objects in console
+ * @param debugmode display debug messages
+ * @param colorizeMessage add logger colours to messages
+ */
+// TODO: Remove this on next major release
+function logger(stringifyJSON, debugmode = false, colorizeMessage = true) {
+    process.emitWarning('logger() is deprecated use createLogger() instead', 'DeprecationWarning');
+    return createLogger(stringifyJSON, debugmode, colorizeMessage);
+}
 exports.logger = logger;

package/bin/reciple/modules.d.ts

@@ -1,15 +1,21 @@
 import { RecipleClient } from './classes/RecipleClient';
-import { RecipleCommandBuilders } from './types/builders';
+import { RecipleCommandBuilder } from './types/builders';
 export declare type LoadedModules = {
-    commands: RecipleCommandBuilders[];
+    commands: RecipleCommandBuilder[];
     modules: RecipleModule[];
 };
+/**
+ * Reciple script object interface
+ */
 export declare class RecipleScript {
     versions: string | string[];
-    commands?: RecipleCommandBuilders[];
+    commands?: RecipleCommandBuilder[];
     onLoad?(reciple: RecipleClient): void | Promise<void>;
     onStart(reciple: RecipleClient): boolean | Promise<boolean>;
 }
+/**
+ * Reciple module object interface
+ */
 export interface RecipleModule {
     script: RecipleScript;
     info: {
@@ -20,5 +26,7 @@ export interface RecipleModule {
 }
 /**
  * Load modules from folder
+ * @param client Reciple client
+ * @param folder Modules folder
  */
 export declare function loadModules(client: RecipleClient, folder?: string): Promise<LoadedModules>;

package/bin/reciple/modules.js

@@ -20,6 +20,8 @@ const path_1 = __importDefault(require("path"));
 const wildcard_match_1 = __importDefault(require("wildcard-match"));
 /**
  * Load modules from folder
+ * @param client Reciple client
+ * @param folder Modules folder
  */
 function loadModules(client, folder) {
     var _a, _b;

package/bin/reciple/permissions.d.ts

@@ -1,15 +1,20 @@
 import { Config } from './classes/RecipleConfig';
-import { RecipleCommandBuilders } from './types/builders';
-import { Guild, PermissionResolvable, PermissionsBitField } from 'discord.js';
+import { RecipleUserHasCommandPermissionsOptions } from './types/paramOptions';
+import { Guild, PermissionResolvable } from 'discord.js';
 /**
  * Check if the user has permissions to execute the given command name
+ * @param options options
  */
-export declare function userHasCommandPermissions(commandName: string, memberPermissions?: PermissionsBitField, configConmmandPermissions?: Config['commands']['messageCommand']['permissions'] | Config['commands']['interactionCommand']['permissions'], builder?: RecipleCommandBuilders): boolean;
+export declare function userHasCommandPermissions(options: RecipleUserHasCommandPermissionsOptions): boolean;
 /**
  * Check if the bot has the required permissions in a guild
+ * @param guild Guild
+ * @param requiredPermissions Required guild bot permissions
  */
 export declare function botHasExecutePermissions(guild?: Guild, requiredPermissions?: PermissionResolvable[]): boolean;
 /**
  * Check if the channel id is ignored in config file
+ * @param channelId Check if channel id is in ignore list
+ * @param ignoredChannelsConfig Ignored channels config
  */
 export declare function isIgnoredChannel(channelId: string, ignoredChannelsConfig?: Config["ignoredChannels"]): boolean;

package/bin/reciple/permissions.js

@@ -3,29 +3,33 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.isIgnoredChannel = exports.botHasExecutePermissions = exports.userHasCommandPermissions = void 0;
 /**
  * Check if the user has permissions to execute the given command name
+ * @param options options
  */
-function userHasCommandPermissions(commandName, memberPermissions, configConmmandPermissions, builder) {
-    var _a, _b;
-    if (!(configConmmandPermissions === null || configConmmandPermissions === void 0 ? void 0 : configConmmandPermissions.enabled))
-        return true;
-    const command = (_a = configConmmandPermissions.commands.find(c => c.command.toLowerCase() === commandName.toLowerCase())) !== null && _a !== void 0 ? _a : { permissions: (_b = builder === null || builder === void 0 ? void 0 : builder.RequiredUserPermissions) !== null && _b !== void 0 ? _b : [] };
+function userHasCommandPermissions(options) {
+    var _a, _b, _c;
+    const command = (_c = (((_a = options.commandPermissions) === null || _a === void 0 ? void 0 : _a.enabled)
+        ? (_b = options.commandPermissions) === null || _b === void 0 ? void 0 : _b.commands.find(c => c.command.toLowerCase() === options.builder.name.toLowerCase())
+        : null)) !== null && _c !== void 0 ? _c : { permissions: options.builder.requiredMemberPermissions };
     if (!command.permissions.length)
         return true;
-    return memberPermissions ? memberPermissions.has(command.permissions) : false;
+    return options.memberPermissions ? options.memberPermissions.has(command.permissions) : false;
 }
 exports.userHasCommandPermissions = userHasCommandPermissions;
 /**
  * Check if the bot has the required permissions in a guild
+ * @param guild Guild
+ * @param requiredPermissions Required guild bot permissions
  */
 function botHasExecutePermissions(guild, requiredPermissions) {
-    var _a;
     if (!(requiredPermissions === null || requiredPermissions === void 0 ? void 0 : requiredPermissions.length))
         return true;
-    return (guild === null || guild === void 0 ? void 0 : guild.members.me) ? (_a = guild.members.me) === null || _a === void 0 ? void 0 : _a.permissions.has(requiredPermissions) : false;
+    return (guild === null || guild === void 0 ? void 0 : guild.members.me) ? guild.members.me.permissions.has(requiredPermissions) : false;
 }
 exports.botHasExecutePermissions = botHasExecutePermissions;
 /**
  * Check if the channel id is ignored in config file
+ * @param channelId Check if channel id is in ignore list
+ * @param ignoredChannelsConfig Ignored channels config
  */
 function isIgnoredChannel(channelId, ignoredChannelsConfig) {
     if (!(ignoredChannelsConfig === null || ignoredChannelsConfig === void 0 ? void 0 : ignoredChannelsConfig.enabled))