xernerx 4.4.3 → 4.4.4

package/dist/functions/delay.js

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

package/dist/functions/deploy.d.ts

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

package/dist/functions/deploy.js

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

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

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

package/dist/functions/isVoter.d.ts

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

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

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

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

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

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

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

package/dist/functions/sendWebhook.js

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

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

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

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

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

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

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

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

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

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

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

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

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

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

package/dist/handlers/InhibitorHandler.js

@@ -0,0 +1,24 @@
+import { z } from 'zod';
+import * as path from 'path';
+import Handler from './Handler.js';
+import XernerxLog from '../tools/XernerxLog.js';
+export default class InhibitorHandler extends Handler {
+    constructor(client) {
+        super(client);
+    }
+    async loadInhibitors(options) {
+        options = z
+            .object({
+                directory: z.string(),
+            })
+            .parse(options);
+        this.client.modules.options.inhibitors = 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, 'Inhibitor');
+            this.emit(data);
+        }
+        new XernerxLog(this.client).info(`Loaded ${this.client.inhibitors.size} Inhibitors.`);
+    }
+}

package/dist/handlers/WebhookHandler.d.ts

@@ -0,0 +1,7 @@
+import XernerxClient from '../client/XernerxClient.js';
+import Handler from './Handler.js';
+export default class WebhookHandler extends Handler {
+    constructor(client: XernerxClient);
+    loadWebhooks(options: { token: string }): Promise<void>;
+    private post;
+}