reciple 6.0.0-dev.1 → 6.0.0-dev.12

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

@@ -1,13 +1,13 @@
 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 { 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 { Config } from './RecipleConfig';
 import { Logger } from 'fallout-utility';
-import { Awaitable, ChatInputCommandInteraction, Client, ClientEvents, ClientOptions, Interaction, Message } from 'discord.js';
-import { ClientModuleManager } from './managers/ClientModuleManager';
 /**
  * Options for {@link RecipleClient}
  */
@@ -47,6 +47,7 @@ export declare class RecipleClient<Ready extends boolean = boolean> extends Clie
     readonly modules: ClientModuleManager;
     readonly logger: Logger;
     readonly version: string;
+    get isClientLogsSilent(): boolean;
     /**
      * @param options Client options
      */
@@ -72,10 +73,6 @@ export declare class RecipleClient<Ready extends boolean = boolean> extends Clie
      * @param defaultMessage Default message when the key does not exists
      */
     getConfigMessage<T = unknown>(messageKey: string, defaultMessage?: T): T;
-    /**
-     * Returns true if client logs is enabled
-     */
-    isClientLogsEnabled(): boolean;
     /**
      * Emits the {@link RecipleClientEvents["recipleReplyError"]} event
      * @param error 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,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;
@@ -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

@@ -1,20 +1,15 @@
-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;
     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>;
-    get(command: (ApplicationCommandData | ApplicationCommandBuilder | string), guild?: GuildResolvable): ApplicationCommand | undefined;
+    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

@@ -1,5 +1,5 @@
 import { ApplicationCommandData, Collection, GuildResolvable, RestOrArray } from 'discord.js';
-import { AnyCommandBuilder, AnyCommandData, AnySlashCommandBuilder, CommandBuilderType, MessageCommandData, SlashCommandData } from '../../types/builders';
+import { AnyCommandBuilder, AnyCommandData, AnySlashCommandBuilder, CommandType, MessageCommandData, SlashCommandData } from '../../types/builders';
 import { MessageCommandBuilder } from '../builders/MessageCommandBuilder';
 import { SlashCommandBuilder } from '../builders/SlashCommandBuilder';
 import { RecipleClient } from '../RecipleClient';
@@ -27,8 +27,8 @@ export declare class ClientCommandManager {
      * @param type Command type
      */
     get(command: string, type?: undefined): AnyCommandBuilder | undefined;
-    get(command: string, type?: CommandBuilderType.MessageCommand): MessageCommandBuilder | undefined;
-    get(command: string, type?: CommandBuilderType.SlashCommand): SlashCommandBuilder | 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

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

@@ -1,79 +1,19 @@
-import { Collection, GuildResolvable, RestOrArray } from 'discord.js';
-import { AnyCommandBuilder, AnyCommandData } from '../../types/builders';
-import { ModuleManagerResolveFilesOptions } from '../../types/paramOptions';
+import { Collection } from 'discord.js';
+import { ClientModuleManagerGetModulePathsOptions, ClientModuleManagerGetModulesFromFilesOptions } from '../../types/paramOptions';
 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>;
-}
-/**
- * Reciple module object
- */
-export interface RecipleModule {
-    /**
-     * Module Id
-     */
-    id: string;
-    /**
-     * Module script
-     */
-    script: RecipleScript;
-    /**
-     * Module local information
-     */
-    info: {
-        /**
-         * Module file name
-         */
-        filename?: string;
-        /**
-         * Module local file path
-         */
-        path?: string;
-    };
-}
-export interface ResolvedModule extends RecipleModule {
-    commands: AnyCommandBuilder[];
-}
-export interface ResolvedScriptCommands {
-    script: RecipleScript;
-    commands: AnyCommandBuilder[];
-}
+import { RecipleModule, RecipleScript } from '../RecipleModule';
 export interface ClientModuleManagerOptions {
     client: RecipleClient;
-    modules?: (RecipleModule & {
-        id?: string;
-    })[];
+    modules?: (RecipleModule | RecipleScript)[];
 }
 export declare class ClientModuleManager {
     readonly client: RecipleClient;
-    readonly modules: Collection<string, ResolvedModule>;
+    readonly modules: Collection<string, RecipleModule>;
     constructor(options: ClientModuleManagerOptions);
-    startModulesFromFiles(options: ModuleManagerResolveFilesOptions): Promise<ResolvedModule[]>;
-    resolveModulesFromFiles(options: ModuleManagerResolveFilesOptions): Promise<ResolvedModule[]>;
-    resolveScriptCommands(...modules: RestOrArray<RecipleScript>): ResolvedScriptCommands[];
-    loadAll(registerApplicationCommands?: boolean, ...registerApplicationCommandsGuilds: RestOrArray<GuildResolvable>): Promise<void>;
-    startModule(mod: ResolvedModule): Promise<void>;
-    resolveModule(mod: RecipleModule, disabeVersionCheck?: boolean): ResolvedModule;
-    getModuleFiles(...folders: RestOrArray<string>): Promise<string[]>;
-    static getModuleDisplayId(mod: RecipleModule): string;
+    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;
+    getModulePaths(options?: ClientModuleManagerGetModulePathsOptions): Promise<string[]>;
 }

package/dist/types/reciple/classes/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
      */

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

@@ -3,7 +3,7 @@ import { SlashCommandExecuteData, SlashCommandHaltData } from '../classes/builde
 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;
 }
 /**

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

@@ -1,21 +1,6 @@
 import { ConfigCommandPermissions } from '../classes/RecipleConfig';
-import { RecipleModule, RecipleScript } from '../modules';
-import { PermissionsBitField } from 'discord.js';
+import { Awaitable, PermissionsBitField } from 'discord.js';
 import { AnyCommandBuilder } from './builders';
-export interface RecipleClientAddModuleOptions {
-    /**
-     * The module script
-     */
-    script: RecipleScript;
-    /**
-     * Register application commands if possible
-     */
-    registerApplicationCommands?: boolean;
-    /**
-     * Module optional info
-     */
-    moduleInfo?: RecipleModule["info"];
-}
 export interface UserHasCommandPermissionsOptions {
     /**
      * Command builder
@@ -33,8 +18,13 @@ export interface UserHasCommandPermissionsOptions {
         commands: ConfigCommandPermissions[];
     };
 }
-export interface ModuleManagerResolveFilesOptions {
+export interface ClientModuleManagerGetModulesFromFilesOptions {
     files: string[];
     disabeVersionCheck?: boolean;
     dontSkipError?: boolean;
 }
+export interface ClientModuleManagerGetModulePathsOptions {
+    folders?: string[];
+    ignoredFiles?: string[];
+    filter?: (file: string) => Awaitable<boolean>;
+}

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

@@ -1,3 +1,4 @@
+import { Logger } from 'fallout-utility';
 import { AnyCommandBuilder } from './types/builders';
 /**
  * Check if an object is a class
@@ -10,3 +11,10 @@ export declare function isClass<T = any>(object: any): object is T;
  */
 export declare function deprecationWarning(content: string | Error): void;
 export declare function validateCommandBuilder(command: AnyCommandBuilder): boolean;
+/**
+ * Create new logger
+ * @param stringifyJSON stringify json objects in console
+ * @param debugmode display debug messages
+ * @param colorizeMessage add logger colours to messages
+ */
+export declare function createLogger(stringifyJSON: boolean, debugmode?: boolean, colorizeMessage?: boolean): Logger;