reciple 6.0.0-dev.2 → 6.0.0-dev.20

package/dist/{cjs/reciple/classes/managers/ClientCommandManager.js → lib/reciple/classes/managers/CommandManager.js}

@@ -1,11 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ClientCommandManager = void 0;
+exports.CommandManager = 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 {
+class CommandManager {
     constructor(options) {
         this.slashCommands = new discord_js_1.Collection();
         this.messageCommands = new discord_js_1.Collection();
@@ -14,31 +14,30 @@ class ClientCommandManager {
         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) {
+            if (command.type === builders_1.CommandType.SlashCommand) {
                 this.slashCommands.set(command.name, SlashCommandBuilder_1.SlashCommandBuilder.resolveSlashCommand(command));
             }
-            else if (command.type === builders_1.CommandBuilderType.MessageCommand) {
+            else if (command.type === builders_1.CommandType.MessageCommand) {
                 this.messageCommands.set(command.name, MessageCommandBuilder_1.MessageCommandBuilder.resolveMessageCommand(command));
             }
+            else {
+                throw new Error(`Unknown reciple command type`);
+            }
         }
         return this;
     }
     get(command, type) {
         switch (type) {
-            case builders_1.CommandBuilderType.SlashCommand:
+            case builders_1.CommandType.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));
+            case builders_1.CommandType.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');
         }
@@ -51,10 +50,10 @@ class ClientCommandManager {
         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');
+            this.client.logger.log(`Regestering ${this.client.applicationCommands.size} application command(s) ${!guilds.length ? 'globaly' : 'to ' + guilds.length + ' guilds'}...`);
+        await this.client.applicationCommands.set([...this.client.applicationCommands.commands], guilds);
+        this.client.emit('recipleRegisterApplicationCommands');
         return this;
     }
 }
-exports.ClientCommandManager = ClientCommandManager;
+exports.CommandManager = CommandManager;

package/dist/lib/reciple/classes/managers/ModuleManager.js

@@ -0,0 +1,179 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ModuleManager = void 0;
+const discord_js_1 = require("discord.js");
+const fs_1 = require("fs");
+const util_1 = require("util");
+const wildcard_match_1 = __importDefault(require("wildcard-match"));
+const RecipleModule_1 = require("../RecipleModule");
+const util_2 = require("../../util");
+class ModuleManager {
+    constructor(options) {
+        this.modules = new discord_js_1.Collection();
+        this.client = options.client;
+        options.modules?.forEach(m => (m instanceof RecipleModule_1.RecipleModule ? m : new RecipleModule_1.RecipleModule({ client: this.client, script: m })));
+    }
+    /**
+     * Start modules
+     * @param options start modules options
+     * @returns started modules
+     */
+    async startModules(options) {
+        const startedModules = [];
+        for (const module_ of options.modules) {
+            if (!this.client.isClientLogsSilent)
+                this.client.logger.log(`Starting module '${module_}'`);
+            try {
+                let error;
+                const start = await module_.start().catch(err => {
+                    error = err;
+                    return false;
+                });
+                if (error)
+                    throw new Error(`An error occured while loading module '${module_}': \n${(0, util_1.inspect)(error)}`);
+                if (!start) {
+                    if (!this.client.isClientLogsSilent)
+                        this.client.logger.error(`Module '${module_}' returned false onStart`);
+                    continue;
+                }
+                if (options.addToModulesCollection !== false)
+                    this.modules.set(module_.id, module_);
+                startedModules.push(module_);
+            }
+            catch (err) {
+                if (options?.ignoreErrors === false)
+                    throw err;
+                if (!this.client.isClientLogsSilent)
+                    this.client.logger.error(`Failed to start module '${module_}': `, err);
+            }
+        }
+        return startedModules;
+    }
+    /**
+     * Load modules
+     * @param options load modules options
+     * @returns loaded modules
+     */
+    async loadModules(options) {
+        const loadedModules = [];
+        for (const module_ of options?.modules ?? this.modules.toJSON()) {
+            try {
+                await module_.load().catch(err => {
+                    throw err;
+                });
+                if (options?.resolveCommands !== false) {
+                    module_.resolveCommands();
+                    this.client.commands.add(module_.commands);
+                }
+                loadedModules.push(module_);
+                if (!this.client.isClientLogsSilent)
+                    this.client.logger.log(`Loaded module '${module_}'`);
+            }
+            catch (err) {
+                if (options?.ignoreErrors === false)
+                    throw err;
+                if (!this.client.isClientLogsSilent)
+                    this.client.logger.error(`Failed to load module '${module_}': `, err);
+            }
+        }
+        return loadedModules;
+    }
+    /**
+     * Unload modules
+     * @param options unload modules options
+     * @returns unloaded modules
+     */
+    async unloadModules(options) {
+        const unloadedModules = [];
+        for (const module_ of options?.modules ?? this.modules.toJSON()) {
+            try {
+                await module_.unload().catch(err => {
+                    throw err;
+                });
+                unloadedModules.push(module_);
+                if (!this.client.isClientLogsSilent)
+                    this.client.logger.log(`Unloaded module '${module_}'`);
+            }
+            catch (err) {
+                if (options?.ignoreErrors === false)
+                    throw err;
+                if (!this.client.isClientLogsSilent)
+                    this.client.logger.error(`Failed to unLoad module '${module_}': `, err);
+            }
+        }
+        return unloadedModules;
+    }
+    /**
+     * Resolve modules from file paths
+     * @param options resolve module files options
+     * @returns resolved modules
+     */
+    async resolveModuleFiles(options) {
+        const modules = [];
+        for (const file of options.files) {
+            try {
+                const resolveFile = await import((util_2.path.isAbsolute(file) ? 'file://' : '') + file);
+                let script = resolveFile instanceof RecipleModule_1.RecipleModule || ModuleManager.validateScript(resolveFile) ? resolveFile : resolveFile?.default?.default instanceof RecipleModule_1.RecipleModule || ModuleManager.validateScript(resolveFile?.default?.default) ? resolveFile.default.default : resolveFile?.default;
+                if (script instanceof RecipleModule_1.RecipleModule) {
+                    modules.push(script);
+                    continue;
+                }
+                if (!ModuleManager.validateScript(script))
+                    throw new Error(`Invalid module script: ${file}`);
+                modules.push(new RecipleModule_1.RecipleModule({
+                    client: this.client,
+                    script,
+                    filePath: file,
+                }));
+            }
+            catch (err) {
+                if (options.ignoreErrors === false)
+                    throw err;
+                if (!this.client.isClientLogsSilent)
+                    this.client.logger.error(`Can't resolve module from: ${file}`, err);
+            }
+        }
+        return modules;
+    }
+    /**
+     * Validate module script
+     * @param script module script
+     * @returns `true` if script is valid
+     */
+    static validateScript(script) {
+        const s = script;
+        if (typeof s !== 'object')
+            return false;
+        if (typeof s.versions !== 'string' && !Array.isArray(s.versions))
+            return false;
+        if (typeof s.onStart !== 'function')
+            return false;
+        if (s.onLoad && typeof s.onLoad !== 'function')
+            return false;
+        if (s.onUnload && typeof s.onUnload !== 'function')
+            return false;
+        return true;
+    }
+    /**
+     * Get module file paths from folders
+     * @param options get module paths options
+     * @returns module paths
+     */
+    async getModulePaths(options) {
+        const modules = [];
+        for (const dir of options?.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 => util_2.path.join(!dir.startsWith('/') ? this.client.cwd : '', dir, file))
+                .filter(file => (options?.filter ? options.filter(file) : file.endsWith('.js'))));
+        }
+        return modules.filter(file => !(options?.ignoredFiles ?? this.client.config.ignoredFiles).some(ignored => (0, wildcard_match_1.default)(ignored)(util_2.path.basename(file))));
+    }
+}
+exports.ModuleManager = ModuleManager;

package/dist/{cjs → lib}/reciple/flags.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.cwd = exports.token = exports.flags = exports.commander = void 0;
-const version_1 = require("./version");
+const version_js_1 = require("./version.js");
 const commander_1 = require("commander");
 /**
  * Commander
@@ -9,7 +9,7 @@ const commander_1 = require("commander");
 exports.commander = new commander_1.Command()
     .name('reciple')
     .description('Reciple.js - Discord.js handler cli')
-    .version(`v${version_1.rawVersion}`, '-v, --version')
+    .version(`v${version_js_1.rawVersion}`, '-v, --version')
     .argument('[current-working-directory]', 'Change the current working directory')
     .option('-t, --token <token>', 'Replace used bot token')
     .option('-c, --config <config>', 'Change path to config file')

package/dist/lib/reciple/types/builders.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CommandType = void 0;
+/**
+ * Types of command builders
+ */
+var CommandType;
+(function (CommandType) {
+    CommandType[CommandType["SlashCommand"] = 1] = "SlashCommand";
+    CommandType[CommandType["MessageCommand"] = 2] = "MessageCommand";
+})(CommandType = exports.CommandType || (exports.CommandType = {}));

package/dist/{cjs → lib}/reciple/types/commands.js

@@ -6,10 +6,10 @@ exports.CommandHaltReason = void 0;
  */
 var CommandHaltReason;
 (function (CommandHaltReason) {
-    CommandHaltReason[CommandHaltReason["Error"] = 0] = "Error";
-    CommandHaltReason[CommandHaltReason["Cooldown"] = 1] = "Cooldown";
-    CommandHaltReason[CommandHaltReason["InvalidArguments"] = 2] = "InvalidArguments";
-    CommandHaltReason[CommandHaltReason["MissingArguments"] = 3] = "MissingArguments";
-    CommandHaltReason[CommandHaltReason["MissingMemberPermissions"] = 4] = "MissingMemberPermissions";
-    CommandHaltReason[CommandHaltReason["MissingBotPermissions"] = 5] = "MissingBotPermissions";
+    CommandHaltReason[CommandHaltReason["Error"] = 1] = "Error";
+    CommandHaltReason[CommandHaltReason["Cooldown"] = 2] = "Cooldown";
+    CommandHaltReason[CommandHaltReason["InvalidArguments"] = 3] = "InvalidArguments";
+    CommandHaltReason[CommandHaltReason["MissingArguments"] = 4] = "MissingArguments";
+    CommandHaltReason[CommandHaltReason["MissingMemberPermissions"] = 5] = "MissingMemberPermissions";
+    CommandHaltReason[CommandHaltReason["MissingBotPermissions"] = 6] = "MissingBotPermissions";
 })(CommandHaltReason = exports.CommandHaltReason || (exports.CommandHaltReason = {}));

package/dist/{cjs/reciple/logger.js → lib/reciple/util.js}

@@ -3,10 +3,40 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.createLogger = void 0;
+exports.path = exports.createLogger = exports.validateCommandBuilder = exports.deprecationWarning = exports.isClass = void 0;
+const chalk_1 = __importDefault(require("chalk"));
 const fallout_utility_1 = require("fallout-utility");
+const path_1 = __importDefault(require("path"));
 const flags_1 = require("./flags");
-const chalk_1 = __importDefault(require("chalk"));
+const builders_1 = require("./types/builders");
+/**
+ * Check if an object is a class
+ * @param object Object to identify
+ */
+function isClass(object) {
+    const isClassConstructor = object.constructor && object.constructor.toString().substring(0, 5) === 'class';
+    if (object.prototype === undefined)
+        return isClassConstructor;
+    const isPrototypeClassConstructor = object.prototype.constructor && object.prototype.constructor.toString && object.prototype.constructor.toString().substring(0, 5) === 'class';
+    return isClassConstructor || isPrototypeClassConstructor;
+}
+exports.isClass = isClass;
+/**
+ * Emit process warning about deprecated method/function
+ * @param content Warning content
+ */
+function deprecationWarning(content) {
+    process.emitWarning(content, 'DeprecationWarning');
+}
+exports.deprecationWarning = deprecationWarning;
+function validateCommandBuilder(command) {
+    if (!command.name)
+        return false;
+    if (command.type === builders_1.CommandType.MessageCommand && command.options.length && command.options.some(o => !o.name))
+        return false;
+    return true;
+}
+exports.validateCommandBuilder = validateCommandBuilder;
 /**
  * Create new logger
  * @param stringifyJSON stringify json objects in console
@@ -35,3 +65,4 @@ function createLogger(stringifyJSON, debugmode = false, colorizeMessage = true)
     });
 }
 exports.createLogger = createLogger;
+exports.path = (0, fallout_utility_1.getOperatingSystem)() === fallout_utility_1.OS.WINDOWS ? path_1.default.win32 : path_1.default.posix;

package/dist/{cjs → lib}/reciple/version.js

@@ -5,7 +5,6 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.isSupportedVersion = exports.parseVersion = exports.isValidVersion = exports.rawVersion = exports.version = void 0;
 const semver_1 = __importDefault(require("semver"));
-// TODO: ESM support
 /**
  * Current reciple version
  */

package/dist/types/esm.d.mts

@@ -0,0 +1 @@
+export * from './index.js';

package/dist/types/index.d.ts

@@ -1,18 +1,19 @@
-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/classes/builders/MessageCommandBuilder.js';
+export * from './reciple/classes/builders/MessageCommandOptionBuilder.js';
+export * from './reciple/classes/builders/SlashCommandBuilder.js';
+export * from './reciple/classes/managers/ApplicationCommandManager.js';
+export * from './reciple/classes/managers/CommandManager.js';
+export * from './reciple/classes/managers/ModuleManager.js';
+export * from './reciple/classes/managers/CommandCooldownManager.js';
+export * from './reciple/classes/managers/MessageCommandOptionManager.js';
+export * from './reciple/classes/RecipleClient.js';
+export * from './reciple/classes/RecipleConfig.js';
+export * from './reciple/classes/RecipleModule.js';
+export * from './reciple/types/builders.js';
+export * from './reciple/types/commands.js';
+export * from './reciple/types/builders.js';
+export * from './reciple/types/builders.js';
 export * from './reciple/flags';
-export * from './reciple/logger';
-export * from './reciple/permissions';
-export * from './reciple/util';
-export * from './reciple/version';
+export * from './reciple/permissions.js';
+export * from './reciple/util.js';
+export * from './reciple/version.js';

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

@@ -4,8 +4,8 @@ import { SlashCommandBuilder, SlashCommandExecuteData, SlashCommandHaltData } fr
 import { AnyCommandExecuteData, AnyCommandHaltData } from '../types/commands';
 import { CommandCooldownManager } from './managers/CommandCooldownManager';
 import { ApplicationCommandManager } from './managers/ApplicationCommandManager';
-import { ClientCommandManager } from './managers/ClientCommandManager';
-import { ClientModuleManager } from './managers/ClientModuleManager';
+import { CommandManager } from './managers/CommandManager';
+import { ModuleManager } from './managers/ModuleManager';
 import { Config } from './RecipleConfig';
 import { Logger } from 'fallout-utility';
 /**
@@ -13,6 +13,7 @@ import { Logger } from 'fallout-utility';
  */
 export interface RecipleClientOptions extends ClientOptions {
     config?: Config;
+    cwd?: string;
 }
 /**
  * Reciple client events
@@ -41,10 +42,11 @@ export interface RecipleClient<Ready extends boolean = boolean> extends Client<R
 }
 export declare class RecipleClient<Ready extends boolean = boolean> extends Client<Ready> {
     readonly config: Config;
-    readonly commands: ClientCommandManager;
+    readonly commands: CommandManager;
     readonly applicationCommands: ApplicationCommandManager;
     readonly cooldowns: CommandCooldownManager;
-    readonly modules: ClientModuleManager;
+    readonly modules: ModuleManager;
+    readonly cwd: string;
     readonly logger: Logger;
     readonly version: string;
     get isClientLogsSilent(): boolean;

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

@@ -22,6 +22,7 @@ export interface Config {
             enabled: boolean;
             replyOnError: boolean;
             registerCommands: boolean;
+            allowRegisterEmptyCommandList: boolean;
             enableCooldown: boolean;
             setRequiredPermissions: boolean;
             acceptRepliedInteractions: boolean;
@@ -81,9 +82,9 @@ export declare class RecipleConfig {
     getConfig(): Config;
     /**
      * Parse token from config
-     * @param askIfNull Ask for token if the token is null/undefined
+     * @param askIfEmpty Ask for token if the token is undefined
      */
-    parseToken(askIfNull?: boolean): string | null;
+    parseToken(askIfEmpty?: boolean): string | null;
     /**
      * Check if the config version is supported
      */

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

@@ -0,0 +1,56 @@
+import { GuildResolvable, RestOrArray } from 'discord.js';
+import { AnyCommandBuilder, AnyCommandData } from '../types/builders';
+import { RecipleClient } from './RecipleClient';
+/**
+ * Reciple script object
+ */
+export interface RecipleScript {
+    /**
+     * Supported reciple versions
+     */
+    versions: string | string[];
+    /**
+     * Module commands
+     */
+    commands?: (AnyCommandBuilder | AnyCommandData)[];
+    /**
+     * Action on module start
+     * @param client Bot client
+     */
+    onStart(client: RecipleClient<false>): boolean | Promise<boolean>;
+    /**
+     * Action on bot ready
+     * @param client Bot client
+     */
+    onLoad?(client: RecipleClient<true>): void | Promise<void>;
+    /**
+     * Action when unloading this module
+     * @param reason Unload reason
+     * @param client Bot client
+     */
+    onUnload?(reason: unknown, client: RecipleClient<true>): void | Promise<void>;
+}
+export interface RecipleModuleOptions<M = unknown> {
+    client: RecipleClient;
+    script: RecipleScript;
+    filePath?: string;
+    metadata?: M;
+}
+export declare class RecipleModule<M = unknown> {
+    readonly id: string;
+    readonly client: RecipleClient;
+    readonly commands: AnyCommandBuilder[];
+    readonly script: RecipleScript;
+    readonly filePath?: string;
+    metadata?: M;
+    get displayName(): string;
+    constructor(options: RecipleModuleOptions<M>);
+    start(): Promise<boolean>;
+    load(resolveCommands?: boolean): Promise<void>;
+    unload(reason?: any): Promise<void>;
+    registerSlashCommands(...guilds: RestOrArray<GuildResolvable>): Promise<void>;
+    unregisterSlashCommands(...guilds: RestOrArray<GuildResolvable>): Promise<void>;
+    updateSlashCommands(...guilds: RestOrArray<GuildResolvable>): Promise<void>;
+    resolveCommands(): AnyCommandBuilder[];
+    toString(): string;
+}

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

@@ -1,4 +1,4 @@
-import { CommandBuilderType, CommandHaltFunction, CommandExecuteFunction, SharedCommandBuilderProperties, MessageCommandData } from '../../types/builders';
+import { CommandType, CommandHaltFunction, CommandExecuteFunction, SharedCommandBuilderProperties, MessageCommandData } from '../../types/builders';
 import { Message, PermissionResolvable, RestOrArray } from 'discord.js';
 import { BaseCommandExecuteData, CommandHaltData } from '../../types/commands';
 import { MessageCommandOptionManager } from '../managers/MessageCommandOptionManager';
@@ -53,20 +53,20 @@ export interface MessageCommandValidatedOption {
 /**
  * Halt data for message command
  */
-export declare type MessageCommandHaltData<T = unknown> = CommandHaltData<CommandBuilderType.MessageCommand, T>;
+export declare type MessageCommandHaltData<T = unknown> = CommandHaltData<CommandType.MessageCommand, T>;
 /**
  * Message command halt function
  */
-export declare type MessageCommandHaltFunction<T = unknown> = CommandHaltFunction<CommandBuilderType.MessageCommand, T>;
+export declare type MessageCommandHaltFunction<T = unknown> = CommandHaltFunction<CommandType.MessageCommand, T>;
 /**
  * Message command execute function
  */
-export declare type MessageCommandExecuteFunction<T = unknown> = CommandExecuteFunction<CommandBuilderType.MessageCommand, T>;
+export declare type MessageCommandExecuteFunction<T = unknown> = CommandExecuteFunction<CommandType.MessageCommand, T>;
 /**
  * Reciple builder for message command
  */
 export declare class MessageCommandBuilder<T = unknown> implements SharedCommandBuilderProperties<T> {
-    readonly type = CommandBuilderType.MessageCommand;
+    readonly type = CommandType.MessageCommand;
     name: string;
     description: string;
     cooldown: number;

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

@@ -1,4 +1,4 @@
-import { CommandBuilderType, CommandHaltFunction, CommandExecuteFunction, SharedCommandBuilderProperties, AnySlashCommandBuilder, SlashCommandData, AnySlashCommandOptionData, AnySlashCommandOptionBuilder } from '../../types/builders';
+import { CommandType, CommandHaltFunction, CommandExecuteFunction, SharedCommandBuilderProperties, AnySlashCommandBuilder, SlashCommandData, AnySlashCommandOptionData, AnySlashCommandOptionBuilder } from '../../types/builders';
 import { BaseCommandExecuteData, CommandHaltData } from '../../types/commands';
 import { ChatInputCommandInteraction, PermissionResolvable, RestOrArray, SlashCommandBuilder as DiscordJsSlashCommandBuilder, SlashCommandSubcommandBuilder, SlashCommandSubcommandGroupBuilder, SlashCommandBooleanOption, SlashCommandUserOption, SlashCommandChannelOption, SlashCommandRoleOption, SlashCommandAttachmentOption, SlashCommandMentionableOption, SlashCommandStringOption, SlashCommandIntegerOption, SlashCommandNumberOption, SharedSlashCommandOptions } from 'discord.js';
 /**
@@ -17,15 +17,15 @@ export interface SlashCommandExecuteData<T = unknown> extends BaseCommandExecute
 /**
  * Slash command halt data
  */
-export declare type SlashCommandHaltData<T = unknown> = CommandHaltData<CommandBuilderType.SlashCommand, T>;
+export declare type SlashCommandHaltData<T = unknown> = CommandHaltData<CommandType.SlashCommand, T>;
 /**
  * Slash command halt function
  */
-export declare type SlashCommandHaltFunction<T = unknown> = CommandHaltFunction<CommandBuilderType.SlashCommand, T>;
+export declare type SlashCommandHaltFunction<T = unknown> = CommandHaltFunction<CommandType.SlashCommand, T>;
 /**
  * Slash command execute function
  */
-export declare type SlashCommandExecuteFunction<T = unknown> = CommandExecuteFunction<CommandBuilderType.SlashCommand, T>;
+export declare type SlashCommandExecuteFunction<T = unknown> = CommandExecuteFunction<CommandType.SlashCommand, T>;
 export declare type SlashCommandSubcommandsOnlyBuilder<T = unknown> = Omit<SlashCommandBuilder<T>, 'addBooleanOption' | 'addUserOption' | 'addChannelOption' | 'addRoleOption' | 'addAttachmentOption' | 'addMentionableOption' | 'addStringOption' | 'addIntegerOption' | 'addNumberOption'>;
 export declare type SlashCommandOptionsOnlyBuilder<T = unknown> = Omit<SlashCommandBuilder<T>, 'addSubcommand' | 'addSubcommandGroup'>;
 export interface SlashCommandBuilder<T = unknown> extends DiscordJsSlashCommandBuilder {
@@ -45,7 +45,7 @@ export interface SlashCommandBuilder<T = unknown> extends DiscordJsSlashCommandB
  * Reciple builder for slash command
  */
 export declare class SlashCommandBuilder<T = unknown> extends DiscordJsSlashCommandBuilder implements SharedCommandBuilderProperties<T> {
-    readonly type = CommandBuilderType.SlashCommand;
+    readonly type = CommandType.SlashCommand;
     cooldown: number;
     requiredBotPermissions: PermissionResolvable[];
     requiredMemberPermissions: PermissionResolvable[];

package/dist/types/reciple/classes/managers/ApplicationCommandManager.d.ts

@@ -1,20 +1,53 @@
-import { ApplicationCommand, ApplicationCommandData, ContextMenuCommandBuilder, GuildResolvable, RESTPostAPIApplicationCommandsJSONBody, SlashCommandBuilder as DiscordJsSlashCommandBuilder } from 'discord.js';
+import { ApplicationCommand, ApplicationCommandData, ContextMenuCommandBuilder, GuildResolvable, RestOrArray, RESTPostAPIApplicationCommandsJSONBody, SlashCommandBuilder as DiscordJsSlashCommandBuilder } from 'discord.js';
 import { AnySlashCommandBuilder } from '../../types/builders';
 import { RecipleClient } from '../RecipleClient';
 export declare type ApplicationCommandBuilder = AnySlashCommandBuilder | ContextMenuCommandBuilder | DiscordJsSlashCommandBuilder;
 export declare class ApplicationCommandManager {
     readonly client: RecipleClient;
-    get commands(): import("discord.js").ApplicationCommandManager<ApplicationCommand<{
-        guild: GuildResolvable;
-    }>, {
-        guild: GuildResolvable;
-    }, null> | undefined;
+    get commands(): (DiscordJsSlashCommandBuilder | import("../builders/SlashCommandBuilder").SlashCommandOptionsOnlyBuilder<unknown> | import("../builders/SlashCommandBuilder").SlashCommandSubcommandsOnlyBuilder<unknown> | ContextMenuCommandBuilder | import("discord.js").UserApplicationCommandData | import("discord.js").MessageApplicationCommandData | import("discord.js").ChatInputApplicationCommandData)[];
+    get size(): number;
     constructor(client: RecipleClient);
-    set(commands: (ApplicationCommandBuilder | ApplicationCommandData)[], guilds?: GuildResolvable[]): Promise<void>;
-    add(command: ApplicationCommandBuilder | ApplicationCommandData, guilds?: GuildResolvable[]): Promise<void>;
-    remove(command: string | ApplicationCommand, guilds?: GuildResolvable[]): Promise<void>;
-    edit(command: string | ApplicationCommand, newCommand: ApplicationCommandBuilder | ApplicationCommandData, guilds?: GuildResolvable[]): Promise<void>;
+    /**
+     * Sets application commands globally or in guilds
+     * @param commands Application commands
+     * @param guilds set only to guilds
+     */
+    set(commands: (ApplicationCommandBuilder | ApplicationCommandData)[], ...guilds: RestOrArray<GuildResolvable>): Promise<void>;
+    /**
+     * Add command globally or in guilds
+     * @param command Application command
+     * @param guilds add only in guilds
+     */
+    add(command: ApplicationCommandBuilder | ApplicationCommandData, ...guilds: RestOrArray<GuildResolvable>): Promise<void>;
+    /**
+     * Remove application command globally or in guilds
+     * @param command id of application commmand or ApplicationCommand class
+     * @param guilds Remove from guilds
+     */
+    remove(command: string | ApplicationCommand, ...guilds: RestOrArray<GuildResolvable>): Promise<void>;
+    /**
+     * Edit application command globally or in guilds
+     * @param command id of application command or ApplicationCommand class
+     * @param newCommand new application command data
+     * @param guilds Edit only from guilds
+     */
+    edit(command: string | ApplicationCommand, newCommand: ApplicationCommandBuilder | ApplicationCommandData, ...guilds: RestOrArray<GuildResolvable>): Promise<void>;
+    /**
+     * Get application command from cache by application command data, builder, id, or name globally or from guid
+     * @param command application command data, builder, id, or name
+     * @param guild get command from guild
+     */
     get(command: ApplicationCommandData | ApplicationCommandBuilder | string, guild?: GuildResolvable): ApplicationCommand | undefined;
+    /**
+     * Fetch application command by id globally or from guild
+     * @param commandId command id
+     * @param guild fetch from guild
+     */
     fetch(commandId: string, guild?: GuildResolvable): Promise<ApplicationCommand>;
+    /**
+     * Parse application command builders to command data
+     * @param commands Application command builders
+     * @param setPermissions set slash commands permissions
+     */
     protected parseCommands(commands: (ApplicationCommandData | ApplicationCommandBuilder | RESTPostAPIApplicationCommandsJSONBody)[], setPermissions?: boolean): (ApplicationCommandData | RESTPostAPIApplicationCommandsJSONBody)[];
 }