xernerx 3.4.2 → 3.5.0

package/dist/main.cjs

@@ -0,0 +1,2012 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/main.ts
+var main_exports = {};
+__export(main_exports, {
+  CommandType: () => CommandType,
+  ContextCommandBuilder: () => ContextCommandBuilder,
+  ContextCommandType: () => ContextCommandType,
+  EventBuilder: () => EventBuilder,
+  EventEmitterType: () => EventEmitterType,
+  ExtensionBuilder: () => import_xernerx_extension_builder.default,
+  InhibitorBuilder: () => InhibitorBuilder,
+  InhibitorType: () => InhibitorType,
+  MessageCommandBuilder: () => MessageCommandBuilder,
+  SlashCommandBuilder: () => SlashCommandBuilder,
+  XernerxClient: () => XernerxClient,
+  XernerxError: () => XernerxError,
+  default: () => main_default,
+  xernerxVersion: () => xernerxVersion
+});
+module.exports = __toCommonJS(main_exports);
+__reExport(main_exports, require("discord.js"), module.exports);
+__reExport(main_exports, require("dumfunctions"), module.exports);
+var import_xernerx_extension_builder = __toESM(require("xernerx-extension-builder"), 1);
+
+// src/client/XernerxClient.ts
+var import_discord4 = require("discord.js");
+var import_zod = require("zod");
+var import_dumfunctions4 = require("dumfunctions");
+
+// src/tools/XernerxError.ts
+var XernerxError = class {
+  name;
+  message;
+  constructor(message) {
+    this.name = "XernerxError";
+    this.message = message || "";
+  }
+};
+
+// src/utils/ClientUtil.ts
+var ClientUtil = class {
+  client;
+  constructor(client) {
+    this.client = client;
+  }
+  uptime(timestamp) {
+    if (!timestamp)
+      timestamp = this.client.uptime || 0;
+    let totalSeconds = timestamp / 1e3;
+    let years = Math.floor(totalSeconds / 31536e3);
+    totalSeconds %= 31536e3;
+    let days = Math.floor(totalSeconds / 86400);
+    totalSeconds %= 86400;
+    let hours = Math.floor(totalSeconds / 3600);
+    totalSeconds %= 3600;
+    let minutes = Math.floor(totalSeconds / 60);
+    let seconds = Math.floor(totalSeconds % 60);
+    if (years >= 1)
+      return `${years}y ${days}d ${hours}h ${minutes}m`;
+    else if (days >= 1)
+      return `${days}d ${hours}h ${minutes}m`;
+    else if (hours >= 1)
+      return `${hours}h ${minutes}m`;
+    else if (minutes >= 1)
+      return `${minutes}m ${seconds}s`;
+    else
+      return `${seconds}s`;
+  }
+  getSubcommands(name) {
+    if (!name || typeof name !== "string")
+      throw new XernerxError(`Expected name to be of type string, received ${typeof name} instead!`);
+    const commands = [];
+    this.getAllCommands().filter((c) => (c.data?.name?.toLowerCase() || c.name?.toLowerCase()) == name?.toLowerCase()).map((c) => {
+      if (c?.data?.options?.length > 0) {
+        c?.data?.options?.map((option) => {
+          if (!option?.type) {
+            if (option?.options?.length > 0) {
+              option?.options?.map((opt) => {
+                if (!opt.type) {
+                  commands.push({
+                    name: c.data.name,
+                    formattedName: `${c.data.name} ${option.name} ${opt.name}`,
+                    description: opt.description,
+                    category: c.category || null,
+                    commandType: c.commandType
+                  });
+                } else {
+                  commands.push({
+                    name: c.data.name,
+                    formattedName: `${c.data.name} ${option.name}`,
+                    description: option.description,
+                    category: c.category || null,
+                    commandType: c.commandType
+                  });
+                }
+              });
+            } else {
+              commands.push({
+                name: c.data.name,
+                formattedName: `${c.data.name} ${option.name}`,
+                description: option.description,
+                category: c.category || null,
+                commandType: c.commandType
+              });
+            }
+          } else {
+            commands.push({
+              name: c.data.name,
+              formattedName: `${c.data.name}`,
+              description: c.data.description,
+              category: c.category || null,
+              commandType: c.commandType
+            });
+          }
+        });
+      } else {
+        commands.push({
+          name: c.data?.name || c.name,
+          formattedName: `${c.data?.name || c.name}`,
+          description: c.data?.description || c.description,
+          category: c.category || null,
+          commandType: c.commandType
+        });
+      }
+    });
+    return commands;
+  }
+  isOwner(userId) {
+    if (!userId)
+      throw new XernerxError("No ID specified");
+    let owners = this.client.settings.ownerId;
+    if (!owners)
+      return false;
+    if (typeof owners === "string")
+      owners = [owners];
+    return owners.includes(userId);
+  }
+  getAllCommands() {
+    const cmds = [];
+    for (const commands of Object.values(this.client.commands)) {
+      commands.map((cmd) => cmds.push(cmd));
+    }
+    return cmds;
+  }
+  getAllMessageCommands() {
+    const cmds = [];
+    this.client.commands.message.map((cmd) => cmds.push(cmd));
+    return cmds;
+  }
+  getAllSlashCommands() {
+    const cmds = [];
+    this.client.commands.slash.map((cmd) => cmds.push(cmd));
+    return cmds;
+  }
+  getAllContextCommands() {
+    const cmds = [];
+    this.client.commands.context.map((cmd) => cmds.push(cmd));
+    return cmds;
+  }
+  setPresence(options) {
+    const client = this.client;
+    function pres() {
+      client.user?.setPresence({
+        activities: [
+          {
+            name: options.text || void 0,
+            type: options.type || void 0,
+            url: options.link || void 0
+          }
+        ],
+        status: options.status || void 0
+      });
+    }
+    pres();
+    if (options.interval) {
+      setInterval(() => {
+        pres();
+      }, options.interval);
+    }
+  }
+  getCooldowns(id, command) {
+    let cooldowns = [];
+    for (const [key, value] of Object.entries(this.client.cache)) {
+      if (!["cooldowns", "messageCommands", "slashCommands", "contextCommands", "commands"].includes(key))
+        continue;
+      if (key === "commands") {
+        if (command) {
+          value.map((x) => {
+            const name = x.name.split(/-/);
+            name.pop();
+            if (name.join("-") === id + "-" + command) {
+              cooldowns.push(x);
+            }
+          });
+        } else {
+          value.map((x) => {
+            if (x.name.split(/-/).shift() === id) {
+              cooldowns.push(x);
+            }
+          });
+        }
+      } else {
+        if (value.has(id)) {
+          const x = value.get(id);
+          cooldowns.push(x);
+        }
+      }
+    }
+    return cooldowns;
+  }
+  getCooldownTimers(id, command) {
+    let cooldowns = [];
+    for (const [key, value] of Object.entries(this.client.cache)) {
+      if (!["cooldowns", "messageCommands", "slashCommands", "contextCommands", "commands"].includes(key))
+        continue;
+      if (key === "commands") {
+        if (command) {
+          value.map((x) => {
+            const name = x.name.split(/-/);
+            name.pop();
+            if (name.join("-") === id + "-" + command) {
+              cooldowns.push({
+                [x.commandName]: x.endsAt - Date.now()
+              });
+            }
+          });
+        } else {
+          value.map((x) => {
+            if (x.name.split(/-/).shift() === id) {
+              cooldowns.push({
+                [x.commandName]: x.endsAt - Date.now()
+              });
+            }
+          });
+        }
+      } else {
+        if (value.has(id)) {
+          const x = value.get(id);
+          cooldowns.push({ [key]: x.endsAt - Date.now() });
+        }
+      }
+    }
+    const sort = cooldowns.map((x) => Object.entries(x).shift()).sort((a, b) => b[1] - a[1]);
+    cooldowns = [];
+    sort.map(([key, value]) => cooldowns.push({ [key]: value }));
+    return cooldowns;
+  }
+  async defer(time) {
+    return new Promise((resolve2) => setTimeout(resolve2, time || 0));
+  }
+};
+
+// src/handlers/Handler.ts
+var import_fs = __toESM(require("fs"), 1);
+var path = __toESM(require("path"), 1);
+
+// src/types/enums.ts
+var InhibitorType = /* @__PURE__ */ ((InhibitorType2) => {
+  InhibitorType2["Member"] = "Member";
+  InhibitorType2["User"] = "User";
+  InhibitorType2["Guild"] = "Guild";
+  InhibitorType2["SlashCommand"] = "SlashCommand";
+  InhibitorType2["MessageCommand"] = "MessageCommand";
+  InhibitorType2["ContextCommand"] = "ContextCommand";
+  InhibitorType2["Command"] = "Command";
+  InhibitorType2["Message"] = "Message";
+  InhibitorType2["Interaction"] = "Interaction";
+  InhibitorType2["Channel"] = "Channel";
+  return InhibitorType2;
+})(InhibitorType || {});
+var CommandType = /* @__PURE__ */ ((CommandType2) => {
+  CommandType2["Message"] = "MessageCommand";
+  CommandType2["Slash"] = "SlashCommand";
+  CommandType2["Context"] = "ContextCommand";
+  CommandType2["Event"] = "Event";
+  CommandType2["Inhibitor"] = "Inhibitor";
+  CommandType2["MessageCommand"] = "MessageCommand";
+  CommandType2["SlashCommand"] = "SlashCommand";
+  CommandType2["ContextCommand"] = "ContextCommand";
+  return CommandType2;
+})(CommandType || {});
+var ContextCommandType = /* @__PURE__ */ ((ContextCommandType2) => {
+  ContextCommandType2[ContextCommandType2["Message"] = 3] = "Message";
+  ContextCommandType2[ContextCommandType2["User"] = 2] = "User";
+  return ContextCommandType2;
+})(ContextCommandType || {});
+var EventEmitterType = /* @__PURE__ */ ((EventEmitterType2) => {
+  EventEmitterType2["Client"] = "client";
+  EventEmitterType2["Rest"] = "rest";
+  EventEmitterType2["Process"] = "process";
+  return EventEmitterType2;
+})(EventEmitterType || {});
+
+// src/handlers/Handler.ts
+var import_shapeshift = require("@sapphire/shapeshift");
+var import_dumfunctions = require("dumfunctions");
+var Handler = class {
+  client;
+  commands;
+  readyTimestamp;
+  constructor(client) {
+    this.client = client;
+    this.commands = [];
+    this.readyTimestamp = Number(Date.now());
+  }
+  /**
+   * @description - The loader for the message commands.
+   * @param {MessageCommandOptions} options - The options for the message command loader.
+   */
+  loadAllMessageCommands(options) {
+    this.client.handlerOptions.message = import_shapeshift.s.object({
+      directory: import_shapeshift.s.string,
+      prefix: import_shapeshift.s.union(import_shapeshift.s.string, import_shapeshift.s.array(import_shapeshift.s.string)),
+      allowMention: import_shapeshift.s.boolean.default(false),
+      cooldown: import_shapeshift.s.number.default(0),
+      userPermissions: import_shapeshift.s.array(import_shapeshift.s.bigint).default([]),
+      clientPermissions: import_shapeshift.s.array(import_shapeshift.s.bigint).default([]),
+      handleEdits: import_shapeshift.s.boolean.default(false),
+      handleDeletes: import_shapeshift.s.boolean.default(false),
+      handleTyping: import_shapeshift.s.boolean.default(false),
+      logging: import_shapeshift.s.boolean.default(false)
+    }).parse(options);
+    const files = this.readdir(options.directory), loaded = [];
+    for (const file of files) {
+      this.load(options.directory, file, "MessageCommand" /* MessageCommand */);
+      loaded.push(file.replace(".js", ""));
+    }
+    if (this.client.handlerOptions.message?.logging)
+      console.info(
+        import_dumfunctions.Style.log(`Xernerx | Loaded ${loaded.length} message commands: ${loaded.join(", ")}.`, {
+          color: import_dumfunctions.Style.TextColor.Cyan
+        })
+      );
+  }
+  /**
+   * @description - The loader for the slash commands.
+   * @param {SlashCommandOptions} options - The options for the slash command loader.
+   */
+  loadAllSlashCommands(options) {
+    this.client.handlerOptions.slash = import_shapeshift.s.object({
+      directory: import_shapeshift.s.string,
+      guildId: import_shapeshift.s.string,
+      global: import_shapeshift.s.boolean,
+      cooldown: import_shapeshift.s.number.default(0),
+      userPermissions: import_shapeshift.s.array(import_shapeshift.s.bigint).default([]),
+      clientPermissions: import_shapeshift.s.array(import_shapeshift.s.bigint).default([]),
+      logging: import_shapeshift.s.boolean.default(false),
+      defer: import_shapeshift.s.object({
+        reply: import_shapeshift.s.boolean.optional,
+        ephemeral: import_shapeshift.s.boolean.optional,
+        fetchReply: import_shapeshift.s.boolean.optional
+      }).optional
+    }).parse(options);
+    const files = this.readdir(options.directory), loaded = [];
+    for (const file of files) {
+      this.load(options.directory, file, "SlashCommand" /* SlashCommand */);
+      loaded.push(file.replace(".js", ""));
+    }
+    if (this.client.handlerOptions.slash?.logging)
+      console.info(
+        import_dumfunctions.Style.log(`Xernerx | Loaded ${loaded.length} slash commands: ${loaded.join(", ")}.`, {
+          color: import_dumfunctions.Style.TextColor.Cyan
+        })
+      );
+  }
+  /**
+   * @description - The loader for the context commands.
+   * @param {ContextCommandOptions} options - The options for the context command loader.
+   */
+  loadAllContextCommands(options) {
+    this.client.handlerOptions.context = import_shapeshift.s.object({
+      directory: import_shapeshift.s.string,
+      guildId: import_shapeshift.s.string,
+      global: import_shapeshift.s.boolean,
+      cooldown: import_shapeshift.s.number.default(0),
+      userPermissions: import_shapeshift.s.array(import_shapeshift.s.bigint).default([]),
+      clientPermissions: import_shapeshift.s.array(import_shapeshift.s.bigint).default([]),
+      logging: import_shapeshift.s.boolean.default(false),
+      defer: import_shapeshift.s.object({
+        reply: import_shapeshift.s.boolean.optional,
+        ephemeral: import_shapeshift.s.boolean.optional,
+        fetchReply: import_shapeshift.s.boolean.optional
+      }).optional
+    }).parse(options);
+    const files = this.readdir(options.directory), loaded = [];
+    for (const file of files) {
+      this.load(options.directory, file, "ContextCommand" /* ContextCommand */);
+      loaded.push(file.replace(".js", ""));
+    }
+    if (this.client.handlerOptions.context?.logging)
+      console.info(
+        import_dumfunctions.Style.log(`Xernerx | Loaded ${loaded.length} context commands: ${loaded.join(", ")}.`, {
+          color: import_dumfunctions.Style.TextColor.Cyan
+        })
+      );
+  }
+  /**
+   * @description - The loader for the events.
+   * @param {EventLoadOptions} options - The options for the event loader.
+   */
+  loadAllEvents(options) {
+    this.client.handlerOptions.events = import_shapeshift.s.object({
+      directory: import_shapeshift.s.string,
+      logging: import_shapeshift.s.boolean.default(false)
+    }).parse(options);
+    const files = this.readdir(options.directory), loaded = [];
+    (async () => {
+      for (const file of files) {
+        try {
+          options.directory.split(/\//).shift();
+          let event = (await import(`file://${path.resolve(options.directory)}/${file}`)).default;
+          event = new event();
+          event.client = this.client;
+          event.commandType = "Event" /* Event */;
+          this.client.events.set(event.name, event);
+          this.emitter(event);
+        } catch (error) {
+          console.error(import_dumfunctions.Style.log(`Xernerx | Couldn't load ${file} because <${error}>`, { color: import_dumfunctions.Style.BackgroundColor.Red }));
+        }
+        loaded.push(file.replace(".js", ""));
+      }
+      if (this.client.handlerOptions.events?.logging)
+        console.info(import_dumfunctions.Style.log(`Xernerx | Loaded ${loaded.length} events: ${loaded.join(", ")}.`, { color: import_dumfunctions.Style.TextColor.Cyan }));
+    })();
+  }
+  /**
+   * @description - The loader for the inhibitors.
+   * @param {InhibitorLoadOptions} options - The options for the inhibitor loader.
+   */
+  loadAllInhibitors(options) {
+    this.client.handlerOptions.inhibitors = import_shapeshift.s.object({
+      directory: import_shapeshift.s.string,
+      logging: import_shapeshift.s.boolean.default(false)
+    }).parse(options);
+    const files = this.readdir(options.directory), loaded = [];
+    for (const file of files) {
+      this.load(options.directory, file, "Inhibitor" /* Inhibitor */);
+      loaded.push(file.replace(".js", ""));
+    }
+    if (this.client.handlerOptions.inhibitors?.logging)
+      console.info(
+        import_dumfunctions.Style.log(`Xernerx | Loaded ${loaded.length} inhibitors: ${loaded.join(", ")}.`, {
+          color: import_dumfunctions.Style.TextColor.Cyan
+        })
+      );
+  }
+  /**
+   * @description - a reader for directories
+   * @param {string} dir - the directory to look for.
+   * @returns array of files.
+   */
+  readdir(dir) {
+    try {
+      return import_fs.default.readdirSync(path.resolve(dir)).filter((file) => file.endsWith(".js"));
+    } catch (error) {
+      console.error(import_dumfunctions.Style.log(`Xernerx | Couldn't read ${dir} because <${error}>.`, { color: import_dumfunctions.Style.BackgroundColor.Red }));
+    }
+    return [];
+  }
+  /**
+   * @description file loader.
+   * @param {string} dir - the directory.
+   * @param {string} file - the file in the directory.
+   * @param {string} type - the type of file.
+   * @returns undefined
+   */
+  async load(dir, file, type) {
+    try {
+      dir.split(/\//).shift();
+      let command = (await import(`file://${path.resolve(dir)}/${file}`)).default;
+      command = new command();
+      command.client = this.client;
+      command.commandType = type;
+      command.filepath = `${path.resolve(dir)}\\${file}`;
+      command.file = file;
+      if (type === "MessageCommand" /* MessageCommand */)
+        this.client.commands.message.set(command?.name || command?.name, command);
+      if (type === "SlashCommand" /* SlashCommand */) {
+        this.client.commands.slash.set(command?.data?.name || command?.name, command);
+      }
+      if (type === "ContextCommand" /* ContextCommand */) {
+        this.client.commands.context.set(command?.data?.name || command?.name, command);
+      }
+      if (type === "Event" /* Event */) {
+        this.client.events.set(command.name, command);
+      }
+      if (type === "Inhibitor" /* Inhibitor */) {
+        this.client.inhibitors.set(command.name, command);
+      }
+    } catch (error) {
+      console.error(import_dumfunctions.Style.log(`Xernerx | Couldn't load ${file} because <${error}>`, { color: import_dumfunctions.Style.BackgroundColor.Red }));
+    }
+  }
+  /**
+   * @description the event emitter to emit all events.
+   * @param {object} event - the event to be emitted.
+   * @returns void
+   */
+  emitter(event) {
+    const client = this.client;
+    if (event.emitter === "client") {
+      if (event.once)
+        client.once(event.name, (...args) => {
+          event.run(...args);
+        });
+      else
+        client.on(event.name, (...args) => {
+          event.run(...args);
+        });
+    } else if (event.emitter === "rest") {
+      if (event.once)
+        client.once(event.name, (...args) => {
+          event.run(...args);
+        });
+      else
+        client.on(event.name, (...args) => {
+          event.run(...args);
+        });
+    } else if (event.emitter === "process") {
+      if (event.once)
+        process.once(event.name, (...args) => {
+          event.run(...args);
+        });
+      else
+        process.on(event.name, (...args) => {
+          event.run(...args);
+        });
+    }
+  }
+};
+
+// src/models/Events.ts
+var import_discord3 = require("discord.js");
+
+// src/utils/CommandUtil.ts
+var import_discord = require("discord.js");
+var MessageCommandUtil = class {
+  client;
+  message;
+  constructor(client, message) {
+    this.client = client;
+    this.message = message;
+  }
+  async reply(content) {
+    if (this.client.cache.messages.has(this.message.id))
+      var existingMessage = this.client.cache.messages.get(this.message.id);
+    if (!existingMessage) {
+      const msg = await this.message.reply(content);
+      this.message.response = msg.id;
+      if (this.client.handlerOptions.message?.handleEdits || this.client.handlerOptions.message?.handleDeletes) {
+        this.client.cache.messages.set(this.message.id, this.message);
+        setInterval(() => {
+          this.client.cache.messages.delete(this.message.id);
+        }, this.client.settings.cooldown?.cache || 3e5);
+      }
+      return msg;
+    }
+    if (existingMessage && this.client.handlerOptions.message?.handleEdits) {
+      try {
+        const msg = await this.message.channel.messages.fetch(existingMessage.response);
+        msg.edit(content);
+        return msg;
+      } catch {
+        const msg = await this.message.reply(content);
+        this.message.response = msg.id;
+        if (this.client.handlerOptions.message?.handleEdits || this.client.handlerOptions.message?.handleDeletes) {
+          this.client.cache.messages.set(this.message.id, this.message);
+          setInterval(() => {
+            this.client.cache.messages.delete(this.message.id);
+          }, this.client.settings.cooldown?.cache || 3e5);
+        }
+      }
+    }
+  }
+  async send(content) {
+    if (this.client.cache.messages.has(this.message.id))
+      var existingMessage = this.client.cache.messages.get(this.message.id);
+    if (!existingMessage) {
+      const msg = await this.message.channel.send(content);
+      this.message.response = msg.id;
+      if (this.client.handlerOptions.message?.handleEdits || this.client.handlerOptions.message?.handleDeletes) {
+        this.client.cache.messages.set(this.message.id, this.message);
+        setInterval(() => {
+          this.client.cache.messages.delete(this.message.id);
+        }, this.client.settings.cooldown?.cache || 3e5);
+      }
+      return msg;
+    }
+    if (existingMessage && this.client.handlerOptions.message?.handleEdits) {
+      try {
+        const msg = await this.message.channel.messages.fetch(existingMessage.response);
+        msg.edit(content);
+        return msg;
+      } catch {
+        const msg = await this.message.channel.send(content);
+        this.message.response = msg.id;
+        if (this.client.handlerOptions.message?.handleEdits || this.client.handlerOptions.message?.handleDeletes) {
+          this.client.cache.messages.set(this.message.id, this.message);
+          setInterval(() => {
+            this.client.cache.messages.delete(this.message.id);
+          }, this.client.settings.cooldown?.cache || 3e5);
+        }
+      }
+    }
+  }
+  async defer(time) {
+    return new Promise((resolve2) => setTimeout(resolve2, time));
+  }
+  getCommands() {
+    return this.client.commands.message;
+  }
+  getCommandName() {
+  }
+  selectMenuPaginator(embeds, options) {
+  }
+  buttonPaginator(embeds, options) {
+  }
+  buttonMenuPaginator(embeds, options) {
+  }
+  isOwner() {
+    return this.client.util.isOwner(this.message.author.id);
+  }
+  createModal() {
+  }
+};
+var InteractionCommandUtil = class {
+  client;
+  interaction;
+  constructor(client, interaction) {
+    this.client = client;
+    this.interaction = interaction;
+  }
+  reply(content) {
+    return this.interaction.replied || this.interaction.deferred ? this.interaction.editReply(content) : this.interaction.reply(content);
+  }
+  async defer(time) {
+    return new Promise((resolve2) => setTimeout(resolve2, time));
+  }
+  getCommands() {
+    if (this.interaction.commandType === 1)
+      return this.client.commands.slash;
+    else
+      return this.client.commands.context;
+  }
+  getCommandName() {
+  }
+  selectMenuPaginator(embeds, options) {
+    if (!Array.isArray(embeds))
+      throw new XernerxError(`Expected embeds to be of type array, received ${typeof embeds} instead.`);
+    if (embeds.length > 25)
+      throw new XernerxError(`Max select menu length is 25.`);
+    if (typeof options !== "object")
+      options = {};
+    if (!Array.isArray(options.components))
+      options.components = [];
+    if (!options.index) {
+      options.index = new import_discord.EmbedBuilder().setTitle("Index").setColor("Random");
+      for (const embed of embeds) {
+        options.index.addFields([
+          {
+            name: embed.data.title || "No Name",
+            value: embed.data.description || "Page",
+            inline: embeds.length > 25 / 2 ? true : false
+          }
+        ]);
+      }
+    }
+    if (!options.row) {
+      options.row = new import_discord.ActionRowBuilder();
+      if (!options.id)
+        options.id = `${this.interaction.id}-menu`;
+      options.component = new import_discord.StringSelectMenuBuilder().setCustomId(options.id).setMaxValues(1).setMinValues(1).setPlaceholder("Select a page.").addOptions({ label: "index", value: "0" });
+      embeds.map((embed, i = 0) => {
+        options?.component?.addOptions({
+          label: embed.data.title || "No Name",
+          description: embed.data.description || `Page ${i}`,
+          value: String(i + 1)
+        });
+      });
+      options.row.addComponents(options.component);
+    }
+    embeds.unshift(options.index);
+    const content = {
+      embeds: [options.index],
+      components: [options.row, ...options.components],
+      ephemeral: !!options.ephemeral
+    };
+    (options.reply === void 0 || options.reply === true ? this.interaction.util.reply(content) : this.interaction.channel.send(content)).then(() => {
+      const collector = this.interaction.channel.createMessageComponentCollector({
+        filter: options?.filter,
+        time: options?.time || 6e4
+      }).on("collect", (interaction) => {
+        if (!interaction.customId.startsWith(this.interaction.id))
+          return;
+        interaction.update({
+          embeds: [embeds[parseInt(interaction.values[0])]]
+        });
+      }).on("end", () => {
+        this.interaction.editReply({ components: [] });
+      });
+    });
+  }
+  buttonPaginator(embeds, options) {
+    if (!Array.isArray(embeds))
+      throw new XernerxError(`Expected embeds to be of type array, received ${typeof embeds} instead.`);
+    if (embeds.length <= 0)
+      throw new XernerxError(`The minimum embeds is 1.`);
+    if (typeof options !== "object")
+      options = {};
+    if (!Array.isArray(options.components))
+      options.components = [];
+    if (!options.row) {
+      options.row = new import_discord.ActionRowBuilder();
+      if (!options.id)
+        options.id = `${this.interaction.id}-menu`;
+    }
+    if (!options.buttons)
+      options.buttons = ["\u23EE\uFE0F", "\u25C0\uFE0F", "\u23F9\uFE0F", "\u25B6\uFE0F", "\u23ED\uFE0F"];
+    for (const button of options.buttons) {
+      options.row.addComponents(
+        new import_discord.ButtonBuilder().setCustomId(`${this.interaction.id}-${options.buttons.indexOf(button)}`).setEmoji(button).setStyle(import_discord.ButtonStyle.Primary)
+      );
+    }
+    let embed = embeds[options.index || 0];
+    const content = {
+      embeds: [embed],
+      components: [options.row, ...options.components],
+      ephemeral: !!options.ephemeral
+    };
+    (options.reply === void 0 || options.reply === true ? this.interaction.util.reply(content) : this.interaction.channel.send(content)).then((message) => {
+      const collector = message.channel.createMessageComponentCollector({
+        filter: options.filter,
+        time: options?.time || 6e4
+      }).on("collect", (interaction) => {
+        let stop = false;
+        if (interaction.customId.startsWith(this.interaction.id)) {
+          switch (Number(interaction.customId.split(/-/).pop())) {
+            case 0: {
+              embed = embeds[0];
+              break;
+            }
+            case 1: {
+              embed = embeds[embeds.indexOf(embed) >= 1 ? embeds.indexOf(embed) - 1 : 0];
+              break;
+            }
+            case 2: {
+              collector.stop();
+              stop = true;
+              break;
+            }
+            case 3: {
+              embed = embeds[embeds.indexOf(embed) < embeds.length - 1 ? embeds.indexOf(embed) + 1 : embeds.length - 1];
+              break;
+            }
+            case 4: {
+              embed = embeds[embeds.length - 1];
+              break;
+            }
+          }
+          stop ? interaction.update({
+            embeds: [embed],
+            components: []
+          }) : interaction.update({
+            embeds: [embed]
+          });
+        }
+      }).on("end", () => {
+        this.interaction.editReply({ components: [] });
+      });
+    });
+  }
+  buttonMenuPaginator(embeds, options) {
+  }
+  isOwner() {
+    return this.client.util.isOwner(this.interaction.user.id);
+  }
+  createModal() {
+  }
+};
+
+// src/models/CommandArguments.ts
+var InteractionArguments = class {
+  interaction;
+  constructor(interaction) {
+    this.interaction = interaction;
+  }
+  group() {
+    return this.interaction?.options?._group;
+  }
+  subcommand() {
+    return this.interaction?.options?._subcommand;
+  }
+  arguments() {
+    const options = {};
+    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;
+  }
+};
+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.match)) {
+      if (flag.match == flg) {
+        message.content = message.content.replace(flag.match, "");
+        args.flags[flag.name] = true;
+      }
+    }
+    if (!args.flags[flag.name])
+      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).split(separator).slice(i);
+    if (content.join(separator) != "" && argument.type !== "flag") {
+      if (argument?.content?.includes(content[0])) {
+        args[argument.name] = content[0];
+      } else if (argument.type == "string") {
+        args[argument.name] = content[0];
+      } 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] = 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])) || null;
+        try {
+          user = await message.client.users.fetch(user?.id || content[0].replace(/<@!?|>/g, "")) || null;
+        } catch (e) {
+          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])) || null;
+        try {
+          role = await message.guild?.roles.fetch(role?.id || content[0].replace(/<@&?|>/g, "")) || null;
+        } catch (e) {
+          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])) || null;
+        try {
+          member = await message.guild?.members.fetch(member?.id || content[0].replace(/<@!?|>/g, "")) || null;
+        } catch (e) {
+          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]));
+        try {
+          channel = await message.client.channels.fetch(channel?.id || content[0].replace(/<#|>/g, ""));
+        } catch (e) {
+          channel = null;
+        }
+        args[argument.name] = channel;
+      } else if (argument.type == "rest") {
+        args[argument.name] = content.join(separator);
+        break;
+      } else if (argument.prompt) {
+        if (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;
+      i++;
+    } else
+      args[argument.name] = typeof argument.default == "function" ? argument.default(message) : argument.default;
+  }
+  return args;
+}
+
+// src/validators/CommandValidations.ts
+var import_discord2 = require("discord.js");
+function getUser(from) {
+  if (from instanceof import_discord2.Message)
+    return from.author;
+  else
+    return from.user;
+}
+function commandValidation(action, command, client, res = false) {
+  let user = getUser(action);
+  if ((command.ignoreOwner || client.settings.ignore?.owner) && client.util.isOwner(user.id))
+    return res;
+  else if (inCooldown(user, client, command, action))
+    return true;
+  else if (command.owner && !client.util.isOwner(user.id)) {
+    res = true;
+    emit(client, action, command, "Not an owner", client.settings.ownerId);
+  } else if (command.channelType?.length > 0 || command.channelType) {
+    if (!Array.isArray(command.channelType))
+      command.channelType = [command.channelType];
+    if (!command?.channelType?.includes(action.channel?.type)) {
+      res = true;
+      emit(client, action, command, "Not the correct channel", command.channelType);
+    }
+  } 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)) {
+    res = true;
+    emit(client, action, command, "Not a whitelisted guild", command.guilds);
+  } else if (command.channelType && command.channelType !== action.channel?.type) {
+    res = true;
+    emit(client, action, command, "Not the correct type of channel", command.channelType);
+  } else if (action?.guild && (command.permissions?.user || client.settings.permissions?.user)) {
+    const permissions = command.permissions?.user || client?.settings?.permissions?.user?.push(...handlerPermissions(client, command.commandType, "user")), missing = [];
+    if (Array.isArray(permissions))
+      permissions.map((permission) => {
+        if (!(action.member?.permissions).has(permission)) {
+          missing.push(permission);
+        }
+      });
+    if (missing.length > 0) {
+      res = true;
+      emit(client, action, command, "Missing User Permissions", missing);
+    }
+  } else if (action?.guild && (command.permissions?.client || client.settings.permissions?.client)) {
+    const permissions = command.permissions?.client || client?.settings?.permissions?.client?.push(...handlerPermissions(client, command.commandType, "client")), missing = [];
+    if (Array.isArray(permissions))
+      permissions.map((permission) => {
+        if (!(action.member?.permissions).has(permission)) {
+          missing.push(permission);
+        }
+      });
+    if (missing.length > 0) {
+      res = true;
+      emit(client, action, command, "Missing Client Permissions", missing);
+    }
+  }
+  return res;
+}
+function emit(client, action, command, reason, extra) {
+  return client.emit("commandBlock", 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 === "MessageCommand" /* MessageCommand */ && client.handlerOptions.message.cooldown) {
+    if (messageCommands.has(user.id)) {
+      const usr = messageCommands.get(user.id);
+      usr.timeRemaining = usr.endsAt - Date.now();
+      downs.message = usr;
+      res = true;
+    }
+    if (!messageCommands.has(user.id)) {
+      messageCommands.set(user.id, toCooldown(action, command, client.handlerOptions.message.cooldown, user.id));
+      setInterval(() => {
+        messageCommands.delete(user.id);
+      }, client.handlerOptions.message.cooldown);
+    }
+  }
+  if (command.commandType === "SlashCommand" /* SlashCommand */ && client.handlerOptions.slash.cooldown) {
+    if (slashCommands.has(user.id)) {
+      const usr = slashCommands.get(user.id);
+      usr.timeRemaining = usr.endsAt - Date.now();
+      downs.slash = usr;
+      res = true;
+    }
+    if (!slashCommands.has(user.id)) {
+      slashCommands.set(user.id, toCooldown(action, command, client.handlerOptions.slash.cooldown, user.id));
+      setInterval(() => {
+        slashCommands.delete(user.id);
+      }, client.handlerOptions.slash.cooldown);
+    }
+  }
+  if (command.commandType === "ContextCommand" /* ContextCommand */ && client.handlerOptions.context.cooldown) {
+    if (contextCommands.has(user.id)) {
+      const usr = contextCommands.get(user.id);
+      usr.timeRemaining = usr.endsAt - Date.now();
+      downs.context = usr;
+      res = true;
+    }
+    if (!contextCommands.has(user.id)) {
+      contextCommands.set(user.id, toCooldown(action, command, client.handlerOptions.context.cooldown, user.id));
+      setInterval(() => {
+        contextCommands.delete(user.id);
+      }, client.handlerOptions.context.cooldown);
+    }
+  }
+  if (client.settings?.cooldown?.default) {
+    if (cooldowns.has(user.id)) {
+      const usr = cooldowns.get(user.id);
+      usr.timeRemaining = usr.endsAt - Date.now();
+      downs.default = usr;
+      res = true;
+    }
+    if (!cooldowns.has(user.id)) {
+      cooldowns.set(user.id, toCooldown(action, command, client.settings.cooldown.default, user.id));
+      setInterval(() => {
+        cooldowns.delete(user.id);
+      }, client.settings.cooldown.default);
+    }
+  }
+  if (command.cooldown) {
+    const name = user.id + "-" + (command.data?.name || command?.name) + "-" + command.commandType;
+    if (commands.has(name)) {
+      const usr = commands.get(name);
+      usr.timeRemaining = usr.endsAt - Date.now();
+      downs.command = usr;
+      res = true;
+    }
+    if (!commands.has(name)) {
+      commands.set(name, toCooldown(action, command, command.cooldown, name));
+      setInterval(() => {
+        commands.delete(name);
+      }, command.cooldown);
+    }
+  }
+  if (Object.keys(downs).length > 0)
+    client.emit("commandCooldown", action, command, downs);
+  return res;
+}
+function toCooldown(action, command, cooldown, name) {
+  let user = getUser(action);
+  return {
+    name,
+    id: user.id,
+    tag: user.tag,
+    commandType: command.commandType,
+    commandName: command?.data?.name || command?.name,
+    guildId: action?.guild?.id,
+    channelId: action?.channel?.id,
+    startsAt: Number(Date.now()),
+    endsAt: Number(Date.now()) + cooldown
+  };
+}
+function handlerPermissions(client, commandType, type) {
+  let permissions = [];
+  if (commandType === "MessageCommand" /* MessageCommand */) {
+    if (type === "user")
+      permissions = client.handlerOptions.message?.userPermissions || [];
+    else if (type === "client")
+      permissions = client.handlerOptions.message?.clientPermissions || [];
+  } else if (commandType === "SlashCommand" /* SlashCommand */) {
+    if (type === "user")
+      permissions = client.handlerOptions.slash?.userPermissions || [];
+    else if (type === "client")
+      permissions = client.handlerOptions.slash?.clientPermissions || [];
+  } else if (commandType === "ContextCommand" /* ContextCommand */) {
+    if (type === "user")
+      permissions = client.handlerOptions.context?.userPermissions || [];
+    else if (type === "client")
+      permissions = client.handlerOptions.context?.clientPermissions || [];
+  }
+  return permissions;
+}
+
+// src/models/Events.ts
+var import_dumfunctions2 = require("dumfunctions");
+
+// src/validators/InhibitorValidations.ts
+var InhibitorValidation = class {
+  client;
+  action;
+  command;
+  inhibited;
+  constructor(client, action, command) {
+    this.client = client;
+    this.action = action;
+    this.command = command;
+    this.inhibited = {};
+  }
+  async inhibit() {
+    for (const inhibitor of this.client.inhibitors) {
+      const inhibit = inhibitor[1];
+      if (inhibit)
+        this.inhibited[inhibit.name] = await inhibit.check(this.action, this.args(this.action, inhibit.type));
+    }
+    for (const inhibit of Object.values(this.inhibited)) {
+      if (inhibit)
+        return this.inhibited;
+    }
+  }
+  args(action, type) {
+    if (type === "Channel" /* Channel */)
+      return action.channel;
+    if (type === "User" /* User */)
+      return action.author || action.user;
+    if (type === "Guild" /* Guild */)
+      return action.guild;
+    if (type === "Member" /* Member */)
+      return action.member;
+  }
+};
+
+// src/models/Events.ts
+var MessageCommandEvents = class {
+  client;
+  constructor(client) {
+    this.client = client;
+  }
+  messageCreate() {
+    this.client.on("messageCreate", async (message) => {
+      if (!message.author.bot) {
+        let command = void 0, px = void 0;
+        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).map(async (cmd) => {
+          if (cmd.prefix) {
+            cmd.prefix.map((prefix2) => {
+              if (message.content.startsWith(prefix2)) {
+                command = message.content.replace(prefix2, "").split(/ +/).shift();
+                px = prefix2;
+              }
+            });
+          }
+          if (this.client.handlerOptions.message?.prefix) {
+            const prefix2 = Array.isArray(this.client.handlerOptions.message.prefix) ? this.client.handlerOptions.message.prefix : [this.client.handlerOptions.message.prefix];
+            prefix2.map((prefix3) => {
+              if (message.content.startsWith(prefix3)) {
+                command = message.content.replace(prefix3, "").split(/ +/).shift();
+                px = prefix3;
+              }
+            });
+          }
+          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();
+              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 {
+              if (this.client.handlerOptions.message?.handleTyping)
+                message.channel.sendTyping();
+              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, await messageArguments(message, cmd)))
+                return;
+              await cmd.exec(message, await messageArguments(message, cmd));
+              this.client.emit("commandRun", message, cmd);
+            } catch (error) {
+              return this.client.emit("commandError", message, error, cmd);
+            }
+          }
+        });
+      }
+    });
+  }
+  messageUpdate() {
+    this.client.on("messageUpdate", async (old, message) => {
+      message = message;
+      if (!message.author?.bot) {
+        let command = void 0, px = void 0;
+        if (message.author)
+          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).map(async (cmd) => {
+          if (cmd.prefix) {
+            cmd.prefix.map((prefix2) => {
+              if (message?.content?.startsWith(prefix2)) {
+                command = message.content.replace(prefix2, "").split(/ +/).shift();
+                px = prefix2;
+              }
+            });
+          }
+          if (this.client.handlerOptions.message?.prefix) {
+            const prefix2 = Array.isArray(this.client.handlerOptions.message.prefix) ? this.client.handlerOptions.message.prefix : [this.client.handlerOptions.message.prefix];
+            prefix2.map((prefix3) => {
+              if (message?.content?.startsWith(prefix3)) {
+                command = message.content.replace(prefix3, "").split(/ +/).shift();
+                px = prefix3;
+              }
+            });
+          }
+          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();
+              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 {
+              if (this.client.handlerOptions.message?.handleTyping)
+                message.channel.sendTyping();
+              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, await messageArguments(message, cmd)))
+                return;
+              await cmd.exec(message, await messageArguments(message, cmd));
+              this.client.emit("commandRun", message, cmd);
+            } catch (error) {
+              return this.client.emit("commandError", message, error, cmd);
+            }
+          }
+        });
+      }
+    });
+  }
+  messageDelete() {
+    this.client.on("messageDelete", async (message) => {
+      if (this.client.cache.messages.has(message.id) && this.client.handlerOptions.message?.handleDeletes) {
+        try {
+          if (this.client.handlerOptions.message?.handleTyping)
+            message.channel.sendTyping();
+          const msg = this.client.cache.messages.get(message.id);
+          const response = await message.channel.messages.fetch(msg?.response);
+          await response.delete();
+        } catch (error) {
+          this.client.emit("commandError", message, error, null);
+        }
+      }
+    });
+  }
+};
+var SlashCommandEvents = class {
+  client;
+  constructor(client) {
+    this.client = client;
+  }
+  slashCreate() {
+    this.client.on("interactionCreate", async (interaction) => {
+      interaction.util = new InteractionCommandUtil(this.client, interaction);
+      interaction.user.isOwner = this.client.util.isOwner(interaction.user.id);
+      if (interaction.type === import_discord3.InteractionType.ApplicationCommand) {
+        if (this.client.commands.slash.has(interaction.commandName)) {
+          let command = this.client.commands.slash.get(interaction.commandName);
+          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()
+            }))
+              return;
+            await command.exec(interaction, {
+              group: argumentsInfo.group(),
+              subcommand: argumentsInfo.subcommand(),
+              args: await argumentsInfo.arguments()
+            });
+            this.client.emit("commandRun", interaction, command);
+          } catch (error) {
+            this.client.emit("commandError", interaction, error, command);
+          }
+        }
+      }
+    });
+  }
+};
+var ContextCommandEvents = class {
+  client;
+  constructor(client) {
+    this.client = client;
+  }
+  contextCreate() {
+    this.client.on("interactionCreate", async (interaction) => {
+      interaction.util = new InteractionCommandUtil(this.client, interaction);
+      interaction.user.isOwner = this.client.util.isOwner(interaction.user.id);
+      if (interaction.type === import_discord3.InteractionType.ApplicationCommand) {
+        if (this.client.commands.context.has(interaction.commandName)) {
+          let command = this.client.commands.context.get(interaction.commandName);
+          try {
+            const inhibitor = new InhibitorValidation(this.client, interaction, command);
+            if (commandValidation(interaction, command, this.client))
+              return;
+            if (await inhibitor.inhibit())
+              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
+              });
+            let args = {};
+            if (command.type === 3)
+              args = await interaction.channel.messages.fetch(interaction.targetId);
+            if (command.type === 2)
+              args = await this.client.users.fetch(interaction.targetId);
+            await command.exec(interaction, args);
+            this.client.emit("commandRun", interaction, command);
+          } catch (error) {
+            this.client.emit("commandError", interaction, error, command);
+          }
+        }
+      }
+    });
+  }
+};
+var CommandsDeploy = class {
+  client;
+  constructor(client) {
+    this.client = client;
+  }
+  deploy() {
+    this.client.once("ready", async (client) => {
+      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 {
+        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(
+              import_dumfunctions2.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: import_dumfunctions2.Style.TextColor.Red }
+              )
+            );
+          this.put("global", guild.slash, [...contextCommands, ...slashCommands]);
+          this.put("guild", guild.slash, []);
+        }
+        if (global.slash && global.context === false) {
+          this.put("global", guild.slash, slashCommands);
+        }
+        if (global.slash === false && global.context) {
+          this.put("global", guild.context, contextCommands);
+        }
+        if (global.slash === false && global.context === false) {
+          this.put("guild", guild.slash, [...contextCommands, ...slashCommands]);
+        }
+        if (this.client.handlerOptions.context?.logging || this.client.handlerOptions.slash?.logging)
+          console.info(
+            import_dumfunctions2.Style.log(
+              `Xernerx | Deployed ${slashCommands.length} slash commands ${global.slash ? "globally" : "locally"} and ${contextCommands.length} context commands ${global.context ? "globally" : "locally"}.`,
+              { color: import_dumfunctions2.Style.TextColor.Purple }
+            )
+          );
+      } catch (error) {
+        console.error(
+          import_dumfunctions2.Style.log(`Xernerx | Couldn't deploy interaction commands because <${error}>.`, {
+            color: import_dumfunctions2.Style.BackgroundColor.Red
+          })
+        );
+      }
+    });
+  }
+  put(type, guild, body) {
+    const rest = new import_discord3.REST({ version: import_discord3.GatewayVersion }).setToken(this.client.token);
+    if (type === "guild")
+      rest.put(import_discord3.Routes.applicationGuildCommands(this.client.user?.id, guild), { body });
+    else
+      rest.put(import_discord3.Routes.applicationCommands(this.client.user?.id), { body });
+  }
+};
+
+// src/handlers/CommandHandler.ts
+var CommandHandler = class {
+  client;
+  handler;
+  constructor(client) {
+    this.client = client;
+    this.handler = new Handler(client);
+    new CommandsDeploy(this.client).deploy();
+  }
+  /**
+   * @description - The message command loader.
+   * @param {MessageCommandOptions} options - message command loader options.
+   */
+  loadAllMessageCommands(options) {
+    this.handler.loadAllMessageCommands(options);
+    const events = new MessageCommandEvents(this.client);
+    events.messageCreate();
+    events.messageUpdate();
+    events.messageDelete();
+  }
+  /**
+   * @description - The slash command loader.
+   * @param {SlashCommandOptions} options - slash command loader options.
+   */
+  loadAllSlashCommands(options) {
+    this.handler.loadAllSlashCommands(options);
+    new SlashCommandEvents(this.client).slashCreate();
+  }
+  /**
+   * @description - The context command loader.
+   * @param {ContextCommandOptions} options - context command loader options.
+   */
+  loadAllContextCommands(options) {
+    this.handler.loadAllContextCommands(options);
+    new ContextCommandEvents(this.client).contextCreate();
+  }
+};
+
+// src/handlers/EventHandler.ts
+var EventHandler = class {
+  client;
+  handler;
+  constructor(client) {
+    this.client = client;
+    this.handler = new Handler(client);
+  }
+  /**
+   * @description - The event loader
+   * @param {EventLoadOptions} options - message command options
+   */
+  loadAllEvents(options) {
+    return this.handler.loadAllEvents(options);
+  }
+};
+
+// src/handlers/InhibitorHandler.ts
+var InhibitorHandler = class {
+  client;
+  handler;
+  constructor(client) {
+    this.client = client;
+    this.handler = new Handler(client);
+  }
+  /**
+   * @description - The loader for all inhibitors.
+   * @param {InhibitorLoadOptions} options - the inhibitor loader options.
+   * @returns undefined
+   */
+  loadAllInhibitors(options) {
+    this.handler.loadAllInhibitors(options);
+  }
+};
+
+// src/models/Extensions.ts
+var import_dumfunctions3 = require("dumfunctions");
+var Extensions = class {
+  client;
+  constructor(client) {
+    this.client = client;
+  }
+  async load(extensions, logging = false) {
+    const exts = [];
+    extensions.map((extension) => {
+      try {
+        this.client.extensions[extension.name] = extension;
+        exts.push(extension.name);
+      } catch (error) {
+        console.error(
+          import_dumfunctions3.Style.log(`Xernerx | An error occurred trying to load ${extension.name}, error: <${error}>`, {
+            color: import_dumfunctions3.Style.BackgroundColor.Red
+          })
+        );
+      }
+    });
+    if (logging)
+      console.info(import_dumfunctions3.Style.log(`Xernerx | Loaded ${exts.length} extensions: ${exts.join(", ")}`, { color: import_dumfunctions3.Style.TextColor.Cyan }));
+  }
+};
+
+// src/client/XernerxClient.ts
+var XernerxClient = class extends import_discord4.Client {
+  settings;
+  commands;
+  cache;
+  modules;
+  util;
+  handlerOptions;
+  events;
+  extensions;
+  inhibitors;
+  config;
+  constructor(discordOptions, clientOptions, config) {
+    super(discordOptions);
+    this.settings = import_zod.z.object({
+      ownerId: import_zod.z.string().or(import_zod.z.array(import_zod.z.string())).default([]),
+      permissions: import_zod.z.object({
+        client: import_zod.z.array(import_zod.z.string()).default([]),
+        user: import_zod.z.array(import_zod.z.string()).default([]),
+        dm: import_zod.z.boolean().default(false)
+      }).optional(),
+      ignore: import_zod.z.object({
+        owner: import_zod.z.boolean().default(false),
+        users: import_zod.z.array(import_zod.z.string()),
+        channels: import_zod.z.array(import_zod.z.string()),
+        guilds: import_zod.z.array(import_zod.z.string())
+      }).optional(),
+      log: import_zod.z.object({
+        ready: import_zod.z.boolean().default(false),
+        error: import_zod.z.boolean().default(false)
+      }).optional(),
+      cooldown: import_zod.z.object({
+        command: import_zod.z.number().default(0),
+        cache: import_zod.z.number().default(0)
+      }).optional()
+    }).parse(clientOptions);
+    this.config = config || {};
+    this.commands = {
+      message: new import_discord4.Collection(),
+      slash: new import_discord4.Collection(),
+      context: new import_discord4.Collection()
+    };
+    this.events = new import_discord4.Collection();
+    this.inhibitors = new import_discord4.Collection();
+    this.cache = {
+      messages: new import_discord4.Collection(),
+      cooldowns: new import_discord4.Collection(),
+      messageCommands: new import_discord4.Collection(),
+      slashCommands: new import_discord4.Collection(),
+      contextCommands: new import_discord4.Collection(),
+      commands: new import_discord4.Collection()
+    };
+    this.modules = {
+      commandHandler: new CommandHandler(this),
+      eventHandler: new EventHandler(this),
+      inhibitorHandler: new InhibitorHandler(this)
+    };
+    this.extensions = {};
+    this.util = new ClientUtil(this);
+    this.handlerOptions = {};
+    if (this.settings?.log?.ready) {
+      this.once("ready", async (client) => {
+        const size = (await client.guilds.fetch()).size;
+        console.info(
+          import_dumfunctions4.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: import_dumfunctions4.Style.TextColor.Purple }
+          )
+        );
+      });
+    }
+  }
+  register(token) {
+    this.login(token);
+  }
+  loadAllExtensions(options) {
+    const extensions = new Extensions(this);
+    return extensions.load(options.extensions, options.logging || false);
+  }
+};
+
+// src/build/EventBuilder.ts
+var import_zod2 = require("zod");
+var EventBuilder = class {
+  id;
+  name;
+  emitter;
+  type;
+  once;
+  client;
+  constructor(id, options) {
+    this.id = id;
+    import_zod2.z.object({
+      name: import_zod2.z.string(),
+      emitter: import_zod2.z.string().optional(),
+      type: import_zod2.z.string().optional(),
+      once: import_zod2.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() {
+  }
+};
+
+// src/build/InhibitorBuilder.ts
+var import_zod3 = require("zod");
+var InhibitorBuilder = class {
+  id;
+  name;
+  type;
+  client;
+  constructor(id, options) {
+    this.id = id;
+    import_zod3.z.object({
+      name: import_zod3.z.string(),
+      type: import_zod3.z.string()
+    }).parse(options);
+    this.name = options.name;
+    this.type = options.type;
+    this.client = XernerxClient;
+  }
+  /**
+   * TODO - update description
+   */
+  async check(interaction, args) {
+  }
+};
+
+// src/build/MessageCommandBuilder.ts
+var import_zod4 = require("zod");
+var MessageCommandBuilder = class {
+  id;
+  name;
+  aliases;
+  separator;
+  description;
+  info;
+  category;
+  prefix;
+  regex;
+  channelType;
+  ignore;
+  strict;
+  permissions;
+  cooldown;
+  args;
+  client;
+  constructor(id, options) {
+    this.id = id;
+    import_zod4.z.object({
+      name: import_zod4.z.string(),
+      aliases: import_zod4.z.array(import_zod4.z.string()).optional(),
+      separator: import_zod4.z.string().min(1).max(1).optional(),
+      description: import_zod4.z.string().optional(),
+      info: import_zod4.z.string().optional(),
+      category: import_zod4.z.string().optional(),
+      prefix: import_zod4.z.array(import_zod4.z.string()).or(import_zod4.z.string()).optional(),
+      regex: import_zod4.z.unknown(),
+      channelType: import_zod4.z.array(import_zod4.z.number()).or(import_zod4.z.number()).optional(),
+      cooldown: import_zod4.z.number().optional(),
+      ignore: import_zod4.z.object({
+        owners: import_zod4.z.boolean().optional(),
+        users: import_zod4.z.array(import_zod4.z.string()).or(import_zod4.z.string()).optional(),
+        channels: import_zod4.z.array(import_zod4.z.string()).or(import_zod4.z.string()).optional(),
+        guilds: import_zod4.z.array(import_zod4.z.string()).or(import_zod4.z.string()).optional()
+      }).optional(),
+      strict: import_zod4.z.object({
+        owners: import_zod4.z.boolean().optional(),
+        users: import_zod4.z.array(import_zod4.z.string()).or(import_zod4.z.string()).optional(),
+        channels: import_zod4.z.array(import_zod4.z.string()).or(import_zod4.z.string()).optional(),
+        guilds: import_zod4.z.array(import_zod4.z.string()).or(import_zod4.z.string()).optional()
+      }).optional(),
+      permissions: import_zod4.z.object({
+        client: import_zod4.z.array(import_zod4.z.string()).optional(),
+        users: import_zod4.z.array(import_zod4.z.string()).optional(),
+        dm: import_zod4.z.boolean().optional()
+      }).optional()
+    }).parse(options);
+    this.name = options.name;
+    this.aliases = options.aliases;
+    this.separator = options.separator || " ";
+    this.description = options.description;
+    this.info = options.info;
+    this.category = options.category;
+    this.prefix = options.prefix ? Array.isArray(options.prefix) ? options.prefix : [options.prefix] : [];
+    this.regex = options.regex;
+    this.channelType = options.channelType;
+    this.ignore = options.ignore;
+    this.strict = options.strict;
+    this.permissions = options.permissions;
+    this.cooldown = options.cooldown || 0;
+    this.args = options.args || [];
+    this.client = XernerxClient;
+  }
+  /**
+   * @param {Message} message - The Discord message event data.
+   * @param {object} args - The arguments you created.
+   * @description make any preconditions here.
+   */
+  async conditions(message, args) {
+  }
+  /**
+   * @param {Message} message - The Discord message event data.
+   * @param {object} args - The arguments you created.
+   * @description Make your custom command here.
+   */
+  async exec(message, args) {
+  }
+};
+
+// src/build/ContextCommandBuilder.ts
+var import_discord5 = require("discord.js");
+var import_zod5 = require("zod");
+var ContextCommandBuilder = class {
+  id;
+  data;
+  name;
+  type;
+  description;
+  info;
+  category;
+  channelType;
+  cooldown;
+  ignore;
+  strict;
+  permissions;
+  defer;
+  client;
+  constructor(id, options) {
+    this.id = id;
+    this.data = new import_discord5.ContextMenuCommandBuilder();
+    if (options.name)
+      this.data.setName(options.name);
+    if (options.type)
+      this.data.setType(options.type);
+    if (options.permissions?.users)
+      this.data.setDefaultMemberPermissions(options.permissions?.users);
+    if (options.permissions?.dm === false)
+      this.data.setDMPermission(options.permissions?.dm);
+    if (options.nameLocalizations)
+      this.data.setNameLocalizations(options.nameLocalizations);
+    import_zod5.z.object({
+      description: import_zod5.z.string(),
+      info: import_zod5.z.string(),
+      category: import_zod5.z.string(),
+      channelType: import_zod5.z.array(import_zod5.z.number()).or(import_zod5.z.number()),
+      cooldown: import_zod5.z.number(),
+      ignore: import_zod5.z.object({
+        owner: import_zod5.z.boolean(),
+        users: import_zod5.z.array(import_zod5.z.string()),
+        channels: import_zod5.z.array(import_zod5.z.string()),
+        guilds: import_zod5.z.array(import_zod5.z.string())
+      }),
+      strict: import_zod5.z.object({
+        owner: import_zod5.z.boolean(),
+        users: import_zod5.z.array(import_zod5.z.string()),
+        channels: import_zod5.z.array(import_zod5.z.string()),
+        guilds: import_zod5.z.array(import_zod5.z.string())
+      }),
+      permissions: import_zod5.z.object({
+        client: import_zod5.z.array(import_zod5.z.string()),
+        users: import_zod5.z.array(import_zod5.z.string()),
+        dm: import_zod5.z.boolean()
+      }),
+      defer: import_zod5.z.object({
+        reply: import_zod5.z.boolean(),
+        ephemeral: import_zod5.z.boolean(),
+        fetch: import_zod5.z.boolean()
+      })
+    }).deepPartial().parse(options);
+    this.name = options.name;
+    this.type = options.type;
+    this.description = options.description;
+    this.info = options.info;
+    this.category = options.category;
+    this.channelType = options.channelType;
+    this.cooldown = options.cooldown;
+    this.ignore = options.ignore;
+    this.strict = options.strict;
+    this.permissions = options.permissions;
+    this.defer = options.defer;
+    this.client = XernerxClient;
+  }
+  /**
+   * @param {Interaction} interaction - The Discord interaction event data.
+   * @description make any preconditions here.
+   * TODO - update description
+   */
+  async conditions(interaction, args) {
+  }
+  /**
+   * @param {Interaction} interaction - The Discord interaction event data.
+   * @description Make your custom command here.
+   * TODO - update description
+   */
+  async exec(interaction, args) {
+  }
+};
+
+// src/build/SlashCommandBuilder.ts
+var import_discord6 = __toESM(require("discord.js"), 1);
+var import_zod6 = require("zod");
+var SlashCommandBuilder = class {
+  id;
+  data;
+  name;
+  description;
+  info;
+  category;
+  channelType;
+  cooldown;
+  ignore;
+  strict;
+  permissions;
+  args;
+  subcommands;
+  groups;
+  defer;
+  client;
+  constructor(id, options) {
+    this.id = id;
+    this.data = new import_discord6.default.SlashCommandBuilder().setName(options.name).setDescription(options.description);
+    if (options.args && options?.args?.length > 0) {
+      this.addArgs(this.data, options.args);
+    }
+    if (options.subcommands && options?.subcommands?.length > 0) {
+      this.addSubcommands(this.data, options.subcommands);
+    }
+    if (options.groups && options?.groups?.length > 0) {
+      this.addSubcommandGroups(options.groups);
+    }
+    import_zod6.z.object({
+      description: import_zod6.z.string(),
+      info: import_zod6.z.string(),
+      category: import_zod6.z.string(),
+      channelType: import_zod6.z.array(import_zod6.z.number()).or(import_zod6.z.number()),
+      cooldown: import_zod6.z.number(),
+      ignore: import_zod6.z.object({
+        owner: import_zod6.z.boolean(),
+        users: import_zod6.z.array(import_zod6.z.string()),
+        channels: import_zod6.z.array(import_zod6.z.string()),
+        guilds: import_zod6.z.array(import_zod6.z.string())
+      }),
+      strict: import_zod6.z.object({
+        owner: import_zod6.z.boolean(),
+        users: import_zod6.z.array(import_zod6.z.string()),
+        channels: import_zod6.z.array(import_zod6.z.string()),
+        guilds: import_zod6.z.array(import_zod6.z.string())
+      }),
+      permissions: import_zod6.z.object({
+        client: import_zod6.z.array(import_zod6.z.string()),
+        users: import_zod6.z.array(import_zod6.z.string()),
+        dm: import_zod6.z.boolean()
+      }),
+      defer: import_zod6.z.object({
+        reply: import_zod6.z.boolean(),
+        ephemeral: import_zod6.z.boolean(),
+        fetch: import_zod6.z.boolean()
+      })
+    }).deepPartial().parse(options);
+    this.name = options.name;
+    this.description = options.description;
+    this.info = options.info;
+    this.category = options.category;
+    this.channelType = options.channelType;
+    this.cooldown = options.cooldown;
+    this.ignore = options.ignore;
+    this.strict = options.strict;
+    this.permissions = options.permissions;
+    this.defer = options.defer;
+    this.client = XernerxClient;
+  }
+  /**
+   * TODO - update description
+   * @param interaction
+   */
+  async conditions(interaction) {
+  }
+  /**
+   * TODO - update description
+   * @param interaction
+   */
+  async exec(interaction) {
+  }
+  addArgs(command, args) {
+    const types = ["boolean", "integer", "number", "string", "user", "role", "channel", "mentionable"];
+    for (const argument of args) {
+      if (!types.includes(argument.type.toLowerCase()))
+        throw new XernerxError(`Expected one of ${types.join(", ")}, received ${argument.type} instead.`);
+      let slashArgumentType = `${argument.type.slice(0, 1).toUpperCase()}${argument.type.slice(1).toLowerCase()}`;
+      command[`add${slashArgumentType}Option`]((option) => {
+        option.setName(argument.name).setDescription(argument.description).setRequired(argument.required || false);
+        if (argument.choices)
+          option.setChoices(...argument?.choices);
+        return option;
+      });
+    }
+  }
+  addSubcommands(method, subcommands) {
+    for (const subcommand of subcommands) {
+      let sub = new import_discord6.SlashCommandSubcommandBuilder().setName(subcommand.name).setDescription(subcommand.description);
+      if (subcommand.args?.length > 0)
+        this.addArgs(sub, subcommand.args);
+      method.addSubcommand(sub);
+    }
+  }
+  addSubcommandGroups(groups) {
+    for (const group of groups) {
+      let subcommandGroup = new import_discord6.SlashCommandSubcommandGroupBuilder().setName(group.name).setDescription(group.description);
+      if (group.subcommands?.length > 0)
+        this.addSubcommands(subcommandGroup, group.subcommands);
+      this.data.addSubcommandGroup(subcommandGroup);
+    }
+  }
+};
+
+// src/tools/package.ts
+var package_default = {
+  name: "xernerx",
+  version: "3.4.3",
+  type: "module",
+  description: "A bot framework for discord.js.",
+  main: "dist/main.js",
+  keywords: ["discord.js", "discord", "framework"],
+  author: "Dummi",
+  license: "MIT",
+  homepage: "https://xernerx.github.io/xernerx/home.html",
+  packageManager: "npm@8.5.5",
+  scripts: {
+    start: "npm i && npm fund && npm audit fix --force && npm link && tsc -w",
+    patch: "npm run build && tsc && git add . && npm run commit && npm version patch && npm publish && git push",
+    minor: "npm run build && tsc && git add . && npm run commit && npm version minor && npm publish && git push",
+    major: "npm run build && tsc && git add . && npm run commit && npm version major && npm publish && git push",
+    site: "git add docs && npm run commit && git push",
+    commit: "node ../.scripts/commit.js",
+    build: "node ../.scripts/rewritePackage.js"
+  },
+  repository: {
+    type: "git",
+    url: "git+https://github.com/xernerx/xernerx.git"
+  },
+  bugs: {
+    url: "https://github.com/xernerx/xernerx/issues"
+  },
+  dependencies: {
+    "@sapphire/shapeshift": "^3.8.1",
+    "discord.js": "^14.7.0",
+    dumfunctions: "^2.0.0",
+    "xernerx-extension-builder": "^0.0.2"
+  },
+  devDependencies: {
+    typescript: "^4.9.4"
+  }
+};
+
+// src/main.ts
+var xernerxVersion = package_default.version;
+var main_default = {
+  // Client
+  Client: XernerxClient,
+  XernerxClient,
+  // Enums
+  CommandType,
+  EventEmitterType,
+  InhibitorType,
+  ContextCommandType,
+  // Builds
+  EventBuilder,
+  MessageCommandBuilder,
+  ContextCommandBuilder,
+  SlashCommandBuilder,
+  InhibitorBuilder,
+  ExtensionBuilder: import_xernerx_extension_builder.default,
+  XernerxError,
+  // Constants
+  version: xernerxVersion
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  CommandType,
+  ContextCommandBuilder,
+  ContextCommandType,
+  EventBuilder,
+  EventEmitterType,
+  ExtensionBuilder,
+  InhibitorBuilder,
+  InhibitorType,
+  MessageCommandBuilder,
+  SlashCommandBuilder,
+  XernerxClient,
+  XernerxError,
+  xernerxVersion
+});