xernerx 4.5.22 → 4.5.26

package/README.md

@@ -9,6 +9,9 @@
 ![Read the Docs](https://img.shields.io/readthedocs/node)
 ![npm type definitions](https://img.shields.io/npm/types/xernerx)
 ![node-current](https://img.shields.io/npm/v/discord.js)
+[![wakatime](https://wakatime.com/badge/user/0eeef1b5-98a7-4ec0-ab4c-db00536d5ed1/project/23ab34b7-623b-45e8-b8db-e9f1910589f7.svg)](https://wakatime.com/badge/user/0eeef1b5-98a7-4ec0-ab4c-db00536d5ed1/project/23ab34b7-623b-45e8-b8db-e9f1910589f7)
+![node-current](https://img.shields.io/node/v/xernerx)
+![GitHub commit activity (branch)](https://img.shields.io/github/commit-activity/t/xernerx/xernerx)
 
 </center>
 # About

package/dist/build/XernerxContextCommand.d.ts

@@ -3,54 +3,46 @@ import { ContextMenuCommandBuilder } from 'discord.js';
 import { XernerxMessageContextInteraction, XernerxUserContextInteraction, XernerxClientType } from '../types/extenders.js';
 import { ContextCommandArguments, ContextCommandOptions } from '../types/interfaces.js';
 export default class XernerxContextCommand {
-	readonly id: string;
-	readonly data: ContextMenuCommandBuilder;
-	readonly name: string;
-	readonly type: 'user' | 'message';
-	readonly description: string | null | undefined;
-	readonly usage: string | null | undefined;
-	readonly info: string | null | undefined;
-	readonly category: string | null | undefined;
-	readonly cooldown: number | null | undefined;
-	readonly ignore:
-		| {
-				owner?: boolean | undefined;
-				users?: string[] | undefined;
-				channels?: string[] | undefined;
-				guilds?: string[] | undefined;
-		  }
-		| undefined;
-	readonly strict:
-		| {
-				owner?: boolean | undefined;
-				users?: string[] | undefined;
-				channels?: string[] | undefined;
-				guilds?: string[] | undefined;
-		  }
-		| undefined;
-	readonly permissions:
-		| {
-				user?: string[] | import('../main.js').PermissionNames[] | undefined;
-				client?: string[] | import('../main.js').PermissionNames[] | undefined;
-				dm?: boolean | undefined;
-		  }
-		| undefined;
-	readonly defer:
-		| {
-				reply?: boolean | undefined;
-				ephemeral?: boolean | undefined;
-				fetchReply?: boolean | undefined;
-		  }
-		| undefined;
-	readonly filetype: 'ContextCommand';
-	readonly filepath: string;
-	readonly client: XernerxClientType;
-	constructor(id: string, options: ContextCommandOptions);
-	/**
-	 * @description the execution of the command
-	 * @param interaction - Interaction event emitted on command
-	 * @param args - The arguments parsed with the command, if any
-	 */
-	exec(interaction: XernerxUserContextInteraction | XernerxMessageContextInteraction, args: ContextCommandArguments<'user' | 'message'>): Promise<any>;
+    readonly id: string;
+    readonly data: ContextMenuCommandBuilder;
+    readonly name: string;
+    readonly type: 'user' | 'message';
+    readonly description: string | null | undefined;
+    readonly usage: string | null | undefined;
+    readonly info: string | null | undefined;
+    readonly category: string | null | undefined;
+    readonly cooldown: number | null | undefined;
+    readonly ignore: {
+        owner?: boolean | undefined;
+        users?: string[] | undefined;
+        channels?: string[] | undefined;
+        guilds?: string[] | undefined;
+    } | undefined;
+    readonly strict: {
+        owner?: boolean | undefined;
+        users?: string[] | undefined;
+        channels?: string[] | undefined;
+        guilds?: string[] | undefined;
+    } | undefined;
+    readonly permissions: {
+        user?: string[] | import("../main.js").PermissionNames[] | undefined;
+        client?: string[] | import("../main.js").PermissionNames[] | undefined;
+        dm?: boolean | undefined;
+    } | undefined;
+    readonly defer: {
+        reply?: boolean | undefined;
+        ephemeral?: boolean | undefined;
+        fetchReply?: boolean | undefined;
+    } | undefined;
+    readonly filetype: 'ContextCommand';
+    readonly filepath: string;
+    readonly client: XernerxClientType;
+    constructor(id: string, options: ContextCommandOptions);
+    /**
+     * @description the execution of the command
+     * @param interaction - Interaction event emitted on command
+     * @param args - The arguments parsed with the command, if any
+     */
+    exec(interaction: XernerxUserContextInteraction | XernerxMessageContextInteraction, args: ContextCommandArguments<'user' | 'message'>): Promise<any>;
 }
-//# sourceMappingURL=XernerxContextCommand.d.ts.map
+//# sourceMappingURL=XernerxContextCommand.d.ts.map

package/dist/build/XernerxContextCommand.js

@@ -3,75 +3,75 @@ import { ContextMenuCommandBuilder } from 'discord.js';
 import { z } from 'zod';
 import { XernerxLog } from '../main.js';
 export default class XernerxContextCommand {
-	constructor(id, options) {
-		this.id = id;
-		this.data = new ContextMenuCommandBuilder();
-		this.data.setName(options.name);
-		this.data.setNameLocalizations(options.nameLocalizations || null);
-		this.data.setType(options.type === 'user' ? 2 : 3);
-		this.data.setDMPermission(options.permissions?.dm || null);
-		options = z
-			.object({
-				name: z.string(),
-				type: z.enum(['user', 'message']),
-				description: z.string().or(z.null()).default(null),
-				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),
-				ignore: z
-					.object({
-						owner: z.boolean().default(false),
-						users: z.array(z.string()).default([]),
-						channels: z.array(z.string()).default([]),
-						guilds: z.array(z.string()).default([]),
-					})
-					.default({}),
-				strict: z
-					.object({
-						owner: z.boolean().default(false),
-						users: z.array(z.string()).default([]),
-						channels: z.array(z.string()).default([]),
-						guilds: z.array(z.string()).default([]),
-					})
-					.default({}),
-				permissions: z
-					.object({
-						user: z.array(z.string()).default([]),
-						client: z.array(z.string()).default([]),
-						dm: z.boolean().default(true),
-					})
-					.default({}),
-				defer: z
-					.object({
-						reply: z.boolean().default(false),
-						ephemeral: z.boolean().default(false),
-						fetch: z.boolean().default(false),
-					})
-					.default({}),
-			})
-			.parse(options);
-		this.name = options.name;
-		this.type = options.type;
-		this.description = options.description;
-		this.usage = options.usage;
-		this.info = options.info;
-		this.category = options.category;
-		this.cooldown = options.cooldown;
-		this.ignore = options.ignore;
-		this.strict = options.strict;
-		this.permissions = options.permissions;
-		this.defer = options.defer;
-		this.client = this.client;
-	}
-	/**
-	 * @description the execution of the command
-	 * @param interaction - Interaction event emitted on command
-	 * @param args - The arguments parsed with the command, if any
-	 */
-	async exec(interaction, args) {
-		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);
-	}
+    constructor(id, options) {
+        this.id = id;
+        this.data = new ContextMenuCommandBuilder();
+        this.data.setName(options.name);
+        this.data.setNameLocalizations(options.nameLocalizations || null);
+        this.data.setType(options.type === 'user' ? 2 : 3);
+        this.data.setDMPermission(options.permissions?.dm || null);
+        options = z
+            .object({
+            name: z.string(),
+            type: z.enum(['user', 'message']),
+            description: z.string().or(z.null()).default(null),
+            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),
+            ignore: z
+                .object({
+                owner: z.boolean().default(false),
+                users: z.array(z.string()).default([]),
+                channels: z.array(z.string()).default([]),
+                guilds: z.array(z.string()).default([]),
+            })
+                .default({}),
+            strict: z
+                .object({
+                owner: z.boolean().default(false),
+                users: z.array(z.string()).default([]),
+                channels: z.array(z.string()).default([]),
+                guilds: z.array(z.string()).default([]),
+            })
+                .default({}),
+            permissions: z
+                .object({
+                user: z.array(z.string()).default([]),
+                client: z.array(z.string()).default([]),
+                dm: z.boolean().default(true),
+            })
+                .default({}),
+            defer: z
+                .object({
+                reply: z.boolean().default(false),
+                ephemeral: z.boolean().default(false),
+                fetch: z.boolean().default(false),
+            })
+                .default({}),
+        })
+            .parse(options);
+        this.name = options.name;
+        this.type = options.type;
+        this.description = options.description;
+        this.usage = options.usage;
+        this.info = options.info;
+        this.category = options.category;
+        this.cooldown = options.cooldown;
+        this.ignore = options.ignore;
+        this.strict = options.strict;
+        this.permissions = options.permissions;
+        this.defer = options.defer;
+        this.client = this.client;
+    }
+    /**
+     * @description the execution of the command
+     * @param interaction - Interaction event emitted on command
+     * @param args - The arguments parsed with the command, if any
+     */
+    async exec(interaction, args) {
+        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);
+    }
 }
-//# sourceMappingURL=XernerxContextCommand.js.map
+//# sourceMappingURL=XernerxContextCommand.js.map

package/dist/build/XernerxEvent.d.ts

@@ -8,19 +8,19 @@ import { XernerxClientType } from '../main.js';
  * @param {EventOptions} options - The event options.
  */
 export default class XernerxEvent {
-	readonly id: string;
-	readonly name: XernerxEventType | string;
-	readonly emitter?: 'client' | 'process' | string;
-	readonly type?: 'discord' | 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>;
+    readonly id: string;
+    readonly name: XernerxEventType | string;
+    readonly emitter?: 'client' | 'process' | string;
+    readonly type?: 'discord' | 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>;
 }
-//# sourceMappingURL=XernerxEvent.d.ts.map
+//# sourceMappingURL=XernerxEvent.d.ts.map

package/dist/build/XernerxEvent.js

@@ -7,26 +7,26 @@ import { XernerxLog } from '../main.js';
  * @param {EventOptions} options - The event options.
  */
 export default class XernerxEvent {
-	constructor(id, options) {
-		this.id = id;
-		z.object({
-			name: z.string(),
-			emitter: z.string().optional(),
-			type: z.string().optional(),
-			once: z.boolean().optional(),
-		}).parse(options);
-		this.name = options.name;
-		this.emitter = options.emitter || 'client';
-		this.type = options.type || 'discord';
-		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.`);
-	}
+    constructor(id, options) {
+        this.id = id;
+        z.object({
+            name: z.string(),
+            emitter: z.string().optional(),
+            type: z.string().optional(),
+            once: z.boolean().optional(),
+        }).parse(options);
+        this.name = options.name;
+        this.emitter = options.emitter || 'client';
+        this.type = options.type || 'discord';
+        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.`);
+    }
 }
-//# sourceMappingURL=XernerxEvent.js.map
+//# sourceMappingURL=XernerxEvent.js.map

package/dist/build/XernerxInhibitor.d.ts

@@ -8,29 +8,18 @@ import { XernerxClientType, XernerxMessage, XernerxMessageContextInteraction, Xe
  * @param {InhibitorOptions} options - The inhibitor options.
  */
 export default class XernerxInhibitor {
-	readonly id: string;
-	readonly name: string;
-	readonly type: InhibitorType;
-	readonly filetype: 'Inhibitor';
-	readonly filepath: string;
-	readonly client: XernerxClientType;
-	constructor(id: string, options: XernerxInhibitorOptions);
-	/**
-	 * @description The check rule
-	 * @param interaction - The interaction with the inhibitor, can be message and interaction
-	 * @param args - The arguments parsed with this command
-	 */
-	check<T extends XernerxMessage | XernerxInteraction<XernerxSlashInteraction | XernerxUserContextInteraction | XernerxMessageContextInteraction>>(
-		interaction: XernerxMessage | XernerxInteraction<XernerxSlashInteraction | XernerxUserContextInteraction | XernerxMessageContextInteraction>,
-		args:
-			| (T extends XernerxMessage
-					? MessageCommandArguments
-					: T extends XernerxSlashInteraction
-					? SlashCommandArguments
-					: T extends XernerxUserContextInteraction
-					? XernerxUserContextInteraction
-					: XernerxMessageContextInteraction)
-			| null
-	): Promise<any>;
+    readonly id: string;
+    readonly name: string;
+    readonly type: InhibitorType;
+    readonly filetype: 'Inhibitor';
+    readonly filepath: string;
+    readonly client: XernerxClientType;
+    constructor(id: string, options: XernerxInhibitorOptions);
+    /**
+     * @description The check rule
+     * @param interaction - The interaction with the inhibitor, can be message and interaction
+     * @param args - The arguments parsed with this command
+     */
+    check<T extends XernerxMessage | XernerxInteraction<XernerxSlashInteraction | XernerxUserContextInteraction | XernerxMessageContextInteraction>>(interaction: XernerxMessage | XernerxInteraction<XernerxSlashInteraction | XernerxUserContextInteraction | XernerxMessageContextInteraction>, args: (T extends XernerxMessage ? MessageCommandArguments : T extends XernerxSlashInteraction ? SlashCommandArguments : T extends XernerxUserContextInteraction ? XernerxUserContextInteraction : XernerxMessageContextInteraction) | null): Promise<any>;
 }
-//# sourceMappingURL=XernerxInhibitor.d.ts.map
+//# sourceMappingURL=XernerxInhibitor.d.ts.map

package/dist/build/XernerxInhibitor.js

@@ -7,24 +7,24 @@ import { XernerxLog } from '../main.js';
  * @param {InhibitorOptions} options - The inhibitor options.
  */
 export default class XernerxInhibitor {
-	constructor(id, options) {
-		this.id = id;
-		z.object({
-			name: z.string(),
-			type: z.string(),
-		}).parse(options);
-		this.name = options.name;
-		this.type = options.type;
-		this.client = this.client;
-	}
-	/**
-	 * @description The check rule
-	 * @param interaction - The interaction with the inhibitor, can be message and interaction
-	 * @param args - The arguments parsed with this command
-	 */
-	async check(interaction, args) {
-		new XernerxLog(this.client).error(`${this.id} doesn't have a check rule.`);
-		return await this.client.emit('commandError', interaction, `${this.name} doesn't have a check rule.`, this, this.filetype);
-	}
+    constructor(id, options) {
+        this.id = id;
+        z.object({
+            name: z.string(),
+            type: z.string(),
+        }).parse(options);
+        this.name = options.name;
+        this.type = options.type;
+        this.client = this.client;
+    }
+    /**
+     * @description The check rule
+     * @param interaction - The interaction with the inhibitor, can be message and interaction
+     * @param args - The arguments parsed with this command
+     */
+    async check(interaction, args) {
+        new XernerxLog(this.client).error(`${this.id} doesn't have a check rule.`);
+        return await this.client.emit('commandError', interaction, `${this.name} doesn't have a check rule.`, this, this.filetype);
+    }
 }
-//# sourceMappingURL=XernerxInhibitor.js.map
+//# sourceMappingURL=XernerxInhibitor.js.map

package/dist/build/XernerxMessageCommand.d.ts

@@ -2,57 +2,51 @@
 import { XernerxClientType, XernerxMessage } from '../types/extenders.js';
 import { MessageCommandArguments, MessageCommandOptions } from '../types/interfaces.js';
 export default class XernerxMessageCommand {
-	readonly id: string;
-	readonly name: string;
-	readonly aliases: string[] | undefined;
-	readonly regex: RegExp | undefined;
-	readonly prefix: string | string[] | undefined;
-	readonly description: string | null | undefined;
-	readonly usage: string | null | undefined;
-	readonly info: string | null | undefined;
-	readonly separator: string | undefined;
-	readonly args: import('../main.js').MessageCommandArgumentOptions[] | undefined;
-	readonly flags: import('../main.js').MessageCommandFlagOptions[] | undefined;
-	readonly category: string | null | undefined;
-	readonly cooldown: number | null | undefined;
-	readonly ignore:
-		| {
-				owner?: boolean | undefined;
-				users?: string[] | undefined;
-				channels?: string[] | undefined;
-				guilds?: string[] | undefined;
-		  }
-		| undefined;
-	readonly strict:
-		| {
-				owner?: boolean | undefined;
-				users?: string[] | undefined;
-				channels?: string[] | undefined;
-				guilds?: string[] | undefined;
-		  }
-		| undefined;
-	readonly permissions:
-		| {
-				user?: string[] | import('../main.js').PermissionNames[] | undefined;
-				client?: string[] | import('../main.js').PermissionNames[] | undefined;
-				dm?: boolean | undefined;
-		  }
-		| undefined;
-	readonly filetype: 'MessageCommand';
-	readonly filepath: string;
-	readonly client: XernerxClientType;
-	constructor(id: string, options: MessageCommandOptions);
-	/**
-	 * @description Checks for conditions before running the command
-	 * @param message - The message event emitted on this command
-	 * @param options - The args and flags parsed on this command
-	 */
-	conditions(message: XernerxMessage, { args, flags }: MessageCommandArguments): Promise<any>;
-	/**
-	 * @description Runs the execution rule
-	 * @param message - The message event emitted on this command
-	 * @param options - The args and flags parsed on this command
-	 */
-	exec(message: XernerxMessage, { args, flags }: MessageCommandArguments): Promise<any>;
+    readonly id: string;
+    readonly name: string;
+    readonly aliases: string[] | undefined;
+    readonly regex: RegExp | undefined;
+    readonly prefix: string | string[] | undefined;
+    readonly description: string | null | undefined;
+    readonly usage: string | null | undefined;
+    readonly info: string | null | undefined;
+    readonly separator: string | undefined;
+    readonly args: import("../main.js").MessageCommandArgumentOptions[] | undefined;
+    readonly flags: import("../main.js").MessageCommandFlagOptions[] | undefined;
+    readonly category: string | null | undefined;
+    readonly cooldown: number | null | undefined;
+    readonly ignore: {
+        owner?: boolean | undefined;
+        users?: string[] | undefined;
+        channels?: string[] | undefined;
+        guilds?: string[] | undefined;
+    } | undefined;
+    readonly strict: {
+        owner?: boolean | undefined;
+        users?: string[] | undefined;
+        channels?: string[] | undefined;
+        guilds?: string[] | undefined;
+    } | undefined;
+    readonly permissions: {
+        user?: string[] | import("../main.js").PermissionNames[] | undefined;
+        client?: string[] | import("../main.js").PermissionNames[] | undefined;
+        dm?: boolean | undefined;
+    } | undefined;
+    readonly filetype: 'MessageCommand';
+    readonly filepath: string;
+    readonly client: XernerxClientType;
+    constructor(id: string, options: MessageCommandOptions);
+    /**
+     * @description Checks for conditions before running the command
+     * @param message - The message event emitted on this command
+     * @param options - The args and flags parsed on this command
+     */
+    conditions(message: XernerxMessage, { args, flags }: MessageCommandArguments): Promise<any>;
+    /**
+     * @description Runs the execution rule
+     * @param message - The message event emitted on this command
+     * @param options - The args and flags parsed on this command
+     */
+    exec(message: XernerxMessage, { args, flags }: MessageCommandArguments): Promise<any>;
 }
-//# sourceMappingURL=XernerxMessageCommand.d.ts.map
+//# sourceMappingURL=XernerxMessageCommand.d.ts.map