@spatulox/simplediscordbot 1.0.30 → 1.0.32

package/dist/index.mjs

@@ -0,0 +1,2554 @@
+// src/bot/Bot.ts
+import { Events, version } from "discord.js";
+
+// src/utils/times/UnitTime.ts
+var UnitTime = class {
+  constructor(val) {
+    this.val = val;
+  }
+  toMilliseconds() {
+    return this.val;
+  }
+  toSeconds() {
+    return this.val / 1e3;
+  }
+  toMinutes() {
+    return this.val / (60 * 1e3);
+  }
+  toHours() {
+    return this.val / (60 * 60 * 1e3);
+  }
+  toDays() {
+    return this.val / (24 * 60 * 60 * 1e3);
+  }
+  toString() {
+    return this.val.toString();
+  }
+  valueOf() {
+    return this.val;
+  }
+  value() {
+    return this.val;
+  }
+};
+var Milliseconds = {
+  MS_100: new UnitTime(100),
+  MS_200: new UnitTime(200),
+  MS_500: new UnitTime(500),
+  MS_800: new UnitTime(800),
+  MS_1000: new UnitTime(1e3)
+};
+var Seconds = {
+  SEC_01: new UnitTime(1e3),
+  SEC_02: new UnitTime(2e3),
+  SEC_03: new UnitTime(3e3),
+  SEC_04: new UnitTime(4e3),
+  SEC_05: new UnitTime(5e3),
+  SEC_06: new UnitTime(6e3),
+  SEC_07: new UnitTime(7e3),
+  SEC_08: new UnitTime(8e3),
+  SEC_09: new UnitTime(9e3),
+  SEC_10: new UnitTime(1e4),
+  SEC_11: new UnitTime(11e3),
+  SEC_12: new UnitTime(12e3),
+  SEC_13: new UnitTime(13e3),
+  SEC_14: new UnitTime(14e3),
+  SEC_15: new UnitTime(15e3),
+  SEC_16: new UnitTime(16e3),
+  SEC_17: new UnitTime(17e3),
+  SEC_18: new UnitTime(18e3),
+  SEC_19: new UnitTime(19e3),
+  SEC_20: new UnitTime(2e4),
+  SEC_21: new UnitTime(21e3),
+  SEC_22: new UnitTime(22e3),
+  SEC_23: new UnitTime(23e3),
+  SEC_24: new UnitTime(24e3),
+  SEC_25: new UnitTime(25e3),
+  SEC_26: new UnitTime(26e3),
+  SEC_27: new UnitTime(27e3),
+  SEC_28: new UnitTime(28e3),
+  SEC_29: new UnitTime(29e3),
+  SEC_30: new UnitTime(3e4),
+  SEC_31: new UnitTime(31e3),
+  SEC_32: new UnitTime(32e3),
+  SEC_33: new UnitTime(33e3),
+  SEC_34: new UnitTime(34e3),
+  SEC_35: new UnitTime(35e3),
+  SEC_36: new UnitTime(36e3),
+  SEC_37: new UnitTime(37e3),
+  SEC_38: new UnitTime(38e3),
+  SEC_39: new UnitTime(39e3),
+  SEC_40: new UnitTime(4e4),
+  SEC_41: new UnitTime(41e3),
+  SEC_42: new UnitTime(42e3),
+  SEC_43: new UnitTime(43e3),
+  SEC_44: new UnitTime(44e3),
+  SEC_45: new UnitTime(45e3),
+  SEC_46: new UnitTime(46e3),
+  SEC_47: new UnitTime(47e3),
+  SEC_48: new UnitTime(48e3),
+  SEC_49: new UnitTime(49e3),
+  SEC_50: new UnitTime(5e4),
+  SEC_51: new UnitTime(51e3),
+  SEC_52: new UnitTime(52e3),
+  SEC_53: new UnitTime(53e3),
+  SEC_54: new UnitTime(54e3),
+  SEC_55: new UnitTime(55e3),
+  SEC_56: new UnitTime(56e3),
+  SEC_57: new UnitTime(57e3),
+  SEC_58: new UnitTime(58e3),
+  SEC_59: new UnitTime(59e3),
+  SEC_60: new UnitTime(6e4)
+};
+var Minutes = {
+  MIN_01: new UnitTime(6e4),
+  MIN_02: new UnitTime(12e4),
+  MIN_03: new UnitTime(18e4),
+  MIN_04: new UnitTime(24e4),
+  MIN_05: new UnitTime(3e5),
+  MIN_06: new UnitTime(36e4),
+  MIN_07: new UnitTime(42e4),
+  MIN_08: new UnitTime(48e4),
+  MIN_09: new UnitTime(54e4),
+  MIN_10: new UnitTime(6e5),
+  MIN_11: new UnitTime(66e4),
+  MIN_12: new UnitTime(72e4),
+  MIN_13: new UnitTime(78e4),
+  MIN_14: new UnitTime(84e4),
+  MIN_15: new UnitTime(9e5),
+  MIN_16: new UnitTime(96e4),
+  MIN_17: new UnitTime(102e4),
+  MIN_18: new UnitTime(108e4),
+  MIN_19: new UnitTime(114e4),
+  MIN_20: new UnitTime(12e5),
+  MIN_21: new UnitTime(126e4),
+  MIN_22: new UnitTime(132e4),
+  MIN_23: new UnitTime(138e4),
+  MIN_24: new UnitTime(144e4),
+  MIN_25: new UnitTime(15e5),
+  MIN_26: new UnitTime(156e4),
+  MIN_27: new UnitTime(162e4),
+  MIN_28: new UnitTime(168e4),
+  MIN_29: new UnitTime(174e4),
+  MIN_30: new UnitTime(18e5),
+  MIN_31: new UnitTime(186e4),
+  MIN_32: new UnitTime(192e4),
+  MIN_33: new UnitTime(198e4),
+  MIN_34: new UnitTime(204e4),
+  MIN_35: new UnitTime(21e5),
+  MIN_36: new UnitTime(216e4),
+  MIN_37: new UnitTime(222e4),
+  MIN_38: new UnitTime(228e4),
+  MIN_39: new UnitTime(234e4),
+  MIN_40: new UnitTime(24e5),
+  MIN_41: new UnitTime(246e4),
+  MIN_42: new UnitTime(252e4),
+  MIN_43: new UnitTime(258e4),
+  MIN_44: new UnitTime(264e4),
+  MIN_45: new UnitTime(27e5),
+  MIN_46: new UnitTime(276e4),
+  MIN_47: new UnitTime(282e4),
+  MIN_48: new UnitTime(288e4),
+  MIN_49: new UnitTime(294e4),
+  MIN_50: new UnitTime(3e6),
+  MIN_51: new UnitTime(306e4),
+  MIN_52: new UnitTime(312e4),
+  MIN_53: new UnitTime(318e4),
+  MIN_54: new UnitTime(324e4),
+  MIN_55: new UnitTime(33e5),
+  MIN_56: new UnitTime(336e4),
+  MIN_57: new UnitTime(342e4),
+  MIN_58: new UnitTime(348e4),
+  MIN_59: new UnitTime(354e4),
+  MIN_60: new UnitTime(36e5)
+};
+var Hours = {
+  HOUR_01: new UnitTime(36e5),
+  HOUR_02: new UnitTime(72e5),
+  HOUR_03: new UnitTime(108e5),
+  HOUR_04: new UnitTime(144e5),
+  HOUR_05: new UnitTime(18e6),
+  HOUR_06: new UnitTime(216e5),
+  HOUR_07: new UnitTime(252e5),
+  HOUR_08: new UnitTime(288e5),
+  HOUR_09: new UnitTime(324e5),
+  HOUR_10: new UnitTime(36e6),
+  HOUR_11: new UnitTime(396e5),
+  HOUR_12: new UnitTime(432e5),
+  HOUR_13: new UnitTime(468e5),
+  HOUR_14: new UnitTime(504e5),
+  HOUR_15: new UnitTime(54e6),
+  HOUR_16: new UnitTime(576e5),
+  HOUR_17: new UnitTime(612e5),
+  HOUR_18: new UnitTime(648e5),
+  HOUR_19: new UnitTime(684e5),
+  HOUR_20: new UnitTime(72e6),
+  HOUR_21: new UnitTime(756e5),
+  HOUR_22: new UnitTime(792e5),
+  HOUR_23: new UnitTime(828e5),
+  HOUR_24: new UnitTime(864e5)
+};
+var Days = {
+  DAY_01: new UnitTime(864e5),
+  DAY_02: new UnitTime(1728e5),
+  DAY_03: new UnitTime(2592e5),
+  DAY_04: new UnitTime(3456e5),
+  DAY_05: new UnitTime(432e6),
+  DAY_06: new UnitTime(5184e5),
+  DAY_07: new UnitTime(6048e5),
+  DAY_08: new UnitTime(6912e5),
+  DAY_09: new UnitTime(7776e5),
+  DAY_10: new UnitTime(864e6)
+};
+var Time = {
+  milisecond: Milliseconds,
+  second: Seconds,
+  minute: Minutes,
+  hour: Hours,
+  day: Days,
+  get DAY() {
+    const h = (/* @__PURE__ */ new Date()).getHours();
+    return h >= 7 && h < 23;
+  },
+  get NIGHT() {
+    return !this.DAY;
+  }
+};
+
+// src/utils/Log.ts
+var Log = class {
+  static getPrefix(level) {
+    const now = /* @__PURE__ */ new Date();
+    const timestamp = `[${now.toLocaleDateString()} - ${now.toLocaleTimeString()}]`;
+    return `${timestamp} [${level.toUpperCase()}]`;
+  }
+  static info(message) {
+    console.info(`${this.getPrefix("info")} ${message}`);
+  }
+  static warn(message) {
+    console.warn(`${this.getPrefix("warn")} ${message}`);
+  }
+  static error(message) {
+    console.error(`${this.getPrefix("error")} ${message}`);
+  }
+  static debug(message) {
+    console.debug(`${this.getPrefix("debug")} ${message}`);
+  }
+  static table(data) {
+    const prefix = this.getPrefix("table");
+    console.info(`${prefix} Table output:`);
+    console.table(data);
+  }
+};
+
+// src/utils/network/InternetChecker.ts
+var InternetChecker = class {
+  /**
+   * Check internet connection towards 1.1.1.1 (Cloudflare DNS)
+   * @param tries Number of attempts (0 = infini)
+   */
+  static async checkConnection(tries = 0) {
+    let attempt = 0;
+    Log.info(
+      tries > 0 ? `HTTP ping ${this.TARGET} (max ${tries} attempts)...` : `HTTP ping ${this.TARGET} (infinite attempts)...`
+    );
+    while (tries === 0 || attempt < tries) {
+      try {
+        const controller = new AbortController();
+        const timeoutId = setTimeout(() => controller.abort(), 5e3);
+        const response = await fetch(this.TARGET, {
+          method: "HEAD",
+          signal: controller.signal,
+          cache: "no-store"
+        });
+        clearTimeout(timeoutId);
+        if (response.ok) {
+          const latency = response.headers.get("x-response-time") || "<1ms";
+          Log.info(`Internet connection OK (${latency})`);
+          return true;
+        }
+      } catch (error) {
+        attempt++;
+        const errorMsg = error.name === "AbortError" ? "Timeout (5s)" : error.message || "Unknown";
+        Log.warn(
+          tries > 0 ? `Ping failed (${errorMsg}) - Attempt ${attempt}/${tries}` : `Ping failed (${errorMsg}) - Retrying in ${this.RETRY_TIME.toSeconds()} seconds...`
+        );
+        try {
+          await new Promise((resolve) => setTimeout(resolve, this.RETRY_TIME.toMilliseconds()));
+        } catch {
+          Log.error("Retry delay failed.");
+        }
+      }
+    }
+    Log.error(`No response from ${this.TARGET} after all attempts.`);
+    return false;
+  }
+};
+InternetChecker.TARGET = "https://1.1.1.1";
+// Cloudflare DNS HTTPS
+InternetChecker.RETRY_TIME = Time.second.SEC_30;
+
+// src/bot/BotLog.ts
+import { EmbedBuilder } from "discord.js";
+var _BotLog = class _BotLog {
+  constructor() {
+  }
+  static config() {
+    return Bot.config.log;
+  }
+  /**
+   * Initialize Discord logging channels and update Bot.log references
+   */
+  static async initDiscordLogging() {
+    if (!Bot.client.isReady()) {
+      Log.warn("Client not ready for Discord logging init");
+      return;
+    }
+    if (Bot.config.log?.logChannelId) {
+      try {
+        const logCh = await Bot.client.channels.fetch(Bot.config.log.logChannelId);
+        if (logCh?.isTextBased()) {
+          _BotLog.logChannel = logCh;
+        } else {
+          Log.warn(`\u274C Log channel ${Bot.config.log.logChannelId} invalid`);
+        }
+      } catch (error) {
+        Log.error(`\u274C Log channel fetch failed: ${error}`);
+      }
+    }
+    if (Bot.config.log?.errorChannelId) {
+      try {
+        const errorCh = await Bot.client.channels.fetch(Bot.config.log.errorChannelId);
+        if (errorCh?.isTextBased()) {
+          _BotLog.errorChannel = errorCh;
+        } else {
+          Log.warn(`\u274C Error channel ${Bot.config.log.errorChannelId} invalid`);
+        }
+      } catch (error) {
+        Log.error(`\u274C Error channel fetch failed: ${error}`);
+      }
+    }
+  }
+  /**
+   * Send content to specific Discord channel
+   */
+  static async _sendToChannel(channel, content, prefix = "info") {
+    if (!channel) return;
+    let msg;
+    try {
+      if (content instanceof EmbedBuilder) {
+        msg = await channel.send({ embeds: [content] });
+      } else {
+        const timestamp = `\`${(/* @__PURE__ */ new Date()).toISOString()}\``;
+        msg = await channel.send(`${prefix.toUpperCase()} ${timestamp} ${content}`);
+      }
+    } catch (error) {
+      Log.error(`Failed to send to Discord channel: ${error}`);
+    }
+    return msg;
+  }
+  /**
+   * Send INFO log - TEXT or EMBED ! Respecte config.log.info
+   */
+  static async info(content) {
+    const logConfig = Bot.config.log;
+    if (!logConfig || logConfig.info.console) {
+      if (!(content instanceof EmbedBuilder)) {
+        Log.info(content);
+      }
+    }
+    if (logConfig?.info.discord && this.logChannel) {
+      return await this._sendToChannel(this.logChannel, content, "info");
+    }
+  }
+  /**
+   * Send ERROR log - TEXT or EMBED ! Respecte config.log.error
+   */
+  static async error(content) {
+    const logConfig = Bot.config.log;
+    if (!logConfig || logConfig.error.console) {
+      if (!(content instanceof EmbedBuilder)) {
+        Log.error(content);
+      }
+    }
+    if (logConfig?.error.discord && this.errorChannel) {
+      return await this._sendToChannel(this.errorChannel, content, "error");
+    }
+  }
+  /**
+   * Send WARNING log - TEXT or EMBED ! Respecte config.log.warn
+   */
+  static async warn(content) {
+    const logConfig = Bot.config.log;
+    if (!logConfig || logConfig?.warn.console) {
+      if (!(content instanceof EmbedBuilder)) {
+        Log.warn(content);
+      }
+    }
+    if (logConfig?.warn.discord && this.logChannel) {
+      return await this._sendToChannel(this.logChannel, content, "warn");
+    }
+  }
+  /**
+   * Send DEBUG log - TEXT or EMBED ! Respecte config.log.debug
+   */
+  static async debug(content) {
+    const logConfig = Bot.config.log;
+    if (!logConfig || logConfig?.debug.console) {
+      if (!(content instanceof EmbedBuilder)) {
+        Log.debug(content);
+      }
+    }
+    if (logConfig?.debug.discord && this.logChannel) {
+      return await this._sendToChannel(this.logChannel, content, "debug");
+    }
+  }
+};
+_BotLog.logChannel = null;
+_BotLog.errorChannel = null;
+var BotLog = _BotLog;
+
+// src/manager/messages/EmbedManager.ts
+import {
+  EmbedBuilder as EmbedBuilder2,
+  MessageFlags
+} from "discord.js";
+var EmbedColor = /* @__PURE__ */ ((EmbedColor3) => {
+  EmbedColor3[EmbedColor3["error"] = 8912917] = "error";
+  EmbedColor3[EmbedColor3["success"] = 65280] = "success";
+  EmbedColor3[EmbedColor3["black"] = 0] = "black";
+  EmbedColor3[EmbedColor3["white"] = 16777215] = "white";
+  EmbedColor3[EmbedColor3["red"] = 16711680] = "red";
+  EmbedColor3[EmbedColor3["green"] = 65280] = "green";
+  EmbedColor3[EmbedColor3["blue"] = 255] = "blue";
+  EmbedColor3[EmbedColor3["yellow"] = 16776960] = "yellow";
+  EmbedColor3[EmbedColor3["cyan"] = 65535] = "cyan";
+  EmbedColor3[EmbedColor3["magenta"] = 16711935] = "magenta";
+  EmbedColor3[EmbedColor3["gray"] = 8421504] = "gray";
+  EmbedColor3[EmbedColor3["lightgray"] = 13882323] = "lightgray";
+  EmbedColor3[EmbedColor3["darkgray"] = 11119017] = "darkgray";
+  EmbedColor3[EmbedColor3["orange"] = 16753920] = "orange";
+  EmbedColor3[EmbedColor3["purple"] = 8388736] = "purple";
+  EmbedColor3[EmbedColor3["pink"] = 16761035] = "pink";
+  EmbedColor3[EmbedColor3["brown"] = 10824234] = "brown";
+  EmbedColor3[EmbedColor3["lime"] = 65280] = "lime";
+  EmbedColor3[EmbedColor3["navy"] = 128] = "navy";
+  EmbedColor3[EmbedColor3["teal"] = 32896] = "teal";
+  EmbedColor3[EmbedColor3["olive"] = 8421376] = "olive";
+  EmbedColor3[EmbedColor3["gold"] = 16766720] = "gold";
+  EmbedColor3[EmbedColor3["silver"] = 12632256] = "silver";
+  EmbedColor3[EmbedColor3["coral"] = 16744272] = "coral";
+  EmbedColor3[EmbedColor3["salmon"] = 16416882] = "salmon";
+  EmbedColor3[EmbedColor3["khaki"] = 15787660] = "khaki";
+  EmbedColor3[EmbedColor3["plum"] = 14524637] = "plum";
+  EmbedColor3[EmbedColor3["lavender"] = 15132410] = "lavender";
+  EmbedColor3[EmbedColor3["beige"] = 16119260] = "beige";
+  EmbedColor3[EmbedColor3["mint"] = 10026904] = "mint";
+  EmbedColor3[EmbedColor3["peach"] = 16767673] = "peach";
+  EmbedColor3[EmbedColor3["chocolate"] = 13789470] = "chocolate";
+  EmbedColor3[EmbedColor3["crimson"] = 14423100] = "crimson";
+  EmbedColor3[EmbedColor3["youtube"] = 16718362] = "youtube";
+  EmbedColor3[EmbedColor3["default"] = 6064856] = "default";
+  EmbedColor3[EmbedColor3["minecraft"] = 25600] = "minecraft";
+  return EmbedColor3;
+})(EmbedColor || {});
+var EmbedManager = class {
+  static get BOT_ICON() {
+    return Bot.config.botIconUrl || "";
+  }
+  static get DEFAULT_COLOR() {
+    return Bot.config.defaultEmbedColor || 6064856 /* default */;
+  }
+  /**
+   * Creates base embed - SAME SIMPLE API !
+   */
+  static create(color = null) {
+    const embed = new EmbedBuilder2().setColor(color ?? this.DEFAULT_COLOR).setTimestamp(/* @__PURE__ */ new Date());
+    if (this.BOT_ICON && Bot.config.botName) {
+      embed.setFooter({
+        text: Bot.config.botName,
+        iconURL: this.BOT_ICON
+      });
+    }
+    return embed;
+  }
+  /**
+   * Creates simple embed with just description
+   */
+  static simple(description, color = null) {
+    return this.create(color).setTitle("").setDescription(description).setTimestamp(null);
+  }
+  /**
+   * Creates error embed
+   */
+  static error(description) {
+    return this.create(8912917 /* error */).setTitle("Something went Wrong").setDescription(description);
+  }
+  /**
+   * Creates success embed
+   */
+  static success(description) {
+    return this.create(25600 /* minecraft */).setTitle("Success").setDescription(description);
+  }
+  /**
+   * Creates success embed
+   */
+  static description(description) {
+    return this.create(25600 /* minecraft */).setDescription(description);
+  }
+  /**
+   * Creates debug embed
+   */
+  static debug(description) {
+    return this.create(65280 /* green */).setTitle("Debug").setDescription(description);
+  }
+  /**
+   * Defer ephemeral reply
+   */
+  static deferEphemeral() {
+    return { flags: MessageFlags.Ephemeral };
+  }
+  /**
+   * Quick field adder
+   */
+  static field(embed, name, value, inline = false) {
+    return embed.addFields({ name, value, inline });
+  }
+  static fields(embed, fields) {
+    fields.forEach((f) => {
+      embed.addFields({ name: f.name, value: f.value, inline: f.inline ?? false });
+    });
+    return embed;
+  }
+  /**
+   * Fluent API shortcuts
+   */
+  static title(embed, title) {
+    return embed.setTitle(title);
+  }
+  static desc(embed, description) {
+    return embed.setDescription(description);
+  }
+  static thumb(embed, url) {
+    return embed.setThumbnail(url);
+  }
+  static image(embed, url) {
+    return embed.setImage(url);
+  }
+  static footer(embed, text) {
+    return embed.setFooter({ text, iconURL: this.BOT_ICON });
+  }
+  /**
+   * Transform embed into objet for interaction.reply()
+   */
+  static toInteraction(embed, ephemeral = false) {
+    return {
+      embeds: [embed],
+      flags: ephemeral ? [MessageFlags.Ephemeral] : void 0
+    };
+  }
+  /**
+   * Transform embed into objet to send a message
+   */
+  static toMessage(embed) {
+    return {
+      embeds: [embed]
+    };
+  }
+};
+
+// src/bot/BotMessage.ts
+import {
+  User,
+  GuildMember
+} from "discord.js";
+
+// src/manager/builder/SendableComponentBuilder.ts
+import {
+  ActionRowBuilder,
+  EmbedBuilder as EmbedBuilder3,
+  MessageFlags as MessageFlags2
+} from "discord.js";
+var SendableComponentBuilder = class {
+  static isSendableComponent(thing) {
+    return thing instanceof EmbedBuilder3 || thing instanceof ActionRowBuilder;
+  }
+  static build(base, content, components) {
+    if (content) {
+      base.content = content;
+    }
+    const comps = Array.isArray(components) ? components : [components].filter(Boolean);
+    for (const comp of comps) {
+      if (comp instanceof EmbedBuilder3) {
+        base.embeds = base.embeds || [];
+        base.embeds.push(comp);
+      }
+      if (comp instanceof ActionRowBuilder) {
+        base.components = base.components || [];
+        base.components.push(comp);
+      }
+    }
+    return base;
+  }
+  static buildInteraction(contentOrComponent, component, ephemeral = false) {
+    let base = {};
+    if (typeof contentOrComponent === "string" && !component) {
+      base = this.build(base, contentOrComponent);
+    }
+    if (typeof contentOrComponent !== "string" && !component) {
+      base = this.build(base, null, contentOrComponent);
+    }
+    if (contentOrComponent && typeof contentOrComponent === "string" && component) {
+      base = this.build(base, contentOrComponent, component);
+    }
+    if (ephemeral) {
+      base.flags = [MessageFlags2.Ephemeral];
+    }
+    return base;
+  }
+  static buildMessage(contentOrComponent, component) {
+    let base = {};
+    if (typeof contentOrComponent === "string" && !component) {
+      return this.build(base, contentOrComponent);
+    }
+    if (typeof contentOrComponent !== "string" && !component) {
+      return this.build(base, null, contentOrComponent);
+    }
+    if (typeof contentOrComponent == "string" && component) {
+      return this.build(base, contentOrComponent, component);
+    }
+    throw new Error("At least content or component need to be defined to build a message");
+  }
+};
+
+// src/bot/BotMessage.ts
+var BotMessage = class {
+  static async send(channel, content, component) {
+    try {
+      if (!channel) {
+        Log.warn("Cannot send message: invalid channel");
+        return null;
+      }
+      if (typeof channel === "string") {
+        const fetchedChannel = Bot.client.channels.cache.get(channel);
+        if (!fetchedChannel?.isTextBased()) {
+          Log.warn(`Invalid channel ID: ${channel}`);
+          return null;
+        }
+        channel = fetchedChannel;
+      }
+      let messageCreate;
+      if (typeof content !== "string" && !component) {
+        if (SendableComponentBuilder.isSendableComponent(content)) {
+          messageCreate = SendableComponentBuilder.buildMessage(content);
+        } else {
+          messageCreate = content;
+        }
+      } else {
+        content = content;
+        if (content && component) {
+          messageCreate = SendableComponentBuilder.buildMessage(content, component);
+        } else if (content) {
+          messageCreate = SendableComponentBuilder.buildMessage(content);
+        } else if (component) {
+          messageCreate = SendableComponentBuilder.buildMessage(component);
+        } else {
+          throw new Error("content and component cannot be null at the same time");
+        }
+      }
+      try {
+        return await channel.send(messageCreate);
+      } catch (e) {
+        throw e;
+      }
+    } catch (e) {
+      Log.error(`Failed to send message : ${e}`);
+      return null;
+    }
+  }
+  static async sendDM(user, content, component) {
+    try {
+      let targetUser;
+      if (user instanceof User || user instanceof GuildMember) {
+        targetUser = user instanceof GuildMember ? user.user : user;
+      } else {
+        targetUser = await Bot.client.users.fetch(user);
+      }
+      let messageCreate;
+      if (content && component) {
+        messageCreate = SendableComponentBuilder.buildMessage(content, component);
+      } else if (content) {
+        messageCreate = SendableComponentBuilder.buildMessage(content);
+      } else if (component) {
+        messageCreate = SendableComponentBuilder.buildMessage(component);
+      } else {
+        throw new Error("content and component cannot be null at the same time");
+      }
+      return await targetUser.send(messageCreate);
+    } catch (error) {
+      Log.error(`Failed to send message to ${user}: ${error}`);
+      return null;
+    }
+  }
+  /**
+   * Quick success message
+   */
+  static success(channel, message) {
+    const embed = EmbedManager.success(message);
+    if (channel instanceof User || channel instanceof GuildMember) {
+      return this.sendDM(channel, message, embed);
+    }
+    return this.send(channel, message, embed);
+  }
+  /**
+   * Quick error message
+   */
+  static error(channel, message) {
+    const embed = EmbedManager.error(message);
+    if (channel instanceof User || channel instanceof GuildMember) {
+      return this.sendDM(channel, message, embed);
+    }
+    return this.send(channel, message, embed);
+  }
+};
+
+// src/utils/DiscordRegex.ts
+var _DiscordRegex = class _DiscordRegex {
+  /**
+   * Validate Discord ID Discord (18)
+   */
+  static isDiscordId(id) {
+    return this.USER_ID.test(id) || this.GUILD_ID.test(id) || this.CHANNEL_ID.test(id);
+  }
+  /**
+   * Validate a bot ID (19)
+   */
+  static isBotMention(mention) {
+    return this.BOT_REGEX.test(mention);
+  }
+  /**
+   * Validate a User ping
+   */
+  static isUserMention(mention) {
+    return this.USER_REGEX.test(mention);
+  }
+  /**
+   * Validate a Discord username
+   */
+  static isUsername(username) {
+    return this.USERNAME.test(username);
+  }
+  /**
+   * Type guard for Discord ID
+   */
+  static isDiscordIdType(id) {
+    return this.isDiscordId(id);
+  }
+  /**
+   * Any Discord URL
+   */
+  static isDiscordUrl(url) {
+    return this.URL_REGEX.test(url) || this.INVITE.test(url);
+  }
+  /**
+   * Any discord mention
+   */
+  static isAnyMention(text) {
+    return this.DISCORD_MENTION_REGEX.test(text);
+  }
+  /**
+   * List all regex
+   */
+  static listAll() {
+    return {
+      SPACE: this.SPACE,
+      URL_REGEX: this.URL_REGEX,
+      USER_REGEX: this.USER_REGEX,
+      BOT_REGEX: this.BOT_REGEX,
+      CHANNEL_REGEX: this.CHANNEL_REGEX,
+      ROLE_REGEX: this.ROLE_REGEX,
+      DISCORD_PING_REGEX: this.DISCORD_PING_REGEX,
+      DISCORD_MENTION_REGEX: this.DISCORD_MENTION_REGEX,
+      USER_ID: this.USER_ID,
+      CHANNEL_ID: this.CHANNEL_ID,
+      GUILD_ID: this.GUILD_ID,
+      USERNAME: this.USERNAME,
+      USERNAME_DISCRIM: this.USERNAME_DISCRIM,
+      CHANNEL_MENTION: this.CHANNEL_MENTION,
+      USER_MENTION: this.USER_MENTION,
+      ROLE_MENTION: this.ROLE_MENTION,
+      INVITE: this.INVITE,
+      EMOJI: this.EMOJI
+    };
+  }
+};
+// Caractères spéciaux
+_DiscordRegex.SPACE = "\u200B";
+// URLs basiques
+_DiscordRegex.URL_REGEX = /(https?:\/\/[^s]+)/;
+/* DISCORD REGEX */
+_DiscordRegex.USER_REGEX = /<@\d{18}>/;
+_DiscordRegex.BOT_REGEX = /<@\d{19}>/;
+_DiscordRegex.CHANNEL_REGEX = /(<#\d{19}>)|(<id:(browse|customize|guide)>)/;
+_DiscordRegex.ROLE_REGEX = /<@&\d{19}>/;
+/**
+ * Mention a User
+ * Mention a Role
+ */
+_DiscordRegex.DISCORD_PING_REGEX = new RegExp(
+  `(${_DiscordRegex.USER_REGEX.source})|(${_DiscordRegex.BOT_REGEX.source})|(${_DiscordRegex.ROLE_REGEX.source})`
+);
+/**
+ * Mention a User
+ * Mention a Role
+ * Mention a Channel
+ */
+_DiscordRegex.DISCORD_MENTION_REGEX = new RegExp(
+  `(${_DiscordRegex.DISCORD_PING_REGEX.source})|(${_DiscordRegex.CHANNEL_REGEX.source})`
+);
+// ID Discord (user, channel guild)
+_DiscordRegex.USER_ID = /^[0-9]{18}$/;
+_DiscordRegex.CHANNEL_ID = /^[0-9]{18}$/;
+_DiscordRegex.GUILD_ID = /^[0-9]{19}$/;
+_DiscordRegex.BOT_ID = /^[0-9]{19}$/;
+// Username Discord (2-32 caractères alphanumériques + _ .)
+_DiscordRegex.USERNAME = /^[a-zA-Z0-9_]{2,32}$/;
+// Username + discrim (ancien format)
+_DiscordRegex.USERNAME_DISCRIM = /^[a-zA-Z0-9_]{2,32}#\d{4}$/;
+// Channel mention <#123456789012345678>
+_DiscordRegex.CHANNEL_MENTION = /^<#([0-9]{18})>$/;
+// User mention <@123456789012345678> ou <@!123456789012345678>
+_DiscordRegex.USER_MENTION = /^<@!?([0-9]{18})>$/;
+// Role mention <@&123456789012345678>
+_DiscordRegex.ROLE_MENTION = /^<@&([0-9]{18})>$/;
+// URL Invite Discord
+_DiscordRegex.INVITE = /^discord(?:app\.com\/invite|gg)\/[a-zA-Z0-9]+$/;
+// Emoji Discord (custom or unicode)
+_DiscordRegex.EMOJI = /^<a?:[a-zA-Z0-9_]{2,32}:[0-9]{18}>$|^[\u{1F300}-\u{1F5FF}\u{1F600}-\u{1F64F}\u{1F680}-\u{1F6FF}\u{2600}-\u{26FF}\u{2700}-\u{27BF}]+$/u;
+var DiscordRegex = _DiscordRegex;
+
+// src/bot/BotEnv.ts
+var BotEnv = {
+  get token() {
+    const token = process.env.DISCORD_BOT_TOKEN;
+    if (!token) throw new Error("Missing environment variable : DISCORD_BOT_TOKEN");
+    return token;
+  },
+  get dev() {
+    return process.env.DEV === "true";
+  },
+  get clientId() {
+    const token = process.env.DISCORD_BOT_CLIENTID;
+    if (!token) throw new Error("Missing environment variable : DISCORD_BOT_CLIENTID");
+    if (!DiscordRegex.BOT_ID.test(token)) {
+      throw new Error("Invalid token format");
+    }
+    return token;
+  }
+};
+
+// src/bot/BotInteraction.ts
+var BotInteraction = class {
+  /**
+   * InteractionReplyOptions && InteractionUpdateOptions
+   * The two have "content", "embeds" & "flags" field, so an internal cast is ok, unless discord/discordjs deprecate it
+   */
+  static buildReplyOptions(content, component, ephemeral) {
+    return this._buildOptions(content, component, ephemeral);
+  }
+  static buildUpdateOptions(content, component) {
+    return this._buildOptions(content, component, false);
+  }
+  static _buildOptions(content, component, ephemeral) {
+    return SendableComponentBuilder.buildInteraction(content, component, ephemeral);
+  }
+  static async send(interaction, content, component = false, ephemeral = false) {
+    if (!interaction.isRepliable()) return false;
+    const options = this.buildReplyOptions(
+      typeof content === "string" ? content : "",
+      typeof content === "string" ? component : content,
+      typeof content === "string" ? ephemeral : component
+    );
+    if (!interaction.deferred && !interaction.replied) {
+      return await interaction.reply(options);
+    } else {
+      return await interaction.followUp(options);
+    }
+  }
+  static async reply(interaction, content, component = false, ephemeral = false) {
+    if (!interaction.isRepliable()) return false;
+    const options = this.buildReplyOptions(
+      typeof content === "string" ? content : "",
+      typeof content === "string" ? component : content,
+      typeof content === "string" ? ephemeral : component
+    );
+    return interaction.reply(options);
+  }
+  static async followUp(interaction, content, component = false, ephemeral = false) {
+    if (!interaction.isRepliable()) return false;
+    const options = this.buildReplyOptions(
+      typeof content === "string" ? content : "",
+      typeof content === "string" ? component : content,
+      typeof content === "string" ? ephemeral : component
+    );
+    return interaction.followUp(options);
+  }
+  static async defer(interaction) {
+    if (!interaction.isRepliable()) return;
+    if (interaction.isChatInputCommand() || interaction.isContextMenuCommand()) {
+      if (!interaction.deferred && !interaction.replied) {
+        await interaction.deferReply();
+      }
+      return;
+    }
+    if (interaction.isButton() || interaction.isAnySelectMenu() || interaction.isModalSubmit()) {
+      if (!interaction.deferred && !interaction.replied) {
+        await interaction.deferUpdate();
+      }
+    }
+  }
+  static async update(interaction, content, component) {
+    if (!interaction.isRepliable()) return false;
+    const options = this.buildUpdateOptions(
+      typeof content === "string" ? content : "",
+      typeof content === "string" ? component : content
+    );
+    if (interaction.isMessageComponent()) {
+      return await interaction.update(options);
+    }
+    if (interaction.deferred || interaction.replied) {
+      return await interaction.editReply(options);
+    }
+    return false;
+  }
+};
+
+// src/bot/Bot.ts
+var _Bot = class _Bot {
+  get config() {
+    return _Bot._config;
+  }
+  get client() {
+    return _Bot._client;
+  }
+  static get client() {
+    return _Bot._client;
+  }
+  static get config() {
+    return _Bot._config;
+  }
+  constructor(client, config) {
+    Log.info("----------------------------------------------------");
+    Log.info("Starting Bot");
+    _Bot.criticConfig = { dev: BotEnv.dev, token: BotEnv.token };
+    _Bot._config = { ...config, clientId: BotEnv.clientId };
+    _Bot._client = client;
+    (async () => {
+      Log.info(`Using discord.js version: ${version}`);
+      Log.info("Trying to connect to Discord Servers");
+      await InternetChecker.checkConnection(3);
+      await this.login();
+    })();
+  }
+  async login(maxTries = 3) {
+    let success = false;
+    let tries = 0;
+    while (!success && tries < maxTries) {
+      try {
+        await _Bot._client.login(_Bot.criticConfig.token);
+        success = true;
+        _Bot._client.on(Events.ClientReady, async () => {
+          if (_Bot._client.user) {
+            await _Bot.log.initDiscordLogging();
+            Log.info(`Connected on ${_Bot._client.guilds.cache.size} servers as ${_Bot._client.user.tag}`);
+            _Bot.log.info(EmbedManager.description("Bot Started"));
+          }
+        });
+      } catch (error) {
+        Log.error(`Connection error : ${error}. Trying again...`);
+        tries++;
+        await new Promise(
+          (resolve) => setTimeout(resolve, Time.second.SEC_03.toMilliseconds())
+        );
+      }
+    }
+    if (!success) {
+      Log.error("Impossible to connect the bot after 3 attempts");
+      return false;
+    }
+    return true;
+  }
+  static setActivity(message, type) {
+    if (_Bot._client.user) {
+      _Bot._client.user.setActivity({ name: message, type });
+      Log.info(`Activity defined : ${message}`);
+    }
+  }
+  static setRandomActivity(randomActivity, intervalMs = null) {
+    if (randomActivity.length == 0) {
+      Log.error("Bot.randomActivity = [{}] is empty");
+      return;
+    }
+    const pickRandom = () => {
+      const random = randomActivity[Math.floor(Math.random() * randomActivity.length)];
+      _Bot.setActivity(random.message, random.type);
+      return random;
+    };
+    if (intervalMs === null) {
+      pickRandom();
+      Log.info(`Activity set ONCE`);
+      return;
+    }
+    pickRandom();
+    setInterval(async () => {
+      pickRandom();
+    }, intervalMs);
+    Log.info(`Random activity started (every ${Math.round(intervalMs / 6e4)}min)`);
+    return;
+  }
+};
+// Static ref
+_Bot.log = BotLog;
+_Bot.message = BotMessage;
+_Bot.interaction = BotInteraction;
+var Bot = _Bot;
+
+// src/manager/FileManager.ts
+import path from "path";
+import fs from "fs/promises";
+var FileManager = class {
+  /**
+   * Reads a JSON file synchronously.
+   * @param filePath Full path to the JSON file
+   * @returns Parsed JSON object or 'Error' string on failure
+   */
+  static async readJsonFile(filePath) {
+    try {
+      const data = await fs.readFile(filePath, "utf8");
+      return JSON.parse(data);
+    } catch (error) {
+      Log.error(`Failed to read JSON file ${filePath}: ${error}`);
+      return false;
+    }
+  }
+  /**
+   * Lists all directories in a given path.
+   * @param directoryPath Path to scan for directories
+   * @returns Array of directory names or false on error
+   */
+  static async listDirectories(directoryPath) {
+    try {
+      const files = await fs.readdir(directoryPath, { withFileTypes: true });
+      const directories = files.filter((file) => file.isDirectory()).map((dir) => dir.name);
+      return directories;
+    } catch (error) {
+      Log.error(`Failed to read directory ${directoryPath}: ${error}`);
+      return false;
+    }
+  }
+  /**
+   * Lists all JSON files in a directory.
+   * @param directoryPath Path to scan for JSON files
+   * @returns Array of JSON filenames or false on error
+   */
+  static async listJsonFiles(directoryPath) {
+    try {
+      const files = await fs.readdir(directoryPath);
+      return files.filter((file) => path.extname(file) === ".json");
+    } catch (error) {
+      Log.error(`Failed to read directory ${directoryPath}: ${error}`);
+      return false;
+    }
+  }
+  /**
+   * Lists files with specific extension in a directory.
+   * @param directoryPath Path to scan
+   * @param extension File extension (with or without dot)
+   * @returns Array of matching filenames or 'Error' string on failure
+   */
+  static async listFiles(directoryPath, extension) {
+    if (typeof directoryPath !== "string" || typeof extension !== "string") {
+      Log.error("Directory path and extension must be strings");
+      return false;
+    }
+    try {
+      let ext = extension;
+      if (ext.startsWith(".")) {
+        ext = ext.slice(1);
+      }
+      const files = await fs.readdir(directoryPath);
+      return files.filter((file) => path.extname(file) === `.${ext}`);
+    } catch (error) {
+      Log.error(`Failed to read directory ${directoryPath}: ${error}`);
+      return false;
+    }
+  }
+  /**
+   * Creates directory structure and writes JSON data to file.
+   * @param directoryPath Full directory path (creates if missing)
+   * @param filename Filename without extension
+   * @param data Data to write (JSON serializable)
+   * @param sendErrorToErrorChannel Send error to the error channel
+   * @returns true on success, false on failure
+   */
+  static async writeJsonFile(directoryPath, filename, data, sendErrorToErrorChannel = true) {
+    if (Array.isArray(data) && data.length === 1 && data[0] === "Error") {
+      Log.error(`Cannot save data for ${filename}: data contains 'Error'`);
+      return false;
+    }
+    try {
+      const directories = directoryPath.split(path.sep).filter(Boolean);
+      let currentPath = "";
+      for (const dir of directories) {
+        currentPath = path.join(currentPath, dir);
+        try {
+          await fs.access(currentPath);
+        } catch {
+          await fs.mkdir(currentPath, { recursive: true });
+        }
+      }
+      if (!filename || filename.trim() === "") {
+        Log.error("Cannot write JSON file: empty filename");
+        return false;
+      }
+      const cleanFilename = filename.replace(/\.json$/i, "");
+      const filePath = path.join(directoryPath, `${cleanFilename}.json`);
+      const jsonContent = JSON.stringify(data, null, 2);
+      await fs.writeFile(filePath, jsonContent);
+      Log.info(`Successfully wrote data to ${filePath}`);
+      return true;
+    } catch (error) {
+      const cleanFilename = filename.replace(/\.json$/i, "") || "unknown";
+      if (sendErrorToErrorChannel) {
+        await Bot.log.info(EmbedManager.error(`Failed to write file ${directoryPath}/${cleanFilename}.json: ${error}`));
+      } else {
+        Log.error(`Failed to write file ${directoryPath}/${cleanFilename}.json: ${error}`);
+      }
+      return false;
+    }
+  }
+};
+
+// src/manager/messages/WebhookManager.ts
+import {
+  ThreadChannel as ThreadChannel2
+} from "discord.js";
+var WebhookManager = class {
+  constructor(channel, name = Bot.config.botName || "", avatarURL) {
+    this.channel = channel;
+    this.name = name;
+    this.avatarURL = avatarURL;
+    this.webhook = null;
+  }
+  get textChannel() {
+    return this.channel instanceof ThreadChannel2 ? this.channel.parent : this.channel;
+  }
+  /**
+   * Get or create webhook (lazy initialization)
+   */
+  async getWebhook() {
+    if (this.webhook) return this.webhook;
+    try {
+      const webhooks = await this.textChannel.fetchWebhooks();
+      this.webhook = webhooks.find((h) => h.name === this.name) ?? await this.textChannel.createWebhook({
+        name: this.name,
+        avatar: this.avatarURL,
+        reason: "Auto-created by WebhookManager"
+      });
+      Log.info(`Webhook ${this.webhook.id} ready for ${this.textChannel.id}`);
+      return this.webhook;
+    } catch (error) {
+      Log.error(`Failed to setup webhook: ${error}`);
+      throw error;
+    }
+  }
+  async send(content) {
+    const webhook = await this.getWebhook();
+    const options = {};
+    if (SendableComponentBuilder.isSendableComponent(content)) {
+      const t = SendableComponentBuilder.buildMessage(content);
+      options.embeds = t.embeds;
+      options.components = t.components;
+    } else if (typeof content == "string") {
+      options.content = content;
+    } else if (typeof content === "object") {
+      Object.assign(options, content);
+    } else {
+      options.content = content;
+    }
+    if (this.channel instanceof ThreadChannel2) {
+      options.threadId = this.channel.id;
+    }
+    try {
+      const message = await webhook.send(options);
+      Log.info(`Webhook sent to ${this.channel.id}: ${content}`);
+      return message;
+    } catch (error) {
+      Log.error(`Webhook send failed ${this.channel.id}: ${error}`);
+      return null;
+    }
+  }
+  /**
+   * Quick success embed
+   */
+  async success(message) {
+    return await this.send(EmbedManager.success(message));
+  }
+  /**
+   * Quick error embed
+   */
+  async error(message) {
+    return await this.send(EmbedManager.error(message));
+  }
+  /**
+   * Delete webhook
+   */
+  async delete(reason) {
+    if (!this.webhook) return;
+    try {
+      await this.webhook.delete(reason ?? "Deleted by WebhookManager");
+      Log.info(`Webhook ${this.webhook.id} deleted`);
+    } catch (error) {
+      if (error.message.includes("Unknown Webhook")) {
+        Log.warn("Webhook already deleted");
+      } else {
+        Log.error(`Failed to delete webhook: ${error}`);
+      }
+    } finally {
+      this.webhook = null;
+    }
+  }
+};
+
+// src/manager/guild/ChannelManager/GuildTextChannelManager.ts
+import { TextChannel as TextChannel4, ChannelType } from "discord.js";
+
+// src/manager/guild/ChannelManager/GuildMessageManager.ts
+var GuildMessageManager = class {
+  /**
+   * Impl
+   */
+  static async send(channelId, content_or_component_or_options) {
+    try {
+      const channel = await GuildTextChannelManager.find(channelId);
+      if (!channel) {
+        Log.error(`Channel ${channelId} not found in guild`);
+        return null;
+      }
+      let payload;
+      if (typeof content_or_component_or_options === "string") {
+        payload = SendableComponentBuilder.buildMessage(content_or_component_or_options);
+      } else if (SendableComponentBuilder.isSendableComponent(content_or_component_or_options) || Array.isArray(content_or_component_or_options)) {
+        payload = SendableComponentBuilder.buildMessage(content_or_component_or_options);
+      } else {
+        payload = content_or_component_or_options;
+      }
+      return await channel.send(payload);
+    } catch (error) {
+      Log.error(`Failed to send message to ${channelId}: ${error}`);
+      throw error;
+    }
+  }
+  /**
+   * Delete message
+   */
+  static async delete(channelId, messageId) {
+    try {
+      const channel = await GuildTextChannelManager.find(channelId);
+      if (!channel) {
+        Log.error(`Channel ${channelId} not found`);
+        return false;
+      }
+      const message = await channel.messages.fetch(messageId);
+      await message.delete();
+      Log.info(`Deleted message ${messageId} from ${channelId}`);
+      return true;
+    } catch (error) {
+      Log.error(`Failed to delete message ${messageId} from ${channelId}: ${error}`);
+      return false;
+    }
+  }
+  /**
+   * Fetch messages (last X messages, default 10)
+   */
+  static async fetch(channelId, limit = 10) {
+    try {
+      const channel = await GuildTextChannelManager.find(channelId);
+      if (!channel) {
+        Log.error(`Channel ${channelId} not found`);
+        return [];
+      }
+      const messages = await channel.messages.fetch({ limit });
+      Log.info(`Fetched ${messages.size} messages from ${channelId}`);
+      return Array.from(messages.values());
+    } catch (error) {
+      Log.error(`Failed to fetch messages from ${channelId}: ${error}`);
+      return [];
+    }
+  }
+  /**
+   * Fetch single message
+   */
+  static async fetchOne(channelId, messageId) {
+    try {
+      const channel = await GuildTextChannelManager.find(channelId);
+      if (!channel) {
+        Log.error(`Channel ${channelId} not found`);
+        return null;
+      }
+      const message = await channel.messages.fetch(messageId);
+      return message;
+    } catch (error) {
+      Log.error(`Failed to fetch message ${messageId} from ${channelId}: ${error}`);
+      return null;
+    }
+  }
+};
+
+// src/manager/guild/ChannelManager/GuildChannelManager.ts
+var _GuildChannelManager = class _GuildChannelManager {
+  /**
+   * Recherche un channel par ID dans une guild spécifique
+   */
+  static async findInGuild(guildId, channelId) {
+    try {
+      const guild = Bot.client.guilds.cache.get(guildId);
+      if (!guild) {
+        Log.warn(`Guild ${guildId} not found`);
+        return null;
+      }
+      const channel = await guild.channels.fetch(channelId);
+      return channel ?? null;
+    } catch (error) {
+      Log.error(`Failed to find channel ${channelId} in guild ${guildId}: ${error}`);
+      return null;
+    }
+  }
+  static async find(channelId) {
+    for (const guild of Bot.client.guilds.cache.values()) {
+      try {
+        const channel = await guild.channels.fetch(channelId);
+        if (channel) return channel;
+      } catch {
+      }
+    }
+    Log.warn(`Channel ${channelId} not found in any guild`);
+    return null;
+  }
+  static findAll(guildId) {
+    const guild = Bot.client.guilds.cache.get(guildId);
+    if (!guild) {
+      Log.warn(`Guild ${guildId} not found`);
+      return [];
+    }
+    return Array.from(guild.channels.cache.values());
+  }
+  /**
+   * Recherche channels par nom (insensible à la casse)
+   */
+  static findByName(guildId, name) {
+    const guild = Bot.client.guilds.cache.get(guildId);
+    if (!guild) {
+      Log.warn(`Guild ${guildId} not found`);
+      return [];
+    }
+    return Array.from(guild.channels.cache.values()).filter(
+      (channel) => channel.name.toLowerCase().includes(name.toLowerCase())
+    );
+  }
+  static async _create(guildId, options) {
+    try {
+      const guild = Bot.client.guilds.cache.get(guildId);
+      if (!guild) {
+        throw new Error(`Guild ${guildId} not found`);
+      }
+      const channel = await guild.channels.create(options);
+      Log.info(`Created channel ${channel.name} (${channel.id}) in guild ${guildId}`);
+      return channel;
+    } catch (error) {
+      Log.error(`Failed to create channel in guild ${guildId}: ${error}`);
+      throw error;
+    }
+  }
+  static async delete(channelId) {
+    try {
+      const channel = await _GuildChannelManager.find(channelId);
+      if (!channel) {
+        throw new Error(`Channel ${channelId} not found`);
+      }
+      await channel.delete();
+      Log.info(`Deleted channel ${channelId}`);
+      return true;
+    } catch (error) {
+      Log.error(`Failed to delete channel ${channelId}: ${error}`);
+      throw error;
+    }
+  }
+};
+_GuildChannelManager.message = GuildMessageManager;
+var GuildChannelManager = _GuildChannelManager;
+
+// src/manager/guild/ChannelManager/GuildTextChannelManager.ts
+var GuildTextChannelManager = class extends GuildChannelManager {
+  static async findInGuild(guildId, channelId) {
+    const channel = await super.findInGuild(guildId, channelId);
+    return channel?.isTextBased() ? channel : null;
+  }
+  static async find(channelId) {
+    const channel = await super.find(channelId);
+    return channel?.isTextBased() ? channel : null;
+  }
+  static findAll(guildId) {
+    const guild = Bot.client.guilds.cache.get(guildId);
+    if (!guild) {
+      Log.warn(`Guild ${guildId} not found`);
+      return [];
+    }
+    return Array.from(guild.channels.cache.values()).filter((c) => c instanceof TextChannel4);
+  }
+  static async create(guildId, name, options) {
+    return await super._create(guildId, {
+      name,
+      type: ChannelType.GuildText,
+      ...options
+    });
+  }
+};
+
+// src/manager/messages/ReactionManager.ts
+var ReactionManager = class {
+  /**
+   * Add a reaction to a message
+   */
+  static async add(channelId, messageId, emoji) {
+    try {
+      const channel = await GuildTextChannelManager.find(channelId);
+      if (!channel) {
+        throw new Error(`Channel ${channelId} not found`);
+      }
+      if (!channel.isTextBased()) {
+        throw new Error(`Channel ${channelId} is not text based`);
+      }
+      const message = await channel.messages.fetch(messageId);
+      await message.react(emoji);
+      Log.info(`Added reaction ${emoji} to message ${messageId}`);
+    } catch (error) {
+      Log.error(`Failed to add reaction to ${messageId}: ${error}`);
+      throw error;
+    }
+  }
+  /**
+   * Delete a reaction from a user
+   */
+  static async remove(channelId, messageId, emoji, userId) {
+    try {
+      const channel = await GuildTextChannelManager.find(channelId);
+      if (!channel) {
+        throw new Error(`Channel ${channelId} not found`);
+      }
+      const message = await channel.messages.fetch(messageId);
+      const reaction = message.reactions.resolve(emoji);
+      if (!reaction) {
+        throw new Error(`Reaction ${emoji} not found on message ${messageId}`);
+      }
+      const user = await Bot.client.users.fetch(userId);
+      await reaction.users.remove(user);
+      Log.info(`Removed reaction ${emoji} from user ${userId} on message ${messageId}`);
+    } catch (error) {
+      Log.error(`Failed to remove reaction from ${messageId}: ${error}`);
+      throw error;
+    }
+  }
+  /**
+   * Get all reaction of a message
+   */
+  static async getAll(channelId, messageId) {
+    try {
+      const channel = await GuildTextChannelManager.find(channelId);
+      if (!channel) {
+        throw new Error(`Channel ${channelId} not found`);
+      }
+      const message = await channel.messages.fetch(messageId);
+      const reactions = message.reactions.cache;
+      const reactionList = [];
+      for (const reaction of reactions.values()) {
+        const users = await reaction.users.fetch();
+        reactionList.push({
+          emoji: reaction.emoji,
+          count: reaction.count,
+          users: Array.from(users.values())
+        });
+      }
+      Log.info(`Fetched ${reactionList.length} reactions for message ${messageId}`);
+      return reactionList;
+    } catch (error) {
+      Log.error(`Failed to fetch reactions for ${messageId}: ${error}`);
+      throw error;
+    }
+  }
+  /**
+   * Delete all reaction
+   */
+  static async clear(channelId, messageId) {
+    try {
+      const channel = await GuildTextChannelManager.find(channelId);
+      if (!channel) {
+        throw new Error(`Channel ${channelId} not found`);
+      }
+      const message = await channel.messages.fetch(messageId);
+      await message.reactions.removeAll();
+      Log.info(`Cleared all reactions from message ${messageId}`);
+    } catch (error) {
+      Log.error(`Failed to clear reactions from ${messageId}: ${error}`);
+      throw error;
+    }
+  }
+};
+
+// src/manager/guild/GuildManager.ts
+import {
+  Guild as Guild2,
+  VoiceChannel as VoiceChannel2,
+  StageChannel as StageChannel2
+} from "discord.js";
+
+// src/manager/direct/BasicUserManager.ts
+import { GuildMember as GuildMember2 } from "discord.js";
+var BasicUserManager = class {
+  /**
+   * Find member in specific guild
+   */
+  static async findInGuild(guildId, memberId) {
+    try {
+      const guild = Bot.client.guilds.cache.get(guildId);
+      if (!guild) throw new Error(`Guild ${guildId} not found`);
+      const member = await guild.members.fetch({ user: memberId, force: true });
+      return member ?? null;
+    } catch (error) {
+      Log.error(`UserManager: Member ${memberId} not found in ${guildId}`);
+      return null;
+    }
+  }
+  /**
+   * Check if user is still in guild
+   */
+  static async isInGuild(guildId, userId) {
+    try {
+      const guild = Bot.client.guilds.cache.get(guildId);
+      if (!guild) return false;
+      await guild.members.fetch({ user: userId, force: true });
+      return true;
+    } catch (error) {
+      return error.code !== 10007;
+    }
+  }
+  /**
+   * Impl
+   */
+  static async send(user_id_or_user, content_or_component_or_options, component) {
+    try {
+      let user;
+      if (typeof user_id_or_user === "string") {
+        user = await Bot.client.users.fetch(user_id_or_user);
+      } else {
+        user = user_id_or_user;
+      }
+      const dmChannel = await user.createDM();
+      let payload;
+      if (component && typeof content_or_component_or_options == "string") {
+        payload = SendableComponentBuilder.buildMessage(
+          content_or_component_or_options,
+          component
+        );
+      } else if (typeof content_or_component_or_options === "string") {
+        payload = SendableComponentBuilder.buildMessage(content_or_component_or_options);
+      } else if (SendableComponentBuilder.isSendableComponent(content_or_component_or_options)) {
+        payload = SendableComponentBuilder.buildMessage(content_or_component_or_options);
+      } else {
+        payload = content_or_component_or_options;
+      }
+      const message = await dmChannel.send(payload);
+      if (user instanceof GuildMember2) {
+        Log.info(`Sent DM to ${user.id} (${user.user.username}): "${(payload.content || "Embed/Component").substring(0, 50)}..."`);
+      } else {
+        Log.info(`Sent DM to ${user.id} (${user.username}): "${(payload.content || "Embed/Component").substring(0, 50)}..."`);
+      }
+      return message;
+    } catch (error) {
+      Log.error(`Failed to send DM to ${user_id_or_user}: ${error}`);
+      throw new Error(`Cannot send DM to ${user_id_or_user}`);
+    }
+  }
+};
+
+// src/manager/guild/GuildUserManager.ts
+import { Guild } from "discord.js";
+import { setTimeout as setTimeout2 } from "timers/promises";
+var MAX_NICKNAME_LENGTH = 32;
+var GuildUserManager = class extends BasicUserManager {
+  static async find(userId, guild) {
+    try {
+      if (guild instanceof Guild) {
+        return await guild.members.fetch(userId);
+      } else {
+        return await (await GuildManager.find(guild)).members.fetch(userId);
+      }
+    } catch (error) {
+      Log.error(`UserManager: Member ${userId} not found`);
+      return null;
+    }
+  }
+  static async rename(member, nickname, maxAttempts = 3) {
+    if (nickname.length > MAX_NICKNAME_LENGTH) {
+      nickname = nickname.slice(0, MAX_NICKNAME_LENGTH);
+    }
+    for (let attempts = 0; attempts < maxAttempts; attempts++) {
+      try {
+        const oldName = member.displayName;
+        await member.setNickname(nickname.trim());
+        Log.info(`Renaming user: ${oldName} \u2192 ${nickname.trim()}`);
+        await setTimeout2(1500);
+        return true;
+      } catch (error) {
+        console.error(`Attempt ${attempts + 1} failed when renaming ${member.displayName} into ${nickname.trim()}:`, error);
+        await setTimeout2(1e3);
+      }
+    }
+    Bot.log.info(EmbedManager.error(`Failed to rename ${member.displayName} to ${nickname.trim()} after ${maxAttempts} attempts.`));
+    return false;
+  }
+  /**
+   * Check if user is banned from guild
+   */
+  static async isBanned(guildId, userId) {
+    try {
+      const guild = Bot.client.guilds.cache.get(guildId);
+      if (!guild) {
+        Log.warn(`Guild ${guildId} not found`);
+        return false;
+      }
+      const ban = await guild.bans.fetch(userId);
+      return !!ban;
+    } catch (error) {
+      Log.debug(`User ${userId} is not banned from guild ${guildId}`);
+      return false;
+    }
+  }
+  /**
+   * Deconnect a member from a voice
+   */
+  static async deconnectFromVoice(guildId, memberId) {
+    try {
+      const guild = Bot.client.guilds.cache.get(guildId);
+      if (!guild) {
+        throw new Error(`Guild ${guildId} not found`);
+      }
+      const member = await guild.members.fetch(memberId);
+      if (!member.voice.channel) {
+        throw new Error(`Member ${memberId} is not in a voice channel`);
+      }
+      await member.voice.disconnect();
+      Log.info(`Disconnected member ${memberId} from voice in guild ${guildId}`);
+    } catch (error) {
+      Log.error(`Failed to disconnect member ${memberId} from voice in ${guildId}: ${error}`);
+      throw error;
+    }
+  }
+  /**
+   * Check if a member is in voice
+   */
+  static async isInVoice(memberId, guildId) {
+    try {
+      const guild = Bot.client.guilds.cache.get(guildId);
+      if (!guild) return false;
+      const member = await guild.members.fetch(memberId);
+      return member.voice.channelId !== null;
+    } catch (error) {
+      Log.debug(`Member ${memberId} not found or not in voice in guild ${guildId}`);
+      return false;
+    }
+  }
+  /**
+   * Mute a member
+   */
+  static async mute(guildId, memberId, reason) {
+    try {
+      const guild = Bot.client.guilds.cache.get(guildId);
+      if (!guild) throw new Error(`Guild ${guildId} not found`);
+      const member = await guild.members.fetch(memberId);
+      await member.voice.setMute(true, reason);
+      Log.info(`Server muted ${memberId} in guild ${guildId}: ${reason || "No reason"}`);
+    } catch (error) {
+      Log.error(`Failed to server mute ${memberId} in ${guildId}:, error`);
+      throw error;
+    }
+  }
+  /**
+   * Unmute a member
+   */
+  static async unmute(guildId, memberId, reason) {
+    try {
+      const guild = Bot.client.guilds.cache.get(guildId);
+      if (!guild) throw new Error(`Guild ${guildId} not found`);
+      const member = await guild.members.fetch(memberId);
+      await member.voice.setMute(false, reason);
+      Log.info(`Server unmuted ${memberId} in guild ${guildId}: ${reason || "No reason"}`);
+    } catch (error) {
+      Log.error(`Failed to server unmute ${memberId} in ${guildId}: ${error}`);
+      throw error;
+    }
+  }
+  /**
+   * Deafen a member
+   */
+  static async deafen(guildId, memberId, reason) {
+    try {
+      const guild = Bot.client.guilds.cache.get(guildId);
+      if (!guild) throw new Error(`Guild ${guildId} not found`);
+      const member = await guild.members.fetch(memberId);
+      await member.voice.setDeaf(true, reason);
+      Log.info(`Server deafened ${memberId} in guild ${guildId}: ${reason || "No reason"}`);
+    } catch (error) {
+      Log.error(`Failed to server deafen ${memberId} in ${guildId}: ${error}`);
+      throw error;
+    }
+  }
+  /**
+   * Undeafen member voice
+   */
+  static async undeafen(guildId, memberId, reason) {
+    try {
+      const guild = Bot.client.guilds.cache.get(guildId);
+      if (!guild) throw new Error(`Guild ${guildId} not found`);
+      const member = await guild.members.fetch(memberId);
+      await member.voice.setDeaf(false, reason);
+      Log.info(`Server undeafened ${memberId} in guild ${guildId}: ${reason || "No reason"}`);
+    } catch (error) {
+      Log.error(`Failed to server undeafen ${memberId} in ${guildId}: ${error}`);
+      throw error;
+    }
+  }
+  /**
+   * Timeout a member
+   */
+  static async timeout(guildId, memberId, duration, reason) {
+    try {
+      const guild = Bot.client.guilds.cache.get(guildId);
+      if (!guild) throw new Error(`Guild ${guildId} not found`);
+      const member = await guild.members.fetch(memberId);
+      const expires = Date.now() + duration;
+      await member.timeout(expires, reason);
+      Log.info(`Timed out ${memberId} for ${duration}ms in guild ${guildId}: ${reason || "No reason"}`);
+    } catch (error) {
+      Log.error(`Failed to timeout ${memberId} in ${guildId}: ${error}`);
+      throw error;
+    }
+  }
+  /**
+   * Remove the timeout of a member
+   */
+  static async untimeout(guildId, memberId, reason) {
+    try {
+      const guild = Bot.client.guilds.cache.get(guildId);
+      if (!guild) throw new Error(`Guild ${guildId} not found`);
+      const member = await guild.members.fetch(memberId);
+      await member.timeout(null, reason);
+      Log.info(`Untimed out ${memberId} in guild ${guildId}: ${reason || "No reason"}`);
+    } catch (error) {
+      Log.error(`Failed to untimeout ${memberId} in ${guildId}: ${error}`);
+      throw error;
+    }
+  }
+  /**
+   * Kick a member
+   */
+  static async kick(guildId, memberId, reason) {
+    try {
+      const guild = Bot.client.guilds.cache.get(guildId);
+      if (!guild) throw new Error(`Guild ${guildId} not found`);
+      const member = await guild.members.fetch(memberId);
+      await member.kick(reason);
+      Log.info(`Kicked ${memberId} from guild ${guildId}: ${reason || "No reason"}`);
+    } catch (error) {
+      Log.error(`Failed to kick ${memberId} from ${guildId}: ${error}`);
+      throw error;
+    }
+  }
+  static async ban(guildId, userId, banOption) {
+    const guild = Bot.client.guilds.cache.get(guildId);
+    if (!guild) {
+      throw new Error(`Guild ${guildId} not found`);
+    }
+    try {
+      await guild.members.ban(userId, banOption);
+      Log.info(`Banned user ${userId} from guild ${guildId}`);
+    } catch (error) {
+      Log.error(`Failed to ban user ${userId} from guild ${guildId}: ${error}`);
+      throw error;
+    }
+  }
+  static async unban(guildId, userId, reason) {
+    const guild = Bot.client.guilds.cache.get(guildId);
+    if (!guild) {
+      throw new Error(`Guild ${guildId} not found`);
+    }
+    try {
+      await guild.members.unban(userId, reason);
+      Log.info(`Unbanned user ${userId} from guild ${guildId}`);
+    } catch (error) {
+      Log.error(`Failed to unban user ${userId} from guild ${guildId}: ${error}`);
+      throw error;
+    }
+  }
+};
+
+// src/manager/guild/RoleManager.ts
+var RoleManager = class {
+  /**
+   * Add role - CACHE ONLY
+   * @param member - GuildMember ALREADY FETCHED
+   * @param roleId - Role ID (string)
+   */
+  static async add(member, roleId) {
+    try {
+      const role = member.roles.cache.get(roleId);
+      if (!role) {
+        Log.warn(`Role ${roleId} not found in cache`);
+        return false;
+      }
+      await member.roles.add(role);
+      Log.info(`\u2705 Added ${role.name} to ${member.displayName}`);
+      return true;
+    } catch (error) {
+      Log.error(`Failed to add role ${roleId}: ${error}`);
+      return false;
+    }
+  }
+  /**
+   * Remove role - CACHE ONLY
+   * @param member - GuildMember ALREADY FETCHED
+   * @param roleIdOrName - Role ID or name
+   */
+  static async remove(member, roleIdOrName) {
+    try {
+      let role;
+      if (typeof roleIdOrName === "string" && roleIdOrName.length === 18) {
+        role = member.roles.cache.get(roleIdOrName);
+      } else {
+        role = member.roles.cache.find(
+          (r) => r.id === roleIdOrName || r.name.toLowerCase() === roleIdOrName.toString().toLowerCase()
+        );
+      }
+      if (!role) {
+        Log.warn(`Role ${roleIdOrName} not found for ${member.displayName}`);
+        return false;
+      }
+      await member.roles.remove(role);
+      Log.info(`\u2705 Removed ${role.name} from ${member.displayName}`);
+      return true;
+    } catch (error) {
+      Log.error(`Failed to remove role ${roleIdOrName}: ${error}`);
+      return false;
+    }
+  }
+  /**
+   * Toggle role (add/remove)
+   */
+  static async toggle(member, roleIdOrName) {
+    const role = member.roles.cache.get(roleIdOrName) || member.roles.cache.find((r) => r.name.toLowerCase() === roleIdOrName.toString().toLowerCase());
+    if (!role) {
+      Log.warn(`Role ${roleIdOrName} not found`);
+      throw new Error(`Role not found`);
+    }
+    if (member.roles.cache.has(role.id)) {
+      await this.remove(member, role.id);
+      return "removed";
+    } else {
+      await this.add(member, role.id);
+      return "added";
+    }
+  }
+  /**
+   * Check if member has role
+   */
+  static hasRole(member, roleIdOrName) {
+    if (typeof roleIdOrName === "string" && roleIdOrName.length === 18) {
+      return member.roles.cache.has(roleIdOrName);
+    }
+    return member.roles.cache.some(
+      (r) => r.id === roleIdOrName || r.name.toLowerCase() === roleIdOrName.toString().toLowerCase()
+    );
+  }
+};
+
+// src/manager/guild/ChannelManager/ForumChannelManager.ts
+import { ChannelType as ChannelType2, ForumChannel } from "discord.js";
+var ForumChannelManager = class extends GuildChannelManager {
+  static async findInGuild(guildId, channelId) {
+    const channel = await super.findInGuild(guildId, channelId);
+    return channel instanceof ForumChannel ? channel : null;
+  }
+  static async find(channelId) {
+    const channel = await super.find(channelId);
+    return channel instanceof ForumChannel ? channel : null;
+  }
+  static findAll(guildId) {
+    const guild = Bot.client.guilds.cache.get(guildId);
+    if (!guild) {
+      Log.warn(`Guild ${guildId} not found`);
+      return [];
+    }
+    return Array.from(guild.channels.cache.values()).filter((c) => c instanceof ForumChannel);
+  }
+  static async create(guildId, name, options) {
+    return await super._create(guildId, {
+      name,
+      type: ChannelType2.GuildForum,
+      ...options
+    });
+  }
+};
+
+// src/manager/guild/ChannelManager/NewsChannelManager.ts
+import { ChannelType as ChannelType3, NewsChannel } from "discord.js";
+var NewsChannelManager = class extends GuildChannelManager {
+  static async findInGuild(guildId, channelId) {
+    const channel = await super.findInGuild(guildId, channelId);
+    return channel instanceof NewsChannel ? channel : null;
+  }
+  static async find(channelId) {
+    const channel = await super.find(channelId);
+    return channel instanceof NewsChannel ? channel : null;
+  }
+  static findAll(guildId) {
+    const guild = Bot.client.guilds.cache.get(guildId);
+    if (!guild) {
+      Log.warn(`Guild ${guildId} not found`);
+      return [];
+    }
+    return Array.from(guild.channels.cache.values()).filter((c) => c instanceof NewsChannel);
+  }
+  static async create(guildId, name, options) {
+    return await super._create(guildId, {
+      name,
+      type: ChannelType3.GuildAnnouncement,
+      ...options
+    });
+  }
+};
+
+// src/manager/guild/ChannelManager/StageChannelManager.ts
+import { ChannelType as ChannelType4, StageChannel } from "discord.js";
+var StageChannelManager = class extends GuildChannelManager {
+  static async findInGuild(guildId, channelId) {
+    const channel = await super.findInGuild(guildId, channelId);
+    return channel instanceof StageChannel ? channel : null;
+  }
+  static async find(channelId) {
+    const channel = await super.find(channelId);
+    return channel instanceof StageChannel ? channel : null;
+  }
+  static findAll(guildId) {
+    const guild = Bot.client.guilds.cache.get(guildId);
+    if (!guild) {
+      Log.warn(`Guild ${guildId} not found`);
+      return [];
+    }
+    return Array.from(guild.channels.cache.values()).filter((c) => c instanceof StageChannel);
+  }
+  static async create(guildId, name, options) {
+    return await super._create(guildId, {
+      name,
+      type: ChannelType4.GuildStageVoice,
+      ...options
+    });
+  }
+};
+
+// src/manager/guild/ChannelManager/ThreadChannelManager.ts
+var ThreadChannelManager = class {
+  static async findInGuild(guildId, channelId) {
+    const channel = await GuildChannelManager.findInGuild(guildId, channelId);
+    return channel?.isThread() ? channel : null;
+  }
+  static async find(channelId) {
+    const channel = await GuildChannelManager.find(channelId);
+    return channel?.isThread() ? channel : null;
+  }
+  static findAll(guildId) {
+    const channels = GuildChannelManager.findAll(guildId);
+    return channels.filter((c) => c.isThread());
+  }
+  static async createFromChannel(parentId, options) {
+    const channel = await GuildTextChannelManager.find(parentId);
+    if (!channel || !channel.isTextBased()) {
+      throw new Error("Parent must be a text-based channel");
+    }
+    const thread = await channel.threads.create(options);
+    return thread;
+  }
+  static async createFromMessage(message, options) {
+    const channel = await GuildChannelManager.find(message.id);
+    if (!channel) throw new Error("Message channel not found");
+    return await message.startThread(options);
+  }
+  /**
+   * Impl
+   */
+  static async send(channelId, content_or_component_or_options) {
+    if (typeof content_or_component_or_options == "string") {
+      return await GuildTextChannelManager.message.send(channelId, content_or_component_or_options);
+    } else if (SendableComponentBuilder.isSendableComponent(content_or_component_or_options) || Array.isArray(content_or_component_or_options)) {
+      return await GuildTextChannelManager.message.send(channelId, content_or_component_or_options);
+    } else {
+      return await GuildTextChannelManager.message.send(channelId, content_or_component_or_options);
+    }
+  }
+};
+
+// src/manager/guild/ChannelManager/GuildVoiceChannelManager.ts
+import { ChannelType as ChannelType5, VoiceChannel } from "discord.js";
+var GuildVoiceChannelManager = class extends GuildChannelManager {
+  static async findInGuild(guildId, channelId) {
+    const channel = await super.findInGuild(guildId, channelId);
+    return channel?.isVoiceBased() ? channel : null;
+  }
+  static async find(channelId) {
+    const channel = await super.find(channelId);
+    return channel?.isVoiceBased() ? channel : null;
+  }
+  static findAll(guildId) {
+    const guild = Bot.client.guilds.cache.get(guildId);
+    if (!guild) {
+      Log.warn(`Guild ${guildId} not found`);
+      return [];
+    }
+    return Array.from(guild.channels.cache.values()).filter((c) => c instanceof VoiceChannel);
+  }
+  static async create(guildId, name, options) {
+    return await super._create(guildId, {
+      name,
+      type: ChannelType5.GuildVoice,
+      ...options
+    });
+  }
+};
+
+// src/manager/guild/ChannelManager/GuildChannelList.ts
+var GuildChannelList = class {
+};
+GuildChannelList.forum = ForumChannelManager;
+GuildChannelList.any = GuildChannelManager;
+GuildChannelList.news = NewsChannelManager;
+GuildChannelList.stage = StageChannelManager;
+GuildChannelList.text = GuildTextChannelManager;
+GuildChannelList.thread = ThreadChannelManager;
+GuildChannelList.voice = GuildVoiceChannelManager;
+
+// src/manager/guild/InviteManager.ts
+var InviteManager = class {
+  /**
+   * Create an invite for a channel
+   */
+  static async create(channelId, options = {}) {
+    try {
+      const channel = await GuildChannelManager.find(channelId);
+      if (!channel) {
+        throw new Error(`Channel ${channelId} not found`);
+      }
+      const guild = channel.guild;
+      const inviteOptions = {
+        maxAge: options.maxAge ?? 86400,
+        maxUses: options.maxUses ?? 0,
+        temporary: options.temporary ?? false,
+        reason: options.reason
+      };
+      const invite = await guild.invites.create(channelId, inviteOptions);
+      Log.info(`Created invite ${invite.code} for channel ${channelId}`);
+      return invite;
+    } catch (error) {
+      Log.error(`Failed to create invite for channel ${channelId}: ${error}`);
+      throw error;
+    }
+  }
+  /**
+   * Delete an invitation
+   */
+  static async delete(invite) {
+    try {
+      await invite.delete();
+      Log.info(`Deleted invite ${invite.code} from guild ${invite.guild?.id}`);
+      return true;
+    } catch (error) {
+      Log.error(`Failed to delete invite ${invite.code}: ${error}`);
+      return false;
+    }
+  }
+  /**
+   * List every invitation from a guild
+   */
+  static async list(guildId) {
+    try {
+      const guild = Bot.client.guilds.cache.get(guildId);
+      if (!guild) {
+        throw new Error(`Guild ${guildId} not found`);
+      }
+      const invites = await guild.invites.fetch();
+      const inviteList = Array.from(invites.values());
+      Log.info(`Fetched ${inviteList.length} invites for guild ${guildId}`);
+      return inviteList;
+    } catch (error) {
+      Log.error(`Failed to fetch invites for guild ${guildId}: ${error}`);
+      throw error;
+    }
+  }
+};
+
+// src/manager/guild/GuildManager.ts
+var GuildManager = class {
+  static list() {
+    return Array.from(Bot.client.guilds.cache.values());
+  }
+  static async find(guild_id) {
+    return await Bot.client.guilds.fetch(guild_id);
+  }
+  /**
+   * Search channel by ID (TextChannel, DMChannel, ThreadChannel)
+   */
+  static async searchChannel(guildId, channelId) {
+    try {
+      return await GuildChannelManager.findInGuild(guildId, channelId);
+    } catch (error) {
+      Log.error(`Failed to fetch channel ${channelId}: ${error}`);
+      return null;
+    }
+  }
+  /**
+   * Search guild member by ID
+   */
+  static async searchMember(memberId, guildId) {
+    try {
+      return await this.user.findInGuild(guildId, guildId);
+    } catch (error) {
+      Log.error(`Failed to fetch member ${memberId} in guild ${guildId}: ${error}`);
+      return null;
+    }
+  }
+  /**
+   * Check if member is still in guild
+   */
+  static async isMemberInGuild(memberId, guildId) {
+    try {
+      return await this.user.isInGuild(memberId, guildId);
+    } catch (error) {
+      return error.code !== 10007;
+    }
+  }
+  /**
+   * Fetch all members with retry (heavy operation)
+   */
+  static async fetchAllMembers(guildId, MAX_ATTEMPTS = 3, RETRY_DELAY = Time.minute.MIN_05.toMilliseconds()) {
+    let guild;
+    if (guildId instanceof Guild2) {
+      guild = guildId;
+    } else {
+      let tmp = Bot.client.guilds.cache.get(guildId);
+      if (!tmp) throw new Error(`Guild ${guildId} not found`);
+      guild = tmp;
+    }
+    for (let attempt = 1; attempt <= MAX_ATTEMPTS; attempt++) {
+      try {
+        Log.info(`UserManager: Fetching ${guild.name} members (attempt ${attempt})`);
+        return await guild.members.fetch();
+      } catch (error) {
+        Log.error(`UserManager: Fetch failed (attempt ${attempt}): ${error}`);
+        if (attempt < MAX_ATTEMPTS) {
+          await new Promise((r) => setTimeout(r, RETRY_DELAY));
+        }
+      }
+    }
+    throw new Error(`Failed to fetch members after ${MAX_ATTEMPTS} attempts`);
+  }
+  static async listban(guildId, limit) {
+    const guild = Bot.client.guilds.cache.get(guildId);
+    if (!guild) {
+      throw new Error(`Guild ${guildId} not found`);
+    }
+    try {
+      const bans = await guild.bans.fetch({ limit });
+      return Array.from(bans.values());
+    } catch (error) {
+      Log.error(`Failed to list bans in guild ${guildId}: ${error}`);
+      throw error;
+    }
+  }
+  static async moveMember(memberId, fromChannelId, toChannelId) {
+    try {
+      const guild = Bot.client.guilds.cache.find(
+        (g) => g.channels.cache.has(fromChannelId) || g.channels.cache.has(toChannelId)
+      );
+      if (!guild) {
+        throw new Error(`Guild containing channels ${fromChannelId} or ${toChannelId} not found`);
+      }
+      const member = await guild.members.fetch(memberId).catch(() => null);
+      if (!member) {
+        throw new Error(`Member ${memberId} not found in guild ${guild.id}`);
+      }
+      const fromChannel = guild.channels.cache.get(fromChannelId);
+      const toChannel = guild.channels.cache.get(toChannelId);
+      if (!fromChannel) {
+        throw new Error(`From channel ${fromChannelId} not found`);
+      }
+      if (!toChannel) {
+        throw new Error(`To channel ${toChannelId} not found`);
+      }
+      if (!(fromChannel instanceof VoiceChannel2 || fromChannel instanceof StageChannel2)) {
+        throw new Error(`From channel ${fromChannelId} is not a voice/stage channel`);
+      }
+      if (!(toChannel instanceof VoiceChannel2 || toChannel instanceof StageChannel2)) {
+        throw new Error(`To channel ${toChannelId} is not a voice/stage channel`);
+      }
+      if (member.voice.channelId !== fromChannelId) {
+        throw new Error(`Member ${memberId} is not in channel ${fromChannelId}`);
+      }
+      try {
+        await member.voice.setChannel(toChannel);
+        Log.info(`Moved member ${memberId} from ${fromChannelId} to ${toChannelId}`);
+      } catch (error) {
+        Log.error(`Failed to move member ${memberId} from ${fromChannelId} to ${toChannelId}: ${error}`);
+        throw error;
+      }
+      return true;
+    } catch (e) {
+      Log.error(`Failed to move member ${e}`);
+      return false;
+    }
+  }
+};
+GuildManager.role = RoleManager;
+GuildManager.user = GuildUserManager;
+GuildManager.channel = GuildChannelList;
+GuildManager.invite = InviteManager;
+
+// src/manager/direct/UserManager.ts
+var UserManager = class extends BasicUserManager {
+  static async find(userId) {
+    try {
+      return await Bot.client.users.fetch(userId);
+    } catch (error) {
+      Log.error(`UserManager: Member ${userId} not found`);
+      return null;
+    }
+  }
+};
+
+// src/manager/interactions/ModalManager.ts
+import {
+  ActionRowBuilder as ActionRowBuilder2,
+  ModalBuilder,
+  TextInputBuilder,
+  TextInputStyle
+} from "discord.js";
+var ModalManager = class _ModalManager {
+  /**
+   * Load modal from JSON file and return ModalBuilder
+   */
+  static async load(filename) {
+    try {
+      const file = await FileManager.readJsonFile(`./handlers/${"modals" /* MODAL */}/${filename}`);
+      if (!file) return false;
+      return _ModalManager.jsonToBuilder(file);
+    } catch {
+      return false;
+    }
+  }
+  /**
+   * List all modal files
+   */
+  static async list() {
+    try {
+      const files = await FileManager.listJsonFiles(`./handlers/${"modals" /* MODAL */}`);
+      return files || [];
+    } catch {
+      return false;
+    }
+  }
+  static jsonToBuilder(json) {
+    const modal = new ModalBuilder().setCustomId(json.customId).setTitle(json.title.slice(0, 45));
+    const actionRows = [];
+    for (const fieldJson of json.fields) {
+      const input = this.fieldJsonToInput(fieldJson);
+      const row = new ActionRowBuilder2().addComponents(input);
+      actionRows.push(row);
+    }
+    return modal.addComponents(...actionRows);
+  }
+  static fieldJsonToInput(fieldJson) {
+    const input = new TextInputBuilder().setCustomId(fieldJson.customId).setLabel(fieldJson.title.slice(0, 45)).setPlaceholder(fieldJson.placeholder || "Enter value...").setRequired(fieldJson.required !== false).setMinLength(fieldJson.minLength || 0).setMaxLength(fieldJson.maxLength || 400);
+    const style = fieldJson.style;
+    if (typeof style === "number") {
+      input.setStyle(style);
+    } else {
+      switch (style) {
+        case "Number":
+        case "Phone":
+        case "Date":
+          input.setStyle(TextInputStyle.Short);
+          input.setPlaceholder(
+            style === "Number" ? "123" : style === "Phone" ? "+33 6 12 34 56 78" : "2024-02-05"
+          );
+          break;
+        default:
+          input.setStyle(TextInputStyle.Short);
+      }
+    }
+    return input;
+  }
+  static parseNumber(value) {
+    if (!/^\d+$/.test(value)) return null;
+    const num = parseInt(value);
+    return isNaN(num) ? null : num;
+  }
+  static parsePhone(value) {
+    const clean = value.replace(/[\s\-\(\)]/g, "");
+    if (/^(06|07|09)\d{8}$/.test(clean) || /^(\+33|0033)?[6-9]\d{8}$/.test(clean)) {
+      if (clean.startsWith("06") || clean.startsWith("07") || clean.startsWith("09")) {
+        return "+33" + clean.slice(2);
+      }
+      return clean.startsWith("0033") ? "+33" + clean.slice(4) : clean;
+    }
+    return null;
+  }
+  static parseDate(value) {
+    if (/^\d{4}-\d{2}-\d{2}$/.test(value)) {
+      const [year, month, day] = value.split("-").map(Number);
+      const date = new Date(year, month - 1, day);
+      return isNaN(date.getTime()) ? null : date;
+    }
+    if (/^\d{2}\/\d{2}\/\d{4}$/.test(value)) {
+      const [day, month, year] = value.split("/").map(Number);
+      const date = new Date(year, month - 1, day);
+      return isNaN(date.getTime()) ? null : date;
+    }
+    return null;
+  }
+};
+
+// src/manager/interactions/SelectMenuManager.ts
+import {
+  ActionRowBuilder as ActionRowBuilder3,
+  StringSelectMenuBuilder,
+  StringSelectMenuOptionBuilder,
+  UserSelectMenuBuilder,
+  RoleSelectMenuBuilder,
+  MentionableSelectMenuBuilder,
+  ChannelSelectMenuBuilder
+} from "discord.js";
+var SelectMenuManager = class {
+  /**
+   * Creates base StringSelectMenu - SIMPLE API !
+   */
+  static create(customId, placeholder = "Select an option...") {
+    return new StringSelectMenuBuilder().setCustomId(customId).setPlaceholder(placeholder).setMinValues(1).setMaxValues(1);
+  }
+  /**
+   * Quick StringSelectMenu
+   */
+  static simple(customId, options, placeholder = "Choose an option") {
+    const menu = this.create(customId, placeholder);
+    menu.addOptions(
+      options.map((opt) => {
+        return this.option(opt);
+      })
+    );
+    return menu;
+  }
+  /**
+   * Pagination menu
+   */
+  static paginated(customId, options, pageSize = 25) {
+    const row = new ActionRowBuilder3();
+    for (let i = 0; i < options.length; i += pageSize) {
+      const pageOptions = options.slice(i, i + pageSize);
+      const menu = new StringSelectMenuBuilder().setCustomId(`${customId}_page_${Math.floor(i / pageSize)}`).setPlaceholder(`Page ${Math.floor(i / pageSize) + 1}`).addOptions(pageOptions.map((opt) => {
+        return this.option(opt);
+      }));
+      row.addComponents(menu);
+    }
+    return row;
+  }
+  /**
+   * User Select Menu (Components V2)
+   */
+  static users(customId, placeholder = "Select users...") {
+    return new UserSelectMenuBuilder().setCustomId(customId).setPlaceholder(placeholder).setMinValues(1).setMaxValues(25);
+  }
+  /**
+   * Role Select Menu (Components V2)
+   */
+  static roles(customId, placeholder = "Select roles...") {
+    return new RoleSelectMenuBuilder().setCustomId(customId).setPlaceholder(placeholder).setMinValues(1).setMaxValues(25);
+  }
+  /**
+   * Mentionable Select Menu (Components V2)
+   */
+  static mentionables(customId, placeholder = "Select users/roles...") {
+    return new MentionableSelectMenuBuilder().setCustomId(customId).setPlaceholder(placeholder).setMinValues(1).setMaxValues(25);
+  }
+  /**
+   * Channel Select Menu (Components V2)
+   */
+  static channels(customId, placeholder = "Select channels...", channelTypes = []) {
+    return new ChannelSelectMenuBuilder().setCustomId(customId).setPlaceholder(placeholder).setMinValues(1).setMaxValues(25).setChannelTypes(...channelTypes);
+  }
+  static option(option) {
+    if (Array.isArray(option)) {
+      return option.map((opt) => this._createOption(opt));
+    }
+    return this._createOption(option);
+  }
+  static _createOption(option) {
+    const builder = new StringSelectMenuOptionBuilder().setLabel(option.label).setValue(option.value);
+    option.description && builder.setDescription(option.description);
+    option.emoji && builder.setEmoji(option.emoji);
+    return builder;
+  }
+  /**
+   * Fluent API pour personnaliser
+   */
+  static placeholder(menu, placeholder) {
+    return menu.setPlaceholder(placeholder);
+  }
+  static minMax(menu, min, max) {
+    return menu.setMinValues(min).setMaxValues(Math.min(max, 25));
+  }
+  static disabled(menu, disabled) {
+    return menu.setDisabled(disabled);
+  }
+  /**
+   * ActionRow
+   */
+  static row(component) {
+    return new ActionRowBuilder3().addComponents(component);
+  }
+  /**
+   * Rows multiples (5 max)
+   */
+  static rows(...components) {
+    return components.slice(0, 5).map(
+      (component) => this.row(component)
+    );
+  }
+};
+
+// src/utils/SimpleMutex.ts
+var SimpleMutex = class {
+  // File d'attente des fonctions de résolution
+  constructor() {
+    this._locked = false;
+    this.queue = [];
+  }
+  /**
+   * Verrouille le mutex. Si le mutex est déjà verrouillé, la méthode retourne une promesse qui sera résolue une fois que le mutex sera disponible.
+   * @returns Une promesse résolue lorsque le mutex est verrouillé.
+   */
+  async lock() {
+    if (this._locked) {
+      return new Promise((resolve) => {
+        this.queue.push(resolve);
+      });
+    }
+    this._locked = true;
+    return Promise.resolve();
+  }
+  /**
+   * Déverrouille le mutex. Si une file d'attente existe, débloque le prochain élément dans la file.
+   */
+  unlock() {
+    if (this.queue.length > 0) {
+      const nextResolve = this.queue.shift();
+      if (nextResolve) {
+        nextResolve();
+      }
+      return;
+    }
+    this._locked = false;
+  }
+  get locked() {
+    return this._locked;
+  }
+};
+
+// package.json
+var package_default = {
+  name: "@spatulox/simplediscordbot",
+  version: "1.0.31",
+  author: "Spatulox",
+  description: "Simple discord bot framework to set up a bot under 30 secondes",
+  exports: {
+    types: "./dist/index.d.ts",
+    import: "./dist/index.js",
+    require: "./dist/index.js"
+  },
+  types: "./dist/index.d.ts",
+  scripts: {
+    build: "rm -r dist/ && tsup",
+    patch: "npm run build && npm version patch",
+    pub: "npm run patch && npm publish --access public",
+    "test-pack": "npm run patch && npm publish --access public",
+    dev: "nodemon --exec tsx src/test/index.ts"
+  },
+  license: "MIT",
+  dependencies: {
+    "@spatulox/discord-interaction-manager": "^1.0.8",
+    "discord.js": "^14.25.1"
+  },
+  devDependencies: {
+    "@types/node": "^22.14.0",
+    "@types/node-schedule": "^2.1.7",
+    dotenv: "^17.2.4",
+    nodemon: "^3.1.9",
+    tsup: "^8.5.1",
+    tsx: "^4.20.3",
+    typescript: "^5.9.3"
+  },
+  keywords: [
+    "discord",
+    "framework",
+    "bot",
+    "client",
+    "discordjs",
+    "discord.js",
+    "node"
+  ],
+  bugs: {
+    url: "https://github.com/Spatulox/SimpleDiscordBot/issues"
+  }
+};
+
+// src/SimpleDiscordBotInfo.ts
+var SimpleDiscordBotInfo = {
+  name: package_default.name,
+  version: package_default.license,
+  author: package_default.author,
+  description: package_default.description,
+  license: package_default.license
+};
+export {
+  Bot,
+  BotEnv,
+  DiscordRegex,
+  EmbedColor,
+  EmbedManager,
+  FileManager,
+  GuildManager,
+  Log,
+  ModalManager,
+  ReactionManager,
+  SelectMenuManager,
+  SimpleDiscordBotInfo,
+  SimpleMutex,
+  Time,
+  UserManager,
+  WebhookManager
+};