xernerx 3.5.2 → 4.0.0

package/dist/models/Arguments.js

@@ -0,0 +1,129 @@
+export async function messageArguments(message, command) {
+    const separator = command.separator || ' ',
+        content = message.content.split(separator).slice(1);
+    let args = {},
+        flags = {};
+    if (command.flags)
+        command.flags.map((flag) => {
+            if (!flags) flags = {};
+            if (content.includes(flag.match)) flags[flag.name] = true;
+            else flags[flag.name] = false;
+            const index = content.indexOf(flag.match);
+            if (index > 0) content.splice(index, 1);
+        });
+    if (command.args)
+        for (const argument of command.args) {
+            const element = content.at(0) || null;
+            if (!element) {
+                if (typeof argument.default === 'function') args[argument.name] = argument.default(message);
+                args[argument.name] = argument.default || null;
+                continue;
+            }
+            if (argument.type === 'option') argument.match?.includes(element) ? (args[argument.name] = element) : (args[argument.name] = null);
+            if (argument.type === 'number') args[argument.name] = parseInt(element);
+            if (argument.type === 'integer') args[argument.name] = parseInt(element);
+            if (argument.type === 'boolean') args[argument.name] = element === 'true' ? true : false;
+            if (argument.type === 'confirm') args[argument.name] = element === 'yes' ? 'yes' : 'no';
+            if (argument.type === 'string') args[argument.name] = element;
+            if (argument.type === 'channel') {
+                try {
+                    const channel = await message.client.channels.fetch(element);
+                    args[argument.name] = channel;
+                } catch (e) {
+                    args[argument.name] = null;
+                }
+            }
+            if (argument.type === 'guild') {
+                try {
+                    const guild = await message.client.guilds.fetch(element);
+                    args[argument.name] = guild;
+                } catch (e) {
+                    args[argument.name] = null;
+                }
+            }
+            if (argument.type === 'mentionable') {
+                (
+                    await Promise.all(
+                        [message.guild?.roles, message.client.users, message.client.guilds, message.client.channels, message.guild?.members, message.channel.messages].map((req) =>
+                            req
+                                ? req
+                                      .fetch(element)
+                                      .then((r) => r)
+                                      .catch(() => null)
+                                : null
+                        )
+                    )
+                ).map((mentionable) => {
+                    if (!args) args = {};
+                    if (mentionable) return (args[argument.name] = mentionable);
+                    else args[argument.name] = null;
+                });
+            }
+            if (argument.type === 'role') {
+                try {
+                    const role = await message.guild?.roles.fetch(element);
+                    args[argument.name] = role;
+                } catch (e) {
+                    args[argument.name] = null;
+                }
+            }
+            if (argument.type === 'user') {
+                try {
+                    const user = await message.client.users.fetch(element);
+                    args[argument.name] = user;
+                } catch (e) {
+                    args[argument.name] = null;
+                }
+            }
+            if (argument.type === 'member') {
+                try {
+                    const member = await message.guild?.members.fetch(element);
+                    args[argument.name] = member;
+                } catch (e) {
+                    args[argument.name] = null;
+                }
+            }
+            if (argument.type === 'message') {
+                try {
+                    const msg = await message.channel?.messages.fetch(element);
+                    args[argument.name] = msg;
+                } catch (e) {
+                    args[argument.name] = null;
+                }
+            }
+            if (argument.type === 'list') {
+                let separator = String(argument.separator) || ',';
+                if (separator.startsWith('/') && separator.endsWith('/')) separator = separator.replace(/^\/|\/$/gim, '');
+                const items = content.join(' ').split(new RegExp(' *' + separator + ' *', 'gi'));
+                if (!argument.content) args[argument.name] = items;
+                else {
+                    const contents = argument.content.map((content) => content.toLowerCase()),
+                        itemList = [];
+                    items.map((item) => (contents.includes(item.toLowerCase()) ? itemList.push(argument.content?.at(contents.indexOf(item.toLowerCase()))) : null));
+                    args[argument.name] = itemList;
+                    break;
+                }
+            }
+            if (argument.type === 'rest') {
+                args[argument.name] = content.join(separator);
+                break;
+            }
+            content.splice(0, 1);
+        }
+    if (!command.flags) flags = null;
+    if (!command.args) args = null;
+    return { args, flags };
+}
+export async function interactionArguments(interaction, command) {
+    const options = {};
+    let args = interaction?.options?._hoistedOptions,
+        group = interaction?.options?._group,
+        subcommand = interaction?.options?._subcommand;
+    if (interaction.options._hoistedOptions) {
+        for (const option of interaction.options._hoistedOptions) {
+            options[option.name] = option.member || option.channel || option.user || option.role || option.value;
+        }
+        args = options;
+    }
+    return { args, group, subcommand };
+}

package/dist/{mjs/models → models}/CommandArguments.js

@@ -1,7 +1,4 @@
-'use strict';
-Object.defineProperty(exports, '__esModule', { value: true });
-exports.messageArguments = exports.InteractionArguments = void 0;
-class InteractionArguments {
+export class InteractionArguments {
     interaction;
     constructor(interaction) {
         this.interaction = interaction;
@@ -22,8 +19,7 @@ class InteractionArguments {
         return options;
     }
 }
-exports.InteractionArguments = InteractionArguments;
-async function messageArguments(message, command) {
+export async function messageArguments(message, command) {
     let args = { flags: {} },
         separator = command.separator || ' ',
         i = 0;
@@ -103,4 +99,3 @@ async function messageArguments(message, command) {
     }
     return args;
 }
-exports.messageArguments = messageArguments;

package/dist/{mjs/models → models}/Events.js

@@ -1,18 +1,11 @@
-'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 {
+import { GatewayVersion, InteractionType, REST, Routes } from 'discord.js';
+import { InteractionCommandUtil, MessageCommandUtil } from '../utils/CommandUtil.js';
+import { InteractionArguments, messageArguments } from './CommandArguments.js';
+import commandValidation from '../validators/CommandValidations.js';
+import { Style } from 'dumfunctions';
+import { InhibitorValidation } from '../validators/InhibitorValidations.js';
+import User from './XernerxUser.js';
+export class MessageCommandEvents {
     client;
     constructor(client) {
         this.client = client;
@@ -22,8 +15,8 @@ class MessageCommandEvents {
             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);
+                message.author = await User(message);
+                message.util = new MessageCommandUtil(this.client, message);
                 const commands = this.client.commands.message;
                 commands
                     .filter((c) => !c.regex)
@@ -58,11 +51,11 @@ class MessageCommandEvents {
                         ) {
                             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;
+                                const inhibitor = new InhibitorValidation(this.client, message, command);
+                                if (commandValidation(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));
+                                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);
                             } catch (error) {
                                 return this.client.emit('commandError', message, error, cmd);
@@ -78,8 +71,8 @@ class MessageCommandEvents {
             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);
+                message.author = await User(message);
+                message.util = new MessageCommandUtil(this.client, message);
                 const commands = this.client.commands.message;
                 commands
                     .filter((c) => !c.regex)
@@ -115,11 +108,11 @@ class MessageCommandEvents {
                             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;
+                                const inhibitor = new InhibitorValidation(this.client, message, command);
+                                if (commandValidation(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));
+                                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);
                             } catch (error) {
                                 return this.client.emit('commandError', message, error, cmd);
@@ -134,6 +127,7 @@ class MessageCommandEvents {
             if (this.client.cache.messages.has(message.id) && this.client.handlerOptions.message?.handleDeletes) {
                 try {
                     if (this.client.handlerOptions.message?.handleTyping) message.channel.sendTyping();
+                    message.author = await User(message);
                     const msg = this.client.cache.messages.get(message.id);
                     const response = await message.channel.messages.fetch(msg?.response);
                     await response.delete();
@@ -144,24 +138,23 @@ class MessageCommandEvents {
         });
     }
 }
-exports.MessageCommandEvents = MessageCommandEvents;
-class SlashCommandEvents {
+export 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) {
+            interaction.util = new InteractionCommandUtil(this.client, interaction);
+            interaction.author = await User(interaction);
+            if (interaction.type === 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);
+                    const argumentsInfo = new InteractionArguments(interaction);
                     try {
-                        const inhibitor = new InhibitorValidations_js_1.InhibitorValidation(this.client, interaction, command);
+                        const inhibitor = new InhibitorValidation(this.client, interaction, command);
                         if (await inhibitor.inhibit()) return;
-                        if ((0, CommandValidations_js_1.default)(interaction, command, this.client)) return;
+                        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,
@@ -195,22 +188,21 @@ class SlashCommandEvents {
         });
     }
 }
-exports.SlashCommandEvents = SlashCommandEvents;
-class ContextCommandEvents {
+export 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) {
+            interaction.util = new InteractionCommandUtil(this.client, interaction);
+            interaction.author = await User(interaction);
+            if (interaction.type === 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;
+                        const inhibitor = new InhibitorValidation(this.client, interaction, command);
+                        if (commandValidation(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)
@@ -236,8 +228,7 @@ class ContextCommandEvents {
         });
     }
 }
-exports.ContextCommandEvents = ContextCommandEvents;
-class CommandsDeploy {
+export class CommandsDeploy {
     client;
     constructor(client) {
         this.client = client;
@@ -261,11 +252,11 @@ class CommandsDeploy {
                 if (global.slash && global.context) {
                     if (guild.slash !== guild.context)
                         console.info(
-                            dumfunctions_1.Style.log(
+                            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 }
+                                { color: Style.TextColor.Red }
                             )
                         );
                     this.put('global', guild.slash, [...contextCommands, ...slashCommands]);
@@ -282,26 +273,25 @@ class CommandsDeploy {
                 }
                 if (this.client.handlerOptions.context?.logging || this.client.handlerOptions.slash?.logging)
                     console.info(
-                        dumfunctions_1.Style.log(
+                        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 }
+                            { color: 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,
+                    Style.log(`Xernerx | Couldn't deploy interaction commands because <${error}>.`, {
+                        color: 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 });
+        const rest = new REST({ version: GatewayVersion }).setToken(this.client.token);
+        if (type === 'guild') rest.put(Routes.applicationGuildCommands(this.client.user?.id, guild), { body });
+        else rest.put(Routes.applicationCommands(this.client.user?.id), { body });
     }
 }
-exports.CommandsDeploy = CommandsDeploy;

package/dist/models/Extensions.js

@@ -0,0 +1,23 @@
+import { Style } from 'dumfunctions';
+export default 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(
+                    Style.log(`Xernerx | An error occurred trying to load ${extension.name}, error: <${error}>`, {
+                        color: Style.BackgroundColor.Red,
+                    })
+                );
+            }
+        });
+        if (logging) console.info(Style.log(`Xernerx | Loaded ${exts.length} extensions: ${exts.join(', ')}`, { color: Style.TextColor.Cyan }));
+    }
+}

package/dist/models/XernerxUser.d.ts

@@ -0,0 +1,2 @@
+import { XernerxUser } from '../types/types.js';
+export default function XernerxUser(interaction: any): Promise<XernerxUser>;

package/dist/models/XernerxUser.js

@@ -0,0 +1,9 @@
+import { hasVoted } from 'dbl-sdk';
+export default async function XernerxUser(interaction) {
+    const user = interaction.user || interaction.author;
+    user.owner = interaction.client.util.isOwner(user.id);
+    user.voter = interaction.client.handlerOptions?.webhook?.topgg?.token
+        ? await hasVoted(user.id, interaction.client.user.id, interaction.client.handlerOptions.webhook.topgg.token, 'top.gg')
+        : false;
+    return user;
+}

package/dist/tools/XernerxError.d.ts

@@ -0,0 +1,6 @@
+export default class XernerxError {
+    name: string;
+    message: string | null;
+    stack: {} | undefined;
+    constructor(message?: string, error?: Error | unknown);
+}

package/dist/tools/XernerxError.js

@@ -0,0 +1,10 @@
+export default class XernerxError {
+    name;
+    message;
+    stack;
+    constructor(message, error) {
+        this.name = 'XernerxError';
+        this.message = message || null;
+        this.stack = error || new Error().stack;
+    }
+}

package/dist/tools/XernerxLog.d.ts

@@ -0,0 +1,13 @@
+import XernerxError from './XernerxError.js';
+import XernerxClient from '../client/XernerxClient.js';
+export default class XernerxLog {
+    private readonly client;
+    private readonly errorLog;
+    private readonly infoLog;
+    private readonly readyLog;
+    constructor(client: XernerxClient);
+    info(message: string, force?: boolean): void | null;
+    warn(message: string): void | null;
+    error(message: string, error?: XernerxError | unknown): void | null;
+    ready(): void;
+}

package/dist/tools/XernerxLog.js

@@ -0,0 +1,30 @@
+import { Style } from 'dumfunctions';
+export default class XernerxLog {
+    client;
+    errorLog;
+    infoLog;
+    readyLog;
+    constructor(client) {
+        this.client = client;
+        this.errorLog = client.settings.log?.error;
+        this.infoLog = client.settings.log?.info;
+        this.readyLog = client.settings.log?.ready;
+    }
+    info(message, force = false) {
+        return this.infoLog || force ? console.info(`${Style.log('✔️  | Xernerx', { color: Style.TextColor.Purple })} | ${message}`) : null;
+    }
+    warn(message) {
+        return this.infoLog ? console.warn(`${Style.log('⚠️  | Xernerx', { color: Style.TextColor.Yellow })} | ${message}`) : null;
+    }
+    error(message, error) {
+        return this.errorLog ? console.error(`${Style.log('❗ | Xernerx', { color: Style.TextColor.Red })} | ${message}${error ? ` | ${error.stack}` : ''}`) : null;
+    }
+    ready() {
+        this.client.prependOnceListener('ready', async (synced) =>
+            this.info(
+                `${synced.user.tag} is now online, watching ${(await this.client.guilds.fetch()).size} guilds, using ${await this.client.guilds.fetch(this.client.settings.local)} as local guild.`,
+                this.readyLog
+            )
+        );
+    }
+}

package/dist/tools/classes.d.ts

@@ -0,0 +1,6 @@
+export default class XernerxError {
+    name: string;
+    message: string | null;
+    error: Error;
+    constructor(message?: string, error?: Error);
+}

package/dist/tools/classes.js

@@ -0,0 +1,10 @@
+export default class XernerxError {
+    name;
+    message;
+    error;
+    constructor(message, error) {
+        this.name = 'XernerxError';
+        this.message = message || null;
+        this.error = error || new Error();
+    }
+}

package/dist/tools/loggers.d.ts

@@ -0,0 +1,4 @@
+export default class XernerxLog {
+    info(message: string): void;
+    error(message: string): void;
+}

package/dist/tools/loggers.js

@@ -0,0 +1,4 @@
+export default class XernerxLog {
+    info(message) {}
+    error(message) {}
+}

package/dist/{cjs/tools → tools}/package.d.ts

@@ -1,21 +1,14 @@
 declare const _default: {
     name: string;
     version: string;
-    type: string;
     description: string;
     main: string;
+    module: 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;
@@ -24,7 +17,10 @@ declare const _default: {
         site: string;
         commit: string;
         write: string;
+        format: string;
         build: string;
+        'build:esm': string;
+        'build:cjs': string;
     };
     repository: {
         type: string;
@@ -35,6 +31,7 @@ declare const _default: {
     };
     dependencies: {
         '@sapphire/shapeshift': string;
+        'dbl-sdk': string;
         'discord.js': string;
         dumfunctions: string;
         'xernerx-extension-builder': string;
@@ -42,7 +39,6 @@ declare const _default: {
     };
     devDependencies: {
         prettier: string;
-        tsup: string;
         typescript: string;
     };
 };

package/dist/{cjs/tools → tools}/package.js

@@ -1,23 +1,14 @@
-'use strict';
-Object.defineProperty(exports, '__esModule', { value: true });
-exports.default = {
+export default {
     name: 'xernerx',
-    version: '3.5.1',
-    type: 'module',
+    version: '3.6.0',
     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', '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',
@@ -25,8 +16,11 @@ exports.default = {
         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',
+        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 && npm run format',
+        'build:esm': 'tsc',
+        'build:cjs': 'tsc --module CommonJS --outDir dist/cjs',
     },
     repository: {
         type: 'git',
@@ -37,14 +31,14 @@ exports.default = {
     },
     dependencies: {
         '@sapphire/shapeshift': '^3.8.1',
+        'dbl-sdk': '^1.2.0',
         'discord.js': '^14.7.1',
-        dumfunctions: '^2.1.1',
-        'xernerx-extension-builder': '^0.0.5',
+        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/{cjs/types → types}/enums.js

@@ -1,7 +1,4 @@
-'use strict';
-Object.defineProperty(exports, '__esModule', { value: true });
-exports.EventEmitterType = exports.ContextCommandType = exports.CommandType = exports.InhibitorType = void 0;
-var InhibitorType;
+export var InhibitorType;
 (function (InhibitorType) {
     InhibitorType['Member'] = 'Member';
     InhibitorType['User'] = 'User';
@@ -13,8 +10,8 @@ var InhibitorType;
     InhibitorType['Message'] = 'Message';
     InhibitorType['Interaction'] = 'Interaction';
     InhibitorType['Channel'] = 'Channel';
-})((InhibitorType = exports.InhibitorType || (exports.InhibitorType = {})));
-var CommandType;
+})((InhibitorType = InhibitorType || (InhibitorType = {})));
+export var CommandType;
 (function (CommandType) {
     CommandType['Message'] = 'MessageCommand';
     CommandType['Slash'] = 'SlashCommand';
@@ -24,15 +21,15 @@ var CommandType;
     CommandType['MessageCommand'] = 'MessageCommand';
     CommandType['SlashCommand'] = 'SlashCommand';
     CommandType['ContextCommand'] = 'ContextCommand';
-})((CommandType = exports.CommandType || (exports.CommandType = {})));
-var ContextCommandType;
+})((CommandType = CommandType || (CommandType = {})));
+export var ContextCommandType;
 (function (ContextCommandType) {
     ContextCommandType[(ContextCommandType['Message'] = 3)] = 'Message';
     ContextCommandType[(ContextCommandType['User'] = 2)] = 'User';
-})((ContextCommandType = exports.ContextCommandType || (exports.ContextCommandType = {})));
-var EventEmitterType;
+})((ContextCommandType = ContextCommandType || (ContextCommandType = {})));
+export var EventEmitterType;
 (function (EventEmitterType) {
     EventEmitterType['Client'] = 'client';
     EventEmitterType['Rest'] = 'rest';
     EventEmitterType['Process'] = 'process';
-})((EventEmitterType = exports.EventEmitterType || (exports.EventEmitterType = {})));
+})((EventEmitterType = EventEmitterType || (EventEmitterType = {})));