xernerx 4.4.2 → 4.4.3

package/dist/client/XernerxShardClient.js

@@ -1,32 +0,0 @@
-import { ShardingManager } from 'discord.js';
-import XernerxLog from '../tools/XernerxLog.js';
-export default class XernerxShardClient extends ShardingManager {
-    constructor(file, discordOptions, xernerxOptions) {
-        super(file, discordOptions);
-        this.stats = { guildCount: 0, userCount: 0, shardCount: 0 };
-        this.user = null;
-        this.on('shardCreate', async (shard) => {
-            shard.on('ready', async () => {
-                const guilds = await shard.fetchClientValue('guilds.cache');
-                const guildCount = guilds.length;
-                const userCount = guilds.map((guild) => guild.memberCount).length ? guilds.map((guild) => guild.memberCount).reduce((a, b) => (a += b)) : 0;
-                this.stats.guildCount += Number(guildCount);
-                this.stats.userCount += Number(userCount);
-                this.stats.shardCount++;
-                this.user = await shard.fetchClientValue('user');
-            });
-            new XernerxLog({ settings: xernerxOptions }).info(`Launching shard ${shard.id} for ${this.user?.tag}!`);
-        });
-        this.spawn().then(async (shards) => {
-            const collector = setInterval(() => {
-                const index = shards.size - 1;
-                if (shards.get(index)?.ready) {
-                    new XernerxLog({ settings: xernerxOptions }).info(
-                        `Launched all ${this.stats.shardCount} shards for ${this.user?.tag}, watching ${this.stats.guildCount} guilds, and ${this.stats.userCount} users!`
-                    );
-                    clearInterval(collector);
-                }
-            }, 1000);
-        });
-    }
-}

package/dist/functions/delay.d.ts

@@ -1 +0,0 @@
-export default function delay(time: number): Promise<unknown>;

package/dist/functions/delay.js

@@ -1,3 +0,0 @@
-export default async function delay(time) {
-    return await new Promise((resolve) => setTimeout(resolve, time));
-}

package/dist/functions/deploy.d.ts

@@ -1,2 +0,0 @@
-import XernerxClient from '../client/XernerxClient.js';
-export default function deploy(client: XernerxClient, type: 'slash' | 'context'): void;

package/dist/functions/deploy.js

@@ -1,33 +0,0 @@
-import { GatewayVersion, REST, Routes } from 'discord.js';
-import XernerxLog from '../tools/XernerxLog.js';
-import XernerxError from '../tools/XernerxError.js';
-const commands = { slash: [], context: [] };
-export default function deploy(client, type) {
-    client.prependOnceListener('ready', (client) => {
-        commands[type] = client.commands[type].map((command) => command.data.toJSON());
-        if (!(!!client.modules.options.slash && !!client.modules.options.context && commands.slash.length > 0 && commands.context.length > 0)) return;
-        try {
-            if (client.settings.global) {
-                put(client, client.settings.global, [...commands.slash, ...commands.context]);
-                put(client, !client.settings.global, []);
-            } else {
-                put(client, !client.settings.global, [...commands.slash, ...commands.context]);
-                put(client, client.settings.global, []);
-            }
-        } catch (error) {
-            new XernerxLog(client).error(`An error occurred while deploying the interaction commands!`, error);
-        } finally {
-            new XernerxLog(client).info(
-                `Deployed ${[client.commands.message.size, client.commands.slash.size, client.commands.context.size].reduce((a, b) => (a += b))} Commands ${
-                    client.settings.global ? 'globally' : 'locally'
-                }.`
-            );
-        }
-    });
-}
-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) rest.put(Routes.applicationGuildCommands(client.user?.id, client.settings.local), { body });
-    else rest.put(Routes.applicationCommands(client.user?.id), { body });
-}

package/dist/functions/isOwner.d.ts

@@ -1,3 +0,0 @@
-import XernerxClient from '../client/XernerxClient.js';
-import { XernerxUser } from '../types/extenders.js';
-export default function isOwner(user: Pick<XernerxUser, 'id'>, client: XernerxClient): boolean;

package/dist/functions/isOwner.js

@@ -1,3 +0,0 @@
-export default function isOwner(user, client) {
-    return client.settings.ownerId.includes(user.id);
-}

package/dist/functions/isVoter.d.ts

@@ -1,3 +0,0 @@
-import XernerxClient from '../client/XernerxClient.js';
-import { XernerxUser } from '../types/extenders.js';
-export default function isVoter(user: XernerxUser, client: XernerxClient, token: string, host: 'top.gg'): Promise<void>;

package/dist/functions/isVoter.js

@@ -1,5 +0,0 @@
-import { hasVoted } from 'dbl-sdk';
-export default async function isVoter(user, client, token, host) {
-    const x = await hasVoted(user.id, client.user?.id, token, host);
-    console.log(x);
-}

package/dist/functions/load.d.ts

@@ -1,3 +0,0 @@
-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,32 +0,0 @@
-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;
-        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,2 +0,0 @@
-import XernerxClient from '../client/XernerxClient.js';
-export default function reload(client: XernerxClient, type: 'message' | 'slash' | 'context' | 'event' | 'inhibitor'): Promise<any>[];

package/dist/functions/reload.js

@@ -1,39 +0,0 @@
-var FileTypes;
-(function (FileTypes) {
-    FileTypes['message'] = 'MessageCommand';
-    FileTypes['slash'] = 'SlashCommand';
-    FileTypes['context'] = 'ContextCommand';
-    FileTypes['event'] = 'Event';
-    FileTypes['inhibitor'] = 'Inhibitor';
-})(FileTypes || (FileTypes = {}));
-export default function reload(client, type) {
-    const files = [];
-    if (type === 'message' || type === 'slash' || type === 'context') {
-        for (const [name] of client.commands[type]) {
-            files.push(client.commands[type].get(name).filePath);
-        }
-        client.commands[type].sweep(() => true);
-    }
-    if (type === 'event') {
-        for (const [name] of client.events) {
-            files.push(client.events.get(name).filePath);
-        }
-        client.events.sweep(() => true);
-    }
-    if (type === 'inhibitor') {
-        for (const [name] of client.inhibitors) {
-            files.push(client.inhibitors.get(name).filePath);
-        }
-        client.inhibitors.sweep(() => true);
-    }
-    return files.map(async (file) => {
-        let filedata = new (await import(`file://${file}`)).default();
-        filedata.fileType = FileTypes[type];
-        filedata.filePath = file;
-        filedata.client = client;
-        if (type === 'message' || type === 'slash' || type === 'context') client.commands[type].set(filedata.name, filedata);
-        if (type === 'event') client.events.set(filedata.name, filedata);
-        if (type === 'inhibitor') client.inhibitors.set(filedata.name, filedata);
-        return filedata;
-    });
-}

package/dist/functions/sendWebhook.d.ts

@@ -1,2 +0,0 @@
-import { MessagePayload } from 'discord.js';
-export default function sendWebhook(url: URL, body: MessagePayload): Promise<any>;

package/dist/functions/sendWebhook.js

@@ -1,12 +0,0 @@
-export default async function sendWebhook(url, body) {
-    const response = await fetch(url, {
-        method: 'POST',
-        headers: {
-            'Content-Type': 'application/json',
-        },
-        body: JSON.stringify(body),
-    });
-    if (response.status === 204) return true;
-    const data = await response.json();
-    return data;
-}

package/dist/functions/setPresence.d.ts

@@ -1,3 +0,0 @@
-import XernerxClient from '../main.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,19 +0,0 @@
-export default function setPresence(client, options) {
-    const presence = () =>
-        client.user?.setPresence({
-            activities: [
-                {
-                    name: options.text,
-                    type: options.type,
-                    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,3 +0,0 @@
-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,8 +0,0 @@
-import isOwner from './isOwner.js';
-export async function xernerxUser(event, client) {
-    const author = event.author || event.user;
-    const user = author;
-    'owner' in user ? null : (user.owner = isOwner(user, client));
-    'voted' in user ? null : (user.voted = client.util.hasVoted ? await client.util.hasVoted(user.id) : null);
-    return user;
-}

package/dist/handlers/CommandHandler.d.ts

@@ -1,13 +0,0 @@
-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 {
-    constructor(client: XernerxClient);
-    loadMessageCommands(options: MessageHandlerOptions): void;
-    loadSlashCommands(options: SlashHandlerOptions): void;
-    loadContextCommands(options: ContextHandlerOptions): void;
-    private messageCommandRun;
-    private slashCommandRun;
-    private contextCommandRun;
-    private exec;
-}

package/dist/handlers/CommandHandler.js

@@ -1,251 +0,0 @@
-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 deploy from '../functions/deploy.js';
-import { inhibitorValidation } from '../validators/inhibitorValidations.js';
-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 ${files.length} 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 ${files.length} Slash Commands.`);
-        deploy(this.client, 'slash');
-        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 ${files.length} Context Commands.`);
-        deploy(this.client, 'context');
-        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;
-                }
-            }
-            if (this.client.commands.message.has(commandName)) cmd = this.client.commands.message.get(commandName);
-            if (await inhibitorValidation(message, cmd)) return;
-            if (!cmd) return this.client.emit('commandNotFound', message, filetype);
-            message.util.parsed = {
-                alias: commandAlias,
-                prefix: commandPrefix,
-            };
-            this.client.emit('commandStart', message, filetype);
-            this.exec(cmd, message, await messageArguments(message, cmd), 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);
-                await this.exec(cmd, interaction, await interactionArguments(interaction, cmd), filetype);
-            })
-            .catch((error) => this.client.emit('commandError', interaction, error, 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);
-        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;
-            cmd.exec(event, args);
-            this.client.emit('commandFinish', event, type);
-        } catch (error) {
-            new XernerxLog(this.client).error(`An error occurred executing ${cmd.name}`, error);
-            this.client.emit('commandError', event, error, type);
-        }
-    }
-}

package/dist/handlers/EventHandler.d.ts

@@ -1,7 +0,0 @@
-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>;
-}

package/dist/handlers/EventHandler.js

@@ -1,24 +0,0 @@
-import { z } from 'zod';
-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);
-    }
-    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 ${this.client.events.size} Events.`);
-    }
-}

package/dist/handlers/ExtensionHandler.d.ts

@@ -1,7 +0,0 @@
-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;
-}

package/dist/handlers/ExtensionHandler.js

@@ -1,21 +0,0 @@
-import Handler from './Handler.js';
-import XernerxLog from '../tools/XernerxLog.js';
-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) {
-                new XernerxLog(this.client).error(`An error occurred while loading ${extension.name}`, error);
-            }
-        });
-        new XernerxLog(this.client).info(`Loaded ${extensions.length} Extensions: ${active.filter((e) => e).join(', ')}`);
-    }
-}

package/dist/handlers/Handler.d.ts

@@ -1,14 +0,0 @@
-import XernerxClient from '../client/XernerxClient.js';
-import MessageCommandBuilder from '../build/MessageCommandBuilder.js';
-import SlashCommandBuilder from '../build/SlashCommandBuilder.js';
-import ContextCommandBuilder from '../build/ContextCommandBuilder.js';
-import { FileType } from '../types/types.js';
-export default class Handler {
-    readonly client: XernerxClient;
-    readonly files: Array<MessageCommandBuilder | SlashCommandBuilder | ContextCommandBuilder>;
-    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>;
-}

package/dist/handlers/Handler.js

@@ -1,36 +0,0 @@
-import * as fs from 'fs';
-import * as path from 'path';
-import load from '../functions/load.js';
-export default class Handler {
-    client;
-    files;
-    readyTimestamp;
-    constructor(client) {
-        this.client = client;
-        this.files = [];
-        this.readyTimestamp = Number(Date.now());
-    }
-    readdir(dir) {
-        try {
-            return fs.readdirSync(path.resolve(dir)).filter((file) => file.endsWith('.js'));
-        } catch (error) {
-            console.error(error);
-        }
-        return [];
-    }
-    async load(filePath, type) {
-        const file = await load(this.client, filePath, type);
-        this.files.push(file);
-        return file;
-    }
-    async emit(event) {
-        if (!event?.fileType) return;
-        if (event.fileType === 'Event') {
-            if (event.emitter === 'client') event.once ? this.client.once(event.name, (...args) => event.run(...args)) : this.client.on(event.name, (...args) => event.run(...args));
-            else if (event.emitter === 'process') event.once ? process.once(event.name, (...args) => event.run(...args)) : process.on(event.name, (...args) => event.run(...args));
-        }
-        if (['MessageCommand', 'SlashCommand', 'ContextCommand'].includes(event.fileType)) {
-            event.once ? this.client.once(event.name, (...args) => event.run(...args)) : this.client.on(event.name, (...args) => event.run(...args));
-        }
-    }
-}

package/dist/handlers/InhibitorHandler.d.ts

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