xernerx 4.5.5 → 4.5.7

package/dist/build/XernerxContextCommand.d.ts

@@ -1,51 +1,53 @@
+/** @format */
+
 import { ContextMenuCommandBuilder } from 'discord.js';
 import XernerxClient from '../client/XernerxClient.js';
 import { XernerxMessageContextInteraction, XernerxUserContextInteraction } 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: typeof XernerxClient;
-    constructor(id: string, options: ContextCommandOptions);
-    exec<T>(interaction: XernerxUserContextInteraction | XernerxMessageContextInteraction, args: ContextCommandArguments<'user' | 'message'>): Promise<void | any | T>;
+	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: typeof XernerxClient;
+	constructor(id: string, options: ContextCommandOptions);
+	exec<T>(interaction: XernerxUserContextInteraction | XernerxMessageContextInteraction, args: ContextCommandArguments<'user' | 'message'>): Promise<void | any | T>;
 }
 //# sourceMappingURL=XernerxContextCommand.d.ts.map

package/dist/build/XernerxContextCommand.js

@@ -1,68 +1,70 @@
+/** @format */
+
 import { ContextMenuCommandBuilder } from 'discord.js';
 import { z } from 'zod';
 import XernerxClient from '../client/XernerxClient.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 = XernerxClient;
-    }
-    async exec(interaction, args) {}
+	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 = XernerxClient;
+	}
+	async exec(interaction, args) {}
 }
 //# sourceMappingURL=XernerxContextCommand.js.map

package/dist/build/XernerxEvent.d.ts

@@ -1,3 +1,5 @@
+/** @format */
+
 import XernerxClient from '../client/XernerxClient.js';
 import { XernerxEventOptions } from '../types/interfaces.js';
 import { XernerxEventType } from '../types/types.js';
@@ -7,19 +9,19 @@ import { XernerxEventType } from '../types/types.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: typeof XernerxClient;
-    constructor(id: string, options: XernerxEventOptions);
-    /**
-     * @description run your custom event here.
-     * TODO - update description
-     */
-    run(...args: any): Promise<void>;
+	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: typeof XernerxClient;
+	constructor(id: string, options: XernerxEventOptions);
+	/**
+	 * @description run your custom event here.
+	 * TODO - update description
+	 */
+	run(...args: any): Promise<void>;
 }
 //# sourceMappingURL=XernerxEvent.d.ts.map

package/dist/build/XernerxEvent.js

@@ -1,3 +1,5 @@
+/** @format */
+
 import { z } from 'zod';
 import XernerxClient from '../client/XernerxClient.js';
 /**
@@ -6,24 +8,24 @@ import XernerxClient from '../client/XernerxClient.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 = XernerxClient;
-    }
-    /**
-     * @description run your custom event here.
-     * TODO - update description
-     */
-    async run(...args) {}
+	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 = XernerxClient;
+	}
+	/**
+	 * @description run your custom event here.
+	 * TODO - update description
+	 */
+	async run(...args) {}
 }
 //# sourceMappingURL=XernerxEvent.js.map

package/dist/build/XernerxInhibitor.d.ts

@@ -1,3 +1,5 @@
+/** @format */
+
 import XernerxClient from '../client/XernerxClient.js';
 import { XernerxInhibitorOptions, MessageCommandArguments, SlashCommandArguments } from '../types/interfaces.js';
 import { InhibitorType, XernerxInteraction } from '../types/types.js';
@@ -8,22 +10,22 @@ import { XernerxMessage, XernerxMessageContextInteraction, XernerxSlashInteracti
  * @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: typeof XernerxClient;
-    constructor(id: string, options: XernerxInhibitorOptions);
-    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<void | any | T>;
+	readonly id: string;
+	readonly name: string;
+	readonly type: InhibitorType;
+	readonly fileType: 'Inhibitor';
+	readonly filePath: string;
+	readonly client: typeof XernerxClient;
+	constructor(id: string, options: XernerxInhibitorOptions);
+	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<void | any | T>;
 }
 //# sourceMappingURL=XernerxInhibitor.d.ts.map

package/dist/build/XernerxInhibitor.js

@@ -1,3 +1,5 @@
+/** @format */
+
 import { z } from 'zod';
 import XernerxClient from '../client/XernerxClient.js';
 /**
@@ -6,16 +8,16 @@ import XernerxClient from '../client/XernerxClient.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 = XernerxClient;
-    }
-    async check(interaction, args) {}
+	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 = XernerxClient;
+	}
+	async check(interaction, args) {}
 }
 //# sourceMappingURL=XernerxInhibitor.js.map

package/dist/build/XernerxMessageCommand.d.ts

@@ -1,48 +1,50 @@
+/** @format */
+
 import XernerxClient from '../client/XernerxClient.js';
 import { 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('../types/interfaces.js').MessageCommandArgumentOptions[] | undefined;
-    readonly flags: import('../types/interfaces.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: typeof XernerxClient;
-    constructor(id: string, options: MessageCommandOptions);
-    conditions<T>(message: XernerxMessage, { args, flags }: MessageCommandArguments): Promise<void | any | T>;
-    exec<T>(message: XernerxMessage, { args, flags }: MessageCommandArguments): Promise<void | any | T>;
+	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('../types/interfaces.js').MessageCommandArgumentOptions[] | undefined;
+	readonly flags: import('../types/interfaces.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: typeof XernerxClient;
+	constructor(id: string, options: MessageCommandOptions);
+	conditions<T>(message: XernerxMessage, { args, flags }: MessageCommandArguments): Promise<void | any | T>;
+	exec<T>(message: XernerxMessage, { args, flags }: MessageCommandArguments): Promise<void | any | T>;
 }
 //# sourceMappingURL=XernerxMessageCommand.d.ts.map

package/dist/build/XernerxMessageCommand.js

@@ -1,61 +1,63 @@
+/** @format */
+
 import { z } from 'zod';
 import XernerxClient from '../client/XernerxClient.js';
 export default class XernerxMessageCommand {
-    constructor(id, options) {
-        this.id = id;
-        this.regex = options.regex;
-        this.args = options.args;
-        this.flags = options.flags;
-        options = z
-            .object({
-                name: z.string(),
-                aliases: z.array(z.string()).default([]),
-                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),
-                prefix: z.array(z.string()).or(z.string()).default([]),
-                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({}),
-            })
-            .parse(options);
-        this.name = options.name;
-        this.aliases = options.aliases;
-        this.prefix = options.prefix;
-        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.separator = options.separator;
-        this.permissions = options.permissions;
-        this.client = XernerxClient;
-    }
-    async conditions(message, { args, flags }) {}
-    async exec(message, { args, flags }) {}
+	constructor(id, options) {
+		this.id = id;
+		this.regex = options.regex;
+		this.args = options.args;
+		this.flags = options.flags;
+		options = z
+			.object({
+				name: z.string(),
+				aliases: z.array(z.string()).default([]),
+				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),
+				prefix: z.array(z.string()).or(z.string()).default([]),
+				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({}),
+			})
+			.parse(options);
+		this.name = options.name;
+		this.aliases = options.aliases;
+		this.prefix = options.prefix;
+		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.separator = options.separator;
+		this.permissions = options.permissions;
+		this.client = XernerxClient;
+	}
+	async conditions(message, { args, flags }) {}
+	async exec(message, { args, flags }) {}
 }
 //# sourceMappingURL=XernerxMessageCommand.js.map