@guardbot/framework 1.1.2 → 2.0.0

package/build/{index.mjs → index.cjs}

@@ -1,215 +1,164 @@
-var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
-  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
-}) : x)(function(x) {
-  if (typeof require !== "undefined") return require.apply(this, arguments);
-  throw Error('Dynamic require of "' + x + '" is not supported');
-});
-
-// src/utils/errors.ts
-import { inspect } from "util";
-var messages = {
-  NoOptions: () => `No options object was provided.`,
-  InvalidOption: (name) => `No "${name}" option was provided.`,
-  InvalidType: (name, expected, actual) => `Expected "${name}" to be of type "${expected}", but got "${actual}".`,
-  InvalidValue: (name, expected) => `Expected "${name}" to be any one of the listed values: ${expected.map((v) => `"${v}"`).join(" | ")}`,
-  InvalidValues: (name, expected) => `Expected "${name}" to contain only the listed values: ${expected.map((v) => `"${v}"`).join(" | ")}`,
-  UnknownComponent: (type, id) => `Encountered an error as there is no "${type}" loaded with the id "${id}".`,
-  ComponentLoadError: (type, error) => `Encountered an error while loading the "${type}": 
-${inspect(error)}`,
-  ComponentAlreadyLoaded: (type, id) => `Encountered an error as a "${type}" with the id "${id}" is already loaded.`,
-  AppCommandRegister: (error, guildId) => `Encountered an error while registering commands ${guildId ? `to guild "${guildId}"` : ""}: 
-${inspect(error)}`
+"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 FrameworkError = class extends Error {
-  constructor(id, ...values) {
-    const message = messages[id](...values);
-    super(message);
-    this.name = `Error [ ${id} ]`;
-  }
-};
-var FrameworkTypeError = class extends TypeError {
-  constructor(id, ...values) {
-    const message = messages[id](...values);
-    super(message);
-    this.name = `TypeError [ ${id} ]`;
+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 __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/autocomplete/Autocompleter.ts
-function Autocompleter(options) {
-  if (!options) throw new FrameworkError("NoOptions");
-  if (typeof options !== "object") throw new FrameworkTypeError("InvalidType", "options", "object", typeof options);
-  if (!options.name || !options.name?.length) throw new FrameworkError("InvalidOption", "name");
-  if (typeof options.name !== "string") throw new FrameworkTypeError("InvalidType", "name", "string", typeof options.name);
-  if (!options.execute) throw new FrameworkError("InvalidOption", "execute");
-  if (typeof options.execute !== "function") throw new FrameworkTypeError("InvalidType", "execute", "function", typeof options.execute);
-  if (options.disabled !== void 0 && typeof options.disabled !== "boolean") throw new FrameworkTypeError("InvalidType", "disabled", "boolean", typeof options.disabled);
-  return {
-    id: options.name,
-    name: options.name,
-    disabled: options.disabled ?? false,
-    execute: options.execute
-  };
-}
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  AttachmentOption: () => import_discord9.SlashCommandAttachmentOption,
+  Autocompleter: () => Autocompleter,
+  BooleanOption: () => import_discord9.SlashCommandBooleanOption,
+  ChannelOption: () => import_discord9.SlashCommandChannelOption,
+  ContextCommand: () => ContextCommand,
+  FrameworkClient: () => FrameworkClient,
+  IntegerOption: () => import_discord9.SlashCommandIntegerOption,
+  Listener: () => Listener,
+  MentionableOption: () => import_discord9.SlashCommandMentionableOption,
+  MessageCommand: () => MessageCommand,
+  NumberOption: () => import_discord9.SlashCommandNumberOption,
+  RoleOption: () => import_discord9.SlashCommandRoleOption,
+  SlashCommand: () => SlashCommand,
+  StringOption: () => import_discord9.SlashCommandStringOption,
+  SubcommandBuilder: () => import_discord9.SlashCommandSubcommandBuilder,
+  SubcommandGroupBuilder: () => import_discord9.SlashCommandSubcommandGroupBuilder,
+  UserOption: () => import_discord9.SlashCommandUserOption
+});
+module.exports = __toCommonJS(index_exports);
 
-// src/commands/ContextCommand.ts
-import { ApplicationIntegrationType as ApplicationIntegrationType2, InteractionContextType as InteractionContextType2 } from "discord.js";
+// src/core/FrameworkClient.ts
+var import_discord4 = require("discord.js");
 
-// src/utils/utils.ts
-import { ApplicationCommandType, ApplicationIntegrationType, InteractionContextType, PermissionsBitField } from "discord.js";
-import path from "path";
-import fs from "fs";
+// src/utils/files.ts
+var import_node_path = __toESM(require("path"), 1);
+var import_node_url = __toESM(require("url"), 1);
+var import_node_fs = __toESM(require("fs"), 1);
 async function listFiles(dir) {
-  if (!fs.existsSync(dir)) return [];
+  if (!import_node_fs.default.existsSync(dir)) return [];
   const files = [];
-  const items = fs.readdirSync(dir, { withFileTypes: true });
+  const items = import_node_fs.default.readdirSync(dir, { withFileTypes: true });
   for (const item of items) {
-    const fullPath = path.join(dir, item.name);
+    const fullPath = import_node_path.default.join(dir, item.name);
     if (item.isDirectory()) files.push(...await listFiles(fullPath));
     else if (item.name.endsWith(".js") || item.name.endsWith(".ts")) files.push(fullPath);
   }
   return files;
 }
-function isPermissionResolvable(option) {
-  try {
-    PermissionsBitField.resolve(option);
-    return true;
-  } catch {
-    return false;
-  }
+function dirExists(dir) {
+  return import_node_fs.default.existsSync(dir);
+}
+function resolvePath(...paths) {
+  return import_node_path.default.resolve(...paths);
+}
+function pathToFileURL(filepath) {
+  return import_node_url.default.pathToFileURL(filepath);
 }
+
+// src/utils/helpers.ts
+var import_discord = require("discord.js");
 function unixTimestamp(date, type = "f") {
   return `<t:${Math.floor(new Date(date).valueOf() / 1e3)}:${type}>`;
 }
-function resolveCommandType(type) {
-  return type === "Slash" ? ApplicationCommandType.ChatInput : type === "ContextUser" ? ApplicationCommandType.User : ApplicationCommandType.Message;
+function createPrefixRegex(userId, prefix2) {
+  return new RegExp(`^(<@!?${userId}>${prefix2 ? `|${prefix2.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}` : ""})\\s*`);
+}
+function normalizeCommandName(name, type) {
+  if (type === "ContextUser" || type === "ContextMessage") return name;
+  return name.trim().toLowerCase().replace(/\s+/g, "-");
 }
 function resolveCommandContexts(contexts) {
-  return contexts?.length ? contexts.map((c) => typeof c === "string" ? InteractionContextType[c] : c) : [InteractionContextType.Guild];
+  return contexts?.length ? contexts.map((c) => typeof c === "string" ? import_discord.InteractionContextType[c] : c) : [import_discord.InteractionContextType.Guild];
 }
 function resolveIntegrationTypes(types) {
-  return types?.length ? types.map((c) => typeof c === "string" ? ApplicationIntegrationType[c] : c) : [ApplicationIntegrationType.GuildInstall];
-}
-
-// src/commands/Command.ts
-var CommandTypes = ["Slash", "Message", "ContextMessage", "ContextUser"];
-function Command(options) {
-  if (!options) throw new FrameworkError("NoOptions");
-  if (typeof options !== "object") throw new FrameworkTypeError("InvalidType", "options", "object", typeof options);
-  if (!options.name || !options.name?.length) throw new FrameworkError("InvalidOption", "name");
-  if (typeof options.name !== "string") throw new FrameworkTypeError("InvalidType", "name", "string", typeof options.name);
-  if (!options.description || !options.description?.length) throw new FrameworkError("InvalidOption", "description");
-  if (typeof options.description !== "string") throw new FrameworkTypeError("InvalidType", "description", "string", typeof options.name);
-  if (!options.commandType) throw new FrameworkError("InvalidOption", "commandType");
-  if (!CommandTypes.includes(options.commandType)) throw new FrameworkError("InvalidValue", "commandType", CommandTypes);
-  if (options.memberPermissions !== void 0 && !isPermissionResolvable(options.memberPermissions)) throw new FrameworkTypeError("InvalidType", "memberPermissions", "PermissionResolvable", typeof options.memberPermissions);
-  if (options.clientPermissions !== void 0 && !isPermissionResolvable(options.clientPermissions)) throw new FrameworkTypeError("InvalidType", "clientPermissions", "PermissionResolvable", typeof options.clientPermissions);
-  if (options.cooldown && typeof options.cooldown !== "number") throw new FrameworkTypeError("InvalidType", "cooldown", "number", typeof options.cooldown);
-  if (options.disabled !== void 0 && typeof options.disabled !== "boolean") throw new FrameworkTypeError("InvalidType", "disabled", "boolean", typeof options.disabled);
-  return {
-    ...options,
-    id: `${options.commandType}:${options.name}`,
-    name: options.name,
-    description: options.description,
-    commandType: options.commandType,
-    memberPermissions: options.memberPermissions ?? void 0,
-    clientPermissions: options.clientPermissions ?? void 0,
-    cooldown: options.cooldown ?? void 0,
-    disabled: options.disabled ?? false
-  };
+  return types?.length ? types.map((t) => typeof t === "string" ? import_discord.ApplicationIntegrationType[t] : t) : [import_discord.ApplicationIntegrationType.GuildInstall];
 }
-
-// src/commands/ContextCommand.ts
-var CommandScope = ["default", "guild", "global"];
-var CommandTypes2 = ["ContextUser", "ContextMessage"];
-var CommandContexts = ["Guild", "BotDM", "PrivateChannel", 0, 1, 2];
-var IntegrationTypes = ["GuildInstall", "UserInstall", 0, 1];
-function ContextCommand(options) {
-  if (!options.commandType) throw new FrameworkError("InvalidOption", "commandType");
-  if (typeof options.commandScope !== "string" || !CommandTypes2.includes(options.commandType)) throw new FrameworkError("InvalidValue", "commandType", CommandTypes2);
-  if (!options.commandScope) throw new FrameworkError("InvalidOption", "commandScope");
-  if (typeof options.commandScope !== "string" || !CommandScope.includes(options.commandScope)) throw new FrameworkError("InvalidValue", "commandScope", CommandScope);
-  if (options.commandContexts && !Array.isArray(options.commandContexts)) throw new FrameworkTypeError("InvalidType", "commandContexts", "Array", typeof options.commandContexts);
-  if (options.commandContexts && options.commandContexts.some((c) => !CommandContexts.includes(c))) throw new FrameworkError("InvalidValues", "commandContexts", CommandContexts);
-  if (options.integrationTypes && !Array.isArray(options.integrationTypes)) throw new FrameworkTypeError("InvalidType", "integrationTypes", "Array", typeof options.integrationTypes);
-  if (options.integrationTypes && options.integrationTypes.some((c) => !IntegrationTypes.includes(c))) throw new FrameworkError("InvalidValues", "integrationTypes", IntegrationTypes);
-  if (!options.execute) throw new FrameworkError("InvalidOption", "execute");
-  if (typeof options.execute !== "function") throw new FrameworkTypeError("InvalidType", "execute", "function", typeof options.execute);
-  if (!options.commandContexts) options.commandContexts = [InteractionContextType2.Guild];
-  if (!options.integrationTypes) options.integrationTypes = [ApplicationIntegrationType2.GuildInstall];
-  return Command({
-    ...options,
-    commandType: options.commandType
-  });
+function normalizeOptions(options) {
+  if (!options || !options?.length) return [];
+  if (typeof options === "function") {
+    const built = options(new import_discord.SlashCommandBuilder());
+    return built.options?.map((o) => o.toJSON()) ?? [];
+  }
+  if (Array.isArray(options)) {
+    return options.map((o) => "toJSON" in o ? o.toJSON() : o);
+  }
+  return [];
 }
 
-// src/commands/MessageCommand.ts
-var Contexts = ["BotDM", "Guild"];
-function MessageCommand(options) {
-  if (options.aliases && !Array.isArray(options.aliases)) throw new FrameworkTypeError("InvalidType", "aliases", "array", typeof options.aliases);
-  if (options.usage && typeof options.usage !== "string") throw new FrameworkTypeError("InvalidType", "usage", "string", typeof options.usage);
-  if (options.contexts && !Array.isArray(options.contexts)) throw new FrameworkTypeError("InvalidType", "contexts", "array", typeof options.contexts);
-  if (options.contexts && options.contexts.some((c) => !Contexts.includes(c))) throw new FrameworkError("InvalidValues", "contexts", Contexts);
-  if (!options.execute) throw new FrameworkError("InvalidOption", "execute");
-  if (typeof options.execute !== "function") throw new FrameworkTypeError("InvalidType", "execute", "function", typeof options.execute);
-  if (options.devOnly !== void 0 && typeof options.devOnly !== "boolean") throw new FrameworkTypeError("InvalidType", "devOnly", "boolean", typeof options.devOnly);
-  if (!options.contexts) options.contexts = ["Guild"];
-  if (options.devOnly === void 0) options.devOnly = false;
-  return Command({
-    ...options,
-    commandType: "Message"
-  });
+// src/utils/perms.ts
+var import_discord2 = require("discord.js");
+function isPermissionResolvable(option) {
+  try {
+    import_discord2.PermissionsBitField.resolve(option);
+    return true;
+  } catch {
+    return false;
+  }
+  ;
 }
-
-// src/commands/SlashCommand.ts
-import { ApplicationIntegrationType as ApplicationIntegrationType3, InteractionContextType as InteractionContextType3 } from "discord.js";
-var CommandScope2 = ["default", "guild", "global"];
-var CommandContexts2 = ["Guild", "BotDM", "PrivateChannel", 0, 1, 2];
-var IntegrationTypes2 = ["GuildInstall", "UserInstall", 0, 1];
-function SlashCommand(options) {
-  if (!options.commandScope) throw new FrameworkError("InvalidOption", "commandScope");
-  if (typeof options.commandScope !== "string" || !CommandScope2.includes(options.commandScope)) throw new FrameworkError("InvalidValue", "commandScope", CommandScope2);
-  if (options.commandContexts && !Array.isArray(options.commandContexts)) throw new FrameworkTypeError("InvalidType", "commandContexts", "Array", typeof options.commandContexts);
-  if (options.commandContexts && options.commandContexts.some((c) => !CommandContexts2.includes(c))) throw new FrameworkError("InvalidValues", "commandContexts", CommandContexts2);
-  if (options.integrationTypes && !Array.isArray(options.integrationTypes)) throw new FrameworkTypeError("InvalidType", "integrationTypes", "Array", typeof options.integrationTypes);
-  if (options.integrationTypes && options.integrationTypes.some((c) => !IntegrationTypes2.includes(c))) throw new FrameworkError("InvalidType", "integrationTypes", IntegrationTypes2);
-  if (!options.execute) throw new FrameworkError("InvalidOption", "execute");
-  if (typeof options.execute !== "function") throw new FrameworkTypeError("InvalidType", "execute", "function", typeof options.execute);
-  if (!options.commandContexts) options.commandContexts = [InteractionContextType3.Guild];
-  if (!options.integrationTypes) options.integrationTypes = [ApplicationIntegrationType3.GuildInstall];
-  return Command({
-    ...options,
-    commandType: "Slash"
-  });
+function resolvePermissions(member, channel) {
+  return (channel && member.permissionsIn(channel)) ?? member.permissions;
 }
-
-// src/listeners/Listener.ts
-function Listener(options) {
-  if (!options) throw new FrameworkError("NoOptions");
-  if (typeof options !== "object") throw new FrameworkTypeError("InvalidType", "options", "object", typeof options);
-  if (!options.name || !options.name?.length) throw new FrameworkError("InvalidOption", "name");
-  if (typeof options.name !== "string") throw new FrameworkTypeError("InvalidType", "name", "string", typeof options.name);
-  if (!options.execute) throw new FrameworkError("InvalidOption", "execute");
-  if (typeof options.execute !== "function") throw new FrameworkTypeError("InvalidType", "execute", "function", typeof options.execute);
-  if (options.once !== void 0 && typeof options.once !== "boolean") throw new FrameworkTypeError("InvalidType", "once", "boolean", typeof options.once);
-  if (options.disabled !== void 0 && typeof options.disabled !== "boolean") throw new FrameworkTypeError("InvalidType", "disabled", "boolean", typeof options.disabled);
-  return {
-    id: `Client:${options.name}`,
-    name: options.name,
-    once: options.once ?? false,
-    disabled: options.disabled ?? false,
-    execute: options.execute
-  };
+function formatPermissions(perms) {
+  return perms.map(
+    (p) => `\`${p.replace(/([A-Z])/g, (m, l, i) => i === 0 ? l : ` ${l}`)}\``
+  ).join(", ");
 }
 
-// src/FrameworkClient.ts
-import { Collection as Collection2, Client as DiscordClient } from "discord.js";
+// src/core/FrameworkError.ts
+var import_util = require("util");
+var messages = {
+  NoOptions: () => `No options object was provided.`,
+  InvalidOption: (name) => `No "${name}" option was provided.`,
+  InvalidType: (name, expected, actual) => `Expected "${name}" to be of type "${expected}", but got "${actual}".`,
+  InvalidValue: (name, expected) => `Expected "${name}" to be any one of the listed values: ${expected.map((v) => `"${v}"`).join(" | ")}`,
+  InvalidValues: (name, expected) => `Expected "${name}" to contain only the listed values: ${expected.map((v) => `"${v}"`).join(" | ")}`,
+  UnknownComponent: (type, id) => `Encountered an error as there is no "${type}" loaded with the id "${id}".`,
+  ComponentLoadError: (type, error) => `Encountered an error while loading the "${type}": 
+${(0, import_util.inspect)(error)}`,
+  ComponentAlreadyLoaded: (type, id) => `Encountered an error as a "${type}" with the id "${id}" is already loaded.`,
+  AppCommandRegister: (error, guildId) => `Encountered an error while registering commands ${guildId ? `to guild "${guildId}"` : ""}: 
+${(0, import_util.inspect)(error)}`
+};
+var FrameworkError = class extends Error {
+  constructor(id, ...values) {
+    super(messages[id](...values));
+    this.name = `FrameworkError [${id}]`;
+  }
+};
+var FrameworkTypeError = class extends TypeError {
+  constructor(id, ...values) {
+    super(messages[id](...values));
+    this.name = `FrameworkTypeError [${id}]`;
+  }
+};
 
-// src/autocomplete/AutocompleteModule.ts
-import { pathToFileURL } from "url";
-import EventEmitter from "events";
-import path2 from "path";
-var AutocompleteModule = class extends EventEmitter {
+// src/modules/AutocompletersModule.ts
+var import_events = __toESM(require("events"), 1);
+var AutocompletersModule = class extends import_events.default {
   client;
   constructor(client) {
     super();
@@ -217,53 +166,54 @@ var AutocompleteModule = class extends EventEmitter {
     this.client.on("interactionCreate", (interaction) => this._handleInteraction(interaction));
   }
   async load(filepath, reload = false) {
-    const completerModule = reload ? __require(filepath) : await import(pathToFileURL(filepath).href);
-    const completer = completerModule.autocomplete ?? completerModule.default?.default ?? completerModule.default ?? completerModule;
+    const module2 = await import(pathToFileURL(filepath).href + `?update=${Date.now()}`);
+    const completer = module2.autocomplete ?? module2.default?.default ?? module2.default ?? module2;
     if (typeof completer !== "object" || !completer.name || completer.disabled) return false;
-    if (!reload && this.client.autocomplete.has(completer.id)) throw new FrameworkError("ComponentAlreadyLoaded", "autocomplete", completer.id);
+    if (!reload && this.client.autocompleters.has(completer.id)) throw new FrameworkError("ComponentAlreadyLoaded", "autocomplete", completer.id);
     completer.filepath = filepath;
-    this.client.autocomplete.set(completer.id, completer);
+    this.client.autocompleters.set(completer.id, completer);
     return true;
   }
   async loadAll() {
-    const listenerDirs = path2.resolve(this.client.rootDir, "autocomplete");
-    const files = await listFiles(listenerDirs);
+    const files = await listFiles(this.client.autocompletersDir);
     for (const file of files) {
       try {
-        await this.load(path2.resolve(file));
+        await this.load(resolvePath(file));
       } catch (error) {
         this.client.emit("error", new FrameworkError("ComponentLoadError", "autocomplete", error));
       }
     }
   }
   async reload(id) {
-    const completer = this.client.autocomplete.get(id);
+    const completer = this.client.autocompleters.get(id);
     if (!completer) throw new FrameworkError("UnknownComponent", "autocomplete", id);
     this.unload(id, true);
     await this.load(completer.filepath, true);
   }
   unload(id, reload = false) {
-    if (!this.client.autocomplete.has(id)) throw new FrameworkError("UnknownComponent", "autocomplete", id);
-    const completer = this.client.autocomplete.get(id);
-    delete __require.cache[__require.resolve(completer.filepath)];
-    if (!reload) this.client.autocomplete.delete(id);
+    if (!this.client.autocompleters.has(id)) throw new FrameworkError("UnknownComponent", "autocomplete", id);
+    const completer = this.client.autocompleters.get(id);
+    delete require.cache[require.resolve(completer.filepath)];
+    if (!reload) this.client.autocompleters.delete(id);
   }
   async _handleInteraction(interaction) {
     if (!interaction.isAutocomplete()) return;
     const option = interaction.options.getFocused(true);
     const command = this.client.commands.get(`Slash:${interaction.commandName}`);
-    const completer = this.client.autocomplete.get(option.name);
-    if (!option || !command || command.commandType !== "Slash") {
+    const completer = this.client.autocompleters.get(option.name);
+    if (!command || command.commandType !== "Slash") {
       this.emit("unknown", interaction);
       return;
     }
-    if (completer && !completer.disabled) {
+    if (!interaction.inCachedGuild()) return;
+    const allowed = !completer?.commands?.length || completer.commands.includes(command.name);
+    if (completer && !completer.disabled && allowed) {
       try {
         this.emit("execute", { interaction, command, completer });
         await completer.execute(this.client, interaction, command, option.value);
         this.emit("success", { interaction, command, completer });
       } catch (error) {
-        this.emit("success", { interaction, command, completer, error });
+        this.emit("error", { interaction, command, completer, error });
       }
     } else if (typeof command.autocomplete === "function" && !command.disabled) {
       try {
@@ -271,7 +221,7 @@ var AutocompleteModule = class extends EventEmitter {
         await command.autocomplete(this.client, interaction);
         this.emit("success", { interaction, command, completer });
       } catch (error) {
-        this.emit("success", { interaction, command, completer, error });
+        this.emit("error", { interaction, command, completer, error });
       }
     } else {
       this.emit("unknown", interaction);
@@ -279,17 +229,15 @@ var AutocompleteModule = class extends EventEmitter {
   }
 };
 
-// src/listeners/ListenersModule.ts
-import { pathToFileURL as pathToFileURL2 } from "url";
-import path3 from "path";
+// src/modules/ListenersModule.ts
 var ListenerModule = class {
   client;
   constructor(client) {
     this.client = client;
   }
   async load(filepath, reload = false) {
-    const listenerModule = reload ? __require(filepath) : await import(pathToFileURL2(filepath).href);
-    const listener = listenerModule.listener ?? listenerModule.default?.default ?? listenerModule.default ?? listenerModule;
+    const module2 = await import(pathToFileURL(filepath).href + `?update=${Date.now()}`);
+    const listener = module2?.listener ?? module2?.default?.default ?? module2?.default ?? module2;
     if (typeof listener !== "object" || !listener.name || listener.disabled) return false;
     if (!reload && this.client.events.has(listener.id)) throw new FrameworkError("ComponentAlreadyLoaded", "listener", listener.id);
     listener.filepath = filepath;
@@ -299,11 +247,10 @@ var ListenerModule = class {
     return true;
   }
   async loadAll() {
-    const listenerDirs = path3.resolve(this.client.rootDir, "listeners");
-    const files = await listFiles(listenerDirs);
+    const files = await listFiles(this.client.listenersDir);
     for (const file of files) {
       try {
-        await this.load(path3.resolve(file));
+        await this.load(resolvePath(file));
       } catch (error) {
         this.client.emit("error", new FrameworkError("ComponentLoadError", "listener", error));
       }
@@ -319,19 +266,19 @@ var ListenerModule = class {
     if (!this.client.events.has(id)) throw new FrameworkError("UnknownComponent", "listener", id);
     const listener = this.client.events.get(id);
     if (listener._execute) this.client.off(listener.name, listener._execute);
-    delete __require.cache[__require.resolve(listener.filepath)];
+    delete require.cache[require.resolve(listener.filepath)];
     if (!reload) this.client.events.delete(id);
   }
 };
 
-// src/commands/CommandsModule.ts
-import { Collection, MessageFlags } from "discord.js";
-import { pathToFileURL as pathToFileURL3 } from "url";
-import EventEmitter2 from "events";
-import path4 from "path";
-var CommandsModule = class extends EventEmitter2 {
+// src/modules/CommandsModule.ts
+var import_discord3 = require("discord.js");
+var import_events2 = __toESM(require("events"), 1);
+var CommandsModule = class extends import_events2.default {
   client;
-  handler = {};
+  handlers = {};
+  middleware;
+  prefixRegex;
   constructor(client) {
     super();
     this.client = client;
@@ -339,17 +286,16 @@ var CommandsModule = class extends EventEmitter2 {
     this.client.on("interactionCreate", (interaction) => this._handleInteraction(interaction));
   }
   setHandler(key, callback) {
-    return this.handler[key] = callback;
-  }
-  setMessageInterceptor(callback) {
-    return this.handler.MessageCommandInterceptor = callback;
+    this.handlers[key] = callback;
+    return true;
   }
-  setInteractionInterceptor(callback) {
-    return this.handler.InteractionCommandInterceptor = callback;
+  setMiddleware(callback) {
+    this.middleware = callback;
+    return true;
   }
   async load(filepath, reload = false) {
-    const commandModule = reload ? __require(filepath) : await import(pathToFileURL3(filepath).href);
-    const command = commandModule?.command ?? commandModule?.default?.default ?? commandModule?.default ?? commandModule;
+    const module2 = await import(pathToFileURL(filepath).href + `?update=${Date.now()}`);
+    const command = module2?.command ?? module2?.default?.default ?? module2?.default ?? module2;
     if (typeof command !== "object" || !command.name || command.disabled) return false;
     if (!reload && this.client.commands.has(command.id)) throw new FrameworkError("ComponentAlreadyLoaded", "command", command.id);
     command.filepath = filepath;
@@ -360,11 +306,10 @@ var CommandsModule = class extends EventEmitter2 {
     return true;
   }
   async loadAll() {
-    const commandsDir = path4.resolve(this.client.rootDir, "commands");
-    const files = await listFiles(commandsDir);
+    const files = await listFiles(this.client.commandsDir);
     for (const file of files) {
       try {
-        await this.load(path4.resolve(file));
+        await this.load(resolvePath(file));
       } catch (error) {
         this.client.emit("error", new FrameworkError("ComponentLoadError", "commands", error));
       }
@@ -379,7 +324,7 @@ var CommandsModule = class extends EventEmitter2 {
   unload(id, reload = false) {
     if (!this.client.commands.has(id)) throw new FrameworkError("UnknownComponent", "commands", id);
     const command = this.client.commands.get(id);
-    delete __require.cache[__require.resolve(command.filepath)];
+    delete require.cache[require.resolve(command.filepath)];
     if (!reload) this.client.commands.delete(id);
   }
   async registerOnStart(guildIds, commands) {
@@ -403,13 +348,9 @@ var CommandsModule = class extends EventEmitter2 {
   }
   async _handleMessage(message) {
     if (!message.content?.length || message.author.bot) return;
-    if (this.handler.MessageCommandInterceptor) {
-      const shouldContinue = await this.handler.MessageCommandInterceptor(message);
-      if (!shouldContinue) return;
-    }
-    const prefixRegex = new RegExp(`^(<@!?${message.client.user.id}>${this.client.prefix ? `|${this.client.prefix.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}` : ""})\\s*`);
-    if (!prefixRegex.test(message.content.toLowerCase())) return;
-    const matchedPrefix = message.content.toLowerCase().match(prefixRegex)?.[1];
+    if (!this.prefixRegex) this.prefixRegex = createPrefixRegex(message.client.user.id, this.client.prefix);
+    if (!this.prefixRegex.test(message.content.toLowerCase())) return;
+    const matchedPrefix = message.content.toLowerCase().match(this.prefixRegex)?.[1];
     if (!matchedPrefix) return;
     const args = (message.content || "").slice(matchedPrefix.length).trim().split(/ +/);
     const commandName = args.shift()?.toLowerCase();
@@ -418,38 +359,48 @@ var CommandsModule = class extends EventEmitter2 {
     const command = this.client.commands.get(commandId) || this.client.commands.get(this.client.aliases.get(commandName) || "");
     if (!command || command.commandType !== "Message" || command.disabled || command.devOnly && !this.client.developers.includes(message.author.id)) return;
     if (!message.inGuild() && !command.contexts.includes("BotDM") || message.inGuild() && !command.contexts.includes("Guild")) return;
-    if (message.inGuild() && command.memberPermissions) {
-      const executor = await message.guild.members.fetch({ user: message.author.id, force: false });
-      const memberPerms = executor.permissionsIn(message.channel) ?? executor.permissions;
-      if (!memberPerms.has(command.memberPermissions)) {
-        const missingPermsArray = memberPerms.missing(command.memberPermissions);
-        if (typeof this.handler.onMemberPermissions === "function") return this.handler.onMemberPermissions(message, command, missingPermsArray);
-        else return await message.reply({ content: "\u274C You don't have the required permission(s) to use this command." }).then((m) => {
-          setTimeout(() => m.delete().catch((e) => null), 1e4);
-        }).catch(() => null);
-      }
+    if (this.middleware) {
+      const shouldContinue = await this.middleware(message, command);
+      if (!shouldContinue) return;
     }
-    if (message.inGuild() && command.clientPermissions) {
-      const clientMember = await message.guild.members.fetchMe({ force: false });
-      const clientPerms = clientMember.permissionsIn(message.channel) ?? clientMember.permissions;
-      if (!clientMember.permissions.has(command.clientPermissions)) {
-        const missingPermsArray = clientPerms.missing(command.clientPermissions);
-        if (typeof this.handler.onClientPermissions === "function") return this.handler.onClientPermissions(message, command, missingPermsArray);
-        else return await message.reply({ content: `\u274C ${clientMember.displayName} requires ${missingPermsArray.map((p) => `\` ${p.replace(/([A-Z])/g, (_, l, i) => i === 0 ? l : ` ${l}`)} \``).join(" ")} permission(s) to run this command.` }).then((m) => {
-          setTimeout(() => m.delete().catch((e) => null), 1e4);
-        }).catch(() => null);
+    if (message.inGuild()) {
+      const [executer, clientMember] = await Promise.all([
+        command.memberPermissions ? message.guild.members.fetch({ user: message.author.id, force: false }) : null,
+        command.clientPermissions ? message.guild.members.fetchMe({ force: false }) : null
+      ]);
+      if (command.memberPermissions && !executer || command.clientPermissions && !clientMember) return;
+      if (command.memberPermissions) {
+        const memberPerms = resolvePermissions(executer, message.channel);
+        if (!memberPerms.has(command.memberPermissions)) {
+          const missing = memberPerms.missing(command.memberPermissions);
+          if (typeof this.handlers.onMemberPermissions === "function") return this.handlers.onMemberPermissions(message, command, missing);
+          return message.reply({ content: "You don't have the required permission(s) to use this command." }).then((m) => {
+            setTimeout(() => m.delete().catch((e) => null), 1e4);
+          }).catch(() => null);
+        }
+      }
+      if (command.clientPermissions) {
+        const clientPerms = resolvePermissions(clientMember, message.channel);
+        if (!clientPerms.has(command.clientPermissions)) {
+          const missing = clientPerms.missing(command.clientPermissions);
+          if (typeof this.handlers.onClientPermissions === "function") return this.handlers.onClientPermissions(message, command, missing);
+          return message.reply({ content: `${clientMember.displayName} requires ${formatPermissions(missing)} permission(s) to run this command.` }).then((m) => {
+            setTimeout(() => m.delete().catch((e) => null), 1e4);
+          }).catch(() => null);
+        }
       }
     }
     if (command.cooldown && command.cooldown > 1e3) {
-      if (!this.client.cooldowns.has(commandId)) this.client.cooldowns.set(commandId, new Collection());
+      if (!this.client.cooldowns.has(commandId)) this.client.cooldowns.set(commandId, new import_discord3.Collection());
       const commandCooldowns = this.client.cooldowns.get(commandId);
       if (commandCooldowns) {
         if (commandCooldowns.has(message.author.id)) {
-          const expirationDate = new Date((commandCooldowns.get(message.author.id) || 0) + command.cooldown);
-          if (expirationDate.valueOf() - Date.now() > 1e3) {
-            if (typeof this.handler.onCooldown === "function") return this.handler.onCooldown(message, command, expirationDate);
-            else return await message.reply({ content: `\u274C Slow down and try the Command Again **${unixTimestamp(new Date(expirationDate), "R")}**.` }).then((m) => {
-              setTimeout(() => m.delete().catch((e) => null), expirationDate.valueOf() - Date.now());
+          const expiresAt = new Date((commandCooldowns.get(message.author.id) || 0) + command.cooldown).valueOf();
+          const now = Date.now();
+          if (expiresAt - now > 1e3) {
+            if (typeof this.handlers.onCooldown === "function") return this.handlers.onCooldown(message, command, new Date(expiresAt));
+            return message.reply({ content: `Slow down and try the Command Again **${unixTimestamp(new Date(expiresAt), "R")}**.` }).then((m) => {
+              setTimeout(() => m.delete().catch((e) => null), expiresAt - Date.now());
             });
           }
         }
@@ -459,7 +410,11 @@ var CommandsModule = class extends EventEmitter2 {
     }
     try {
       this.emit("execute", { context: message, command });
-      await command.execute(this.client, message, args);
+      if (message.inGuild() && command.contexts.includes("Guild")) {
+        await command.execute(this.client, message, args);
+      } else if (!message.inGuild() && command.contexts.includes("BotDM")) {
+        await command.execute(this.client, message, args);
+      }
       this.emit("success", { context: message, command });
     } catch (error) {
       this.emit("error", { context: message, command, error });
@@ -467,34 +422,35 @@ var CommandsModule = class extends EventEmitter2 {
   }
   async _handleInteraction(interaction) {
     if (!interaction.isChatInputCommand() && !interaction.isContextMenuCommand()) return;
-    if (this.handler.InteractionCommandInterceptor) {
-      const shouldContinue = await this.handler.InteractionCommandInterceptor(interaction);
-      if (!shouldContinue) return;
-    }
     const commandId = `${this._getCommandId(interaction)}:${interaction.commandName}`;
     const command = this.client.commands.get(commandId);
     if (!command || command.disabled || command.commandType === "Message") {
       this.emit("unknown", interaction);
       return;
     }
-    if (interaction.guild && interaction.channel && !interaction.channel.isDMBased() && command.clientPermissions) {
+    if (this.middleware) {
+      const shouldContinue = await this.middleware(interaction, command);
+      if (!shouldContinue) return;
+    }
+    if (!interaction.inCachedGuild() && (command.commandContexts?.includes("Guild") || command.commandContexts?.includes(0))) return;
+    if (command.clientPermissions && interaction.inCachedGuild()) {
       const clientMember = await interaction.guild.members.fetchMe({ force: false });
-      const clientPerms = interaction.channel.isSendable() ? clientMember.permissionsIn(interaction.channel) : clientMember.permissions;
+      const clientPerms = resolvePermissions(clientMember, interaction.channel);
       if (!clientPerms.has(command.clientPermissions)) {
-        const missingPermsArray = clientPerms.missing(command.clientPermissions);
-        if (typeof this.handler.onClientPermissions === "function") return this.handler.onClientPermissions(interaction, command, missingPermsArray);
-        else return await interaction.reply({ content: `\u274C ${clientMember.displayName} requires ${missingPermsArray.map((p) => `\` ${p.replace(/([A-Z])/g, (_, l, i) => i === 0 ? l : ` ${l}`)} \``).join(" ")} permission(s) to run this command.`, flags: MessageFlags.Ephemeral });
+        const missing = clientPerms.missing(command.clientPermissions);
+        if (typeof this.handlers.onClientPermissions === "function") return this.handlers.onClientPermissions(interaction, command, missing);
+        return interaction.reply({ content: `${clientMember.displayName} requires ${formatPermissions(missing)} permission(s) to run this command.`, flags: import_discord3.MessageFlags.Ephemeral });
       }
     }
     if (command.cooldown && command.cooldown > 1e3) {
-      if (!this.client.cooldowns.has(commandId)) this.client.cooldowns.set(commandId, new Collection());
+      if (!this.client.cooldowns.has(commandId)) this.client.cooldowns.set(commandId, new import_discord3.Collection());
       const commandCooldowns = this.client.cooldowns.get(commandId);
       if (commandCooldowns) {
         if (commandCooldowns.has(interaction.user.id)) {
-          const expirationDate = new Date((commandCooldowns.get(interaction.user.id) || 0) + command.cooldown);
-          if (expirationDate.valueOf() - Date.now() > 1e3) {
-            if (typeof this.handler.onCooldown === "function") return this.handler.onCooldown(interaction, command, expirationDate);
-            else return await interaction.reply({ content: `\u274C Slow down and try the Command Again **${unixTimestamp(new Date(expirationDate), "R")}**.`, flags: MessageFlags.Ephemeral });
+          const expiresAt = new Date((commandCooldowns.get(interaction.user.id) || 0) + command.cooldown).valueOf();
+          if (expiresAt - Date.now() > 1e3) {
+            if (typeof this.handlers.onCooldown === "function") return this.handlers.onCooldown(interaction, command, new Date(expiresAt));
+            return await interaction.reply({ content: `Slow down and try the Command Again **${unixTimestamp(new Date(expiresAt), "R")}**.`, flags: import_discord3.MessageFlags.Ephemeral });
           }
         }
         commandCooldowns.set(interaction.user.id, (/* @__PURE__ */ new Date()).valueOf());
@@ -516,60 +472,229 @@ var CommandsModule = class extends EventEmitter2 {
     return "unknown";
   }
   _getCommandData(command) {
-    return {
+    const base = {
       name: command.name,
-      description: command.description,
-      type: resolveCommandType(command.commandType),
       defaultMemberPermissions: command.memberPermissions ?? null,
       contexts: resolveCommandContexts(command.commandContexts),
       integrationTypes: resolveIntegrationTypes(command.integrationTypes),
       nameLocalizations: command.nameLocalizations,
-      descriptionLocalizations: command.descriptionLocalizations,
-      ...command.commandType === "Slash" ? { options: command.options ?? [] } : {}
+      descriptionLocalizations: command.descriptionLocalizations
+    };
+    if (command.commandType === "Slash") {
+      return {
+        ...base,
+        type: import_discord3.ApplicationCommandType.ChatInput,
+        description: command.description,
+        options: command.options
+      };
+    } else if (command.commandType === "ContextMessage") {
+      return {
+        ...base,
+        type: import_discord3.ApplicationCommandType.Message
+      };
+    }
+    return {
+      ...base,
+      type: import_discord3.ApplicationCommandType.User
     };
   }
 };
 
-// src/FrameworkClient.ts
-import fs2 from "fs";
-var FrameworkClient = class extends DiscordClient {
-  rootDir;
+// src/core/FrameworkClient.ts
+var FrameworkClient = class extends import_discord4.Client {
   prefix;
   developers;
+  rootDir;
+  commandsDir;
+  listenersDir;
+  autocompletersDir;
+  _inited = false;
+  autocompleters = new import_discord4.Collection();
+  events = new import_discord4.Collection();
+  aliases = new import_discord4.Collection();
+  commands = new import_discord4.Collection();
+  cooldowns = new import_discord4.Collection();
+  commandsModule;
+  listenersModule;
+  autocompletersModule;
   constructor(frameworkOptions) {
     super(frameworkOptions.clientOptions);
     this.prefix = frameworkOptions.prefix ?? "!";
-    this.rootDir = frameworkOptions.rootDir ?? (fs2.existsSync("./src") ? "./src" : "./");
-    this.developers = frameworkOptions.developers || [];
-    this.autocomplete = new Collection2();
-    this.events = new Collection2();
-    this.aliases = new Collection2();
-    this.commands = new Collection2();
-    this.cooldowns = new Collection2();
-    this.autocompleteModule = new AutocompleteModule(this);
-    this.listenerModule = new ListenerModule(this);
+    this.developers = [...frameworkOptions.developers || []];
+    this.rootDir = frameworkOptions.rootDir ?? (dirExists("./src") ? "./src" : "./");
+    this.commandsDir = resolvePath(this.rootDir, frameworkOptions.commandsDir ?? "commands");
+    this.listenersDir = resolvePath(this.rootDir, frameworkOptions.listenersDir ?? "listeners");
+    this.autocompletersDir = resolvePath(this.rootDir, frameworkOptions.autocompletersDir ?? "autocompleters");
     this.commandsModule = new CommandsModule(this);
-    this.on("interactionCreate", (interaction) => {
-      if (interaction.isAnySelectMenu()) return this.emit("selectMenuInteraction", interaction);
-      else if (interaction.isModalSubmit()) return this.emit("modalSubmitInteraction", interaction);
-      else if (interaction.isButton()) return this.emit("buttonInteraction", interaction);
-    });
+    this.listenersModule = new ListenerModule(this);
+    this.autocompletersModule = new AutocompletersModule(this);
+    this.routeInteractions();
     this.once("clientReady", async () => {
       if (frameworkOptions.registerOnStart && frameworkOptions.guildsToRegister?.length) {
         await this.commandsModule.registerOnStart(frameworkOptions.guildsToRegister);
       }
     });
   }
-  async start(token) {
-    await this.listenerModule.loadAll();
-    await this.autocompleteModule.loadAll();
+  async init() {
+    this._inited = true;
+    await this.listenersModule.loadAll();
+    await this.autocompletersModule.loadAll();
     await this.commandsModule.loadAll();
+  }
+  async start(token) {
+    if (!this._inited) await this.init();
     await this.login(token);
   }
+  routeInteractions() {
+    this.on("interactionCreate", (interaction) => {
+      if (interaction.isAnySelectMenu()) return this.emit("selectMenuInteraction", interaction);
+      else if (interaction.isModalSubmit()) return this.emit("modalSubmitInteraction", interaction);
+      else if (interaction.isButton()) return this.emit("buttonInteraction", interaction);
+    });
+  }
 };
 
+// src/builders/autocompleters/Autocompleter.ts
+function Autocompleter(options) {
+  if (!options) throw new FrameworkError("NoOptions");
+  if (typeof options !== "object") throw new FrameworkTypeError("InvalidType", "options", "object", typeof options);
+  if (!options.name || !options.name?.length) throw new FrameworkError("InvalidOption", "name");
+  if (typeof options.name !== "string") throw new FrameworkTypeError("InvalidType", "name", "string", typeof options.name);
+  if (!options.execute) throw new FrameworkError("InvalidOption", "execute");
+  if (typeof options.execute !== "function") throw new FrameworkTypeError("InvalidType", "execute", "function", typeof options.execute);
+  if (options.commands && !Array.isArray(options.commands)) throw new FrameworkTypeError("InvalidType", "commands", "string[]", typeof options.commands);
+  if (options.disabled !== void 0 && typeof options.disabled !== "boolean") throw new FrameworkTypeError("InvalidType", "disabled", "boolean", typeof options.disabled);
+  return {
+    id: options.name,
+    name: options.name,
+    disabled: options.disabled ?? false,
+    execute: options.execute
+  };
+}
+
+// src/types/commands.ts
+var CommandTypes = ["Slash", "Message", "ContextMessage", "ContextUser"];
+var CommandContexts = ["Guild", "BotDM", "PrivateChannel", 0, 1, 2];
+var IntegrationTypes = ["GuildInstall", "UserInstall", 0, 1];
+var CommandScopes = ["default", "guild", "global"];
+var MessageCommandContexts = ["Guild", "BotDM"];
+
+// src/builders/commands/ContextCommand.ts
+var import_discord5 = require("discord.js");
+
+// src/builders/commands/BaseCommand.ts
+function BaseCommand(options) {
+  if (!options) throw new FrameworkError("NoOptions");
+  if (typeof options !== "object") throw new FrameworkTypeError("InvalidType", "options", "object", typeof options);
+  if (!options.name || !options.name?.length) throw new FrameworkError("InvalidOption", "name");
+  if (typeof options.name !== "string") throw new FrameworkTypeError("InvalidType", "name", "string", typeof options.name);
+  if (!options.description || !options.description?.length) throw new FrameworkError("InvalidOption", "description");
+  if (typeof options.description !== "string") throw new FrameworkTypeError("InvalidType", "description", "string", typeof options.description);
+  if (!options.commandType) throw new FrameworkError("InvalidOption", "commandType");
+  if (!CommandTypes.includes(options.commandType)) throw new FrameworkError("InvalidValue", "commandType", CommandTypes);
+  if (options.memberPermissions !== void 0 && !isPermissionResolvable(options.memberPermissions)) {
+    throw new FrameworkTypeError("InvalidType", "memberPermissions", "PermissionResolvable", typeof options.memberPermissions);
+  }
+  if (options.clientPermissions !== void 0 && !isPermissionResolvable(options.clientPermissions)) {
+    throw new FrameworkTypeError("InvalidType", "clientPermissions", "PermissionResolvable", typeof options.clientPermissions);
+  }
+  if (options.cooldown && typeof options.cooldown !== "number") throw new FrameworkTypeError("InvalidType", "cooldown", "number", typeof options.cooldown);
+  if (options.disabled !== void 0 && typeof options.disabled !== "boolean") throw new FrameworkTypeError("InvalidType", "disabled", "boolean", typeof options.disabled);
+  return {
+    ...options,
+    id: `${options.commandType}:${options.name}`,
+    name: normalizeCommandName(options.name, options.commandType),
+    description: options.description,
+    commandType: options.commandType,
+    memberPermissions: options.memberPermissions ?? void 0,
+    clientPermissions: options.clientPermissions ?? void 0,
+    cooldown: options.cooldown ?? void 0,
+    disabled: options.disabled ?? false
+  };
+}
+
+// src/builders/commands/ContextCommand.ts
+function ContextCommand(options) {
+  if (!options.commandType) throw new FrameworkError("InvalidOption", "commandType");
+  if (options.commandType !== CommandTypes[2] && options.commandType !== CommandTypes[3]) throw new FrameworkError("InvalidValue", "commandType", CommandTypes);
+  if (!options.commandScope) throw new FrameworkError("InvalidOption", "commandScope");
+  if (typeof options.commandScope !== "string" || !CommandScopes.includes(options.commandScope)) throw new FrameworkError("InvalidValue", "commandScope", CommandScopes);
+  if (options.commandContexts && !Array.isArray(options.commandContexts)) throw new FrameworkTypeError("InvalidType", "commandContexts", "Array", typeof options.commandContexts);
+  if (options.commandContexts && options.commandContexts.some((c) => !CommandContexts.includes(c))) throw new FrameworkError("InvalidValues", "commandContexts", CommandContexts);
+  if (options.integrationTypes && !Array.isArray(options.integrationTypes)) throw new FrameworkTypeError("InvalidType", "integrationTypes", "Array", typeof options.integrationTypes);
+  if (options.integrationTypes && options.integrationTypes.some((c) => !IntegrationTypes.includes(c))) throw new FrameworkError("InvalidValues", "integrationTypes", IntegrationTypes);
+  if (!options.execute) throw new FrameworkError("InvalidOption", "execute");
+  if (typeof options.execute !== "function") throw new FrameworkTypeError("InvalidType", "execute", "function", typeof options.execute);
+  if (!options.commandContexts || !options.commandContexts.length) options.commandContexts = [import_discord5.InteractionContextType.Guild];
+  if (!options.integrationTypes || !options.integrationTypes.length) options.integrationTypes = [import_discord5.ApplicationIntegrationType.GuildInstall];
+  return BaseCommand({
+    ...options,
+    commandType: options.commandType,
+    description: options.description ?? "no description"
+  });
+}
+
+// src/builders/commands/MessageCommand.ts
+function MessageCommand(options) {
+  if (options.aliases && !Array.isArray(options.aliases)) throw new FrameworkTypeError("InvalidType", "aliases", "array", typeof options.aliases);
+  if (options.usage && typeof options.usage !== "string") throw new FrameworkTypeError("InvalidType", "usage", "string", typeof options.usage);
+  if (options.contexts && !Array.isArray(options.contexts)) throw new FrameworkTypeError("InvalidType", "contexts", "array", typeof options.contexts);
+  if (options.contexts && options.contexts.some((c) => !MessageCommandContexts.includes(c))) throw new FrameworkError("InvalidValues", "contexts", MessageCommandContexts);
+  if (!options.execute) throw new FrameworkError("InvalidOption", "execute");
+  if (typeof options.execute !== "function") throw new FrameworkTypeError("InvalidType", "execute", "function", typeof options.execute);
+  if (options.devOnly !== void 0 && typeof options.devOnly !== "boolean") throw new FrameworkTypeError("InvalidType", "devOnly", "boolean", typeof options.devOnly);
+  if (!options.contexts) options.contexts = ["Guild"];
+  if (options.devOnly === void 0) options.devOnly = false;
+  return BaseCommand({
+    ...options,
+    commandType: "Message"
+  });
+}
+
+// src/builders/commands/SlashCommand.ts
+var import_discord6 = require("discord.js");
+function SlashCommand(options) {
+  if (!options.commandScope) throw new FrameworkError("InvalidOption", "commandScope");
+  if (typeof options.commandScope !== "string" || !CommandScopes.includes(options.commandScope)) throw new FrameworkError("InvalidValue", "commandScope", CommandScopes);
+  if (options.commandContexts && !Array.isArray(options.commandContexts)) throw new FrameworkTypeError("InvalidType", "commandContexts", "Array", typeof options.commandContexts);
+  if (options.commandContexts && options.commandContexts.some((c) => !CommandContexts.includes(c))) throw new FrameworkError("InvalidValues", "commandContexts", CommandContexts);
+  if (options.integrationTypes && !Array.isArray(options.integrationTypes)) throw new FrameworkTypeError("InvalidType", "integrationTypes", "Array", typeof options.integrationTypes);
+  if (options.integrationTypes && options.integrationTypes.some((c) => !IntegrationTypes.includes(c))) throw new FrameworkError("InvalidValues", "integrationTypes", IntegrationTypes);
+  if (!options.execute) throw new FrameworkError("InvalidOption", "execute");
+  if (typeof options.execute !== "function") throw new FrameworkTypeError("InvalidType", "execute", "function", typeof options.execute);
+  options.options = normalizeOptions(options.options);
+  if (!options.commandContexts || !options.commandContexts.length) options.commandContexts = [import_discord6.InteractionContextType.Guild];
+  if (!options.integrationTypes || !options.integrationTypes.length) options.integrationTypes = [import_discord6.ApplicationIntegrationType.GuildInstall];
+  return BaseCommand({
+    ...options,
+    commandType: "Slash"
+  });
+}
+
+// src/builders/listeners/Listener.ts
+function Listener(options) {
+  if (!options) throw new FrameworkError("NoOptions");
+  if (typeof options !== "object") throw new FrameworkTypeError("InvalidType", "options", "object", typeof options);
+  if (!options.name || !options.name?.length) throw new FrameworkError("InvalidOption", "name");
+  if (typeof options.name !== "string") throw new FrameworkTypeError("InvalidType", "name", "string", typeof options.name);
+  if (!options.execute) throw new FrameworkError("InvalidOption", "execute");
+  if (typeof options.execute !== "function") throw new FrameworkTypeError("InvalidType", "execute", "function", typeof options.execute);
+  if (options.once !== void 0 && typeof options.once !== "boolean") throw new FrameworkTypeError("InvalidType", "once", "boolean", typeof options.once);
+  if (options.disabled !== void 0 && typeof options.disabled !== "boolean") throw new FrameworkTypeError("InvalidType", "disabled", "boolean", typeof options.disabled);
+  return {
+    id: `Client:${options.name}`,
+    name: options.name,
+    once: options.once ?? false,
+    disabled: options.disabled ?? false,
+    execute: options.execute
+  };
+}
+
+// src/extensions/index.ts
+var import_discord8 = require("discord.js");
+
 // src/extensions/Message.ts
-import { Message as Message2, MessageCollector, InteractionCollector, InteractionType } from "discord.js";
+var import_discord7 = require("discord.js");
 function prefix() {
   return this.client.prefix;
 }
@@ -581,7 +706,7 @@ function awaitMemberResponse(options = {}) {
     if (!this.channel) {
       return reject(new Error("Channel not available for this message."));
     }
-    const collector = new MessageCollector(this.channel, {
+    const collector = new import_discord7.MessageCollector(this.channel, {
       time: 6e4,
       filter: (m) => m.author.id === this.author.id && (m.content || "").length > 0,
       ...options,
@@ -599,19 +724,19 @@ function awaitMemberResponse(options = {}) {
   });
 }
 function createModalSubmitCollector(options = {}) {
-  return new InteractionCollector(this.client, {
+  return new import_discord7.InteractionCollector(this.client, {
     ...options,
-    interactionType: InteractionType.ModalSubmit,
+    interactionType: import_discord7.InteractionType.ModalSubmit,
     message: this
   });
 }
 function awaitModalSubmitComponent(options = {}) {
   return new Promise((resolve, reject) => {
-    const collector = new InteractionCollector(this.client, {
+    const collector = new import_discord7.InteractionCollector(this.client, {
       time: 6e4,
       filter: (i) => i.user.id === this.author.id,
       ...options,
-      interactionType: InteractionType.ModalSubmit,
+      interactionType: import_discord7.InteractionType.ModalSubmit,
       message: this,
       max: 1
     });
@@ -622,7 +747,9 @@ function awaitModalSubmitComponent(options = {}) {
     });
   });
 }
-Object.defineProperties(Message2.prototype, {
+
+// src/extensions/index.ts
+Object.defineProperties(import_discord8.Message.prototype, {
   prefix: { get: prefix, configurable: true },
   isDeveloper: { value: isDeveloper, writable: true, configurable: true },
   awaitMemberResponse: { value: awaitMemberResponse, writable: true, configurable: true },
@@ -630,36 +757,26 @@ Object.defineProperties(Message2.prototype, {
   awaitModalSubmitComponent: { value: awaitModalSubmitComponent, writable: true, configurable: true }
 });
 
-// src/Builders.ts
-import {
-  SlashCommandAttachmentOption,
-  SlashCommandBooleanOption,
-  SlashCommandChannelOption,
-  SlashCommandIntegerOption,
-  SlashCommandMentionableOption,
-  SlashCommandNumberOption,
-  SlashCommandRoleOption,
-  SlashCommandStringOption,
-  SlashCommandUserOption,
-  SlashCommandSubcommandBuilder,
-  SlashCommandSubcommandGroupBuilder
-} from "discord.js";
-export {
-  SlashCommandAttachmentOption as AttachmentOption,
+// src/index.ts
+var import_discord9 = require("discord.js");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AttachmentOption,
   Autocompleter,
-  SlashCommandBooleanOption as BooleanOption,
-  SlashCommandChannelOption as ChannelOption,
+  BooleanOption,
+  ChannelOption,
   ContextCommand,
   FrameworkClient,
-  SlashCommandIntegerOption as IntegerOption,
+  IntegerOption,
   Listener,
-  SlashCommandMentionableOption as MentionableOption,
+  MentionableOption,
   MessageCommand,
-  SlashCommandNumberOption as NumberOption,
-  SlashCommandRoleOption as RoleOption,
+  NumberOption,
+  RoleOption,
   SlashCommand,
-  SlashCommandStringOption as StringOption,
-  SlashCommandSubcommandBuilder as SubcommandBuilder,
-  SlashCommandSubcommandGroupBuilder as SubcommandGroupBuilder,
-  SlashCommandUserOption as UserOption
-};
+  StringOption,
+  SubcommandBuilder,
+  SubcommandGroupBuilder,
+  UserOption
+});
+//# sourceMappingURL=index.cjs.map