reciple 5.5.6 → 6.0.0-dev.1

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

@@ -4,25 +4,31 @@ import { ChatInputCommandInteraction, PermissionResolvable, RestOrArray, SlashCo
 /**
  * Execute data for slash command
  */
-export interface SlashCommandExecuteData<T extends unknown = any> extends BaseCommandExecuteData {
+export interface SlashCommandExecuteData<T = unknown> extends BaseCommandExecuteData {
+    /**
+     * Command interaction
+     */
     interaction: ChatInputCommandInteraction;
+    /**
+     * Command Builder
+     */
     builder: AnySlashCommandBuilder<T>;
 }
 /**
  * Slash command halt data
  */
-export declare type SlashCommandHaltData = CommandHaltData<CommandBuilderType.SlashCommand>;
+export declare type SlashCommandHaltData<T = unknown> = CommandHaltData<CommandBuilderType.SlashCommand, T>;
 /**
  * Slash command halt function
  */
-export declare type SlashCommandHaltFunction = CommandHaltFunction<CommandBuilderType.SlashCommand>;
+export declare type SlashCommandHaltFunction<T = unknown> = CommandHaltFunction<CommandBuilderType.SlashCommand, T>;
 /**
  * Slash command execute function
  */
-export declare type SlashCommandExecuteFunction = CommandExecuteFunction<CommandBuilderType.SlashCommand>;
-export declare type SlashCommandSubcommandsOnlyBuilder<T extends unknown = any> = Omit<SlashCommandBuilder<T>, "addBooleanOption" | "addUserOption" | "addChannelOption" | "addRoleOption" | "addAttachmentOption" | "addMentionableOption" | "addStringOption" | "addIntegerOption" | "addNumberOption">;
-export declare type SlashCommandOptionsOnlyBuilder<T extends unknown = any> = Omit<SlashCommandBuilder<T>, "addSubcommand" | "addSubcommandGroup">;
-export interface SlashCommandBuilder<T extends unknown = any> extends DiscordJsSlashCommandBuilder {
+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 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">;
@@ -38,36 +44,45 @@ export interface SlashCommandBuilder<T extends unknown = any> extends DiscordJsS
 /**
  * Reciple builder for slash command
  */
-export declare class SlashCommandBuilder<T extends unknown = any> extends DiscordJsSlashCommandBuilder implements SharedCommandBuilderProperties<T> {
+export declare class SlashCommandBuilder<T = unknown> extends DiscordJsSlashCommandBuilder implements SharedCommandBuilderProperties<T> {
     readonly type = CommandBuilderType.SlashCommand;
     cooldown: number;
     requiredBotPermissions: PermissionResolvable[];
     requiredMemberPermissions: PermissionResolvable[];
-    halt?: SlashCommandHaltFunction;
-    execute: SlashCommandExecuteFunction;
+    halt?: SlashCommandHaltFunction<T>;
+    execute: SlashCommandExecuteFunction<T>;
     metadata?: T;
     constructor(data?: Partial<Omit<SlashCommandData<T>, "type">>);
     setCooldown(cooldown: number): this;
     setRequiredBotPermissions(...permissions: RestOrArray<PermissionResolvable>): this;
     setRequiredMemberPermissions(...permissions: RestOrArray<PermissionResolvable>): this;
-    setHalt(halt?: SlashCommandHaltFunction | null): this;
-    setExecute(execute: SlashCommandExecuteFunction): this;
+    setHalt(halt?: SlashCommandHaltFunction<T> | null): this;
+    setExecute(execute: SlashCommandExecuteFunction<T>): this;
     setMetadata(metadata?: T): this;
     /**
      * Add option builder to command builder
+     * @param builder Command/Subcommand builder
+     * @param option Option builder
      */
     static addOption(builder: SharedSlashCommandOptions | SlashCommandBuilder, option: AnySlashCommandOptionBuilder): SharedSlashCommandOptions;
     /**
      * Resolve option data
+     * @param option Option dara to resolve
      */
     static resolveOption<T extends AnySlashCommandOptionBuilder>(option: AnySlashCommandOptionData): T;
-    static resolveSlashCommand<T extends unknown = any>(commandData: SlashCommandData<T> | AnySlashCommandBuilder<T>): AnySlashCommandBuilder;
+    /**
+     * Resolve slash command data/builder
+     * @param commandData Command data to resolve
+     */
+    static resolveSlashCommand<T = unknown>(commandData: SlashCommandData<T> | AnySlashCommandBuilder<T>): AnySlashCommandBuilder<T>;
     /**
      * Is a slash command builder
+     * @param builder data to check
      */
-    static isSlashCommandBuilder<T extends unknown = any>(builder: unknown): builder is AnySlashCommandBuilder<T>;
+    static isSlashCommandBuilder<T = unknown>(builder: unknown): builder is AnySlashCommandBuilder<T>;
     /**
      * Is a slash command execute data
+     * @param executeData data to check
      */
     static isSlashCommandExecuteData(executeData: unknown): executeData is SlashCommandExecuteData;
 }

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

@@ -0,0 +1,20 @@
+import { ApplicationCommand, ApplicationCommandData, ContextMenuCommandBuilder, GuildResolvable, 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;
+    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, CommandBuilderType, 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?: CommandBuilderType.MessageCommand): MessageCommandBuilder | undefined;
+    get(command: string, type?: CommandBuilderType.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,79 @@
+import { Collection, GuildResolvable, RestOrArray } from 'discord.js';
+import { AnyCommandBuilder, AnyCommandData } from '../../types/builders';
+import { ModuleManagerResolveFilesOptions } 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[];
+}
+export interface ClientModuleManagerOptions {
+    client: RecipleClient;
+    modules?: (RecipleModule & {
+        id?: string;
+    })[];
+}
+export declare class ClientModuleManager {
+    readonly client: RecipleClient;
+    readonly modules: Collection<string, ResolvedModule>;
+    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;
+}

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

@@ -1,14 +1,32 @@
 import { Guild, RestOrArray, TextBasedChannel, User } from 'discord.js';
-import { CommandBuilderType } from '../types/builders';
+import { CommandBuilderType } from '../../types/builders';
 /**
  * cooled-down user object interface
  */
 export interface CooledDownUser {
+    /**
+     * Cooled-down user
+     */
     user: User;
+    /**
+     * Cooled-down command name
+     */
     command: string;
+    /**
+     * Command type
+     */
     type: CommandBuilderType;
+    /**
+     * In guild
+     */
     guild?: Guild | null;
+    /**
+     * Cooled-down channel
+     */
     channel?: TextBasedChannel;
+    /**
+     * Cooldown expiration
+     */
     expireTime: number;
 }
 /**
@@ -25,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/modules.d.ts

@@ -1,26 +1,58 @@
 import { AnyCommandBuilder, AnyCommandData } from './types/builders';
 import { RecipleClient } from './classes/RecipleClient';
-export declare type LoadedModules = {
+/**
+ * Loaded modules and commands
+ */
+export interface LoadedModules {
     commands: AnyCommandBuilder[];
     modules: RecipleModule[];
-};
+}
 /**
  * Reciple script object
  */
 export interface RecipleScript {
+    /**
+     * Supported reciple versions
+     */
     versions: string | string[];
+    /**
+     * Module commands
+     */
     commands?: (AnyCommandBuilder | AnyCommandData)[];
-    onLoad?(client: RecipleClient): void | Promise<void>;
-    onStart(client: RecipleClient): boolean | Promise<boolean>;
+    /**
+     * Action on bot ready
+     * @param client Bot client
+     */
+    onLoad?(client: RecipleClient<true>): void | Promise<void>;
+    /**
+     * Action on module start
+     * @param client Bot client
+     */
+    onStart(client: RecipleClient<false>): boolean | Promise<boolean>;
 }
 /**
  * Reciple module object
  */
 export interface RecipleModule {
+    /**
+     * Module script
+     */
     script: RecipleScript;
+    /**
+     * Module local information
+     */
     info: {
+        /**
+         * Module file name
+         */
         filename?: string;
+        /**
+         * Supported reciple versions
+         */
         versions: string[];
+        /**
+         * Module local file path
+         */
         path?: string;
     };
 }

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

@@ -7,11 +7,13 @@ import { UserHasCommandPermissionsOptions } from './types/paramOptions';
 export declare function userHasCommandPermissions(options: UserHasCommandPermissionsOptions): boolean;
 /**
  * Check if the bot has the required permissions in a guild
- * @param guild Check if the bot has the required permissions in a guild
+ * @param guild Check if the bot has the required permissions in this guild
  * @param requiredPermissions Required guild bot permissions
  */
 export declare function botHasExecutePermissions(guild?: Guild, requiredPermissions?: PermissionResolvable[]): boolean;
 /**
- * @param channel Check if the bot has the required permissions in a channel
+ * Check if the bot has the required permissions in a channel
+ * @param channel Check if the bot has the required permissions in this channel
+ * @param requiredPermissions Required guild bot permissions
  */
 export declare function botHasExecutePermissions(channel?: GuildTextBasedChannel, requiredPermissions?: PermissionResolvable[]): boolean;

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

@@ -5,31 +5,31 @@ import { MessageCommandOptionBuilder } from '../classes/builders/MessageCommandO
 /**
  * Any command builders
  */
-export declare type AnyCommandBuilder<T extends unknown = any> = AnySlashCommandBuilder<T> | MessageCommandBuilder<T>;
+export declare type AnyCommandBuilder<T = unknown> = AnySlashCommandBuilder<T> | MessageCommandBuilder<T>;
 /**
  * Any command data
  */
-export declare type AnyCommandData<T extends unknown = any> = SlashCommandData<T> | MessageCommandData<T>;
+export declare type AnyCommandData<T = unknown> = SlashCommandData<T> | MessageCommandData<T>;
 /**
  * Any slash command builders
  */
-export declare type AnySlashCommandBuilder<T extends unknown = any> = SlashCommandBuilder<T> | SlashCommandOptionsOnlyBuilder<T> | SlashCommandSubcommandsOnlyBuilder<T>;
+export declare type AnySlashCommandBuilder<T = unknown> = SlashCommandBuilder<T> | SlashCommandOptionsOnlyBuilder<T> | SlashCommandSubcommandsOnlyBuilder<T>;
 /**
  * Any command halt functions
  */
-export declare type AnyCommandHaltFunction = SlashCommandHaltFunction | MessageCommandHaltFunction;
+export declare type AnyCommandHaltFunction<T = unknown> = SlashCommandHaltFunction<T> | MessageCommandHaltFunction<T>;
 /**
  * Any command execute function
  */
-export declare type AnyCommandExecuteFunction = SlashCommandExecuteFunction | MessageCommandExecuteFunction;
+export declare type AnyCommandExecuteFunction<T = unknown> = SlashCommandExecuteFunction<T> | MessageCommandExecuteFunction<T>;
 /**
  * Command halt function
  */
-export declare type CommandHaltFunction<T extends CommandBuilderType> = (haltData: T extends CommandBuilderType.SlashCommand ? SlashCommandHaltData : MessageCommandHaltData) => Awaitable<boolean | null | undefined | void>;
+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>;
 /**
  * Command execute function
  */
-export declare type CommandExecuteFunction<T extends CommandBuilderType> = (executeData: T extends CommandBuilderType.SlashCommand ? SlashCommandExecuteData : MessageCommandExecuteData) => Awaitable<void>;
+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>;
 /**
  * Message command options resolvable
  */
@@ -60,13 +60,13 @@ export declare enum CommandBuilderType {
 /**
  * Shared command builder methods and properties
  */
-export interface SharedCommandBuilderProperties<T extends unknown> {
+export interface SharedCommandBuilderProperties<T = unknown> {
     readonly type: CommandBuilderType;
     cooldown: number;
     requiredBotPermissions: PermissionResolvable[];
     requiredMemberPermissions: PermissionResolvable[];
-    halt?: AnyCommandHaltFunction;
-    execute: AnyCommandExecuteFunction;
+    halt?: AnyCommandHaltFunction<T>;
+    execute: AnyCommandExecuteFunction<T>;
     metadata?: T;
     /**
      * Sets the execute cooldown for this command.
@@ -110,7 +110,7 @@ export interface SharedCommandDataProperties {
 /**
  * Slash command object data interface
  */
-export interface SlashCommandData<T extends unknown = any> extends SharedCommandDataProperties, Partial<Omit<SharedCommandBuilderProperties<T>, "setCooldown" | "setRequiredBotPermissions" | "setRequiredMemberPermissions" | "setHalt" | "setExecute" | "setMetadata" | "halt" | "execute">> {
+export interface SlashCommandData<T = unknown> extends SharedCommandDataProperties, Partial<Omit<SharedCommandBuilderProperties<T>, "setCooldown" | "setRequiredBotPermissions" | "setRequiredMemberPermissions" | "setHalt" | "setExecute" | "setMetadata" | "halt" | "execute">> {
     type: CommandBuilderType.SlashCommand;
     nameLocalizations?: LocalizationMap;
     descriptionLocalizations?: LocalizationMap;
@@ -121,8 +121,8 @@ export interface SlashCommandData<T extends unknown = any> extends SharedCommand
     defaultPermission?: boolean;
     defaultMemberPermissions?: string | null;
     dmPermission?: boolean;
-    halt?: SlashCommandHaltFunction;
-    execute: SlashCommandExecuteFunction;
+    halt?: SlashCommandHaltFunction<T>;
+    execute: SlashCommandExecuteFunction<T>;
 }
 export interface SharedSlashCommandOptionData<V = string | number> extends SharedCommandDataProperties, Pick<SlashCommandData, "nameLocalizations" | "descriptionLocalizations"> {
     choices?: {
@@ -178,14 +178,14 @@ export interface SlashCommandSubCommandGroupData extends SharedCommandDataProper
 /**
  * Message command object data interface
  */
-export interface MessageCommandData<T extends unknown = any> extends SharedCommandDataProperties, Partial<Omit<SharedCommandBuilderProperties<T>, "setCooldown" | "setRequiredBotPermissions" | "setRequiredMemberPermissions" | "setHalt" | "setExecute" | "setMetadata" | "halt" | "execute">> {
+export interface MessageCommandData<T = unknown> extends SharedCommandDataProperties, Partial<Omit<SharedCommandBuilderProperties<T>, "setCooldown" | "setRequiredBotPermissions" | "setRequiredMemberPermissions" | "setHalt" | "setExecute" | "setMetadata" | "halt" | "execute">> {
     type: CommandBuilderType.MessageCommand;
     aliases?: string[];
     validateOptions?: boolean;
     allowExecuteInDM?: boolean;
     allowExecuteByBots?: boolean;
-    halt?: MessageCommandHaltFunction;
-    execute: MessageCommandExecuteFunction;
+    halt?: MessageCommandHaltFunction<T>;
+    execute: MessageCommandExecuteFunction<T>;
     options?: MessageCommandOptionResolvable[];
 }
 /**

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

@@ -1,52 +1,71 @@
 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';
 /**
  * Any command halt data
  */
-export declare type AnyCommandHaltData = SlashCommandHaltData | MessageCommandHaltData;
+export declare type AnyCommandHaltData<T = unknown> = SlashCommandHaltData<T> | MessageCommandHaltData<T>;
 /**
  * command halt data
  */
-export declare type CommandHaltData<T extends CommandBuilderType> = CommandErrorData<T> | CommandCooldownData<T> | (T extends CommandBuilderType.SlashCommand ? never : CommandInvalidArguments<T> | CommandMissingArguments<T>) | CommandMissingMemberPermissions<T> | CommandMissingBotPermissions<T>;
+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>;
 /**
  * Any command execute data
  */
-export declare type AnyCommandExecuteData = SlashCommandExecuteData | MessageCommandExecuteData;
+export declare type AnyCommandExecuteData<T = unknown> = SlashCommandExecuteData<T> | MessageCommandExecuteData<T>;
 /**
  * Command execute data
  */
 export interface BaseCommandExecuteData {
+    /**
+     * Bot client
+     */
     client: RecipleClient<true>;
 }
 /**
  * Command halt reason base
  */
-export interface BaseCommandHaltData<T extends CommandBuilderType> {
-    executeData: T extends CommandBuilderType.SlashCommand ? SlashCommandExecuteData : T extends CommandBuilderType.MessageCommand ? MessageCommandExecuteData : AnyCommandExecuteData;
+export interface BaseCommandHaltData<T extends CommandBuilderType, M = unknown> {
+    /**
+     * Halt reason
+     */
+    reason: CommandHaltReason;
+    /**
+     * Command execute da6a
+     */
+    executeData: T extends CommandBuilderType.SlashCommand ? SlashCommandExecuteData<M> : T extends CommandBuilderType.MessageCommand ? MessageCommandExecuteData<M> : AnyCommandExecuteData<M>;
 }
-export interface CommandErrorData<T extends CommandBuilderType> extends BaseCommandHaltData<T> {
+export interface CommandErrorData<T extends CommandBuilderType, M = unknown> extends BaseCommandHaltData<T, M> {
     reason: CommandHaltReason.Error;
+    /**
+     * Caught error
+     */
     error: any;
 }
-export interface CommandCooldownData<T extends CommandBuilderType> extends BaseCommandHaltData<T>, CooledDownUser {
+export interface CommandCooldownData<T extends CommandBuilderType, M = unknown> extends BaseCommandHaltData<T, M>, CooledDownUser {
     reason: CommandHaltReason.Cooldown;
 }
-export interface CommandInvalidArguments<T extends CommandBuilderType> extends BaseCommandHaltData<T> {
+export interface CommandInvalidArguments<T extends CommandBuilderType, M = unknown> extends BaseCommandHaltData<T, M> {
     reason: CommandHaltReason.InvalidArguments;
+    /**
+     * Arguments that are invalid
+     */
     invalidArguments: MessageCommandOptionManager;
 }
-export interface CommandMissingArguments<T extends CommandBuilderType> extends BaseCommandHaltData<T> {
+export interface CommandMissingArguments<T extends CommandBuilderType, M = unknown> extends BaseCommandHaltData<T, M> {
     reason: CommandHaltReason.MissingArguments;
+    /**
+     * Arguments that are missing
+     */
     missingArguments: MessageCommandOptionManager;
 }
-export interface CommandMissingMemberPermissions<T extends CommandBuilderType> extends BaseCommandHaltData<T> {
+export interface CommandMissingMemberPermissions<T extends CommandBuilderType, M = unknown> extends BaseCommandHaltData<T, M> {
     reason: CommandHaltReason.MissingMemberPermissions;
 }
-export interface CommandMissingBotPermissions<T extends CommandBuilderType> extends BaseCommandHaltData<T> {
+export interface CommandMissingBotPermissions<T extends CommandBuilderType, M = unknown> extends BaseCommandHaltData<T, M> {
     reason: CommandHaltReason.MissingBotPermissions;
 }
 /**

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

@@ -1,8 +1,6 @@
-import { ApplicationCommandBuilder } from '../registerApplicationCommands';
-import { ApplicationCommandData, PermissionsBitField } from 'discord.js';
+import { ConfigCommandPermissions } from '../classes/RecipleConfig';
 import { RecipleModule, RecipleScript } from '../modules';
-import { RecipleClient } from '../classes/RecipleClient';
-import { Config } from '../classes/RecipleConfig';
+import { PermissionsBitField } from 'discord.js';
 import { AnyCommandBuilder } from './builders';
 export interface RecipleClientAddModuleOptions {
     /**
@@ -18,22 +16,25 @@ export interface RecipleClientAddModuleOptions {
      */
     moduleInfo?: RecipleModule["info"];
 }
-export interface RegisterApplicationCommandsOptions {
+export interface UserHasCommandPermissionsOptions {
     /**
-     * Bot client
+     * Command builder
      */
-    client: RecipleClient;
+    builder: AnyCommandBuilder;
     /**
-     * Commands to register
+     * Member permissions
      */
-    commands: (ApplicationCommandData | ApplicationCommandBuilder)[];
-    /**
-     * Set guild to not register commands globally
+    memberPermissions?: PermissionsBitField;
+    /***
+     * Required command config permissions
      */
-    guilds?: string | string[];
+    commandPermissions?: {
+        enabled: boolean;
+        commands: ConfigCommandPermissions[];
+    };
 }
-export interface UserHasCommandPermissionsOptions {
-    builder: AnyCommandBuilder;
-    memberPermissions?: PermissionsBitField;
-    commandPermissions?: Config["commands"]["slashCommand"]["permissions"] | Config["commands"]["messageCommand"]["permissions"];
+export interface ModuleManagerResolveFilesOptions {
+    files: string[];
+    disabeVersionCheck?: boolean;
+    dontSkipError?: boolean;
 }

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

@@ -1 +1,12 @@
-export declare function isClass<T extends any>(object: any): object is T;
+import { AnyCommandBuilder } from './types/builders';
+/**
+ * Check if an object is a class
+ * @param object Object to identify
+ */
+export declare function isClass<T = any>(object: any): object is T;
+/**
+ * Emit process warning about deprecated method/function
+ * @param content Warning content
+ */
+export declare function deprecationWarning(content: string | Error): void;
+export declare function validateCommandBuilder(command: AnyCommandBuilder): boolean;