reciple 5.6.0 → 6.0.0-dev.2

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

@@ -0,0 +1,137 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ApplicationCommandManager = void 0;
+const discord_js_1 = require("discord.js");
+const SlashCommandBuilder_1 = require("../builders/SlashCommandBuilder");
+class ApplicationCommandManager {
+    constructor(client) {
+        this.client = client;
+    }
+    get commands() {
+        return this.client.application?.commands;
+    }
+    async set(commands, guilds) {
+        if (!this.client.isReady())
+            throw new Error('Client is not ready');
+        if (guilds && guilds.length > 1) {
+            for (const guild of guilds) {
+                await this.set(commands, [guild]);
+            }
+            return;
+        }
+        let guild = guilds?.shift();
+        guild = guild ? this.client.guilds.resolveId(guild) || undefined : undefined;
+        if (!guild) {
+            this.client.application.commands.set(commands);
+            if (!this.client.isClientLogsSilent)
+                this.client.logger.log(`Registered ${this.client.commands.applicationCommandsSize} application command(s) globally...`);
+        }
+        else {
+            this.client.application.commands.set(commands, guild);
+            if (!this.client.isClientLogsSilent)
+                this.client.logger.log(`Registered ${this.client.commands.applicationCommandsSize} application command(s) to guild ${guild}...`);
+        }
+    }
+    async add(command, guilds) {
+        if (!this.client.isReady())
+            throw new Error('Client is not ready');
+        if (!command)
+            throw new Error('Command is undefined');
+        if (guilds && guilds.length > 1) {
+            for (const guild of guilds) {
+                await this.add(command, [guild]);
+            }
+            return;
+        }
+        let guild = guilds?.shift();
+        guild = guild ? this.client.guilds.resolveId(guild) || undefined : undefined;
+        if (!guild) {
+            this.client.application.commands.create(command);
+            if (!this.client.isClientLogsSilent)
+                this.client.logger.log(`Created application command '${command.name}' globally`);
+        }
+        else {
+            this.client.application.commands.create(command, guild);
+            if (!this.client.isClientLogsSilent)
+                this.client.logger.log(`Created application command '${command.name}' to guild ${guild}`);
+        }
+    }
+    async remove(command, guilds) {
+        if (!this.client.isReady())
+            throw new Error('Client is not ready');
+        if (!command)
+            throw new Error('Command is undefined');
+        if (guilds && guilds.length > 1) {
+            for (const guild of guilds) {
+                await this.remove(command, [guild]);
+            }
+            return;
+        }
+        let guild = guilds?.shift();
+        guild = guild ? this.client.guilds.resolveId(guild) || undefined : undefined;
+        if (!guild) {
+            this.client.application.commands.delete(command);
+            if (!this.client.isClientLogsSilent)
+                this.client.logger.log(`Removed application command '${typeof command === 'string' ? command : command.name}' globally`);
+        }
+        else {
+            this.client.application.commands.delete(command, guild);
+            if (!this.client.isClientLogsSilent)
+                this.client.logger.log(`Removed application command '${typeof command === 'string' ? command : command.name}' from guild ${guild}`);
+        }
+    }
+    async edit(command, newCommand, guilds) {
+        if (!this.client.isReady())
+            throw new Error('Client is not ready');
+        if (!command)
+            throw new Error('Command is undefined');
+        if (guilds && guilds.length > 1) {
+            for (const guild of guilds) {
+                await this.edit(command, newCommand, [guild]);
+            }
+            return;
+        }
+        let guild = guilds?.shift();
+        guild = guild ? this.client.guilds.resolveId(guild) || undefined : undefined;
+        if (!guild) {
+            this.client.application.commands.edit(command, newCommand);
+            if (!this.client.isClientLogsSilent)
+                this.client.logger.log(`Removed application command '${typeof command === 'string' ? command : command.name}' globally`);
+        }
+        else {
+            this.client.application.commands.edit(command, newCommand, guild);
+            if (!this.client.isClientLogsSilent)
+                this.client.logger.log(`Removed application command '${typeof command === 'string' ? command : command.name}' from guild ${guild}`);
+        }
+    }
+    get(command, guild) {
+        const commands = guild ? this.client.guilds.resolve(guild)?.commands.cache : this.client.application?.commands.cache;
+        if (!commands)
+            throw new Error('Guild not found in cache');
+        return commands.find(cmd => typeof command === 'string' ? cmd.id === command || cmd.name === command : cmd.name === command.name || (command instanceof discord_js_1.ApplicationCommand && cmd.id === command.id));
+    }
+    async fetch(commandId, guild) {
+        const manager = guild ? this.client.guilds.resolve(guild)?.commands : this.client.application?.commands;
+        if (!manager)
+            throw new Error('Guild not found in cache');
+        return manager.fetch(commandId);
+    }
+    parseCommands(commands, setPermissions = true) {
+        return commands.map(cmd => {
+            if (cmd?.toJSON === undefined)
+                return cmd;
+            if (SlashCommandBuilder_1.SlashCommandBuilder.isSlashCommandBuilder(cmd) && this.client.config.commands.slashCommand.setRequiredPermissions) {
+                const permissions = setPermissions || this.client.config.commands.slashCommand.permissions.enabled
+                    ? this.client.config.commands.slashCommand.permissions.commands.find(cmd_ => cmd_.command.toLowerCase() === cmd.name.toLowerCase())?.permissions
+                    : undefined;
+                if (permissions) {
+                    cmd.setRequiredMemberPermissions(...permissions);
+                    if (!this.client.isClientLogsSilent)
+                        this.client.logger.debug(`Set required permissions for ${cmd.name}`);
+                }
+            }
+            return cmd.toJSON();
+        });
+    }
+}
+exports.ApplicationCommandManager = ApplicationCommandManager;

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

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ClientCommandManager = void 0;
+const discord_js_1 = require("discord.js");
+const builders_1 = require("../../types/builders");
+const MessageCommandBuilder_1 = require("../builders/MessageCommandBuilder");
+const SlashCommandBuilder_1 = require("../builders/SlashCommandBuilder");
+class ClientCommandManager {
+    constructor(options) {
+        this.slashCommands = new discord_js_1.Collection();
+        this.messageCommands = new discord_js_1.Collection();
+        this.additionalApplicationCommands = [];
+        this.client = options.client;
+        options.slashCommands?.forEach(e => this.slashCommands.set(e.name, SlashCommandBuilder_1.SlashCommandBuilder.resolveSlashCommand(e)));
+        options.messageCommands?.forEach(e => this.messageCommands.set(e.name, MessageCommandBuilder_1.MessageCommandBuilder.resolveMessageCommand(e)));
+    }
+    get applicationCommandsSize() {
+        return this.client.commands.slashCommands.size + this.client.commands.additionalApplicationCommands.length;
+    }
+    /**
+     * Add command to command manager
+     * @param commands Any command data or builder
+     */
+    add(...commands) {
+        for (const command of (0, discord_js_1.normalizeArray)(commands)) {
+            if (command.type === builders_1.CommandBuilderType.SlashCommand) {
+                this.slashCommands.set(command.name, SlashCommandBuilder_1.SlashCommandBuilder.resolveSlashCommand(command));
+            }
+            else if (command.type === builders_1.CommandBuilderType.MessageCommand) {
+                this.messageCommands.set(command.name, MessageCommandBuilder_1.MessageCommandBuilder.resolveMessageCommand(command));
+            }
+        }
+        return this;
+    }
+    get(command, type) {
+        switch (type) {
+            case builders_1.CommandBuilderType.SlashCommand:
+                return this.slashCommands.get(command);
+            case builders_1.CommandBuilderType.MessageCommand:
+                return (this.messageCommands.get(command.toLowerCase()) ??
+                    (this.client.config.commands.messageCommand.allowCommandAlias ? this.messageCommands.find(c => c.aliases.some(a => a == command?.toLowerCase())) : undefined));
+            default:
+                throw new TypeError('Unknown command type');
+        }
+    }
+    /**
+     * Register application commands
+     * @param guilds Register application commands to guilds
+     */
+    async registerApplicationCommands(...guilds) {
+        guilds = (0, discord_js_1.normalizeArray)(guilds);
+        guilds = guilds.length ? guilds : (0, discord_js_1.normalizeArray)([this.client.config.commands.slashCommand.guilds]);
+        if (!this.client.isClientLogsSilent)
+            this.client.logger.log(`Regestering ${this.applicationCommandsSize} application command(s) ${!guilds.length ? 'globaly' : 'to ' + guilds.length + ' guilds'}...`);
+        await this.client.applicationCommands.set([...this.slashCommands.toJSON(), ...this.additionalApplicationCommands], guilds);
+        this.client.emit('RegisterApplicationCommands');
+        return this;
+    }
+}
+exports.ClientCommandManager = ClientCommandManager;

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

@@ -0,0 +1,193 @@
+"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.isClientLogsSilent)
+                    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.isClientLogsSilent)
+                    this.client.logger.log(`Resolved ${file}`);
+            }
+            catch (err) {
+                if (options.dontSkipError)
+                    throw err;
+                if (!this.client.isClientLogsSilent)
+                    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.isClientLogsSilent)
+                        this.client.logger.error(`Error loading ${m.info.filename ?? 'unknown module'}:`, err);
+                    return;
+                }
+            }
+            this.client.commands.add(m.commands);
+            if (!this.client.isClientLogsSilent)
+                this.client.logger.log(`Loaded module: ${ClientModuleManager.getModuleDisplayId(m)}`);
+        }));
+        if (!this.client.isClientLogsSilent) {
+            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.isClientLogsSilent)
+            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
@@ -44,7 +47,13 @@ class CommandCooldownManager extends Array {
         const data = this.get(options);
         if (!data)
             return false;
-        this.remove({ ...data, channel: undefined, guild: undefined, type: undefined, command: undefined });
+        this.remove({
+            ...data,
+            channel: undefined,
+            guild: undefined,
+            type: undefined,
+            command: undefined,
+        });
         if (data.expireTime < Date.now())
             return false;
         return true;

package/dist/cjs/reciple/logger.js

@@ -19,17 +19,19 @@ function createLogger(stringifyJSON, debugmode = false, colorizeMessage = true)
         enableDebugMode: flags_1.flags.debugmode ?? debugmode,
         loggerName: 'Main',
         prefixes: {
-            [fallout_utility_1.LogLevels.INFO]: (name) => `[${new Date().toLocaleTimeString(undefined, { hour12: false })}][${(name ? name + "/" : '') + "INFO"}]`,
-            [fallout_utility_1.LogLevels.WARN]: (name) => `[${chalk_1.default.yellow(new Date().toLocaleTimeString(undefined, { hour12: false }))}][${chalk_1.default.yellow((name ? name + "/" : '') + "WARN")}]`,
-            [fallout_utility_1.LogLevels.ERROR]: (name) => `[${chalk_1.default.red(new Date().toLocaleTimeString(undefined, { hour12: false }))}][${chalk_1.default.red((name ? name + "/" : '') + "ERROR")}]`,
-            [fallout_utility_1.LogLevels.DEBUG]: (name) => `[${chalk_1.default.blue(new Date().toLocaleTimeString(undefined, { hour12: false }))}][${chalk_1.default.blue((name ? name + "/" : '') + "DEBUG")}]`
+            [fallout_utility_1.LogLevels.INFO]: (name) => `[${new Date().toLocaleTimeString(undefined, {
+                hour12: false,
+            })}][${(name ? name + '/' : '') + 'INFO'}]`,
+            [fallout_utility_1.LogLevels.WARN]: (name) => `[${chalk_1.default.yellow(new Date().toLocaleTimeString(undefined, { hour12: false }))}][${chalk_1.default.yellow((name ? name + '/' : '') + 'WARN')}]`,
+            [fallout_utility_1.LogLevels.ERROR]: (name) => `[${chalk_1.default.red(new Date().toLocaleTimeString(undefined, { hour12: false }))}][${chalk_1.default.red((name ? name + '/' : '') + 'ERROR')}]`,
+            [fallout_utility_1.LogLevels.DEBUG]: (name) => `[${chalk_1.default.blue(new Date().toLocaleTimeString(undefined, { hour12: false }))}][${chalk_1.default.blue((name ? name + '/' : '') + 'DEBUG')}]`,
         },
         colorMessages: {
             [fallout_utility_1.LogLevels.INFO]: (message) => message,
-            [fallout_utility_1.LogLevels.WARN]: (message) => !colorizeMessage ? message : chalk_1.default.yellow(message),
-            [fallout_utility_1.LogLevels.ERROR]: (message) => !colorizeMessage ? message : chalk_1.default.red(message),
-            [fallout_utility_1.LogLevels.DEBUG]: (message) => !colorizeMessage ? message : chalk_1.default.blue(message)
-        }
+            [fallout_utility_1.LogLevels.WARN]: (message) => (!colorizeMessage ? message : chalk_1.default.yellow(message)),
+            [fallout_utility_1.LogLevels.ERROR]: (message) => (!colorizeMessage ? message : chalk_1.default.red(message)),
+            [fallout_utility_1.LogLevels.DEBUG]: (message) => (!colorizeMessage ? message : chalk_1.default.blue(message)),
+        },
     });
 }
 exports.createLogger = createLogger;

package/dist/cjs/reciple/permissions.js

@@ -7,10 +7,9 @@ const discord_js_1 = require("discord.js");
  * @param options options
  */
 function userHasCommandPermissions(options) {
-    const command = (options.commandPermissions?.enabled
-        ? options.commandPermissions?.commands.find(c => c.command.toLowerCase() === options.builder.name.toLowerCase())
-        : null)
-        ?? { permissions: options.builder.requiredMemberPermissions };
+    const command = (options.commandPermissions?.enabled ? options.commandPermissions?.commands.find(c => c.command.toLowerCase() === options.builder.name.toLowerCase()) : null) ?? {
+        permissions: options.builder.requiredMemberPermissions,
+    };
     if (!command.permissions.length)
         return true;
     return options.memberPermissions ? options.memberPermissions.has(command.permissions) : false;

package/dist/cjs/reciple/util.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.deprecationWarning = 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
@@ -21,3 +22,11 @@ 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/types/index.d.ts

@@ -1,17 +1,18 @@
-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/ClientModuleManager';
+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';
 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,19 @@
 import { MessageCommandBuilder, MessageCommandExecuteData, MessageCommandHaltData } from './builders/MessageCommandBuilder';
+import { Awaitable, ChatInputCommandInteraction, Client, ClientEvents, ClientOptions, Interaction, Message } from 'discord.js';
 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 { CommandCooldownManager } from './managers/CommandCooldownManager';
+import { ApplicationCommandManager } from './managers/ApplicationCommandManager';
+import { ClientCommandManager } from './managers/ClientCommandManager';
+import { ClientModuleManager } from './managers/ClientModuleManager';
 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 {@link RecipleClient}
  */
 export interface RecipleClientOptions extends ClientOptions {
     config?: Config;
 }
-/**
- * Reciple client commands
- */
-export interface RecipleClientCommands {
-    /**
-     * Collection of loaded slash commands
-     */
-    slashCommands: Collection<string, AnySlashCommandBuilder>;
-    /**
-     * Collection of loaded message commands
-     */
-    messageCommands: Collection<string, MessageCommandBuilder>;
-}
 /**
  * Reciple client events
  */
@@ -54,37 +40,18 @@ 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: Logger;
-    version: string;
+    readonly config: Config;
+    readonly commands: ClientCommandManager;
+    readonly applicationCommands: ApplicationCommandManager;
+    readonly cooldowns: CommandCooldownManager;
+    readonly modules: ClientModuleManager;
+    readonly logger: Logger;
+    readonly version: string;
+    get isClientLogsSilent(): boolean;
     /**
      * @param options Client options
      */
     constructor(options: RecipleClientOptions);
-    /**
-     * Load and start modules from given folders
-     * @param folders folders that contains the modules you want to load
-     */
-    startModules(...folders: RestOrArray<string>): Promise<this>;
-    /**
-     * Execute {@link RecipleModule['onLoad']} from client modules and register application commands if enabled
-     */
-    loadModules(): Promise<this>;
-    /**
-     * Add module
-     * @param options Module options
-     * @deprecated This is very stupid, Just add it manually
-     */
-    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
      */
@@ -93,34 +60,19 @@ 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>;
-    /**
-     * Registers client slash commands and other application commands
-     */
-    registerClientApplicationCommands(): Promise<void>;
+    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 {@link RecipleClientEvents["recipleReplyError"]} event
      * @param error Received Error
@@ -138,8 +90,8 @@ export declare class RecipleClient<Ready extends boolean = boolean> extends Clie
      * @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