xernerx 3.2.5 → 3.3.0

package/dist/models/Events.js

@@ -1,6 +1,6 @@
 import { GatewayVersion, InteractionType, REST, Routes, } from "discord.js";
 import { InteractionCommandUtil, MessageCommandUtil, } from "../utils/CommandUtil.js";
-import { CommandArguments, messageArgs } from "./CommandArguments.js";
+import { InteractionArguments, messageArguments } from "./CommandArguments.js";
 import commandValidation from "./CommandValidations.js";
 import { Style } from "dumfunctions";
 import { InhibitorValidation } from "./InhibitorValidations.js";
@@ -13,67 +13,48 @@ export class MessageCommandEvents {
         this.client.on("messageCreate", async (message) => {
             if (!message.author.bot) {
                 let command = undefined, px = undefined;
+                if (this.client.handlerOptions.message?.handleTyping)
+                    message.channel.sendTyping();
                 message.author.isOwner = this.client.util.isOwner(message.author.id);
                 message.util = new MessageCommandUtil(this.client, message);
                 const commands = this.client.commands.message;
                 commands
-                    .filter((c) => !c.regex)
+                    .filter(c => !c.regex)
                     .map(async (cmd) => {
                     if (cmd.prefix) {
-                        cmd.prefix.map((prefix) => {
+                        cmd.prefix.map(prefix => {
                             if (message.content.startsWith(prefix)) {
-                                command = message.content
-                                    .replace(prefix, "")
-                                    .split(/ +/)
-                                    .shift();
+                                command = message.content.replace(prefix, "").split(/ +/).shift();
                                 px = prefix;
                             }
                         });
                     }
                     if (this.client.handlerOptions.message?.prefix) {
-                        const prefix = Array.isArray(this.client.handlerOptions.message.prefix)
-                            ? this.client.handlerOptions.message.prefix
-                            : [this.client.handlerOptions.message.prefix];
+                        const prefix = Array.isArray(this.client.handlerOptions.message.prefix) ? this.client.handlerOptions.message.prefix : [this.client.handlerOptions.message.prefix];
                         prefix.map((prefix) => {
                             if (message.content.startsWith(prefix)) {
-                                command = message.content
-                                    .replace(prefix, "")
-                                    .split(/ +/)
-                                    .shift();
+                                command = message.content.replace(prefix, "").split(/ +/).shift();
                                 px = prefix;
                             }
                         });
                     }
                     if (this.client.handlerOptions.message?.allowMention) {
-                        if (message.mentions.users.has(this.client.user?.id || "") ||
-                            message.mentions.repliedUser?.id === this.client.user?.id) {
-                            command = message.content
-                                .replace(`<@${this.client.user?.id}>`, "")
-                                .trim()
-                                .split(/ +/)
-                                .shift();
+                        if (message.mentions.users.has(this.client.user?.id) || message.mentions.repliedUser?.id === this.client.user?.id) {
+                            command = message.content.replace(`<@${this.client.user?.id}>`, "").trim().split(/ +/).shift();
                             px = "MentionPrefix";
                         }
                     }
-                    const prefix = Array.isArray(this.client.handlerOptions.message?.prefix)
-                        ? this.client.handlerOptions.message?.prefix
-                        : [this.client.handlerOptions.message?.prefix];
-                    if ((cmd.name.toLowerCase() == command?.toLowerCase() ||
-                        cmd.aliases
-                            ?.map((c) => c.toLowerCase())
-                            ?.includes(command?.toLowerCase())) &&
-                        (cmd.prefix.includes(px) ||
-                            prefix?.includes(px) ||
-                            px === "MentionPrefix")) {
+                    const prefix = Array.isArray(this.client.handlerOptions.message?.prefix) ? this.client.handlerOptions.message?.prefix : [this.client.handlerOptions.message?.prefix];
+                    if ((cmd.name.toLowerCase() == command?.toLowerCase() || cmd.aliases?.map((c) => c.toLowerCase())?.includes(command?.toLowerCase())) && (cmd.prefix.includes(px) || prefix?.includes(px) || px === "MentionPrefix")) {
                         try {
                             const inhibitor = new InhibitorValidation(this.client, message, command);
                             if (commandValidation(message, cmd, this.client))
                                 return;
                             if (await inhibitor.inhibit())
                                 return;
-                            if (cmd.conditions && (await cmd.conditions(message)))
+                            if (cmd.conditions && await cmd.conditions(message, await messageArguments(message, cmd)))
                                 return;
-                            await cmd.exec(message, await messageArgs(message, cmd));
+                            await cmd.exec(message, await messageArguments(message, cmd));
                             this.client.emit("commandRun", message, cmd);
                         }
                         catch (error) {
@@ -86,9 +67,11 @@ export class MessageCommandEvents {
     }
     messageUpdate() {
         this.client.on("messageUpdate", async (old, message) => {
-            message = message; // could just do this
+            message = message;
             if (!message.author?.bot) {
                 let command = undefined, px = undefined;
+                if (this.client.handlerOptions.message?.handleTyping)
+                    message.channel.sendTyping();
                 if (message.author)
                     message.author.isOwner = this.client.util.isOwner(message.author.id);
                 message.util = new MessageCommandUtil(this.client, message);
@@ -99,58 +82,38 @@ export class MessageCommandEvents {
                     if (cmd.prefix) {
                         cmd.prefix.map((prefix) => {
                             if (message?.content?.startsWith(prefix)) {
-                                command = message.content
-                                    .replace(prefix, "")
-                                    .split(/ +/)
-                                    .shift();
+                                command = message.content.replace(prefix, "").split(/ +/).shift();
                                 px = prefix;
                             }
                         });
                     }
                     if (this.client.handlerOptions.message?.prefix) {
-                        const prefix = Array.isArray(this.client.handlerOptions.message.prefix)
-                            ? this.client.handlerOptions.message.prefix
-                            : [this.client.handlerOptions.message.prefix];
+                        const prefix = Array.isArray(this.client.handlerOptions.message.prefix) ? this.client.handlerOptions.message.prefix : [this.client.handlerOptions.message.prefix];
                         prefix.map((prefix) => {
                             if (message?.content?.startsWith(prefix)) {
-                                command = message.content
-                                    .replace(prefix, "")
-                                    .split(/ +/)
-                                    .shift();
+                                command = message.content.replace(prefix, "").split(/ +/).shift();
                                 px = prefix;
                             }
                         });
                     }
                     if (this.client.handlerOptions.message?.allowMention) {
-                        if (message.mentions.users.has(this.client.user?.id || "") ||
-                            message.mentions.repliedUser?.id === this.client.user?.id) {
-                            command = message?.content
-                                ?.replace(`<@${this.client.user?.id}>`, "")
-                                .trim()
-                                .split(/ +/)
-                                .shift();
+                        if (message.mentions.users.has(this.client.user?.id || "") || message.mentions.repliedUser?.id === this.client.user?.id) {
+                            command = message?.content?.replace(`<@${this.client.user?.id}>`, "").trim().split(/ +/).shift();
                             px = "MentionPrefix";
                         }
                     }
-                    const prefix = Array.isArray(this.client.handlerOptions.message?.prefix)
-                        ? this.client.handlerOptions.message?.prefix
-                        : [this.client.handlerOptions.message?.prefix];
-                    if ((cmd.name.toLowerCase() == command?.toLowerCase() ||
-                        cmd.aliases
-                            ?.map((c) => c.toLowerCase())
-                            ?.includes(command?.toLowerCase())) &&
-                        (cmd.prefix.includes(px) ||
-                            prefix?.includes(px) ||
-                            px === "MentionPrefix")) {
+                    const prefix = Array.isArray(this.client.handlerOptions.message?.prefix) ? this.client.handlerOptions.message?.prefix : [this.client.handlerOptions.message?.prefix];
+                    if ((cmd.name.toLowerCase() == command?.toLowerCase() || cmd.aliases?.map((c) => c.toLowerCase())?.includes(command?.toLowerCase())) && (cmd.prefix.includes(px) || prefix?.includes(px) || px === "MentionPrefix")) {
                         try {
+                            message = message;
                             const inhibitor = new InhibitorValidation(this.client, message, command);
                             if (commandValidation(message, cmd, this.client))
                                 return;
                             if (await inhibitor.inhibit())
                                 return;
-                            if (cmd.conditions && (await cmd.conditions(message)))
+                            if (cmd.conditions && await cmd.conditions(message, await messageArguments(message, cmd)))
                                 return;
-                            await cmd.exec(message, await messageArgs(message, cmd));
+                            await cmd.exec(message, await messageArguments(message, cmd));
                             this.client.emit("commandRun", message, cmd);
                         }
                         catch (error) {
@@ -163,8 +126,9 @@ export class MessageCommandEvents {
     }
     messageDelete() {
         this.client.on("messageDelete", async (message) => {
-            if (this.client.cache.messages.has(message.id) &&
-                this.client.handlerOptions.message?.handleDeletes) {
+            if (this.client.cache.messages.has(message.id) && this.client.handlerOptions.message?.handleDeletes) {
+                if (this.client.handlerOptions.message?.handleTyping)
+                    message.channel.sendTyping();
                 try {
                     const msg = this.client.cache.messages.get(message.id);
                     const response = await message.channel.messages.fetch(msg?.response);
@@ -187,39 +151,20 @@ export class SlashCommandEvents {
             if (interaction.type === InteractionType.ApplicationCommand) {
                 if (this.client.commands.slash.has(interaction.commandName)) {
                     let command = this.client.commands.slash.get(interaction.commandName);
-                    const argumentsInfo = new CommandArguments(interaction);
+                    const argumentsInfo = new InteractionArguments(interaction);
                     try {
                         const inhibitor = new InhibitorValidation(this.client, interaction, command);
                         if (await inhibitor.inhibit())
                             return;
                         if (commandValidation(interaction, command, this.client))
                             return;
-                        if (command.defer?.reply !== false &&
-                            this.client.handlerOptions.slash?.defer?.reply) {
-                            await interaction.deferReply({
-                                ephemeral: this.client.handlerOptions.slash?.defer?.ephemeral,
-                                fetchReply: this.client.handlerOptions.slash?.defer?.fetchReply,
-                            });
-                        }
-                        if (!(interaction.deferred || interaction.replied) &&
-                            command.defer?.reply) {
-                            await interaction.deferReply({
-                                ephemeral: command.defer?.ephemeral,
-                                fetchReply: command.defer?.fetchReply,
-                            });
-                        }
-                        if (command.conditions &&
-                            (await command.conditions(interaction, {
-                                group: argumentsInfo.group(),
-                                subcommand: argumentsInfo.subcommand(),
-                                args: await argumentsInfo.arguments(),
-                            })))
+                        if (command.defer?.reply !== false && this.client.handlerOptions.slash?.defer?.reply)
+                            await interaction.deferReply({ ephemeral: this.client.handlerOptions.slash?.defer?.ephemeral, fetchReply: this.client.handlerOptions.slash?.defer?.fetchReply, });
+                        if (!(interaction.deferred || interaction.replied) && command.defer?.reply)
+                            await interaction.deferReply({ ephemeral: command.defer?.ephemeral, fetchReply: command.defer?.fetchReply, });
+                        if (command.conditions && (await command.conditions(interaction, { group: argumentsInfo.group(), subcommand: argumentsInfo.subcommand(), args: await argumentsInfo.arguments() })))
                             return;
-                        await command.exec(interaction, {
-                            group: argumentsInfo.group(),
-                            subcommand: argumentsInfo.subcommand(),
-                            args: await argumentsInfo.arguments(),
-                        });
+                        await command.exec(interaction, { group: argumentsInfo.group(), subcommand: argumentsInfo.subcommand(), args: await argumentsInfo.arguments(), });
                         this.client.emit("commandRun", interaction, command);
                     }
                     catch (error) {
@@ -250,20 +195,10 @@ export class ContextCommandEvents {
                             return;
                         if (command.conditions && (await command.conditions(interaction)))
                             return;
-                        if (command.defer?.reply !== false &&
-                            this.client.handlerOptions.context?.defer?.reply) {
-                            await interaction.deferReply({
-                                ephemeral: this.client.handlerOptions.context?.defer?.ephemeral,
-                                fetchReply: this.client.handlerOptions.context?.defer?.fetchReply,
-                            });
-                        }
-                        if (!(interaction.deferred || interaction.replied) &&
-                            command.defer?.reply) {
-                            await interaction.deferReply({
-                                ephemeral: command.defer?.ephemeral,
-                                fetchReply: command.defer?.fetchReply,
-                            });
-                        }
+                        if (command.defer?.reply !== false && this.client.handlerOptions.context?.defer?.reply)
+                            await interaction.deferReply({ ephemeral: this.client.handlerOptions.context?.defer?.ephemeral, fetchReply: this.client.handlerOptions.context?.defer?.fetchReply, });
+                        if (!(interaction.deferred || interaction.replied) && command.defer?.reply)
+                            await interaction.deferReply({ ephemeral: command.defer?.ephemeral, fetchReply: command.defer?.fetchReply, });
                         await command.exec(interaction);
                         this.client.emit("commandRun", interaction, command);
                     }
@@ -282,47 +217,39 @@ export class CommandsDeploy {
     }
     deploy() {
         this.client.once("ready", async (client) => {
-            const rest = new REST({ version: GatewayVersion }).setToken(client.token);
-            const commands = [
-                ...this.client.commands.context,
-                ...this.client.commands.slash,
-            ];
-            const deployableCommands = [];
-            commands.map((commands) => commands.map((command) => {
-                if (command?.data) {
-                    deployableCommands.push(command.data.toJSON());
-                }
-            }));
+            const slashCommands = [], contextCommands = [];
+            this.client.commands.context.map(command => command.data ? contextCommands.push(command.data.toJSON()) : null);
+            this.client.commands.slash.map(command => command.data ? slashCommands.push(command.data.toJSON()) : null);
             try {
-                if (this.client.handlerOptions.context?.global === true ||
-                    this.client.handlerOptions.slash?.global === true) {
-                    rest.put(Routes.applicationCommands(client.user.id), {
-                        body: deployableCommands,
-                    });
-                    rest.put(Routes.applicationGuildCommands(client.user.id, this.client.handlerOptions.slash?.guildId ||
-                        this.client.handlerOptions.context?.guildId ||
-                        ""), {
-                        body: [],
-                    });
+                const global = { slash: this.client.handlerOptions.slash?.global, context: this.client.handlerOptions.context?.global };
+                const guild = { slash: this.client.handlerOptions.slash?.guildId, context: this.client.handlerOptions.context?.guildId };
+                if (global.slash && global.context) {
+                    if (guild.slash !== guild.context)
+                        console.info(Style.log(`Xernerx | Warning: slash and context commands are both set to global, but don't have a matching guildId, using ${(await this.client.guilds.fetch(this.client.handlerOptions.slash?.guildId)).name}!`, { color: Style.TextColor.Red }));
+                    this.put("global", guild.slash, [...contextCommands, ...slashCommands]);
+                    this.put("guild", guild.slash, []);
+                }
+                if (global.slash && !global.context) {
+                    this.put("global", guild.slash, slashCommands);
                 }
-                if (this.client.handlerOptions.context?.global === false ||
-                    this.client.handlerOptions.slash?.global === false) {
-                    rest.put(Routes.applicationGuildCommands(client.user.id, this.client.handlerOptions.slash?.guildId ||
-                        this.client.handlerOptions.context?.guildId ||
-                        ""), {
-                        body: deployableCommands,
-                    });
+                if (!global.slash && global.context) {
+                    this.put("global", guild.context, contextCommands);
                 }
-                if (this.client.handlerOptions.slash?.logging ||
-                    this.client.handlerOptions?.context?.logging)
-                    console.info(Style.log(`Xernerx | Deployed ${deployableCommands.length} of ${commands.length} interaction commands ${this.client.handlerOptions.slash?.global ||
-                        this.client.handlerOptions.context?.global
-                        ? `globally in ${(await this.client.guilds.fetch()).size} server(s), deleted local commands.`
-                        : "locally"}.`, { color: Style.TextColor.Purple }));
+                if (!global.slash && !global.context) {
+                    this.put("guild", guild.slash, [...contextCommands, ...slashCommands]);
+                }
+                console.log(Style.log(`Xernerx | Deployed ${slashCommands.length} slash commands ${global.slash ? "globally" : "locally"} and ${contextCommands.length} context commands ${global.context ? "globally" : "locally"}.`, { color: Style.TextColor.Purple }));
             }
             catch (error) {
                 console.error(Style.log(`Xernerx | Couldn't deploy interaction commands because <${error}>.`, { color: Style.BackgroundColor.Red }));
             }
         });
     }
+    put(type, guild, body) {
+        const rest = new REST({ version: GatewayVersion }).setToken(this.client.token);
+        if (type === "guild")
+            rest.put(Routes.applicationGuildCommands(this.client.user?.id, guild), { body });
+        else
+            rest.put(Routes.applicationCommands(this.client.user?.id), { body });
+    }
 }

package/dist/models/Extensions.d.ts

@@ -1,6 +1,6 @@
-import { XernerxClient } from "../main.js";
+import { ExtensionBuilder, XernerxClient } from "../main.js";
 export default class Extensions {
     client: XernerxClient;
     constructor(client: XernerxClient);
-    load(extensions: Array<any>, logging?: boolean): Promise<void>;
+    load(extensions: Array<ExtensionBuilder>, logging?: boolean): Promise<void>;
 }

package/dist/models/InhibitorValidations.d.ts

@@ -1,17 +1,12 @@
-import { Interaction, Message } from "discord.js";
-import { MessageCommandOptions, SlashCommandOptions, ContextCommandOptions } from "../interfaces/CommandInterfaces.js";
-import { InhibitorType } from "../types/InhibitorTypes.js";
+import { InhibitorType } from "../types/enums.js";
 import XernerxClient from "../client/XernerxClient.js";
+import { XernerxInteraction, XernerxMessage } from "../types/types.js";
 export declare class InhibitorValidation {
     client: XernerxClient;
-    action: Message | Interaction;
-    command: MessageCommandOptions | SlashCommandOptions | ContextCommandOptions;
-    inhibited: {
-        [index: string]: any;
-    };
-    constructor(client: XernerxClient, action: Message | Interaction, command: any);
-    inhibit(): Promise<{
-        [index: string]: any;
-    } | undefined>;
-    args(action: any, type: InhibitorType): any;
+    action: XernerxMessage | XernerxInteraction;
+    command: string;
+    inhibited: Record<string, string | void>;
+    constructor(client: XernerxClient, action: XernerxMessage | XernerxInteraction, command: string);
+    inhibit(): Promise<Record<string, string | void> | undefined>;
+    args(action: XernerxInteraction | XernerxMessage | any, type: InhibitorType): any;
 }

package/dist/models/InhibitorValidations.js

@@ -1,4 +1,4 @@
-import { InhibitorType } from "../types/InhibitorTypes.js";
+import { InhibitorType } from "../types/enums.js";
 export class InhibitorValidation {
     client;
     action;

package/dist/types/Types.d.ts

@@ -1,28 +1,32 @@
-import { SlashCommandStringOption, SlashCommandNumberOption, SlashCommandIntegerOption, SlashCommandBooleanOption, SlashCommandUserOption, SlashCommandChannelOption, SlashCommandRoleOption, SlashCommandMentionableOption } from "discord.js";
-export declare enum CommandType {
-    Message = "MessageCommand",
-    Slash = "SlashCommand",
-    Context = "ContextCommand",
-    Event = "Event",
-    Inhibitor = "Inhibitor",
-    MessageCommand = "MessageCommand",
-    SlashCommand = "SlashCommand",
-    ContextCommand = "ContextCommand"
+import { TextChannel, Message, User, Guild, GuildMember, Channel, Role, InteractionResponse } from "discord.js";
+import { InteractionCommandUtil, MessageCommandUtil } from "../utils/CommandUtil.js";
+export interface XernerxMessage extends Message {
+    util?: MessageCommandUtil;
+    response?: string;
 }
-export declare enum ContextCommandType {
-    Message = 3,
-    User = 2
+export interface XernerxInteraction extends InteractionResponse {
+    util: InteractionCommandUtil;
+    options?: {
+        _group: string;
+        _subcommand: string;
+        _hoistedOptions: Array<{
+            name: string;
+            channel: Channel;
+            user: XernerxUser;
+            role: XernerxRole;
+            value: string;
+        }>;
+    };
 }
-export declare enum EventEmitterType {
-    Client = "client",
-    Rest = "rest",
-    Process = "process"
+export interface XernerxUser extends User {
+    isOwner: boolean;
 }
-export type SlashCommandOptionChoices = SlashCommandStringOption | SlashCommandNumberOption | SlashCommandIntegerOption;
-export type SlashCommandOption = SlashCommandOptionChoices | SlashCommandBooleanOption | SlashCommandUserOption | SlashCommandChannelOption | SlashCommandRoleOption | SlashCommandMentionableOption;
-export type SlashArgumentTypes = "String" | "Number" | "Boolean" | "User" | "Channel" | "Role" | "Mentionable" | "Integer";
-declare const _default: {
-    CommandType: typeof CommandType;
-    EventEmitterType: typeof EventEmitterType;
-};
-export default _default;
+export interface XernerxRole extends Role {
+}
+export interface XernerxTextChannel extends TextChannel {
+}
+export interface XernerxGuild extends Guild {
+}
+export interface XernerxMember extends GuildMember {
+}
+export type MessageCommandArgsTypes = "flag" | "string" | "number" | "channel" | "user" | "member" | "boolean" | "role";

package/dist/types/Types.js

@@ -1,26 +1 @@
-export var CommandType;
-(function (CommandType) {
-    CommandType["Message"] = "MessageCommand";
-    CommandType["Slash"] = "SlashCommand";
-    CommandType["Context"] = "ContextCommand";
-    CommandType["Event"] = "Event";
-    CommandType["Inhibitor"] = "Inhibitor";
-    CommandType["MessageCommand"] = "MessageCommand";
-    CommandType["SlashCommand"] = "SlashCommand";
-    CommandType["ContextCommand"] = "ContextCommand";
-})(CommandType = CommandType || (CommandType = {}));
-export var ContextCommandType;
-(function (ContextCommandType) {
-    ContextCommandType[ContextCommandType["Message"] = 3] = "Message";
-    ContextCommandType[ContextCommandType["User"] = 2] = "User";
-})(ContextCommandType = ContextCommandType || (ContextCommandType = {}));
-export var EventEmitterType;
-(function (EventEmitterType) {
-    EventEmitterType["Client"] = "client";
-    EventEmitterType["Rest"] = "rest";
-    EventEmitterType["Process"] = "process";
-})(EventEmitterType = EventEmitterType || (EventEmitterType = {}));
-export default {
-    CommandType,
-    EventEmitterType,
-};
+export {};

package/dist/types/enums.d.ts

@@ -0,0 +1,35 @@
+import { SlashCommandStringOption, SlashCommandNumberOption, SlashCommandIntegerOption, SlashCommandBooleanOption, SlashCommandUserOption, SlashCommandChannelOption, SlashCommandRoleOption, SlashCommandMentionableOption } from "discord.js";
+export declare enum InhibitorType {
+    Member = "Member",
+    User = "User",
+    Guild = "Guild",
+    SlashCommand = "SlashCommand",
+    MessageCommand = "MessageCommand",
+    ContextCommand = "ContextCommand",
+    Command = "Command",
+    Message = "Message",
+    Interaction = "Interaction",
+    Channel = "Channel"
+}
+export declare enum CommandType {
+    Message = "MessageCommand",
+    Slash = "SlashCommand",
+    Context = "ContextCommand",
+    Event = "Event",
+    Inhibitor = "Inhibitor",
+    MessageCommand = "MessageCommand",
+    SlashCommand = "SlashCommand",
+    ContextCommand = "ContextCommand"
+}
+export declare enum ContextCommandType {
+    Message = 3,
+    User = 2
+}
+export declare enum EventEmitterType {
+    Client = "client",
+    Rest = "rest",
+    Process = "process"
+}
+export type SlashCommandOptionChoices = SlashCommandStringOption | SlashCommandNumberOption | SlashCommandIntegerOption;
+export type SlashCommandOption = SlashCommandOptionChoices | SlashCommandBooleanOption | SlashCommandUserOption | SlashCommandChannelOption | SlashCommandRoleOption | SlashCommandMentionableOption;
+export type SlashArgumentTypes = "String" | "Number" | "Boolean" | "User" | "Channel" | "Role" | "Mentionable" | "Integer";

package/dist/types/enums.js

@@ -0,0 +1,35 @@
+export var InhibitorType;
+(function (InhibitorType) {
+    InhibitorType["Member"] = "Member";
+    InhibitorType["User"] = "User";
+    InhibitorType["Guild"] = "Guild";
+    InhibitorType["SlashCommand"] = "SlashCommand";
+    InhibitorType["MessageCommand"] = "MessageCommand";
+    InhibitorType["ContextCommand"] = "ContextCommand";
+    InhibitorType["Command"] = "Command";
+    InhibitorType["Message"] = "Message";
+    InhibitorType["Interaction"] = "Interaction";
+    InhibitorType["Channel"] = "Channel";
+})(InhibitorType = InhibitorType || (InhibitorType = {}));
+export var CommandType;
+(function (CommandType) {
+    CommandType["Message"] = "MessageCommand";
+    CommandType["Slash"] = "SlashCommand";
+    CommandType["Context"] = "ContextCommand";
+    CommandType["Event"] = "Event";
+    CommandType["Inhibitor"] = "Inhibitor";
+    CommandType["MessageCommand"] = "MessageCommand";
+    CommandType["SlashCommand"] = "SlashCommand";
+    CommandType["ContextCommand"] = "ContextCommand";
+})(CommandType = CommandType || (CommandType = {}));
+export var ContextCommandType;
+(function (ContextCommandType) {
+    ContextCommandType[ContextCommandType["Message"] = 3] = "Message";
+    ContextCommandType[ContextCommandType["User"] = 2] = "User";
+})(ContextCommandType = ContextCommandType || (ContextCommandType = {}));
+export var EventEmitterType;
+(function (EventEmitterType) {
+    EventEmitterType["Client"] = "client";
+    EventEmitterType["Rest"] = "rest";
+    EventEmitterType["Process"] = "process";
+})(EventEmitterType = EventEmitterType || (EventEmitterType = {}));

package/dist/types/interfaces.d.ts

@@ -0,0 +1,25 @@
+import { Collection } from "discord.js";
+import CommandHandler from "../handlers/CommandHandler.js";
+import EventHandler from "../handlers/EventHandler.js";
+import InhibitorHandler from "../handlers/InhibitorHandler.js";
+import MessageCommandBuilder from "../build/MessageCommandBuilder.js";
+import ContextCommandBuilder from "../build/ContextCommandBuilder.js";
+import SlashCommandBuilder from "../build/SlashCommandBuilder.js";
+export interface ClientCommands {
+    message: Collection<string, MessageCommandBuilder>;
+    slash: Collection<string, SlashCommandBuilder>;
+    context: Collection<string, ContextCommandBuilder>;
+}
+export interface ClientCache {
+    messages: Collection<string, object>;
+    cooldowns: Collection<string, object>;
+    messageCommands: Collection<string, object>;
+    slashCommands: Collection<string, object>;
+    contextCommands: Collection<string, object>;
+    commands: Collection<string, object>;
+}
+export interface ClientModules {
+    commandHandler: CommandHandler;
+    eventHandler: EventHandler;
+    inhibitorHandler: InhibitorHandler;
+}

package/dist/types/interfaces.js

@@ -0,0 +1 @@
+export {};

package/dist/types/objects.d.ts

@@ -0,0 +1,18 @@
+import { TextChannel, Message, User, Guild, GuildMember } from "discord.js";
+import { InteractionCommandUtil, MessageCommandUtil } from "../utils/CommandUtil.js";
+export interface XernerxMessage extends Message {
+    util?: MessageCommandUtil;
+    response?: string;
+}
+export interface XernerxInteraction extends Message {
+    util: InteractionCommandUtil;
+}
+export interface XernerxUser extends User {
+    isOwner: boolean;
+}
+export interface XernerxTextChannel extends TextChannel {
+}
+export interface XernerxGuild extends Guild {
+}
+export interface XernerxMember extends GuildMember {
+}

package/dist/types/objects.js

@@ -0,0 +1 @@
+export {};