xernerx 3.2.6 → 3.3.0

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 { 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

@@ -5,7 +5,6 @@ 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";
 /**
  * @description - The Client.
@@ -59,7 +58,6 @@ 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);

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,5 +1,5 @@
-import { InhibitorLoadOptions } from "../interfaces/HandlerInterfaces.js";
 import XernerxClient from "../client/XernerxClient.js";
+import { InhibitorHandlerOptions } from "../types/options.js";
 import { Handler } from "./Handler.js";
 /**
  * @description - Inhibitor loader.
@@ -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/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,13 @@
 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 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 ExtensionBuilder from "./build/ExtensionBuilder.js";
 declare const version: string;
 declare const _default: {
     Discord: typeof Discord;
@@ -82,12 +82,13 @@ 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;
     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, version, };

package/dist/main.js

@@ -1,13 +1,13 @@
 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 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 ExtensionBuilder from "./build/ExtensionBuilder.js";
 import pkg from "../package.js";
 const version = pkg.version;
 export default {
@@ -17,17 +17,18 @@ export default {
     // Client
     Client: XernerxClient,
     XernerxClient,
-    // Types
+    // Enums
     CommandType,
     EventEmitterType,
     InhibitorType,
     ContextCommandType,
     // Builds
-    Event,
-    MessageCommand,
-    ContextCommand,
-    SlashCommand,
-    Inhibitor,
+    EventBuilder,
+    MessageCommandBuilder,
+    ContextCommandBuilder,
+    SlashCommandBuilder,
+    InhibitorBuilder,
+    ExtensionBuilder,
     // Constants
     version,
 };
@@ -36,9 +37,9 @@ export {
 Discord, DumFunctions, 
 // Client
 XernerxClient, 
-// Types
+// Enums
 CommandType, EventEmitterType, InhibitorType, ContextCommandType, 
 // Builds
-Event, MessageCommand, ContextCommand, SlashCommand, Inhibitor, 
+EventBuilder, MessageCommandBuilder, ContextCommandBuilder, SlashCommandBuilder, InhibitorBuilder, ExtensionBuilder, 
 // 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,18 +1,18 @@
-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) {
+        if (this.interaction?.options?._hoistedOptions) {
+            for (const option of this.interaction.options._hoistedOptions) {
                 options[option.name] =
                     option.channel || option.user || option.role || option.value;
             }
@@ -20,13 +20,14 @@ export class CommandArguments {
         return options;
     }
 }
-export async function messageArgs(message, command) {
+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")
         .map((flag) => {
+        args = args;
         for (const flg of message.content.matchAll(flag.content)) {
             if (flag.content == flg) {
                 message.content = message.content.replace(flag.content, "");
@@ -37,6 +38,7 @@ 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)
@@ -55,49 +57,47 @@ export async function messageArgs(message, command) {
                 args[argument.name] = parseInt(content[0]);
             }
             else if (argument.type == "boolean") {
-                if (content[0]?.toLowerCase() != "true" &&
-                    content[0]?.toLowerCase() != "false")
-                    content[0] = undefined;
+                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]));
+                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]));
+                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]));
+                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]));
+                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, ""));
                 }
                 catch (e) {
-                    channel = new Error("Invalid channel snowflake ID");
+                    channel = null;
                 }
                 args[argument.name] = channel;
             }
@@ -107,22 +107,16 @@ export async function messageArgs(message, command) {
             }
             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;

package/dist/models/CommandValidations.js

@@ -1,5 +1,5 @@
 import { Message } from "discord.js";
-import { CommandType } from "../types/Types.js";
+import { CommandType } from "../types/enums.js";
 function getUser(from) {
     if (from instanceof Message)
         return from.author;
@@ -8,8 +8,7 @@ function getUser(from) {
 }
 export default function commandValidation(action, command, client, res = false) {
     let user = getUser(action);
-    if ((command.ignoreOwner || client.settings.ignoreOwner) &&
-        client.util.isOwner(user.id))
+    if ((command.ignoreOwner || client.settings.ignoreOwner) && client.util.isOwner(user.id))
         return res;
     else if (inCooldown(user, client, command, action))
         return true;
@@ -25,20 +24,16 @@ export default function commandValidation(action, command, client, res = false)
             emit(client, action, command, "Not the correct channel", command.channelType);
         }
     }
-    else if (command.channels?.length > 0 &&
-        !command.channels.includes(action.channel?.id)) {
+    else if (command.channels?.length > 0 && !command.channels.includes(action.channel?.id)) {
         res = true;
         emit(client, action, command, "Not a whitelisted channel", command.channels);
     }
-    else if (command.guilds?.length > 0 &&
-        !command.guilds.includes(action.guild?.id)) {
+    else if (command.guilds?.length > 0 && !command.guilds.includes(action.guild?.id)) {
         res = true;
         emit(client, action, command, "Not a whitelisted guild", command.guilds);
     }
-    else if (action?.guild &&
-        (command.userPermissions || client.settings.userPermissions)) {
-        const permissions = command.userPermissions ||
-            client?.settings?.userPermissions?.push(...handlerPermissions(client, command.commandType, "user")), missing = [];
+    else if (action?.guild && (command.userPermissions || client.settings.userPermissions)) {
+        const permissions = command.userPermissions || client?.settings?.userPermissions?.push(...handlerPermissions(client, command.commandType, "user")), missing = [];
         if (Array.isArray(permissions))
             permissions.map((permission) => {
                 if (!(action.member?.permissions).has(permission)) {
@@ -50,10 +45,8 @@ export default function commandValidation(action, command, client, res = false)
             emit(client, action, command, "Missing User Permissions", missing);
         }
     }
-    else if (action?.guild &&
-        (command.clientPermissions || client.settings.clientPermissions)) {
-        const permissions = command.clientPermissions ||
-            client?.settings?.clientPermissions?.push(...handlerPermissions(client, command.commandType, "client")), missing = [];
+    else if (action?.guild && (command.clientPermissions || client.settings.clientPermissions)) {
+        const permissions = command.clientPermissions || client?.settings?.clientPermissions?.push(...handlerPermissions(client, command.commandType, "client")), missing = [];
         if (Array.isArray(permissions))
             permissions.map((permission) => {
                 if (!(action.member?.permissions).has(permission)) {
@@ -73,8 +66,7 @@ function emit(client, action, command, reason, extra) {
 function inCooldown(user, client, command, action) {
     let res = false, downs = {};
     const { cooldowns, messageCommands, slashCommands, contextCommands, commands, } = client.cache;
-    if (command.commandType === CommandType.MessageCommand &&
-        client.handlerOptions.message.cooldown) {
+    if (command.commandType === CommandType.MessageCommand && client.handlerOptions.message.cooldown) {
         if (messageCommands.has(user.id)) {
             const usr = messageCommands.get(user.id);
             usr.timeRemaining = usr.endsAt - Date.now();

package/dist/models/Events.d.ts

@@ -20,4 +20,5 @@ export declare class CommandsDeploy {
     client: XernerxClient;
     constructor(client: XernerxClient);
     deploy(): void;
+    put(type: string, guild: string, body: Array<object>): void;
 }