xernerx 4.16.0 → 4.17.1

package/dist/build/XernerxContextCommand.d.ts

@@ -43,6 +43,7 @@ export default class XernerxContextCommand {
     readonly filepath: string;
     readonly client: XernerxClientType;
     util: InteractionUtil;
+    snowflake: string | null;
     constructor(id: string, options: ContextCommandOptions);
     /**
      * @description the execution of the command

package/dist/build/XernerxEvent.d.ts

@@ -1,25 +1,21 @@
 /** @format */
 import { XernerxEventOptions } from '../types/interfaces.js';
-import { XernerxEventType } from '../types/types.js';
-import { XernerxClientType } from '../types/extenders.js';
+import { XernerxClientEvents, XernerxClientType } from '../types/extenders.js';
+import { Awaitable, RestEvents } from 'discord.js';
 /**
  * @description - The event builder for  events.
  * @param {String} id - The unique ID of the event.
  * @param {EventOptions} options - The event options.
  */
-export default class XernerxEvent {
+export default class XernerxEvent<Event extends keyof XernerxClientEvents> {
     readonly id: string;
-    readonly name: XernerxEventType | string;
-    readonly emitter?: 'client' | 'process' | string;
-    readonly type?: 'discord' | string;
+    readonly name: Event | keyof RestEvents | string;
+    readonly emitter?: 'client' | 'process' | 'rest' | string;
+    readonly type?: 'discord' | 'node' | string;
     readonly once?: boolean;
     readonly filetype: 'Event';
     readonly filepath: string;
     readonly client: XernerxClientType;
     constructor(id: string, options: XernerxEventOptions);
-    /**
-     * @description run your custom event here.
-     * @param any - there can be all kinds of parameters on events.
-     */
-    run(...args: any): Promise<any>;
+    run(...args: XernerxClientEvents[Event]): Promise<Awaitable<any>>;
 }

package/dist/build/XernerxEvent.js

@@ -21,10 +21,6 @@ export default class XernerxEvent {
         this.once = options.once || false;
         this.client = this.client;
     }
-    /**
-     * @description run your custom event here.
-     * @param any - there can be all kinds of parameters on events.
-     */
     async run(...args) {
         return new XernerxLog(this.client).error(`${this.id} doesn't have a run rule.`);
     }

package/dist/build/XernerxMessageCommand.d.ts

@@ -40,6 +40,7 @@ export default class XernerxMessageCommand {
     readonly filetype: 'MessageCommand';
     readonly filepath: string;
     readonly client: XernerxClientType;
+    snowflake: string | null;
     util: MessageUtil;
     constructor(id: string, options: MessageCommandOptions);
     /**

package/dist/build/XernerxMessageCommand.js

@@ -114,6 +114,6 @@ export default class XernerxMessageCommand {
      */
     async exec(message, { args, flags }) {
         new XernerxLog(this.client).error(`${this.id} doesn't have an execution rule.`);
-        return await this.client.emit('commandError', message, `${this.id} doesn't have an execution rule.`, this, this.filetype);
+        return await this.client.emit('commandError', message, `${this.id} doesn't have an execution rule.`, this);
     }
 }

package/dist/build/XernerxSlashCommand.d.ts

@@ -42,6 +42,7 @@ export default class XernerxSlashCommand {
     readonly filetype: 'SlashCommand';
     readonly filepath: string;
     readonly client: XernerxClientType;
+    snowflake: string | null;
     util: InteractionUtil;
     constructor(id: string, options: SlashCommandOptions);
     /**

package/dist/build/XernerxSlashCommand.js

@@ -27,6 +27,7 @@ export default class XernerxSlashCommand {
             usage: z.string().or(z.null()).default(null),
             info: z.string().or(z.null()).default(null),
             category: z.string().or(z.null()).default(null),
+            cooldown: z.number().or(z.null()).default(null),
             number: z.number().or(z.null()).default(null),
             global: z.boolean().default(true),
             channel: z
@@ -137,7 +138,7 @@ export default class XernerxSlashCommand {
      */
     async exec(interaction, { args, subcommand, group }) {
         new XernerxLog(this.client).error(`${this.id} doesn't have an execution rule.`);
-        return await this.client.emit('commandError', interaction, `${this.id} doesn't have an execution rule.`, this, this.filetype);
+        return await this.client.emit('commandError', interaction, `${this.id} doesn't have an execution rule.`, this);
     }
     addArguments(command, args) {
         for (const argument of args) {

package/dist/client/XernerxClient.d.ts

@@ -1,11 +1,12 @@
 /** @format */
 import { Client, ClientOptions, Collection } from 'discord.js';
 import { XernerxOptions, ModuleOptions, XernerxCommands, XernerxCache } from '../types/interfaces.js';
+import { XernerxClientEvents } from '../types/extenders.js';
 import ClientUtil from '../utils/ClientUtil.js';
 import XernerxInhibitor from '../build/XernerxInhibitor.js';
 import XernerxEvent from '../build/XernerxEvent.js';
 import Cooldowns from '../models/Cooldowns.js';
-export default class XernerxClient extends Client {
+export default class XernerxClient<T = unknown> extends Client {
     readonly settings: {
         ownerId: (string | string[]) & (string | string[] | undefined);
         local: string;
@@ -39,9 +40,9 @@ export default class XernerxClient extends Client {
             collections: string[];
         } | undefined;
     };
-    readonly config: {} | null;
+    readonly config: T;
     readonly commands: XernerxCommands;
-    readonly events: Collection<string, XernerxEvent>;
+    readonly events: Collection<string, XernerxEvent<keyof XernerxClientEvents>>;
     readonly inhibitors: Collection<string, XernerxInhibitor>;
     readonly modules: ModuleOptions;
     readonly util: ClientUtil;
@@ -49,6 +50,6 @@ export default class XernerxClient extends Client {
     readonly cache: XernerxCache;
     readonly cooldowns: Cooldowns;
     readonly dbl: any;
-    constructor(discordOptions: ClientOptions, xernerxOptions: XernerxOptions, config?: unknown);
+    constructor(discordOptions: ClientOptions, xernerxOptions: XernerxOptions, config?: T);
     connect(token: string): Promise<string>;
 }

package/dist/client/XernerxClient.js

@@ -57,7 +57,7 @@ export default class XernerxClient extends Client {
                 .optional(),
         })
             .parse(xernerxOptions);
-        this.config = config || null;
+        this.config = config;
         this.commands = {
             message: new Collection(),
             slash: new Collection(),
@@ -87,7 +87,6 @@ export default class XernerxClient extends Client {
             integrationHandler: new IntegrationHandler(this),
             extensionHandler: new ExtensionHandler(this),
         };
-        return this;
     }
     async connect(token) {
         const login = this.login(token);

package/dist/handlers/CommandHandler.js

@@ -291,7 +291,7 @@ export default class CommandHandler extends Handler {
             cmd.util = interaction.util;
             return await this.exec(cmd, interaction, args, filetype);
         })
-            .catch((error) => this.client.emit('commandError', interaction, error, cmd, filetype));
+            .catch((error) => this.client.emit('commandError', interaction, error, cmd));
     }
     async contextCommandRun(interaction) {
         const filetype = 'ContextCommand';
@@ -337,7 +337,7 @@ export default class CommandHandler extends Handler {
         }
         catch (error) {
             new XernerxLog(this.client).error(`An error occurred executing ${Style.log(cmd.name, { color: Style.TextColor.Blue })}`, error);
-            return await this.client.emit('commandError', event, error, cmd, type);
+            return await this.client.emit('commandError', event, error, cmd);
         }
     }
     _checks(command) {

package/dist/handlers/Handler.d.ts

@@ -4,11 +4,20 @@ import MessageCommandBuilder from '../build/XernerxMessageCommand.js';
 import XernerxSlashCommand from '../build/XernerxSlashCommand.js';
 import XernerxContextCommand from '../build/XernerxContextCommand.js';
 import { filetype } from '../types/types.js';
+import { XernerxClientEvents, XernerxEvent, XernerxInhibitor } from '../main.js';
 export default class Handler {
-    readonly client: XernerxClient;
+    readonly client: XernerxClient<unknown>;
     readonly files: Array<MessageCommandBuilder | XernerxSlashCommand | XernerxContextCommand>;
     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>;
+    /**
+     * Emits a file that has been loaded into the handler.
+     * @param file - The file to emit.
+     */
+    emit<File extends {
+        name: string;
+        filetype: 'MessageCommand' | 'SlashCommand' | 'ContextCommand';
+        run: Function;
+    } | XernerxInhibitor | XernerxEvent<keyof XernerxClientEvents>>(file: File): Promise<void>;
 }

package/dist/handlers/Handler.js

@@ -23,23 +23,32 @@ export default class Handler {
         this.files.push(file);
         return file;
     }
-    async emit(event) {
-        if (!event?.filetype)
+    /**
+     * Emits a file that has been loaded into the handler.
+     * @param file - The file to emit.
+     */
+    async emit(file) {
+        if (!file?.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 (file.filetype === 'Inhibitor')
+            return;
+        if (file.filetype === 'Event' && file.emitter) {
+            if (file.emitter === 'client') {
+                this.client[file.once ? 'once' : 'on'](file.name, (...args) => file.run(...args));
+            }
+            else if (file.emitter === 'process') {
+                process[file.once ? 'once' : 'on'](file.name, (...args) => file.run(...args));
+            }
+            else if (file.emitter === 'rest') {
+                this.client.rest[file.once ? 'once' : 'on'](file.name, (...args) => file.run(...args));
+            }
+            else {
+                // @ts-expect-error
+                this.client[file.emitter][file.once ? 'once' : 'on'](file.name, (...args) => file.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));
+        else {
+            this.client.on(file.name, (...args) => file.run(...args));
         }
     }
 }

package/dist/tools/XernerxIntents.d.ts

@@ -1,5 +1,6 @@
 /** @format */
+import { GatewayIntentBits } from 'discord.js';
 export declare const XernerxIntents: {
-    Default: string[];
-    All: string[];
+    Default: GatewayIntentBits[];
+    All: GatewayIntentBits[];
 };

package/dist/tools/XernerxIntents.js

@@ -1,24 +1,26 @@
 /** @format */
+import { GatewayIntentBits } from 'discord.js';
 export const XernerxIntents = {
     Default: [
-        'Guilds',
-        'GuildModeration',
-        'GuildBans',
-        'GuildEmojisAndStickers',
-        'GuildIntegrations',
-        'GuildWebhooks',
-        'GuildInvites',
-        'GuildVoiceStates',
-        'GuildMessages',
-        'GuildMessageReactions',
-        'GuildMessageTyping',
-        'DirectMessages',
-        'DirectMessageReactions',
-        'DirectMessageTyping',
-        'GuildScheduledEvents',
-        'AutoModerationConfiguration',
-        'AutoModerationExecution',
+        GatewayIntentBits.Guilds,
+        GatewayIntentBits.GuildModeration,
+        GatewayIntentBits.GuildBans,
+        GatewayIntentBits.GuildModeration,
+        GatewayIntentBits.GuildEmojisAndStickers,
+        GatewayIntentBits.GuildIntegrations,
+        GatewayIntentBits.GuildWebhooks,
+        GatewayIntentBits.GuildInvites,
+        GatewayIntentBits.GuildVoiceStates,
+        GatewayIntentBits.GuildMessages,
+        GatewayIntentBits.GuildMessageReactions,
+        GatewayIntentBits.GuildMessageTyping,
+        GatewayIntentBits.DirectMessages,
+        GatewayIntentBits.DirectMessageReactions,
+        GatewayIntentBits.DirectMessageTyping,
+        GatewayIntentBits.GuildScheduledEvents,
+        GatewayIntentBits.AutoModerationConfiguration,
+        GatewayIntentBits.AutoModerationExecution,
     ],
-    All: [''],
+    All: [GatewayIntentBits.GuildMembers, GatewayIntentBits.GuildPresences, GatewayIntentBits.MessageContent],
 };
-XernerxIntents.All = [...XernerxIntents.Default, 'GuildMembers', 'GuildPresences', 'MessageContent'];
+XernerxIntents.All.push(...XernerxIntents.Default);

package/dist/tools/XernerxLog.d.ts

@@ -9,7 +9,7 @@ export default class XernerxLog {
     private readonly warnLog;
     private readonly readyLog;
     private readonly tableLog;
-    private readonly config;
+    private readonly format;
     private readonly time;
     private readonly ram;
     private shard;

package/dist/tools/XernerxLog.js

@@ -12,6 +12,7 @@ export default class XernerxLog {
             this.errorLog = true;
             this.infoLog = true;
             this.warnLog = true;
+            this.format = ['ram', 'time'];
         }
         else {
             this.errorLog = client.settings.log?.error;
@@ -19,9 +20,9 @@ export default class XernerxLog {
             this.warnLog = client.settings.log?.warn;
             this.readyLog = client.settings.log?.ready;
             this.tableLog = client.settings.log?.table;
-            this.config = client.settings.log?.config || ['ram', 'time'];
+            this.format = client.settings.log?.format || ['ram', 'time'];
         }
-        const config = {
+        const format = {
             name: this.blue(pkg.name),
             node: this.green(process.version),
             xernerx: this.cyan(version),
@@ -38,13 +39,12 @@ export default class XernerxLog {
                 return i;
             },
         };
-        this.config;
         process.on('message', (message) => {
             if (message.type == 'xernerx')
-                config.shard = message?.data?.sharded ? `| ${message?.data?.shardId} |` : '';
+                format.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.config
-            ?.map((c) => (typeof config[c] == 'function' ? config[c]() : config[c]) || null)
+        this.base = (type, message) => `${type == 'info' ? `✔️  | ${this.purple('Xernerx')}` : type == `error` ? `❗ | ${this.red('Xernerx')}` : type == `update` ? `⬆️  | ${this.blue('Xernerx')}` : `⚠️  | ${this.yellow('Xernerx')}`} | ${this.format
+            ?.map((c) => (typeof format[c] == 'function' ? format[c]() : format[c]) || null)
             .filter((x) => x)
             .join(' | ')} | ${message}`;
     }

package/dist/tools/XernerxText.d.ts

@@ -7,6 +7,7 @@ export default class XernerxText {
     role(role: string | Role): string;
     emoji(emoji: string | Emoji, animated?: boolean): string;
     member(member: string | XernerxMember): string;
+    command(id: string, name: string): string | null;
     timestamp(timestamp?: number | Date, format?: 't' | 'T' | 'd' | 'D' | 'f' | 'F' | 'R'): string;
     codeBlock(code: string, language: string): string;
     iCodeBlock(code: string): string;

package/dist/tools/XernerxText.js

@@ -25,6 +25,11 @@ export default class XernerxText {
             member = member.id;
         return `<@!${member}>`;
     }
+    command(id, name) {
+        if (typeof id !== 'string')
+            return null;
+        return `</${name}:${id}>`;
+    }
     timestamp(timestamp = Date.now(), format = 'R') {
         if (typeof timestamp == 'string')
             timestamp = Number(timestamp);

package/dist/types/extenders.d.ts

@@ -1,5 +1,5 @@
 /** @format */
-import { ChatInputCommandInteraction, Collection, DMChannel, Guild, GuildChannel, GuildMember, Message, MessageContextMenuCommandInteraction, User, UserContextMenuCommandInteraction } from 'discord.js';
+import { ChatInputCommandInteraction, Collection, DMChannel, Guild, GuildChannel, GuildMember, Message, MessageContextMenuCommandInteraction, User, UserContextMenuCommandInteraction, ClientEvents } from 'discord.js';
 import InteractionUtil from '../utils/InteractionUtil.js';
 import MessageUtil from '../utils/MessageUtil.js';
 import { ModuleOptions, XernerxCache, XernerxCommands } from '../types/interfaces.js';
@@ -7,6 +7,8 @@ import XernerxEvent from '../build/XernerxEvent.js';
 import XernerxInhibitor from '../build/XernerxInhibitor.js';
 import XernerxClient from '../client/XernerxClient.js';
 import ClientUtil from '../utils/ClientUtil.js';
+import { XernerxContextCommand, XernerxMessageCommand, XernerxSlashCommand } from '../main.js';
+import XernerxError from '../tools/XernerxError.js';
 export interface XernerxUser extends User {
     owner: boolean;
     voted: boolean | null;
@@ -40,7 +42,7 @@ export interface XernerxMessageContextInteraction extends MessageContextMenuComm
 }
 export interface XernerxClientType extends XernerxClient {
     commands: XernerxCommands;
-    events: Collection<string, XernerxEvent>;
+    events: Collection<string, XernerxEvent<keyof XernerxClientEvents>>;
     inhibitors: Collection<string, XernerxInhibitor>;
     modules: ModuleOptions;
     util: ClientUtil;
@@ -58,4 +60,17 @@ export interface XernerxClientType extends XernerxClient {
     cache: XernerxCache;
     connect: () => Promise<string>;
 }
+interface CommandBlockInfo {
+    reason: string;
+    message: string;
+    required: Array<string> | string;
+    missing: Array<string> | string;
+}
+export interface XernerxClientEvents extends ClientEvents {
+    commandBlock: [event: XernerxMessage | XernerxSlashInteraction, info: CommandBlockInfo, command: XernerxSlashCommand | XernerxMessageCommand | XernerxContextCommand];
+    commandError: [event: XernerxMessage | XernerxSlashInteraction, error: XernerxError, command: XernerxSlashCommand | XernerxMessageCommand | XernerxContextCommand];
+    commandStart: [event: XernerxMessage | XernerxSlashInteraction, command: XernerxSlashCommand | XernerxMessageCommand | XernerxContextCommand];
+    commandFinish: [event: XernerxMessage | XernerxSlashInteraction, command: XernerxSlashCommand | XernerxMessageCommand | XernerxContextCommand];
+    commandNotFound: [event: XernerxMessage | XernerxSlashInteraction, commandName: string, filetype: 'MessageCommand' | 'SlashCommand' | 'ContextCommand'];
+}
 export {};

package/dist/types/interfaces.d.ts

@@ -7,9 +7,9 @@ import IntegrationHandler from '../handlers/IntegrationHandler.js';
 import XernerxContextCommand from '../build/XernerxContextCommand.js';
 import MessageCommandBuilder from '../build/XernerxMessageCommand.js';
 import XernerxSlashCommand from '../build/XernerxSlashCommand.js';
-import { Locales, MessageCommandArgumentType, PermissionNames, SlashCommandArgumentType, XernerxEventType, InhibitorType } from './types.js';
+import { Locales, MessageCommandArgumentType, PermissionNames, SlashCommandArgumentType, InhibitorType } from './types.js';
 import ExtensionHandler from '../handlers/ExtensionHandler.js';
-import { XernerxMessage, XernerxUser } from './extenders.js';
+import { XernerxClientEvents, XernerxMessage, XernerxUser } from './extenders.js';
 export interface XernerxOptions {
     local: string;
     global?: boolean;
@@ -35,7 +35,7 @@ export interface XernerxOptions {
         warn?: boolean;
         error?: boolean;
         table?: Array<'name' | 'aliases' | 'description' | 'filetype' | 'category'>;
-        config?: Array<'name' | 'node' | 'xernerx' | 'discordjs' | 'platform' | 'time' | 'date' | 'ram' | 'version' | 'author' | 'shard' | 'index'>;
+        format?: Array<'name' | 'node' | 'xernerx' | 'discordjs' | 'platform' | 'time' | 'date' | 'ram' | 'version' | 'author' | 'shard' | 'index'>;
     };
     cooldown?: {
         command?: number;
@@ -223,7 +223,7 @@ export interface SlashCommandArguments<T = SlashCommandArgumentType> {
     group: string;
 }
 export interface XernerxEventOptions {
-    name: XernerxEventType;
+    name: keyof XernerxClientEvents;
     emitter?: 'client' | 'process';
     type?: 'discord' | 'node';
     once?: boolean;

package/dist/types/types.d.ts

@@ -7,8 +7,6 @@ export type SlashCommandArgumentType = 'attachment' | 'boolean' | 'channel' | 'i
 export type SlashCommandOptionChoices = SlashCommandStringOption | SlashCommandNumberOption | SlashCommandIntegerOption;
 export type SlashCommandOption = SlashCommandOptionChoices | SlashCommandBooleanOption | SlashCommandUserOption | SlashCommandChannelOption | SlashCommandRoleOption | SlashCommandMentionableOption;
 export type MessageCommandArgumentType = 'string' | 'number' | 'boolean' | 'confirm' | 'channel' | 'guild' | 'integer' | 'mentionable' | 'role' | 'user' | 'message' | 'member' | 'list' | 'option' | 'rest';
-export type DiscordEventType = 'applicationCommandPermissionsUpdate' | 'autoModerationActionExecution' | 'autoModerationRuleCreate' | 'autoModerationRuleDelete' | 'autoModerationRuleUpdate' | 'ready' | 'guildCreate' | 'guildDelete' | 'guildUpdate' | 'guildUnavailable' | 'guildMemberAdd' | 'guildMemberRemove' | 'guildMemberUpdate' | 'guildMemberAvailable' | 'guildMembersChunk' | 'guildIntegrationsUpdate' | 'roleCreate' | 'roleDelete' | 'inviteCreate' | 'inviteDelete' | 'roleUpdate' | 'emojiCreate' | 'emojiDelete' | 'emojiUpdate' | 'guildBanAdd' | 'guildBanRemove' | 'channelCreate' | 'channelDelete' | 'channelUpdate' | 'channelPinsUpdate' | 'messageCreate' | 'messageDelete' | 'messageUpdate' | 'messageDeleteBulk' | 'messageReactionAdd' | 'messageReactionRemove' | 'messageReactionRemoveAll' | 'messageReactionRemoveEmoji' | 'threadCreate' | 'threadDelete' | 'threadUpdate' | 'threadListSync' | 'threadMemberUpdate' | 'threadMembersUpdate' | 'userUpdate' | 'presenceUpdate' | 'voiceServerUpdate' | 'voiceStateUpdate' | 'typingStart' | 'webhookUpdate' | 'interactionCreate' | 'error' | 'warn' | 'debug' | 'cacheSweep' | 'shardDisconnect' | 'shardError' | 'shardReconnecting' | 'shardReady' | 'shardResume' | 'invalidated' | 'raw' | 'stageInstanceCreate' | 'stageInstanceUpdate' | 'stageInstanceDelete' | 'stickerCreate' | 'stickerDelete' | 'stickerUpdate' | 'guildScheduledEventCreate' | 'guildScheduledEventUpdate' | 'guildScheduledEventDelete' | 'guildScheduledEventUserAdd' | 'guildScheduledEventUserRemove';
-export type XernerxEventType = DiscordEventType | 'webhookCreate' | 'webhookError' | 'commandBlock' | 'commandError' | 'commandStart' | 'commandFinish' | 'commandCooldown';
 export type XernerxInteraction<T extends XernerxSlashInteraction | XernerxUserContextInteraction | XernerxMessageContextInteraction> = T extends XernerxSlashInteraction ? XernerxSlashInteraction : T extends XernerxUserContextInteraction ? XernerxUserContextInteraction : XernerxMessageContextInteraction;
 export type PermissionNames = 'create instant invite' | 'kick members' | 'ban members' | 'administrator' | 'manage channels' | 'manage guild' | 'add reactions' | 'view audit log' | 'priority speaker' | 'stream' | 'view channel' | 'send messages' | 'send tts messages' | 'manage messages' | 'embed links' | 'attach files' | 'read message history' | 'mention everyone' | 'use external emojis' | 'view guild insights' | 'connect' | 'speak' | 'mute members' | 'deafen members' | 'move members' | 'use vad' | 'change nickname' | 'manage nicknames' | 'manage roles' | 'manage webhooks' | 'manage emojis and stickers' | 'use application commands' | 'request to speak' | 'manage events' | 'manage threads' | 'create public threads' | 'create private threads' | 'use external stickers' | 'send messages in threads' | 'start embedded activities' | 'moderate members';
 export type InhibitorType = '*' | 'message' | 'interaction' | 'command' | 'channel' | 'user' | 'member' | 'guild' | 'contextCommand' | 'messageCommand' | 'slashCommand';

package/dist/utils/ClientUtil.d.ts

@@ -11,7 +11,7 @@ export default class ClientUtil extends Util {
     constructor(client: XernerxClient);
     setPresence(options: PresenceOptions): import("discord.js").ClientPresence | undefined;
     private resolveCooldown;
-    resolveCommand(options: ResolveCommandOptions): XernerxSlashCommand | XernerxContextCommand | XernerxMessageCommand | Collection<string, XernerxSlashCommand | XernerxContextCommand | XernerxMessageCommand>;
+    resolveCommand(options: ResolveCommandOptions): Promise<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;

package/dist/utils/ClientUtil.js

@@ -11,7 +11,8 @@ export default class ClientUtil extends Util {
     }
     // @ts-ignore
     resolveCooldown() { }
-    resolveCommand(options) {
+    async resolveCommand(options) {
+        const interCommands = await this.client.application?.commands.fetch();
         const commands = [], collection = new Collection();
         if (options?.type == 'MessageCommand' || !options?.type)
             commands.push(...this.client.commands.message);
@@ -19,7 +20,10 @@ export default class ClientUtil extends Util {
             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));
+        commands.map(([name, command]) => {
+            command.snowflake = interCommands?.find((cmd) => command.name === cmd.name)?.id || null;
+            collection.set(name, command);
+        });
         if (options?.name) {
             return collection.get(options.name) || null;
         }

package/dist/utils/Util.d.ts

@@ -2,7 +2,7 @@
 import XernerxClient from '../client/XernerxClient.js';
 import XernerxText from '../tools/XernerxText.js';
 export default class Util {
-    readonly client: XernerxClient;
+    readonly client: XernerxClient<unknown>;
     readonly text: XernerxText;
     constructor(client: XernerxClient);
     delay(time: number): Promise<unknown>;

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "xernerx",
-	"version": "4.16.0",
+	"version": "4.17.1",
 	"description": "A bot framework for discord.js.",
 	"main": "dist/main.js",
 	"type": "module",