xernerx 4.5.6 → 4.5.7

package/dist/handlers/CommandHandler.js

@@ -1,3 +1,5 @@
+/** @format */
+
 import { z } from 'zod';
 import * as path from 'path';
 import { GatewayIntentBits } from 'discord.js';
@@ -11,244 +13,244 @@ 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);
-    }
-    loadMessageCommands(options) {
-        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()).default([]),
-                        client: z.array(z.string()).default([]),
-                        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 = this.readdir(options.directory);
-        for (const file of files) {
-            const filePath = `${path.resolve(options.directory)}\\${file}`;
-            this.load(filePath, 'MessageCommand');
-        }
-        new XernerxLog(this.client).info(`Loaded ${Style.log(String(files.length), { color: Style.TextColor.Cyan })} Message Commands.`);
-        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'),
-        });
-    }
-    // public reloadMessageCommands() {
-    //     return reload(this.client, 'message');
-    // }
-    loadSlashCommands(options) {
-        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()).default([]),
-                        client: z.array(z.string()).default([]),
-                        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 = this.readdir(options.directory);
-        for (const file of files) {
-            const filePath = `${path.resolve(options.directory)}\\${file}`;
-            this.load(filePath, 'SlashCommand');
-        }
-        new XernerxLog(this.client).info(`Loaded ${Style.log(String(files.length), { color: Style.TextColor.Cyan })} Slash Commands.`);
-        this.emit({
-            name: 'interactionCreate',
-            fileType: 'SlashCommand',
-            run: (interaction) => this.slashCommandRun(interaction),
-        });
-    }
-    loadContextCommands(options) {
-        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()).default([]),
-                        client: z.array(z.string()).default([]),
-                        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 = this.readdir(options.directory);
-        for (const file of files) {
-            const filePath = `${path.resolve(options.directory)}\\${file}`;
-            this.load(filePath, 'ContextCommand');
-        }
-        new XernerxLog(this.client).info(`Loaded ${Style.log(String(files.length), { color: Style.TextColor.Cyan })} Context Commands.`);
-        this.emit({
-            name: 'interactionCreate',
-            fileType: 'ContextCommand',
-            run: (interaction) => this.contextCommandRun(interaction),
-        });
-    }
-    async messageCommandRun(message, message2) {
-        const filetype = 'MessageCommand';
-        if (message.author.bot) return;
-        message.util = new MessageUtil(this.client, message);
-        message.user = await xernerxUser(message, this.client);
-        if (typeof message2 === 'object') message = message2;
-        if (message2 === 'delete') {
-            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;
-                    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 (!cmd) return this.client.emit('commandNotFound', message, filetype);
-            if (await inhibitorValidation(message, cmd)) return;
-            message.util.parsed = {
-                alias: commandAlias,
-                prefix: commandPrefix,
-            };
-            this.client.emit('commandStart', message, cmd, filetype);
-            return await this.exec(cmd, message, await messageArguments(message, cmd, commandPrefix), filetype);
-        }
-    }
-    async slashCommandRun(interaction) {
-        const filetype = 'SlashCommand';
-        interaction.util = new InteractionUtil(this.client, interaction);
-        interaction.user = await xernerxUser(interaction, this.client);
-        let cmd = null;
-        if (this.client.commands.slash.has(interaction.commandName)) cmd = this.client.commands.slash.get(interaction.commandName);
-        if (await inhibitorValidation(interaction, cmd)) return;
-        if (!cmd) return this.client.emit('commandNotFound', interaction);
-        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 () => {
-                this.client.emit('commandStart', interaction, filetype);
-                return await this.exec(cmd, interaction, await interactionArguments(interaction, cmd), filetype);
-            })
-            .catch((error) => this.client.emit('commandError', interaction, error, cmd, filetype));
-    }
-    async contextCommandRun(interaction) {
-        const filetype = 'ContextCommand';
-        interaction.util = new InteractionUtil(this.client, interaction);
-        interaction.user = await xernerxUser(interaction, this.client);
-        let cmd;
-        if (this.client.commands.context.has(interaction.commandName)) cmd = this.client.commands.context.get(interaction.commandName);
-        if (await inhibitorValidation(interaction, cmd)) return;
-        if (!cmd) return this.client.emit('commandNotFound', interaction, filetype);
-        this.client.emit('commandStart', interaction, filetype);
-        return await this.exec(cmd, interaction, await interactionArguments(interaction, cmd), filetype);
-    }
-    async exec(cmd, event, args, type) {
-        try {
-            if (await commandValidation(event, cmd)) return;
-            if (cmd.conditions && (await cmd.conditions(event, args))) return;
-            await cmd.exec(event, args);
-            return await this.client.emit('commandFinish', event, type);
-        } 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, type);
-        }
-    }
+	constructor(client) {
+		super(client);
+	}
+	loadMessageCommands(options) {
+		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()).default([]),
+						client: z.array(z.string()).default([]),
+						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 = this.readdir(options.directory);
+		for (const file of files) {
+			const filePath = `${path.resolve(options.directory)}\\${file}`;
+			this.load(filePath, 'MessageCommand');
+		}
+		new XernerxLog(this.client).info(`Loaded ${Style.log(String(files.length), { color: Style.TextColor.Cyan })} Message Commands.`);
+		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'),
+		});
+	}
+	// public reloadMessageCommands() {
+	//     return reload(this.client, 'message');
+	// }
+	loadSlashCommands(options) {
+		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()).default([]),
+						client: z.array(z.string()).default([]),
+						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 = this.readdir(options.directory);
+		for (const file of files) {
+			const filePath = `${path.resolve(options.directory)}\\${file}`;
+			this.load(filePath, 'SlashCommand');
+		}
+		new XernerxLog(this.client).info(`Loaded ${Style.log(String(files.length), { color: Style.TextColor.Cyan })} Slash Commands.`);
+		this.emit({
+			name: 'interactionCreate',
+			fileType: 'SlashCommand',
+			run: (interaction) => this.slashCommandRun(interaction),
+		});
+	}
+	loadContextCommands(options) {
+		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()).default([]),
+						client: z.array(z.string()).default([]),
+						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 = this.readdir(options.directory);
+		for (const file of files) {
+			const filePath = `${path.resolve(options.directory)}\\${file}`;
+			this.load(filePath, 'ContextCommand');
+		}
+		new XernerxLog(this.client).info(`Loaded ${Style.log(String(files.length), { color: Style.TextColor.Cyan })} Context Commands.`);
+		this.emit({
+			name: 'interactionCreate',
+			fileType: 'ContextCommand',
+			run: (interaction) => this.contextCommandRun(interaction),
+		});
+	}
+	async messageCommandRun(message, message2) {
+		const filetype = 'MessageCommand';
+		if (message.author.bot) return;
+		message.util = new MessageUtil(this.client, message);
+		message.user = await xernerxUser(message, this.client);
+		if (typeof message2 === 'object') message = message2;
+		if (message2 === 'delete') {
+			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;
+					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 (!cmd) return this.client.emit('commandNotFound', message, filetype);
+			if (await inhibitorValidation(message, cmd)) return;
+			message.util.parsed = {
+				alias: commandAlias,
+				prefix: commandPrefix,
+			};
+			this.client.emit('commandStart', message, cmd, filetype);
+			return await this.exec(cmd, message, await messageArguments(message, cmd, commandPrefix), filetype);
+		}
+	}
+	async slashCommandRun(interaction) {
+		const filetype = 'SlashCommand';
+		interaction.util = new InteractionUtil(this.client, interaction);
+		interaction.user = await xernerxUser(interaction, this.client);
+		let cmd = null;
+		if (this.client.commands.slash.has(interaction.commandName)) cmd = this.client.commands.slash.get(interaction.commandName);
+		if (await inhibitorValidation(interaction, cmd)) return;
+		if (!cmd) return this.client.emit('commandNotFound', interaction);
+		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 () => {
+				this.client.emit('commandStart', interaction, filetype);
+				return await this.exec(cmd, interaction, await interactionArguments(interaction, cmd), filetype);
+			})
+			.catch((error) => this.client.emit('commandError', interaction, error, cmd, filetype));
+	}
+	async contextCommandRun(interaction) {
+		const filetype = 'ContextCommand';
+		interaction.util = new InteractionUtil(this.client, interaction);
+		interaction.user = await xernerxUser(interaction, this.client);
+		let cmd;
+		if (this.client.commands.context.has(interaction.commandName)) cmd = this.client.commands.context.get(interaction.commandName);
+		if (await inhibitorValidation(interaction, cmd)) return;
+		if (!cmd) return this.client.emit('commandNotFound', interaction, filetype);
+		this.client.emit('commandStart', interaction, filetype);
+		return await this.exec(cmd, interaction, await interactionArguments(interaction, cmd), filetype);
+	}
+	async exec(cmd, event, args, type) {
+		try {
+			if (await commandValidation(event, cmd)) return;
+			if (cmd.conditions && (await cmd.conditions(event, args))) return;
+			await cmd.exec(event, args);
+			return await this.client.emit('commandFinish', event, type);
+		} 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, type);
+		}
+	}
 }
 //# sourceMappingURL=CommandHandler.js.map

package/dist/handlers/EventHandler.d.ts

@@ -1,8 +1,10 @@
+/** @format */
+
 import XernerxClient from '../client/XernerxClient.js';
 import { EventHandlerOptions } from '../types/interfaces.js';
 import Handler from './Handler.js';
 export default class EventHandler extends Handler {
-    constructor(client: XernerxClient);
-    loadEvents(options: EventHandlerOptions): Promise<void>;
+	constructor(client: XernerxClient);
+	loadEvents(options: EventHandlerOptions): Promise<void>;
 }
 //# sourceMappingURL=EventHandler.d.ts.map

package/dist/handlers/EventHandler.js

@@ -1,26 +1,28 @@
+/** @format */
+
 import { z } from 'zod';
 import * as path from 'path';
 import Handler from './Handler.js';
 import XernerxLog from '../tools/XernerxLog.js';
 import { Style } from 'dumfunctions';
 export default class EventHandler extends Handler {
-    constructor(client) {
-        super(client);
-    }
-    async loadEvents(options) {
-        options = z
-            .object({
-                directory: z.string(),
-            })
-            .parse(options);
-        this.client.modules.options.events = options;
-        const files = this.readdir(options.directory);
-        for (const file of files) {
-            const filePath = `${path.resolve(options.directory)}\\${file}`;
-            const data = await this.load(filePath, 'Event');
-            this.emit(data);
-        }
-        new XernerxLog(this.client).info(`Loaded ${Style.log(String(this.client.events.size), { color: Style.TextColor.Cyan })} Events.`);
-    }
+	constructor(client) {
+		super(client);
+	}
+	async loadEvents(options) {
+		options = z
+			.object({
+				directory: z.string(),
+			})
+			.parse(options);
+		this.client.modules.options.events = options;
+		const files = this.readdir(options.directory);
+		for (const file of files) {
+			const filePath = `${path.resolve(options.directory)}\\${file}`;
+			const data = await this.load(filePath, 'Event');
+			this.emit(data);
+		}
+		new XernerxLog(this.client).info(`Loaded ${Style.log(String(this.client.events.size), { color: Style.TextColor.Cyan })} Events.`);
+	}
 }
 //# sourceMappingURL=EventHandler.js.map

package/dist/handlers/ExtensionHandler.d.ts

@@ -1,8 +1,10 @@
+/** @format */
+
 import XernerxExtensionBuilder from 'xernerx-extension-builder';
 import XernerxClient from '../client/XernerxClient.js';
 import Handler from './Handler.js';
 export default class ExtensionHandler extends Handler {
-    constructor(client: XernerxClient);
-    loadExtensions(...extensions: Array<XernerxExtensionBuilder>): void;
+	constructor(client: XernerxClient);
+	loadExtensions(...extensions: Array<XernerxExtensionBuilder>): void;
 }
 //# sourceMappingURL=ExtensionHandler.d.ts.map

package/dist/handlers/ExtensionHandler.js

@@ -1,23 +1,25 @@
+/** @format */
+
 import Handler from './Handler.js';
 import XernerxLog from '../tools/XernerxLog.js';
 import { Style } from 'dumfunctions';
 export default class ExtensionHandler extends Handler {
-    constructor(client) {
-        super(client);
-    }
-    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.Blue })}`, error);
-            }
-        });
-        new XernerxLog(this.client).info(`Loaded ${Style.log(String(extensions.length), { color: Style.TextColor.Cyan })} Extensions: ${active.filter((e) => e).join(', ')}`);
-    }
+	constructor(client) {
+		super(client);
+	}
+	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.Blue })}`, error);
+			}
+		});
+		new XernerxLog(this.client).info(`Loaded ${Style.log(String(extensions.length), { color: Style.TextColor.Cyan })} Extensions: ${active.filter((e) => e).join(', ')}`);
+	}
 }
 //# sourceMappingURL=ExtensionHandler.js.map

package/dist/handlers/Handler.d.ts

@@ -1,15 +1,17 @@
+/** @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';
 export default class Handler {
-    readonly client: XernerxClient<unknown>;
-    readonly files: Array<MessageCommandBuilder | XernerxSlashCommand | XernerxContextCommand>;
-    readonly readyTimestamp: number;
-    constructor(client: XernerxClient);
-    readdir(dir: string): string[];
-    load(filePath: string, type: FileType): Promise<any>;
-    emit<T extends Record<string, string | boolean | Function | void>>(event: T): Promise<void>;
+	readonly client: XernerxClient<unknown>;
+	readonly files: Array<MessageCommandBuilder | XernerxSlashCommand | XernerxContextCommand>;
+	readonly readyTimestamp: number;
+	constructor(client: XernerxClient);
+	readdir(dir: string): string[];
+	load(filePath: string, type: FileType): Promise<any>;
+	emit<T extends Record<string, string | boolean | Function | void>>(event: T): Promise<void>;
 }
 //# sourceMappingURL=Handler.d.ts.map