xernerx 4.17.7 → 5.0.2

package/dist/build/XernerxSlashCommand.js

@@ -1,182 +0,0 @@
-/** @format */
-import Discord, { SlashCommandSubcommandBuilder, SlashCommandSubcommandGroupBuilder } from 'discord.js';
-import { z } from 'zod';
-import XernerxLog from '../tools/XernerxLog.js';
-export default class XernerxSlashCommand {
-	constructor(id, options) {
-		this.id = id;
-		this.data = new Discord.SlashCommandBuilder();
-		this.data.setName(options.name);
-		this.data.setNameLocalizations(options.nameLocalizations || null);
-		this.data.setDescription(options.description);
-		this.data.setDescriptionLocalizations(options.descriptionLocalizations || null);
-		this.data.setDMPermission(options.permissions?.dm || null);
-		if (options.args && options?.args?.length > 0) {
-			this.addArguments(this.data, options.args);
-		}
-		if (options.subcommands && options?.subcommands?.length > 0) {
-			this.addSubcommands(this.data, options.subcommands);
-		}
-		if (options.groups && options?.groups?.length > 0) {
-			this.addSubcommandGroups(options.groups);
-		}
-		options = z
-			.object({
-				name: z.string(),
-				description: z.string(),
-				usage: z.string().or(z.null()).default(null),
-				info: z.string().or(z.null()).default(null),
-				category: z.string().or(z.null()).default(null),
-				cooldown: z.number().or(z.null()).default(null),
-				number: z.number().or(z.null()).default(null),
-				global: z.boolean().default(true),
-				channel: z
-					.array(
-						z.enum([
-							'GuildText',
-							'DM',
-							'GuildVoice',
-							'GroupDM',
-							'GuildCategory',
-							'GuildAnnouncement',
-							'AnnouncementThread',
-							'PublicThread',
-							'PrivateThread',
-							'GuildStageVoice',
-							'GuildDirectory',
-							'GuildForum',
-							'GuildNews',
-							'GuildNewsThread',
-							'GuildPublicThread',
-							'GuildPrivateThread',
-						])
-					)
-					.or(
-						z.enum([
-							'GuildText',
-							'DM',
-							'GuildVoice',
-							'GroupDM',
-							'GuildCategory',
-							'GuildAnnouncement',
-							'AnnouncementThread',
-							'PublicThread',
-							'PrivateThread',
-							'GuildStageVoice',
-							'GuildDirectory',
-							'GuildForum',
-							'GuildNews',
-							'GuildNewsThread',
-							'GuildPublicThread',
-							'GuildPrivateThread',
-						])
-					)
-					.or(z.null())
-					.default(null),
-				ignore: z
-					.object({
-						owner: z.boolean().default(false),
-						users: z.array(z.string()).default([]),
-						channels: z.array(z.string()).default([]),
-						guilds: z.array(z.string()).default([]),
-						voice: z.boolean().default(false),
-					})
-					.default({}),
-				strict: z
-					.object({
-						owner: z.boolean().default(false),
-						users: z.array(z.string()).default([]),
-						channels: z.array(z.string()).default([]),
-						guilds: z.array(z.string()).default([]),
-						voice: z.boolean().default(false),
-					})
-					.default({}),
-				permissions: z
-					.object({
-						user: z.array(z.string()).or(z.null()).default(null),
-						client: z.array(z.string()).or(z.null()).default(null),
-						dm: z.boolean().default(true),
-					})
-					.default({}),
-				defer: z
-					.object({
-						reply: z.boolean().optional(),
-						ephemeral: z.boolean().optional(),
-						fetch: z.boolean().optional(),
-					})
-					.default({}),
-			})
-			.parse(options);
-		this.name = options.name;
-		this.description = options.description;
-		this.usage = options.usage;
-		this.info = options.info;
-		this.category = options.category;
-		this.cooldown = options.cooldown;
-		this.channel = options.channel ? (Array.isArray(options.channel) ? options.channel : [options.channel]) : null;
-		this.global = options.global;
-		this.ignore = options.ignore;
-		this.strict = options.strict;
-		this.permissions = options.permissions;
-		this.defer = options.defer;
-		this.client = this.client;
-		this.util = this.util;
-	}
-	/**
-	 * @description autocomplete let's you add choices to string option arguments
-	 * @param interaction - The interaction event emitted on this command
-	 * @param focused - The command option that is in focus
-	 * @param options - The full list of options on the command
-	 */
-	async autocomplete(interaction, focused, options) {}
-	/**
-	 * @description Checks for conditions before running the command
-	 * @param interaction - The interaction event emitted on this command
-	 * @param options - The args, group and subcommand parsed on this command
-	 */
-	async conditions(interaction, { args, subcommand, group }) {}
-	/**
-	 * @description Runs the execution rule
-	 * @param interaction - The interaction event emitted on this command
-	 * @param options - The args, group and subcommand parsed on this command
-	 */
-	async exec(interaction, { args, subcommand, group }) {
-		new XernerxLog(this.client).error(`${this.id} doesn't have an execution rule.`);
-		return await this.client.emit('commandError', interaction, `${this.id} doesn't have an execution rule.`, this);
-	}
-	addArguments(command, args) {
-		for (const argument of args) {
-			let slashCommandArgumentType = `${argument.type.charAt(0).toUpperCase()}${argument.type.slice(1).toLowerCase()}`;
-			command[`add${slashCommandArgumentType}Option`]((option) => {
-				option
-					.setName(argument.name)
-					.setDescription(argument.description)
-					.setRequired(argument.required || false);
-				if (slashCommandArgumentType === 'String') {
-					if (argument.choices)
-						option.setChoices(
-							...argument.choices.map((choices) => {
-								return { name: Object.keys(choices).at(0), value: Object.values(choices).at(0) };
-							})
-						);
-					option.setAutocomplete(argument.autocomplete || false);
-				}
-				return option;
-			});
-		}
-	}
-	addSubcommands(method, subcommands) {
-		for (const subcommand of subcommands) {
-			let sub = new SlashCommandSubcommandBuilder().setName(subcommand.name).setDescription(subcommand.description);
-			if (subcommand.args && subcommand?.args?.length > 0) this.addArguments(sub, subcommand.args);
-			method.addSubcommand(sub);
-		}
-	}
-	addSubcommandGroups(groups) {
-		for (const group of groups) {
-			let subcommandGroup = new SlashCommandSubcommandGroupBuilder().setName(group.name).setDescription(group.description);
-			if (group.subcommands?.length > 0) this.addSubcommands(subcommandGroup, group.subcommands);
-			this.data.addSubcommandGroup(subcommandGroup);
-		}
-	}
-}

package/dist/client/XernerxClient.d.ts

@@ -1,70 +0,0 @@
-/** @format */
-import { Client, ClientOptions, Collection } from 'discord.js';
-import { XernerxOptions, ModuleOptions, XernerxCommands, XernerxCache } from '../types/interfaces.js';
-import { XernerxClientEvents } from '../types/extenders.js';
-import ClientUtil from '../utils/ClientUtil.js';
-import XernerxInhibitor from '../build/XernerxInhibitor.js';
-import XernerxEvent from '../build/XernerxEvent.js';
-import Cooldowns from '../models/Cooldowns.js';
-export default class XernerxClient<
-	T extends object = {
-		[index: string | number]: any;
-	},
-> extends Client {
-	readonly settings: {
-		ownerId: (string | string[]) & (string | string[] | undefined);
-		local: string;
-		ceaseless: boolean;
-		global?: boolean | undefined;
-		debug?: boolean | undefined;
-		permissions?:
-			| {
-					user: string[] | null;
-					client: string[] | null;
-					dm: boolean;
-			  }
-			| undefined;
-		ignore?:
-			| {
-					system: boolean;
-					users: string[];
-					owner: boolean;
-					self: boolean;
-					bots: boolean;
-					channels: string[];
-					guilds: string[];
-			  }
-			| undefined;
-		log?:
-			| boolean
-			| {
-					warn: boolean;
-					error: boolean;
-					ready: boolean;
-					info: boolean;
-					table: string[] | null;
-					format: string[] | null;
-			  }
-			| undefined;
-		cooldown?:
-			| {
-					command: number;
-					cache: number;
-					collections: string[];
-			  }
-			| undefined;
-	};
-	readonly config: T;
-	readonly commands: XernerxCommands;
-	readonly events: Collection<string, XernerxEvent<keyof XernerxClientEvents>>;
-	readonly inhibitors: Collection<string, XernerxInhibitor>;
-	readonly modules: ModuleOptions;
-	readonly util: ClientUtil;
-	readonly stats: Record<string, number>;
-	readonly cache: XernerxCache;
-	readonly cooldowns: Cooldowns;
-	readonly dbl: any;
-	readonly [index: string]: unknown;
-	constructor(discordOptions: ClientOptions, xernerxOptions: XernerxOptions, config?: T);
-	connect(token: string): Promise<string | void>;
-}

package/dist/client/XernerxClient.js

@@ -1,106 +0,0 @@
-/** @format */
-import { Client, Collection } from 'discord.js';
-import { z } from 'zod';
-import * as clack from '@clack/prompts';
-import CommandHandler from '../handlers/CommandHandler.js';
-import EventHandler from '../handlers/EventHandler.js';
-import InhibitorHandler from '../handlers/InhibitorHandler.js';
-import IntegrationHandler from '../handlers/IntegrationHandler.js';
-import XernerxLog from '../tools/XernerxLog.js';
-import ClientUtil from '../utils/ClientUtil.js';
-import ExtensionHandler from '../handlers/ExtensionHandler.js';
-import deploy from '../functions/deploy.js';
-import Cooldowns from '../models/Cooldowns.js';
-export default class XernerxClient extends Client {
-	constructor(discordOptions, xernerxOptions, config) {
-		super(discordOptions);
-		clack.intro('Xernerx');
-		this.settings = z
-			.object({
-				local: z.string(),
-				global: z.boolean().default(false).optional(),
-				debug: z.boolean().default(false).optional(),
-				ownerId: z.string().or(z.array(z.string())).default([]),
-				ceaseless: z.boolean().default(false),
-				permissions: z
-					.object({
-						client: z.array(z.string()).or(z.null()).default(null),
-						user: z.array(z.string()).or(z.null()).default(null),
-						dm: z.boolean().default(false),
-					})
-					.optional(),
-				ignore: z
-					.object({
-						owner: z.boolean().default(false),
-						self: z.boolean().default(true),
-						bots: z.boolean().default(true),
-						system: z.boolean().default(true),
-						users: z.array(z.string()).default([]),
-						channels: z.array(z.string()).default([]),
-						guilds: z.array(z.string()).default([]),
-					})
-					.optional(),
-				log: z
-					.object({
-						ready: z.boolean().default(false),
-						info: z.boolean().default(false),
-						warn: z.boolean().default(false),
-						error: z.boolean().default(false),
-						table: z.array(z.string()).or(z.null()).default(null),
-						format: z.array(z.string()).or(z.null()).default(null),
-					})
-					.or(z.boolean())
-					.optional(),
-				cooldown: z
-					.object({
-						command: z.number().default(0),
-						cache: z.number().default(0),
-						collections: z.array(z.string()).default(['commands']),
-					})
-					.optional(),
-			})
-			.parse(xernerxOptions);
-		this.config = config;
-		this.commands = {
-			message: new Collection(),
-			slash: new Collection(),
-			context: new Collection(),
-		};
-		this.events = new Collection();
-		this.inhibitors = new Collection();
-		this.util = new ClientUtil(this);
-		this.stats = {
-			guildCount: this.guilds.cache.size,
-			userCount: 0,
-			shardId: 0,
-			shardCount: this.options.shardCount || 1,
-			voteCount: 0,
-		};
-		this.dbl = {};
-		this.cache = {
-			messages: new Collection(),
-			cooldowns: new Collection(),
-		};
-		this.cooldowns = new Cooldowns(this, xernerxOptions.cooldown?.collections);
-		this.modules = {
-			options: {},
-			commandHandler: new CommandHandler(this),
-			eventHandler: new EventHandler(this),
-			inhibitorHandler: new InhibitorHandler(this),
-			integrationHandler: new IntegrationHandler(this),
-			extensionHandler: new ExtensionHandler(this),
-		};
-	}
-	async connect(token) {
-		if (this.settings.debug) new XernerxLog(this).debug(`Connecting to discord using token ${token}...`);
-		const login = await this.login(token).catch(() => {
-			new XernerxLog(this).error('An invalid token was provided. Please make sure to provide a valid Discord bot token.');
-		});
-		if (this.settings.debug) new XernerxLog(this).debug(`Connected to discord using token ${token}`);
-		deploy(this);
-		new XernerxLog(this).ready();
-		const spinner = clack.spinner();
-		spinner.start();
-		return login;
-	}
-}

package/dist/client/XernerxShardClient.d.ts

@@ -1,21 +0,0 @@
-/** @format */
-import { ShardingManager, ShardingManagerOptions, ClientUser } from 'discord.js';
-interface XernerxOptions {
-	log?: {
-		info?: boolean;
-	};
-	timeout?: number;
-}
-export default class XernerxShardClient extends ShardingManager {
-	readonly stats: {
-		guildCount: number;
-		userCount: number;
-		shardCount: number;
-		voteCount: number;
-		shards: {};
-	};
-	user: ClientUser | null;
-	spawner: Promise<import('discord.js').Collection<number, import('discord.js').Shard>>;
-	constructor(file: string, discordOptions: ShardingManagerOptions, xernerxOptions?: XernerxOptions, data?: unknown);
-}
-export {};

package/dist/client/XernerxShardClient.js

@@ -1,67 +0,0 @@
-/** @format */
-import { ShardingManager } from 'discord.js';
-import { Style } from 'dumfunctions';
-import XernerxLog from '../tools/XernerxLog.js';
-export default class XernerxShardClient extends ShardingManager {
-	constructor(file, discordOptions, xernerxOptions, data = {}) {
-		super(file, discordOptions);
-		this.stats = { guildCount: 0, userCount: 0, shardCount: 0, voteCount: 0, shards: {} };
-		this.user = null;
-		new XernerxLog(true).info('Starting sharding process...');
-		this.on('shardCreate', async (shard) => {
-			shard
-				.on('ready', async () => {
-					await new Promise((resolve) => setTimeout(resolve, 250));
-					const stats = await shard.fetchClientValue('stats');
-					this.stats.shards[String(shard.id)] = stats;
-					this.user = await shard.fetchClientValue('user');
-					this.stats.guildCount += stats.guildCount;
-					this.stats.userCount += stats.userCount;
-					this.stats.shardCount++;
-					this.stats.voteCount = stats.voteCount;
-					shard.send({ type: 'xernerx', data: { shardId: shard.id, sharded: true } });
-					shard.send({ type: 'client', data });
-					new XernerxLog({ settings: xernerxOptions }).info(
-						`Launched shard ${Style.log(String(shard.id), { color: Style.TextColor.Cyan })} for ${Style.log(this.user?.tag, { color: Style.TextColor.Blue })}! ${
-							xernerxOptions?.timeout ? `Automatically killing in ${Style.log(String(xernerxOptions.timeout), { color: Style.TextColor.Cyan })}ms.` : ''
-						}`
-					);
-				})
-				.on('error', (error) => {
-					new XernerxLog({ settings: xernerxOptions }).info(
-						`An error occurred in ${Style.log(String(shard.id), { color: Style.TextColor.Cyan })} for ${Style.log(String(this.user?.tag), { color: Style.TextColor.Blue })}! ${error}`
-					);
-				});
-			if (xernerxOptions?.timeout)
-				setTimeout(() => {
-					new XernerxLog({ settings: xernerxOptions }).warn(
-						`Automatically killing shard ${Style.log(String(shard.id), { color: Style.TextColor.Cyan })} on ${Style.log(String(shard.manager.user?.tag), {
-							color: Style.TextColor.Blue,
-						})}!`
-					);
-					shard.kill();
-				}, xernerxOptions.timeout);
-		});
-		const spawn = this.spawn();
-		this.spawner = spawn;
-		spawn.then(async (shards) => {
-			const collector = setInterval(() => {
-				const index = shards.size - 1;
-				if (shards.get(index)?.ready) {
-					clearInterval(collector);
-					new XernerxLog({ settings: xernerxOptions }).info(
-						`All Shards launched for ${Style.log(String(this.user?.tag), {
-							color: Style.TextColor.Blue,
-						})} with a total of ${Style.log(String(this.stats.shardCount), { color: Style.TextColor.Cyan })} shard${this.stats.shardCount > 1 ? 's' : ''}, watching ${Style.log(
-							String(this.stats.guildCount),
-							{
-								color: Style.TextColor.Cyan,
-							}
-						)} guild${this.stats.guildCount > 1 ? 's' : ''}, and ${Style.log(String(this.stats.userCount), { color: Style.TextColor.Cyan })} user${this.stats.userCount > 1 ? 's' : ''}!`
-					);
-				}
-			}, 1000);
-		});
-		return this;
-	}
-}

package/dist/functions/deploy.d.ts

@@ -1,3 +0,0 @@
-/** @format */
-import XernerxClient from '../client/XernerxClient.js';
-export default function deploy(client: XernerxClient): void;

package/dist/functions/deploy.js

@@ -1,56 +0,0 @@
-/** @format */
-import { GatewayVersion, REST, Routes } from 'discord.js';
-import { Style } from 'dumfunctions';
-import XernerxLog from '../tools/XernerxLog.js';
-import XernerxError from '../tools/XernerxError.js';
-const globalCommands = [];
-const localCommands = [];
-export default function deploy(client) {
-	const commands = [];
-	function stats() {
-		client.stats.guildCount = client.guilds.cache.size;
-		client.stats.userCount = client.guilds.cache.map((g) => g.memberCount || g.approximateMemberCount || 0).reduce((a, b) => (a += b), 0);
-	}
-	process.on('message', (message) => {
-		if (message.type == 'xernerx') client.stats.shardId = message?.data?.shardId;
-		if (message.type == 'client') client.data = message.data;
-	});
-	client.on('messageCreate', stats);
-	client.on('interactionCreate', stats);
-	client.once('ready', (client) => {
-		stats();
-		client.commands.slash.map((command) => commands.push(command));
-		client.commands.context.map((command) => commands.push(command));
-		client.commands.message.map((command) => commands.push(command));
-		if (client.commands.slash.size) client.commands.slash.map((command) => (command.global ? globalCommands.push(command.data.toJSON()) : localCommands.push(command.data.toJSON())));
-		if (client.commands.context.size) client.commands.context.map((command) => (command.global ? globalCommands.push(command.data.toJSON()) : localCommands.push(command.data.toJSON())));
-		if (!globalCommands.length && !localCommands.length && !client.commands.message.size) return;
-		try {
-			if (client.settings.global) {
-				put(client, client.settings.global, globalCommands);
-				put(client, !client.settings.global, localCommands);
-			} else {
-				put(client, !client.settings.global, [...globalCommands, ...localCommands]);
-				put(client, client.settings.global, []);
-			}
-		} catch (error) {
-			new XernerxLog(client).error(`An error occurred while deploying the commands!`, error);
-		} finally {
-			new XernerxLog(client).info(
-				`Deployed ${Style.log(String(commands.filter((command) => command.global).length), {
-					color: Style.TextColor.Cyan,
-				})} Commands ${
-					client.settings.global
-						? Style.log('globally', { color: Style.TextColor.Green })
-						: `${Style.log('locally', { color: Style.TextColor.Red })} in ${Style.log(client.guilds.cache.get(client.settings.local)?.name, { color: Style.TextColor.Blue })}`
-				}.`
-			);
-		}
-	});
-}
-function put(client, global, body) {
-	const rest = new REST({ version: GatewayVersion }).setToken(client.token);
-	if (!global && !client.settings?.local) throw new XernerxError(`No guild ID provided as local guild!`);
-	if (!global && client.settings?.local) return rest.put(Routes.applicationGuildCommands(client.user?.id, client.settings.local), { body });
-	else return rest.put(Routes.applicationCommands(client.user?.id), { body });
-}

package/dist/functions/load.d.ts

@@ -1,4 +0,0 @@
-/** @format */
-import XernerxClient from '../client/XernerxClient.js';
-import { filetype } from '../types/types.js';
-export default function load(client: XernerxClient, path: string, type: filetype): Promise<any>;

package/dist/functions/load.js

@@ -1,34 +0,0 @@
-/** @format */
-import XernerxLog from '../tools/XernerxLog.js';
-export default async function load(client, path, type) {
-	try {
-		let file = new (await import(`file://${path}`)).default();
-		file.filetype = type;
-		file.filepath = path;
-		file.client = client;
-		file.util = {};
-		fileSave(client, file, type);
-		return file;
-	} catch (error) {
-		new XernerxLog(client).error(`Couldn't load ${type} ${path.match(/\w*\.js$/gim)?.at(0) || path}`, error);
-	}
-}
-function fileSave(client, file, type) {
-	switch (type) {
-		case 'MessageCommand':
-			client.commands.message.set(file.name, file);
-			break;
-		case 'SlashCommand':
-			client.commands.slash.set(file.name, file);
-			break;
-		case 'ContextCommand':
-			client.commands.context.set(file.name, file);
-			break;
-		case 'Inhibitor':
-			client.inhibitors.set(file.name, file);
-			break;
-		case 'Event':
-			client.events.set(file.name, file);
-			break;
-	}
-}

package/dist/functions/reload.d.ts

@@ -1,3 +0,0 @@
-/** @format */
-import XernerxClient from '../client/XernerxClient.js';
-export default function reload(client: XernerxClient, type: 'commands' | 'context' | 'message' | 'slash' | 'events' | 'inhibitors'): Promise<true | void | null>;

package/dist/functions/reload.js

@@ -1,29 +0,0 @@
-/** @format */
-import * as path from 'path';
-import * as fs from 'fs';
-import load from './load.js';
-export default async function reload(client, type) {
-	switch (type) {
-		case 'message': {
-			client.commands.message.clear();
-			if (!client.modules.options.message) return null;
-			const directory = path.resolve(client.modules.options.message?.directory);
-			for (const file of fs.readdirSync(directory)) {
-				load(client, `${directory}\\${file}`, 'MessageCommand');
-			}
-			return true;
-		}
-		case 'slash': {
-			return client.commands.slash.clear();
-		}
-		case 'context': {
-			return client.commands.context.clear();
-		}
-		case 'events': {
-			return client.events.clear();
-		}
-		case 'inhibitors': {
-			return client.inhibitors.clear();
-		}
-	}
-}

package/dist/functions/setPresence.d.ts

@@ -1,4 +0,0 @@
-/** @format */
-import XernerxClient from '../client/XernerxClient.js';
-import { PresenceOptions } from '../types/interfaces.js';
-export default function setPresence(client: XernerxClient, options: PresenceOptions): import('discord.js').ClientPresence | undefined;

package/dist/functions/setPresence.js

@@ -1,22 +0,0 @@
-/** @format */
-import { ActivityType } from 'discord.js';
-import { Style } from 'dumfunctions';
-export default function setPresence(client, options) {
-	const presence = () =>
-		client.user?.setPresence({
-			activities: [
-				{
-					name: options.text,
-					type: ActivityType[Style.titleCase(options.type || 'Custom')],
-					url: options.url,
-				},
-			],
-			status: options.status,
-		});
-	let response = presence();
-	if (options.interval)
-		setInterval(() => {
-			response = presence();
-		}, options.interval);
-	return response;
-}

package/dist/functions/xernerxUser.d.ts

@@ -1,4 +0,0 @@
-/** @format */
-import XernerxClient from '../client/XernerxClient.js';
-import { XernerxMessage, XernerxSlashInteraction, XernerxUser, XernerxUserContextInteraction } from '../types/extenders.js';
-export declare function xernerxUser(event: XernerxMessage | XernerxSlashInteraction | XernerxUserContextInteraction | XernerxUserContextInteraction, client: XernerxClient): Promise<XernerxUser>;

package/dist/functions/xernerxUser.js

@@ -1,10 +0,0 @@
-/** @format */
-export async function xernerxUser(event, client) {
-	const author = event.author || event.user;
-	author.owner = isOwner(client, author);
-	if (client.dbl.validate) author.voted = await client?.dbl?.validate(author);
-	return author;
-}
-function isOwner(client, user) {
-	return client.settings.ownerId.includes(user.id);
-}

package/dist/handlers/CommandHandler.d.ts

@@ -1,16 +0,0 @@
-/** @format */
-import XernerxClient from '../client/XernerxClient.js';
-import { ContextHandlerOptions, MessageHandlerOptions, SlashHandlerOptions } from '../types/interfaces.js';
-import Handler from './Handler.js';
-export default class CommandHandler extends Handler {
-	readonly readyTimestamp: number;
-	constructor(client: XernerxClient);
-	loadMessageCommands(options: MessageHandlerOptions): Promise<void>;
-	loadSlashCommands(options: SlashHandlerOptions): Promise<void>;
-	loadContextCommands(options: ContextHandlerOptions): Promise<void>;
-	private messageCommandRun;
-	private slashCommandRun;
-	private contextCommandRun;
-	private exec;
-	private _checks;
-}