xernerx 3.3.6 → 3.4.0

package/dist/models/CommandValidations.js

@@ -1,5 +1,5 @@
-import { Message } from "discord.js";
-import { CommandType } from "../types/enums.js";
+import { Message } from 'discord.js';
+import { CommandType } from '../types/enums.js';
 function getUser(from) {
     if (from instanceof Message)
         return from.author;
@@ -14,26 +14,30 @@ export default function commandValidation(action, command, client, res = false)
         return true;
     else if (command.owner && !client.util.isOwner(user.id)) {
         res = true;
-        emit(client, action, command, "Not an owner", client.settings.ownerId);
+        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);
+            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);
+        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);
+        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.userPermissions || client.settings.userPermissions)) {
-        const permissions = command.userPermissions || client?.settings?.userPermissions?.push(...handlerPermissions(client, command.commandType, "user")), missing = [];
+        const permissions = command.userPermissions || client?.settings?.userPermissions?.push(...handlerPermissions(client, command.commandType, 'user')), missing = [];
         if (Array.isArray(permissions))
             permissions.map((permission) => {
                 if (!(action.member?.permissions).has(permission)) {
@@ -42,11 +46,11 @@ export default function commandValidation(action, command, client, res = false)
             });
         if (missing.length > 0) {
             res = true;
-            emit(client, action, command, "Missing User Permissions", missing);
+            emit(client, action, command, 'Missing User Permissions', missing);
         }
     }
     else if (action?.guild && (command.clientPermissions || client.settings.clientPermissions)) {
-        const permissions = command.clientPermissions || client?.settings?.clientPermissions?.push(...handlerPermissions(client, command.commandType, "client")), missing = [];
+        const permissions = command.clientPermissions || client?.settings?.clientPermissions?.push(...handlerPermissions(client, command.commandType, 'client')), missing = [];
         if (Array.isArray(permissions))
             permissions.map((permission) => {
                 if (!(action.member?.permissions).has(permission)) {
@@ -55,17 +59,17 @@ export default function commandValidation(action, command, client, res = false)
             });
         if (missing.length > 0) {
             res = true;
-            emit(client, action, command, "Missing Client Permissions", missing);
+            emit(client, action, command, 'Missing Client Permissions', missing);
         }
     }
     return res;
 }
 function emit(client, action, command, reason, extra) {
-    return client.emit("commandBlock", 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;
+    const { cooldowns, messageCommands, slashCommands, contextCommands, commands } = client.cache;
     if (command.commandType === CommandType.MessageCommand && client.handlerOptions.message.cooldown) {
         if (messageCommands.has(user.id)) {
             const usr = messageCommands.get(user.id);
@@ -80,8 +84,7 @@ function inCooldown(user, client, command, action) {
             }, client.handlerOptions.message.cooldown);
         }
     }
-    if (command.commandType === CommandType.SlashCommand &&
-        client.handlerOptions.slash.cooldown) {
+    if (command.commandType === CommandType.SlashCommand && client.handlerOptions.slash.cooldown) {
         if (slashCommands.has(user.id)) {
             const usr = slashCommands.get(user.id);
             usr.timeRemaining = usr.endsAt - Date.now();
@@ -95,8 +98,7 @@ function inCooldown(user, client, command, action) {
             }, client.handlerOptions.slash.cooldown);
         }
     }
-    if (command.commandType === CommandType.ContextCommand &&
-        client.handlerOptions.context.cooldown) {
+    if (command.commandType === CommandType.ContextCommand && client.handlerOptions.context.cooldown) {
         if (contextCommands.has(user.id)) {
             const usr = contextCommands.get(user.id);
             usr.timeRemaining = usr.endsAt - Date.now();
@@ -125,11 +127,7 @@ function inCooldown(user, client, command, action) {
         }
     }
     if (command.cooldown) {
-        const name = user.id +
-            "-" +
-            (command.data?.name || command?.name) +
-            "-" +
-            command.commandType;
+        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();
@@ -144,7 +142,7 @@ function inCooldown(user, client, command, action) {
         }
     }
     if (Object.keys(downs).length > 0)
-        client.emit("commandCooldown", action, command, downs);
+        client.emit('commandCooldown', action, command, downs);
     return res;
 }
 function toCooldown(action, command, cooldown, name) {
@@ -164,21 +162,21 @@ function toCooldown(action, command, cooldown, name) {
 function handlerPermissions(client, commandType, type) {
     let permissions = [];
     if (commandType === CommandType.MessageCommand) {
-        if (type === "user")
+        if (type === 'user')
             permissions = client.handlerOptions.message?.userPermissions || [];
-        else if (type === "client")
+        else if (type === 'client')
             permissions = client.handlerOptions.message?.clientPermissions || [];
     }
     else if (commandType === CommandType.SlashCommand) {
-        if (type === "user")
+        if (type === 'user')
             permissions = client.handlerOptions.slash?.userPermissions || [];
-        else if (type === "client")
+        else if (type === 'client')
             permissions = client.handlerOptions.slash?.clientPermissions || [];
     }
     else if (commandType === CommandType.ContextCommand) {
-        if (type === "user")
+        if (type === 'user')
             permissions = client.handlerOptions.context?.userPermissions || [];
-        else if (type === "client")
+        else if (type === 'client')
             permissions = client.handlerOptions.context?.clientPermissions || [];
     }
     return permissions;

package/dist/models/Events.d.ts

@@ -1,24 +1,24 @@
 import XernerxClient from '../client/XernerxClient.js';
 export declare class MessageCommandEvents {
-    client: XernerxClient;
+    private client;
     constructor(client: XernerxClient);
     messageCreate(): void;
     messageUpdate(): void;
     messageDelete(): void;
 }
 export declare class SlashCommandEvents {
-    client: XernerxClient;
+    private client;
     constructor(client: XernerxClient);
     slashCreate(): void;
 }
 export declare class ContextCommandEvents {
-    client: XernerxClient;
+    private client;
     constructor(client: XernerxClient);
     contextCreate(): void;
 }
 export declare class CommandsDeploy {
-    client: XernerxClient;
+    private client;
     constructor(client: XernerxClient);
     deploy(): void;
-    put(type: string, guild: string, body: Array<object>): void;
+    private put;
 }

package/dist/models/Events.js

@@ -1,9 +1,9 @@
 import { GatewayVersion, InteractionType, REST, Routes } from 'discord.js';
 import { InteractionCommandUtil, MessageCommandUtil } from '../utils/CommandUtil.js';
 import { InteractionArguments, messageArguments } from './CommandArguments.js';
-import commandValidation from './CommandValidations.js';
+import commandValidation from '../validators/CommandValidations.js';
 import { Style } from 'dumfunctions';
-import { InhibitorValidation } from './InhibitorValidations.js';
+import { InhibitorValidation } from '../validators/InhibitorValidations.js';
 export class MessageCommandEvents {
     client;
     constructor(client) {
@@ -28,7 +28,9 @@ export class MessageCommandEvents {
                         });
                     }
                     if (this.client.handlerOptions.message?.prefix) {
-                        const prefix = Array.isArray(this.client.handlerOptions.message.prefix) ? this.client.handlerOptions.message.prefix : [this.client.handlerOptions.message.prefix];
+                        const prefix = Array.isArray(this.client.handlerOptions.message.prefix)
+                            ? this.client.handlerOptions.message.prefix
+                            : [this.client.handlerOptions.message.prefix];
                         prefix.map((prefix) => {
                             if (message.content.startsWith(prefix)) {
                                 command = message.content.replace(prefix, '').split(/ +/).shift();
@@ -37,13 +39,17 @@ export class MessageCommandEvents {
                         });
                     }
                     if (this.client.handlerOptions.message?.allowMention) {
-                        if (message.mentions.users.has(this.client.user?.id) || message.mentions.repliedUser?.id === this.client.user?.id) {
+                        if (message.mentions.users.has(this.client.user?.id) ||
+                            message.mentions.repliedUser?.id === this.client.user?.id) {
                             command = message.content.replace(`<@${this.client.user?.id}>`, '').trim().split(/ +/).shift();
                             px = 'MentionPrefix';
                         }
                     }
-                    const prefix = Array.isArray(this.client.handlerOptions.message?.prefix) ? this.client.handlerOptions.message?.prefix : [this.client.handlerOptions.message?.prefix];
-                    if ((cmd.name.toLowerCase() == command?.toLowerCase() || cmd.aliases?.map((c) => c.toLowerCase())?.includes(command?.toLowerCase())) &&
+                    const prefix = Array.isArray(this.client.handlerOptions.message?.prefix)
+                        ? this.client.handlerOptions.message?.prefix
+                        : [this.client.handlerOptions.message?.prefix];
+                    if ((cmd.name.toLowerCase() == command?.toLowerCase() ||
+                        cmd.aliases?.map((c) => c.toLowerCase())?.includes(command?.toLowerCase())) &&
                         (cmd.prefix.includes(px) || prefix?.includes(px) || px === 'MentionPrefix')) {
                         try {
                             if (this.client.handlerOptions.message?.handleTyping)
@@ -53,7 +59,8 @@ export class MessageCommandEvents {
                                 return;
                             if (await inhibitor.inhibit())
                                 return;
-                            if (cmd.conditions && (await cmd.conditions(message, (await messageArguments(message, cmd)))))
+                            if (cmd.conditions &&
+                                (await cmd.conditions(message, (await messageArguments(message, cmd)))))
                                 return;
                             await cmd.exec(message, (await messageArguments(message, cmd)));
                             this.client.emit('commandRun', message, cmd);
@@ -87,7 +94,9 @@ export class MessageCommandEvents {
                         });
                     }
                     if (this.client.handlerOptions.message?.prefix) {
-                        const prefix = Array.isArray(this.client.handlerOptions.message.prefix) ? this.client.handlerOptions.message.prefix : [this.client.handlerOptions.message.prefix];
+                        const prefix = Array.isArray(this.client.handlerOptions.message.prefix)
+                            ? this.client.handlerOptions.message.prefix
+                            : [this.client.handlerOptions.message.prefix];
                         prefix.map((prefix) => {
                             if (message?.content?.startsWith(prefix)) {
                                 command = message.content.replace(prefix, '').split(/ +/).shift();
@@ -96,13 +105,17 @@ export class MessageCommandEvents {
                         });
                     }
                     if (this.client.handlerOptions.message?.allowMention) {
-                        if (message.mentions.users.has(this.client.user?.id || '') || message.mentions.repliedUser?.id === this.client.user?.id) {
+                        if (message.mentions.users.has(this.client.user?.id || '') ||
+                            message.mentions.repliedUser?.id === this.client.user?.id) {
                             command = message?.content?.replace(`<@${this.client.user?.id}>`, '').trim().split(/ +/).shift();
                             px = 'MentionPrefix';
                         }
                     }
-                    const prefix = Array.isArray(this.client.handlerOptions.message?.prefix) ? this.client.handlerOptions.message?.prefix : [this.client.handlerOptions.message?.prefix];
-                    if ((cmd.name.toLowerCase() == command?.toLowerCase() || cmd.aliases?.map((c) => c.toLowerCase())?.includes(command?.toLowerCase())) &&
+                    const prefix = Array.isArray(this.client.handlerOptions.message?.prefix)
+                        ? this.client.handlerOptions.message?.prefix
+                        : [this.client.handlerOptions.message?.prefix];
+                    if ((cmd.name.toLowerCase() == command?.toLowerCase() ||
+                        cmd.aliases?.map((c) => c.toLowerCase())?.includes(command?.toLowerCase())) &&
                         (cmd.prefix.includes(px) || prefix?.includes(px) || px === 'MentionPrefix')) {
                         try {
                             if (this.client.handlerOptions.message?.handleTyping)
@@ -113,7 +126,8 @@ export class MessageCommandEvents {
                                 return;
                             if (await inhibitor.inhibit())
                                 return;
-                            if (cmd.conditions && (await cmd.conditions(message, (await messageArguments(message, cmd)))))
+                            if (cmd.conditions &&
+                                (await cmd.conditions(message, (await messageArguments(message, cmd)))))
                                 return;
                             await cmd.exec(message, (await messageArguments(message, cmd)));
                             this.client.emit('commandRun', message, cmd);
@@ -128,15 +142,18 @@ export class MessageCommandEvents {
     }
     messageDelete() {
         this.client.on('messageDelete', async (message) => {
-            if (this.client.cache.messages.has(message.id) && this.client.handlerOptions.message?.handleDeletes) {
-                if (this.client.handlerOptions.message?.handleTyping)
-                    message.channel.sendTyping();
+            if (this.client.cache.messages.has(message.id) &&
+                this.client.handlerOptions.message?.handleDeletes) {
                 try {
+                    if (this.client.handlerOptions.message?.handleTyping)
+                        message.channel.sendTyping();
                     const msg = this.client.cache.messages.get(message.id);
                     const response = await message.channel.messages.fetch(msg?.response);
                     await response.delete();
                 }
-                catch { }
+                catch (error) {
+                    this.client.emit('commandError', message, error, null);
+                }
             }
         });
     }
@@ -161,12 +178,27 @@ export class SlashCommandEvents {
                         if (commandValidation(interaction, command, this.client))
                             return;
                         if (command.defer?.reply !== false && this.client.handlerOptions.slash?.defer?.reply)
-                            await interaction.deferReply({ ephemeral: this.client.handlerOptions.slash?.defer?.ephemeral, fetchReply: this.client.handlerOptions.slash?.defer?.fetchReply });
+                            await interaction.deferReply({
+                                ephemeral: this.client.handlerOptions.slash?.defer?.ephemeral,
+                                fetchReply: this.client.handlerOptions.slash?.defer?.fetchReply,
+                            });
                         if (!(interaction.deferred || interaction.replied) && command.defer?.reply)
-                            await interaction.deferReply({ ephemeral: command.defer?.ephemeral, fetchReply: command.defer?.fetchReply });
-                        if (command.conditions && (await command.conditions(interaction, { group: argumentsInfo.group(), subcommand: argumentsInfo.subcommand(), args: await argumentsInfo.arguments() })))
+                            await interaction.deferReply({
+                                ephemeral: command.defer?.ephemeral,
+                                fetchReply: command.defer?.fetchReply,
+                            });
+                        if (command.conditions &&
+                            (await command.conditions(interaction, {
+                                group: argumentsInfo.group(),
+                                subcommand: argumentsInfo.subcommand(),
+                                args: await argumentsInfo.arguments(),
+                            })))
                             return;
-                        await command.exec(interaction, { group: argumentsInfo.group(), subcommand: argumentsInfo.subcommand(), args: await argumentsInfo.arguments() });
+                        await command.exec(interaction, {
+                            group: argumentsInfo.group(),
+                            subcommand: argumentsInfo.subcommand(),
+                            args: await argumentsInfo.arguments(),
+                        });
                         this.client.emit('commandRun', interaction, command);
                     }
                     catch (error) {
@@ -198,9 +230,15 @@ export class ContextCommandEvents {
                         if (command.conditions && (await command.conditions(interaction)))
                             return;
                         if (command.defer?.reply !== false && this.client.handlerOptions.context?.defer?.reply)
-                            await interaction.deferReply({ ephemeral: this.client.handlerOptions.context?.defer?.ephemeral, fetchReply: this.client.handlerOptions.context?.defer?.fetchReply });
+                            await interaction.deferReply({
+                                ephemeral: this.client.handlerOptions.context?.defer?.ephemeral,
+                                fetchReply: this.client.handlerOptions.context?.defer?.fetchReply,
+                            });
                         if (!(interaction.deferred || interaction.replied) && command.defer?.reply)
-                            await interaction.deferReply({ ephemeral: command.defer?.ephemeral, fetchReply: command.defer?.fetchReply });
+                            await interaction.deferReply({
+                                ephemeral: command.defer?.ephemeral,
+                                fetchReply: command.defer?.fetchReply,
+                            });
                         await command.exec(interaction);
                         this.client.emit('commandRun', interaction, command);
                     }
@@ -220,30 +258,39 @@ export class CommandsDeploy {
     deploy() {
         this.client.once('ready', async (client) => {
             const slashCommands = [], contextCommands = [];
-            this.client.commands.context.map((command) => (command.data ? contextCommands.push(command.data.toJSON()) : null));
+            this.client.commands.context.map((command) => command.data ? contextCommands.push(command.data.toJSON()) : null);
             this.client.commands.slash.map((command) => (command.data ? slashCommands.push(command.data.toJSON()) : null));
             try {
-                const global = { slash: this.client.handlerOptions.slash?.global, context: this.client.handlerOptions.context?.global };
-                const guild = { slash: this.client.handlerOptions.slash?.guildId, context: this.client.handlerOptions.context?.guildId };
+                const global = {
+                    slash: this.client.handlerOptions.slash?.global,
+                    context: this.client.handlerOptions.context?.global,
+                };
+                const guild = {
+                    slash: this.client.handlerOptions.slash?.guildId,
+                    context: this.client.handlerOptions.context?.guildId,
+                };
                 if (global.slash && global.context) {
                     if (guild.slash !== guild.context)
                         console.info(Style.log(`Xernerx | Warning: slash and context commands are both set to global, but don't have a matching guildId, using ${(await this.client.guilds.fetch(this.client.handlerOptions.slash?.guildId)).name}!`, { color: Style.TextColor.Red }));
                     this.put('global', guild.slash, [...contextCommands, ...slashCommands]);
                     this.put('guild', guild.slash, []);
                 }
-                if (global.slash && !global.context) {
+                if (global.slash && global.context === false) {
                     this.put('global', guild.slash, slashCommands);
                 }
-                if (!global.slash && global.context) {
+                if (global.slash === false && global.context) {
                     this.put('global', guild.context, contextCommands);
                 }
-                if (!global.slash && !global.context) {
+                if (global.slash === false && global.context === false) {
                     this.put('guild', guild.slash, [...contextCommands, ...slashCommands]);
                 }
-                console.log(Style.log(`Xernerx | Deployed ${slashCommands.length} slash commands ${global.slash ? 'globally' : 'locally'} and ${contextCommands.length} context commands ${global.context ? 'globally' : 'locally'}.`, { color: Style.TextColor.Purple }));
+                if (this.client.handlerOptions.context?.logging || this.client.handlerOptions.slash?.logging)
+                    console.info(Style.log(`Xernerx | Deployed ${slashCommands.length} slash commands ${global.slash ? 'globally' : 'locally'} and ${contextCommands.length} context commands ${global.context ? 'globally' : 'locally'}.`, { color: Style.TextColor.Purple }));
             }
             catch (error) {
-                console.error(Style.log(`Xernerx | Couldn't deploy interaction commands because <${error}>.`, { color: Style.BackgroundColor.Red }));
+                console.error(Style.log(`Xernerx | Couldn't deploy interaction commands because <${error}>.`, {
+                    color: Style.BackgroundColor.Red,
+                }));
             }
         });
     }

package/dist/models/Extensions.d.ts

@@ -1,6 +1,7 @@
-import { ExtensionBuilder, XernerxClient } from "../main.js";
+import XernerxExtensionBuilder from 'xernerx-extension-builder';
+import XernerxClient from '../client/XernerxClient.js';
 export default class Extensions {
-    client: XernerxClient;
+    private client;
     constructor(client: XernerxClient);
-    load(extensions: Array<ExtensionBuilder>, logging?: boolean): Promise<void>;
+    load(extensions: Array<XernerxExtensionBuilder>, logging?: boolean): Promise<void>;
 }

package/dist/models/Extensions.js

@@ -1,4 +1,4 @@
-import { Style } from "dumfunctions";
+import { Style } from 'dumfunctions';
 export default class Extensions {
     client;
     constructor(client) {
@@ -6,13 +6,15 @@ export default class Extensions {
     }
     async load(extensions, logging = false) {
         const exts = [];
-        extensions.map(extension => {
+        extensions.map((extension) => {
             try {
                 this.client.extensions[extension.name] = extension;
                 exts.push(extension.name);
             }
             catch (error) {
-                console.error(Style.log(`Xernerx | An error occurred trying to load ${extension.name}, error: <${error}>`, { color: Style.BackgroundColor.Red }));
+                console.error(Style.log(`Xernerx | An error occurred trying to load ${extension.name}, error: <${error}>`, {
+                    color: Style.BackgroundColor.Red,
+                }));
             }
         });
         if (logging)

package/dist/tools/package.d.ts

@@ -0,0 +1,38 @@
+declare const _default: {
+    name: string;
+    version: string;
+    type: string;
+    description: string;
+    main: string;
+    keywords: string[];
+    author: string;
+    license: string;
+    homepage: string;
+    packageManager: string;
+    scripts: {
+        start: string;
+        patch: string;
+        minor: string;
+        major: string;
+        site: string;
+        commit: string;
+        package: string;
+    };
+    repository: {
+        type: string;
+        url: string;
+    };
+    bugs: {
+        url: string;
+    };
+    dependencies: {
+        '@sapphire/shapeshift': string;
+        'discord.js': string;
+        dumfunctions: string;
+        'xernerx-extension-builder': string;
+    };
+    devDependencies: {
+        typescript: string;
+    };
+};
+export default _default;

package/dist/tools/package.js

@@ -0,0 +1,37 @@
+export default {
+    name: 'xernerx',
+    version: '3.3.7',
+    type: 'module',
+    description: 'A bot framework for discord.js.',
+    main: 'dist/main.js',
+    keywords: ['discord.js', 'discord', 'framework'],
+    author: 'Dummi',
+    license: 'MIT',
+    homepage: 'https://xernerx.github.io/xernerx/home.html',
+    packageManager: 'npm@8.5.5',
+    scripts: {
+        start: 'npm i && npm fund && npm audit fix --force &&  npm link && npm run package && tsc -w',
+        patch: 'git add . && npm run commit && npm version patch && npm publish && git push',
+        minor: 'git add . && npm run commit && npm version minor && npm publish && git push',
+        major: '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',
+        package: 'node ../.scripts/rewritePackage.js',
+    },
+    repository: {
+        type: 'git',
+        url: 'git+https://github.com/xernerx/xernerx.git',
+    },
+    bugs: {
+        url: 'https://github.com/xernerx/xernerx/issues',
+    },
+    dependencies: {
+        '@sapphire/shapeshift': '^3.8.1',
+        'discord.js': '^14.7.0',
+        dumfunctions: '^2.0.0',
+        'xernerx-extension-builder': '^0.0.2',
+    },
+    devDependencies: {
+        typescript: '^4.9.4',
+    },
+};

package/dist/types/enums.js

@@ -10,7 +10,7 @@ export var InhibitorType;
     InhibitorType["Message"] = "Message";
     InhibitorType["Interaction"] = "Interaction";
     InhibitorType["Channel"] = "Channel";
-})(InhibitorType = InhibitorType || (InhibitorType = {}));
+})(InhibitorType || (InhibitorType = {}));
 export var CommandType;
 (function (CommandType) {
     CommandType["Message"] = "MessageCommand";
@@ -21,15 +21,15 @@ export var CommandType;
     CommandType["MessageCommand"] = "MessageCommand";
     CommandType["SlashCommand"] = "SlashCommand";
     CommandType["ContextCommand"] = "ContextCommand";
-})(CommandType = CommandType || (CommandType = {}));
+})(CommandType || (CommandType = {}));
 export var ContextCommandType;
 (function (ContextCommandType) {
     ContextCommandType[ContextCommandType["Message"] = 3] = "Message";
     ContextCommandType[ContextCommandType["User"] = 2] = "User";
-})(ContextCommandType = ContextCommandType || (ContextCommandType = {}));
+})(ContextCommandType || (ContextCommandType = {}));
 export var EventEmitterType;
 (function (EventEmitterType) {
     EventEmitterType["Client"] = "client";
     EventEmitterType["Rest"] = "rest";
     EventEmitterType["Process"] = "process";
-})(EventEmitterType = EventEmitterType || (EventEmitterType = {}));
+})(EventEmitterType || (EventEmitterType = {}));

package/dist/types/options.d.ts

@@ -1,5 +1,6 @@
 import { CacheFactory, ChannelType, ContextMenuCommandType, MessageMentionOptions, Partials, PresenceData, RESTOptions, SweeperOptions, WebSocketOptions } from 'discord.js';
-import { ContextCommandType, EventEmitterType, ExtensionBuilder, InhibitorType } from '../main.js';
+import XernerxExtensionBuilder from 'xernerx-extension-builder';
+import { ContextCommandType, EventEmitterType, InhibitorType } from './enums.js';
 import { MessageCommandArgsTypes } from './types.js';
 export interface DiscordOptions {
     shards?: number | number[] | 'auto';
@@ -36,7 +37,7 @@ export interface HandlerOptions {
     inhibitors?: InhibitorHandlerOptions;
 }
 export interface ExtensionOptions {
-    extensions: Array<ExtensionBuilder>;
+    extensions: Array<XernerxExtensionBuilder>;
     logging?: boolean;
 }
 export interface MessageCommandOptions {

package/dist/utils/ClientUtil.d.ts

@@ -8,7 +8,7 @@ interface Presence {
     interval?: number;
 }
 export declare class ClientUtil {
-    client: XernerxClient;
+    private client;
     constructor(client: XernerxClient);
     uptime(timestamp: number | null): string;
     getSubcommands(name: string): object[];

package/dist/utils/ClientUtil.js

@@ -3,17 +3,6 @@ export class ClientUtil {
     client;
     constructor(client) {
         this.client = client;
-        this.uptime = this.uptime;
-        this.getSubcommands = this.getSubcommands;
-        this.isOwner = this.isOwner;
-        this.getAllCommands = this.getAllCommands;
-        this.getAllMessageCommands = this.getAllMessageCommands;
-        this.getAllSlashCommands = this.getAllSlashCommands;
-        this.getAllContextCommands = this.getAllContextCommands;
-        this.setPresence = this.setPresence;
-        this.getCooldowns = this.getCooldowns;
-        this.getCooldownTimers = this.getCooldownTimers;
-        this.defer = this.defer;
     }
     uptime(timestamp) {
         if (!timestamp)

package/dist/utils/CommandUtil.d.ts

@@ -25,26 +25,32 @@ interface ButtonOptions {
     ephemeral?: boolean;
 }
 export declare class MessageCommandUtil {
-    #private;
-    client: XernerxClient;
-    message: XernerxMessage;
+    private client;
+    private message;
     constructor(client: XernerxClient, message: Message & XernerxMessage);
     reply(content: MessagePayload | string): Promise<Message<boolean> | undefined>;
     send(content: MessagePayload | string): Promise<Message<true> | Message<false> | undefined>;
     defer(time: number): Promise<unknown>;
     getCommands(): import("@discordjs/collection").Collection<string, import("../main.js").MessageCommandBuilder>;
+    getCommandName(): void;
+    selectMenuPaginator(embeds: Array<EmbedBuilder>, options?: SelectMenuOptions): void;
+    buttonPaginator(embeds: Array<EmbedBuilder>, options: ButtonOptions): void;
+    buttonMenuPaginator(embeds: Array<EmbedBuilder>, options: ButtonOptions & SelectMenuOptions): void;
     isOwner(): boolean;
+    createModal(): void;
 }
 export declare class InteractionCommandUtil {
-    #private;
-    client: XernerxClient;
-    interaction: any;
+    private client;
+    private interaction;
     constructor(client: XernerxClient, interaction: Interaction);
     reply(content: MessagePayload | string): any;
     defer(time: number): Promise<unknown>;
     getCommands(): import("@discordjs/collection").Collection<string, import("../main.js").SlashCommandBuilder> | import("@discordjs/collection").Collection<string, import("../main.js").ContextCommandBuilder>;
+    getCommandName(): void;
     selectMenuPaginator(embeds: Array<EmbedBuilder>, options?: SelectMenuOptions): void;
     buttonPaginator(embeds: Array<EmbedBuilder>, options: ButtonOptions): void;
+    buttonMenuPaginator(embeds: Array<EmbedBuilder>, options: ButtonOptions & SelectMenuOptions): void;
     isOwner(): boolean;
+    createModal(): void;
 }
 export {};