xernerx 3.2.6 → 3.3.1

package/dist/build/XernerxExtension.js

@@ -0,0 +1,9 @@
+/**
+ * A class constructor you can use to make any extension work.
+ */
+export default class XernerxExtension {
+    name;
+    constructor(name) {
+        this.name = name;
+    }
+}

package/dist/client/XernerxClient.d.ts

@@ -1,6 +1,10 @@
-import { Client, Collection } from "discord.js";
-import { ClientUtil } from "../utils/ClientUtil.js";
-import { DiscordOptions, ClientOptions, Commands, Cache, Modules, HandlerOptions, ExtensionOptions } from "../interfaces/ClientInterfaces.js";
+import { Client, Collection } from 'discord.js';
+import { ClientUtil } from '../utils/ClientUtil.js';
+import { ClientOptions, DiscordOptions, ExtensionOptions, HandlerOptions } from '../types/options.js';
+import { ClientCache, ClientCommands, ClientModules } from '../types/interfaces.js';
+import EventBuilder from '../build/EventBuilder.js';
+import ExtensionBuilder from '../build/ExtensionBuilder.js';
+import InhibitorBuilder from '../build/InhibitorBuilder.js';
 /**
  * @description - The Client.
  * @param {DiscordOptions} discordOptions - The options for discord.js.
@@ -9,14 +13,14 @@ import { DiscordOptions, ClientOptions, Commands, Cache, Modules, HandlerOptions
  */
 export default class XernerxClient extends Client {
     settings: ClientOptions;
-    commands: Commands;
-    cache: Cache;
-    modules: Modules;
+    commands: ClientCommands;
+    cache: ClientCache;
+    modules: ClientModules;
     util: ClientUtil;
     handlerOptions: HandlerOptions;
-    events: Collection<string, object>;
-    extensions: Record<string, object>;
-    inhibitors: Collection<string, object>;
+    events: Collection<string, EventBuilder>;
+    extensions: Record<string, ExtensionBuilder>;
+    inhibitors: Collection<string, InhibitorBuilder>;
     config: object;
     constructor(discordOptions: DiscordOptions, clientOptions: ClientOptions, config?: object);
     register(token: string): void;

package/dist/client/XernerxClient.js

@@ -1,12 +1,11 @@
-import { Client, Collection } from "discord.js";
-import { s } from "@sapphire/shapeshift";
-import CommandHandler from "../handlers/CommandHandler.js";
-import EventHandler from "../handlers/EventHandler.js";
-import InhibitorHandler from "../handlers/InhibitorHandler.js";
-import { ClientUtil } from "../utils/ClientUtil.js";
-import { Style } from "dumfunctions";
-import WebhookHandler from "../handlers/WebhookHandler.js";
-import Extensions from "../models/Extensions.js";
+import { Client, Collection } from 'discord.js';
+import { s } from '@sapphire/shapeshift';
+import CommandHandler from '../handlers/CommandHandler.js';
+import EventHandler from '../handlers/EventHandler.js';
+import InhibitorHandler from '../handlers/InhibitorHandler.js';
+import { ClientUtil } from '../utils/ClientUtil.js';
+import { Style } from 'dumfunctions';
+import Extensions from '../models/Extensions.js';
 /**
  * @description - The Client.
  * @param {DiscordOptions} discordOptions - The options for discord.js.
@@ -59,15 +58,16 @@ export default class XernerxClient extends Client {
             commandHandler: new CommandHandler(this),
             eventHandler: new EventHandler(this),
             inhibitorHandler: new InhibitorHandler(this),
-            webhookHandler: new WebhookHandler(this),
         };
         this.extensions = {};
         this.util = new ClientUtil(this);
         this.handlerOptions = {};
         if (this.settings.logging) {
-            this.once("ready", async (client) => {
+            this.once('ready', async (client) => {
                 const size = (await client.guilds.fetch()).size;
-                console.info(Style.log(`Xernerx | ${client.user.tag} signed in watching ${size} server${size > 1 ? "s" : ""}. ${(this.handlerOptions.slash || this.handlerOptions.context)?.guildId ? `Using ${(await this.guilds.fetch((this.handlerOptions.slash || this.handlerOptions.context)?.guildId || "0")).name} as local guild.` : ""}`, { color: Style.TextColor.Purple }));
+                console.info(Style.log(`Xernerx | ${client.user.tag} signed in watching ${size} server${size > 1 ? 's' : ''}. ${(this.handlerOptions.slash || this.handlerOptions.context)?.guildId
+                    ? `Using ${(await this.guilds.fetch((this.handlerOptions.slash || this.handlerOptions.context)?.guildId || '0')).name} as local guild.`
+                    : ''}`, { color: Style.TextColor.Purple }));
             });
         }
         this.register = this.register;

package/dist/handlers/CommandHandler.d.ts

@@ -1,6 +1,6 @@
-import { ContextCommandOptions, SlashCommandOptions, MessageCommandOptions } from "../interfaces/HandlerInterfaces.js";
 import XernerxClient from "../client/XernerxClient.js";
 import { Handler } from "./Handler.js";
+import { ContextCommandHandlerOptions, MessageCommandHandlerOptions, SlashCommandHandlerOptions } from "../types/options.js";
 /**
  * @description - The command handler.
  * @param {XernerxClient} client - The XernerxClient.
@@ -13,15 +13,15 @@ export default class CommandHandler {
      * @description - The message command loader.
      * @param {MessageCommandOptions} options - message command loader options.
      */
-    loadAllMessageCommands(options: MessageCommandOptions): void;
+    loadAllMessageCommands(options: MessageCommandHandlerOptions): void;
     /**
      * @description - The slash command loader.
      * @param {SlashCommandOptions} options - slash command loader options.
      */
-    loadAllSlashCommands(options: SlashCommandOptions): void;
+    loadAllSlashCommands(options: SlashCommandHandlerOptions): void;
     /**
      * @description - The context command loader.
      * @param {ContextCommandOptions} options - context command loader options.
      */
-    loadAllContextCommands(options: ContextCommandOptions): void;
+    loadAllContextCommands(options: ContextCommandHandlerOptions): void;
 }

package/dist/handlers/EventHandler.d.ts

@@ -1,5 +1,5 @@
-import { EventLoadOptions } from "../interfaces/HandlerInterfaces.js";
 import XernerxClient from "../client/XernerxClient.js";
+import { EventHandlerOptions } from "../types/options.js";
 import { Handler } from "./Handler.js";
 export default class EventHandler {
     client: XernerxClient;
@@ -9,5 +9,5 @@ export default class EventHandler {
      * @description - The event loader
      * @param {EventLoadOptions} options - message command options
      */
-    loadAllEvents(options: EventLoadOptions): void;
+    loadAllEvents(options: EventHandlerOptions): void;
 }

package/dist/handlers/Handler.d.ts

@@ -1,5 +1,5 @@
 import XernerxClient from "../client/XernerxClient.js";
-import { ContextCommandOptions, MessageCommandOptions, SlashCommandOptions, EventLoadOptions, InhibitorLoadOptions } from "../interfaces/HandlerInterfaces.js";
+import { ContextCommandHandlerOptions, EventHandlerOptions, InhibitorHandlerOptions, MessageCommandHandlerOptions, SlashCommandHandlerOptions } from "../types/options.js";
 /**
  * @description - The Handler class.
  * @param {XernerxClient} client - The XernerxClient.
@@ -14,25 +14,25 @@ export declare class Handler {
      * @description - The loader for the message commands.
      * @param {MessageCommandOptions} options - The options for the message command loader.
      */
-    loadAllMessageCommands(options: MessageCommandOptions): void;
+    loadAllMessageCommands(options: MessageCommandHandlerOptions): void;
     /**
      * @description - The loader for the slash commands.
      * @param {SlashCommandOptions} options - The options for the slash command loader.
      */
-    loadAllSlashCommands(options: SlashCommandOptions): void;
+    loadAllSlashCommands(options: SlashCommandHandlerOptions): void;
     /**
      * @description - The loader for the context commands.
      * @param {ContextCommandOptions} options - The options for the context command loader.
      */
-    loadAllContextCommands(options: ContextCommandOptions): void;
+    loadAllContextCommands(options: ContextCommandHandlerOptions): void;
     /**
      * @description - The loader for the events.
      * @param {EventLoadOptions} options - The options for the event loader.
      */
-    loadAllEvents(options: EventLoadOptions): void;
+    loadAllEvents(options: EventHandlerOptions): void;
     /**
      * @description - The loader for the inhibitors.
      * @param {InhibitorLoadOptions} options - The options for the inhibitor loader.
      */
-    loadAllInhibitors(options: InhibitorLoadOptions): void;
+    loadAllInhibitors(options: InhibitorHandlerOptions): void;
 }

package/dist/handlers/Handler.js

@@ -1,6 +1,6 @@
 import fs from "node:fs";
 import * as path from "path";
-import { CommandType } from "../types/Types.js";
+import { CommandType } from "../types/enums.js";
 import { s } from "@sapphire/shapeshift";
 import { Style } from 'dumfunctions';
 /**

package/dist/handlers/InhibitorHandler.d.ts

@@ -1,6 +1,6 @@
-import { InhibitorLoadOptions } from "../interfaces/HandlerInterfaces.js";
-import XernerxClient from "../client/XernerxClient.js";
-import { Handler } from "./Handler.js";
+import XernerxClient from '../client/XernerxClient.js';
+import { InhibitorHandlerOptions } from '../types/options.js';
+import { Handler } from './Handler.js';
 /**
  * @description - Inhibitor loader.
  * @param {XernerxClient} client - The XernerxClient.
@@ -14,5 +14,5 @@ export default class InhibitorHandler {
      * @param {InhibitorLoadOptions} options - the inhibitor loader options.
      * @returns undefined
      */
-    loadAllInhibitors(options: InhibitorLoadOptions): void;
+    loadAllInhibitors(options: InhibitorHandlerOptions): void;
 }

package/dist/handlers/InhibitorHandler.js

@@ -1,4 +1,4 @@
-import { Handler } from "./Handler.js";
+import { Handler } from './Handler.js';
 /**
  * @description - Inhibitor loader.
  * @param {XernerxClient} client - The XernerxClient.

package/dist/interfaces/ClientInterfaces.d.ts

@@ -3,8 +3,10 @@ import CommandHandler from "../handlers/CommandHandler.js";
 import EventHandler from "../handlers/EventHandler.js";
 import InhibitorHandler from "../handlers/InhibitorHandler.js";
 import { ContextCommandOptions, MessageCommandOptions, SlashCommandOptions, EventLoadOptions, InhibitorLoadOptions } from "./HandlerInterfaces.js";
-import { MessageCommand } from "../build/MessageCommand.js";
-import WebhookHandler from "../handlers/WebhookHandler.js";
+import MessageCommandBuilder from "../build/MessageCommandBuilder.js";
+import ContextCommandBuilder from "../build/ContextCommandBuilder.js";
+import SlashCommandBuilder from "../build/SlashCommandBuilder.js";
+import ExtensionBuilder from "../build/ExtensionBuilder.js";
 export interface DiscordOptions {
     shards?: number | number[] | "auto";
     closeTimeout?: number;
@@ -40,9 +42,9 @@ export interface HandlerOptions {
     inhibitors?: InhibitorLoadOptions;
 }
 export interface Commands {
-    message: Collection<string, MessageCommand>;
-    slash: Collection<string, object>;
-    context: Collection<string, object>;
+    message: Collection<string, MessageCommandBuilder>;
+    slash: Collection<string, SlashCommandBuilder>;
+    context: Collection<string, ContextCommandBuilder>;
 }
 export interface Cache {
     messages: Collection<string, object>;
@@ -56,9 +58,8 @@ export interface Modules {
     commandHandler: CommandHandler;
     eventHandler: EventHandler;
     inhibitorHandler: InhibitorHandler;
-    webhookHandler: WebhookHandler;
 }
 export interface ExtensionOptions {
-    extensions: Array<any>;
+    extensions: Array<ExtensionBuilder>;
     logging?: boolean;
 }

package/dist/interfaces/CommandInterfaces.d.ts

@@ -1,5 +1,5 @@
 import { ChannelType, ContextMenuCommandType } from "discord.js";
-import { ContextCommandType } from "../types/Types.js";
+import { ContextCommandType } from "../types/enums.js";
 export interface MessageCommandOptions {
     name: string;
     regex?: string;

package/dist/interfaces/HandlerInterfaces.d.ts

@@ -1,6 +1,4 @@
-import { Message, User } from "discord.js";
-import { EventEmitterType } from "../types/Types.js";
-import { MessageCommandUtil } from "../utils/CommandUtil.js";
+import { EventEmitterType, InhibitorType } from "../types/enums.js";
 export interface MessageCommandOptions {
     directory: string;
     prefix: string[] | string;
@@ -60,12 +58,5 @@ export interface InhibitorLoadOptions {
 }
 export interface InhibitorOptions {
     name: string;
-    type: string;
-}
-export interface XernerxMessage extends Message {
-    util?: MessageCommandUtil;
-    response?: string;
-}
-export interface XernerxUser extends User {
-    isOwner: boolean;
+    type: InhibitorType;
 }

package/dist/main.d.ts

@@ -1,13 +1,14 @@
-import Discord from "discord.js";
-import DumFunctions from "dumfunctions";
-import XernerxClient from "./client/XernerxClient.js";
-import { Event } from "./build/Event.js";
-import { Inhibitor } from "./build/Inhibitor.js";
-import { MessageCommand } from "./build/MessageCommand.js";
-import { ContextCommand } from "./build/ContextCommand.js";
-import { SlashCommand } from "./build/SlashCommand.js";
-import { CommandType, EventEmitterType, ContextCommandType } from "./types/Types.js";
-import { InhibitorType } from "./types/InhibitorTypes.js";
+import Discord from 'discord.js';
+import DumFunctions from 'dumfunctions';
+import XernerxClient from './client/XernerxClient.js';
+import EventBuilder from './build/EventBuilder.js';
+import InhibitorBuilder from './build/InhibitorBuilder.js';
+import MessageCommandBuilder from './build/MessageCommandBuilder.js';
+import ContextCommandBuilder from './build/ContextCommandBuilder.js';
+import SlashCommandBuilder from './build/SlashCommandBuilder.js';
+import { CommandType, EventEmitterType, ContextCommandType, InhibitorType } from './types/enums.js';
+import XernerxError from './tools/XernerxError.js';
+import ExtensionBuilder from './build/ExtensionBuilder.js';
 declare const version: string;
 declare const _default: {
     Discord: typeof Discord;
@@ -82,12 +83,14 @@ declare const _default: {
     EventEmitterType: typeof EventEmitterType;
     InhibitorType: typeof InhibitorType;
     ContextCommandType: typeof ContextCommandType;
-    Event: typeof Event;
-    MessageCommand: typeof MessageCommand;
-    ContextCommand: typeof ContextCommand;
-    SlashCommand: typeof SlashCommand;
-    Inhibitor: typeof Inhibitor;
+    EventBuilder: typeof EventBuilder;
+    MessageCommandBuilder: typeof MessageCommandBuilder;
+    ContextCommandBuilder: typeof ContextCommandBuilder;
+    SlashCommandBuilder: typeof SlashCommandBuilder;
+    InhibitorBuilder: typeof InhibitorBuilder;
+    ExtensionBuilder: typeof ExtensionBuilder;
+    XernerxError: typeof XernerxError;
     version: string;
 };
 export default _default;
-export { Discord, DumFunctions, XernerxClient, CommandType, EventEmitterType, InhibitorType, ContextCommandType, Event, MessageCommand, ContextCommand, SlashCommand, Inhibitor, version, };
+export { Discord, DumFunctions, XernerxClient, CommandType, EventEmitterType, InhibitorType, ContextCommandType, EventBuilder, MessageCommandBuilder, ContextCommandBuilder, SlashCommandBuilder, InhibitorBuilder, ExtensionBuilder, XernerxError, version, };

package/dist/main.js

@@ -1,14 +1,15 @@
-import Discord from "discord.js";
-import DumFunctions from "dumfunctions";
-import XernerxClient from "./client/XernerxClient.js";
-import { Event } from "./build/Event.js";
-import { Inhibitor } from "./build/Inhibitor.js";
-import { MessageCommand } from "./build/MessageCommand.js";
-import { ContextCommand } from "./build/ContextCommand.js";
-import { SlashCommand } from "./build/SlashCommand.js";
-import { CommandType, EventEmitterType, ContextCommandType } from "./types/Types.js";
-import { InhibitorType } from "./types/InhibitorTypes.js";
-import pkg from "../package.js";
+import Discord from 'discord.js';
+import DumFunctions from 'dumfunctions';
+import XernerxClient from './client/XernerxClient.js';
+import EventBuilder from './build/EventBuilder.js';
+import InhibitorBuilder from './build/InhibitorBuilder.js';
+import MessageCommandBuilder from './build/MessageCommandBuilder.js';
+import ContextCommandBuilder from './build/ContextCommandBuilder.js';
+import SlashCommandBuilder from './build/SlashCommandBuilder.js';
+import { CommandType, EventEmitterType, ContextCommandType, InhibitorType } from './types/enums.js';
+import XernerxError from './tools/XernerxError.js';
+import ExtensionBuilder from './build/ExtensionBuilder.js';
+import pkg from '../package.js';
 const version = pkg.version;
 export default {
     // Imported methods
@@ -17,17 +18,19 @@ export default {
     // Client
     Client: XernerxClient,
     XernerxClient,
-    // Types
+    // Enums
     CommandType,
     EventEmitterType,
     InhibitorType,
     ContextCommandType,
     // Builds
-    Event,
-    MessageCommand,
-    ContextCommand,
-    SlashCommand,
-    Inhibitor,
+    EventBuilder,
+    MessageCommandBuilder,
+    ContextCommandBuilder,
+    SlashCommandBuilder,
+    InhibitorBuilder,
+    ExtensionBuilder,
+    XernerxError,
     // Constants
     version,
 };
@@ -36,9 +39,9 @@ export {
 Discord, DumFunctions, 
 // Client
 XernerxClient, 
-// Types
+// Enums
 CommandType, EventEmitterType, InhibitorType, ContextCommandType, 
 // Builds
-Event, MessageCommand, ContextCommand, SlashCommand, Inhibitor, 
+EventBuilder, MessageCommandBuilder, ContextCommandBuilder, SlashCommandBuilder, InhibitorBuilder, ExtensionBuilder, XernerxError, 
 // Constants
 version, };

package/dist/models/CommandArguments.d.ts

@@ -1,9 +1,17 @@
-import { Interaction, Message } from "discord.js";
-export declare class CommandArguments {
-    action: any;
-    constructor(action: Message | Interaction);
-    group(): any;
-    subcommand(): any;
+import { MessageCommandBuilder } from '../main.js';
+import { XernerxInteraction, XernerxMessage } from '../types/types.js';
+export declare class InteractionArguments {
+    interaction: XernerxInteraction;
+    constructor(interaction: XernerxInteraction);
+    group(): string | undefined;
+    subcommand(): string | undefined;
     arguments(): Record<string, object>;
 }
-export declare function messageArgs(message: any, command: any): Promise<any>;
+interface Flag {
+    flags: Record<string, string | boolean>;
+}
+interface Argument {
+    [index: string]: string | number | null;
+}
+export declare function messageArguments(message: XernerxMessage, command: MessageCommandBuilder): Promise<import("discord.js").Message<boolean> | Flag | Argument | undefined>;
+export {};

package/dist/models/CommandArguments.js

@@ -1,35 +1,35 @@
-export class CommandArguments {
-    action;
-    constructor(action) {
-        this.action = action;
+export class InteractionArguments {
+    interaction;
+    constructor(interaction) {
+        this.interaction = interaction;
     }
     group() {
-        return this.action?.options?._group;
+        return this.interaction?.options?._group;
     }
     subcommand() {
-        return this.action?.options?._subcommand;
+        return this.interaction?.options?._subcommand;
     }
     arguments() {
         const options = {};
-        if (this.action?.options?._hoistedOptions) {
-            for (const option of this.action.options._hoistedOptions) {
-                options[option.name] =
-                    option.channel || option.user || option.role || option.value;
+        if (this.interaction?.options?._hoistedOptions) {
+            for (const option of this.interaction.options._hoistedOptions) {
+                options[option.name] = option.channel || option.user || option.role || option.value;
             }
         }
         return options;
     }
 }
-export async function messageArgs(message, command) {
-    let args = { flags: {} }, separator = command.separator || " ", i = 0;
+export async function messageArguments(message, command) {
+    let args = { flags: {} }, separator = command.separator || ' ', i = 0;
     if (!command.args)
         return;
     command.args
-        .filter((c) => c.type == "flag")
+        .filter((c) => c.type == 'flag')
         .map((flag) => {
+        args = args;
         for (const flg of message.content.matchAll(flag.content)) {
             if (flag.content == flg) {
-                message.content = message.content.replace(flag.content, "");
+                message.content = message.content.replace(flag.content, '');
                 args.flags[flag.name] = true;
             }
         }
@@ -37,92 +37,85 @@ export async function messageArgs(message, command) {
             args.flags[flag.name] = false;
     });
     for (const argument of command.args) {
+        args = args;
         let content = message.content
             .split(/ +/)
             .slice(1)
             .join(separator)
-            .replace(new RegExp(`${separator}${separator}+`, "g"), separator)
+            .replace(new RegExp(`${separator}${separator}+`, 'g'), separator)
             .split(separator)
             .slice(i);
-        if (content.join(separator) != "" && argument.type !== "flag") {
+        if (content.join(separator) != '' && argument.type !== 'flag') {
             if (argument?.content?.includes(content[0])) {
                 args[argument.name] = content[0];
             }
-            else if (argument.type == "string") {
+            else if (argument.type == 'string') {
                 args[argument.name] = content[0];
             }
-            else if (argument.type == "number") {
+            else if (argument.type == 'number') {
                 args[argument.name] = parseInt(content[0]);
             }
-            else if (argument.type == "boolean") {
-                if (content[0]?.toLowerCase() != "true" &&
-                    content[0]?.toLowerCase() != "false")
-                    content[0] = undefined;
+            else if (argument.type == 'boolean') {
+                if (content[0]?.toLowerCase() != 'true' && content[0]?.toLowerCase() != 'false')
+                    content[0] = null;
                 args[argument.name] = content[0];
             }
-            else if (argument.type == "user") {
-                let user = message.client.users.cache.find((u) => u?.username?.toLowerCase()?.includes(content[0]));
+            else if (argument.type == 'user') {
+                let user = message.client.users.cache.find((u) => u?.username?.toLowerCase()?.includes(content[0])) || null;
                 try {
-                    user = await message.client.users.fetch(user?.id || content[0].replace(/<@!?|>/g, ""));
+                    user = (await message.client.users.fetch(user?.id || content[0].replace(/<@!?|>/g, ''))) || null;
                 }
                 catch (e) {
-                    user = new Error("Invalid user snowflake ID");
+                    user = null;
                 }
                 args[argument.name] = user;
             }
-            else if (argument.type == "role") {
-                let role = message.guild.roles.cache.find((r) => r?.name?.toLowerCase()?.includes(content[0]));
+            else if (argument.type == 'role') {
+                let role = message.guild?.roles.cache.find((r) => r?.name?.toLowerCase()?.includes(content[0])) || null;
                 try {
-                    role = await message.guild.roles.fetch(role?.id || content[0].replace(/<@&?|>/g, ""));
+                    role = (await message.guild?.roles.fetch(role?.id || content[0].replace(/<@&?|>/g, ''))) || null;
                 }
                 catch (e) {
-                    role = new Error("Invalid role snowflake ID");
+                    role = null;
                 }
                 args[argument.name] = role;
             }
-            else if (argument.type == "member") {
-                let member = message.guild.members.cache.find((m) => m?.nickname?.toLowerCase()?.includes(content[0]) ||
-                    m?.user?.username?.toLowerCase()?.includes(content[0]));
+            else if (argument.type == 'member') {
+                let member = message.guild?.members.cache.find((m) => m?.nickname?.toLowerCase()?.includes(content[0]) || m?.user?.username?.toLowerCase()?.includes(content[0])) || null;
                 try {
-                    member = await message.guild.members.fetch(member?.id || content[0].replace(/<@!?|>/g, ""));
+                    member = (await message.guild?.members.fetch(member?.id || content[0].replace(/<@!?|>/g, ''))) || null;
                 }
                 catch (e) {
-                    member = new Error("Invalid member snowflake ID");
+                    member = null;
                 }
                 args[argument.name] = member;
             }
-            else if (argument.type == "channel") {
-                let channel = message.guild.channels.cache.find((c) => c?.name?.toLowerCase()?.includes(content[0]));
+            else if (argument.type == 'channel') {
+                let channel = message.guild?.channels.cache.find((c) => c?.name?.toLowerCase()?.includes(content[0]));
                 try {
-                    channel = await message.client.channels.fetch(channel?.id || content[0].replace(/<#|>/g, ""));
+                    channel = await message.client.channels.fetch(channel?.id || content[0].replace(/<#|>/g, ''));
                 }
                 catch (e) {
-                    channel = new Error("Invalid channel snowflake ID");
+                    channel = null;
                 }
                 args[argument.name] = channel;
             }
-            else if (argument.type == "rest") {
+            else if (argument.type == 'rest') {
                 args[argument.name] = content.join(separator);
                 break;
             }
             else if (argument.prompt) {
                 if (argument.prompt.reply)
-                    return message.reply(argument.prompt.reply);
+                    return message.util?.reply(argument.prompt.reply);
                 else if (argument.prompt.send)
                     return message.channel.send(argument.prompt.send);
             }
             else
-                args[argument.name] =
-                    typeof argument.default == "function"
-                        ? argument.default(message)
-                        : argument.default;
+                args[argument.name] = typeof argument.default == 'function' ? argument.default(message) : argument.default;
             i++;
         }
         else
-            args[argument.name] =
-                typeof argument.default == "function"
-                    ? argument.default(message)
-                    : argument.default;
+            args[argument.name] = typeof argument.default == 'function' ? argument.default(message) : argument.default;
     }
     return args;
 }

package/dist/models/CommandValidations.d.ts

@@ -1,3 +1,4 @@
-import { Interaction, Message } from "discord.js";
-import { XernerxClient, SlashCommand, MessageCommand, ContextCommand } from "../main.js";
-export default function commandValidation(action: Message | Interaction, command: SlashCommand | MessageCommand | ContextCommand | any, client: XernerxClient, res?: boolean): boolean;
+import { Interaction } from "discord.js";
+import { ContextCommandBuilder, MessageCommandBuilder, SlashCommandBuilder, XernerxClient } from "../main.js";
+import { XernerxMessage } from "../types/types.js";
+export default function commandValidation(action: XernerxMessage | Interaction, command: SlashCommandBuilder | MessageCommandBuilder | ContextCommandBuilder | any, client: XernerxClient, res?: boolean): boolean;