xernerx 4.14.0 → 4.15.0

package/dist/cjs/handlers/IntegrationHandler.js

@@ -0,0 +1,29 @@
+"use strict";
+/** @format */
+Object.defineProperty(exports, "__esModule", { value: true });
+const dbl_sdk_1 = __importDefault(require("dbl-sdk"));
+const XernerxLog_js_1 = __importDefault(require("../tools/XernerxLog.js"));
+const Handler_js_1 = __importDefault(require("./Handler.js"));
+class IntegrationHandler extends Handler_js_1.default {
+    constructor(client) {
+        super(client);
+        this.dbl = new dbl_sdk_1.default(client, client.config);
+        this.readyTimestamp = Number(Date.now());
+    }
+    async loadIntegrations(options = { votes: true }) {
+        this.client.once('ready', async (client) => {
+            this.client.dbl.validate = (user) => this.dbl.validate(user);
+            if (options.post) {
+                this.dbl.post();
+            }
+            if (options.votes) {
+                this.dbl.votes();
+                this.client.on('dbl-sync', (client, responses) => {
+                    this.client.stats.voteCount = responses.voteCount;
+                });
+            }
+        });
+        new XernerxLog_js_1.default(this.client).info(`Successfully syncing with top.gg.`);
+    }
+}
+exports.default = IntegrationHandler;

package/dist/cjs/main.js

@@ -0,0 +1,36 @@
+"use strict";
+/** @format */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.XernerxLog = exports.version = exports.Discord = exports.XernerxExtension = exports.XernerxInhibitor = exports.XernerxEvent = exports.XernerxContextCommand = exports.XernerxSlashCommand = exports.XernerxMessageCommand = exports.XernerxShardClient = exports.XernerxClient = exports.XernerxIntents = void 0;
+const fs = __importStar(require("fs"));
+const version = JSON.parse(fs.readFileSync('node_modules/xernerx/package.json', 'utf-8')).version;
+exports.version = version;
+new XernerxLog_js_1.default(true).update(version, 'https://raw.githubusercontent.com/xernerx/xernerx/master/package.json');
+const XernerxClient_js_1 = __importDefault(require("./client/XernerxClient.js"));
+exports.XernerxClient = XernerxClient_js_1.default;
+const XernerxShardClient_js_1 = __importDefault(require("./client/XernerxShardClient.js"));
+exports.XernerxShardClient = XernerxShardClient_js_1.default;
+const XernerxMessageCommand_js_1 = __importDefault(require("./build/XernerxMessageCommand.js"));
+exports.XernerxMessageCommand = XernerxMessageCommand_js_1.default;
+const XernerxSlashCommand_js_1 = __importDefault(require("./build/XernerxSlashCommand.js"));
+exports.XernerxSlashCommand = XernerxSlashCommand_js_1.default;
+const XernerxContextCommand_js_1 = __importDefault(require("./build/XernerxContextCommand.js"));
+exports.XernerxContextCommand = XernerxContextCommand_js_1.default;
+const XernerxEvent_js_1 = __importDefault(require("./build/XernerxEvent.js"));
+exports.XernerxEvent = XernerxEvent_js_1.default;
+const XernerxInhibitor_js_1 = __importDefault(require("./build/XernerxInhibitor.js"));
+exports.XernerxInhibitor = XernerxInhibitor_js_1.default;
+const XernerxLog_js_1 = __importDefault(require("./tools/XernerxLog.js"));
+exports.XernerxLog = XernerxLog_js_1.default;
+var XernerxIntents_js_1 = require("./tools/XernerxIntents.js");
+Object.defineProperty(exports, "XernerxIntents", { enumerable: true, get: function () { return XernerxIntents_js_1.XernerxIntents; } });
+__exportStar(require("discord.js"), exports);
+__exportStar(require("dumfunctions"), exports);
+const discord_js_1 = __importDefault(require("discord.js"));
+exports.Discord = discord_js_1.default;
+const xernerx_extension_builder_1 = __importDefault(require("xernerx-extension-builder"));
+exports.XernerxExtension = xernerx_extension_builder_1.default;
+__exportStar(require("./types/types.js"), exports);
+__exportStar(require("./types/extenders.js"), exports);
+__exportStar(require("./types/interfaces.js"), exports);
+exports.default = XernerxClient_js_1.default;

package/dist/cjs/models/Arguments.js

@@ -0,0 +1,159 @@
+"use strict";
+/** @format */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.interactionArguments = exports.messageArguments = void 0;
+async function messageArguments(message, command, prefix) {
+    const separator = command.separator || ' ', content = message.content
+        .replace(new RegExp(`${prefix} +?`), '')
+        .split(separator)
+        .slice(1);
+    let args = {}, flags = {};
+    if (command.flags)
+        command.flags.map((flag) => {
+            if (!flags)
+                flags = {};
+            if (content.includes(flag.match))
+                flags[flag.name] = true;
+            else
+                flags[flag.name] = false;
+            const index = content.indexOf(flag.match);
+            if (index > 0)
+                content.splice(index, 1);
+        });
+    if (command.args)
+        for (const argument of command.args) {
+            const element = content.at(0) || null;
+            if (!element) {
+                if (typeof argument.default === 'function')
+                    args[argument.name] = argument.default(message);
+                args[argument.name] = argument.default || null;
+                continue;
+            }
+            if (argument.type === 'option')
+                argument.match?.includes(element) ? (args[argument.name] = element) : (args[argument.name] = null);
+            if (argument.type === 'number')
+                args[argument.name] = parseInt(element);
+            if (argument.type === 'integer')
+                args[argument.name] = parseInt(element);
+            if (argument.type === 'boolean')
+                args[argument.name] = element === 'true' ? true : false;
+            if (argument.type === 'confirm')
+                args[argument.name] = element === 'yes' ? 'yes' : 'no';
+            if (argument.type === 'string')
+                args[argument.name] = element;
+            if (argument.type === 'channel') {
+                try {
+                    const channel = await message.client.channels.fetch(element);
+                    args[argument.name] = channel;
+                }
+                catch (e) {
+                    args[argument.name] = null;
+                }
+            }
+            if (argument.type === 'guild') {
+                try {
+                    const guild = await message.client.guilds.fetch(element);
+                    args[argument.name] = guild;
+                }
+                catch (e) {
+                    args[argument.name] = null;
+                }
+            }
+            if (argument.type === 'mentionable') {
+                (await Promise.all([message.guild?.roles, message.client.users, message.client.guilds, message.client.channels, message.guild?.members, message.channel.messages].map((req) => req
+                    ? req
+                        .fetch(element)
+                        .then((r) => r)
+                        .catch(() => null)
+                    : null))).map((mentionable) => {
+                    if (!args)
+                        args = {};
+                    if (mentionable)
+                        return (args[argument.name] = mentionable);
+                    else
+                        return (args[argument.name] = null);
+                });
+            }
+            if (argument.type === 'role') {
+                try {
+                    const role = await message.guild?.roles.fetch(element);
+                    args[argument.name] = role;
+                }
+                catch (e) {
+                    args[argument.name] = null;
+                }
+            }
+            if (argument.type === 'user') {
+                try {
+                    const user = await message.client.users.fetch(element);
+                    args[argument.name] = user;
+                }
+                catch (e) {
+                    args[argument.name] = null;
+                }
+            }
+            if (argument.type === 'member') {
+                try {
+                    const member = await message.guild?.members.fetch(element);
+                    args[argument.name] = member;
+                }
+                catch (e) {
+                    args[argument.name] = null;
+                }
+            }
+            if (argument.type === 'message') {
+                try {
+                    const msg = await message.channel?.messages.fetch(element);
+                    args[argument.name] = msg;
+                }
+                catch (e) {
+                    args[argument.name] = null;
+                }
+            }
+            if (argument.type === 'list') {
+                let separator = String(argument.separator) || ',';
+                if (separator.startsWith('/') && separator.endsWith('/'))
+                    separator = separator.replace(/^\/|\/$/gim, '');
+                const items = content.join(' ').split(new RegExp(' *' + separator + ' *', 'gi'));
+                if (!argument.content)
+                    args[argument.name] = items;
+                else {
+                    const contents = argument.content.map((content) => content.toLowerCase()), itemList = [];
+                    items.map((item) => (contents.includes(item.toLowerCase()) ? itemList.push(argument.content?.at(contents.indexOf(item.toLowerCase()))) : null));
+                    args[argument.name] = itemList;
+                    break;
+                }
+            }
+            if (argument.type === 'rest') {
+                args[argument.name] = content.join(separator);
+                break;
+            }
+            content.splice(0, 1);
+        }
+    if (!command.flags)
+        flags = null;
+    if (!command.args)
+        args = null;
+    return { args, flags };
+}
+exports.messageArguments = messageArguments;
+async function interactionArguments(interaction, command) {
+    if (command.filetype === 'SlashCommand') {
+        const options = {};
+        let args = interaction?.options?._hoistedOptions, group = interaction?.options?._group, subcommand = interaction?.options?._subcommand;
+        if (interaction.options._hoistedOptions) {
+            for (const option of interaction.options._hoistedOptions) {
+                options[option.name] = option.member || option.channel || option.user || option.role || option.value;
+            }
+            args = options;
+        }
+        return { args, group, subcommand };
+    }
+    if (command.filetype === 'ContextCommand') {
+        if (command.type === 'user')
+            return await interaction.client.users.fetch(interaction.targetId);
+        if (command.type === 'message')
+            return await interaction.channel.messages.fetch(interaction.targetId);
+    }
+}
+exports.interactionArguments = interactionArguments;

package/dist/cjs/models/Cooldowns.js

@@ -0,0 +1,36 @@
+"use strict";
+/** @format */
+Object.defineProperty(exports, "__esModule", { value: true });
+const discord_js_1 = require("discord.js");
+class Cooldowns {
+    constructor(client, collections = []) {
+        this._client = client;
+        this.collections = {
+            commands: new discord_js_1.Collection(),
+        };
+        for (const collection of collections) {
+            this.collections[collection] = new discord_js_1.Collection();
+        }
+    }
+    add(collection, id, value) {
+        if (!this.collections[collection])
+            return `${collection} collection does not exist!`;
+        return this.collections[collection].set(id, value);
+    }
+    delete(collection, id) {
+        if (!this.collections[collection])
+            return `${collection} collection does not exist!`;
+        return this.collections[collection].delete(id);
+    }
+    has(id) {
+        const collected = {};
+        for (const [name, collection] of Object.entries(this.collections)) {
+            if (collection.has(id))
+                collected[name] = collection;
+            else
+                continue;
+        }
+        return collected;
+    }
+}
+exports.default = Cooldowns;

package/dist/cjs/tools/XernerxError.js

@@ -0,0 +1,14 @@
+"use strict";
+/** @format */
+Object.defineProperty(exports, "__esModule", { value: true });
+class XernerxError {
+    name;
+    message;
+    stack;
+    constructor(message, error) {
+        this.name = 'XernerxError';
+        this.message = message || null;
+        this.stack = error || new Error().stack;
+    }
+}
+exports.default = XernerxError;

package/dist/cjs/tools/XernerxIntents.js

@@ -0,0 +1,27 @@
+"use strict";
+/** @format */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.XernerxIntents = void 0;
+exports.XernerxIntents = {
+    Default: [
+        'Guilds',
+        'GuildModeration',
+        'GuildBans',
+        'GuildEmojisAndStickers',
+        'GuildIntegrations',
+        'GuildWebhooks',
+        'GuildInvites',
+        'GuildVoiceStates',
+        'GuildMessages',
+        'GuildMessageReactions',
+        'GuildMessageTyping',
+        'DirectMessages',
+        'DirectMessageReactions',
+        'DirectMessageTyping',
+        'GuildScheduledEvents',
+        'AutoModerationConfiguration',
+        'AutoModerationExecution',
+    ],
+    All: [''],
+};
+exports.XernerxIntents.All = [...exports.XernerxIntents.Default, 'GuildMembers', 'GuildPresences', 'MessageContent'];

package/dist/cjs/tools/XernerxLog.js

@@ -0,0 +1,98 @@
+"use strict";
+/** @format */
+Object.defineProperty(exports, "__esModule", { value: true });
+const dumfunctions_1 = require("dumfunctions");
+class XernerxLog {
+    constructor(client) {
+        this.client = client;
+        if (client == true || (typeof client.settings.log == 'boolean' && client.settings.log)) {
+            this.errorLog = true;
+            this.infoLog = true;
+            this.warnLog = true;
+        }
+        else {
+            this.errorLog = client.settings.log?.error;
+            this.infoLog = client.settings.log?.info;
+            this.warnLog = client.settings.log?.warn;
+            this.readyLog = client.settings.log?.ready;
+            this.tableLog = client.settings.log?.table;
+        }
+        this.time = () => String(new Date()).split(/ +/)[4];
+        this.ram = () => Math.round(process.memoryUsage().rss / 1000000);
+        this.shard = '';
+        process.on('message', (message) => {
+            if (message.type == 'xernerx')
+                this.shard = message?.data?.sharded ? `| ${message?.data?.shardId} |` : '';
+        });
+        this.base = (type, message) => `${type == 'info' ? `✔️  | ${this.purple('Xernerx')}` : type == `error` ? `❗ | ${this.red('Xernerx')}` : type == `update` ? `⬆️  | ${this.blue('Xernerx')}` : `⚠️  | ${this.yellow('Xernerx')}`} | ${this.cyan(this.time())} | ${this.cyan(this.ram())}mb | ${this.client.stats?.shardCount > 1 ? `${this.cyan(this.client.stats.shardId)} | ` : ''}${message}`;
+    }
+    info(message, force = false) {
+        return this.infoLog || force ? console.info(this.base('info', message)) : null;
+    }
+    warn(message) {
+        return this.warnLog ? console.warn(this.base('warn', message)) : null;
+    }
+    async update(version, url) {
+        const pkg = await fetch(url)
+            .then(async (res) => await res.json())
+            .catch(() => ({ version }));
+        if (version !== pkg.version)
+            console.info(this.base('update', `A new version for ${pkg.name} is available, you're using version ${this.cyan(version)}, new version is ${this.cyan(pkg.version)}, run ${dumfunctions_1.Style.log(`npm i ${pkg.name}@${pkg.version}`, {
+                color: dumfunctions_1.Style.BackgroundColor.Grey,
+            })} to update to the latest version.`));
+    }
+    error(message, error) {
+        return this.errorLog ? console.error(this.base('error', message), error) : null;
+    }
+    ready() {
+        if (typeof this.client == 'boolean')
+            return;
+        const client = this.client;
+        this.client.prependOnceListener('ready', async (synced) => {
+            this.info(`${dumfunctions_1.Style.log(synced.user.tag, { color: dumfunctions_1.Style.TextColor.Blue })} is now ${this.green('online')}, watching ${this.cyan(String(client.guilds.cache.size))} guild${client.guilds.cache.size > 1 ? 's' : ''}, using ${client.settings.local ? this.blue((await client.guilds.fetch(client.settings.local))?.name) : 'none'} as local guild.`, this.readyLog);
+            const files = [];
+            for (const [id, data] of client.commands.message) {
+                files.push(data);
+                id;
+            }
+            for (const [id, data] of client.commands.slash) {
+                files.push(data);
+                id;
+            }
+            for (const [id, data] of client.commands.context) {
+                files.push(data);
+                id;
+            }
+            for (const [id, data] of client.events) {
+                files.push(data);
+                id;
+            }
+            for (const [id, data] of client.inhibitors) {
+                files.push(data);
+                id;
+            }
+            if (this.tableLog) {
+                console.table(files, this.tableLog);
+            }
+        });
+    }
+    cyan(string) {
+        return dumfunctions_1.Style.log(String(string), { color: dumfunctions_1.Style.TextColor.Cyan });
+    }
+    blue(string) {
+        return dumfunctions_1.Style.log(String(string), { color: dumfunctions_1.Style.TextColor.Blue });
+    }
+    yellow(string) {
+        return dumfunctions_1.Style.log(String(string), { color: dumfunctions_1.Style.TextColor.Yellow });
+    }
+    purple(string) {
+        return dumfunctions_1.Style.log(String(string), { color: dumfunctions_1.Style.TextColor.Purple });
+    }
+    red(string) {
+        return dumfunctions_1.Style.log(String(string), { color: dumfunctions_1.Style.TextColor.Red });
+    }
+    green(string) {
+        return dumfunctions_1.Style.log(String(string), { color: dumfunctions_1.Style.TextColor.Green });
+    }
+}
+exports.default = XernerxLog;

package/dist/cjs/tools/XernerxText.js

@@ -0,0 +1,92 @@
+"use strict";
+/** @format */
+Object.defineProperty(exports, "__esModule", { value: true });
+class XernerxText {
+    user(user) {
+        if (typeof user == 'object')
+            user = user.id;
+        return `<@${user}>`;
+    }
+    channel(channel) {
+        if (typeof channel == 'object')
+            channel = channel.id;
+        return `<#${channel}>`;
+    }
+    role(role) {
+        if (typeof role == 'object')
+            role = role.id;
+        return `<@&${role}>`;
+    }
+    emoji(emoji, animated = false) {
+        if (typeof emoji == 'object')
+            emoji = emoji.id;
+        return `<${animated ? 'a' : ''}:${emoji}>`;
+    }
+    member(member) {
+        if (typeof member == 'object')
+            member = member.id;
+        return `<@!${member}>`;
+    }
+    timestamp(timestamp = Date.now(), format = 'R') {
+        if (typeof timestamp == 'string')
+            timestamp = Number(timestamp);
+        if (isNaN(timestamp))
+            return 'Invalid Date';
+        return `<t:${timestamp}:${format}>`;
+    }
+    codeBlock(code, language) {
+        return `\`\`\`${language}
+    ${code}
+    \`\`\``;
+    }
+    iCodeBlock(code) {
+        return `\`${code}\``;
+    }
+    bold(text) {
+        return `**${text}**`;
+    }
+    italic(text) {
+        return `*${text}*`;
+    }
+    underline(text) {
+        return `__${text}__`;
+    }
+    strike(text) {
+        return `~~${text}~~`;
+    }
+    spoiler(text) {
+        return `||${text}||`;
+    }
+    quote(text) {
+        return `> ${text}`;
+    }
+    blockQuote(text) {
+        return `>>> ${text}`;
+    }
+    hyperlink(text, url) {
+        return `[${text}](${url})`;
+    }
+    // public static HyperlinkWithTooltip(text: string, url: string, tooltip: string) {
+    // 	return `[${text}](${url} "${tooltip}")`;
+    // }
+    // public static HyperlinkWithTooltipAndImage(text: string, url: string, tooltip: string, imageUrl: string) {
+    // 	return `[${text}](${url} "${tooltip}":${imageUrl})`;
+    // }
+    // public static HyperlinkWithImage(text: string, url: string, imageUrl: string) {
+    // 	return `[${text}](${url}:${imageUrl})`;
+    // }
+    Progressbar(min, max, cur, options = {}) {
+        if (!options.fill)
+            options.fill = '█';
+        if (!options.fade)
+            options.fade = '▓▒';
+        if (!options.empty)
+            options.empty = '░';
+        const length = options.length || 20, percentage = cur / max, filledLength = Math.round(length * percentage), emptyLength = length - filledLength;
+        if (!options.percentage)
+            return '`' + options.fill.repeat(filledLength) + options.empty.repeat(emptyLength) + '`';
+        else
+            return '`' + options.fill.repeat(filledLength) + options.empty.repeat(emptyLength) + '` ' + `\`${percentage * 100}%\``;
+    }
+}
+exports.default = XernerxText;

package/dist/cjs/types/extenders.js

@@ -0,0 +1,3 @@
+"use strict";
+/** @format */
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/types/interfaces.js

@@ -0,0 +1,3 @@
+"use strict";
+/** @format */
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/types/types.js

@@ -0,0 +1,3 @@
+"use strict";
+/** @format */
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/{utils → cjs/utils}/ClientUtil.d.ts

@@ -11,8 +11,9 @@ export default class ClientUtil extends Util {
     constructor(client: XernerxClient);
     setPresence(options: PresenceOptions): import("discord.js").ClientPresence | undefined;
     private resolveCooldown;
-    resolveCommand(options: ResolveCommandOptions): XernerxMessageCommand | XernerxSlashCommand | XernerxContextCommand | Collection<string, XernerxMessageCommand | XernerxSlashCommand | XernerxContextCommand>;
+    resolveCommand(options: ResolveCommandOptions): XernerxSlashCommand | XernerxContextCommand | XernerxMessageCommand | Collection<string, XernerxSlashCommand | XernerxContextCommand | XernerxMessageCommand>;
     resolveChannel(query: string | Record<string, string>): Promise<import("discord.js").Channel | null>;
     resolveGuild(query: string | Record<string, string>): Promise<import("discord.js").Guild | null>;
     uptime(timestamp?: number | null): string;
+    commands(): (XernerxSlashCommand | XernerxContextCommand | XernerxMessageCommand)[];
 }

package/dist/cjs/utils/ClientUtil.js

@@ -0,0 +1,84 @@
+"use strict";
+/** @format */
+Object.defineProperty(exports, "__esModule", { value: true });
+const discord_js_1 = require("discord.js");
+const setPresence_js_1 = __importDefault(require("../functions/setPresence.js"));
+const Util_js_1 = __importDefault(require("./Util.js"));
+class ClientUtil extends Util_js_1.default {
+    constructor(client) {
+        super(client);
+    }
+    setPresence(options) {
+        return (0, setPresence_js_1.default)(this.client, options);
+    }
+    // @ts-ignore
+    resolveCooldown() { }
+    resolveCommand(options) {
+        const commands = [], collection = new discord_js_1.Collection();
+        if (options?.type == 'MessageCommand' || !options?.type)
+            commands.push(...this.client.commands.message);
+        if (options?.type == 'Interaction' || options?.type == 'SlashCommand' || !options?.type)
+            commands.push(...this.client.commands.slash);
+        if (options?.type == 'Interaction' || options?.type == 'ContextCommand' || !options?.type)
+            commands.push(...this.client.commands.context);
+        commands.map(([name, command]) => collection.set(name, command));
+        if (options?.name) {
+            return collection.get(options.name) || null;
+        }
+        else
+            return collection;
+    }
+    async resolveChannel(query) {
+        if (typeof query == 'object')
+            query = query.id;
+        try {
+            let channel = this.client.channels.cache.find((channel) => channel.name == query.toLowerCase() || channel.id == query.toLowerCase() ? channel : null) || null;
+            if (!channel)
+                channel = (await this.client.channels.fetch(query)) || null;
+            return channel;
+        }
+        catch {
+            return null;
+        }
+    }
+    async resolveGuild(query) {
+        if (typeof query == 'object')
+            query = query.id;
+        try {
+            let guild = this.client.guilds.cache.find((guild) => guild.name.toLowerCase() == query.toLowerCase()) || null;
+            if (!guild)
+                guild = (await this.client.guilds.fetch(query)) || null;
+            return guild;
+        }
+        catch {
+            return null;
+        }
+    }
+    uptime(timestamp) {
+        if (!timestamp)
+            timestamp = this.client.uptime || 0;
+        let totalSeconds = timestamp / 1000;
+        let years = Math.floor(totalSeconds / 31536000);
+        totalSeconds %= 31536000;
+        let days = Math.floor(totalSeconds / 86400);
+        totalSeconds %= 86400;
+        let hours = Math.floor(totalSeconds / 3600);
+        totalSeconds %= 3600;
+        let minutes = Math.floor(totalSeconds / 60);
+        let seconds = Math.floor(totalSeconds % 60);
+        if (years >= 1)
+            return `${years}y ${days}d ${hours}h ${minutes}m`;
+        else if (days >= 1)
+            return `${days}d ${hours}h ${minutes}m`;
+        else if (hours >= 1)
+            return `${hours}h ${minutes}m`;
+        else if (minutes >= 1)
+            return `${minutes}m ${seconds}s`;
+        else
+            return `${seconds}s`;
+    }
+    commands() {
+        return [...this.client.commands.context.toJSON(), ...this.client.commands.slash.toJSON(), ...this.client.commands.message.toJSON()];
+    }
+}
+exports.default = ClientUtil;

package/dist/{utils → cjs/utils}/InteractionUtil.d.ts

@@ -2,7 +2,7 @@
 import { EmbedBuilder, InteractionEditReplyOptions, InteractionReplyOptions, MessageCreateOptions, MessagePayload } from 'discord.js';
 import XernerxClient from '../client/XernerxClient.js';
 import { ContextCommandArguments, PaginatorOptions, SlashCommandArguments } from '../types/interfaces.js';
-import { XernerxInteraction } from '../types/types.js';
+import { PermissionNames, XernerxInteraction } from '../types/types.js';
 import Util from './Util.js';
 import { XernerxMessageContextInteraction, XernerxSlashInteraction, XernerxUser, XernerxUserContextInteraction } from '../types/extenders.js';
 type MimicOptions = {
@@ -18,7 +18,8 @@ export default class InteractionUtil extends Util {
     send(content: any): Promise<import("discord.js").Message<false> | import("discord.js").Message<true> | undefined>;
     reply(content: string | MessagePayload | InteractionReplyOptions | InteractionEditReplyOptions): Promise<import("discord.js").InteractionResponse<boolean> | import("discord.js").Message<boolean>>;
     mimic(user: XernerxUser | string, interaction: MessageCreateOptions, options: MimicOptions): Promise<void>;
-    private commandName;
     paginator(embeds: Array<EmbedBuilder>, options?: PaginatorOptions): Promise<void | import("discord.js").Message<false> | import("discord.js").Message<true>>;
+    commands(): import("@discordjs/collection").Collection<string, import("../main.js").XernerxSlashCommand> | import("@discordjs/collection").Collection<string, import("../main.js").XernerxContextCommand>;
+    permissionCheck(type: 'user' | 'client', permissions: Array<PermissionNames>): boolean;
 }
 export {};