xernerx 4.2.1 → 4.3.0

package/dist/cjs/models/CommandArguments.d.ts

@@ -1,17 +0,0 @@
-import MessageCommandBuilder from '../build/MessageCommandBuilder.js';
-import { XernerxInteraction, XernerxMessage } from '../types/types.js';
-export declare class InteractionArguments {
-    interaction: XernerxInteraction;
-    constructor(interaction: XernerxInteraction);
-    group(): string | undefined;
-    subcommand(): string | undefined;
-    arguments(): Record<string, object>;
-}
-interface Flag {
-    flags: Record<string, string | boolean>;
-}
-interface Argument {
-    [index: string]: string | number | null;
-}
-export declare function messageArguments(message: XernerxMessage, command: MessageCommandBuilder): Promise<import('discord.js').Message<boolean> | Flag | Argument | undefined>;
-export {};

package/dist/cjs/models/CommandArguments.js

@@ -1,106 +0,0 @@
-'use strict';
-Object.defineProperty(exports, '__esModule', { value: true });
-exports.messageArguments = exports.InteractionArguments = void 0;
-class InteractionArguments {
-    interaction;
-    constructor(interaction) {
-        this.interaction = interaction;
-    }
-    group() {
-        return this.interaction?.options?._group;
-    }
-    subcommand() {
-        return this.interaction?.options?._subcommand;
-    }
-    arguments() {
-        const options = {};
-        if (this.interaction?.options?._hoistedOptions) {
-            for (const option of this.interaction.options._hoistedOptions) {
-                options[option.name] = option.channel || option.user || option.role || option.value;
-            }
-        }
-        return options;
-    }
-}
-exports.InteractionArguments = InteractionArguments;
-async function messageArguments(message, command) {
-    let args = { flags: {} },
-        separator = command.separator || ' ',
-        i = 0;
-    if (!command.args) return;
-    command.args
-        .filter((c) => c.type == 'flag')
-        .map((flag) => {
-            args = args;
-            for (const flg of message.content.matchAll(flag.match)) {
-                if (flag.match == flg) {
-                    message.content = message.content.replace(flag.match, '');
-                    args.flags[flag.name] = true;
-                }
-            }
-            if (!args.flags[flag.name]) args.flags[flag.name] = false;
-        });
-    for (const argument of command.args) {
-        args = args;
-        let content = message.content
-            .split(/ +/)
-            .slice(1)
-            .join(separator)
-            .replace(new RegExp(`${separator}${separator}+`, 'g'), separator)
-            .split(separator)
-            .slice(i);
-        if (content.join(separator) != '' && argument.type !== 'flag') {
-            if (argument?.content?.includes(content[0])) {
-                args[argument.name] = content[0];
-            } else if (argument.type == 'string') {
-                args[argument.name] = content[0];
-            } else if (argument.type == 'number') {
-                args[argument.name] = parseInt(content[0]);
-            } else if (argument.type == 'boolean') {
-                if (content[0]?.toLowerCase() != 'true' && content[0]?.toLowerCase() != 'false') content[0] = null;
-                args[argument.name] = content[0];
-            } else if (argument.type == 'user') {
-                let user = message.client.users.cache.find((u) => u?.username?.toLowerCase()?.includes(content[0])) || null;
-                try {
-                    user = (await message.client.users.fetch(user?.id || content[0].replace(/<@!?|>/g, ''))) || null;
-                } catch (e) {
-                    user = null;
-                }
-                args[argument.name] = user;
-            } else if (argument.type == 'role') {
-                let role = message.guild?.roles.cache.find((r) => r?.name?.toLowerCase()?.includes(content[0])) || null;
-                try {
-                    role = (await message.guild?.roles.fetch(role?.id || content[0].replace(/<@&?|>/g, ''))) || null;
-                } catch (e) {
-                    role = null;
-                }
-                args[argument.name] = role;
-            } else if (argument.type == 'member') {
-                let member = message.guild?.members.cache.find((m) => m?.nickname?.toLowerCase()?.includes(content[0]) || m?.user?.username?.toLowerCase()?.includes(content[0])) || null;
-                try {
-                    member = (await message.guild?.members.fetch(member?.id || content[0].replace(/<@!?|>/g, ''))) || null;
-                } catch (e) {
-                    member = null;
-                }
-                args[argument.name] = member;
-            } else if (argument.type == 'channel') {
-                let channel = message.guild?.channels.cache.find((c) => c?.name?.toLowerCase()?.includes(content[0]));
-                try {
-                    channel = await message.client.channels.fetch(channel?.id || content[0].replace(/<#|>/g, ''));
-                } catch (e) {
-                    channel = null;
-                }
-                args[argument.name] = channel;
-            } else if (argument.type == 'rest') {
-                args[argument.name] = content.join(separator);
-                break;
-            } else if (argument.prompt) {
-                if (argument.prompt.reply) return message.util?.reply(argument.prompt.reply);
-                else if (argument.prompt.send) return message.channel.send(argument.prompt.send);
-            } else args[argument.name] = typeof argument.default == 'function' ? argument.default(message) : argument.default;
-            i++;
-        } else args[argument.name] = typeof argument.default == 'function' ? argument.default(message) : argument.default;
-    }
-    return args;
-}
-exports.messageArguments = messageArguments;

package/dist/cjs/models/Events.d.ts

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

package/dist/cjs/models/Events.js

@@ -1,307 +0,0 @@
-'use strict';
-var __importDefault =
-    (this && this.__importDefault) ||
-    function (mod) {
-        return mod && mod.__esModule ? mod : { default: mod };
-    };
-Object.defineProperty(exports, '__esModule', { value: true });
-exports.CommandsDeploy = exports.ContextCommandEvents = exports.SlashCommandEvents = exports.MessageCommandEvents = void 0;
-const discord_js_1 = require('discord.js');
-const CommandUtil_js_1 = require('../utils/CommandUtil.js');
-const CommandArguments_js_1 = require('./CommandArguments.js');
-const CommandValidations_js_1 = __importDefault(require('../validators/CommandValidations.js'));
-const dumfunctions_1 = require('dumfunctions');
-const InhibitorValidations_js_1 = require('../validators/InhibitorValidations.js');
-class MessageCommandEvents {
-    client;
-    constructor(client) {
-        this.client = client;
-    }
-    messageCreate() {
-        this.client.on('messageCreate', async (message) => {
-            if (!message.author.bot) {
-                let command = undefined,
-                    px = undefined;
-                message.author.isOwner = this.client.util.isOwner(message.author.id);
-                message.util = new CommandUtil_js_1.MessageCommandUtil(this.client, message);
-                const commands = this.client.commands.message;
-                commands
-                    .filter((c) => !c.regex)
-                    .map(async (cmd) => {
-                        if (cmd.prefix) {
-                            cmd.prefix.map((prefix) => {
-                                if (message.content.startsWith(prefix)) {
-                                    command = message.content.replace(prefix, '').split(/ +/).shift();
-                                    px = prefix;
-                                }
-                            });
-                        }
-                        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];
-                            prefix.map((prefix) => {
-                                if (message.content.startsWith(prefix)) {
-                                    command = message.content.replace(prefix, '').split(/ +/).shift();
-                                    px = prefix;
-                                }
-                            });
-                        }
-                        if (this.client.handlerOptions.message?.allowMention) {
-                            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())) &&
-                            (cmd.prefix.includes(px) || prefix?.includes(px) || px === 'MentionPrefix')
-                        ) {
-                            try {
-                                if (this.client.handlerOptions.message?.handleTyping) message.channel.sendTyping();
-                                const inhibitor = new InhibitorValidations_js_1.InhibitorValidation(this.client, message, command);
-                                if ((0, CommandValidations_js_1.default)(message, cmd, this.client)) return;
-                                if (await inhibitor.inhibit()) return;
-                                if (cmd.conditions && (await cmd.conditions(message, await (0, CommandArguments_js_1.messageArguments)(message, cmd)))) return;
-                                await cmd.exec(message, await (0, CommandArguments_js_1.messageArguments)(message, cmd));
-                                this.client.emit('commandRun', message, cmd);
-                            } catch (error) {
-                                return this.client.emit('commandError', message, error, cmd);
-                            }
-                        }
-                    });
-            }
-        });
-    }
-    messageUpdate() {
-        this.client.on('messageUpdate', async (old, message) => {
-            message = message;
-            if (!message.author?.bot) {
-                let command = undefined,
-                    px = undefined;
-                if (message.author) message.author.isOwner = this.client.util.isOwner(message.author.id);
-                message.util = new CommandUtil_js_1.MessageCommandUtil(this.client, message);
-                const commands = this.client.commands.message;
-                commands
-                    .filter((c) => !c.regex)
-                    .map(async (cmd) => {
-                        if (cmd.prefix) {
-                            cmd.prefix.map((prefix) => {
-                                if (message?.content?.startsWith(prefix)) {
-                                    command = message.content.replace(prefix, '').split(/ +/).shift();
-                                    px = prefix;
-                                }
-                            });
-                        }
-                        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];
-                            prefix.map((prefix) => {
-                                if (message?.content?.startsWith(prefix)) {
-                                    command = message.content.replace(prefix, '').split(/ +/).shift();
-                                    px = prefix;
-                                }
-                            });
-                        }
-                        if (this.client.handlerOptions.message?.allowMention) {
-                            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())) &&
-                            (cmd.prefix.includes(px) || prefix?.includes(px) || px === 'MentionPrefix')
-                        ) {
-                            try {
-                                if (this.client.handlerOptions.message?.handleTyping) message.channel.sendTyping();
-                                message = message;
-                                const inhibitor = new InhibitorValidations_js_1.InhibitorValidation(this.client, message, command);
-                                if ((0, CommandValidations_js_1.default)(message, cmd, this.client)) return;
-                                if (await inhibitor.inhibit()) return;
-                                if (cmd.conditions && (await cmd.conditions(message, await (0, CommandArguments_js_1.messageArguments)(message, cmd)))) return;
-                                await cmd.exec(message, await (0, CommandArguments_js_1.messageArguments)(message, cmd));
-                                this.client.emit('commandRun', message, cmd);
-                            } catch (error) {
-                                return this.client.emit('commandError', message, error, cmd);
-                            }
-                        }
-                    });
-            }
-        });
-    }
-    messageDelete() {
-        this.client.on('messageDelete', async (message) => {
-            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 (error) {
-                    this.client.emit('commandError', message, error, null);
-                }
-            }
-        });
-    }
-}
-exports.MessageCommandEvents = MessageCommandEvents;
-class SlashCommandEvents {
-    client;
-    constructor(client) {
-        this.client = client;
-    }
-    slashCreate() {
-        this.client.on('interactionCreate', async (interaction) => {
-            interaction.util = new CommandUtil_js_1.InteractionCommandUtil(this.client, interaction);
-            interaction.user.isOwner = this.client.util.isOwner(interaction.user.id);
-            if (interaction.type === discord_js_1.InteractionType.ApplicationCommand) {
-                if (this.client.commands.slash.has(interaction.commandName)) {
-                    let command = this.client.commands.slash.get(interaction.commandName);
-                    const argumentsInfo = new CommandArguments_js_1.InteractionArguments(interaction);
-                    try {
-                        const inhibitor = new InhibitorValidations_js_1.InhibitorValidation(this.client, interaction, command);
-                        if (await inhibitor.inhibit()) return;
-                        if ((0, CommandValidations_js_1.default)(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,
-                            });
-                        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(),
-                            }))
-                        )
-                            return;
-                        await command.exec(interaction, {
-                            group: argumentsInfo.group(),
-                            subcommand: argumentsInfo.subcommand(),
-                            args: await argumentsInfo.arguments(),
-                        });
-                        this.client.emit('commandRun', interaction, command);
-                    } catch (error) {
-                        this.client.emit('commandError', interaction, error, command);
-                    }
-                }
-            }
-        });
-    }
-}
-exports.SlashCommandEvents = SlashCommandEvents;
-class ContextCommandEvents {
-    client;
-    constructor(client) {
-        this.client = client;
-    }
-    contextCreate() {
-        this.client.on('interactionCreate', async (interaction) => {
-            interaction.util = new CommandUtil_js_1.InteractionCommandUtil(this.client, interaction);
-            interaction.user.isOwner = this.client.util.isOwner(interaction.user.id);
-            if (interaction.type === discord_js_1.InteractionType.ApplicationCommand) {
-                if (this.client.commands.context.has(interaction.commandName)) {
-                    let command = this.client.commands.context.get(interaction.commandName);
-                    try {
-                        const inhibitor = new InhibitorValidations_js_1.InhibitorValidation(this.client, interaction, command);
-                        if ((0, CommandValidations_js_1.default)(interaction, command, this.client)) return;
-                        if (await inhibitor.inhibit()) return;
-                        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,
-                            });
-                        if (!(interaction.deferred || interaction.replied) && command.defer?.reply)
-                            await interaction.deferReply({
-                                ephemeral: command.defer?.ephemeral,
-                                fetchReply: command.defer?.fetchReply,
-                            });
-                        let args = {};
-                        if (command.type === 3) args = await interaction.channel.messages.fetch(interaction.targetId);
-                        if (command.type === 2) args = await this.client.users.fetch(interaction.targetId);
-                        await command.exec(interaction, args);
-                        this.client.emit('commandRun', interaction, command);
-                    } catch (error) {
-                        this.client.emit('commandError', interaction, error, command);
-                    }
-                }
-            }
-        });
-    }
-}
-exports.ContextCommandEvents = ContextCommandEvents;
-class CommandsDeploy {
-    client;
-    constructor(client) {
-        this.client = client;
-    }
-    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.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,
-                };
-                if (!guild.slash && !guild.context) return;
-                if (global.slash && global.context) {
-                    if (guild.slash !== guild.context)
-                        console.info(
-                            dumfunctions_1.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: dumfunctions_1.Style.TextColor.Red }
-                            )
-                        );
-                    this.put('global', guild.slash, [...contextCommands, ...slashCommands]);
-                    this.put('guild', guild.slash, []);
-                }
-                if (global.slash && global.context === false) {
-                    this.put('global', guild.slash, slashCommands);
-                }
-                if (global.slash === false && global.context) {
-                    this.put('global', guild.context, contextCommands);
-                }
-                if (global.slash === false && global.context === false) {
-                    this.put('guild', guild.slash, [...contextCommands, ...slashCommands]);
-                }
-                if (this.client.handlerOptions.context?.logging || this.client.handlerOptions.slash?.logging)
-                    console.info(
-                        dumfunctions_1.Style.log(
-                            `Xernerx | Deployed ${slashCommands.length} slash commands ${global.slash ? 'globally' : 'locally'} and ${contextCommands.length} context commands ${
-                                global.context ? 'globally' : 'locally'
-                            }.`,
-                            { color: dumfunctions_1.Style.TextColor.Purple }
-                        )
-                    );
-            } catch (error) {
-                console.error(
-                    dumfunctions_1.Style.log(`Xernerx | Couldn't deploy interaction commands because <${error}>.`, {
-                        color: dumfunctions_1.Style.BackgroundColor.Red,
-                    })
-                );
-            }
-        });
-    }
-    put(type, guild, body) {
-        const rest = new discord_js_1.REST({ version: discord_js_1.GatewayVersion }).setToken(this.client.token);
-        if (type === 'guild') rest.put(discord_js_1.Routes.applicationGuildCommands(this.client.user?.id, guild), { body });
-        else rest.put(discord_js_1.Routes.applicationCommands(this.client.user?.id), { body });
-    }
-}
-exports.CommandsDeploy = CommandsDeploy;

package/dist/cjs/models/Extensions.d.ts

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

package/dist/cjs/models/Extensions.js

@@ -1,26 +0,0 @@
-'use strict';
-Object.defineProperty(exports, '__esModule', { value: true });
-const dumfunctions_1 = require('dumfunctions');
-class Extensions {
-    client;
-    constructor(client) {
-        this.client = client;
-    }
-    async load(extensions, logging = false) {
-        const exts = [];
-        extensions.map((extension) => {
-            try {
-                this.client.extensions[extension.name] = extension;
-                exts.push(extension.name);
-            } catch (error) {
-                console.error(
-                    dumfunctions_1.Style.log(`Xernerx | An error occurred trying to load ${extension.name}, error: <${error}>`, {
-                        color: dumfunctions_1.Style.BackgroundColor.Red,
-                    })
-                );
-            }
-        });
-        if (logging) console.info(dumfunctions_1.Style.log(`Xernerx | Loaded ${exts.length} extensions: ${exts.join(', ')}`, { color: dumfunctions_1.Style.TextColor.Cyan }));
-    }
-}
-exports.default = Extensions;

package/dist/cjs/tools/XernerxError.d.ts

@@ -1,5 +0,0 @@
-export default class XernerxError {
-    name: string;
-    message: string;
-    constructor(message?: string);
-}

package/dist/cjs/tools/XernerxError.js

@@ -1,11 +0,0 @@
-'use strict';
-Object.defineProperty(exports, '__esModule', { value: true });
-class XernerxError {
-    name;
-    message;
-    constructor(message) {
-        this.name = 'XernerxError';
-        this.message = message || '';
-    }
-}
-exports.default = XernerxError;

package/dist/cjs/tools/package.d.ts

@@ -1,49 +0,0 @@
-declare const _default: {
-    name: string;
-    version: string;
-    type: string;
-    description: string;
-    main: string;
-    keywords: string[];
-    author: string;
-    license: string;
-    homepage: string;
-    packageManager: string;
-    exports: {
-        import: string;
-        require: string;
-        types: string;
-        node: null;
-        default: null;
-    };
-    scripts: {
-        start: string;
-        patch: string;
-        minor: string;
-        major: string;
-        site: string;
-        commit: string;
-        write: string;
-        build: string;
-    };
-    repository: {
-        type: string;
-        url: string;
-    };
-    bugs: {
-        url: string;
-    };
-    dependencies: {
-        '@sapphire/shapeshift': string;
-        'discord.js': string;
-        dumfunctions: string;
-        'xernerx-extension-builder': string;
-        zod: string;
-    };
-    devDependencies: {
-        prettier: string;
-        tsup: string;
-        typescript: string;
-    };
-};
-export default _default;

package/dist/cjs/tools/package.js

@@ -1,50 +0,0 @@
-'use strict';
-Object.defineProperty(exports, '__esModule', { value: true });
-exports.default = {
-    name: 'xernerx',
-    version: '3.5.1',
-    type: 'module',
-    description: 'A bot framework for discord.js.',
-    main: 'dist/main.js',
-    keywords: ['discord.js', 'discord', 'framework', 'mjs', 'esm', 'cjs', 'ts'],
-    author: 'Dummi',
-    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',
-        minor: 'npm run write && git add . && npm run commit && npm version minor && npm publish && git push',
-        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',
-    },
-    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.1',
-        dumfunctions: '^2.1.1',
-        'xernerx-extension-builder': '^0.0.5',
-        zod: '^3.20.6',
-    },
-    devDependencies: {
-        prettier: '^2.8.4',
-        tsup: '^6.6.0',
-        typescript: '^4.9.5',
-    },
-};

package/dist/cjs/types/enums.d.ts

@@ -1,44 +0,0 @@
-import {
-    SlashCommandStringOption,
-    SlashCommandNumberOption,
-    SlashCommandIntegerOption,
-    SlashCommandBooleanOption,
-    SlashCommandUserOption,
-    SlashCommandChannelOption,
-    SlashCommandRoleOption,
-    SlashCommandMentionableOption,
-} from 'discord.js';
-export declare enum InhibitorType {
-    Member = 'Member',
-    User = 'User',
-    Guild = 'Guild',
-    SlashCommand = 'SlashCommand',
-    MessageCommand = 'MessageCommand',
-    ContextCommand = 'ContextCommand',
-    Command = 'Command',
-    Message = 'Message',
-    Interaction = 'Interaction',
-    Channel = 'Channel',
-}
-export declare enum CommandType {
-    Message = 'MessageCommand',
-    Slash = 'SlashCommand',
-    Context = 'ContextCommand',
-    Event = 'Event',
-    Inhibitor = 'Inhibitor',
-    MessageCommand = 'MessageCommand',
-    SlashCommand = 'SlashCommand',
-    ContextCommand = 'ContextCommand',
-}
-export declare enum ContextCommandType {
-    Message = 3,
-    User = 2,
-}
-export declare enum EventEmitterType {
-    Client = 'client',
-    Rest = 'rest',
-    Process = 'process',
-}
-export type SlashCommandOptionChoices = SlashCommandStringOption | SlashCommandNumberOption | SlashCommandIntegerOption;
-export type SlashCommandOption = SlashCommandOptionChoices | SlashCommandBooleanOption | SlashCommandUserOption | SlashCommandChannelOption | SlashCommandRoleOption | SlashCommandMentionableOption;
-export type SlashArgumentTypes = 'String' | 'Number' | 'Boolean' | 'User' | 'Channel' | 'Role' | 'Mentionable' | 'Integer';