reciple 5.5.6 → 6.0.0-dev.1

package/dist/cjs/bin.js

@@ -12,7 +12,6 @@ const flags_1 = require("./reciple/flags");
 const fallout_utility_1 = require("fallout-utility");
 const chalk_1 = __importDefault(require("chalk"));
 require("dotenv/config");
-const discord_js_1 = require("discord.js");
 const path_1 = __importDefault(require("path"));
 const allowedFiles = ['node_modules', 'reciple.yml', 'package.json'];
 const configPath = path_1.default.join(flags_1.cwd, './reciple.yml');
@@ -34,15 +33,15 @@ const client = new RecipleClient_1.RecipleClient({ config: config, ...config.cli
 if (config.fileLogging.clientLogs)
     client.logger.info('Starting Reciple client v' + version_1.rawVersion);
 (async () => {
-    await client.startModules((0, discord_js_1.normalizeArray)([config.modulesFolder]));
+    client.addCommandListeners();
+    await client.modules.startModulesFromFiles({
+        files: await client.modules.getModuleFiles()
+    });
     client.on('ready', async () => {
+        await client.modules.loadAll(true);
         if (client.isClientLogsEnabled())
             client.logger.warn(`Logged in as ${client.user?.tag || 'Unknown'}!`);
-        client.on('cacheSweep', () => {
-            client.cooldowns.clean();
-        });
-        await client.loadModules();
-        client.addCommandListeners();
+        client.on('cacheSweep', () => client.cooldowns.clean());
     });
     client.login(config.token).catch(err => {
         if (client.isClientLogsEnabled())

package/dist/cjs/index.js

@@ -14,13 +14,15 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./reciple/classes/CommandCooldownManager"), exports);
-__exportStar(require("./reciple/classes/MessageCommandOptionManager"), exports);
-__exportStar(require("./reciple/classes/RecipleClient"), exports);
-__exportStar(require("./reciple/classes/RecipleConfig"), exports);
 __exportStar(require("./reciple/classes/builders/MessageCommandBuilder"), exports);
 __exportStar(require("./reciple/classes/builders/MessageCommandOptionBuilder"), exports);
 __exportStar(require("./reciple/classes/builders/SlashCommandBuilder"), exports);
+__exportStar(require("./reciple/classes/managers/ApplicationCommandManager"), exports);
+__exportStar(require("./reciple/classes/managers/CommandCooldownManager"), exports);
+__exportStar(require("./reciple/classes/managers/ClientCommandManager"), exports);
+__exportStar(require("./reciple/classes/managers/MessageCommandOptionManager"), exports);
+__exportStar(require("./reciple/classes/RecipleClient"), exports);
+__exportStar(require("./reciple/classes/RecipleConfig"), exports);
 __exportStar(require("./reciple/types/builders"), exports);
 __exportStar(require("./reciple/types/commands"), exports);
 __exportStar(require("./reciple/types/paramOptions"), exports);
@@ -28,6 +30,5 @@ __exportStar(require("./reciple/flags"), exports);
 __exportStar(require("./reciple/logger"), exports);
 __exportStar(require("./reciple/modules"), exports);
 __exportStar(require("./reciple/permissions"), exports);
-__exportStar(require("./reciple/registerApplicationCommands"), exports);
 __exportStar(require("./reciple/util"), exports);
 __exportStar(require("./reciple/version"), exports);

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

@@ -6,20 +6,21 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.RecipleClient = void 0;
 const MessageCommandBuilder_1 = require("./builders/MessageCommandBuilder");
 const SlashCommandBuilder_1 = require("./builders/SlashCommandBuilder");
-const builders_1 = require("../types/builders");
-const registerApplicationCommands_1 = require("../registerApplicationCommands");
 const commands_1 = require("../types/commands");
+const CommandCooldownManager_1 = require("./managers/CommandCooldownManager");
 const permissions_1 = require("../permissions");
-const CommandCooldownManager_1 = require("./CommandCooldownManager");
-const MessageCommandOptionManager_1 = require("./MessageCommandOptionManager");
-const fallout_utility_1 = require("fallout-utility");
+const MessageCommandOptionManager_1 = require("./managers/MessageCommandOptionManager");
+const ApplicationCommandManager_1 = require("./managers/ApplicationCommandManager");
+const builders_1 = require("../types/builders");
+const ClientCommandManager_1 = require("./managers/ClientCommandManager");
 const RecipleConfig_1 = require("./RecipleConfig");
-const modules_1 = require("../modules");
+const fallout_utility_1 = require("fallout-utility");
 const logger_1 = require("../logger");
 const version_1 = require("../version");
 const flags_1 = require("../flags");
 const path_1 = __importDefault(require("path"));
 const discord_js_1 = require("discord.js");
+const ClientModuleManager_1 = require("./managers/ClientModuleManager");
 class RecipleClient extends discord_js_1.Client {
     /**
      * @param options Client options
@@ -27,139 +28,28 @@ class RecipleClient extends discord_js_1.Client {
     constructor(options) {
         super(options);
         this.config = RecipleConfig_1.RecipleConfig.getDefaultConfig();
-        this.commands = { slashCommands: new discord_js_1.Collection(), messageCommands: new discord_js_1.Collection() };
-        this.additionalApplicationCommands = [];
+        this.commands = new ClientCommandManager_1.ClientCommandManager({ client: this });
         this.cooldowns = new CommandCooldownManager_1.CommandCooldownManager();
-        this.modules = [];
+        this.modules = new ClientModuleManager_1.ClientModuleManager({ client: this });
         this.version = version_1.version;
         this.logger = (0, logger_1.createLogger)(!!options.config?.fileLogging.stringifyLoggedJSON, options.config?.fileLogging.debugmode);
-        if (!options.config)
-            throw new Error('Config is not defined.');
         this.config = { ...this.config, ...(options.config ?? {}) };
         if (this.config.fileLogging.enabled)
             this.logger.logFile(path_1.default.join(flags_1.cwd, this.config.fileLogging.logFilePath ?? 'logs/latest.log'), false);
-    }
-    /**
-     * Load modules from modules folder
-     * @param folders List of folders that contains the modules you want to load
-     */
-    async startModules(...folders) {
-        folders = (0, discord_js_1.normalizeArray)(folders).map(f => path_1.default.join(flags_1.cwd, f));
-        for (const folder of folders) {
-            if (this.isClientLogsEnabled())
-                this.logger.info(`Loading Modules from ${folder}`);
-            const modules = await (0, modules_1.getModules)(this, folder).catch(() => null);
-            if (!modules) {
-                if (this.isClientLogsEnabled())
-                    this.logger.error(`Failed to load modules from ${folder}`);
-                continue;
-            }
-            this.modules.push(...modules.modules);
-        }
-        return this;
-    }
-    /**
-     * Execute `onLoad()` from client modules and register application commands if enabled
-     */
-    async loadModules() {
-        for (const m in this.modules) {
-            const index = (m);
-            const module_ = this.modules[index];
-            try {
-                if (typeof module_.script?.onLoad === 'function') {
-                    await Promise.resolve(module_.script.onLoad(this)).catch(err => {
-                        if (this.isClientLogsEnabled()) {
-                            this.logger.error(`Error loading ${module_.info.filename ?? 'unknown module'}:`);
-                            this.logger.error(err);
-                        }
-                        this.modules.splice(index);
-                    });
-                }
-            }
-            catch (err) {
-                if (this.isClientLogsEnabled()) {
-                    this.logger.error(`Error loading ${module_.info.filename ?? 'unknown module'}:`);
-                    this.logger.error(err);
-                }
-                this.modules.splice(index);
-            }
-            if (module_.script?.commands && Array.isArray(module_.script?.commands)) {
-                for (const command of module_.script.commands) {
-                    this.addCommand(command);
-                }
-            }
-        }
-        if (this.isClientLogsEnabled()) {
-            this.logger.info(`${this.modules.length} modules loaded.`);
-            this.logger.info(`${this.commands.messageCommands.size} message commands loaded.`);
-            this.logger.info(`${this.commands.slashCommands.size} slash commands loaded.`);
-        }
-        if (this.config.commands.slashCommand.registerCommands) {
-            await (0, registerApplicationCommands_1.registerApplicationCommands)({
-                client: this,
-                commands: [...this.commands.slashCommands.toJSON(), ...this.additionalApplicationCommands],
-                guilds: this.config.commands.slashCommand.guilds
-            });
-        }
-        return this;
-    }
-    /**
-     * Add module
-     * @param options Module options
-     */
-    async addModule(options) {
-        const { script } = options;
-        const registerCommands = options.registerApplicationCommands;
-        const info = options.moduleInfo;
-        this.modules.push({
-            script,
-            info: {
-                filename: undefined,
-                versions: typeof script.versions == 'string' ? [script.versions] : script.versions,
-                path: undefined,
-                ...info
-            }
-        });
-        if (typeof script?.onLoad === 'function')
-            await Promise.resolve(script.onLoad(this));
-        if (this.isClientLogsEnabled())
-            this.logger.info(`${this.modules.length} modules loaded.`);
-        for (const command of script.commands ?? []) {
-            if (!command.name)
-                continue;
-            this.addCommand(command);
-        }
-        if (registerCommands)
-            await (0, registerApplicationCommands_1.registerApplicationCommands)({
-                client: this,
-                commands: [...this.commands.slashCommands.toJSON(), ...this.additionalApplicationCommands],
-                guilds: this.config.commands.slashCommand.guilds
-            });
-    }
-    /**
-     * Add slash or message command to client
-     * @param command Slash/Message command builder
-     */
-    addCommand(command) {
-        if (command.type === builders_1.CommandBuilderType.SlashCommand) {
-            this.commands.slashCommands.set(command.name, SlashCommandBuilder_1.SlashCommandBuilder.resolveSlashCommand(command));
-        }
-        else if (command.type === builders_1.CommandBuilderType.MessageCommand) {
-            this.commands.messageCommands.set(command.name, MessageCommandBuilder_1.MessageCommandBuilder.resolveMessageCommand(command));
-        }
-        else if (this.isClientLogsEnabled()) {
-            this.logger.error(`Unknow command "${typeof command ?? 'unknown'}".`);
-        }
-        return this;
+        this.applicationCommands = new ApplicationCommandManager_1.ApplicationCommandManager(this);
     }
     /**
      * Listed to command executions
      */
     addCommandListeners() {
-        if (this.config.commands.messageCommand.enabled)
-            this.on('messageCreate', (message) => { this.messageCommandExecute(message); });
-        if (this.config.commands.slashCommand.enabled)
-            this.on('interactionCreate', (interaction) => { this.slashCommandExecute(interaction); });
+        this.on('messageCreate', (message) => {
+            if (this.config.commands.messageCommand.enabled)
+                this.messageCommandExecute(message);
+        });
+        this.on('interactionCreate', (interaction) => {
+            if (this.config.commands.slashCommand.enabled)
+                this.slashCommandExecute(interaction);
+        });
         return this;
     }
     /**
@@ -171,7 +61,7 @@ class RecipleClient extends discord_js_1.Client {
             return;
         if (!this.config.commands.slashCommand.acceptRepliedInteractions && (interaction.replied || interaction.deferred))
             return;
-        const command = this.findCommand(interaction.commandName, builders_1.CommandBuilderType.SlashCommand);
+        const command = this.commands.get(interaction.commandName, builders_1.CommandBuilderType.SlashCommand);
         if (!command)
             return;
         const executeData = {
@@ -225,7 +115,7 @@ class RecipleClient extends discord_js_1.Client {
         const parseCommand = (0, fallout_utility_1.getCommand)(message.content, prefix || this.config.commands.messageCommand.prefix || '!', this.config.commands.messageCommand.commandArgumentSeparator || ' ');
         if (!parseCommand || !parseCommand?.command)
             return;
-        const command = this.findCommand(parseCommand.command, builders_1.CommandBuilderType.MessageCommand);
+        const command = this.commands.get(parseCommand.command, builders_1.CommandBuilderType.MessageCommand);
         if (!command)
             return;
         const commandOptions = await (0, MessageCommandBuilder_1.validateMessageCommandOptions)(command, parseCommand);
@@ -293,19 +183,6 @@ class RecipleClient extends discord_js_1.Client {
     getConfigMessage(messageKey, defaultMessage) {
         return this.config.messages[messageKey] ?? defaultMessage ?? messageKey;
     }
-    findCommand(command, type) {
-        switch (type) {
-            case builders_1.CommandBuilderType.SlashCommand:
-                return this.commands.slashCommands.get(command);
-            case builders_1.CommandBuilderType.MessageCommand:
-                return this.commands.messageCommands.get(command.toLowerCase())
-                    ?? (this.config.commands.messageCommand.allowCommandAlias
-                        ? this.commands.messageCommands.find(c => c.aliases.some(a => a == command?.toLowerCase()))
-                        : undefined);
-            default:
-                throw new TypeError('Unknown command type');
-        }
-    }
     /**
      * Returns true if client logs is enabled
      */
@@ -313,7 +190,7 @@ class RecipleClient extends discord_js_1.Client {
         return !!this.config.fileLogging.clientLogs;
     }
     /**
-     * Emits the "recipleReplyError" event
+     * Emits the {@link RecipleClientEvents["recipleReplyError"]} event
      * @param error Received Error
      */
     _replyError(error) {

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

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

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

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

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

@@ -79,6 +79,8 @@ class SlashCommandBuilder extends discord_js_1.SlashCommandBuilder {
     }
     /**
      * Add option builder to command builder
+     * @param builder Command/Subcommand builder
+     * @param option Option builder
      */
     static addOption(builder, option) {
         if (option instanceof discord_js_1.SlashCommandAttachmentOption) {
@@ -120,6 +122,7 @@ class SlashCommandBuilder extends discord_js_1.SlashCommandBuilder {
     }
     /**
      * Resolve option data
+     * @param option Option dara to resolve
      */
     static resolveOption(option) {
         let builder;
@@ -199,17 +202,23 @@ class SlashCommandBuilder extends discord_js_1.SlashCommandBuilder {
             .setNameLocalizations(option.nameLocalizations ?? null)
             .setDescriptionLocalizations(option.descriptionLocalizations ?? null);
     }
+    /**
+     * Resolve slash command data/builder
+     * @param commandData Command data to resolve
+     */
     static resolveSlashCommand(commandData) {
         return this.isSlashCommandBuilder(commandData) ? commandData : new SlashCommandBuilder(commandData);
     }
     /**
      * Is a slash command builder
+     * @param builder data to check
      */
     static isSlashCommandBuilder(builder) {
         return builder instanceof SlashCommandBuilder;
     }
     /**
      * Is a slash command execute data
+     * @param executeData data to check
      */
     static isSlashCommandExecuteData(executeData) {
         return executeData.builder !== undefined && this.isSlashCommandBuilder(executeData.builder);

package/dist/cjs/reciple/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.isClientLogsEnabled())
+                this.client.logger.log(`Registered ${this.client.commands.applicationCommandsSize} application command(s) globally...`);
+        }
+        else {
+            this.client.application.commands.set(commands, guild);
+            if (this.client.isClientLogsEnabled())
+                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.isClientLogsEnabled())
+                this.client.logger.log(`Created application command '${command.name}' globally`);
+        }
+        else {
+            this.client.application.commands.create(command, guild);
+            if (this.client.isClientLogsEnabled())
+                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.isClientLogsEnabled())
+                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.isClientLogsEnabled())
+                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.isClientLogsEnabled())
+                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.isClientLogsEnabled())
+                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.isClientLogsEnabled())
+                        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,62 @@
+"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.isClientLogsEnabled())
+            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;