xernerx 4.17.7 → 5.0.2

package/dist/handlers/CommandHandler.js

@@ -1,326 +0,0 @@
-/** @format */
-import { z } from 'zod';
-import * as path from 'path';
-import { GatewayIntentBits } from 'discord.js';
-import Handler from './Handler.js';
-import MessageUtil from '../utils/MessageUtil.js';
-import { xernerxUser } from '../functions/xernerxUser.js';
-import InteractionUtil from '../utils/InteractionUtil.js';
-import commandValidation from '../validators/commandValidation.js';
-import XernerxLog from '../tools/XernerxLog.js';
-import { interactionArguments, messageArguments } from '../models/Arguments.js';
-import { inhibitorValidation } from '../validators/inhibitorValidations.js';
-import { Style } from 'dumfunctions';
-export default class CommandHandler extends Handler {
-	constructor(client) {
-		super(client);
-		this.readyTimestamp = Number(Date.now());
-	}
-	async loadMessageCommands(options) {
-		const commands = [];
-		if (!this.client.options.intents.has(GatewayIntentBits.MessageContent)) new XernerxLog(this.client).warn(`Message commands might not work as you're missing the intent MessageContent!`);
-		if (!this.client.options.intents.has(GatewayIntentBits.GuildMessages)) new XernerxLog(this.client).warn(`Message commands might not work as you're missing the intent GuildMessages!`);
-		options = z
-			.object({
-				directory: z.string(),
-				prefix: z.string().or(z.array(z.string())),
-				allowMention: z.boolean().default(false),
-				cooldown: z.number().default(0),
-				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({}),
-				handleEdits: z.boolean().default(false),
-				handleDeletes: z.boolean().default(false),
-				handleTyping: z.boolean().default(false),
-				logging: z.boolean().default(false),
-			})
-			.parse(options);
-		this.client.modules.options.message = options;
-		const files = await this.readdir(options.directory, 'MessageCommands');
-		for (const file of files) {
-			const filepath = `${path.resolve(options.directory)}\\${file}`;
-			const command = await this.load(filepath, 'MessageCommand');
-			this._checks(command);
-			commands.push(command.id);
-		}
-		new XernerxLog(this.client).info(
-			`Loaded ${Style.log(String(files.length), { color: Style.TextColor.Cyan })} Message Commands: ${commands.map((command) => Style.log(command, { color: Style.TextColor.LightYellow })).join(', ')}`
-		);
-		this.emit({
-			name: 'messageCreate',
-			filetype: 'MessageCommand',
-			run: (message) => this.messageCommandRun(message),
-		});
-		this.emit({
-			name: 'messageUpdate',
-			filetype: 'MessageCommand',
-			run: (message, message2) => this.messageCommandRun(message, message2),
-		});
-		this.emit({
-			name: 'messageDelete',
-			filetype: 'MessageCommand',
-			run: (message) => this.messageCommandRun(message, 'delete'),
-		});
-		this.client.on('messageReactionAdd', (message) => {
-			message.util = new MessageUtil(this.client, message);
-		});
-		this.client.on('messageReactionRemove', (message) => {
-			message.util = new MessageUtil(this.client, message);
-		});
-		this.client.on('messageReactionRemoveAll', (message) => {
-			message.util = new MessageUtil(this.client, message);
-		});
-		this.client.on('messageReactionRemoveEmoji', (message) => {
-			message.util = new MessageUtil(this.client, message);
-		});
-	}
-	// public reloadMessageCommands() {
-	// 	return reload(this.client, 'message');
-	// }
-	async loadSlashCommands(options) {
-		const commands = [];
-		if (!this.client.settings.local) new XernerxLog(this.client).warn(`Slash commands might not work as you haven't specified a local guild ID.`);
-		options = z
-			.object({
-				directory: z.string(),
-				cooldown: z.number().default(0),
-				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({}),
-				logging: z.boolean().default(false),
-				defer: z
-					.object({
-						reply: z.boolean().default(false),
-						ephemeral: z.boolean().default(false),
-						fetchReply: z.boolean().default(false),
-					})
-					.default({}),
-			})
-			.parse(options);
-		this.client.modules.options.slash = options;
-		const files = await this.readdir(options.directory, 'SlashCommands');
-		for (const file of files) {
-			const filepath = `${path.resolve(options.directory)}\\${file}`;
-			const command = await this.load(filepath, 'SlashCommand');
-			commands.push(command.id);
-		}
-		new XernerxLog(this.client).info(
-			`Loaded ${Style.log(String(files.length), { color: Style.TextColor.Cyan })} Slash Commands: ${commands.map((command) => Style.log(command, { color: Style.TextColor.LightYellow })).join(', ')}`
-		);
-		this.emit({
-			name: 'interactionCreate',
-			filetype: 'SlashCommand',
-			run: (interaction) => this.slashCommandRun(interaction),
-		});
-	}
-	async loadContextCommands(options) {
-		const commands = [];
-		if (!this.client.settings.local) new XernerxLog(this.client).warn(`Context commands might not work as you haven't specified a local guild ID.`);
-		options = z
-			.object({
-				directory: z.string(),
-				cooldown: z.number().default(0),
-				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({}),
-				logging: z.boolean().default(false),
-				defer: z
-					.object({
-						reply: z.boolean().default(false),
-						ephemeral: z.boolean().default(false),
-						fetchReply: z.boolean().default(false),
-					})
-					.default({}),
-			})
-			.parse(options);
-		this.client.modules.options.context = options;
-		const files = await this.readdir(options.directory, 'ContextCommands');
-		for (const file of files) {
-			const filepath = `${path.resolve(options.directory)}\\${file}`;
-			const command = await this.load(filepath, 'ContextCommand');
-			commands.push(command.id);
-		}
-		new XernerxLog(this.client).info(
-			`Loaded ${Style.log(String(files.length), { color: Style.TextColor.Cyan })} Context Commands: ${commands.map((command) => Style.log(command, { color: Style.TextColor.LightYellow })).join(', ')}`
-		);
-		this.emit({
-			name: 'interactionCreate',
-			filetype: 'ContextCommand',
-			run: (interaction) => this.contextCommandRun(interaction),
-		});
-	}
-	async messageCommandRun(message, message2) {
-		const filetype = 'MessageCommand';
-		if (message.author.id === this.client.user?.id && this.client.settings.ignore?.self) return;
-		else if (message.author.bot && this.client.settings.ignore?.bots) return;
-		if (message.system && this.client.settings.ignore?.system) return;
-		message.util = new MessageUtil(this.client, message);
-		message.user = await xernerxUser(message, this.client);
-		if (await inhibitorValidation(message, undefined, undefined, 'pre')) return;
-		if (typeof message2 === 'object') message = message2;
-		if (message2 === 'delete' && this.client.modules.options.message?.handleDeletes) {
-			if (!this.client.cache.messages.has(message.id)) return;
-			const id = this.client.cache.messages.get(message.id);
-			if (!id) return;
-			(async () => {
-				const msg = await message.channel.messages.fetch(id);
-				await msg.delete();
-				this.client.cache.messages.delete(message.id);
-			})();
-			return;
-		}
-		if (message.content && this.client.modules.options.message) {
-			const commands = this.client.commands.message;
-			const prefixes = Array.isArray(this.client.modules.options.message.prefix) ? this.client.modules.options.message.prefix : [this.client.modules.options.message.prefix];
-			let commandName = null,
-				cmd,
-				commandAlias = null,
-				commandPrefix = null;
-			commands.map((command) => {
-				let prefix = null;
-				if (command.regex && message.content.match(command.regex)) {
-					const [match] = message.content.match(command.regex) || [null];
-					if (match) commandName = command.name;
-				}
-				const cp = Array.isArray(command.prefix) ? command.prefix : [command.prefix];
-				prefixes.map((p) => {
-					if (message.content.startsWith(p)) prefix = p;
-				});
-				cp.map((p) => {
-					if (message.content.startsWith(p)) prefix = p;
-				});
-				if (!prefix) return;
-				if (!commandName)
-					commandName =
-						message.content
-							.replace(prefix, '')
-							.split(command.separator || / +/)
-							.shift()
-							?.trim()
-							?.toLowerCase() || '';
-				if (!this.client.commands.message.has(commandName) && command.aliases?.includes(commandName)) {
-					commandAlias = commandName;
-					commandName = command.name;
-				}
-				commandAlias = commandAlias ? commandAlias : commandName;
-				commandPrefix = prefix;
-			});
-			if (!cmd && this.client.modules.options.message.allowMention) {
-				if (message.mentions.users.has(this.client.user?.id) || message.mentions.repliedUser?.id === this.client.user?.id) {
-					commandName = message.content.replace(`<@${this.client.user?.id}>`, '').trim().split(/ +/).shift()?.toLowerCase() || null;
-					commands.map((command) => {
-						if (command.aliases?.includes(commandName)) {
-							commandName = command.name;
-							return (commandAlias = commandName);
-						}
-					});
-					commandPrefix = `<@${this.client.user?.id}>`;
-				}
-			}
-			if (this.client.commands.message.has(commandName)) {
-				if (this.client.modules.options.message?.handleTyping) message.channel.sendTyping();
-				cmd = this.client.commands.message.get(commandName);
-			}
-			if (!commandPrefix || !commandName) return;
-			if (!cmd) return await this.client.emit('commandNotFound', message, commandName, filetype);
-			await this.client.emit('commandStart', message, cmd);
-			const args = await messageArguments(message, cmd, commandPrefix);
-			message.util.parsed = {
-				alias: commandAlias,
-				prefix: commandPrefix,
-				args: args.args,
-			};
-			cmd.util = message.util;
-			return await this.exec(cmd, message, args, filetype);
-		}
-	}
-	async slashCommandRun(interaction) {
-		const filetype = 'SlashCommand';
-		interaction.util = new InteractionUtil(this.client, interaction);
-		interaction.user = await xernerxUser(interaction, this.client);
-		if (await inhibitorValidation(interaction, undefined, undefined, 'pre')) return;
-		let cmd = null;
-		if (this.client.commands.slash.has(interaction.commandName)) cmd = this.client.commands.slash.get(interaction.commandName);
-		if (!cmd) return this.client.emit('commandNotFound', interaction, interaction.commandName, filetype);
-		new Promise(async (resolve) => {
-			if (interaction.isAutocomplete()) {
-				const focused = interaction.options.getFocused(true);
-				const options = interaction.options;
-				await cmd.autocomplete(interaction, focused, options);
-			} else resolve(true);
-		})
-			.then(async () => {
-				await this.client.emit('commandStart', interaction);
-				const args = await interactionArguments(interaction, cmd);
-				interaction.util.parsed = {
-					alias: [interaction.commandName, args.group || null, args.subcommand || null].filter((x) => x).join(' '),
-					args: args.args,
-				};
-				cmd.util = interaction.util;
-				return await this.exec(cmd, interaction, args, filetype);
-			})
-			.catch((error) => this.client.emit('commandError', interaction, error, cmd));
-	}
-	async contextCommandRun(interaction) {
-		const filetype = 'ContextCommand';
-		interaction.util = new InteractionUtil(this.client, interaction);
-		interaction.user = await xernerxUser(interaction, this.client);
-		if (await inhibitorValidation(interaction, undefined, undefined, 'pre')) return;
-		let cmd;
-		if (this.client.commands.context.has(interaction.commandName)) cmd = this.client.commands.context.get(interaction.commandName);
-		if (!cmd) return this.client.emit('commandNotFound', interaction, interaction.commandName, filetype);
-		await this.client.emit('commandStart', interaction);
-		const args = await interactionArguments(interaction, cmd);
-		interaction.util.parsed = {
-			alias: interaction.commandName,
-			args: args,
-		};
-		cmd.util = interaction.util;
-		return await this.exec(cmd, interaction, args, filetype);
-	}
-	async exec(cmd, event, args, type) {
-		try {
-			if (cmd.filetype == 'SlashCommand' && (cmd?.defer?.reply ?? this.client.modules.options.slash?.defer?.reply)) {
-				await event.deferReply({
-					ephemeral: cmd.defer?.ephemeral || this.client.modules.options.slash?.defer?.ephemeral || false,
-				});
-			}
-			if (cmd.filetype == 'ContextCommand' && (cmd?.defer?.reply ?? this.client.modules.options.context?.defer?.reply)) {
-				await event.deferReply({
-					ephemeral: cmd.defer?.ephemeral || this.client.modules.options.context?.defer?.ephemeral || false,
-				});
-			}
-			if (await commandValidation(event, cmd)) return;
-			if (await inhibitorValidation(event, args, cmd, 'check')) return;
-			if (cmd.conditions && (await cmd.conditions(event, args))) return;
-			await cmd.exec(event, args);
-			await inhibitorValidation(event, args, cmd, 'post');
-			return await this.client.emit('commandFinish', event, cmd);
-		} catch (error) {
-			new XernerxLog(this.client).error(`An error occurred executing ${Style.log(cmd.name, { color: Style.TextColor.Blue })}`, error);
-			return await this.client.emit('commandError', event, error, cmd);
-		}
-	}
-	_checks(command) {
-		if ((command.strict?.voice || command.ignore?.voice) && !this.client.options.intents.has('GuildVoiceStates'))
-			new XernerxLog(this.client).warn(
-				`${Style.log(command.id, { color: Style.TextColor.Blue })} options ${Style.log(`Xernerx${command.filetype}#strict#voice`, {
-					color: Style.BackgroundColor.Grey,
-				})} or ${Style.log(`Xernerx${command.filetype}#ignore#voice`, {
-					color: Style.BackgroundColor.Grey,
-				})} will misbehave due to missing the ${Style.log('GuildVoiceStates', { color: Style.TextColor.Yellow })} intent.`
-			);
-	}
-}

package/dist/handlers/EventHandler.d.ts

@@ -1,9 +0,0 @@
-/** @format */
-import XernerxClient from '../client/XernerxClient.js';
-import { EventHandlerOptions } from '../types/interfaces.js';
-import Handler from './Handler.js';
-export default class EventHandler extends Handler {
-	readonly readyTimestamp: number;
-	constructor(client: XernerxClient);
-	loadEvents(options: EventHandlerOptions): Promise<void>;
-}

package/dist/handlers/EventHandler.js

@@ -1,56 +0,0 @@
-/** @format */
-import { z } from 'zod';
-import { Style } from 'dumfunctions';
-import * as path from 'path';
-import Handler from './Handler.js';
-import XernerxLog from '../tools/XernerxLog.js';
-export default class EventHandler extends Handler {
-	constructor(client) {
-		super(client);
-		this.readyTimestamp = Number(Date.now());
-	}
-	async loadEvents(options) {
-		const events = [];
-		options = z
-			.object({
-				directory: z.string(),
-			})
-			.parse(options);
-		this.client.modules.options.events = options;
-		const files = await this.readdir(options.directory, 'Events');
-		for (const file of files) {
-			const filepath = `${path.resolve(options.directory)}\\${file}`;
-			const event = await this.load(filepath, 'Event');
-			this.emit(event);
-			events.push(event.id);
-		}
-		new XernerxLog(this.client).info(
-			`Loaded ${Style.log(String(this.client.events.size), { color: Style.TextColor.Cyan })} Events: ${events.map((event) => Style.log(event, { color: Style.TextColor.LightYellow })).join(', ')}`
-		);
-		process.on('unhandledRejection', async (error) => {
-			if (this.client.settings.ceaseless) new XernerxLog(this.client).error('An uncaught error happpened, this is triggered from the ceaseless setting.', error);
-			const data = {
-				channel: null,
-				message: null,
-				user: null,
-				url: error.url || null,
-				stack: error.stack || error,
-			};
-			if (error.url) {
-				await error.url.match(/(channels|messages|servers|users)\/\d{10,100}/gim)?.map(async (identifier) => {
-					const [type, id] = identifier.split('/');
-					console.log(type, id);
-					switch (type) {
-						case 'channels':
-							return (data.channel = (await this.client.channels.fetch(id)) || id);
-						case 'messages' && data.channel:
-							return (data.message = (await data.channel.messages.cache.get(id)) || id);
-						case 'users':
-							return (data.user = (await this.client.users.fetch(id)) || id);
-					}
-				});
-			}
-			this.client.emit('processError', this.client, data);
-		});
-	}
-}

package/dist/handlers/ExtensionHandler.d.ts

@@ -1,9 +0,0 @@
-/** @format */
-import XernerxExtensionBuilder from 'xernerx-extension-builder';
-import XernerxClient from '../client/XernerxClient.js';
-import Handler from './Handler.js';
-export default class ExtensionHandler extends Handler {
-	readonly readyTimestamp: number;
-	constructor(client: XernerxClient);
-	loadExtensions(...extensions: Array<XernerxExtensionBuilder>): void;
-}

package/dist/handlers/ExtensionHandler.js

@@ -1,29 +0,0 @@
-/** @format */
-import { Style } from 'dumfunctions';
-import Handler from './Handler.js';
-import XernerxLog from '../tools/XernerxLog.js';
-export default class ExtensionHandler extends Handler {
-	constructor(client) {
-		super(client);
-		this.readyTimestamp = Number(Date.now());
-	}
-	loadExtensions(...extensions) {
-		const active = extensions.map((extension) => {
-			try {
-				if (extension.main) extension.main(this.client);
-				if (extension.defer) {
-					this.client.on('ready', (client) => extension.defer(client));
-				}
-				return extension.name;
-			} catch (error) {
-				return new XernerxLog(this.client).error(`An error occurred while loading ${Style.log(extension.name, { color: Style.TextColor.Red })}`, error);
-			}
-		});
-		new XernerxLog(this.client).info(
-			`Loaded ${Style.log(String(extensions.length), { color: Style.TextColor.Cyan })} Extensions: ${active
-				.filter((e) => e)
-				.map((event) => Style.log(event, { color: Style.TextColor.LightYellow }))
-				.join(', ')}`
-		);
-	}
-}

package/dist/handlers/Handler.d.ts

@@ -1,31 +0,0 @@
-/** @format */
-import XernerxClient from '../client/XernerxClient.js';
-import MessageCommandBuilder from '../build/XernerxMessageCommand.js';
-import XernerxSlashCommand from '../build/XernerxSlashCommand.js';
-import XernerxContextCommand from '../build/XernerxContextCommand.js';
-import { filetype } from '../types/types.js';
-import { XernerxClientEvents, XernerxEvent, XernerxInhibitor } from '../main.js';
-export default class Handler {
-	readonly client: XernerxClient<{
-		[index: string]: any;
-		[index: number]: any;
-	}>;
-	readonly files: Array<MessageCommandBuilder | XernerxSlashCommand | XernerxContextCommand>;
-	constructor(client: XernerxClient);
-	readdir(dir: string, type: string): Promise<string[]>;
-	load(filepath: string, type: filetype): Promise<any>;
-	/**
-	 * Emits a file that has been loaded into the handler.
-	 * @param file - The file to emit.
-	 */
-	emit<
-		File extends
-			| {
-					name: string;
-					filetype: 'MessageCommand' | 'SlashCommand' | 'ContextCommand';
-					run: Function;
-			  }
-			| XernerxInhibitor
-			| XernerxEvent<keyof XernerxClientEvents>,
-	>(file: File): Promise<void>;
-}

package/dist/handlers/Handler.js

@@ -1,52 +0,0 @@
-/** @format */
-import * as fs from 'fs';
-import * as path from 'path';
-import load from '../functions/load.js';
-import { Style, XernerxLog } from '../main.js';
-export default class Handler {
-	client;
-	files;
-	constructor(client) {
-		this.client = client;
-		this.files = [];
-	}
-	async readdir(dir, type) {
-		try {
-			return fs.readdirSync(path.resolve(dir)).filter((file) => file.endsWith('.js'));
-		} catch (error) {
-			new XernerxLog(this.client).error(`Cannot load ${type.toLowerCase()}, there is no such directory ${Style.log(dir, { color: Style.BackgroundColor.Grey })}.`);
-		}
-		return [];
-	}
-	async load(filepath, type) {
-		const file = await load(this.client, filepath, type);
-		if (this.client.settings.debug) new XernerxLog(this.client).debug(`Loaded ${Style.log(type, { color: Style.TextColor.Blue })} ${Style.log(file.name, { color: Style.TextColor.Yellow })}`);
-		this.files.push(file);
-		return file;
-	}
-	/**
-	 * Emits a file that has been loaded into the handler.
-	 * @param file - The file to emit.
-	 */
-	async emit(file) {
-		if (!file?.filetype) return;
-		if (file.filetype === 'Inhibitor') return;
-		if (file.filetype === 'Event' && file.emitter) {
-			if (file.emitter === 'client') {
-				if (this.client.settings.debug) new XernerxLog(this.client).debug(`Listening to client event ${Style.log(file.name, { color: Style.TextColor.Yellow })}`);
-				this.client[file.once ? 'once' : 'on'](file.name, (...args) => file.run(...args));
-			} else if (file.emitter === 'process') {
-				if (this.client.settings.debug) new XernerxLog(this.client).debug(`Listening to process event ${Style.log(file.name, { color: Style.TextColor.Yellow })}`);
-				process[file.once ? 'once' : 'on'](file.name, (...args) => file.run(...args));
-			} else if (file.emitter === 'rest') {
-				if (this.client.settings.debug) new XernerxLog(this.client).debug(`Listening to rest event ${Style.log(file.name, { color: Style.TextColor.Yellow })}`);
-				this.client.rest[file.once ? 'once' : 'on'](file.name, (...args) => file.run(...args));
-			} else {
-				// @ts-expect-error
-				this.client[file.emitter][file.once ? 'once' : 'on'](file.name, (...args) => file.run(...args));
-			}
-		} else {
-			this.client.on(file.name, (...args) => file.run(...args));
-		}
-	}
-}

package/dist/handlers/InhibitorHandler.d.ts

@@ -1,9 +0,0 @@
-/** @format */
-import XernerxClient from '../client/XernerxClient.js';
-import Handler from './Handler.js';
-import { InhibitorHandlerOptions } from '../types/interfaces.js';
-export default class InhibitorHandler extends Handler {
-	readonly readyTimestamp: number;
-	constructor(client: XernerxClient);
-	loadInhibitors(options: InhibitorHandlerOptions): Promise<void>;
-}

package/dist/handlers/InhibitorHandler.js

@@ -1,33 +0,0 @@
-/** @format */
-import { z } from 'zod';
-import * as path from 'path';
-import { Style } from 'dumfunctions';
-import Handler from './Handler.js';
-import XernerxLog from '../tools/XernerxLog.js';
-export default class InhibitorHandler extends Handler {
-	constructor(client) {
-		super(client);
-		this.readyTimestamp = Number(Date.now());
-	}
-	async loadInhibitors(options) {
-		const inhibitors = [];
-		options = z
-			.object({
-				directory: z.string(),
-			})
-			.parse(options);
-		this.client.modules.options.inhibitors = options;
-		const files = await this.readdir(options.directory, 'Inhibitors');
-		for (const file of files) {
-			const filepath = `${path.resolve(options.directory)}\\${file}`;
-			const inhibitor = await this.load(filepath, 'Inhibitor');
-			this.emit(inhibitor);
-			inhibitors.push(inhibitor.id);
-		}
-		new XernerxLog(this.client).info(
-			`Loaded ${Style.log(String(this.client.inhibitors.size), { color: Style.TextColor.Cyan })} Inhibitors: ${inhibitors
-				.map((inhibitor) => Style.log(inhibitor, { color: Style.TextColor.LightYellow }))
-				.join(', ')}`
-		);
-	}
-}

package/dist/handlers/IntegrationHandler.d.ts

@@ -1,15 +0,0 @@
-/** @format */
-import dbl from 'dbl-sdk';
-import XernerxClient from '../client/XernerxClient.js';
-import Handler from './Handler.js';
-export default class IntegrationHandler extends Handler {
-	readonly readyTimestamp: number;
-	readonly dbl: dbl;
-	constructor(client: XernerxClient);
-	loadIntegrations(options?: DBLOptions): Promise<void>;
-}
-interface DBLOptions {
-	post?: boolean;
-	votes?: boolean;
-}
-export {};

package/dist/handlers/IntegrationHandler.js

@@ -1,26 +0,0 @@
-/** @format */
-import dbl from 'dbl-sdk';
-import XernerxLog from '../tools/XernerxLog.js';
-import Handler from './Handler.js';
-export default class IntegrationHandler extends Handler {
-	constructor(client) {
-		super(client);
-		this.dbl = new dbl(client, client.config);
-		this.readyTimestamp = Number(Date.now());
-	}
-	async loadIntegrations(options = { votes: true }) {
-		this.client.once('ready', async (client) => {
-			this.client.dbl.validate = (user) => this.dbl.validate(user);
-			if (options.post) {
-				this.dbl.post();
-			}
-			if (options.votes) {
-				this.dbl.votes();
-				this.client.on('dbl-sync', (client, responses) => {
-					this.client.stats.voteCount = responses.voteCount;
-				});
-			}
-		});
-		new XernerxLog(this.client).info(`Successfully syncing with top.gg.`);
-	}
-}

package/dist/models/Arguments.d.ts

@@ -1,12 +0,0 @@
-/** @format */
-import XernerxSlashCommand from '../build/XernerxSlashCommand.js';
-import XernerxContextCommand from '../build/XernerxContextCommand.js';
-import MessageCommandBuilder from '../build/XernerxMessageCommand.js';
-import { XernerxMessage, XernerxMessageContextInteraction, XernerxSlashInteraction, XernerxUserContextInteraction } from '../types/extenders.js';
-import { MessageCommandArguments } from '../types/interfaces.js';
-import { XernerxInteraction } from '../types/types.js';
-export declare function messageArguments(message: XernerxMessage, command: MessageCommandBuilder, prefix: string): Promise<MessageCommandArguments>;
-export declare function interactionArguments(
-	interaction: XernerxInteraction<XernerxSlashInteraction | XernerxUserContextInteraction | XernerxMessageContextInteraction> | any,
-	command: XernerxContextCommand | XernerxSlashCommand
-): Promise<any>;