xernerx 3.5.0 → 3.5.2

package/dist/mjs/utils/CommandUtil.js

@@ -0,0 +1,247 @@
+'use strict';
+var __importDefault =
+    (this && this.__importDefault) ||
+    function (mod) {
+        return mod && mod.__esModule ? mod : { default: mod };
+    };
+Object.defineProperty(exports, '__esModule', { value: true });
+exports.InteractionCommandUtil = exports.MessageCommandUtil = void 0;
+const discord_js_1 = require('discord.js');
+const XernerxError_js_1 = __importDefault(require('../tools/XernerxError.js'));
+class MessageCommandUtil {
+    client;
+    message;
+    constructor(client, message) {
+        this.client = client;
+        this.message = message;
+    }
+    async reply(content) {
+        if (this.client.cache.messages.has(this.message.id)) var existingMessage = this.client.cache.messages.get(this.message.id);
+        if (!existingMessage) {
+            const msg = await this.message.reply(content);
+            this.message.response = msg.id;
+            if (this.client.handlerOptions.message?.handleEdits || this.client.handlerOptions.message?.handleDeletes) {
+                this.client.cache.messages.set(this.message.id, this.message);
+                setInterval(() => {
+                    this.client.cache.messages.delete(this.message.id);
+                }, this.client.settings.cooldown?.cache || 300000);
+            }
+            return msg;
+        }
+        if (existingMessage && this.client.handlerOptions.message?.handleEdits) {
+            try {
+                const msg = await this.message.channel.messages.fetch(existingMessage.response);
+                msg.edit(content);
+                return msg;
+            } catch {
+                const msg = await this.message.reply(content);
+                this.message.response = msg.id;
+                if (this.client.handlerOptions.message?.handleEdits || this.client.handlerOptions.message?.handleDeletes) {
+                    this.client.cache.messages.set(this.message.id, this.message);
+                    setInterval(() => {
+                        this.client.cache.messages.delete(this.message.id);
+                    }, this.client.settings.cooldown?.cache || 300000);
+                }
+            }
+        }
+    }
+    async send(content) {
+        if (this.client.cache.messages.has(this.message.id)) var existingMessage = this.client.cache.messages.get(this.message.id);
+        if (!existingMessage) {
+            const msg = await this.message.channel.send(content);
+            this.message.response = msg.id;
+            if (this.client.handlerOptions.message?.handleEdits || this.client.handlerOptions.message?.handleDeletes) {
+                this.client.cache.messages.set(this.message.id, this.message);
+                setInterval(() => {
+                    this.client.cache.messages.delete(this.message.id);
+                }, this.client.settings.cooldown?.cache || 300000);
+            }
+            return msg;
+        }
+        if (existingMessage && this.client.handlerOptions.message?.handleEdits) {
+            try {
+                const msg = await this.message.channel.messages.fetch(existingMessage.response);
+                msg.edit(content);
+                return msg;
+            } catch {
+                const msg = await this.message.channel.send(content);
+                this.message.response = msg.id;
+                if (this.client.handlerOptions.message?.handleEdits || this.client.handlerOptions.message?.handleDeletes) {
+                    this.client.cache.messages.set(this.message.id, this.message);
+                    setInterval(() => {
+                        this.client.cache.messages.delete(this.message.id);
+                    }, this.client.settings.cooldown?.cache || 300000);
+                }
+            }
+        }
+    }
+    async defer(time) {
+        return new Promise((resolve) => setTimeout(resolve, time));
+    }
+    getCommands() {
+        return this.client.commands.message;
+    }
+    getCommandName() {}
+    selectMenuPaginator(embeds, options) {}
+    buttonPaginator(embeds, options) {}
+    buttonMenuPaginator(embeds, options) {}
+    isOwner() {
+        return this.client.util.isOwner(this.message.author.id);
+    }
+    createModal() {}
+}
+exports.MessageCommandUtil = MessageCommandUtil;
+class InteractionCommandUtil {
+    client;
+    interaction;
+    constructor(client, interaction) {
+        this.client = client;
+        this.interaction = interaction;
+    }
+    reply(content) {
+        return this.interaction.replied || this.interaction.deferred ? this.interaction.editReply(content) : this.interaction.reply(content);
+    }
+    async defer(time) {
+        return new Promise((resolve) => setTimeout(resolve, time));
+    }
+    getCommands() {
+        if (this.interaction.commandType === 1) return this.client.commands.slash;
+        else return this.client.commands.context;
+    }
+    getCommandName() {}
+    selectMenuPaginator(embeds, options) {
+        if (!Array.isArray(embeds)) throw new XernerxError_js_1.default(`Expected embeds to be of type array, received ${typeof embeds} instead.`);
+        if (embeds.length > 25) throw new XernerxError_js_1.default(`Max select menu length is 25.`);
+        if (typeof options !== 'object') options = {};
+        if (!Array.isArray(options.components)) options.components = [];
+        if (!options.index) {
+            options.index = new discord_js_1.EmbedBuilder().setTitle('Index').setColor('Random');
+            for (const embed of embeds) {
+                options.index.addFields([
+                    {
+                        name: embed.data.title || 'No Name',
+                        value: embed.data.description || 'Page',
+                        inline: embeds.length > 25 / 2 ? true : false,
+                    },
+                ]);
+            }
+        }
+        if (!options.row) {
+            options.row = new discord_js_1.ActionRowBuilder();
+            if (!options.id) options.id = `${this.interaction.id}-menu`;
+            options.component = new discord_js_1.StringSelectMenuBuilder()
+                .setCustomId(options.id)
+                .setMaxValues(1)
+                .setMinValues(1)
+                .setPlaceholder('Select a page.')
+                .addOptions({ label: 'index', value: '0' });
+            embeds.map((embed, i = 0) => {
+                options?.component?.addOptions({
+                    label: embed.data.title || 'No Name',
+                    description: embed.data.description || `Page ${i}`,
+                    value: String(i + 1),
+                });
+            });
+            options.row.addComponents(options.component);
+        }
+        embeds.unshift(options.index);
+        const content = {
+            embeds: [options.index],
+            components: [options.row, ...options.components],
+            ephemeral: !!options.ephemeral,
+        };
+        (options.reply === undefined || options.reply === true ? this.interaction.util.reply(content) : this.interaction.channel.send(content)).then(() => {
+            const collector = this.interaction.channel
+                .createMessageComponentCollector({
+                    filter: options?.filter,
+                    time: options?.time || 60000,
+                })
+                .on('collect', (interaction) => {
+                    if (!interaction.customId.startsWith(this.interaction.id)) return;
+                    interaction.update({
+                        embeds: [embeds[parseInt(interaction.values[0])]],
+                    });
+                })
+                .on('end', () => {
+                    this.interaction.editReply({ components: [] });
+                });
+        });
+    }
+    buttonPaginator(embeds, options) {
+        if (!Array.isArray(embeds)) throw new XernerxError_js_1.default(`Expected embeds to be of type array, received ${typeof embeds} instead.`);
+        if (embeds.length <= 0) throw new XernerxError_js_1.default(`The minimum embeds is 1.`);
+        if (typeof options !== 'object') options = {};
+        if (!Array.isArray(options.components)) options.components = [];
+        if (!options.row) {
+            options.row = new discord_js_1.ActionRowBuilder();
+            if (!options.id) options.id = `${this.interaction.id}-menu`;
+        }
+        if (!options.buttons) options.buttons = ['⏮️', '◀️', '⏹️', '▶️', '⏭️'];
+        for (const button of options.buttons) {
+            options.row.addComponents(
+                new discord_js_1.ButtonBuilder()
+                    .setCustomId(`${this.interaction.id}-${options.buttons.indexOf(button)}`)
+                    .setEmoji(button)
+                    .setStyle(discord_js_1.ButtonStyle.Primary)
+            );
+        }
+        let embed = embeds[options.index || 0];
+        const content = {
+            embeds: [embed],
+            components: [options.row, ...options.components],
+            ephemeral: !!options.ephemeral,
+        };
+        (options.reply === undefined || options.reply === true ? this.interaction.util.reply(content) : this.interaction.channel.send(content)).then((message) => {
+            const collector = message.channel
+                .createMessageComponentCollector({
+                    filter: options.filter,
+                    time: options?.time || 60000,
+                })
+                .on('collect', (interaction) => {
+                    let stop = false;
+                    if (interaction.customId.startsWith(this.interaction.id)) {
+                        switch (Number(interaction.customId.split(/-/).pop())) {
+                            case 0: {
+                                embed = embeds[0];
+                                break;
+                            }
+                            case 1: {
+                                embed = embeds[embeds.indexOf(embed) >= 1 ? embeds.indexOf(embed) - 1 : 0];
+                                break;
+                            }
+                            case 2: {
+                                collector.stop();
+                                stop = true;
+                                break;
+                            }
+                            case 3: {
+                                embed = embeds[embeds.indexOf(embed) < embeds.length - 1 ? embeds.indexOf(embed) + 1 : embeds.length - 1];
+                                break;
+                            }
+                            case 4: {
+                                embed = embeds[embeds.length - 1];
+                                break;
+                            }
+                        }
+                        stop
+                            ? interaction.update({
+                                  embeds: [embed],
+                                  components: [],
+                              })
+                            : interaction.update({
+                                  embeds: [embed],
+                              });
+                    }
+                })
+                .on('end', () => {
+                    this.interaction.editReply({ components: [] });
+                });
+        });
+    }
+    buttonMenuPaginator(embeds, options) {}
+    isOwner() {
+        return this.client.util.isOwner(this.interaction.user.id);
+    }
+    createModal() {}
+}
+exports.InteractionCommandUtil = InteractionCommandUtil;

package/dist/mjs/validators/CommandValidations.d.ts

@@ -0,0 +1,12 @@
+import { Interaction } from 'discord.js';
+import ContextCommandBuilder from '../build/ContextCommandBuilder.js';
+import MessageCommandBuilder from '../build/MessageCommandBuilder.js';
+import SlashCommandBuilder from '../build/SlashCommandBuilder.js';
+import XernerxClient from '../client/XernerxClient.js';
+import { XernerxMessage } from '../types/types.js';
+export default function commandValidation(
+    action: XernerxMessage | Interaction,
+    command: SlashCommandBuilder | MessageCommandBuilder | ContextCommandBuilder | any,
+    client: XernerxClient,
+    res?: boolean
+): boolean;

package/dist/mjs/validators/CommandValidations.js

@@ -0,0 +1,169 @@
+'use strict';
+Object.defineProperty(exports, '__esModule', { value: true });
+const discord_js_1 = require('discord.js');
+const enums_js_1 = require('../types/enums.js');
+function getUser(from) {
+    if (from instanceof discord_js_1.Message) return from.author;
+    else return from.user;
+}
+function commandValidation(action, command, client, res = false) {
+    let user = getUser(action);
+    if ((command.ignoreOwner || client.settings.ignore?.owner) && client.util.isOwner(user.id)) return res;
+    else if (inCooldown(user, client, command, action)) return true;
+    else if (command.owner && !client.util.isOwner(user.id)) {
+        res = true;
+        emit(client, action, command, 'Not an owner', client.settings.ownerId);
+    } else if (command.channelType?.length > 0 || command.channelType) {
+        if (!Array.isArray(command.channelType)) command.channelType = [command.channelType];
+        if (!command?.channelType?.includes(action.channel?.type)) {
+            res = true;
+            emit(client, action, command, 'Not the correct channel', command.channelType);
+        }
+    } else if (command.channels?.length > 0 && !command.channels.includes(action.channel?.id)) {
+        res = true;
+        emit(client, action, command, 'Not a whitelisted channel', command.channels);
+    } else if (command.guilds?.length > 0 && !command.guilds.includes(action.guild?.id)) {
+        res = true;
+        emit(client, action, command, 'Not a whitelisted guild', command.guilds);
+    } else if (command.channelType && command.channelType !== action.channel?.type) {
+        res = true;
+        emit(client, action, command, 'Not the correct type of channel', command.channelType);
+    } else if (action?.guild && (command.permissions?.user || client.settings.permissions?.user)) {
+        const permissions = command.permissions?.user || client?.settings?.permissions?.user?.push(...handlerPermissions(client, command.commandType, 'user')),
+            missing = [];
+        if (Array.isArray(permissions))
+            permissions.map((permission) => {
+                if (!(action.member?.permissions).has(permission)) {
+                    missing.push(permission);
+                }
+            });
+        if (missing.length > 0) {
+            res = true;
+            emit(client, action, command, 'Missing User Permissions', missing);
+        }
+    } else if (action?.guild && (command.permissions?.client || client.settings.permissions?.client)) {
+        const permissions = command.permissions?.client || client?.settings?.permissions?.client?.push(...handlerPermissions(client, command.commandType, 'client')),
+            missing = [];
+        if (Array.isArray(permissions))
+            permissions.map((permission) => {
+                if (!(action.member?.permissions).has(permission)) {
+                    missing.push(permission);
+                }
+            });
+        if (missing.length > 0) {
+            res = true;
+            emit(client, action, command, 'Missing Client Permissions', missing);
+        }
+    }
+    return res;
+}
+exports.default = commandValidation;
+function emit(client, action, command, reason, extra) {
+    return client.emit('commandBlock', action, command, reason, extra);
+}
+function inCooldown(user, client, command, action) {
+    let res = false,
+        downs = {};
+    const { cooldowns, messageCommands, slashCommands, contextCommands, commands } = client.cache;
+    if (command.commandType === enums_js_1.CommandType.MessageCommand && client.handlerOptions.message.cooldown) {
+        if (messageCommands.has(user.id)) {
+            const usr = messageCommands.get(user.id);
+            usr.timeRemaining = usr.endsAt - Date.now();
+            downs.message = usr;
+            res = true;
+        }
+        if (!messageCommands.has(user.id)) {
+            messageCommands.set(user.id, toCooldown(action, command, client.handlerOptions.message.cooldown, user.id));
+            setInterval(() => {
+                messageCommands.delete(user.id);
+            }, client.handlerOptions.message.cooldown);
+        }
+    }
+    if (command.commandType === enums_js_1.CommandType.SlashCommand && client.handlerOptions.slash.cooldown) {
+        if (slashCommands.has(user.id)) {
+            const usr = slashCommands.get(user.id);
+            usr.timeRemaining = usr.endsAt - Date.now();
+            downs.slash = usr;
+            res = true;
+        }
+        if (!slashCommands.has(user.id)) {
+            slashCommands.set(user.id, toCooldown(action, command, client.handlerOptions.slash.cooldown, user.id));
+            setInterval(() => {
+                slashCommands.delete(user.id);
+            }, client.handlerOptions.slash.cooldown);
+        }
+    }
+    if (command.commandType === enums_js_1.CommandType.ContextCommand && client.handlerOptions.context.cooldown) {
+        if (contextCommands.has(user.id)) {
+            const usr = contextCommands.get(user.id);
+            usr.timeRemaining = usr.endsAt - Date.now();
+            downs.context = usr;
+            res = true;
+        }
+        if (!contextCommands.has(user.id)) {
+            contextCommands.set(user.id, toCooldown(action, command, client.handlerOptions.context.cooldown, user.id));
+            setInterval(() => {
+                contextCommands.delete(user.id);
+            }, client.handlerOptions.context.cooldown);
+        }
+    }
+    if (client.settings?.cooldown?.default) {
+        if (cooldowns.has(user.id)) {
+            const usr = cooldowns.get(user.id);
+            usr.timeRemaining = usr.endsAt - Date.now();
+            downs.default = usr;
+            res = true;
+        }
+        if (!cooldowns.has(user.id)) {
+            cooldowns.set(user.id, toCooldown(action, command, client.settings.cooldown.default, user.id));
+            setInterval(() => {
+                cooldowns.delete(user.id);
+            }, client.settings.cooldown.default);
+        }
+    }
+    if (command.cooldown) {
+        const name = user.id + '-' + (command.data?.name || command?.name) + '-' + command.commandType;
+        if (commands.has(name)) {
+            const usr = commands.get(name);
+            usr.timeRemaining = usr.endsAt - Date.now();
+            downs.command = usr;
+            res = true;
+        }
+        if (!commands.has(name)) {
+            commands.set(name, toCooldown(action, command, command.cooldown, name));
+            setInterval(() => {
+                commands.delete(name);
+            }, command.cooldown);
+        }
+    }
+    if (Object.keys(downs).length > 0) client.emit('commandCooldown', action, command, downs);
+    return res;
+}
+function toCooldown(action, command, cooldown, name) {
+    let user = getUser(action);
+    return {
+        name,
+        id: user.id,
+        tag: user.tag,
+        commandType: command.commandType,
+        commandName: command?.data?.name || command?.name,
+        guildId: action?.guild?.id,
+        channelId: action?.channel?.id,
+        startsAt: Number(Date.now()),
+        endsAt: Number(Date.now()) + cooldown,
+    };
+}
+function handlerPermissions(client, commandType, type) {
+    let permissions = [];
+    if (commandType === enums_js_1.CommandType.MessageCommand) {
+        if (type === 'user') permissions = client.handlerOptions.message?.userPermissions || [];
+        else if (type === 'client') permissions = client.handlerOptions.message?.clientPermissions || [];
+    } else if (commandType === enums_js_1.CommandType.SlashCommand) {
+        if (type === 'user') permissions = client.handlerOptions.slash?.userPermissions || [];
+        else if (type === 'client') permissions = client.handlerOptions.slash?.clientPermissions || [];
+    } else if (commandType === enums_js_1.CommandType.ContextCommand) {
+        if (type === 'user') permissions = client.handlerOptions.context?.userPermissions || [];
+        else if (type === 'client') permissions = client.handlerOptions.context?.clientPermissions || [];
+    }
+    return permissions;
+}

package/dist/mjs/validators/InhibitorValidations.d.ts

@@ -0,0 +1,11 @@
+import XernerxClient from '../client/XernerxClient.js';
+import { XernerxInteraction, XernerxMessage } from '../types/types.js';
+export declare class InhibitorValidation {
+    client: XernerxClient;
+    action: XernerxMessage | XernerxInteraction;
+    command: string;
+    inhibited: Record<string, string | void>;
+    constructor(client: XernerxClient, action: XernerxMessage | XernerxInteraction, command: string);
+    inhibit(): Promise<Record<string, string | void> | undefined>;
+    private args;
+}

package/dist/mjs/validators/InhibitorValidations.js

@@ -0,0 +1,40 @@
+'use strict';
+Object.defineProperty(exports, '__esModule', { value: true });
+exports.InhibitorValidation = void 0;
+const enums_js_1 = require('../types/enums.js');
+class InhibitorValidation {
+    client;
+    action;
+    command;
+    inhibited;
+    constructor(client, action, command) {
+        this.client = client;
+        this.action = action;
+        this.command = command;
+        this.inhibited = {};
+    }
+    async inhibit() {
+        for (const inhibitor of this.client.inhibitors) {
+            const inhibit = inhibitor[1];
+            if (inhibit) this.inhibited[inhibit.name] = await inhibit.check(this.action, this.args(this.action, inhibit.type));
+        }
+        for (const inhibit of Object.values(this.inhibited)) {
+            if (inhibit) return this.inhibited;
+        }
+    }
+    args(action, type) {
+        if (type === enums_js_1.InhibitorType.Channel) return action.channel;
+        if (type === enums_js_1.InhibitorType.User) return action.author || action.user;
+        if (type === enums_js_1.InhibitorType.Guild) return action.guild;
+        if (type === enums_js_1.InhibitorType.Member) return action.member;
+        // if (type === InhibitorType.Command)
+        // 	return this.client.util.getAllCommands().filter(this.command.name);
+        // if (type === InhibitorType.MessageCommand)
+        // 	return this.client.util.getAllMessageCommands().find(this.command.name);
+        // if (type === InhibitorType.SlashCommand)
+        // 	return this.client.util.getAllSlashCommands().find(this.command.name);
+        // if (type === InhibitorType.ContextCommand)
+        // 	return this.client.util.getAllContextCommands().find(this.command.name);
+    }
+}
+exports.InhibitorValidation = InhibitorValidation;

package/package.json

@@ -1,9 +1,9 @@
 {
     "name": "xernerx",
-    "version": "3.5.0",
-    "type": "module",
+    "version": "3.5.2",
     "description": "A bot framework for discord.js.",
-    "main": "dist/main.js",
+    "main": "dist/cjs/main.js",
+    "module": "dist/mjs/main.js",
     "keywords": [
         "discord.js",
         "discord",
@@ -17,13 +17,6 @@
     "license": "MIT",
     "homepage": "https://xernerx.github.io/xernerx/home.html",
     "packageManager": "npm@8.5.5",
-    "exports": {
-        "import": "./dist/main.js",
-        "require": "./dist/main.cjs",
-        "types": "./types",
-        "node": null,
-        "default": null
-    },
     "scripts": {
         "start": "npm i && npm fund && npm audit fix --force && npm link && tsc -w",
         "patch": "npm run write && git add . && npm run commit && npm version patch && npm publish && git push",
@@ -31,8 +24,11 @@
         "major": "npm run write && git add . && npm run commit && npm version major && npm publish && git push",
         "site": "git add docs && npm run commit && git push",
         "commit": "node ../.scripts/commit.js",
-        "write": "npm run build && node ../.scripts/rewritePackage.js ",
-        "build": "tsc && npx tsup src/main.ts && npx prettier --write src types"
+        "write": "npm run build && npm run format && node ../.scripts/rewritePackage.js ",
+        "format": "npx prettier --write src dist",
+        "build": "npm run build:esm && npm run build:cjs",
+        "build:esm": "tsc",
+        "build:cjs": "tsc --module CommonJS --outDir dist/cjs"
     },
     "repository": {
         "type": "git",
@@ -43,14 +39,13 @@
     },
     "dependencies": {
         "@sapphire/shapeshift": "^3.8.1",
-        "discord.js": "^14.7.0",
-        "dumfunctions": "^2.0.0",
-        "xernerx-extension-builder": "^0.0.2",
+        "discord.js": "^14.7.1",
+        "dumfunctions": "^2.1.2",
+        "xernerx-extension-builder": "^0.0.8",
         "zod": "^3.20.6"
     },
     "devDependencies": {
         "prettier": "^2.8.4",
-        "tsup": "^6.6.0",
         "typescript": "^4.9.5"
     }
 }

package/dist/build/ContextCommandBuilder.js

@@ -1,93 +0,0 @@
-import { ContextMenuCommandBuilder } from 'discord.js';
-import { z } from 'zod';
-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;
-    data;
-    name;
-    type;
-    description;
-    info;
-    category;
-    channelType;
-    cooldown;
-    ignore;
-    strict;
-    permissions;
-    defer;
-    client;
-    constructor(id, options) {
-        this.id = id;
-        this.data = new ContextMenuCommandBuilder();
-        if (options.name)
-            this.data.setName(options.name);
-        if (options.type)
-            this.data.setType(options.type);
-        if (options.permissions?.users)
-            this.data.setDefaultMemberPermissions(options.permissions?.users);
-        if (options.permissions?.dm === false)
-            this.data.setDMPermission(options.permissions?.dm);
-        if (options.nameLocalizations)
-            this.data.setNameLocalizations(options.nameLocalizations);
-        z.object({
-            description: z.string(),
-            info: z.string(),
-            category: z.string(),
-            channelType: z.array(z.number()).or(z.number()),
-            cooldown: z.number(),
-            ignore: z.object({
-                owner: z.boolean(),
-                users: z.array(z.string()),
-                channels: z.array(z.string()),
-                guilds: z.array(z.string()),
-            }),
-            strict: z.object({
-                owner: z.boolean(),
-                users: z.array(z.string()),
-                channels: z.array(z.string()),
-                guilds: z.array(z.string()),
-            }),
-            permissions: z.object({
-                client: z.array(z.string()),
-                users: z.array(z.string()),
-                dm: z.boolean(),
-            }),
-            defer: z.object({
-                reply: z.boolean(),
-                ephemeral: z.boolean(),
-                fetch: z.boolean(),
-            }),
-        })
-            .deepPartial()
-            .parse(options);
-        this.name = options.name;
-        this.type = options.type;
-        this.description = options.description;
-        this.info = options.info;
-        this.category = options.category;
-        this.channelType = options.channelType;
-        this.cooldown = options.cooldown;
-        this.ignore = options.ignore;
-        this.strict = options.strict;
-        this.permissions = options.permissions;
-        this.defer = options.defer;
-        this.client = XernerxClient;
-    }
-    /**
-     * @param {Interaction} interaction - The Discord interaction event data.
-     * @description make any preconditions here.
-     * TODO - update description
-     */
-    async conditions(interaction, args) { }
-    /**
-     * @param {Interaction} interaction - The Discord interaction event data.
-     * @description Make your custom command here.
-     * TODO - update description
-     */
-    async exec(interaction, args) { }
-}

package/dist/build/EventBuilder.js

@@ -1,34 +0,0 @@
-import { z } from 'zod';
-import XernerxClient from '../client/XernerxClient.js';
-/**
- * @description - The event builder for  events.
- * @param {String} id - The unique ID of the event.
- * @param {EventOptions} options - The event options.
- */
-export default class EventBuilder {
-    id;
-    name;
-    emitter;
-    type;
-    once;
-    client;
-    constructor(id, options) {
-        this.id = id;
-        z.object({
-            name: z.string(),
-            emitter: z.string().optional(),
-            type: z.string().optional(),
-            once: z.boolean().optional(),
-        }).parse(options);
-        this.name = options.name;
-        this.emitter = options.emitter || 'client';
-        this.type = options.type || 'discord';
-        this.once = options.once || false;
-        this.client = XernerxClient;
-    }
-    /**
-     * @description run your custom event here.
-     * TODO - update description
-     */
-    async run() { }
-}