xernerx 0.1.120-beta.2 → 0.1.120-beta.21

package/dist/main.js

@@ -1,122 +1,190 @@
-import * as Discord from 'discord.js';
-import { z } from 'zod';
-import sharpyy2, { link } from 'sharpyy';
-import * as fs from 'fs';
-import * as path from 'path';
-import path__default from 'path';
+import { ClusterManager, getInfo, ClusterClient } from 'discord-hybrid-sharding';
+import sharpyy8 from 'sharpyy';
+import fs from 'fs';
+import ora from 'ora';
+import boxen from 'boxen';
+import { User, SKUType, EntitlementType, MessageFlags, REST, GatewayVersion, Routes, Client, Collection, ChannelType, SlashCommandBuilder, InteractionContextType, ApplicationIntegrationType, PermissionFlagsBits, SlashCommandSubcommandBuilder, SlashCommandSubcommandGroupBuilder } from 'discord.js';
+export * from 'discord.js';
+import z2, { z } from 'zod';
+import { MonetizationAPI } from '@discordjs/core';
+import path from 'path';
 
 var __defProp = Object.defineProperty;
 var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
-var XernerxLog_default = new class XernerxLog {
+var XernerxBase = class {
   static {
-    __name(this, "XernerxLog");
+    __name(this, "XernerxBase");
   }
   constructor() {
-    this.baseText = `${sharpyy2("XERNERX", "txRainbow", "bold")} | ${(/* @__PURE__ */ new Date()).toLocaleTimeString().split(/ /gim).map(
-      (str) => str.split(":").map((str2) => isNaN(Number(str2)) ? str2 : sharpyy2(str2, "txCyan")).join(":")
-    ).join(" ")} | ${sharpyy2(String(Math.round(process.memoryUsage().rss / 1e4) / 100), "txCyan")}mb |`;
+    this.base = () => `| ${sharpyy8("XERNERX", "txRainbow", "bold")} | ${(/* @__PURE__ */ new Date()).toLocaleTimeString().split("").map((c) => Number.isNaN(Number(c)) ? sharpyy8(c, "txWhite") : sharpyy8(c, "txCyan")).join("")} | ${sharpyy8(String(Math.round(process.memoryUsage().rss / 1e6)), "txCyan")}mb | `;
   }
-  info(message) {
-    return console.info(`\u2714\uFE0F  |`, this.baseText, message);
+};
+
+// src/tools/XernerxInfo.ts
+var XernerxInfo = class extends XernerxBase {
+  static {
+    __name(this, "XernerxInfo");
   }
-  async error(message, error) {
-    const { default: boxen } = await import('boxen');
-    const errorMessage = boxen(error?.stack, { padding: 1, margin: 1, borderStyle: "round", borderColor: "red" });
-    if (error) return console.error(`\u2757 |`, this.baseText, message, errorMessage);
-    else return console.error(`\u2757 |`, this.baseText, message);
+  constructor(message) {
+    super();
+    ora().info(`${this.base()}${message}`);
   }
-  warn(message, url) {
-    console.warn(`\u26A0\uFE0F  |`, this.baseText, message, url ? `Read more here ${link("here", url)}` : "");
+};
+var XernerxError = class extends XernerxBase {
+  static {
+    __name(this, "XernerxError");
   }
-  debug(message) {
-    return console.debug(`\u{1F41B} |`, this.baseText, message);
+  constructor(message, exit = 0) {
+    super();
+    ora().fail(`${this.base()}${sharpyy8(message, "txRed")}`);
+    exit ? process.exit(exit) : null;
   }
-  async box(message, color, title) {
-    const { default: boxen } = await import('boxen');
-    const time = (/* @__PURE__ */ new Date()).toLocaleTimeString().split(/ /gim).map(
-      (str) => str.split(":").map((str2) => isNaN(Number(str2)) ? str2 : sharpyy2(str2, "txCyan")).join(":")
-    ).join(" ");
-    return console.info(boxen(message, { padding: 1, margin: 1, borderStyle: "round", borderColor: color, title: `${time} - ${sharpyy2("XERNERX", "txRainbow", "bold")} - ${title || ""}` }));
+};
+var XernerxSuccess = class extends XernerxBase {
+  static {
+    __name(this, "XernerxSuccess");
   }
-}();
+  constructor(message) {
+    super();
+    ora().succeed(`${this.base()}${message}`);
+  }
+};
+var XernerxInitial = class extends XernerxBase {
+  static {
+    __name(this, "XernerxInitial");
+  }
+  constructor(type) {
+    super();
+    console.clear();
+    console.info(
+      boxen(sharpyy8("XERNERX", "txRainbow", "bold"), {
+        borderStyle: "round",
+        borderColor: "magenta",
+        textAlignment: "center",
+        fullscreen: /* @__PURE__ */ __name((width, height) => [width, 4], "fullscreen")
+      })
+    );
+    const spinner = ora().start(`${this.base()}${type == "Client" ? "Starting..." : "Sharding..."}`);
+    setInterval(() => spinner.text = `${this.base()}`, 500);
+  }
+};
 
-// src/util/prompts.ts
-var init = false;
-async function start(client) {
-  if (init) return;
-  if (client.settings.debug) XernerxLog_default.info("Debug mode enabled, preventing console clear and logging all handlings...");
-  else console.clear();
-  const { default: ora, spinners } = await import('ora');
-  const { default: boxen } = await import('boxen');
-  console.info(
-    boxen(sharpyy2("XERNERX", "txRainbow", "bold", "underlines"), {
-      padding: 1,
-      margin: 1,
-      borderStyle: "round",
-      height: 3,
-      align: "center",
-      borderColor: "magenta",
-      fullscreen: /* @__PURE__ */ __name((width, height) => [width - 5, height], "fullscreen")
-    })
-  );
-  if (!client.options.intents.has("Guilds"))
-    XernerxLog_default.warn("Your bot is signed in without the Guilds intent, this may cause issues with the bot.", new URL("https://discord.com/developers/docs/topics/gateway#gateway-intents"));
-  const spinner = ora();
-  spinner.spinner = spinners.dots12;
-  spinner.start();
-  let index = 0;
-  setInterval(async () => {
-    calculateStats(client);
-    const time = (/* @__PURE__ */ new Date()).toLocaleTimeString().split(/ /gim).map(
-      (str) => str.split(":").map((str2) => isNaN(Number(str2)) ? str2 : sharpyy2(str2, "txCyan")).join(":")
-    ).join(" "), ram = `${sharpyy2(String(Math.round(process.memoryUsage().rss / 1e4) / 100), "txCyan")}mb`;
-    const colors = ["red", "green", "yellow", "blue", "magenta", "cyan"];
-    const baseText = `${sharpyy2("XERNERX", "txRainbow", "bold")} | ${time} | ${ram} | `;
-    if (client.user) {
-      spinner.color = colors[index];
-      const counts = {
-        local: client.commands.stats.slash.local + client.commands.stats.message.local + client.commands.stats.context.local,
-        global: client.commands.stats.slash.global + client.commands.stats.message.global + client.commands.stats.context.global
-      };
-      spinner.text = boxen(
-        Object.entries({
-          "Name": sharpyy2(client.user.tag, "txBlue"),
-          "Status": `${sharpyy2("Online", "txGreen")} | ${client.settings.global ? sharpyy2("Global", "txGreen") : sharpyy2("Local", "txRed")}`,
-          "Uptime": client.util.uptime(client.uptime).split("").map((c) => isNaN(Number(c)) ? c : sharpyy2(c, "txCyan")).join(""),
-          "Commands": client.settings.global ? `${counts.local ? `local: ${counts.local}` : ""}|${counts.global ? `global: ${counts.global}` : ""}` : counts.local + counts.global,
-          "RAM Usage": ram,
-          "Guilds": (await Promise.all(client.settings.guilds.map(async (id) => sharpyy2((await client.guilds.fetch(id))?.name || id, "txBlue")))).join(", "),
-          "Owners": (await Promise.all(client.settings.owners.map(async (id) => sharpyy2((await client.users.fetch(id))?.username || id, "txBlue")))).join(", "),
-          "GuildCount": sharpyy2(String(client.stats.guilds), "txCyan"),
-          "UserCount": sharpyy2(String(client.stats.users), "txCyan"),
-          "ShardCount": sharpyy2(String(client.stats.shardCount), "txCyan")
-        }).map(([key, value]) => `${key}: ${value}`).join("\n"),
-        {
-          padding: 1,
-          margin: 1,
-          borderStyle: "round",
-          borderColor: "magenta",
-          title: time + " - " + sharpyy2("XERNERX", "txRainbow", "bold") + "\x1B[35m",
-          height: 15,
-          fullscreen: /* @__PURE__ */ __name((width, height) => [width - 5, height], "fullscreen")
-        }
-      );
-    } else {
-      spinner.color = "green";
-      spinner.text = baseText + `Connecting to Discord${index == 0 ? "." : index == 1 ? ".." : index == 2 ? "..." : ""}`;
-    }
-    index++;
-    if (index == colors.length - 1) index = 0;
-  }, 250);
-  init = true;
-}
-__name(start, "start");
-function calculateStats(client) {
-  client.stats.guilds = client.guilds.cache.size;
-  client.stats.users = client.users.cache.size;
-  client.stats.shardCount = client.options.shardCount || null;
-}
-__name(calculateStats, "calculateStats");
+// src/client/XernerxShardClient.ts
+var XernerxShardClient = class extends ClusterManager {
+  static {
+    __name(this, "XernerxShardClient");
+  }
+  constructor(options) {
+    new XernerxInitial("ShardClient");
+    try {
+      new XernerxInfo(`Loading ShardClient from ${sharpyy8(options.file, "bgGray")}`);
+      fs.readFileSync(options.file), "utf-8";
+      new XernerxSuccess(`ShardClient loaded successfully`);
+    } catch {
+      new XernerxError(`File ${sharpyy8(options.file, "bgGray")} not found.`, 1);
+    }
+    super(options.file, options);
+    this.onlineShards = /* @__PURE__ */ new Set();
+    this.stats = {
+      onlineSince: Number(/* @__PURE__ */ new Date()),
+      guildCount: null,
+      userCount: null,
+      shardCount: null,
+      voteCount: null,
+      shards: []
+    };
+    this.on("clusterCreate", (cluster) => {
+      new XernerxInfo(`${sharpyy8(`Shard ${cluster.id}`, "txCyan")} | Creating...`);
+      cluster.on("ready", () => {
+        this.onlineShards.add(cluster);
+        if (this.onlineShards.size == (this.totalClusters || this.totalShards)) this.#update();
+      });
+      cluster.on("disconnect", () => {
+        this.onlineShards.delete(cluster);
+      });
+      cluster.on("death", (error) => {
+        this.onlineShards.delete(cluster);
+      });
+    });
+    this.spawn({ timeout: -1 });
+  }
+  async #update() {
+    await new Promise((resolve) => setTimeout(resolve, 1e3));
+    setInterval(async () => {
+      const stats = await this.fetchClientValues("stats");
+      const shards = await this.fetchClientValues("stats.shard");
+      this.stats.guildCount = stats[0].guildCount;
+      this.stats.userCount = stats[0].userCount;
+      this.stats.shardCount = stats[0].shardCount;
+      this.stats.voteCount = stats[0].voteCount;
+      this.stats.shards = shards;
+    }, 1e3);
+    await new Promise((resolve) => setTimeout(resolve, 4e3));
+    new XernerxSuccess(
+      `All Shards are online! Watching ${sharpyy8(String(this.stats.guildCount?.toLocaleString()), "txCyan")} guilds and users: ${sharpyy8(String(this.stats.userCount?.toLocaleString()), "txCyan")}, and ${sharpyy8(String(this.stats.shardCount?.toLocaleString()), "txCyan")} shards.`
+    );
+  }
+};
+var XernerxMonitisation = class extends MonetizationAPI {
+  static {
+    __name(this, "XernerxMonitisation");
+  }
+  constructor(client) {
+    super(client.rest);
+    this.client = client;
+  }
+  /**
+   * Consumes an entitlement for the current user.
+   *
+   * @param id - The unique identifier of the entitlement to be consumed.
+   * @param options - Optional request options specifying authentication or signaling method.
+   * @returns A promise that resolves when the entitlement is successfully consumed.
+   */
+  consume(id, options) {
+    return this.consumeEntitlement(this.client.user.id, id, options);
+  }
+  /**
+   * Retrieves entitlements for the current user.
+   *
+   * @param id - An optional query object to filter entitlements.
+   * @param options - Optional request options specifying authentication or signaling method.
+   * @returns A promise that resolves with the entitlements for the current user.
+   */
+  entitlements(id, options) {
+    return this.getEntitlements(this.client.user.id, id || {}, options);
+  }
+  /**
+   * Retrieves the Stock Keeping Units (SKUs) for the current user.
+   *
+   * @param options - Optional request options specifying authentication or signaling method.
+   * @returns A promise that resolves with the SKUs for the current user.
+   */
+  sku(options) {
+    return this.getSKUs(this.client.user.id, options);
+  }
+  /**
+   * Creates a test entitlement for a specified user and SKU.
+   *
+   * @param id - The unique identifier of the SKU for which the entitlement is to be created.
+   * @param user - The unique identifier of the user who will own the entitlement.
+   * @returns A promise that resolves with the created test entitlement, or undefined if the SKU is not found.
+   */
+  async create(id, user) {
+    const skus = await this.sku();
+    const sku = skus.find((s) => s.id === id);
+    if (!sku) return;
+    return await this.createTestEntitlement(this.client.user.id, { owner_id: user, owner_type: sku.type == 5 ? 2 : 1, sku_id: id });
+  }
+  /**
+   * Deletes a test entitlement for the current user.
+   *
+   * @param id - The unique identifier of the test entitlement to be deleted.
+   * @returns A promise that resolves when the test entitlement is successfully deleted.
+   */
+  delete(id) {
+    return this.deleteTestEntitlement(this.client.user.id, id);
+  }
+};
 var Handler = class {
   static {
     __name(this, "Handler");
@@ -124,203 +192,1145 @@ var Handler = class {
   constructor(client) {
     this.client = client;
   }
-  async readdir(directory) {
-    const dirpath = path.resolve(directory);
-    if (this.client.settings.debug) XernerxLog_default.debug(`Attempting to read directory ${link(directory, new URL(dirpath))}`);
+  /**
+   * Loads JavaScript files from a specified directory.
+   *
+   * @param dir - The directory path from which to load the files.
+   * @returns An array of file paths for JavaScript files in the specified directory.
+   *          Returns an empty array if an error occurs during the file reading process.
+   */
+  loadFiles(dir) {
     try {
-      const files = fs.readdirSync(dirpath);
-      return files.filter((file) => file.endsWith(".js") || file.endsWith(".mjs") || file.endsWith(".cjs"));
+      return fs.readdirSync(dir).filter((file) => file.endsWith(".js")).map((file) => path.join(dir, file));
     } catch (error) {
-      XernerxLog_default.error(`Error reading directory ${link(directory, new URL(dirpath))}:`, error);
+      new XernerxError(error.message, 0);
       return [];
     }
   }
-  async load(filepath) {
-    if (this.client.settings.debug) XernerxLog_default.debug(`Attempting to load ${link(filepath, new URL(filepath))}`);
+  /**
+   * Asynchronously loads a JavaScript file and imports its default export.
+   *
+   * @param file - The path to the JavaScript file to be loaded.
+   * @returns A promise that resolves when the file is successfully loaded and imported.
+   *          If the file does not have a default export, an error is thrown.
+   */
+  async loadFile(file) {
+    const filepath = path.resolve(file);
+    const filename = path.basename(filepath);
     try {
-      const file = (await import(`file://${filepath}`))?.default || await import(`file://${filepath}`);
-      const openFile = new file();
-      const [collection, group] = openFile.collection.split(".");
-      group ? this.client[group][collection].set(openFile._id, openFile) : this.client[collection].set(openFile._id, openFile);
-      if (this.client.settings.debug) XernerxLog_default.debug(`Loaded ${link(openFile._id, new URL(filepath))}`);
-      return openFile;
+      const file2 = await import(`file://${filepath}`);
+      if (!file2.default) return new XernerxError(`${filename} | ${file2} does not have a default export.`, 0);
+      const builder = new file2.default(this.client);
+      builder.filepath = filepath;
+      builder.filename = filename;
+      this.importFile(builder);
     } catch (error) {
-      XernerxLog_default.error(`Error loading ${link(filepath, new URL(filepath))}:`, error);
-      return null;
+      new XernerxError(`${filename} | ${error.message}`, 0);
+    }
+  }
+  /**
+   * Imports a file by registering it with the client based on its type.
+   *
+   * @param builder - An instance of XernerxEventBuilder, XernerxMessageCommandBuilder, or XernerxSlashCommandBuilder.
+   *                  This object contains the necessary information to register the file with the client.
+   * @param filename - An optional string representing the name of the file being imported.
+   *                   Used for error reporting if the builder ID is not unique.
+   * @returns The builder object after it has been registered with the client.
+   *          If the builder is of type XernerxEvent, it is registered as an event listener.
+   *          If the builder is of type XernerxMessageCommand or XernerxSlashCommand, it is registered as a command.
+   */
+  async importFile(builder, filename) {
+    if (builder.filetype === "XernerxEvent") {
+      if (this.client.events.has(builder.id)) return new XernerxError(`${filename} | ID must be unique`);
+      this.client.events.set(builder.id, builder);
+      builder.once ? this[builder.emitter].once(builder.name, (...args) => builder.run(...args)) : this[builder.emitter].on(builder.name, (...args) => builder.run(...args));
+    }
+    if (builder.filetype === "XernerxMessageCommand") {
+      this.client.commands.message.set(builder.id, builder);
     }
+    if (builder.filetype === "XernerxSlashCommand") {
+      this.client.commands.slash.set(builder.id, builder);
+    }
+    return builder;
   }
 };
-var CommandHandler = class extends Handler {
+
+// src/handler/EventHandler.ts
+var EventHandler = class extends Handler {
   static {
-    __name(this, "CommandHandler");
+    __name(this, "EventHandler");
   }
   constructor(client) {
     super(client);
   }
-  async loadSlashCommands(options) {
-    if (!this.client.modules.options.slash) this.client.modules.options.slash = {};
-    this.client.modules.options.slash.global = options.global ?? this.client.settings.global;
-    for (const file of await this.readdir(options.directory)) {
-      const command = await this.load(path__default.resolve(`${options.directory}/${file}`));
-      if (!command) continue;
-      if (command.filetype == "XernerxMessageCommand" || command.filetype == "XernerxSlashCommand" || command.filetype == "XernerxContextCommand") {
-        if (!this.client.modules.options.slash.global) this.client.commands.stats.slash.local++;
-        else if (!command.global) this.client.commands.stats.slash.local++;
-        else this.client.commands.stats.slash.global++;
-      }
+  /**
+   * Loads a single event file.
+   *
+   * @param file - The path to the event file to be loaded.
+   * @returns A promise that resolves when the event file has been successfully loaded.
+   */
+  async loadEvent(file) {
+    return this.loadFile(file);
+  }
+  /**
+   * Loads all event files from the specified directory and initializes them.
+   *
+   * @param options - An object containing options for loading events.
+   * @param options.directory - The directory path where event files are located.
+   * @returns A promise that resolves when all events have been loaded.
+   */
+  async loadEvents(options) {
+    const files = this.loadFiles(options.directory);
+    for (const file of files) {
+      await this.loadEvent(file);
     }
+    new XernerxSuccess(
+      `Loaded events: ${this.client.events.filter((event) => !event.id.startsWith("Xernerx")).map((event) => sharpyy8(event.id, "txYellow")).join(", ")}`
+    );
   }
-  async loadMessageCommands(options) {
+};
+
+// src/build/XernerxBaseBuilder.ts
+var XernerxBaseBuilder = class {
+  static {
+    __name(this, "XernerxBaseBuilder");
+  }
+  /**
+   * Constructs a new instance of the XernerxBaseBuilder class.
+   *
+   * @param id - A unique identifier for the builder instance.
+   * @param options - Configuration options for the builder, which can be either
+   *                  XernerxSlashCommandBuilderOptions or XernerxEventBuilderOptions.
+   */
+  constructor(id, options) {
+    this.id = id;
   }
-  async loadContextCommands(options) {
+};
+var XernerxWarn = class extends XernerxBase {
+  static {
+    __name(this, "XernerxWarn");
+  }
+  constructor(message) {
+    super();
+    ora().warn(`${this.base()}${message}`);
   }
 };
 
-// src/util/Util.ts
-var Util = class {
+// src/build/XernerxEventBuilder.ts
+var XernerxEventBuilder = class extends XernerxBaseBuilder {
   static {
-    __name(this, "Util");
+    __name(this, "XernerxEventBuilder");
   }
-  constructor(client) {
+  constructor(id, options) {
+    super(id, options);
+    this.filetype = "XernerxEvent";
+    this.name = options.name;
+    this.emitter = options.emitter ?? "client";
+    this.once = options.once ?? false;
+  }
+  /**
+   * Executes the event logic. This method should be overridden in subclasses to provide specific event handling.
+   *
+   * @param args - A variable number of arguments that are passed to the event handler.
+   *               These arguments are specific to the event being handled.
+   * @returns A promise that resolves when the event handling is complete.
+   *          The resolved value can be any type, depending on the implementation in subclasses.
+   */
+  async run(...args) {
+    new XernerxWarn(`Event ${sharpyy8(`${this.id}`, "txYellow")} does not have a run method, and will therefore not work.`);
+  }
+};
+var XernerxUser = class extends User {
+  static {
+    __name(this, "XernerxUser");
+  }
+  #monitisation;
+  constructor(client, user) {
+    super(client, user);
+    this.#monitisation = new XernerxMonitisation(client);
+  }
+  /**
+   * Checks if the user has any entitlements, indicating premium status.
+   *
+   * @param id - The ID of the user to check for premium entitlements.
+   * @returns A promise that resolves to a boolean indicating whether the user has any entitlements (true) or not (false).
+   */
+  async premium(id) {
+    const entitlements = await this.#monitisation.entitlements({ user_id: this.id });
+    if (!entitlements.length) return false;
+    return true;
+  }
+  /**
+   * Retrieves the entitlements for the user and maps them to their corresponding SKU.
+   *
+   * @returns A promise that resolves to an array of objects, each containing an entitlement and its associated SKU.
+   */
+  async entitlements() {
+    const entitlements = await this.#monitisation.entitlements({ user_id: this.id });
+    const SKU = await this.#monitisation.sku();
+    return entitlements.map((entitlement) => ({ entitlement, sku: SKU.find((sku) => sku.id === entitlement.sku_id) }));
+  }
+  /**
+   * Synchronizes the user's entitlements with the current SKU data and performs necessary actions
+   * such as consuming, deleting, or creating entitlements based on their type and the client's premium settings.
+   *
+   * @returns A promise that resolves to an array of error messages, if any occurred during the synchronization process.
+   */
+  async synchronize() {
+    const errors = [];
+    const client = this.client;
+    const skus = await this.#monitisation.sku();
+    const entitlements = await this.#monitisation.entitlements({ user_id: this.id });
+    for (const entitlement of entitlements) {
+      if (!client.premium.synchronize) continue;
+      const sku = skus.find((sku2) => sku2.id === entitlement.sku_id);
+      if (!sku) continue;
+      if (sku.type == SKUType.Consumable && !entitlement.consumed && client.premium.consume) this.#monitisation.consume(entitlement.id).catch((e) => errors.push(e.message));
+      if (sku.type == SKUType.Durable) ;
+      if (sku.type == SKUType.Subscription && entitlement.type == EntitlementType.ApplicationSubscription) this.#monitisation.delete(entitlement.id).catch((e) => errors.push(e.message));
+      if (sku.type == SKUType.SubscriptionGroup && entitlement.type == EntitlementType.ApplicationSubscription) this.#monitisation.delete(entitlement.id).catch((e) => errors.push(e.message));
+    }
+    for (const sku of skus) {
+      if (!client.premium.owners) continue;
+      if (sku.type == 5) {
+        await this.#monitisation.create(sku.id, this.id).catch((e) => errors.push(e.message));
+      }
+    }
+    return errors;
+  }
+};
+
+// src/util/XernerxUtil.ts
+var XernerxBaseUtil = class {
+  static {
+    __name(this, "XernerxBaseUtil");
+  }
+  constructor(client, interaction) {
     this.client = client;
+    this.parsed = { command: null, alias: null, mention: null, prefix: null };
+    this.interaction = interaction;
+  }
+  /**
+   * Sends a message using a webhook in the current interaction's channel.
+   *
+   * @param options - The message content or options to send via the webhook. This can be a string, MessagePayload, or WebhookMessageCreateOptions.
+   * @returns A promise that resolves to the message sent by the webhook.
+   */
+  async webhook(options) {
+    if (!this.interaction.channel) return;
+    const webhooks = await this.interaction.channel.fetchWebhooks();
+    let webhook = await webhooks.find((wh) => wh.token);
+    if (!webhook)
+      webhook = this.interaction.channel.createWebhook({
+        name: this.client.user.username,
+        avatar: this.client.user.displayAvatarURL()
+      });
+    return await webhook.send(options);
+  }
+};
+
+// src/util/XernerxMessageUtil.ts
+var XernerxMessageUtil = class extends XernerxBaseUtil {
+  static {
+    __name(this, "XernerxMessageUtil");
+  }
+  constructor(client, message) {
+    super(client, message);
+    this.message = message;
+    this.cache = this.client.cache.messages;
+    this.args = [];
+    this.#parse();
+  }
+  /**
+   * Parses the message content to extract command, alias, prefix, and arguments.
+   * It also checks if the message mentions the bot.
+   */
+  #parse() {
+    if (this.message.content.trim().startsWith(`<@${this.client.user.id}>`)) this.message.content = this.message.content.replace(`<@${this.client.user.id}>`, "").trimStart();
+    const [command, ...args] = this.message.content.split(this.client.handler.message.seperator || " ");
+    this.client.commands.message.map(({ name, prefix, alias }) => {
+      if (command.toLowerCase().endsWith(name.toLowerCase())) {
+        this.parsed.command = name;
+        this.parsed.alias = name;
+      }
+      alias.map((a) => command.toLowerCase().endsWith(a.toLowerCase()) ? this.parsed.alias = a : null);
+      prefix.map((p) => command.toLowerCase().startsWith(p.toLowerCase()) ? this.parsed.prefix = p : null);
+    });
+    this.client.handler.message.prefix?.map((p) => command.toLowerCase().startsWith(p.toLowerCase()) ? this.parsed.prefix = p : null);
+    this.parsed.mention = this.message.mentions.has(this.client.user.id);
+    this.args = args;
+  }
+  /**
+   * Sends a message to the channel or edits an existing message if applicable.
+   *
+   * @param options - The content or options for the message to be sent or edited.
+   *                  It can be a string, MessagePayload, MessageCreateOptions, or MessageEditOptions.
+   * @returns The sent or edited message, or null if the message ID is not found in the cache.
+   */
+  async send(options) {
+    if (this.cache.has(this.message.id) && this.client.handler.message.handleEdits) {
+      const id = this.cache.get(this.message.id);
+      if (!id) return null;
+      const msg2 = await this.message.channel.messages.fetch(id);
+      msg2.edit(options);
+      return msg2;
+    }
+    const msg = await this.message.channel.send(options);
+    this.cache.set(this.message.id, msg.id);
+    return msg;
+  }
+  /**
+   * Replies to the current message or edits an existing reply if applicable.
+   *
+   * @param options - The content or options for the reply message.
+   *                  It can be a string, MessagePayload, or MessageReplyOptions.
+   * @returns The sent or edited message, or null if the message ID is not found in the cache.
+   */
+  async reply(options) {
+    if (this.cache.has(this.message.id) && this.client.handler.message.handleEdits) {
+      const id = this.cache.get(this.message.id);
+      if (!id) return null;
+      const msg2 = await this.message.channel.messages.fetch(id);
+      msg2.edit(options);
+      return msg2;
+    }
+    const msg = await this.message.reply(options);
+    this.cache.set(this.message.id, msg.id);
+    return msg;
+  }
+};
+
+// src/events/messageCreate.ts
+var XernerxMessageCreateEvent = class extends XernerxEventBuilder {
+  static {
+    __name(this, "XernerxMessageCreateEvent");
+  }
+  constructor() {
+    super("XernerxMessageCreateEvent", {
+      name: "messageCreate",
+      emitter: "client",
+      once: false
+    });
+  }
+  async run(message) {
+    this.client = message.client;
+    message.user = new XernerxUser(message.client, message.author);
+    message.util = new XernerxMessageUtil(this.client, message);
+    if (!message.content) return;
+    if (this.client.handler.message.ignore?.bots && message.author.bot) return;
+    if (this.client.handler.message.ignore?.self && message.author.id === this.client.user?.id) return;
+    if (this.client.handler.message.ignore?.system && message.system) return;
+    if (!message.util.parsed.command) return;
+    const command = this.client.commands.message.get(message.util.parsed.command);
+    if (!command) return;
+    if (this.client.handler.message.mention && !message.util.parsed.mention && !command?.prefix.includes(message.util.parsed.prefix) && !this.client.handler.message.prefix?.includes(message.util.parsed.prefix))
+      return;
+    try {
+      await message.client.emit("commandStart", message, {}, command);
+      await command?.exec(message, message.util.args);
+      await message.client.emit("commandFinish", message, {}, command);
+    } catch (error) {
+      await message.client.emit("commandError", message, {}, command, error);
+    }
   }
 };
 
-// src/util/ClientUtil.ts
-var ClientUtil = class extends Util {
+// src/events/messageUpdate.ts
+var XernerxMessageUpdateEvent = class extends XernerxEventBuilder {
   static {
-    __name(this, "ClientUtil");
+    __name(this, "XernerxMessageUpdateEvent");
+  }
+  constructor() {
+    super("XernerxMessageUpdateEvent", {
+      name: "messageUpdate",
+      emitter: "client",
+      once: false
+    });
+  }
+  async run(oldMessage, message) {
+    this.client = message.client;
+    message.user = new XernerxUser(message.client, message.author);
+    message.util = new XernerxMessageUtil(this.client, message);
+    if (!message.content) return;
+    if (this.client.handler.message.ignore?.bots && message.author.bot) return;
+    if (this.client.handler.message.ignore?.self && message.author.id === this.client.user?.id) return;
+    if (this.client.handler.message.ignore?.system && message.system) return;
+    if (!message.util.parsed.command) return;
+    const command = this.client.commands.message.get(message.util.parsed.command);
+    if (!command) return;
+    if (this.client.handler.message.mention && !message.util.parsed.mention && !command?.prefix.includes(message.util.parsed.prefix) && !this.client.handler.message.prefix?.includes(message.util.parsed.prefix))
+      return;
+    try {
+      await message.client.emit("commandStart", message, {}, command);
+      await command?.exec(message, message.util.args);
+      await message.client.emit("commandFinish", message, {}, command);
+    } catch (error) {
+      await message.client.emit("commandError", message, {}, command, error);
+    }
+  }
+};
+
+// src/events/messageDelete.ts
+var XernerxMessageDeleteEvent = class extends XernerxEventBuilder {
+  static {
+    __name(this, "XernerxMessageDeleteEvent");
+  }
+  constructor() {
+    super("XernerxMessageDeleteEvent", {
+      name: "messageDelete",
+      emitter: "client",
+      once: false
+    });
+  }
+  async run(message) {
+    this.client = message.client;
+    message.user = new XernerxUser(message.client, message.author);
+    message.util = new XernerxMessageUtil(this.client, message);
+    if (!this.client.handler.message.handleDeletions) return;
+    if (!this.client.cache.messages.has(message.id)) return;
+    const id = this.client.cache.messages.get(message.id);
+    if (!id) return;
+    try {
+      const msg = await message.channel.messages.fetch(id);
+      await msg.delete();
+    } catch (error) {
+      await this.client.emit("commandDelete", message, error);
+    }
+  }
+};
+var XernerxInteractionUtil = class extends XernerxBaseUtil {
+  static {
+    __name(this, "XernerxInteractionUtil");
+  }
+  constructor(client, interaction) {
+    super(client, interaction);
+    this.interaction = interaction;
+    this.cache = this.client.cache.slash;
+  }
+  /**
+   * Sends a message to the channel associated with the interaction.
+   *
+   * @param options - The content or options for the message to be sent. It can be a string, MessagePayload, or MessageCreateOptions.
+   * @returns A promise that resolves to the sent message.
+   * @throws {XernerxError} Throws an error if the options parameter is not provided.
+   */
+  async send(options) {
+    if (!options) throw new XernerxError(`Can't send a message without content.`);
+    return await this.interaction.channel.send(options);
+  }
+  /**
+   * Replies to the interaction with the provided options.
+   *
+   * @param options - The content or options for the reply. It can be a string, MessagePayload, or InteractionEditReplyOptions.
+   * @returns A promise that resolves to the sent message or the edited reply.
+   * @throws {XernerxError} Throws an error if the options parameter is not provided.
+   */
+  async reply(options) {
+    if (!options) throw new XernerxError(`Can't send a message without options.`);
+    return await (this.interaction.replied || this.interaction.deferred ? this.interaction.editReply(options) : this.interaction.reply(options));
+  }
+  /**
+   * Sends a message to the channel associated with the interaction with componentsV2 flag.
+   *
+   * @param options - The options for the message to be sent, including content and other message properties.
+   * @returns A promise that resolves to the sent message.
+   */
+  async send2(options) {
+    options.flags = MessageFlags.IsComponentsV2;
+    return await this.send(options);
+  }
+  /**
+   * Replies to the interaction with the provided options, using the componentsV2 flag.
+   *
+   * @param options - The options for the reply, including content and other message properties.
+   * @returns A promise that resolves to the sent message or the edited reply.
+   */
+  async reply2(options) {
+    options.flags = MessageFlags.IsComponentsV2;
+    return await this.reply(options);
+  }
+};
+
+// src/events/interactionCreate.ts
+var XernerxInteractionCreateEvent = class extends XernerxEventBuilder {
+  static {
+    __name(this, "XernerxInteractionCreateEvent");
+  }
+  constructor() {
+    super("XernerxInteractionCreateEvent", {
+      name: "interactionCreate",
+      emitter: "client",
+      once: false
+    });
+  }
+  async run(interaction) {
+    this.client = interaction.client;
+    interaction.user = new XernerxUser(interaction.client, interaction.user);
+    interaction.util = new XernerxInteractionUtil(this.client, interaction);
+    if (interaction.isChatInputCommand()) return await interaction.client.emit("slashCommandInteraction", interaction);
+    if (interaction.isContextMenuCommand()) return await interaction.client.emit("contextCommandInteraction", interaction);
+    if (interaction.isAnySelectMenu()) return await interaction.client.emit("selectMenuInteraction", interaction);
+    if (interaction.isButton()) return await interaction.client.emit("buttonInteraction", interaction);
+    if (interaction.isModalSubmit()) return await interaction.client.emit("modalInteraction", interaction);
+  }
+};
+var XernerxClientReadyEvent = class extends XernerxEventBuilder {
+  static {
+    __name(this, "XernerxClientReadyEvent");
+  }
+  constructor() {
+    super("XernerxClientReadyEvent", {
+      name: "clientReady",
+      emitter: "client",
+      once: true
+    });
+    this.commands = {
+      global: [],
+      local: []
+    };
+  }
+  async run(client) {
+    if (client.settings.owners?.length) {
+      const owners = [];
+      if (client.premium?.synchronize) new XernerxInfo(`Synchronizing entitlements for premium owners...`);
+      for (const owner of client.settings.owners) {
+        const user = await client.users.fetch(owner);
+        new XernerxUser(client, user).synchronize();
+        owners.push(user);
+      }
+      if (client.premium?.synchronize) new XernerxSuccess(`Successfully synchronized entitlements for ${owners.map((owner) => owner.username).join(",")}`);
+    }
+    try {
+      const commands = [...client.commands.slash].map(([, command]) => command);
+      if (!client.settings.global) {
+        this.commands.global = [];
+        this.commands.local = commands;
+      } else {
+        this.commands.global = commands.filter((command) => command.deploy?.global);
+        this.commands.local = commands.filter((command) => !command.deploy?.global);
+      }
+      this.put(client);
+      new XernerxSuccess(`Successfully deployed slash commands ${client.settings.global ? "globally" : "locally"}`);
+    } catch (error) {
+      new XernerxError(error.message);
+    }
+  }
+  async put(client) {
+    const rest = new REST({ version: GatewayVersion }).setToken(client.token);
+    if (this.commands.global.length) {
+      if (!client.settings.global) return new XernerxInfo("Loading commands locally");
+      await rest.put(Routes.applicationCommands(client.user?.id), { body: this.commands.global.map((command) => command.data.toJSON()) });
+    }
+    if (this.commands.local.length) {
+      const guilds = {};
+      for (const command of this.commands.local) {
+        command.deploy?.guilds?.map((id) => guilds[id] ? guilds[id].push(command) : guilds[id] = [command]);
+      }
+      if (!client.settings.guildId?.length && !Object.keys(guilds).length) return new XernerxError("Cannot locally deploy slash commands without a guild ID");
+      client.settings.guildId.map((id) => guilds[id] ? guilds[id] : guilds[id] = this.commands.local);
+      for (const [guildId, commands] of Object.entries(guilds)) {
+        await rest.put(Routes.applicationGuildCommands(client.user?.id, guildId), { body: commands.map((command) => command.data.toJSON()) });
+      }
+    }
+  }
+};
+
+// src/model/XernerxInteractionArguments.ts
+var XernerxInteractionArguments = class {
+  static {
+    __name(this, "XernerxInteractionArguments");
+  }
+  constructor(interaction, command) {
+    this.interaction = interaction;
+    this.command = command;
+  }
+  /**
+   * Retrieves the options from the current interaction based on the command structure.
+   *
+   * This method processes the command's groups, subcommands, and options to extract
+   * the relevant options from the interaction. It returns a record of option names
+   * and their corresponding values from the interaction.
+   *
+   * @returns {Record<string, any> | null} A record of option names and values if available, otherwise null.
+   */
+  options() {
+    const options = {};
+    if (this.command.groups) {
+      const group = this.command.groups.find((group2) => group2.name === this.group());
+      if (!group) return null;
+      const subcommand = group.subcommands.find((subcommand2) => subcommand2.name === this.subcommand());
+      if (!subcommand) return null;
+      for (const option of subcommand.options || []) {
+        options[option.name] = this.interaction.options.get(option.name);
+      }
+    }
+    if (this.command.subcommands) {
+      const subcommand = this.command.subcommands.find((subcommand2) => subcommand2.name === this.subcommand());
+      if (!subcommand) return null;
+      for (const option of subcommand?.options || []) {
+        options[option.name] = this.interaction.options.get(option.name);
+      }
+    }
+    if (this.command.options) {
+      for (const option of this.command.options) {
+        options[option.name] = this.interaction.options.get(option.name);
+      }
+    }
+    return options || null;
+  }
+  /**
+   * Retrieves the name of the subcommand from the current interaction.
+   *
+   * This method attempts to extract the subcommand name from the interaction options.
+   * If no subcommand is present or an error occurs, it returns null.
+   *
+   * @returns {string | null} The name of the subcommand if available, otherwise null.
+   */
+  subcommand() {
+    try {
+      return this.interaction.options.getSubcommand();
+    } catch {
+      return null;
+    }
+  }
+  /**
+   * Retrieves the name of the subcommand group from the current interaction.
+   *
+   * This method attempts to extract the subcommand group name from the interaction options.
+   * If no subcommand group is present or an error occurs, it returns null.
+   *
+   * @returns {string | null} The name of the subcommand group if available, otherwise null.
+   */
+  group() {
+    try {
+      return this.interaction.options.getSubcommandGroup();
+    } catch {
+      return null;
+    }
+  }
+};
+
+// src/validators/XernerxBaseValidator.ts
+var XernerxBaseValidator = class {
+  static {
+    __name(this, "XernerxBaseValidator");
+  }
+  constructor(interaction, command) {
+    this.client = interaction.client;
+    this.interaction = interaction;
+    this.command = command;
+    this.satisified = true;
+  }
+  /**
+   * Checks if the command requires a premium subscription and validates the user's premium status.
+   * If the user does not have a premium subscription, it emits an error and sets the validation status to false.
+   *
+   * @returns A promise that resolves when the premium check is complete.
+   */
+  async premium() {
+    if (!this.command.premium) return;
+    const premium = await this.interaction.user.premium("");
+    if (!premium) {
+      this.emit({ type: "premiumCommand", message: "This command requires a premium subscription.", data: [] });
+      this.satisified = false;
+    }
+  }
+  /**
+   * Checks if the command is globally available or restricted to specific guilds.
+   * If the command is not available in the current guild, it emits an error and sets the validation status to false.
+   */
+  global() {
+    if (!this.interaction.guild) return;
+    if (!this.client.settings.global && !this.client.settings.guildId?.includes(this.interaction.guild?.id)) {
+      this.emit({ type: "localCommand", message: "This command is not available in this server.", data: this.client.settings.guildId });
+      this.satisified = false;
+    }
+  }
+  /**
+   * Emits an error event related to command execution.
+   *
+   * @param error - An object containing details about the error.
+   * @param error.type - The type of error that occurred.
+   * @param error.message - A descriptive message about the error.
+   * @param error.data - Optional additional data related to the error.
+   * @returns A promise that resolves when the error event has been emitted.
+   */
+  async emit(error) {
+    return await this.client.emit("commandBlock", this.interaction, this.command, error);
+  }
+  /**
+   * Validates the command by checking its global availability and premium status.
+   *
+   * @returns A promise that resolves to a boolean indicating whether all validation checks are satisfied.
+   */
+  async validate() {
+    await this.global();
+    await this.premium();
+    return this.satisified;
+  }
+};
+
+// src/validators/XernerxSlashCommandValidator.ts
+var XernerxSlashCommandValidator = class extends XernerxBaseValidator {
+  static {
+    __name(this, "XernerxSlashCommandValidator");
+  }
+  constructor(interaction, command) {
+    super(interaction, command);
+  }
+};
+
+// src/events/slashCommandInteraction.ts
+var XernerxSlashCommandInteractionEvent = class extends XernerxEventBuilder {
+  static {
+    __name(this, "XernerxSlashCommandInteractionEvent");
+  }
+  constructor() {
+    super("XernerxSlashCommandInteractionEvent", {
+      name: "slashCommandInteraction",
+      emitter: "client",
+      once: false
+    });
+  }
+  async run(interaction) {
+    const command = interaction.client.commands.slash.get(interaction.commandName);
+    if (!command) return;
+    new Promise(async (resolve) => {
+      if (interaction.isAutocomplete()) {
+        const focused = interaction.options.getFocused(true);
+        const options = interaction.options;
+        await command.autocomplete({ interaction, focused, options });
+      } else resolve(true);
+    }).then(async () => {
+      const args = new XernerxInteractionArguments(interaction, command);
+      const options = { options: args.options(), subcommand: args.subcommand(), group: args.subcommand() };
+      try {
+        await interaction.client.emit("commandStart", interaction, options, command);
+        const validation = new XernerxSlashCommandValidator(interaction, command);
+        if (!await validation.validate()) return;
+        if (command.defer) await interaction.deferReply();
+        if (await command.conditions({ interaction, ...options, command })) return;
+        await command.exec({ interaction, ...options, command });
+        await interaction.client.emit("commandFinish", interaction, options, command);
+      } catch (error) {
+        await interaction.client.emit("commandError", interaction, options, command, error);
+      }
+    });
+  }
+};
+
+// src/events/entitlementCreate.ts
+var XernerxEntitlementCreateEvent = class extends XernerxEventBuilder {
+  static {
+    __name(this, "XernerxEntitlementCreateEvent");
+  }
+  constructor() {
+    super("XernerxEntitlementCreateEvent", {
+      name: "entitlementCreate",
+      emitter: "client",
+      once: false
+    });
+  }
+  async run(a, b, c) {
+  }
+};
+
+// src/handler/CommandHandler.ts
+var CommandHandler = class extends Handler {
+  static {
+    __name(this, "CommandHandler");
   }
   constructor(client) {
     super(client);
+    this.loadEvents(XernerxEntitlementCreateEvent, XernerxClientReadyEvent);
+  }
+  /**
+   * Loads a message command from a specified file.
+   *
+   * @param file - The path to the file containing the message command to be loaded.
+   * @returns A promise that resolves when the file has been successfully loaded.
+   */
+  async loadMessageCommand(file) {
+    return await this.loadFile(file);
+  }
+  /**
+   * Loads message commands based on the provided options.
+   *
+   * @param options - Configuration options for loading message commands, including directory, prefix, mention, separator, handleEdits, handleDeletions, and ignore settings.
+   * @returns A promise that resolves when all message commands have been successfully loaded.
+   */
+  async loadMessageCommands(options) {
+    const config = z.object({
+      directory: z.string(),
+      prefix: z.union([z.string(), z.array(z.string())]).default([]),
+      mention: z.boolean().default(false),
+      seperator: z.string().default(" "),
+      handleEdits: z.boolean().default(false),
+      handleDeletions: z.boolean().default(false),
+      ignore: z.object({
+        system: z.boolean().default(true),
+        bots: z.boolean().default(true),
+        self: z.boolean().default(true)
+      }).default({ system: true, bots: true, self: true })
+    }).parse(options);
+    typeof config.prefix == "string" ? config.prefix = [config.prefix] : config.prefix;
+    this.client.handler.message = config;
+    const files = this.loadFiles(config.directory);
+    this.loadEvents(XernerxMessageCreateEvent, XernerxMessageUpdateEvent, XernerxMessageDeleteEvent);
+    if (!this.client.options.intents.has("GuildMessages")) new XernerxError(`Missing ${sharpyy8("GuildMessages", "txYellow")} intent, message commands will not work.`);
+    if (!this.client.options.intents.has("MessageContent") && !config.mention)
+      new XernerxError(`Missing ${sharpyy8("MessageContent", "txYellow")} intent and bot mention is turned off, message commands will not work.`);
+    if (!this.client.options.intents.has("MessageContent") && config.mention)
+      new XernerxWarn(`Missing ${sharpyy8("MessageContent", "txYellow")} intent, message commands can only be triggered by @mention.`);
+    for (const file of files) {
+      await this.loadMessageCommand(file);
+    }
+    new XernerxSuccess(`Loaded message commands: ${this.client.commands.message.map((command) => sharpyy8(command.id, "txYellow")).join(", ")}`);
+  }
+  /**
+   * Loads a slash command from a specified file.
+   *
+   * @param file - The path to the file containing the slash command to be loaded.
+   * @returns A promise that resolves when the file has been successfully loaded.
+   */
+  async loadSlashCommand(file) {
+    return await this.loadFile(file);
+  }
+  /**
+   * Loads slash commands based on the provided options.
+   *
+   * @param options - Configuration options for loading slash commands, including the directory where the command files are located.
+   * @returns A promise that resolves when all slash commands have been successfully loaded.
+   */
+  async loadSlashCommands(options) {
+    const config = z.object({
+      directory: z.string()
+    }).parse(options);
+    this.client.handler.slash = config;
+    const files = this.loadFiles(config.directory);
+    for (const file of files) {
+      await this.loadSlashCommand(file);
+    }
+    this.loadEvents(XernerxInteractionCreateEvent, XernerxSlashCommandInteractionEvent);
+    new XernerxSuccess(`Loaded slash commands: ${this.client.commands.slash.map((command) => sharpyy8(command.id, "txYellow")).join(", ")}`);
   }
-  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`;
+  /**
+   * Loads and imports event files based on the provided event classes.
+   *
+   * @param args - An array of event classes extending XernerxEventBuilder. Each class represents an event to be loaded and imported.
+   * @returns A promise that resolves when all specified events have been successfully imported.
+   */
+  async loadEvents(...args) {
+    for (const event of args) {
+      this.importFile(new event("", { name: "" }));
+    }
   }
 };
 
 // src/client/XernerxClient.ts
-var XernerxClient = class extends Discord.Client {
+var XernerxClient = class extends Client {
   static {
     __name(this, "XernerxClient");
   }
-  constructor(DiscordOptions, XernerxOptions, config) {
-    super(DiscordOptions);
-    this.settings = z.object({
-      // required settings
-      token: z.string(),
-      // optional settings
-      global: z.boolean().default(false),
-      owners: z.array(z.string()).default([]),
-      guilds: z.array(z.string()).default([]),
-      // dev settings
-      debug: z.boolean().default(false)
-    }).parse({ ...XernerxOptions, ...config });
+  constructor(options) {
+    try {
+      options.shards = getInfo().SHARD_LIST;
+      options.shardCount = getInfo().TOTAL_SHARDS;
+    } catch {
+      new XernerxInitial("Client");
+    }
+    super(options);
+    this.settings = z2.object({
+      token: z2.string(),
+      global: z2.boolean().default(false),
+      guildId: z2.string().or(z2.array(z2.string()).max(5)).default([]),
+      owners: z2.string().or(z2.array(z2.string()).max(5)).default([]),
+      premium: z2.object({
+        owners: z2.boolean().default(true),
+        consume: z2.boolean().default(true),
+        synchronize: z2.boolean().default(true)
+      }).optional()
+    }).parse(options);
+    this.sharded = options.shardCount ? true : false;
+    this.token = options.token;
+    this.settings.guildId = typeof this.settings.guildId == "string" ? [this.settings.guildId] : this.settings.guildId;
+    this.settings.owners = typeof this.settings.owners == "string" ? [this.settings.owners] : this.settings.owners;
+    this.premium = this.settings.premium || {
+      owners: true,
+      consume: true,
+      synchronize: true
+    };
+    delete this.settings.premium;
+    this.monitisation = { skus: [] };
     this.stats = {
-      guilds: null,
-      users: null,
-      shardId: null,
+      onlineSince: Number(/* @__PURE__ */ new Date()),
+      guildCount: null,
+      userCount: null,
       shardCount: null,
-      shards: null,
       voteCount: null,
-      votes: null
+      shard: null
     };
-    this.util = new ClientUtil(this);
-    start(this);
-    this.modules = {
-      commandHandler: new CommandHandler(this),
-      options: {}
+    this.cache = { messages: new Collection(), slash: new Collection() };
+    this.handler = {
+      message: { directory: null },
+      slash: { directory: null }
     };
-    this.commands = {
-      message: new Discord.Collection(),
-      slash: new Discord.Collection(),
-      context: new Discord.Collection(),
-      stats: {
-        slash: {
-          local: 0,
-          global: 0
-        },
-        message: {
-          local: 0,
-          global: 0
-        },
-        context: {
-          local: 0,
-          global: 0
-        }
-      }
-    };
-    this.events = new Discord.Collection();
-    this.inhibitors = new Discord.Collection();
-    this.connect();
+    this.commands = { message: new Collection(), slash: new Collection() };
+    this.events = new Collection();
+    if (this.sharded) this.cluster = new ClusterClient(this);
+    this.modules = { eventHandler: new EventHandler(this), commandHandler: new CommandHandler(this) };
   }
+  /**
+   * Connects the client to Discord and initializes various client statistics and handlers.
+   *
+   * @returns A promise that resolves when the client successfully logs in, or rejects with an error message if the login fails.
+   */
   async connect() {
-    this.deploy();
-    this.login(this.settings.token);
-  }
-  async deploy() {
-    this.once("ready", async (client) => {
-      const commands = { local: [], global: [] };
-      if (this.settings.global) {
-        if (!this.modules.options.slash?.global) commands.global.push(...this.commands.slash);
-        else {
-          commands.global.push(...this.commands.slash.filter((c) => c.global));
-          commands.local.push(...this.commands.slash.filter((c) => !c.global));
-        }
-        if (!this.modules.options.context?.global) commands.global.push(...this.commands.context);
-        else {
-          commands.global.push(...this.commands.context.filter((c) => c.global));
-          commands.local.push(...this.commands.context.filter((c) => !c.global));
-        }
-      } else commands.local.push(...this.commands.context, ...this.commands.slash);
-      for (const id of this.settings.guilds) {
-        const guild = await this.guilds.fetch(id);
-        if (!commands.local.length) break;
-        if (this.settings.debug) XernerxLog_default.debug(`Attempting to deploy commands to guild: ${sharpyy2(guild.name, "txBlue")}`);
-        this.rest.put(Discord.Routes.applicationGuildCommands(client.user.id, id), { body: commands.local.map(([id2, command]) => command.toJSON()) });
-        await XernerxLog_default.box(
-          commands.local.map(([id2]) => sharpyy2(id2, "txYellow")).join(", "),
-          "red",
-          `Deployed ${sharpyy2("local", "txRed", "bold")} commands in ${sharpyy2(guild.name, "txBlue")}`
+    new XernerxInfo(`${this.cluster ? `${sharpyy8(`Shard ${this.cluster.id}`, "txCyan")} | ` : ""}Connecting...`);
+    this.on("clientReady", async (client) => {
+      this.monitisation.skus = await new XernerxMonitisation(client).sku();
+      if (this.sharded && this.cluster) {
+        this.stats.shard = {
+          shardId: this.cluster.id,
+          onlineSince: Number(/* @__PURE__ */ new Date()),
+          guildCount: null,
+          userCount: null
+        };
+        setInterval(async () => {
+          if (!this.cluster || !this.stats.shard) return;
+          this.stats.guildCount = (await this.cluster.broadcastEval("this.guilds.cache.size")).reduce((a, b) => a + b, 0);
+          this.stats.userCount = (await this.cluster.broadcastEval("this.guilds.cache.map((a) => a.memberCount).reduce((a, b) => a + b, 0)")).reduce((a, b) => a + b, 0);
+          this.stats.shardCount = getInfo().TOTAL_SHARDS;
+          this.stats.shard.guildCount = client.guilds.cache.size;
+          this.stats.voteCount = 0;
+          this.stats.shard.userCount = client.guilds.cache.map((a) => a.memberCount).reduce((a, b) => a + b, 0);
+        }, 1e3);
+        await new Promise((resolve) => setTimeout(resolve, 2e3));
+        new XernerxSuccess(
+          `${sharpyy8(`Shard ${this.cluster.id}`, "txCyan")} | Signed in as ${sharpyy8(client.user?.tag, "txBlue")}, watching ${sharpyy8(String(this.stats.shard?.guildCount?.toLocaleString()), "txCyan")} guilds and users: ${sharpyy8(String(this.stats.shard?.userCount?.toLocaleString()), "txCyan")}`
+        );
+      } else {
+        setInterval(() => {
+          this.stats.guildCount = client.guilds.cache.size;
+          this.stats.userCount = client.guilds.cache.map((a) => a.memberCount).reduce((a, b) => a + b, 0);
+          this.stats.voteCount = 0;
+          this.stats.shardCount = 0;
+        }, 1e3);
+        await new Promise((resolve) => setTimeout(resolve, 2e3));
+        new XernerxSuccess(
+          `Signed in as ${sharpyy8(client.user?.tag, "txBlue")}, watching ${sharpyy8(String(this.stats.guildCount?.toLocaleString()), "txCyan")} guilds and users: ${sharpyy8(String(this.stats.userCount?.toLocaleString()), "txCyan")}`
         );
-      }
-      if (this.settings.global) {
-        if (this.settings.debug) XernerxLog_default.debug(`Attempting to deploy commands globally`);
-        this.rest.put(Discord.Routes.applicationCommands(client.user.id), { body: [] });
-        await XernerxLog_default.box(commands.global.map(([id]) => sharpyy2(id, "txYellow")).join(", "), "green", `Deployed ${sharpyy2("global", "txGreen", "bold")} commands`);
       }
     });
+    return await this.login(this.token).catch((error) => new XernerxError(error.message, 1));
   }
 };
-var XernerxSlashCommand = class extends Discord.SlashCommandBuilder {
+var XernerxMessageCommandBuilder = class extends XernerxBaseBuilder {
   static {
-    __name(this, "XernerxSlashCommand");
+    __name(this, "XernerxMessageCommandBuilder");
   }
-  constructor(options) {
-    super();
-    this._id = options.id;
-    this.setName(options.name);
-    this.setDescription(options.description);
-    this.global = options.global ?? true;
+  /**
+   * Constructs an instance of XernerxMessageCommandBuilder.
+   *
+   * @param id - A unique identifier for the command.
+   * @param options - An object containing configuration options for the command.
+   * @param options.name - The name of the command.
+   * @param options.alias - An alias or an array of aliases for the command.
+   * @param options.prefix - A prefix or an array of prefixes for the command.
+   * @param options.premium - An array indicating premium features or settings.
+   */
+  constructor(id, options) {
+    super(id, options);
+    options = z.object({
+      name: z.string(),
+      alias: z.union([z.string(), z.array(z.string())]).default([]),
+      prefix: z.union([z.string(), z.array(z.string())]).default([]),
+      premium: z.any()
+    }).parse(options);
+    this.name = options.name;
+    this.alias = typeof options.alias == "string" ? [options.alias] : options.alias;
+    this.prefix = typeof options.prefix == "string" ? [options.prefix] : options.prefix;
+    this.premium = options.premium;
+    this.filetype = "XernerxMessageCommand";
+  }
+  /**
+   * Executes the command logic. This function is intended to be overridden by subclasses.
+   * If not overridden, it will log a warning indicating that the command will not respond.
+   *
+   * @param args - A variable number of arguments that can be passed to the command execution.
+   * @returns A promise that resolves to any value, depending on the implementation.
+   */
+  async exec(...args) {
+    new XernerxWarn(`${this.id} has no exec function, command will not respond.`);
+  }
+};
+var XernerxSlashCommandBuilder = class extends XernerxBaseBuilder {
+  static {
+    __name(this, "XernerxSlashCommandBuilder");
+  }
+  constructor(id, options) {
+    super(id, options);
+    options = z.object({
+      // Discord
+      name: z.string(),
+      locales: z.record(z.string(), z.object({ name: z.string(), description: z.string() })).optional(),
+      description: z.string(),
+      contexts: z.array(z.custom()).default(["Guild"]),
+      integration: z.array(z.custom()).default(["GuildInstall"]),
+      nsfw: z.boolean().default(false),
+      options: z.any(),
+      subcommands: z.any(),
+      groups: z.any(),
+      // Xernerx
+      premium: z.boolean().default(false),
+      defer: z.boolean().default(false),
+      deploy: z.object({ global: z.boolean().default(true), guilds: z.string().or(z.array(z.string())).default([]) }).optional(),
+      info: z.string().optional(),
+      usage: z.string().optional(),
+      category: z.string().optional(),
+      cooldown: z.number().min(0).default(0),
+      strict: z.object({
+        owner: z.boolean().default(false),
+        users: z.array(z.string()).default([]),
+        channels: z.array(z.string()).default([]),
+        guilds: z.array(z.string()).default([]),
+        types: z.enum(ChannelType).optional()
+      }).optional(),
+      ignore: z.object({
+        owner: z.boolean().default(false),
+        users: z.array(z.string()).default([]),
+        channels: z.array(z.string()).default([]),
+        guilds: z.array(z.string()).default([]),
+        types: z.enum(ChannelType).optional()
+      }).optional(),
+      permissions: z.object({
+        client: z.union([z.array(z.custom()), z.number(), z.bigint()]).nullable().default(null),
+        user: z.union([z.array(z.custom()), z.number(), z.bigint()]).nullable().default(null)
+      }).default({ client: null, user: null })
+    }).parse(options);
+    this.name = options.name;
+    this.description = options.description;
+    this.info = options.info;
+    this.usage = options.usage;
+    this.category = options.category;
+    this.cooldown = options.cooldown;
+    this.premium = options.premium || false;
+    this.defer = options.defer;
+    this.deploy = {
+      global: options.deploy?.global ?? true,
+      guilds: typeof options.deploy?.guilds == "string" ? [options.deploy.guilds] : options.deploy?.guilds || []
+    };
     this.filetype = "XernerxSlashCommand";
-    this.collection = "slash.commands";
+    this.permissions = options.permissions;
+    this.strict = options.strict;
+    this.ignore = options.ignore;
+    this.data = new SlashCommandBuilder();
+    this.data.setName(this.name);
+    this.data.setDescription(this.description);
+    this.data.setContexts(...options.contexts?.map((context) => InteractionContextType[context]) || [InteractionContextType.Guild]);
+    this.data.setIntegrationTypes(
+      ...options.integration?.map((integration) => ApplicationIntegrationType[integration]) || [ApplicationIntegrationType.GuildInstall]
+    );
+    if (Array.isArray(options.permissions?.user))
+      this.data.setDefaultMemberPermissions(options.permissions?.user?.map((permission) => PermissionFlagsBits[permission]).reduce((a, b) => a += b));
+    else this.data.setDefaultMemberPermissions(options.permissions?.user || null);
+    this.data.setNSFW(options.nsfw || false);
+    for (const locale of Object.entries(options.locales || [])) {
+      this.data.setNameLocalization(locale[0], locale[1].name);
+      this.data.setDescriptionLocalization(locale[0], locale[1].description);
+    }
+    if (options.options && options?.options?.length > 0) {
+      this.addArguments(this.data, options.options);
+      this.options = options.options;
+    }
+    if (options.subcommands && options?.subcommands?.length > 0) {
+      this.addSubcommands(this.data, options.subcommands);
+      this.subcommands = options.subcommands;
+    }
+    if (options.groups && options?.groups?.length > 0) {
+      this.addSubcommandGroups(options.groups);
+      this.groups = options.groups;
+    }
+    this.client = this.client;
+  }
+  /**
+   * Handles the autocomplete functionality for a slash command.
+   *
+   * @param args - The arguments for the autocomplete function, which include the context and options for the command.
+   * @returns A promise that resolves to either void or any value, depending on the implementation.
+   */
+  async autocomplete(args) {
+  }
+  /**
+   * Evaluates conditions for executing a slash command.
+   *
+   * @param args - The arguments for the conditions function, which include the context and options for the command.
+   * @returns A promise that resolves to either void or any value, depending on the implementation.
+   */
+  async conditions(args) {
+  }
+  /**
+   * Executes the slash command.
+   *
+   * @param args - The arguments for the exec function, which include the context and options for the command.
+   * @returns A promise that resolves to either void or any value, depending on the implementation.
+   */
+  async exec(args) {
+    new XernerxWarn(`${this.id} has no exec function, command will not respond.`);
+  }
+  addArguments(command, args) {
+    for (const argument of args) {
+      let slashCommandArgumentType = `${argument.type.charAt(0).toUpperCase()}${argument.type.slice(1).toLowerCase()}`;
+      command[`add${slashCommandArgumentType}Option`]((option) => {
+        option.setName(argument.name).setDescription(argument.description).setRequired(argument.required || false);
+        for (const locale of Object.entries(argument.locales || [])) {
+          option.setNameLocalization(locale[0], locale[1].name);
+          option.setDescriptionLocalization(locale[0], locale[1].description);
+        }
+        if (slashCommandArgumentType === "String") {
+          if (argument.choices) {
+            for (const choice of argument.choices) {
+              const locales = choice?.locales;
+              option.addChoices({ ...choice, name_localizations: locales });
+            }
+          }
+          if (argument.maxLength) option.setMaxLength(argument.maxLength);
+          if (argument.minLength) option.setMinLength(argument.minLength);
+          option.setAutocomplete(argument.autocomplete || false);
+        }
+        return option;
+      });
+    }
+  }
+  addSubcommands(method, subcommands) {
+    for (const subcommand of subcommands) {
+      let sub = new SlashCommandSubcommandBuilder().setName(subcommand.name).setDescription(subcommand.description);
+      for (const locale of Object.entries(subcommand.locales || [])) {
+        sub.setNameLocalization(locale[0], locale[1].name);
+        sub.setDescriptionLocalization(locale[0], locale[1].description);
+      }
+      if (subcommand.options && subcommand?.options?.length > 0) this.addArguments(sub, subcommand.options);
+      method.addSubcommand(sub);
+    }
+  }
+  /**
+   * Adds subcommand groups to the slash command builder.
+   *
+   * @param groups - An array of subcommand groups to be added. Each group contains a name, description, locales, and subcommands.
+   */
+  addSubcommandGroups(groups) {
+    for (const group of groups) {
+      let subcommandGroup = new SlashCommandSubcommandGroupBuilder().setName(group.name).setDescription(group.description);
+      for (const locale of Object.entries(group.locales || [])) {
+        subcommandGroup.setNameLocalization(locale[0], locale[1].name);
+        subcommandGroup.setDescriptionLocalization(locale[0], locale[1].description);
+      }
+      if (group.subcommands?.length > 0) this.addSubcommands(subcommandGroup, group.subcommands);
+      this.data.addSubcommandGroup(subcommandGroup);
+    }
   }
 };
 
-export { XernerxClient, XernerxSlashCommand };
+export { XernerxClient, XernerxEventBuilder, XernerxMessageCommandBuilder, XernerxShardClient, XernerxSlashCommandBuilder };
 //# sourceMappingURL=main.js.map
 //# sourceMappingURL=main.js.map