reciple 6.0.0-dev.17 → 6.0.0-dev.19

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

@@ -1,103 +1,103 @@
-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';
-/**
- * Options for {@link RecipleClient}
- */
-export interface RecipleClientOptions extends ClientOptions {
-    config?: Config;
-    cwd?: string;
-}
-/**
- * Reciple client events
- */
-export interface RecipleClientEvents extends ClientEvents {
-    recipleCommandExecute: [executeData: AnyCommandExecuteData];
-    recipleCommandHalt: [haltData: AnyCommandHaltData];
-    recipleRegisterApplicationCommands: [];
-    recipleReplyError: [error: unknown];
-}
-/**
- * Reciple client
- */
-export interface RecipleClient<Ready extends boolean = boolean> extends Client<Ready> {
-    on<E extends keyof RecipleClientEvents>(event: E, listener: (...args: RecipleClientEvents[E]) => Awaitable<void>): this;
-    on<E extends string | symbol>(event: E, listener: (...args: any) => Awaitable<void>): this;
-    once<E extends keyof RecipleClientEvents>(event: E, listener: (...args: RecipleClientEvents[E]) => Awaitable<void>): this;
-    once<E extends keyof string | symbol>(event: E, listener: (...args: any) => Awaitable<void>): this;
-    emit<E extends keyof RecipleClientEvents>(event: E, ...args: RecipleClientEvents[E]): boolean;
-    emit<E extends string | symbol>(event: E, ...args: any): boolean;
-    off<E extends keyof RecipleClientEvents>(event: E, listener: (...args: RecipleClientEvents[E]) => Awaitable<void>): this;
-    off<E extends string | symbol>(event: E, listener: (...args: any) => Awaitable<void>): this;
-    removeAllListeners<E extends keyof RecipleClientEvents>(event?: E): this;
-    removeAllListeners(event?: string | symbol): this;
-    isReady(): this is RecipleClient<true>;
-}
-export declare class RecipleClient<Ready extends boolean = boolean> extends Client<Ready> {
-    readonly config: Config;
-    readonly commands: ClientCommandManager;
-    readonly applicationCommands: ApplicationCommandManager;
-    readonly cooldowns: CommandCooldownManager;
-    readonly modules: ClientModuleManager;
-    readonly cwd: string;
-    readonly logger: Logger;
-    readonly version: string;
-    get isClientLogsSilent(): boolean;
-    /**
-     * @param options Client options
-     */
-    constructor(options: RecipleClientOptions);
-    /**
-     * Listed to command executions
-     */
-    addCommandListeners(): RecipleClient<Ready>;
-    /**
-     * Execute a slash command
-     * @param interaction Slash command interaction
-     */
-    slashCommandExecute(interaction: Interaction | ChatInputCommandInteraction): Promise<undefined | SlashCommandExecuteData>;
-    /**
-     * Execute a Message command
-     * @param message Message command executor
-     * @param prefix Message command prefix
-     */
-    messageCommandExecute(message: Message, prefix?: string): Promise<undefined | MessageCommandExecuteData>;
-    /**
-     * Get a message from config
-     * @param messageKey Config messages key
-     * @param defaultMessage Default message when the key does not exists
-     */
-    getConfigMessage<T = unknown>(messageKey: string, defaultMessage?: T): T;
-    /**
-     * Emits the {@link RecipleClientEvents["recipleReplyError"]} event
-     * @param error Received Error
-     */
-    protected _replyError(error: unknown): void;
-    /**
-     * Executes command halt function
-     * @param command Halted command's builder
-     * @param haltData Halted command's data
-     */
-    protected _haltCommand(command: SlashCommandBuilder, haltData: SlashCommandHaltData): Promise<boolean>;
-    protected _haltCommand(command: MessageCommandBuilder, haltData: MessageCommandHaltData): Promise<boolean>;
-    /**
-     * Executes a command's {@link SharedCommandBuilderProperties["execute"]} method
-     * @param command Command builder
-     * @param executeData Command execute data
-     */
-    protected _executeCommand(command: SlashCommandBuilder, executeData: SlashCommandExecuteData): Promise<SlashCommandExecuteData | undefined>;
-    protected _executeCommand(command: MessageCommandBuilder, executeData: MessageCommandExecuteData): Promise<MessageCommandExecuteData | undefined>;
-    /**
-     * Error message when a command fails to execute
-     * @param err Received error
-     * @param command Slash/Message command execute data
-     */
-    protected _commandExecuteError(err: Error, command: AnyCommandExecuteData): Promise<void>;
-}
+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';
+/**
+ * Options for {@link RecipleClient}
+ */
+export interface RecipleClientOptions extends ClientOptions {
+    config?: Config;
+    cwd?: string;
+}
+/**
+ * Reciple client events
+ */
+export interface RecipleClientEvents extends ClientEvents {
+    recipleCommandExecute: [executeData: AnyCommandExecuteData];
+    recipleCommandHalt: [haltData: AnyCommandHaltData];
+    recipleRegisterApplicationCommands: [];
+    recipleReplyError: [error: unknown];
+}
+/**
+ * Reciple client
+ */
+export interface RecipleClient<Ready extends boolean = boolean> extends Client<Ready> {
+    on<E extends keyof RecipleClientEvents>(event: E, listener: (...args: RecipleClientEvents[E]) => Awaitable<void>): this;
+    on<E extends string | symbol>(event: E, listener: (...args: any) => Awaitable<void>): this;
+    once<E extends keyof RecipleClientEvents>(event: E, listener: (...args: RecipleClientEvents[E]) => Awaitable<void>): this;
+    once<E extends keyof string | symbol>(event: E, listener: (...args: any) => Awaitable<void>): this;
+    emit<E extends keyof RecipleClientEvents>(event: E, ...args: RecipleClientEvents[E]): boolean;
+    emit<E extends string | symbol>(event: E, ...args: any): boolean;
+    off<E extends keyof RecipleClientEvents>(event: E, listener: (...args: RecipleClientEvents[E]) => Awaitable<void>): this;
+    off<E extends string | symbol>(event: E, listener: (...args: any) => Awaitable<void>): this;
+    removeAllListeners<E extends keyof RecipleClientEvents>(event?: E): this;
+    removeAllListeners(event?: string | symbol): this;
+    isReady(): this is RecipleClient<true>;
+}
+export declare class RecipleClient<Ready extends boolean = boolean> extends Client<Ready> {
+    readonly config: Config;
+    readonly commands: ClientCommandManager;
+    readonly applicationCommands: ApplicationCommandManager;
+    readonly cooldowns: CommandCooldownManager;
+    readonly modules: ClientModuleManager;
+    readonly cwd: string;
+    readonly logger: Logger;
+    readonly version: string;
+    get isClientLogsSilent(): boolean;
+    /**
+     * @param options Client options
+     */
+    constructor(options: RecipleClientOptions);
+    /**
+     * Listed to command executions
+     */
+    addCommandListeners(): RecipleClient<Ready>;
+    /**
+     * Execute a slash command
+     * @param interaction Slash command interaction
+     */
+    slashCommandExecute(interaction: Interaction | ChatInputCommandInteraction): Promise<undefined | SlashCommandExecuteData>;
+    /**
+     * Execute a Message command
+     * @param message Message command executor
+     * @param prefix Message command prefix
+     */
+    messageCommandExecute(message: Message, prefix?: string): Promise<undefined | MessageCommandExecuteData>;
+    /**
+     * Get a message from config
+     * @param messageKey Config messages key
+     * @param defaultMessage Default message when the key does not exists
+     */
+    getConfigMessage<T = unknown>(messageKey: string, defaultMessage?: T): T;
+    /**
+     * Emits the {@link RecipleClientEvents["recipleReplyError"]} event
+     * @param error Received Error
+     */
+    protected _replyError(error: unknown): void;
+    /**
+     * Executes command halt function
+     * @param command Halted command's builder
+     * @param haltData Halted command's data
+     */
+    protected _haltCommand(command: SlashCommandBuilder, haltData: SlashCommandHaltData): Promise<boolean>;
+    protected _haltCommand(command: MessageCommandBuilder, haltData: MessageCommandHaltData): Promise<boolean>;
+    /**
+     * Executes a command's {@link SharedCommandBuilderProperties["execute"]} method
+     * @param command Command builder
+     * @param executeData Command execute data
+     */
+    protected _executeCommand(command: SlashCommandBuilder, executeData: SlashCommandExecuteData): Promise<SlashCommandExecuteData | undefined>;
+    protected _executeCommand(command: MessageCommandBuilder, executeData: MessageCommandExecuteData): Promise<MessageCommandExecuteData | undefined>;
+    /**
+     * Error message when a command fails to execute
+     * @param err Received error
+     * @param command Slash/Message command execute data
+     */
+    protected _commandExecuteError(err: Error, command: AnyCommandExecuteData): Promise<void>;
+}

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

@@ -1,100 +1,100 @@
-import { ClientOptions, PermissionResolvable } from 'discord.js';
-/**
- * Command permissions config object interface
- */
-export interface ConfigCommandPermissions {
-    /**
-     * Command name
-     */
-    command: string;
-    /**
-     * Override command builder permissions
-     */
-    permissions: PermissionResolvable[];
-}
-/**
- * Reciple config object interface
- */
-export interface Config {
-    token: string;
-    commands: {
-        slashCommand: {
-            enabled: boolean;
-            replyOnError: boolean;
-            registerCommands: boolean;
-            allowRegisterEmptyCommandList: boolean;
-            enableCooldown: boolean;
-            setRequiredPermissions: boolean;
-            acceptRepliedInteractions: boolean;
-            guilds?: string[] | string;
-            permissions: {
-                enabled: boolean;
-                commands: ConfigCommandPermissions[];
-            };
-        };
-        messageCommand: {
-            enabled: boolean;
-            prefix?: string;
-            replyOnError: boolean;
-            allowCommandAlias: boolean;
-            enableCooldown: boolean;
-            commandArgumentSeparator: string;
-            permissions: {
-                enabled: boolean;
-                commands: ConfigCommandPermissions[];
-            };
-        };
-    };
-    fileLogging: {
-        enabled: boolean;
-        debugmode: boolean;
-        clientLogs: boolean;
-        stringifyLoggedJSON: boolean;
-        logFilePath: string;
-    };
-    client: ClientOptions;
-    messages: {
-        [messageKey: string]: any;
-    };
-    ignoredFiles: string[];
-    modulesFolder: string | string[];
-    disableVersionCheck: boolean;
-    version: string;
-}
-/**
- * Create/parse reciple config
- */
-export declare class RecipleConfig {
-    config: Config;
-    configPath: string;
-    static defaultConfigPath: string;
-    /**
-     * @param configPath Path to config
-     */
-    constructor(configPath: string);
-    /**
-     * Parse the config file
-     */
-    parseConfig(): this;
-    /**
-     * Returns the parsed config file
-     */
-    getConfig(): Config;
-    /**
-     * Parse token from config
-     * @param askIfNull Ask for token if the token is null/undefined
-     */
-    parseToken(askIfNull?: boolean): string | null;
-    /**
-     * Check if the config version is supported
-     */
-    protected _isSupportedConfig(): boolean;
-    /**
-     * Ask for a token
-     */
-    protected _askToken(): string | null;
-    /**
-     * Get default config
-     */
-    static getDefaultConfig(): Config;
-}
+import { ClientOptions, PermissionResolvable } from 'discord.js';
+/**
+ * Command permissions config object interface
+ */
+export interface ConfigCommandPermissions {
+    /**
+     * Command name
+     */
+    command: string;
+    /**
+     * Override command builder permissions
+     */
+    permissions: PermissionResolvable[];
+}
+/**
+ * Reciple config object interface
+ */
+export interface Config {
+    token: string;
+    commands: {
+        slashCommand: {
+            enabled: boolean;
+            replyOnError: boolean;
+            registerCommands: boolean;
+            allowRegisterEmptyCommandList: boolean;
+            enableCooldown: boolean;
+            setRequiredPermissions: boolean;
+            acceptRepliedInteractions: boolean;
+            guilds?: string[] | string;
+            permissions: {
+                enabled: boolean;
+                commands: ConfigCommandPermissions[];
+            };
+        };
+        messageCommand: {
+            enabled: boolean;
+            prefix?: string;
+            replyOnError: boolean;
+            allowCommandAlias: boolean;
+            enableCooldown: boolean;
+            commandArgumentSeparator: string;
+            permissions: {
+                enabled: boolean;
+                commands: ConfigCommandPermissions[];
+            };
+        };
+    };
+    fileLogging: {
+        enabled: boolean;
+        debugmode: boolean;
+        clientLogs: boolean;
+        stringifyLoggedJSON: boolean;
+        logFilePath: string;
+    };
+    client: ClientOptions;
+    messages: {
+        [messageKey: string]: any;
+    };
+    ignoredFiles: string[];
+    modulesFolder: string | string[];
+    disableVersionCheck: boolean;
+    version: string;
+}
+/**
+ * Create/parse reciple config
+ */
+export declare class RecipleConfig {
+    config: Config;
+    configPath: string;
+    static defaultConfigPath: string;
+    /**
+     * @param configPath Path to config
+     */
+    constructor(configPath: string);
+    /**
+     * Parse the config file
+     */
+    parseConfig(): this;
+    /**
+     * Returns the parsed config file
+     */
+    getConfig(): Config;
+    /**
+     * Parse token from config
+     * @param askIfEmpty Ask for token if the token is undefined
+     */
+    parseToken(askIfEmpty?: boolean): string | null;
+    /**
+     * Check if the config version is supported
+     */
+    protected _isSupportedConfig(): boolean;
+    /**
+     * Ask for a token
+     */
+    protected _askToken(): string | null;
+    /**
+     * Get default config
+     */
+    static getDefaultConfig(): Config;
+}

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

@@ -1,56 +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;
-}
+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;
+}