xernerx 3.5.2 → 4.0.0

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/voted.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/functions/voted.js

@@ -0,0 +1 @@
+export {};

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,220 @@
+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 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) {
+        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 Slash Commands.`);
+        deploy(this.client, 'slash');
+        this.emit({
+            name: 'interactionCreate',
+            fileType: 'SlashCommand',
+            run: (interaction) => this.slashCommandRun(interaction),
+        });
+    }
+    loadContextCommands(options) {
+        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 Context Commands.`);
+        deploy(this.client, 'context');
+        this.emit({
+            name: 'interactionCreate',
+            fileType: 'ContextCommand',
+            run: (interaction) => this.contextCommandRun(interaction),
+        });
+    }
+    async messageCommandRun(message, message2) {
+        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, cmd;
+            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 (!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();
+                }
+            }
+            if (!commandName) commandName = '';
+            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');
+            this.exec(cmd, message, await messageArguments(message, cmd), 'MessageCommand');
+        }
+    }
+    async slashCommandRun(interaction) {
+        interaction.util = new InteractionUtil(this.client, interaction);
+        interaction.user = await xernerxUser(interaction, this.client);
+        let cmd;
+        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);
+        this.exec(cmd, interaction, await interactionArguments(interaction, cmd), 'SlashCommand');
+    }
+    async contextCommandRun(interaction) {
+        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);
+        this.exec(cmd, interaction, await interactionArguments(interaction, cmd), 'ContextCommand');
+    }
+    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('commandExecute', 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 Events.`);
+    }
+}

package/dist/handlers/ExtensionHandler.d.ts

@@ -0,0 +1,7 @@
+import XernerxExtensionBuilder from 'xernerx-extension-builder';
+import XernerxClient from '../main.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,19 @@
+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 {
+                // extension.main(client);
+                // extension.await(client);
+                return extension.name;
+            } catch (error) {
+                new XernerxLog(this.client).error(`An error occurred while loading ${extension.name}`);
+            }
+        });
+        new XernerxLog(this.client).info(`Loaded 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 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;
+}

package/dist/handlers/WebhookHandler.js

@@ -0,0 +1,50 @@
+import XernerxLog from '../tools/XernerxLog.js';
+import Handler from './Handler.js';
+export default class WebhookHandler extends Handler {
+    constructor(client) {
+        super(client);
+    }
+    async loadWebhooks(options) {
+        this.client.once('ready', async (client) => {
+            this.post(options.token);
+            setInterval(() => {
+                this.post(client.token);
+            }, 60000 * 30);
+            this.client.util.hasVoted = async (userId) => {
+                return !!(
+                    await (
+                        await fetch(`https://top.gg/api/bots/${this.client.user?.id}/check?userId=${userId}`, {
+                            headers: { Authorization: options.token, 'Content-Type': 'application/json' },
+                        })
+                    ).json()
+                ).voted;
+            };
+        });
+    }
+    async post(token) {
+        const guilds = await this.client.guilds.fetch();
+        this.client.stats.guildCount = guilds.size;
+        this.client.stats.userCount = (await Promise.all(guilds.map(async (guild) => (await this.client.guilds.fetch(guild.id)).memberCount))).reduce((a, b) => (a += b));
+        this.client.stats.shardId = this.client.options.shards?.at(0) || 0;
+        this.client.stats.shardCount = this.client.options.shardCount || this.client.options.shards?.length || 1;
+        try {
+            new XernerxLog(this.client).info(`Posted Stats to Top.gg!`);
+            this.client.emit('webhookCreate', this.client, this.client.stats);
+            return await fetch(`https://top.gg/api/bots/stats`, {
+                method: 'POST',
+                headers: {
+                    Authorization: token,
+                    'Content-Type': 'application/json',
+                },
+                body: JSON.stringify({
+                    server_count: this.client.stats.guildCount,
+                    shard_id: this.client.stats.shardId,
+                    shard_count: this.client.stats.shardCount,
+                }),
+            });
+        } catch (error) {
+            new XernerxLog(this.client).error(`An error occurred while posting stats to Top.gg`, error);
+            return this.client.emit('webhookError', this.client, this.client.stats);
+        }
+    }
+}

package/dist/main.d.ts

@@ -0,0 +1,11 @@
+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 EventBuilder from './build/EventBuilder.js';
+import InhibitorBuilder from './build/InhibitorBuilder.js';
+export default XernerxClient;
+export * from 'discord.js';
+export * from 'dumfunctions';
+import ExtensionBuilder from 'xernerx-extension-builder';
+export { XernerxClient, MessageCommandBuilder, SlashCommandBuilder, ContextCommandBuilder, EventBuilder, InhibitorBuilder, ExtensionBuilder };

package/dist/main.js

@@ -0,0 +1,11 @@
+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 EventBuilder from './build/EventBuilder.js';
+import InhibitorBuilder from './build/InhibitorBuilder.js';
+export default XernerxClient;
+export * from 'discord.js';
+export * from 'dumfunctions';
+import ExtensionBuilder from 'xernerx-extension-builder';
+export { XernerxClient, MessageCommandBuilder, SlashCommandBuilder, ContextCommandBuilder, EventBuilder, InhibitorBuilder, ExtensionBuilder };

package/dist/models/Arguments.d.ts

@@ -0,0 +1,15 @@
+import SlashCommandBuilder from '../build/SlashCommandBuilder.js';
+import ContextCommandBuilder from '../build/ContextCommandBuilder.js';
+import MessageCommandBuilder from '../build/MessageCommandBuilder.js';
+import { XernerxMessage } from '../types/extenders.js';
+import { MessageCommandArguments } from '../types/interfaces.js';
+import { XernerxInteraction } from '../types/types.js';
+export declare function messageArguments(message: XernerxMessage, command: MessageCommandBuilder): Promise<MessageCommandArguments>;
+export declare function interactionArguments(
+    interaction: XernerxInteraction | any,
+    command: ContextCommandBuilder | SlashCommandBuilder
+): Promise<{
+    args: any;
+    group: any;
+    subcommand: any;
+}>;