xernerx 4.0.5 → 4.2.0

package/dist/build/SlashCommandBuilder.d.ts

@@ -42,6 +42,7 @@ export default class SlashCommandBuilder {
         | undefined;
     client: typeof XernerxClient;
     constructor(id: string, options: SlashCommandOptions);
+    autocomplete<T>(interaction: XernerxSlashInteraction, focused: T, options: Array<T>): Promise<void>;
     conditions(interaction: XernerxSlashInteraction, args: SlashCommandArguments): Promise<void>;
     exec(interaction: XernerxSlashInteraction, args: SlashCommandArguments): Promise<void>;
     private addArguments;

package/dist/build/SlashCommandBuilder.js

@@ -82,6 +82,7 @@ export default class SlashCommandBuilder {
         this.defer = options.defer;
         this.client = XernerxClient;
     }
+    async autocomplete(interaction, focused, options) {}
     async conditions(interaction, args) {}
     async exec(interaction, args) {}
     addArguments(command, args) {

package/dist/client/XernerxClient.d.ts

@@ -1,12 +1,12 @@
 import { Client, ClientOptions, Collection } from 'discord.js';
 import { XernerxOptions, ModuleOptions, XernerxCommands, XernerxCache } from '../types/interfaces.js';
 import ClientUtil from '../utils/ClientUtil.js';
-import { InhibitorBuilder } from '../main.js';
+import { InhibitorBuilder, EventBuilder } from '../main.js';
 export default class XernerxClient extends Client {
     readonly settings: {
         ownerId: (string | string[]) & (string | string[] | undefined);
-        local: string;
         global: boolean;
+        local?: string | undefined;
         permissions?:
             | {
                   client: string[];
@@ -27,6 +27,7 @@ export default class XernerxClient extends Client {
                   ready: boolean;
                   error: boolean;
                   info: boolean;
+                  table: string[] | null;
               }
             | undefined;
         cooldown?:
@@ -38,7 +39,7 @@ export default class XernerxClient extends Client {
     };
     readonly config: unknown;
     readonly commands: XernerxCommands;
-    readonly events: Collection<unknown, unknown>;
+    readonly events: Collection<string, EventBuilder>;
     readonly inhibitors: Collection<string, InhibitorBuilder>;
     readonly modules: ModuleOptions;
     readonly util: ClientUtil;
@@ -49,6 +50,6 @@ export default class XernerxClient extends Client {
         shardCount: number;
     };
     readonly cache: XernerxCache;
-    constructor(discordOptions: ClientOptions, xernerxOptions: XernerxOptions, config: unknown);
+    constructor(discordOptions: ClientOptions, xernerxOptions: XernerxOptions, config?: unknown);
     connect(token: string): void;
 }

package/dist/client/XernerxClient.js

@@ -8,20 +8,11 @@ import XernerxLog from '../tools/XernerxLog.js';
 import ClientUtil from '../utils/ClientUtil.js';
 import ExtensionHandler from '../handlers/ExtensionHandler.js';
 export default class XernerxClient extends Client {
-    settings;
-    config;
-    commands;
-    events;
-    inhibitors;
-    modules;
-    util;
-    stats;
-    cache;
     constructor(discordOptions, xernerxOptions, config) {
         super(discordOptions);
         this.settings = z
             .object({
-                local: z.string(),
+                local: z.string().optional(),
                 global: z.boolean().default(false),
                 ownerId: z.string().or(z.array(z.string())).default([]),
                 permissions: z
@@ -44,6 +35,7 @@ export default class XernerxClient extends Client {
                         ready: z.boolean().default(false),
                         info: z.boolean().default(false),
                         error: z.boolean().default(false),
+                        table: z.array(z.string()).or(z.null()).default(null),
                     })
                     .optional(),
                 cooldown: z

package/dist/functions/deploy.js

@@ -1,29 +1,33 @@
 import { GatewayVersion, REST, Routes } from 'discord.js';
 import XernerxLog from '../tools/XernerxLog.js';
-const commands = { slash: [], context: [], retries: 0 };
+import XernerxError from '../tools/XernerxError.js';
+const commands = { slash: [], context: [] };
 export default function deploy(client, type) {
     client.prependOnceListener('ready', (client) => {
         commands[type] = client.commands[type].map((command) => command.data.toJSON());
-        if (commands.retries % 2) {
-            try {
-                if (client.settings.global) {
-                    put(client, client.settings.global, [...commands.slash, ...commands.context]);
-                    put(client, !client.settings.global, []);
-                } else {
-                    put(client, !client.settings.global, [...commands.slash, ...commands.context]);
-                    put(client, client.settings.global, []);
-                }
-            } catch (error) {
-                new XernerxLog(client).error(`An error occurred while deploying the interaction commands!`, error);
-            } finally {
-                new XernerxLog(client).info(`Deployed All Commands ${client.settings.global ? 'globally' : 'locally'}.`);
+        if (!(!!client.modules.options.slash && !!client.modules.options.context && commands.slash.length > 0 && commands.context.length > 0)) return;
+        try {
+            if (client.settings.global) {
+                put(client, client.settings.global, [...commands.slash, ...commands.context]);
+                put(client, !client.settings.global, []);
+            } else {
+                put(client, !client.settings.global, [...commands.slash, ...commands.context]);
+                put(client, client.settings.global, []);
             }
+        } catch (error) {
+            new XernerxLog(client).error(`An error occurred while deploying the interaction commands!`, error);
+        } finally {
+            new XernerxLog(client).info(
+                `Deployed ${[client.commands.message.size, client.commands.slash.size, client.commands.context.size].reduce((a, b) => (a += b))} Commands ${
+                    client.settings.global ? 'globally' : 'locally'
+                }.`
+            );
         }
-        commands.retries++;
     });
 }
 function put(client, global, body) {
     const rest = new REST({ version: GatewayVersion }).setToken(client.token);
-    if (!global) rest.put(Routes.applicationGuildCommands(client.user?.id, client.settings.local), { body });
+    if (!global && !client.settings?.local) throw new XernerxError(`No guild ID provided as local guild!`);
+    if (!global && client.settings?.local) rest.put(Routes.applicationGuildCommands(client.user?.id, client.settings.local), { body });
     else rest.put(Routes.applicationCommands(client.user?.id), { body });
 }

package/dist/handlers/CommandHandler.js

@@ -42,7 +42,7 @@ export default class CommandHandler extends Handler {
             const filePath = `${path.resolve(options.directory)}\\${file}`;
             this.load(filePath, 'MessageCommand');
         }
-        new XernerxLog(this.client).info(`Loaded Message Commands.`);
+        new XernerxLog(this.client).info(`Loaded ${files.length} Message Commands.`);
         this.emit({
             name: 'messageCreate',
             fileType: 'MessageCommand',
@@ -63,6 +63,7 @@ export default class CommandHandler extends Handler {
     //     return reload(this.client, 'message');
     // }
     loadSlashCommands(options) {
+        if (!this.client.settings.local) new XernerxLog(this.client).warn(`Slash commands might not work as you haven't specified a local guild ID.`);
         options = z
             .object({
                 directory: z.string(),
@@ -90,7 +91,7 @@ export default class CommandHandler extends Handler {
             const filePath = `${path.resolve(options.directory)}\\${file}`;
             this.load(filePath, 'SlashCommand');
         }
-        new XernerxLog(this.client).info(`Loaded Slash Commands.`);
+        new XernerxLog(this.client).info(`Loaded ${files.length} Slash Commands.`);
         deploy(this.client, 'slash');
         this.emit({
             name: 'interactionCreate',
@@ -99,6 +100,7 @@ export default class CommandHandler extends Handler {
         });
     }
     loadContextCommands(options) {
+        if (!this.client.settings.local) new XernerxLog(this.client).warn(`Context commands might not work as you haven't specified a local guild ID.`);
         options = z
             .object({
                 directory: z.string(),
@@ -126,7 +128,7 @@ export default class CommandHandler extends Handler {
             const filePath = `${path.resolve(options.directory)}\\${file}`;
             this.load(filePath, 'ContextCommand');
         }
-        new XernerxLog(this.client).info(`Loaded Context Commands.`);
+        new XernerxLog(this.client).info(`Loaded ${files.length} Context Commands.`);
         deploy(this.client, 'context');
         this.emit({
             name: 'interactionCreate',
@@ -135,6 +137,7 @@ export default class CommandHandler extends Handler {
         });
     }
     async messageCommandRun(message, message2) {
+        const filetype = 'MessageCommand';
         if (message.author.bot) return;
         message.util = new MessageUtil(this.client, message);
         message.user = await xernerxUser(message, this.client);
@@ -153,9 +156,10 @@ export default class CommandHandler extends Handler {
         if (message.content && this.client.modules.options.message) {
             const commands = this.client.commands.message;
             const prefixes = Array.isArray(this.client.modules.options.message.prefix) ? this.client.modules.options.message.prefix : [this.client.modules.options.message.prefix];
-            let commandName,
+            let commandName = null,
                 cmd,
-                alias = null;
+                commandAlias = null,
+                commandPrefix = null;
             commands.map((command) => {
                 let prefix = null;
                 if (command.regex && message.content.match(command.regex)) {
@@ -179,47 +183,66 @@ export default class CommandHandler extends Handler {
                             ?.trim()
                             ?.toLowerCase() || '';
                 if (!this.client.commands.message.has(commandName) && command.aliases?.includes(commandName)) {
-                    alias = commandName;
+                    commandAlias = commandName;
                     commandName = command.name;
                 }
+                commandAlias = commandAlias ? commandAlias : commandName;
+                commandPrefix = prefix;
             });
             if (!cmd && this.client.modules.options.message.allowMention) {
                 if (message.mentions.users.has(this.client.user?.id) || message.mentions.repliedUser?.id === this.client.user?.id) {
-                    commandName = message.content.replace(`<@${this.client.user?.id}>`, '').trim().split(/ +/).shift()?.toLowerCase();
+                    commandName = message.content.replace(`<@${this.client.user?.id}>`, '').trim().split(/ +/).shift()?.toLowerCase() || null;
                 }
             }
-            if (!commandName) commandName = '';
             if (this.client.commands.message.has(commandName)) cmd = this.client.commands.message.get(commandName);
             if (await inhibitorValidation(message, cmd)) return;
-            if (!cmd) return this.client.emit('commandNotFound');
-            message.util.alias = alias === commandName ? null : alias;
-            this.exec(cmd, message, await messageArguments(message, cmd), 'MessageCommand');
+            if (!cmd) return this.client.emit('commandNotFound', message, filetype);
+            message.util.parsed = {
+                alias: commandAlias,
+                prefix: commandPrefix,
+            };
+            this.client.emit('commandStart', message, filetype);
+            this.exec(cmd, message, await messageArguments(message, cmd), filetype);
         }
     }
     async slashCommandRun(interaction) {
+        const filetype = 'SlashCommand';
         interaction.util = new InteractionUtil(this.client, interaction);
         interaction.user = await xernerxUser(interaction, this.client);
-        let cmd;
+        let cmd = null;
         if (this.client.commands.slash.has(interaction.commandName)) cmd = this.client.commands.slash.get(interaction.commandName);
         if (await inhibitorValidation(interaction, cmd)) return;
         if (!cmd) return this.client.emit('commandNotFound', interaction);
-        this.exec(cmd, interaction, await interactionArguments(interaction, cmd), 'SlashCommand');
+        new Promise(async (resolve) => {
+            if (interaction.isAutocomplete()) {
+                const focused = interaction.options.getFocused(true);
+                const options = interaction.options;
+                await cmd.autocomplete(interaction, focused, options);
+            } else resolve(true);
+        })
+            .then(async () => {
+                this.client.emit('commandStart', interaction, filetype);
+                await this.exec(cmd, interaction, await interactionArguments(interaction, cmd), filetype);
+            })
+            .catch((error) => this.client.emit('commandError', interaction, error, filetype));
     }
     async contextCommandRun(interaction) {
+        const filetype = 'ContextCommand';
         interaction.util = new InteractionUtil(this.client, interaction);
         interaction.user = await xernerxUser(interaction, this.client);
         let cmd;
         if (this.client.commands.context.has(interaction.commandName)) cmd = this.client.commands.context.get(interaction.commandName);
         if (await inhibitorValidation(interaction, cmd)) return;
-        if (!cmd) return this.client.emit('commandNotFound', interaction);
-        this.exec(cmd, interaction, await interactionArguments(interaction, cmd), 'ContextCommand');
+        if (!cmd) return this.client.emit('commandNotFound', interaction, filetype);
+        this.client.emit('commandStart', interaction, filetype);
+        this.exec(cmd, interaction, await interactionArguments(interaction, cmd), filetype);
     }
     async exec(cmd, event, args, type) {
         try {
             if (await commandValidation(event, cmd)) return;
             if (cmd.conditions && (await cmd.conditions(event, args))) return;
             cmd.exec(event, args);
-            this.client.emit('commandExecute', event, type);
+            this.client.emit('commandFinish', event, type);
         } catch (error) {
             new XernerxLog(this.client).error(`An error occurred executing ${cmd.name}`, error);
             this.client.emit('commandError', event, error, type);

package/dist/handlers/EventHandler.js

@@ -19,6 +19,6 @@ export default class EventHandler extends Handler {
             const data = await this.load(filePath, 'Event');
             this.emit(data);
         }
-        new XernerxLog(this.client).info(`Loaded Events.`);
+        new XernerxLog(this.client).info(`Loaded ${this.client.events.size} Events.`);
     }
 }

package/dist/handlers/ExtensionHandler.js

@@ -14,6 +14,6 @@ export default class ExtensionHandler extends Handler {
                 new XernerxLog(this.client).error(`An error occurred while loading ${extension.name}`, error);
             }
         });
-        new XernerxLog(this.client).info(`Loaded Extensions: ${active.filter((e) => e).join(', ')}`);
+        new XernerxLog(this.client).info(`Loaded ${extensions.length} Extensions: ${active.filter((e) => e).join(', ')}`);
     }
 }

package/dist/handlers/InhibitorHandler.js

@@ -19,6 +19,6 @@ export default class InhibitorHandler extends Handler {
             const data = await this.load(filePath, 'Inhibitor');
             this.emit(data);
         }
-        new XernerxLog(this.client).info(`Loaded Inhibitors.`);
+        new XernerxLog(this.client).info(`Loaded ${this.client.inhibitors.size} Inhibitors.`);
     }
 }

package/dist/main.d.ts

@@ -4,10 +4,11 @@ import SlashCommandBuilder from './build/SlashCommandBuilder.js';
 import ContextCommandBuilder from './build/ContextCommandBuilder.js';
 import EventBuilder from './build/EventBuilder.js';
 import InhibitorBuilder from './build/InhibitorBuilder.js';
+import XernerxLog from './tools/XernerxLog.js';
 export default XernerxClient;
 export * from 'discord.js';
 export * from 'dumfunctions';
 import ExtensionBuilder from 'xernerx-extension-builder';
 import Discord from 'discord.js';
-declare const version = '4.0.5';
-export { XernerxClient, MessageCommandBuilder, SlashCommandBuilder, ContextCommandBuilder, EventBuilder, InhibitorBuilder, ExtensionBuilder, Discord, version };
+declare const version = '4.2.0';
+export { XernerxClient, MessageCommandBuilder, SlashCommandBuilder, ContextCommandBuilder, EventBuilder, InhibitorBuilder, ExtensionBuilder, Discord, version, XernerxLog };

package/dist/main.js

@@ -4,10 +4,11 @@ import SlashCommandBuilder from './build/SlashCommandBuilder.js';
 import ContextCommandBuilder from './build/ContextCommandBuilder.js';
 import EventBuilder from './build/EventBuilder.js';
 import InhibitorBuilder from './build/InhibitorBuilder.js';
+import XernerxLog from './tools/XernerxLog.js';
 export default XernerxClient;
 export * from 'discord.js';
 export * from 'dumfunctions';
 import ExtensionBuilder from 'xernerx-extension-builder';
 import Discord from 'discord.js';
-const version = '4.0.5';
-export { XernerxClient, MessageCommandBuilder, SlashCommandBuilder, ContextCommandBuilder, EventBuilder, InhibitorBuilder, ExtensionBuilder, Discord, version };
+const version = '4.2.0';
+export { XernerxClient, MessageCommandBuilder, SlashCommandBuilder, ContextCommandBuilder, EventBuilder, InhibitorBuilder, ExtensionBuilder, Discord, version, XernerxLog };

package/dist/tools/XernerxLog.d.ts

@@ -5,6 +5,7 @@ export default class XernerxLog {
     private readonly errorLog;
     private readonly infoLog;
     private readonly readyLog;
+    private readonly tableLog;
     constructor(client: XernerxClient);
     info(message: string, force?: boolean): void | null;
     warn(message: string): void | null;

package/dist/tools/XernerxLog.js

@@ -1,14 +1,11 @@
 import { Style } from 'dumfunctions';
 export default class XernerxLog {
-    client;
-    errorLog;
-    infoLog;
-    readyLog;
     constructor(client) {
         this.client = client;
         this.errorLog = client.settings.log?.error;
         this.infoLog = client.settings.log?.info;
         this.readyLog = client.settings.log?.ready;
+        this.tableLog = client.settings.log?.table;
     }
     info(message, force = false) {
         return this.infoLog || force ? console.info(`${Style.log('✔️  | Xernerx', { color: Style.TextColor.Purple })} | ${message}`) : null;
@@ -20,11 +17,32 @@ export default class XernerxLog {
         return this.errorLog ? console.error(`${Style.log('❗ | Xernerx', { color: Style.TextColor.Red })} | ${message}${error ? ` | ${error.stack}` : ''}`) : null;
     }
     ready() {
-        this.client.prependOnceListener('ready', async (synced) =>
+        this.client.prependOnceListener('ready', async (synced) => {
             this.info(
-                `${synced.user.tag} is now online, watching ${(await this.client.guilds.fetch()).size} guilds, using ${await this.client.guilds.fetch(this.client.settings.local)} as local guild.`,
+                `${synced.user.tag} is now online, watching ${(await this.client.guilds.fetch()).size} guilds, using ${
+                    this.client.settings.local ? await this.client.guilds.fetch(this.client.settings.local) : 'none'
+                } as local guild.`,
                 this.readyLog
-            )
-        );
+            );
+            const files = [];
+            for (const [id, data] of this.client.commands.message) {
+                files.push(data);
+            }
+            for (const [id, data] of this.client.commands.slash) {
+                files.push(data);
+            }
+            for (const [id, data] of this.client.commands.context) {
+                files.push(data);
+            }
+            for (const [id, data] of this.client.events) {
+                files.push(data);
+            }
+            for (const [id, data] of this.client.inhibitors) {
+                files.push(data);
+            }
+            if (this.tableLog) {
+                console.table(files, this.tableLog);
+            }
+        });
     }
 }

package/dist/types/extenders.d.ts

@@ -11,13 +11,18 @@ export interface XernerxMember extends GuildMember {
 export interface XernerxGuild extends Guild {}
 export interface XernerxGuildChannel extends GuildChannel {}
 export interface XernerxDMChannel extends DMChannel {}
-interface XernerxCommand {
-    util: InteractionUtil | MessageUtil;
-}
+interface XernerxCommand {}
 export interface XernerxMessage extends Message, XernerxCommand {
     user: XernerxUser;
+    util: MessageUtil;
+}
+export interface XernerxSlashInteraction extends ChatInputCommandInteraction, XernerxCommand {
+    util: InteractionUtil;
+}
+export interface XernerxUserContextInteraction extends UserContextMenuCommandInteraction, XernerxCommand {
+    util: InteractionUtil;
+}
+export interface XernerxMessageContextInteraction extends MessageContextMenuCommandInteraction, XernerxCommand {
+    util: InteractionUtil;
 }
-export interface XernerxSlashInteraction extends ChatInputCommandInteraction, XernerxCommand {}
-export interface XernerxUserContextInteraction extends UserContextMenuCommandInteraction, XernerxCommand {}
-export interface XernerxMessageContextInteraction extends MessageContextMenuCommandInteraction, XernerxCommand {}
 export {};

package/dist/types/interfaces.d.ts

@@ -9,25 +9,29 @@ import SlashCommandBuilder from '../build/SlashCommandBuilder.js';
 import { Locales, MessageCommandArgumentType, PermissionNames, SlashCommandArgumentType, EventType, InhibitorType } from './types.js';
 import ExtensionHandler from '../handlers/ExtensionHandler.js';
 export interface XernerxOptions {
-    ownerId: string;
-    permissions: {
-        client: Array<string>;
-        user: Array<string>;
-        dm: boolean;
-    };
-    ignore: {
-        owner: boolean;
-        users: Array<string>;
-        channels: Array<string>;
-        guilds: Array<string>;
-    };
-    log: {
-        ready: boolean;
-        error: boolean;
-    };
-    cooldown: {
-        command: number;
-        cache: number;
+    local?: string;
+    global?: boolean;
+    ownerId?: string | Array<string>;
+    permissions?: {
+        client?: Array<string>;
+        user?: Array<string>;
+        dm?: boolean;
+    };
+    ignore?: {
+        owner?: boolean;
+        users?: Array<string>;
+        channels?: Array<string>;
+        guilds?: Array<string>;
+    };
+    log?: {
+        ready?: boolean;
+        info?: boolean;
+        error?: boolean;
+        table?: Array<'name' | 'aliases' | 'description' | 'fileType' | 'category'>;
+    };
+    cooldown?: {
+        command?: number;
+        cache?: number;
     };
 }
 export interface ModuleOptions {

package/dist/utils/ClientUtil.d.ts

@@ -1,8 +1,9 @@
-import XernerxClient from '../main.js';
+import XernerxClient from '../client/XernerxClient.js';
 import { PresenceOptions } from '../types/interfaces.js';
 import Util from './Util.js';
 export default class ClientUtil extends Util {
     hasVoted?: Function;
     constructor(client: XernerxClient);
     setPresence(options: PresenceOptions): import('discord.js').ClientPresence | undefined;
+    resolveChannel(query: string | Record<string, string>): Promise<import('discord.js').Channel | null>;
 }

package/dist/utils/ClientUtil.js

@@ -1,11 +1,20 @@
 import setPresence from '../functions/setPresence.js';
 import Util from './Util.js';
 export default class ClientUtil extends Util {
-    hasVoted;
     constructor(client) {
         super(client);
     }
     setPresence(options) {
         return setPresence(this.client, options);
     }
+    async resolveChannel(query) {
+        if (typeof query == 'object') query = query.id;
+        try {
+            let channel = this.client.channels.cache.find((channel) => (channel.name == query.toLowerCase() || channel.id == query.toLowerCase() ? channel : null)) || null;
+            if (!channel) channel = (await this.client.channels.fetch(query)) || null;
+            return channel;
+        } catch {
+            return null;
+        }
+    }
 }

package/dist/utils/MessageUtil.d.ts

@@ -4,7 +4,10 @@ import { XernerxMessage } from '../types/extenders.js';
 import Util from './Util.js';
 export default class MessageUtil extends Util {
     private readonly message;
-    alias: string | null;
+    parsed: {
+        alias: null | string;
+        prefix: null | string;
+    };
     constructor(client: XernerxClient, message: XernerxMessage);
     reply(content: MessagePayload): Promise<import('discord.js').Message<boolean> | undefined>;
     webhookReply(content: MessagePayload, url?: URL, user?: User): Promise<void>;

package/dist/utils/MessageUtil.js

@@ -5,11 +5,13 @@ import sendWebhook from '../functions/sendWebhook.js';
 import XernerxError from '../tools/XernerxError.js';
 export default class MessageUtil extends Util {
     message;
-    alias;
     constructor(client, message) {
         super(client);
         this.message = message;
-        this.alias = null;
+        this.parsed = {
+            alias: null,
+            prefix: null,
+        };
     }
     async reply(content) {
         if (this.client.cache.messages.has(this.message.id)) {

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "xernerx",
-    "version": "4.0.5",
+    "version": "4.2.0",
     "description": "A bot framework for discord.js.",
     "main": "dist/main.js",
     "type": "module",

package/dist/build copy/ContextCommandBuilder.d.ts

@@ -1,37 +0,0 @@
-import { ContextMenuCommandBuilder, Interaction } from 'discord.js';
-import { ContextCommandOptions } from '../types/options.js';
-import XernerxClient from '../client/XernerxClient.js';
-/**
- * @description The command builder for context commands.
- * @param {String} id - The unique ID of the command.
- * @param {ContextCommandOptions} options - The command options.
- */
-export default class ContextCommandBuilder {
-    id: string;
-    data: ContextMenuCommandBuilder;
-    name: any;
-    type: any;
-    description: any;
-    info: any;
-    category: any;
-    channelType: any;
-    cooldown: any;
-    ignore: any;
-    strict: any;
-    permissions: any;
-    defer: any;
-    client: typeof XernerxClient;
-    constructor(id: string, options: ContextCommandOptions);
-    /**
-     * @param {Interaction} interaction - The Discord interaction event data.
-     * @description make any preconditions here.
-     * TODO - update description
-     */
-    conditions(interaction: Interaction, args: any): Promise<void>;
-    /**
-     * @param {Interaction} interaction - The Discord interaction event data.
-     * @description Make your custom command here.
-     * TODO - update description
-     */
-    exec(interaction: Interaction, args: any): Promise<void>;
-}