reciple 5.6.0 → 6.0.0-dev.10

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

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,7 +1,7 @@
-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 '../MessageCommandOptionManager';
+import { MessageCommandOptionManager } from '../managers/MessageCommandOptionManager';
 import { MessageCommandOptionBuilder } from './MessageCommandOptionBuilder';
 import { Command } from 'fallout-utility';
 /**
@@ -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;
@@ -80,7 +80,7 @@ export declare class MessageCommandBuilder<T = unknown> implements SharedCommand
     halt?: MessageCommandHaltFunction<T>;
     execute: MessageCommandExecuteFunction<T>;
     metadata?: T;
-    constructor(data?: Partial<Omit<MessageCommandData<T>, "type">>);
+    constructor(data?: Partial<Omit<MessageCommandData<T>, 'type'>>);
     /**
      * Sets the command name
      * @param name Command name

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,42 +17,42 @@ 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 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 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 {
     addSubcommandGroup(input: SlashCommandSubcommandGroupBuilder | ((subcommandGroup: SlashCommandSubcommandGroupBuilder) => SlashCommandSubcommandGroupBuilder)): SlashCommandSubcommandsOnlyBuilder;
     addSubcommand(input: SlashCommandSubcommandBuilder | ((subcommandGroup: SlashCommandSubcommandBuilder) => SlashCommandSubcommandBuilder)): SlashCommandSubcommandsOnlyBuilder;
-    addBooleanOption(input: SlashCommandBooleanOption | ((builder: SlashCommandBooleanOption) => SlashCommandBooleanOption)): Omit<this, "addSubcommand" | "addSubcommandGroup">;
-    addUserOption(input: SlashCommandUserOption | ((builder: SlashCommandUserOption) => SlashCommandUserOption)): Omit<this, "addSubcommand" | "addSubcommandGroup">;
-    addChannelOption(input: SlashCommandChannelOption | ((builder: SlashCommandChannelOption) => SlashCommandChannelOption)): Omit<this, "addSubcommand" | "addSubcommandGroup">;
-    addRoleOption(input: SlashCommandRoleOption | ((builder: SlashCommandRoleOption) => SlashCommandRoleOption)): Omit<this, "addSubcommand" | "addSubcommandGroup">;
-    addAttachmentOption(input: SlashCommandAttachmentOption | ((builder: SlashCommandAttachmentOption) => SlashCommandAttachmentOption)): Omit<this, "addSubcommand" | "addSubcommandGroup">;
-    addMentionableOption(input: SlashCommandMentionableOption | ((builder: SlashCommandMentionableOption) => SlashCommandMentionableOption)): Omit<this, "addSubcommand" | "addSubcommandGroup">;
-    addStringOption(input: SlashCommandStringOption | Omit<SlashCommandStringOption, 'setAutocomplete'> | Omit<SlashCommandStringOption, 'addChoices'> | ((builder: SlashCommandStringOption) => SlashCommandStringOption | Omit<SlashCommandStringOption, 'setAutocomplete'> | Omit<SlashCommandStringOption, 'addChoices'>)): Omit<this, "addSubcommand" | "addSubcommandGroup">;
-    addIntegerOption(input: SlashCommandIntegerOption | Omit<SlashCommandIntegerOption, 'setAutocomplete'> | Omit<SlashCommandIntegerOption, 'addChoices'> | ((builder: SlashCommandIntegerOption) => SlashCommandIntegerOption | Omit<SlashCommandIntegerOption, 'setAutocomplete'> | Omit<SlashCommandIntegerOption, 'addChoices'>)): Omit<this, "addSubcommand" | "addSubcommandGroup">;
-    addNumberOption(input: SlashCommandNumberOption | Omit<SlashCommandNumberOption, 'setAutocomplete'> | Omit<SlashCommandNumberOption, 'addChoices'> | ((builder: SlashCommandNumberOption) => SlashCommandNumberOption | Omit<SlashCommandNumberOption, 'setAutocomplete'> | Omit<SlashCommandNumberOption, 'addChoices'>)): Omit<this, "addSubcommand" | "addSubcommandGroup">;
+    addBooleanOption(input: SlashCommandBooleanOption | ((builder: SlashCommandBooleanOption) => SlashCommandBooleanOption)): Omit<this, 'addSubcommand' | 'addSubcommandGroup'>;
+    addUserOption(input: SlashCommandUserOption | ((builder: SlashCommandUserOption) => SlashCommandUserOption)): Omit<this, 'addSubcommand' | 'addSubcommandGroup'>;
+    addChannelOption(input: SlashCommandChannelOption | ((builder: SlashCommandChannelOption) => SlashCommandChannelOption)): Omit<this, 'addSubcommand' | 'addSubcommandGroup'>;
+    addRoleOption(input: SlashCommandRoleOption | ((builder: SlashCommandRoleOption) => SlashCommandRoleOption)): Omit<this, 'addSubcommand' | 'addSubcommandGroup'>;
+    addAttachmentOption(input: SlashCommandAttachmentOption | ((builder: SlashCommandAttachmentOption) => SlashCommandAttachmentOption)): Omit<this, 'addSubcommand' | 'addSubcommandGroup'>;
+    addMentionableOption(input: SlashCommandMentionableOption | ((builder: SlashCommandMentionableOption) => SlashCommandMentionableOption)): Omit<this, 'addSubcommand' | 'addSubcommandGroup'>;
+    addStringOption(input: SlashCommandStringOption | Omit<SlashCommandStringOption, 'setAutocomplete'> | Omit<SlashCommandStringOption, 'addChoices'> | ((builder: SlashCommandStringOption) => SlashCommandStringOption | Omit<SlashCommandStringOption, 'setAutocomplete'> | Omit<SlashCommandStringOption, 'addChoices'>)): Omit<this, 'addSubcommand' | 'addSubcommandGroup'>;
+    addIntegerOption(input: SlashCommandIntegerOption | Omit<SlashCommandIntegerOption, 'setAutocomplete'> | Omit<SlashCommandIntegerOption, 'addChoices'> | ((builder: SlashCommandIntegerOption) => SlashCommandIntegerOption | Omit<SlashCommandIntegerOption, 'setAutocomplete'> | Omit<SlashCommandIntegerOption, 'addChoices'>)): Omit<this, 'addSubcommand' | 'addSubcommandGroup'>;
+    addNumberOption(input: SlashCommandNumberOption | Omit<SlashCommandNumberOption, 'setAutocomplete'> | Omit<SlashCommandNumberOption, 'addChoices'> | ((builder: SlashCommandNumberOption) => SlashCommandNumberOption | Omit<SlashCommandNumberOption, 'setAutocomplete'> | Omit<SlashCommandNumberOption, 'addChoices'>)): Omit<this, 'addSubcommand' | 'addSubcommandGroup'>;
 }
 /**
  * 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[];
     halt?: SlashCommandHaltFunction<T>;
     execute: SlashCommandExecuteFunction<T>;
     metadata?: T;
-    constructor(data?: Partial<Omit<SlashCommandData<T>, "type">>);
+    constructor(data?: Partial<Omit<SlashCommandData<T>, 'type'>>);
     setCooldown(cooldown: number): this;
     setRequiredBotPermissions(...permissions: RestOrArray<PermissionResolvable>): this;
     setRequiredMemberPermissions(...permissions: RestOrArray<PermissionResolvable>): this;

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

@@ -0,0 +1,15 @@
+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;
+    constructor(client: RecipleClient);
+    set(commands: (ApplicationCommandBuilder | ApplicationCommandData)[], ...guilds: RestOrArray<GuildResolvable>): Promise<void>;
+    add(command: ApplicationCommandBuilder | ApplicationCommandData, ...guilds: RestOrArray<GuildResolvable>): Promise<void>;
+    remove(command: string | ApplicationCommand, ...guilds: RestOrArray<GuildResolvable>): Promise<void>;
+    edit(command: string | ApplicationCommand, newCommand: ApplicationCommandBuilder | ApplicationCommandData, ...guilds: RestOrArray<GuildResolvable>): Promise<void>;
+    get(command: ApplicationCommandData | ApplicationCommandBuilder | string, guild?: GuildResolvable): ApplicationCommand | undefined;
+    fetch(commandId: string, guild?: GuildResolvable): Promise<ApplicationCommand>;
+    protected parseCommands(commands: (ApplicationCommandData | ApplicationCommandBuilder | RESTPostAPIApplicationCommandsJSONBody)[], setPermissions?: boolean): (ApplicationCommandData | RESTPostAPIApplicationCommandsJSONBody)[];
+}

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

@@ -0,0 +1,37 @@
+import { ApplicationCommandData, Collection, GuildResolvable, RestOrArray } from 'discord.js';
+import { AnyCommandBuilder, AnyCommandData, AnySlashCommandBuilder, CommandType, MessageCommandData, SlashCommandData } from '../../types/builders';
+import { MessageCommandBuilder } from '../builders/MessageCommandBuilder';
+import { SlashCommandBuilder } from '../builders/SlashCommandBuilder';
+import { RecipleClient } from '../RecipleClient';
+import { ApplicationCommandBuilder } from './ApplicationCommandManager';
+export interface ClientCommandManagerOptions {
+    client: RecipleClient;
+    messageCommands?: (MessageCommandBuilder | MessageCommandData)[];
+    slashCommands?: (AnySlashCommandBuilder | SlashCommandData)[];
+}
+export declare class ClientCommandManager {
+    readonly client: RecipleClient;
+    readonly slashCommands: Collection<string, AnySlashCommandBuilder>;
+    readonly messageCommands: Collection<string, MessageCommandBuilder>;
+    readonly additionalApplicationCommands: (ApplicationCommandBuilder | ApplicationCommandData)[];
+    get applicationCommandsSize(): number;
+    constructor(options: ClientCommandManagerOptions);
+    /**
+     * Add command to command manager
+     * @param commands Any command data or builder
+     */
+    add(...commands: RestOrArray<AnyCommandBuilder | AnyCommandData>): this;
+    /**
+     * Get command builder by name or alias if it's a message command
+     * @param command Command name
+     * @param type Command type
+     */
+    get(command: string, type?: undefined): AnyCommandBuilder | undefined;
+    get(command: string, type?: CommandType.MessageCommand): MessageCommandBuilder | undefined;
+    get(command: string, type?: CommandType.SlashCommand): SlashCommandBuilder | undefined;
+    /**
+     * Register application commands
+     * @param guilds Register application commands to guilds
+     */
+    registerApplicationCommands(...guilds: RestOrArray<GuildResolvable>): Promise<this>;
+}

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

@@ -0,0 +1,19 @@
+import { Collection, RestOrArray } from 'discord.js';
+import { ClientModuleManagerGetModulesFromFilesOptions } from '../../types/paramOptions';
+import { RecipleClient } from '../RecipleClient';
+import { RecipleModule, RecipleScript } from '../RecipleModule';
+export interface ClientModuleManagerOptions {
+    client: RecipleClient;
+    modules?: (RecipleModule | RecipleScript)[];
+}
+export declare class ClientModuleManager {
+    readonly client: RecipleClient;
+    readonly modules: Collection<string, RecipleModule>;
+    constructor(options: ClientModuleManagerOptions);
+    startModules(modules: RecipleModule[], ignoreErrors?: boolean): Promise<RecipleModule[]>;
+    loadModules(modules: RecipleModule[], addModuleCommandsToClient?: boolean, ignoreErrors?: boolean): Promise<RecipleModule[]>;
+    unLoadModules(modules: RecipleModule[], removeUnloadedModules?: boolean, ignoreErrors?: boolean): Promise<RecipleModule[]>;
+    getModulesFromFiles(options: ClientModuleManagerGetModulesFromFilesOptions): Promise<RecipleModule[]>;
+    static validateScript(script: unknown): script is RecipleScript;
+    getModuleFiles(...folders: RestOrArray<string>): Promise<string[]>;
+}

package/dist/types/reciple/classes/{CommandCooldownManager.d.ts → managers/CommandCooldownManager.d.ts}

@@ -1,5 +1,5 @@
 import { Guild, RestOrArray, TextBasedChannel, User } from 'discord.js';
-import { CommandBuilderType } from '../types/builders';
+import { CommandType } from '../../types/builders';
 /**
  * cooled-down user object interface
  */
@@ -15,7 +15,7 @@ export interface CooledDownUser {
     /**
      * Command type
      */
-    type: CommandBuilderType;
+    type: CommandType;
     /**
      * In guild
      */
@@ -43,8 +43,9 @@ export declare class CommandCooldownManager extends Array<CooledDownUser> {
      * 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: Partial<CooledDownUser>, limit?: number): void;
+    remove(options: Partial<CooledDownUser>, limit?: number): CooledDownUser[];
     /**
      * Check if the given user is cooled-down
      * @param options Options to identify if user is on cooldown

package/dist/types/reciple/classes/{MessageCommandOptionManager.d.ts → managers/MessageCommandOptionManager.d.ts}

@@ -1,4 +1,4 @@
-import { MessageCommandValidatedOption } from './builders/MessageCommandBuilder';
+import { MessageCommandValidatedOption } from '../builders/MessageCommandBuilder';
 import { RestOrArray } from 'discord.js';
 /**
  * Validated message options manager

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

@@ -25,11 +25,11 @@ export declare type AnyCommandExecuteFunction<T = unknown> = SlashCommandExecute
 /**
  * Command halt function
  */
-export declare type CommandHaltFunction<T extends CommandBuilderType, M = unknown> = (haltData: T extends CommandBuilderType.SlashCommand ? SlashCommandHaltData<M> : T extends CommandBuilderType.MessageCommand ? MessageCommandHaltData<M> : SlashCommandHaltData<M> | MessageCommandHaltData<M>) => Awaitable<boolean | null | undefined | void>;
+export declare type CommandHaltFunction<T extends CommandType, M = unknown> = (haltData: T extends CommandType.SlashCommand ? SlashCommandHaltData<M> : T extends CommandType.MessageCommand ? MessageCommandHaltData<M> : SlashCommandHaltData<M> | MessageCommandHaltData<M>) => Awaitable<boolean | null | undefined | void>;
 /**
  * Command execute function
  */
-export declare type CommandExecuteFunction<T extends CommandBuilderType, M = unknown> = (executeData: T extends CommandBuilderType.SlashCommand ? SlashCommandExecuteData<M> : T extends CommandBuilderType.MessageCommand ? MessageCommandExecuteData<M> : SlashCommandExecuteData<M> | MessageCommandExecuteData<M>) => Awaitable<void>;
+export declare type CommandExecuteFunction<T extends CommandType, M = unknown> = (executeData: T extends CommandType.SlashCommand ? SlashCommandExecuteData<M> : T extends CommandType.MessageCommand ? MessageCommandExecuteData<M> : SlashCommandExecuteData<M> | MessageCommandExecuteData<M>) => Awaitable<void>;
 /**
  * Message command options resolvable
  */
@@ -53,7 +53,7 @@ export declare type AnySlashCommandOptionsOnlyOptionBuilder = SlashCommandAttach
 /**
  * Types of command builders
  */
-export declare enum CommandBuilderType {
+export declare enum CommandType {
     MessageCommand = 0,
     SlashCommand = 1
 }
@@ -61,7 +61,7 @@ export declare enum CommandBuilderType {
  * Shared command builder methods and properties
  */
 export interface SharedCommandBuilderProperties<T = unknown> {
-    readonly type: CommandBuilderType;
+    readonly type: CommandType;
     cooldown: number;
     requiredBotPermissions: PermissionResolvable[];
     requiredMemberPermissions: PermissionResolvable[];
@@ -88,12 +88,12 @@ export interface SharedCommandBuilderProperties<T = unknown> {
      * Function when the command is interupted
      * @param halt Function to execute when command is halted
      */
-    setHalt(halt?: this["halt"]): this;
+    setHalt(halt?: this['halt']): this;
     /**
      * Function when the command is executed
      * @param execute Function to execute when the command is called
      */
-    setExecute(execute: this["execute"]): this;
+    setExecute(execute: this['execute']): this;
     /**
      * Set a command metadata
      * @param metadata Command metadata
@@ -110,8 +110,8 @@ export interface SharedCommandDataProperties {
 /**
  * Slash command object data interface
  */
-export interface SlashCommandData<T = unknown> extends SharedCommandDataProperties, Partial<Omit<SharedCommandBuilderProperties<T>, "setCooldown" | "setRequiredBotPermissions" | "setRequiredMemberPermissions" | "setHalt" | "setExecute" | "setMetadata" | "halt" | "execute">> {
-    type: CommandBuilderType.SlashCommand;
+export interface SlashCommandData<T = unknown> extends SharedCommandDataProperties, Partial<Omit<SharedCommandBuilderProperties<T>, 'setCooldown' | 'setRequiredBotPermissions' | 'setRequiredMemberPermissions' | 'setHalt' | 'setExecute' | 'setMetadata' | 'halt' | 'execute'>> {
+    type: CommandType.SlashCommand;
     nameLocalizations?: LocalizationMap;
     descriptionLocalizations?: LocalizationMap;
     options?: (AnySlashCommandOptionData | AnySlashCommandOptionBuilder)[];
@@ -124,7 +124,7 @@ export interface SlashCommandData<T = unknown> extends SharedCommandDataProperti
     halt?: SlashCommandHaltFunction<T>;
     execute: SlashCommandExecuteFunction<T>;
 }
-export interface SharedSlashCommandOptionData<V = string | number> extends SharedCommandDataProperties, Pick<SlashCommandData, "nameLocalizations" | "descriptionLocalizations"> {
+export interface SharedSlashCommandOptionData<V = string | number> extends SharedCommandDataProperties, Pick<SlashCommandData, 'nameLocalizations' | 'descriptionLocalizations'> {
     choices?: {
         name: string;
         nameLocalizations?: LocalizationMap;
@@ -133,13 +133,13 @@ export interface SharedSlashCommandOptionData<V = string | number> extends Share
     autocomplete?: boolean;
     required?: boolean;
 }
-export interface SlashCommandAttachmentOptionData extends Omit<SharedSlashCommandOptionData, "choices" | "autocomplete"> {
+export interface SlashCommandAttachmentOptionData extends Omit<SharedSlashCommandOptionData, 'choices' | 'autocomplete'> {
     type: ApplicationCommandOptionType.Attachment;
 }
-export interface SlashCommandBooleanOptionData extends Omit<SharedSlashCommandOptionData, "choices" | "autocomplete"> {
+export interface SlashCommandBooleanOptionData extends Omit<SharedSlashCommandOptionData, 'choices' | 'autocomplete'> {
     type: ApplicationCommandOptionType.Boolean;
 }
-export interface SlashCommandChannelOptionData extends Omit<SharedSlashCommandOptionData, "choices" | "autocomplete"> {
+export interface SlashCommandChannelOptionData extends Omit<SharedSlashCommandOptionData, 'choices' | 'autocomplete'> {
     type: ApplicationCommandOptionType.Channel;
     channelTypes?: ApplicationCommandOptionAllowedChannelTypes[];
 }
@@ -148,7 +148,7 @@ export interface SlashCommandIntegerOptionData extends SharedSlashCommandOptionD
     minValue?: number;
     maxValue?: number;
 }
-export interface SlashCommandMentionableOptionData extends Omit<SharedSlashCommandOptionData, "choices" | "autocomplete"> {
+export interface SlashCommandMentionableOptionData extends Omit<SharedSlashCommandOptionData, 'choices' | 'autocomplete'> {
     type: ApplicationCommandOptionType.Mentionable;
 }
 export interface SlashCommandNumberOptionData extends SharedSlashCommandOptionData<number> {
@@ -156,7 +156,7 @@ export interface SlashCommandNumberOptionData extends SharedSlashCommandOptionDa
     minValue?: number;
     maxValue?: number;
 }
-export interface SlashCommandRoleOptionData extends Omit<SharedSlashCommandOptionData, "choices" | "autocomplete"> {
+export interface SlashCommandRoleOptionData extends Omit<SharedSlashCommandOptionData, 'choices' | 'autocomplete'> {
     type: ApplicationCommandOptionType.Role;
 }
 export interface SlashCommandStringOptionData extends SharedSlashCommandOptionData<string> {
@@ -164,22 +164,22 @@ export interface SlashCommandStringOptionData extends SharedSlashCommandOptionDa
     minLength?: number;
     maxLength?: number;
 }
-export interface SlashCommandUserOptionData extends Omit<SharedSlashCommandOptionData, "choices" | "autocomplete"> {
+export interface SlashCommandUserOptionData extends Omit<SharedSlashCommandOptionData, 'choices' | 'autocomplete'> {
     type: ApplicationCommandOptionType.User;
 }
-export interface SlashCommandSubCommandData extends SharedCommandDataProperties, Pick<SlashCommandData, "nameLocalizations" | "descriptionLocalizations"> {
+export interface SlashCommandSubCommandData extends SharedCommandDataProperties, Pick<SlashCommandData, 'nameLocalizations' | 'descriptionLocalizations'> {
     type: ApplicationCommandOptionType.Subcommand;
     options: (AnySlashCommandOptionsOnlyOptionData | AnySlashCommandOptionsOnlyOptionBuilder)[];
 }
-export interface SlashCommandSubCommandGroupData extends SharedCommandDataProperties, Pick<SlashCommandData, "nameLocalizations" | "descriptionLocalizations"> {
+export interface SlashCommandSubCommandGroupData extends SharedCommandDataProperties, Pick<SlashCommandData, 'nameLocalizations' | 'descriptionLocalizations'> {
     type: ApplicationCommandOptionType.SubcommandGroup;
     options: (SlashCommandSubCommandData | SlashCommandSubcommandBuilder)[];
 }
 /**
  * Message command object data interface
  */
-export interface MessageCommandData<T = unknown> extends SharedCommandDataProperties, Partial<Omit<SharedCommandBuilderProperties<T>, "setCooldown" | "setRequiredBotPermissions" | "setRequiredMemberPermissions" | "setHalt" | "setExecute" | "setMetadata" | "halt" | "execute">> {
-    type: CommandBuilderType.MessageCommand;
+export interface MessageCommandData<T = unknown> extends SharedCommandDataProperties, Partial<Omit<SharedCommandBuilderProperties<T>, 'setCooldown' | 'setRequiredBotPermissions' | 'setRequiredMemberPermissions' | 'setHalt' | 'setExecute' | 'setMetadata' | 'halt' | 'execute'>> {
+    type: CommandType.MessageCommand;
     aliases?: string[];
     validateOptions?: boolean;
     allowExecuteInDM?: boolean;

package/dist/types/reciple/types/commands.d.ts

@@ -1,9 +1,9 @@
 import { MessageCommandExecuteData, MessageCommandHaltData } from '../classes/builders/MessageCommandBuilder';
 import { SlashCommandExecuteData, SlashCommandHaltData } from '../classes/builders/SlashCommandBuilder';
-import { MessageCommandOptionManager } from '../classes/MessageCommandOptionManager';
-import { CooledDownUser } from '../classes/CommandCooldownManager';
+import { MessageCommandOptionManager } from '../classes/managers/MessageCommandOptionManager';
+import { CooledDownUser } from '../classes/managers/CommandCooldownManager';
 import { RecipleClient } from '../classes/RecipleClient';
-import { CommandBuilderType } from '../types/builders';
+import { CommandType } from '../types/builders';
 /**
  * Any command halt data
  */
@@ -11,7 +11,7 @@ export declare type AnyCommandHaltData<T = unknown> = SlashCommandHaltData<T> |
 /**
  * command halt data
  */
-export declare type CommandHaltData<T extends CommandBuilderType, M = unknown> = CommandErrorData<T, M> | CommandCooldownData<T, M> | (T extends CommandBuilderType.SlashCommand ? never : CommandInvalidArguments<T, M> | CommandMissingArguments<T, M>) | CommandMissingMemberPermissions<T, M> | CommandMissingBotPermissions<T, M>;
+export declare type CommandHaltData<T extends CommandType, M = unknown> = CommandErrorData<T, M> | CommandCooldownData<T, M> | (T extends CommandType.SlashCommand ? never : CommandInvalidArguments<T, M> | CommandMissingArguments<T, M>) | CommandMissingMemberPermissions<T, M> | CommandMissingBotPermissions<T, M>;
 /**
  * Any command execute data
  */
@@ -28,7 +28,7 @@ export interface BaseCommandExecuteData {
 /**
  * Command halt reason base
  */
-export interface BaseCommandHaltData<T extends CommandBuilderType, M = unknown> {
+export interface BaseCommandHaltData<T extends CommandType, M = unknown> {
     /**
      * Halt reason
      */
@@ -36,36 +36,36 @@ export interface BaseCommandHaltData<T extends CommandBuilderType, M = unknown>
     /**
      * Command execute da6a
      */
-    executeData: T extends CommandBuilderType.SlashCommand ? SlashCommandExecuteData<M> : T extends CommandBuilderType.MessageCommand ? MessageCommandExecuteData<M> : AnyCommandExecuteData<M>;
+    executeData: T extends CommandType.SlashCommand ? SlashCommandExecuteData<M> : T extends CommandType.MessageCommand ? MessageCommandExecuteData<M> : AnyCommandExecuteData<M>;
 }
-export interface CommandErrorData<T extends CommandBuilderType, M = unknown> extends BaseCommandHaltData<T, M> {
+export interface CommandErrorData<T extends CommandType, M = unknown> extends BaseCommandHaltData<T, M> {
     reason: CommandHaltReason.Error;
     /**
      * Caught error
      */
     error: any;
 }
-export interface CommandCooldownData<T extends CommandBuilderType, M = unknown> extends BaseCommandHaltData<T, M>, CooledDownUser {
+export interface CommandCooldownData<T extends CommandType, M = unknown> extends BaseCommandHaltData<T, M>, CooledDownUser {
     reason: CommandHaltReason.Cooldown;
 }
-export interface CommandInvalidArguments<T extends CommandBuilderType, M = unknown> extends BaseCommandHaltData<T, M> {
+export interface CommandInvalidArguments<T extends CommandType, M = unknown> extends BaseCommandHaltData<T, M> {
     reason: CommandHaltReason.InvalidArguments;
     /**
      * Arguments that are invalid
      */
     invalidArguments: MessageCommandOptionManager;
 }
-export interface CommandMissingArguments<T extends CommandBuilderType, M = unknown> extends BaseCommandHaltData<T, M> {
+export interface CommandMissingArguments<T extends CommandType, M = unknown> extends BaseCommandHaltData<T, M> {
     reason: CommandHaltReason.MissingArguments;
     /**
      * Arguments that are missing
      */
     missingArguments: MessageCommandOptionManager;
 }
-export interface CommandMissingMemberPermissions<T extends CommandBuilderType, M = unknown> extends BaseCommandHaltData<T, M> {
+export interface CommandMissingMemberPermissions<T extends CommandType, M = unknown> extends BaseCommandHaltData<T, M> {
     reason: CommandHaltReason.MissingMemberPermissions;
 }
-export interface CommandMissingBotPermissions<T extends CommandBuilderType, M = unknown> extends BaseCommandHaltData<T, M> {
+export interface CommandMissingBotPermissions<T extends CommandType, M = unknown> extends BaseCommandHaltData<T, M> {
     reason: CommandHaltReason.MissingBotPermissions;
 }
 /**