reciple 6.0.0-dev.2 → 6.0.0-dev.21

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, MessageCommandOptionResolvable } from '../../types/builders';
 import { Message, PermissionResolvable, RestOrArray } from 'discord.js';
 import { BaseCommandExecuteData, CommandHaltData } from '../../types/commands';
 import { MessageCommandOptionManager } from '../managers/MessageCommandOptionManager';
@@ -53,33 +53,57 @@ 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;
-    name: string;
-    description: string;
-    cooldown: number;
-    aliases: string[];
-    validateOptions: boolean;
-    options: MessageCommandOptionBuilder[];
-    requiredBotPermissions: PermissionResolvable[];
-    requiredMemberPermissions: PermissionResolvable[];
-    allowExecuteInDM: boolean;
-    allowExecuteByBots: boolean;
-    halt?: MessageCommandHaltFunction<T>;
-    execute: MessageCommandExecuteFunction<T>;
+    readonly type = CommandType.MessageCommand;
+    private _name;
+    private _description;
+    private _cooldown;
+    private _aliases;
+    private _validateOptions;
+    private _options;
+    private _requiredBotPermissions;
+    private _requiredMemberPermissions;
+    private _allowExecuteInDM;
+    private _allowExecuteByBots;
+    private _halt?;
+    private _execute;
     metadata?: T;
+    get name(): typeof this._name;
+    get description(): typeof this._description;
+    get cooldown(): typeof this._cooldown;
+    get aliases(): typeof this._aliases;
+    get validateOptions(): typeof this._validateOptions;
+    get options(): MessageCommandOptionResolvable[];
+    get requiredBotPermissions(): typeof this._requiredBotPermissions;
+    get requiredMemberPermissions(): typeof this._requiredMemberPermissions;
+    get allowExecuteInDM(): typeof this._allowExecuteInDM;
+    get allowExecuteByBots(): typeof this._allowExecuteByBots;
+    get halt(): typeof this._halt;
+    get execute(): typeof this._execute;
+    set name(name: typeof this._name);
+    set description(description: typeof this._description);
+    set cooldown(cooldown: typeof this._cooldown);
+    set aliases(aliases: typeof this._aliases);
+    set validateOptions(validate: typeof this._validateOptions);
+    set options(options: MessageCommandOptionResolvable[]);
+    set requiredBotPermissions(permissions: typeof this._requiredBotPermissions);
+    set requiredMemberPermissions(permissions: typeof this._requiredMemberPermissions);
+    set allowExecuteInDM(allow: typeof this._allowExecuteInDM);
+    set allowExecuteByBots(allow: typeof this._allowExecuteByBots);
+    set halt(halt: typeof this._halt);
+    set execute(execute: typeof this._execute);
     constructor(data?: Partial<Omit<MessageCommandData<T>, 'type'>>);
     /**
      * Sets the command name
@@ -96,6 +120,11 @@ export declare class MessageCommandBuilder<T = unknown> implements SharedCommand
      * @param aliases Command aliases
      */
     addAliases(...aliases: RestOrArray<string>): this;
+    /**
+     * Replace aliases from command builder
+     * @param aliases Command aliases
+     */
+    setAliases(...aliases: RestOrArray<string>): this;
     /**
      * Set if command can be executed in dms
      * @param allowExecuteInDM `true` if the command can execute in DMs
@@ -107,10 +136,15 @@ export declare class MessageCommandBuilder<T = unknown> implements SharedCommand
      */
     setAllowExecuteByBots(allowExecuteByBots: boolean): this;
     /**
-     * Add option to the command
-     * @param option Message option builder
+     * Add options to command
+     * @param options Message options
+     */
+    addOptions(...options: RestOrArray<MessageCommandOptionResolvable | ((builder: MessageCommandOptionBuilder) => MessageCommandOptionBuilder)>): this;
+    /**
+     * Replace options from command
+     * @params options Message options
      */
-    addOption(option: MessageCommandOptionBuilder | ((constructor: MessageCommandOptionBuilder) => MessageCommandOptionBuilder)): this;
+    setOptions(...options: RestOrArray<MessageCommandOptionResolvable | ((builder: MessageCommandOptionBuilder) => MessageCommandOptionBuilder)>): this;
     /**
      * Validate options before executing
      * @param validateOptions `true` if the command options needs to be validated before executing
@@ -141,10 +175,10 @@ export declare class MessageCommandBuilder<T = unknown> implements SharedCommand
      * @param executeData data to check
      */
     static isMessageCommandExecuteData(executeData: unknown): executeData is MessageCommandExecuteData;
+    /**
+     * Validate message command options
+     * @param builder Command builder
+     * @param options Parsed command args
+     */
+    static validateOptions(builder: MessageCommandBuilder, options: Command): Promise<MessageCommandOptionManager>;
 }
-/**
- * Validate message command options
- * @param builder Command builder
- * @param options Parsed command args
- */
-export declare function validateMessageCommandOptions(builder: MessageCommandBuilder, options: Command): Promise<MessageCommandOptionManager>;

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

@@ -1,13 +1,21 @@
-import { MessageCommandOptionData } from '../../types/builders';
+import { MessageCommandOptionData, MessageCommandOptionResolvable } from '../../types/builders';
 import { Awaitable } from 'discord.js';
 /**
  * Option builder for MessageCommandBuilder
  */
 export declare class MessageCommandOptionBuilder {
-    name: string;
-    description: string;
-    required: boolean;
-    validator: (value: string) => Awaitable<boolean>;
+    private _name;
+    private _description;
+    private _required;
+    private _validator?;
+    get name(): typeof this._name;
+    get description(): typeof this._description;
+    get required(): typeof this._required;
+    get validator(): typeof this._validator;
+    set name(name: typeof this._name);
+    set description(description: typeof this._description);
+    set required(required: typeof this._required);
+    set validator(validator: typeof this._validator);
     constructor(data?: Partial<MessageCommandOptionData>);
     /**
      * Set command option name
@@ -28,13 +36,13 @@ export declare class MessageCommandOptionBuilder {
      * Set your custom function to validate given value for this option
      * @param validator Custom function to validate value given for this option
      */
-    setValidator(validator: (value: string) => Awaitable<boolean>): this;
+    setValidator(validator?: (value: string) => Awaitable<boolean>): this;
     toJSON(): MessageCommandOptionData;
     /**
      * Resolves message command option data/builder
      * @param option Option data to resolve
      */
-    static resolveMessageCommandOption(option: MessageCommandOptionBuilder | MessageCommandOptionBuilder): MessageCommandOptionBuilder;
+    static resolveMessageCommandOption(option: MessageCommandOptionResolvable): MessageCommandOptionBuilder;
     /**
      * Is a Message command option builder
      * @param builder data to check

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

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

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

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

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/classes/managers/{ClientCommandManager.d.ts → CommandManager.d.ts}

@@ -1,21 +1,20 @@
 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';
 import { ApplicationCommandBuilder } from './ApplicationCommandManager';
-export interface ClientCommandManagerOptions {
+export interface CommandManagerOptions {
     client: RecipleClient;
     messageCommands?: (MessageCommandBuilder | MessageCommandData)[];
     slashCommands?: (AnySlashCommandBuilder | SlashCommandData)[];
 }
-export declare class ClientCommandManager {
+export declare class CommandManager {
     readonly client: RecipleClient;
     readonly slashCommands: Collection<string, AnySlashCommandBuilder>;
     readonly messageCommands: Collection<string, MessageCommandBuilder>;
     readonly additionalApplicationCommands: (ApplicationCommandBuilder | ApplicationCommandData)[];
-    get applicationCommandsSize(): number;
-    constructor(options: ClientCommandManagerOptions);
+    constructor(options: CommandManagerOptions);
     /**
      * Add command to command manager
      * @param commands Any command data or builder
@@ -27,8 +26,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/ModuleManager.d.ts

@@ -0,0 +1,49 @@
+import { Collection } from 'discord.js';
+import { ModuleManagerGetModulePathsOptions, ModuleManagerLoadModulesOptions, ModuleManagerResolveModuleFilesOptions, ModuleManagerStartModulesOptions, ModuleManagerUnloadModulesOptions } from '../../types/paramOptions';
+import { RecipleClient } from '../RecipleClient';
+import { RecipleModule, RecipleScript } from '../RecipleModule';
+export interface ModuleManagerOptions {
+    client: RecipleClient;
+    modules?: (RecipleModule | RecipleScript)[];
+}
+export declare class ModuleManager {
+    readonly client: RecipleClient;
+    readonly modules: Collection<string, RecipleModule>;
+    constructor(options: ModuleManagerOptions);
+    /**
+     * Start modules
+     * @param options start modules options
+     * @returns started modules
+     */
+    startModules(options: ModuleManagerStartModulesOptions): Promise<RecipleModule[]>;
+    /**
+     * Load modules
+     * @param options load modules options
+     * @returns loaded modules
+     */
+    loadModules(options?: ModuleManagerLoadModulesOptions): Promise<RecipleModule[]>;
+    /**
+     * Unload modules
+     * @param options unload modules options
+     * @returns unloaded modules
+     */
+    unloadModules(options?: ModuleManagerUnloadModulesOptions): Promise<RecipleModule[]>;
+    /**
+     * Resolve modules from file paths
+     * @param options resolve module files options
+     * @returns resolved modules
+     */
+    resolveModuleFiles(options: ModuleManagerResolveModuleFilesOptions): Promise<RecipleModule[]>;
+    /**
+     * Validate module script
+     * @param script module script
+     * @returns `true` if script is valid
+     */
+    static validateScript(script: unknown): script is RecipleScript;
+    /**
+     * Get module file paths from folders
+     * @param options get module paths options
+     * @returns module paths
+     */
+    getModulePaths(options?: ModuleManagerGetModulePathsOptions): Promise<string[]>;
+}

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,15 +53,15 @@ export declare type AnySlashCommandOptionsOnlyOptionBuilder = SlashCommandAttach
 /**
  * Types of command builders
  */
-export declare enum CommandBuilderType {
-    MessageCommand = 0,
-    SlashCommand = 1
+export declare enum CommandType {
+    SlashCommand = 1,
+    MessageCommand = 2
 }
 /**
  * Shared command builder methods and properties
  */
 export interface SharedCommandBuilderProperties<T = unknown> {
-    readonly type: CommandBuilderType;
+    readonly type: CommandType;
     cooldown: number;
     requiredBotPermissions: PermissionResolvable[];
     requiredMemberPermissions: PermissionResolvable[];
@@ -111,7 +111,7 @@ 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;
+    type: CommandType.SlashCommand;
     nameLocalizations?: LocalizationMap;
     descriptionLocalizations?: LocalizationMap;
     options?: (AnySlashCommandOptionData | AnySlashCommandOptionBuilder)[];
@@ -179,7 +179,7 @@ export interface SlashCommandSubCommandGroupData extends SharedCommandDataProper
  * 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;
+    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> = CommandErrorHaltData<T, M> | CommandCooldownHaltData<T, M> | (T extends CommandType.SlashCommand ? never : CommandInvalidArgumentsHaltData<T, M> | CommandMissingArgumentsHaltData<T, M>) | CommandMissingMemberPermissionsHaltData<T, M> | CommandMissingBotPermissionsHaltData<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,46 +36,46 @@ 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 CommandErrorHaltData<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 CommandCooldownHaltData<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 CommandInvalidArgumentsHaltData<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 CommandMissingArgumentsHaltData<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 CommandMissingMemberPermissionsHaltData<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 CommandMissingBotPermissionsHaltData<T extends CommandType, M = unknown> extends BaseCommandHaltData<T, M> {
     reason: CommandHaltReason.MissingBotPermissions;
 }
 /**
  * Command halt reasons
  */
 export declare enum CommandHaltReason {
-    Error = 0,
-    Cooldown = 1,
-    InvalidArguments = 2,
-    MissingArguments = 3,
-    MissingMemberPermissions = 4,
-    MissingBotPermissions = 5
+    Error = 1,
+    Cooldown = 2,
+    InvalidArguments = 3,
+    MissingArguments = 4,
+    MissingMemberPermissions = 5,
+    MissingBotPermissions = 6
 }