@impulsedev/chameleon 1.7.0 → 3.0.0

package/dist/index.js

@@ -1,3 +1,40 @@
+import {
+  ActionRowBuilder,
+  ButtonBuilder,
+  ButtonStyle,
+  Colors,
+  ComponentType,
+  EmbedBuilder,
+  ModalBuilder,
+  SelectMenuBuilder,
+  TextInputBuilder,
+  buildAutoModRule,
+  buildChannel,
+  buildEmoji,
+  buildEntitlement,
+  buildGuild,
+  buildIntegration,
+  buildInteraction,
+  buildInvite,
+  buildMember,
+  buildMessage,
+  buildRole,
+  buildScheduledEvent,
+  buildStageInstance,
+  buildSticker,
+  buildStickerItem,
+  buildUser,
+  buildVoiceState,
+  buildWebhook,
+  resolveChannel,
+  resolveGuild,
+  resolveRole,
+  resolveUser,
+  serializeComponent,
+  toCamelCase,
+  toSnakeCase
+} from "./chunk-G4SUOXGV.js";
+
 // src/types/user/index.ts
 var UserFlag = {
   STAFF: 1 << 0,
@@ -462,26 +499,6 @@ var AutoModerationActionType = {
   BLOCK_MEMBER_INTERACTION: 4
 };
 
-// src/types/components/index.ts
-var ComponentType = {
-  ACTION_ROW: 1,
-  BUTTON: 2,
-  STRING_SELECT: 3,
-  TEXT_INPUT: 4,
-  USER_SELECT: 5,
-  ROLE_SELECT: 6,
-  MENTIONABLE_SELECT: 7,
-  CHANNEL_SELECT: 8
-};
-var ButtonStyle = {
-  PRIMARY: 1,
-  SECONDARY: 2,
-  SUCCESS: 3,
-  DANGER: 4,
-  LINK: 5,
-  PREMIUM: 6
-};
-
 // src/types/entitlement/index.ts
 var EntitlementType = {
   PURCHASE: 1,
@@ -588,49 +605,97 @@ var WebhookType = {
   APPLICATION: 3
 };
 
+// src/utils/collection.ts
+var Collection = class _Collection extends Map {
+  first() {
+    return this.values().next().value;
+  }
+  last() {
+    const arr = Array.from(this.values());
+    return arr[arr.length - 1];
+  }
+  random() {
+    const arr = Array.from(this.values());
+    return arr[Math.floor(Math.random() * arr.length)];
+  }
+  find(fn) {
+    for (const [key, val] of this) {
+      if (fn(val, key, this)) return val;
+    }
+    return void 0;
+  }
+  filter(fn) {
+    const results = new _Collection();
+    for (const [key, val] of this) {
+      if (fn(val, key, this)) results.set(key, val);
+    }
+    return results;
+  }
+  map(fn) {
+    const results = [];
+    for (const [key, val] of this) {
+      results.push(fn(val, key, this));
+    }
+    return results;
+  }
+  some(fn) {
+    for (const [key, val] of this) {
+      if (fn(val, key, this)) return true;
+    }
+    return false;
+  }
+  every(fn) {
+    for (const [key, val] of this) {
+      if (!fn(val, key, this)) return false;
+    }
+    return true;
+  }
+  reduce(fn, initialValue) {
+    let accumulator;
+    let init = false;
+    if (initialValue !== void 0) {
+      accumulator = initialValue;
+      init = true;
+    }
+    for (const [key, val] of this) {
+      if (!init) {
+        accumulator = val;
+        init = true;
+      } else {
+        accumulator = fn(accumulator, val, key, this);
+      }
+    }
+    return accumulator;
+  }
+  toArray() {
+    return Array.from(this.values());
+  }
+};
+
 // src/utils/tongue.ts
-var Tongue = class {
-  map;
+var Tongue = class extends Collection {
   max;
   constructor(maxSize = Infinity) {
-    this.map = /* @__PURE__ */ new Map();
+    super();
     this.max = maxSize;
   }
   get(key) {
-    if (!this.map.has(key)) return void 0;
-    const val = this.map.get(key);
-    this.map.delete(key);
-    this.map.set(key, val);
+    if (!super.has(key)) return void 0;
+    const val = super.get(key);
+    super.delete(key);
+    super.set(key, val);
     return val;
   }
   set(key, val) {
-    if (this.map.has(key)) {
-      this.map.delete(key);
-    } else if (this.map.size >= this.max) {
-      const firstKey = this.map.keys().next().value;
-      if (firstKey !== void 0) this.map.delete(firstKey);
+    if (super.has(key)) {
+      super.delete(key);
+    } else if (this.size >= this.max) {
+      const firstKey = this.keys().next().value;
+      if (firstKey !== void 0) super.delete(firstKey);
     }
-    this.map.set(key, val);
+    super.set(key, val);
     return this;
   }
-  has(key) {
-    return this.map.has(key);
-  }
-  delete(key) {
-    return this.map.delete(key);
-  }
-  clear() {
-    this.map.clear();
-  }
-  get size() {
-    return this.map.size;
-  }
-  values() {
-    return this.map.values();
-  }
-  keys() {
-    return this.map.keys();
-  }
 };
 
 // src/client/store.ts
@@ -647,19 +712,21 @@ var TongueStore = class {
   scheduledEvents;
   autoModRules;
   integrations;
+  voiceStates;
   constructor(options) {
-    this.guilds = new Tongue(options?.guilds ?? Infinity);
-    this.roles = new Tongue(options?.roles ?? Infinity);
-    this.channels = new Tongue(options?.channels ?? Infinity);
+    this.guilds = new Tongue(options?.guilds ?? 100);
+    this.roles = new Tongue(options?.roles ?? 5e3);
+    this.channels = new Tongue(options?.channels ?? 5e3);
     this.members = new Tongue(options?.members ?? 1e3);
     this.messages = new Tongue(options?.messages ?? 100);
-    this.users = new Tongue(options?.users ?? Infinity);
-    this.emojis = new Tongue(options?.emojis ?? Infinity);
-    this.stickers = new Tongue(options?.stickers ?? Infinity);
-    this.stageInstances = new Tongue(options?.stageInstances ?? Infinity);
-    this.scheduledEvents = new Tongue(options?.scheduledEvents ?? Infinity);
-    this.autoModRules = new Tongue(options?.autoModRules ?? Infinity);
-    this.integrations = new Tongue(options?.integrations ?? Infinity);
+    this.users = new Tongue(options?.users ?? 1e4);
+    this.emojis = new Tongue(options?.emojis ?? 5e3);
+    this.stickers = new Tongue(options?.stickers ?? 5e3);
+    this.stageInstances = new Tongue(options?.stageInstances ?? 1e3);
+    this.scheduledEvents = new Tongue(options?.scheduledEvents ?? 1e3);
+    this.autoModRules = new Tongue(options?.autoModRules ?? 1e3);
+    this.integrations = new Tongue(options?.integrations ?? 1e3);
+    this.voiceStates = new Tongue(options?.voiceStates ?? 5e3);
   }
   static memberKey(guildId, userId) {
     return `${guildId}_${userId}`;
@@ -681,7 +748,7 @@ var Bucket = class {
   resetTimestamp = 0;
   promiseQueue = Promise.resolve();
   async queue(fn) {
-    return new Promise((resolve2, reject) => {
+    return new Promise((resolve4, reject) => {
       this.promiseQueue = this.promiseQueue.then(async () => {
         while (true) {
           if (this.remaining <= 0 && Date.now() < this.resetTimestamp) {
@@ -690,7 +757,7 @@ var Bucket = class {
           this.remaining--;
           try {
             const res = await fn();
-            resolve2(res);
+            resolve4(res);
             break;
           } catch (e) {
             if (e instanceof RateLimitError) {
@@ -710,13 +777,13 @@ var RateLimiter = class {
   routeToBucket = /* @__PURE__ */ new Map();
   buckets = /* @__PURE__ */ new Map();
   getRoute(method, endpoint) {
-    const path2 = endpoint.replace(/\/([a-z-]+)\/(?:[0-9]{17,19})/g, (match, p1) => {
+    const path4 = endpoint.replace(/\/([a-z-]+)\/(?:[0-9]{17,19})/g, (match, p1) => {
       if (["channels", "guilds", "webhooks"].includes(p1)) {
         return match;
       }
       return `/${p1}/:id`;
     });
-    const reactionRoute = path2.replace(/\/reactions\/[^/]+\/?(@me|[0-9]{17,19})?/g, "/reactions/:emoji/:id");
+    const reactionRoute = path4.replace(/\/reactions\/[^/]+\/?(@me|[0-9]{17,19})?/g, "/reactions/:emoji/:id");
     return `${method} ${reactionRoute}`;
   }
   async execute(method, endpoint, requestFn) {
@@ -783,8 +850,8 @@ var ChameleonREST = class {
    * Internal generic request handler that doesn't throw, returning `{ ok: boolean, ... }` shape
    */
   async request(method, endpoint, body, headers) {
-    const path2 = endpoint.startsWith("/") ? endpoint : `/${endpoint}`;
-    const url = `${this.baseUrl}${path2}`;
+    const path4 = endpoint.startsWith("/") ? endpoint : `/${endpoint}`;
+    const url = `${this.baseUrl}${path4}`;
     const reqHeaders = {
       "Authorization": `Bot ${this.token}`,
       "User-Agent": "Chameleon (https://github.com/impulsedoes/chameleon)",
@@ -796,7 +863,7 @@ var ChameleonREST = class {
       reqBody = JSON.stringify(body);
     }
     try {
-      const response = await this.limiter.execute(method, path2, () => fetch(url, {
+      const response = await this.limiter.execute(method, path4, () => fetch(url, {
         method,
         headers: reqHeaders,
         ...reqBody !== void 0 ? { body: reqBody } : {}
@@ -846,6 +913,62 @@ var ChameleonREST = class {
   delete(endpoint, headers) {
     return this.request("DELETE", endpoint, void 0, headers);
   }
+  async requestWithFiles(method, endpoint, body, files, headers) {
+    const routePath = endpoint.startsWith("/") ? endpoint : `/${endpoint}`;
+    const url = `${this.baseUrl}${routePath}`;
+    const reqHeaders = {
+      "Authorization": `Bot ${this.token}`,
+      "User-Agent": "Chameleon (https://github.com/impulsedoes/chameleon)",
+      ...headers
+    };
+    const formData = new FormData();
+    const jsonPayload = {
+      ...body ?? {},
+      attachments: files.map((f, i) => f.toAttachmentJSON(i))
+    };
+    formData.append("payload_json", JSON.stringify(jsonPayload));
+    for (let i = 0; i < files.length; i++) {
+      const file = files[i];
+      const uint8 = file.data instanceof Uint8Array ? file.data : new Uint8Array(file.data);
+      const blob = new Blob([uint8], { type: file.contentType ?? "application/octet-stream" });
+      formData.append(`files[${i}]`, blob, file.name);
+    }
+    try {
+      const response = await this.limiter.execute(method, routePath, () => fetch(url, {
+        method,
+        headers: reqHeaders,
+        body: formData
+      }));
+      let data = null;
+      if (response.status !== 204) {
+        const text = await response.text();
+        if (text) {
+          try {
+            data = JSON.parse(text);
+          } catch {
+            data = text;
+          }
+        }
+      }
+      if (response.ok) {
+        return { ok: true, data };
+      }
+      const errData = data;
+      return {
+        ok: false,
+        status: response.status,
+        ...typeof errData?.code === "number" ? { code: errData.code } : {},
+        message: typeof errData?.message === "string" ? errData.message : response.statusText,
+        raw: data
+      };
+    } catch (error) {
+      return {
+        ok: false,
+        status: 0,
+        message: error instanceof Error ? error.message : "Unknown network error"
+      };
+    }
+  }
 };
 
 // src/gateway/index.ts
@@ -1215,7 +1338,7 @@ var ChameleonGateway = class {
 // package.json
 var package_default = {
   name: "@impulsedev/chameleon",
-  version: "1.7.0",
+  version: "2.0.0",
   description: "highly optimized, memory-efficient, and fully type-safe Discord API library",
   main: "dist/index.js",
   types: "dist/index.d.ts",
@@ -1290,1541 +1413,2042 @@ var MESSAGE_FLAGS = {
 var CHAMELEON_VERSION = package_default.version;
 var CHAMELEON = package_default.name;
 
-// src/builders/embed.ts
-var Colors = {
-  Blue: 2003199,
-  Purple: 10181046,
-  Orange: 16744272,
-  Pink: 16739201,
-  White: 16777215,
-  Blurple: 5793266,
-  Green: 5763719,
-  Yellow: 16705372,
-  Fuchsia: 15418782,
-  Red: 15548997,
-  Black: 2303786,
-  Transparent: 3092790
-};
-var EmbedBuilder = class {
-  data = {};
-  constructor(data) {
-    if (data) Object.assign(this.data, data);
-  }
-  setTitle(title) {
-    this.data.title = title;
-    return this;
-  }
-  setDescription(description) {
-    this.data.description = description;
-    return this;
-  }
-  setColor(color) {
-    this.data.color = color;
-    return this;
+// src/commands/options.ts
+var opt = {
+  string: (description, options) => ({
+    type: "string",
+    description,
+    required: options?.required ?? false,
+    ...options
+  }),
+  integer: (description, options) => ({
+    type: "integer",
+    description,
+    required: options?.required ?? false,
+    ...options
+  }),
+  number: (description, options) => ({
+    type: "number",
+    description,
+    required: options?.required ?? false,
+    ...options
+  }),
+  boolean: (description, options) => ({
+    type: "boolean",
+    description,
+    required: options?.required ?? false
+  }),
+  user: (description, options) => ({
+    type: "user",
+    description,
+    required: options?.required ?? false
+  }),
+  channel: (description, options) => ({
+    type: "channel",
+    description,
+    required: options?.required ?? false
+  }),
+  role: (description, options) => ({
+    type: "role",
+    description,
+    required: options?.required ?? false
+  })
+};
+
+// src/commands/context.ts
+var BaseInteractionContext = class {
+  user;
+  guild;
+  channel;
+  interactionId;
+  interactionToken;
+  _client;
+  _deferred = false;
+  _replied = false;
+  constructor(client, raw, user, guild, channel) {
+    this._client = client;
+    this.interactionId = raw.id;
+    this.interactionToken = raw.token;
+    this.user = user;
+    this.guild = guild;
+    this.channel = channel;
   }
-  setURL(url) {
-    this.data.url = url;
-    return this;
+  get replied() {
+    return this._replied;
   }
-  setTimestamp(ts = Date.now()) {
-    this.data.timestamp = ts instanceof Date ? ts.getTime() : ts;
-    return this;
+  get deferred() {
+    return this._deferred;
   }
-  setFooter(text, iconUrl) {
-    this.data.footer = {
-      text,
-      ...iconUrl ? { iconUrl } : {}
-    };
-    return this;
+  _resolvePayload(payload) {
+    const data = typeof payload === "string" ? { content: payload } : { ...payload };
+    if (typeof payload === "object") {
+      if (payload.ephemeral) data.flags = MESSAGE_FLAGS.EPHEMERAL;
+      if (payload.embeds) {
+        data.embeds = payload.embeds.map((e) => {
+          if (e && typeof e.toJSON === "function") {
+            return e.toJSON();
+          }
+          return e;
+        });
+      }
+      if (payload.components) {
+        data.components = payload.components.map((c) => serializeComponent(c));
+      }
+    }
+    return data;
   }
-  setAuthor(name, iconUrl, url) {
-    this.data.author = {
-      name,
-      ...iconUrl ? { iconUrl } : {},
-      ...url ? { url } : {}
-    };
-    return this;
+  async reply(payload) {
+    if (this._replied || this._deferred) throw new Error("Interaction already acknowledged.");
+    const data = this._resolvePayload(payload);
+    await this._client.rest.post(`/interactions/${this.interactionId}/${this.interactionToken}/callback`, {
+      type: 4 /* CHANNEL_MESSAGE_WITH_SOURCE */,
+      data
+    });
+    this._replied = true;
   }
-  setImage(url) {
-    this.data.image = { url };
-    return this;
+  async defer(options) {
+    if (this._replied || this._deferred) throw new Error("Interaction already acknowledged.");
+    await this._client.rest.post(`/interactions/${this.interactionId}/${this.interactionToken}/callback`, {
+      type: 5 /* DEFERRED_CHANNEL_MESSAGE_WITH_SOURCE */,
+      data: { flags: options?.ephemeral ? MESSAGE_FLAGS.EPHEMERAL : 0 }
+    });
+    this._deferred = true;
   }
-  setThumbnail(url) {
-    this.data.thumbnail = { url };
-    return this;
+  async followUp(payload) {
+    if (!this._deferred && !this._replied) throw new Error("Interaction not acknowledged.");
+    const data = this._resolvePayload(payload);
+    await this._client.rest.post(`/webhooks/${this._client.user?.id}/${this.interactionToken}`, data);
   }
-  addField(name, value, inline = false) {
-    if (!this.data.fields) this.data.fields = [];
-    this.data.fields.push({ name, value, inline });
-    return this;
+  async showModal(modal) {
+    if (this._replied || this._deferred) throw new Error("Interaction already acknowledged.");
+    const payload = modal.type === "modal" ? {
+      custom_id: modal.customId,
+      title: modal.title,
+      components: Array.isArray(modal.fields) ? modal.fields.map((f) => ({
+        type: 1 /* ACTION_ROW */,
+        components: [{
+          type: 4 /* TEXT_INPUT */,
+          custom_id: f.id,
+          style: f.type,
+          label: f.label,
+          required: f.required,
+          min_length: f.minLength,
+          max_length: f.maxLength,
+          placeholder: f.placeholder,
+          value: f.value
+        }]
+      })) : []
+    } : modal;
+    await this._client.rest.post(`/interactions/${this.interactionId}/${this.interactionToken}/callback`, {
+      type: 9 /* MODAL */,
+      data: payload
+    });
+    this._replied = true;
   }
-  addFields(...fields) {
-    if (!this.data.fields) this.data.fields = [];
-    this.data.fields.push(...fields);
-    return this;
+};
+var CommandContext = class extends BaseInteractionContext {
+  options;
+  constructor(client, rawInteraction, parsedOptions, user, guild, channel) {
+    super(client, rawInteraction, user, guild, channel);
+    this.options = parsedOptions;
   }
-  build() {
-    return this.data;
+};
+
+// src/commands/command.ts
+function defineSubcommand(def) {
+  return def;
+}
+function defineCommand(def) {
+  if (!def.execute && (!def.subcommands || Object.keys(def.subcommands).length === 0)) {
+    throw new Error(`Command ${def.name} must have an execute function or subcommands.`);
   }
-  toJSON() {
-    const e = this.data;
-    const payload = {};
-    if (typeof e.title === "string") payload.title = e.title;
-    if (typeof e.description === "string") payload.description = e.description;
-    if (typeof e.color === "number") payload.color = e.color;
-    if (typeof e.url === "string") payload.url = e.url;
-    if (typeof e.timestamp === "number" && !Number.isNaN(e.timestamp)) {
-      payload.timestamp = new Date(e.timestamp).toISOString();
-    }
-    if (e.author) {
-      const author = {
-        name: e.author.name
-      };
-      if (typeof e.author.url === "string") {
-        author.url = e.author.url;
-      }
-      if (typeof e.author.iconUrl === "string") {
-        author.icon_url = e.author.iconUrl;
-      }
-      if (typeof e.author.proxyIconUrl === "string") {
-        author.proxy_icon_url = e.author.proxyIconUrl;
-      }
-      payload.author = author;
-    }
-    if (e.footer) {
-      const footer = {
-        text: e.footer.text
-      };
-      if (typeof e.footer.iconUrl === "string") {
-        footer.icon_url = e.footer.iconUrl;
-      }
-      if (typeof e.footer.proxyIconUrl === "string") {
-        footer.proxy_icon_url = e.footer.proxyIconUrl;
+  return def;
+}
+
+// src/commands/interactions.ts
+var ModalContext = class extends BaseInteractionContext {
+  customId;
+  _fields = /* @__PURE__ */ new Map();
+  constructor(client, raw, user, guild, channel) {
+    super(client, raw, user, guild, channel);
+    this.customId = raw.data?.custom_id ?? "";
+    const rows = raw.data?.components ?? [];
+    for (const row of rows) {
+      for (const comp of row.components ?? []) {
+        if (comp.custom_id && comp.value !== void 0) {
+          this._fields.set(comp.custom_id, comp.value);
+        }
       }
-      payload.footer = footer;
-    }
-    if (e.image?.url) {
-      payload.image = {
-        url: e.image.url
-      };
-    }
-    if (e.thumbnail?.url) {
-      payload.thumbnail = {
-        url: e.thumbnail.url
-      };
     }
-    if (Array.isArray(e.fields) && e.fields.length > 0) {
-      payload.fields = e.fields.map((f) => ({
-        name: f.name,
-        value: f.value,
-        inline: !!f.inline
-      }));
-    }
-    return payload;
+  }
+  // Get a text input value by its customId
+  // values from a select menu interaction
+  get values() {
+    return this._values ?? [];
+  }
+  // Get all field values as a plain object
+  get fields() {
+    return Object.fromEntries(this._fields);
   }
 };
 
-// src/builders/components.ts
-function serializeEmoji(emoji) {
-  if (!emoji) return void 0;
-  return {
-    id: emoji.id,
-    name: emoji.name,
-    animated: emoji.animated
-  };
-}
-var ButtonBuilder = class {
-  data = {
-    type: ComponentType.BUTTON
-  };
-  setCustomId(id) {
-    this.data.customId = id;
-    return this;
-  }
-  setLabel(label) {
-    this.data.label = label;
-    return this;
-  }
-  setStyle(style) {
-    this.data.style = style;
-    return this;
-  }
-  setEmoji(emoji) {
-    this.data.emoji = emoji;
-    return this;
-  }
-  setDisabled(disabled = true) {
-    this.data.disabled = disabled;
-    return this;
-  }
-  setURL(url) {
-    this.data.url = url;
-    this.data.style = ButtonStyle.LINK;
-    return this;
-  }
-  build() {
-    return {
-      ...this.data
-    };
-  }
-  toJSON() {
-    return {
-      type: ComponentType.BUTTON,
-      custom_id: this.data.customId,
-      label: this.data.label,
-      style: this.data.style,
-      disabled: this.data.disabled,
-      url: this.data.url,
-      emoji: serializeEmoji(this.data.emoji)
-    };
-  }
-};
-var SelectMenuBuilder = class {
-  data = {
-    type: ComponentType.STRING_SELECT
-  };
-  setCustomId(id) {
-    this.data.customId = id;
-    return this;
-  }
-  setPlaceholder(placeholder) {
-    this.data.placeholder = placeholder;
-    return this;
-  }
-  setMinValues(min) {
-    this.data.minValues = min;
-    return this;
-  }
-  setMaxValues(max) {
-    this.data.maxValues = max;
-    return this;
-  }
-  setDisabled(disabled = true) {
-    this.data.disabled = disabled;
-    return this;
-  }
-  setType(type) {
-    this.data.type = type;
-    return this;
-  }
-  addOption(option) {
-    if (!this.data.options) {
-      this.data.options = [];
+// src/components/context.ts
+var ComponentContext = class extends BaseInteractionContext {
+  customId;
+  message;
+  values;
+  fields;
+  constructor(client, raw, user, guild, channel) {
+    super(client, raw, user, guild, channel);
+    const data = raw.data;
+    this.customId = data?.custom_id ?? "";
+    if (raw.message) {
+      this.message = raw.message;
     }
-    this.data.options.push(option);
-    return this;
-  }
-  addOptions(...options) {
-    if (!this.data.options) {
-      this.data.options = [];
+    this.values = data?.values ?? [];
+    const fields = {};
+    if (data?.components) {
+      for (const row of data.components) {
+        for (const comp of row.components) {
+          fields[comp.custom_id] = comp.value;
+        }
+      }
     }
-    this.data.options.push(...options);
-    return this;
+    this.fields = fields;
   }
-  build() {
-    return {
-      ...this.data
-    };
+  async deferUpdate() {
+    if (this._replied || this._deferred) throw new Error("Interaction already acknowledged.");
+    await this._client.rest.post(`/interactions/${this.interactionId}/${this.interactionToken}/callback`, {
+      type: 6 /* DEFERRED_UPDATE_MESSAGE */
+    });
+    this._deferred = true;
   }
-  toJSON() {
-    return {
-      type: this.data.type ?? ComponentType.STRING_SELECT,
-      custom_id: this.data.customId,
-      placeholder: this.data.placeholder,
-      min_values: this.data.minValues,
-      max_values: this.data.maxValues,
-      disabled: this.data.disabled,
-      options: this.data.options?.map((option) => ({
-        label: option.label,
-        value: option.value,
-        description: option.description,
-        emoji: serializeEmoji(option.emoji),
-        default: option.default
-      }))
-    };
+  async update(payload) {
+    if (this._replied || this._deferred) throw new Error("Interaction already acknowledged.");
+    const data = this._resolvePayload(payload);
+    await this._client.rest.post(`/interactions/${this.interactionId}/${this.interactionToken}/callback`, {
+      type: 7 /* UPDATE_MESSAGE */,
+      data
+    });
+    this._replied = true;
   }
 };
-var TextInputBuilder = class {
-  data = {
-    type: ComponentType.TEXT_INPUT
-  };
-  _minLength;
-  _maxLength;
-  _required;
-  _value;
-  setCustomId(id) {
-    this.data.customId = id;
-    return this;
-  }
-  setLabel(label) {
-    this.data.label = label;
-    return this;
-  }
-  setStyle(style) {
-    this.data.style = style;
-    return this;
-  }
-  setPlaceholder(placeholder) {
-    this.data.placeholder = placeholder;
-    return this;
-  }
-  setMinLength(length) {
-    this._minLength = length;
-    return this;
-  }
-  setMaxLength(length) {
-    this._maxLength = length;
-    return this;
+
+// src/commands/manager.ts
+import * as fs from "fs";
+import * as path from "path";
+var CommandManager = class {
+  _commands = /* @__PURE__ */ new Map();
+  _components = [];
+  _modals = [];
+  _client;
+  constructor(client) {
+    this._client = client;
   }
-  setRequired(required = true) {
-    this._required = required;
-    return this;
+  register(...commands) {
+    for (const cmd of commands) {
+      this._commands.set(cmd.name, cmd);
+    }
+    this._deployCommands(commands).catch(console.error);
   }
-  setValue(value) {
-    this._value = value;
-    return this;
+  registerGuild(guildId, ...commands) {
+    for (const cmd of commands) {
+      this._commands.set(cmd.name, cmd);
+    }
+    this._deployCommands(commands, guildId).catch(console.error);
   }
-  build() {
-    return {
-      ...this.data,
-      minLength: this._minLength,
-      maxLength: this._maxLength,
-      required: this._required,
-      value: this._value
-    };
+  registerComponent(handler) {
+    this._components.push(handler);
   }
-  toJSON() {
-    return {
-      type: ComponentType.TEXT_INPUT,
-      custom_id: this.data.customId,
-      style: this.data.style,
-      label: this.data.label,
-      placeholder: this.data.placeholder,
-      min_length: this._minLength,
-      max_length: this._maxLength,
-      required: this._required,
-      value: this._value
-    };
+  registerModal(handler) {
+    this._modals.push(handler);
   }
-};
-var ActionRowBuilder = class {
-  data = {
-    type: ComponentType.ACTION_ROW,
-    components: []
-  };
-  addComponent(component) {
-    this.data.components.push(component);
-    return this;
+  async load(directory) {
+    const fullPath = path.resolve(process.cwd(), directory);
+    if (!fs.existsSync(fullPath)) {
+      console.error(`[Chameleon] Command directory ${directory} does not exist.`);
+      return;
+    }
+    const files = fs.readdirSync(fullPath).filter((f) => f.endsWith(".js") || f.endsWith(".ts"));
+    const commands = [];
+    for (const file of files) {
+      const filePath = path.join(fullPath, file);
+      try {
+        const module = await import(`file://${filePath}`);
+        const command = module.default;
+        if (command && typeof command.name === "string") {
+          commands.push(command);
+        }
+      } catch (err) {
+        console.error(`[Chameleon] Failed to load command from ${file}:`, err);
+      }
+    }
+    if (commands.length > 0) {
+      this.register(...commands);
+    }
   }
-  addComponents(...components) {
-    for (const component of components) {
-      this.addComponent(component);
+  async _deployCommands(commands, guildId) {
+    const payload = commands.map((c) => this._transformCommand(c));
+    if (this._client.user?.id) {
+      const url = guildId ? `/applications/${this._client.user.id}/guilds/${guildId}/commands` : `/applications/${this._client.user.id}/commands`;
+      await this._client.rest.put(url, payload);
+    } else {
+      this._client.on("READY", async () => {
+        const url = guildId ? `/applications/${this._client.user.id}/guilds/${guildId}/commands` : `/applications/${this._client.user.id}/commands`;
+        await this._client.rest.put(url, payload);
+      });
     }
-    return this;
   }
-  build() {
-    return {
-      ...this.data,
-      components: [...this.data.components]
+  _transformCommand(cmd) {
+    const mapType = (t) => {
+      switch (t) {
+        case "string":
+          return 3;
+        case "integer":
+          return 4;
+        case "boolean":
+          return 5;
+        case "user":
+          return 6;
+        case "channel":
+          return 7;
+        case "role":
+          return 8;
+        case "number":
+          return 10;
+        default:
+          return 3;
+      }
     };
-  }
-  toJSON() {
-    return {
-      type: ComponentType.ACTION_ROW,
-      components: this.data.components?.map((component) => {
-        if (component && typeof component.toJSON === "function") {
-          return component.toJSON();
+    const options = [];
+    if (cmd.subcommands) {
+      for (const [subName, subDef] of Object.entries(cmd.subcommands)) {
+        const subOpts = [];
+        if (subDef.options) {
+          for (const [optName, optDefRaw] of Object.entries(subDef.options)) {
+            const optDef = optDefRaw;
+            subOpts.push({
+              type: mapType(optDef.type),
+              name: optName,
+              description: optDef.description,
+              required: optDef.required,
+              choices: optDef.choices,
+              min_value: optDef.min,
+              max_value: optDef.max
+            });
+          }
         }
-        return component;
-      })
-    };
-  }
-};
-var ModalBuilder = class {
-  _title = "";
-  _customId = "";
-  _components = [];
-  setTitle(title) {
-    this._title = title;
-    return this;
-  }
-  setCustomId(id) {
-    this._customId = id;
-    return this;
-  }
-  addComponent(component) {
-    this._components.push(component);
-    return this;
-  }
-  addComponents(...components) {
-    for (const component of components) {
-      this.addComponent(component);
+        options.push({
+          type: 1 /* SUB_COMMAND */,
+          name: subName,
+          description: subDef.description,
+          options: subOpts
+        });
+      }
+    } else if (cmd.options) {
+      for (const [optName, optDefRaw] of Object.entries(cmd.options)) {
+        const optDef = optDefRaw;
+        options.push({
+          type: mapType(optDef.type),
+          name: optName,
+          description: optDef.description,
+          required: optDef.required,
+          choices: optDef.choices,
+          min_value: optDef.min,
+          max_value: optDef.max
+        });
+      }
     }
-    return this;
-  }
-  build() {
     return {
-      title: this._title,
-      custom_id: this._customId,
-      components: [...this._components]
+      name: cmd.name,
+      description: cmd.description,
+      options: options.length ? options : void 0
     };
   }
-  toJSON() {
-    return {
-      title: this._title,
-      custom_id: this._customId,
-      components: this._components.map((component) => {
-        if (component && typeof component.toJSON === "function") {
-          return component.toJSON();
-        }
-        return component;
-      })
-    };
+  async handleInteraction(raw) {
+    const data = raw.data;
+    if (!data) return;
+    if (raw.type === 3 /* MESSAGE_COMPONENT */) return this._handleComponentInteraction(raw, data);
+    if (raw.type === 5 /* MODAL_SUBMIT */) return this._handleModalInteraction(raw, data);
+    if (raw.type !== 2 /* APPLICATION_COMMAND */) return;
+    const name = data.name;
+    if (!name) return;
+    const command = this._commands.get(name);
+    if (!command) return;
+    const parsedOptions = {};
+    let targetExecute = command.execute;
+    const rawOptions = data.options || [];
+    let actualOptions = rawOptions;
+    if (rawOptions.length > 0 && rawOptions[0].type === 1 /* SUB_COMMAND */) {
+      const subcommandName = rawOptions[0].name;
+      actualOptions = rawOptions[0].options || [];
+      if (command.subcommands && command.subcommands[subcommandName]) {
+        targetExecute = command.subcommands[subcommandName].execute;
+      }
+    }
+    for (const opt2 of actualOptions) {
+      if (opt2.type === 6 /* USER */ && data.resolved?.users?.[opt2.value]) {
+        parsedOptions[opt2.name] = resolveUser(opt2.value, this._client);
+      } else if (opt2.type === 7 /* CHANNEL */ && data.resolved?.channels?.[opt2.value]) {
+        parsedOptions[opt2.name] = resolveChannel(opt2.value, this._client);
+      } else if (opt2.type === 8 /* ROLE */ && data.resolved?.roles?.[opt2.value]) {
+        parsedOptions[opt2.name] = resolveRole(opt2.value, this._client, raw.guild_id);
+      } else {
+        parsedOptions[opt2.name] = opt2.value;
+      }
+    }
+    const member = raw.member;
+    const userRaw = member?.user ?? raw.user;
+    const user = buildUser(userRaw);
+    const ctx = new CommandContext(
+      this._client,
+      raw,
+      parsedOptions,
+      user,
+      raw.guild_id ? resolveGuild(raw.guild_id, this._client) : void 0,
+      raw.channel_id ? resolveChannel(raw.channel_id, this._client) : void 0
+    );
+    if (targetExecute) {
+      try {
+        await targetExecute(ctx);
+      } catch (err) {
+        console.error(`[Chameleon] Error executing command ${name}:`, err);
+      }
+    }
   }
-};
+  async _handleComponentInteraction(raw, data) {
+    const customId = data.custom_id;
+    const handler = this._components.find((h) => {
+      if (!h.customId) return false;
+      return typeof h.customId === "string" ? h.customId === customId : h.customId.test(customId);
+    });
+    if (!handler) return;
+    const member = raw.member;
+    const userRaw = member?.user ?? raw.user;
+    const user = buildUser(userRaw);
+    const ctx = new ComponentContext(
+      this._client,
+      raw,
+      user,
+      raw.guild_id ? resolveGuild(raw.guild_id, this._client) : void 0,
+      raw.channel_id ? resolveChannel(raw.channel_id, this._client) : void 0
+    );
+    try {
+      await handler.execute?.(ctx);
+    } catch (err) {
+      console.error(`[Chameleon] Error executing component ${customId}:`, err);
+    }
+  }
+  async _handleModalInteraction(raw, data) {
+    const customId = data.custom_id;
+    const handler = this._modals.find(
+      (h) => typeof h.customId === "string" ? h.customId === customId : h.customId.test(customId)
+    );
+    if (!handler) return;
+    const member = raw.member;
+    const userRaw = member?.user ?? raw.user;
+    const user = buildUser(userRaw);
+    const ctx = new ModalContext(
+      this._client,
+      raw,
+      user,
+      raw.guild_id ? resolveGuild(raw.guild_id, this._client) : void 0,
+      raw.channel_id ? resolveChannel(raw.channel_id, this._client) : void 0
+    );
+    try {
+      await handler.execute?.(ctx);
+    } catch (err) {
+      console.error(`[Chameleon] Error executing modal ${customId}:`, err);
+    }
+  }
+};
 
-// src/builders/index.ts
-function buildUser(raw) {
-  return {
-    id: raw.id,
-    username: raw.username,
-    discriminator: raw.discriminator,
-    globalName: raw.global_name ?? null,
-    avatar: raw.avatar ?? null,
-    bot: raw.bot ?? false,
-    system: raw.system ?? false,
-    mfaEnabled: raw.mfa_enabled ?? false,
-    banner: raw.banner ?? null,
-    accentColor: raw.accent_color ?? null,
-    locale: raw.locale ?? void 0,
-    flags: raw.flags ?? 0,
-    premiumType: raw.premium_type ?? 0,
-    publicFlags: raw.public_flags ?? 0
-  };
-}
-function buildChannel(raw, guildId) {
-  return {
-    id: raw.id,
-    type: raw.type,
-    guildId: raw.guild_id ?? guildId ?? void 0,
-    name: raw.name ?? null,
-    position: raw.position ?? 0,
-    parentId: raw.parent_id ?? null,
-    topic: raw.topic ?? null,
-    nsfw: raw.nsfw ?? false,
-    lastMessageId: raw.last_message_id ?? null,
-    bitrate: raw.bitrate ?? void 0,
-    userLimit: raw.user_limit ?? void 0,
-    rateLimitPerUser: raw.rate_limit_per_user ?? 0,
-    permissionOverwrites: raw.permission_overwrites ?? []
-  };
-}
-function buildGuild(raw) {
-  return {
-    id: raw.id,
-    name: raw.name,
-    icon: raw.icon ?? null,
-    splash: raw.splash ?? null,
-    discoverySplash: raw.discovery_splash ?? null,
-    ownerId: raw.owner_id,
-    afkChannelId: raw.afk_channel_id ?? null,
-    afkTimeout: raw.afk_timeout ?? 0,
-    verificationLevel: raw.verification_level ?? 0,
-    defaultMessageNotifications: raw.default_message_notifications ?? 0,
-    explicitContentFilter: raw.explicit_content_filter ?? 0,
-    features: raw.features ?? [],
-    mfaLevel: raw.mfa_level ?? 0,
-    systemChannelId: raw.system_channel_id ?? null,
-    systemChannelFlags: raw.system_channel_flags ?? 0,
-    rulesChannelId: raw.rules_channel_id ?? null,
-    memberCount: raw.member_count ?? 0,
-    vanityUrlCode: raw.vanity_url_code ?? null,
-    description: raw.description ?? null,
-    banner: raw.banner ?? null,
-    premiumTier: raw.premium_tier ?? 0,
-    premiumSubscriptionCount: raw.premium_subscription_count ?? 0,
-    preferredLocale: raw.preferred_locale ?? "en-US",
-    publicUpdatesChannelId: raw.public_updates_channel_id ?? null,
-    nsfwLevel: raw.nsfw_level ?? 0,
-    premiumProgressBarEnabled: raw.premium_progress_bar_enabled ?? false,
-    roles: Array.isArray(raw.roles) ? raw.roles.map((r) => buildRole(r)) : [],
-    emojis: raw.emojis ?? [],
-    applicationId: raw.application_id ?? null,
-    large: raw.large ?? false
-  };
-}
-function buildRole(raw) {
-  return {
-    id: raw.id,
-    name: raw.name,
-    color: raw.color ?? 0,
-    hoist: raw.hoist ?? false,
-    position: raw.position ?? 0,
-    permissions: raw.permissions,
-    managed: raw.managed ?? false,
-    mentionable: raw.mentionable ?? false,
-    icon: raw.icon ?? null,
-    unicodeEmoji: raw.unicode_emoji ?? null,
-    flags: raw.flags ?? 0
-  };
+// src/components/define.ts
+function resolveButtonStyle(style) {
+  if (typeof style === "number") return style;
+  const map = { primary: 1, secondary: 2, success: 3, danger: 4, link: 5, premium: 6 };
+  return map[style] ?? 1;
 }
-function buildMember(raw, guildId, cache) {
-  let userObj;
-  if (raw.user) {
-    const user = buildUser(raw.user);
-    cache.users.set(user.id, user);
-    userObj = user;
-  }
-  return {
-    ...userObj ? { user: userObj } : {},
-    nick: raw.nick ?? null,
-    avatar: raw.avatar ?? null,
-    roles: raw.roles ?? [],
-    joinedAt: raw.joined_at ? Date.parse(raw.joined_at) : 0,
-    premiumSince: raw.premium_since ? Date.parse(raw.premium_since) : null,
-    deaf: raw.deaf ?? false,
-    mute: raw.mute ?? false,
-    pending: raw.pending ?? false,
-    flags: raw.flags ?? 0,
-    communicationDisabledUntil: raw.communication_disabled_until ? Date.parse(raw.communication_disabled_until) : null
-  };
+function defineButton(def) {
+  return { ...def, type: "button" };
 }
-function buildMessage(raw, cache, oldMessage) {
-  const authorRaw = raw.author;
-  const author = authorRaw ? buildUser(authorRaw) : oldMessage?.author ?? {};
-  if (authorRaw && author.id) {
-    cache.users.set(author.id, author);
-  }
-  const msgId = raw.id ?? oldMessage?.id;
-  const channelId = raw.channel_id ?? oldMessage?.channelId;
-  const guildId = raw.guild_id ? raw.guild_id : oldMessage?.guildId;
-  const msg = {
-    id: msgId,
-    channelId,
-    author,
-    ...guildId ? { guildId } : {},
-    url: `https://discord.com/channels/${guildId ?? "@me"}/${channelId}/${msgId}`,
-    content: raw.content ?? oldMessage?.content ?? "",
-    timestamp: raw.timestamp ? Date.parse(raw.timestamp) : oldMessage?.timestamp ?? Date.now(),
-    editedTimestamp: raw.edited_timestamp ? Date.parse(raw.edited_timestamp) : oldMessage?.editedTimestamp ?? null,
-    tts: raw.tts ?? oldMessage?.tts ?? false,
-    mentionEveryone: raw.mention_everyone ?? oldMessage?.mentionEveryone ?? false,
-    mentions: raw.mentions ? raw.mentions.map((m) => buildUser(m)) : oldMessage?.mentions ?? [],
-    mentionRoles: raw.mention_roles ?? oldMessage?.mentionRoles ?? [],
-    attachments: raw.attachments ?? oldMessage?.attachments ?? [],
-    embeds: raw.embeds ?? oldMessage?.embeds ?? [],
-    pinned: raw.pinned ?? oldMessage?.pinned ?? false,
-    type: raw.type ?? oldMessage?.type ?? 0
-  };
-  return msg;
+function defineStringSelect(def) {
+  return { ...def, type: "string_select" };
 }
-function resolveChannel(channelId, cache) {
-  return cache.channels.get(channelId) ?? { id: channelId };
+function defineUserSelect(def) {
+  return { ...def, type: "user_select" };
 }
-function resolveGuild(guildId, cache) {
-  return cache.guilds.get(guildId) ?? { id: guildId };
+function defineRoleSelect(def) {
+  return { ...def, type: "role_select" };
 }
-function resolveUser(userId, cache) {
-  return cache.users.get(userId) ?? { id: userId };
+function defineChannelSelect(def) {
+  return { ...def, type: "channel_select" };
 }
-function resolveRole(roleId, cache) {
-  return cache.roles.get(roleId) ?? { id: roleId };
+function defineMentionableSelect(def) {
+  return { ...def, type: "mentionable_select" };
 }
-
-// src/commands/options.ts
-var opt = {
-  string: (description, options) => ({
-    type: "string",
-    description,
-    required: options?.required ?? false,
-    ...options
-  }),
-  integer: (description, options) => ({
-    type: "integer",
-    description,
-    required: options?.required ?? false,
+var field = {
+  short: (id, label, options) => ({
+    id,
+    type: 1 /* SHORT */,
+    label,
+    required: options?.required ?? true,
     ...options
   }),
-  number: (description, options) => ({
-    type: "number",
-    description,
-    required: options?.required ?? false,
+  paragraph: (id, label, options) => ({
+    id,
+    type: 2 /* PARAGRAPH */,
+    label,
+    required: options?.required ?? true,
     ...options
-  }),
-  boolean: (description, options) => ({
-    type: "boolean",
-    description,
-    required: options?.required ?? false
-  }),
-  user: (description, options) => ({
-    type: "user",
-    description,
-    required: options?.required ?? false
-  }),
-  channel: (description, options) => ({
-    type: "channel",
-    description,
-    required: options?.required ?? false
-  }),
-  role: (description, options) => ({
-    type: "role",
-    description,
-    required: options?.required ?? false
   })
 };
+function defineModal(def) {
+  return { ...def, type: "modal" };
+}
 
-// src/commands/context.ts
-var CommandContext = class {
-  options;
-  user;
-  guild;
-  channel;
-  interactionId;
-  interactionToken;
-  _client;
-  _deferred = false;
-  _replied = false;
-  constructor(client, rawInteraction, parsedOptions, user, guild, channel) {
-    this._client = client;
-    this.interactionId = rawInteraction.id;
-    this.interactionToken = rawInteraction.token;
-    this.options = parsedOptions;
-    this.user = user;
-    this.guild = guild;
-    this.channel = channel;
-  }
-  get replied() {
-    return this._replied;
-  }
-  get deferred() {
-    return this._deferred;
+// src/components/actionRow.ts
+var ActionRow = {
+  of: (...components) => {
+    return {
+      type: 1 /* ACTION_ROW */,
+      components: components.map((c) => {
+        if ("type" in c && c.type === "button") {
+          const btn = c;
+          return {
+            type: 2 /* BUTTON */,
+            custom_id: btn.customId,
+            url: btn.url,
+            label: btn.label,
+            style: resolveButtonStyle(btn.style),
+            disabled: btn.disabled,
+            emoji: btn.emoji,
+            sku_id: btn.skuId
+          };
+        }
+        if ("type" in c && c.type === "string_select") {
+          const sel = c;
+          return {
+            type: 3 /* STRING_SELECT */,
+            custom_id: sel.customId,
+            options: sel.options,
+            placeholder: sel.placeholder,
+            min_values: sel.minValues,
+            max_values: sel.maxValues,
+            disabled: sel.disabled
+          };
+        }
+        if ("type" in c && c.type === "user_select") {
+          const sel = c;
+          return { type: 5 /* USER_SELECT */, custom_id: sel.customId, placeholder: sel.placeholder, min_values: sel.minValues, max_values: sel.maxValues, disabled: sel.disabled };
+        }
+        if ("type" in c && c.type === "role_select") {
+          const sel = c;
+          return { type: 6 /* ROLE_SELECT */, custom_id: sel.customId, placeholder: sel.placeholder, min_values: sel.minValues, max_values: sel.maxValues, disabled: sel.disabled };
+        }
+        if ("type" in c && c.type === "mentionable_select") {
+          const sel = c;
+          return { type: 7 /* MENTIONABLE_SELECT */, custom_id: sel.customId, placeholder: sel.placeholder, min_values: sel.minValues, max_values: sel.maxValues, disabled: sel.disabled };
+        }
+        if ("type" in c && c.type === "channel_select") {
+          const sel = c;
+          return { type: 8 /* CHANNEL_SELECT */, custom_id: sel.customId, channel_types: sel.channelTypes, placeholder: sel.placeholder, min_values: sel.minValues, max_values: sel.maxValues, disabled: sel.disabled };
+        }
+        if ("type" in c && (c.type === 1 /* SHORT */ || c.type === 2 /* PARAGRAPH */)) {
+          const field2 = c;
+          return {
+            type: 4 /* TEXT_INPUT */,
+            custom_id: field2.id,
+            style: field2.type,
+            label: field2.label,
+            required: field2.required,
+            min_length: field2.minLength,
+            max_length: field2.maxLength,
+            placeholder: field2.placeholder,
+            value: field2.value
+          };
+        }
+        return c;
+      }).map((obj) => {
+        const clean = {};
+        for (const [k, v] of Object.entries(obj)) {
+          if (v !== void 0) clean[k] = v;
+        }
+        return clean;
+      })
+    };
   }
-  async reply(payload) {
-    if (this._replied || this._deferred) throw new Error("Interaction already acknowledged.");
-    const data = typeof payload === "string" ? { content: payload } : { ...payload };
-    if (typeof payload === "object" && payload.ephemeral) data.flags = 64;
-    await this._client.rest.post(`/interactions/${this.interactionId}/${this.interactionToken}/callback`, {
-      type: 4 /* CHANNEL_MESSAGE_WITH_SOURCE */,
-      data
-    });
-    this._replied = true;
+};
+
+// src/components/manager.ts
+var ComponentManager = class {
+  constructor(client) {
+    this.client = client;
   }
-  async defer(options) {
-    if (this._replied || this._deferred) throw new Error("Interaction already acknowledged.");
-    await this._client.rest.post(`/interactions/${this.interactionId}/${this.interactionToken}/callback`, {
-      type: 5 /* DEFERRED_CHANNEL_MESSAGE_WITH_SOURCE */,
-      data: {
-        flags: options?.ephemeral ? 64 : 0
+  client;
+  handlers = /* @__PURE__ */ new Map();
+  register(...components) {
+    for (const comp of components) {
+      if (comp.customId && typeof comp.customId === "string") {
+        this.handlers.set(comp.customId, comp);
       }
-    });
-    this._deferred = true;
-  }
-  async followUp(payload) {
-    if (!this._deferred && !this._replied) throw new Error("Interaction not acknowledged. Use reply or defer first.");
-    const data = typeof payload === "string" ? { content: payload } : { ...payload };
-    if (typeof payload === "object" && payload.ephemeral) data.flags = 64;
-    await this._client.rest.post(`/webhooks/${this._client.user?.id}/${this.interactionToken}`, data);
+    }
   }
-  async showModal(modal) {
-    if (this._replied || this._deferred) throw new Error("Interaction already acknowledged.");
-    const payload = modal.type === "modal" ? {
-      custom_id: modal.customId,
-      title: modal.title,
-      components: modal.fields.map((f) => ({
-        type: 1 /* ACTION_ROW */,
-        components: [{
-          type: 4 /* TEXT_INPUT */,
-          custom_id: f.id,
-          style: f.type,
-          // 1 short, 2 paragraph
-          label: f.label,
-          required: f.required,
-          min_length: f.minLength,
-          max_length: f.maxLength,
-          placeholder: f.placeholder,
-          value: f.value
-        }]
-      }))
-    } : modal;
-    await this._client.rest.post(`/interactions/${this.interactionId}/${this.interactionToken}/callback`, {
-      type: 9 /* MODAL */,
-      data: payload
-    });
-    this._replied = true;
+  async handleInteraction(raw) {
+    const data = raw.data;
+    if (!data) return;
+    const customId = data.custom_id;
+    if (!customId) return;
+    const handler = this.handlers.get(customId);
+    if (!handler || !handler.execute) return;
+    const userRaw = raw.member?.user ?? raw.user;
+    const user = buildUser(userRaw);
+    let guild;
+    if (raw.guild_id) {
+      guild = this.client.cache.guilds.get(raw.guild_id) ?? { id: raw.guild_id };
+    }
+    let channel;
+    if (raw.channel_id) {
+      channel = resolveChannel(raw.channel_id, this.client) ?? { id: raw.channel_id };
+    }
+    const resolved = data.resolved;
+    if (resolved?.members && resolved?.users && raw.guild_id) {
+      for (const [id] of Object.entries(resolved.members)) {
+        const userData = resolved.users[id];
+        if (userData) {
+          const u = buildUser(userData);
+          this.client.cache.users.set(u.id, u);
+        }
+      }
+    }
+    const ctx = new ComponentContext(this.client, raw, user, guild, channel);
+    if (handler.type === "user_select" && resolved?.users) {
+      ctx.values = ctx.values.map((id) => {
+        const uData = resolved.users[id];
+        return uData ? buildUser(uData) : { id };
+      });
+    } else if (handler.type === "channel_select" && resolved?.channels) {
+      ctx.values = ctx.values.map((id) => {
+        const cData = resolved.channels[id];
+        return cData ? buildChannel(cData, raw.guild_id) : { id };
+      });
+    }
+    try {
+      await handler.execute(ctx);
+    } catch (err) {
+      console.error(`[COMPONENTS] Error executing component ${customId}:`, err);
+    }
   }
 };
 
-// src/commands/command.ts
-function defineSubcommand(def) {
-  return def;
-}
-function defineCommand(def) {
-  if (!def.execute && (!def.subcommands || Object.keys(def.subcommands).length === 0)) {
-    throw new Error(`Command ${def.name} must have an execute function or subcommands.`);
-  }
-  return def;
-}
-
-// src/commands/interactions.ts
-var ComponentContext = class {
-  customId;
-  user;
-  guild;
-  channel;
-  message;
-  interactionId;
-  interactionToken;
-  _client;
-  _deferred = false;
-  _replied = false;
-  constructor(client, raw, user, guild, channel) {
-    this._client = client;
-    this.interactionId = raw.id;
-    this.interactionToken = raw.token;
-    this.customId = raw.data?.custom_id ?? "";
-    this.message = raw.message;
-    this.user = user;
-    this.guild = guild;
-    this.channel = channel;
-  }
-  get replied() {
-    return this._replied;
+// src/managers/base.ts
+var BaseManager = class {
+  constructor(rest, store) {
+    this.rest = rest;
+    this.store = store;
   }
-  get deferred() {
-    return this._deferred;
+  rest;
+  store;
+  async fetch(id, force = false) {
+    if (!force) {
+      const tongue2 = this.store[this.storeKey];
+      const cached = tongue2.get(id);
+      if (cached) return { ok: true, data: cached };
+    }
+    const result = await this.rest.get(this.endpoint(id));
+    if (!result.ok) return result;
+    const entity = this.build(result.data);
+    const tongue = this.store[this.storeKey];
+    tongue.set(id, entity);
+    return { ok: true, data: entity };
   }
-  /** Values from a select menu interaction */
-  get values() {
-    return this._values ?? [];
+};
+
+// src/managers/user.ts
+var UserManager = class extends BaseManager {
+  storeKey = "users";
+  endpoint(id) {
+    return `/users/${id}`;
   }
-  async reply(payload) {
-    if (this._replied || this._deferred) throw new Error("Interaction already acknowledged.");
-    const data = typeof payload === "string" ? { content: payload } : { ...payload };
-    if (typeof payload === "object" && payload.ephemeral) data.flags = 64;
-    await this._client.rest.post(`/interactions/${this.interactionId}/${this.interactionToken}/callback`, {
-      type: 4 /* CHANNEL_MESSAGE_WITH_SOURCE */,
-      data
-    });
-    this._replied = true;
+  build = buildUser;
+  async createDM(userId) {
+    const result = await this.rest.post("/users/@me/channels", { recipient_id: userId });
+    if (!result.ok) return result;
+    return { ok: true, data: (await import("./builders-WHD6LQWX.js")).buildChannel(result.data) };
   }
-  async deferUpdate() {
-    if (this._replied || this._deferred) throw new Error("Interaction already acknowledged.");
-    await this._client.rest.post(`/interactions/${this.interactionId}/${this.interactionToken}/callback`, {
-      type: 6 /* DEFERRED_UPDATE_MESSAGE */
-    });
-    this._deferred = true;
+  async editCurrent(payload) {
+    const result = await this.rest.patch("/users/@me", toSnakeCase(payload));
+    if (!result.ok) return result;
+    const user = this.build(result.data);
+    this.store.users.set(user.id, user);
+    return { ok: true, data: user };
   }
-  async update(payload) {
-    if (this._replied || this._deferred) throw new Error("Interaction already acknowledged.");
-    const data = typeof payload === "string" ? { content: payload } : { ...payload };
-    if (typeof payload === "object" && payload.ephemeral) data.flags = 64;
-    await this._client.rest.post(`/interactions/${this.interactionId}/${this.interactionToken}/callback`, {
-      type: 7 /* UPDATE_MESSAGE */,
-      data
-    });
-    this._replied = true;
+};
+
+// src/managers/role.ts
+var RoleManager = class {
+  constructor(rest, store, guildId) {
+    this.rest = rest;
+    this.store = store;
+    this.guildId = guildId;
   }
-  async followUp(payload) {
-    if (!this._deferred && !this._replied) throw new Error("Interaction not acknowledged.");
-    const data = typeof payload === "string" ? { content: payload } : { ...payload };
-    if (typeof payload === "object" && payload.ephemeral) data.flags = 64;
-    await this._client.rest.post(`/webhooks/${this._client.user?.id}/${this.interactionToken}`, data);
+  rest;
+  store;
+  guildId;
+  async fetch(roleId, force = false) {
+    if (!force) {
+      const cached = this.store.roles.get(roleId);
+      if (cached) return { ok: true, data: cached };
+    }
+    const result = await this.rest.get(`/guilds/${this.guildId}/roles`);
+    if (!result.ok) return result;
+    const roles = result.data.map((raw) => buildRole(raw));
+    for (const r of roles) {
+      this.store.roles.set(r.id, r);
+    }
+    const target = roles.find((r) => r.id === roleId);
+    if (target) return { ok: true, data: target };
+    return { ok: false, status: 404, message: "Role not found" };
   }
-};
-var ModalContext = class {
-  customId;
-  user;
-  guild;
-  channel;
-  interactionId;
-  interactionToken;
-  _fields = /* @__PURE__ */ new Map();
-  _client;
-  _replied = false;
-  _deferred = false;
-  constructor(client, raw, user, guild, channel) {
-    this._client = client;
-    this.interactionId = raw.id;
-    this.interactionToken = raw.token;
-    this.customId = raw.data?.custom_id ?? "";
-    this.user = user;
-    this.guild = guild;
-    this.channel = channel;
-    const rows = raw.data?.components ?? [];
-    for (const row of rows) {
-      for (const comp of row.components ?? []) {
-        if (comp.custom_id && comp.value !== void 0) {
-          this._fields.set(comp.custom_id, comp.value);
-        }
-      }
+  async list() {
+    const result = await this.rest.get(`/guilds/${this.guildId}/roles`);
+    if (!result.ok) return result;
+    const roles = result.data.map((raw) => buildRole(raw));
+    for (const r of roles) {
+      this.store.roles.set(r.id, r);
     }
+    return { ok: true, data: roles };
   }
-  get replied() {
-    return this._replied;
+  async create(payload, reason) {
+    const headers = {};
+    if (reason) headers["X-Audit-Log-Reason"] = encodeURIComponent(reason);
+    const result = await this.rest.post(`/guilds/${this.guildId}/roles`, toSnakeCase(payload), headers);
+    if (!result.ok) return result;
+    const role = buildRole(result.data);
+    this.store.roles.set(role.id, role);
+    return { ok: true, data: role };
   }
-  get deferred() {
-    return this._deferred;
+  async edit(roleId, payload, reason) {
+    const headers = {};
+    if (reason) headers["X-Audit-Log-Reason"] = encodeURIComponent(reason);
+    const result = await this.rest.patch(`/guilds/${this.guildId}/roles/${roleId}`, toSnakeCase(payload), headers);
+    if (!result.ok) return result;
+    const role = buildRole(result.data);
+    this.store.roles.set(role.id, role);
+    return { ok: true, data: role };
   }
-  /** Get a text input value by its customId */
-  getField(customId) {
-    return this._fields.get(customId);
+  async delete(roleId, reason) {
+    const headers = {};
+    if (reason) headers["X-Audit-Log-Reason"] = encodeURIComponent(reason);
+    const result = await this.rest.delete(`/guilds/${this.guildId}/roles/${roleId}`, headers);
+    if (result.ok) this.store.roles.delete(roleId);
+    return result;
   }
-  /** Get all field values as a plain object */
-  get fields() {
-    return Object.fromEntries(this._fields);
+};
+
+// src/managers/member.ts
+var MemberManager = class {
+  constructor(rest, store, guildId) {
+    this.rest = rest;
+    this.store = store;
+    this.guildId = guildId;
   }
-  async reply(payload) {
-    if (this._replied || this._deferred) throw new Error("Interaction already acknowledged.");
-    const data = typeof payload === "string" ? { content: payload } : { ...payload };
-    if (typeof payload === "object" && payload.ephemeral) data.flags = 64;
-    await this._client.rest.post(`/interactions/${this.interactionId}/${this.interactionToken}/callback`, {
-      type: 4 /* CHANNEL_MESSAGE_WITH_SOURCE */,
-      data
+  rest;
+  store;
+  guildId;
+  async fetch(userId, force = false) {
+    const cacheKey = TongueStore.memberKey(this.guildId, userId);
+    if (!force) {
+      const cached = this.store.members.get(cacheKey);
+      if (cached) return { ok: true, data: cached };
+    }
+    const result = await this.rest.get(`/guilds/${this.guildId}/members/${userId}`);
+    if (!result.ok) return result;
+    const member = buildMember(result.data, this.guildId, this.store);
+    this.store.members.set(cacheKey, member);
+    return { ok: true, data: member };
+  }
+  async edit(userId, payload, reason) {
+    const headers = {};
+    if (reason) headers["X-Audit-Log-Reason"] = encodeURIComponent(reason);
+    const result = await this.rest.patch(`/guilds/${this.guildId}/members/${userId}`, toSnakeCase(payload), headers);
+    if (!result.ok) return result;
+    const cacheKey = TongueStore.memberKey(this.guildId, userId);
+    const member = buildMember(result.data, this.guildId, this.store);
+    this.store.members.set(cacheKey, member);
+    return { ok: true, data: member };
+  }
+  async list(options) {
+    let url = `/guilds/${this.guildId}/members`;
+    if (options) {
+      const params = new URLSearchParams();
+      if (options.limit) params.append("limit", options.limit.toString());
+      if (options.after) params.append("after", options.after);
+      const qs = params.toString();
+      if (qs) url += `?${qs}`;
+    }
+    const result = await this.rest.get(url);
+    if (!result.ok) return result;
+    const members = result.data.map((m) => {
+      const member = buildMember(m, this.guildId, this.store);
+      if (member.user) {
+        this.store.members.set(TongueStore.memberKey(this.guildId, member.user.id), member);
+      }
+      return member;
     });
-    this._replied = true;
+    return { ok: true, data: members };
   }
-  async defer(options) {
-    if (this._replied || this._deferred) throw new Error("Interaction already acknowledged.");
-    await this._client.rest.post(`/interactions/${this.interactionId}/${this.interactionToken}/callback`, {
-      type: 5 /* DEFERRED_CHANNEL_MESSAGE_WITH_SOURCE */,
-      data: { flags: options?.ephemeral ? 64 : 0 }
+  async search(query, limit) {
+    const params = new URLSearchParams({ query });
+    if (limit) params.append("limit", limit.toString());
+    const result = await this.rest.get(`/guilds/${this.guildId}/members/search?${params.toString()}`);
+    if (!result.ok) return result;
+    const members = result.data.map((m) => {
+      const member = buildMember(m, this.guildId, this.store);
+      if (member.user) {
+        this.store.members.set(TongueStore.memberKey(this.guildId, member.user.id), member);
+      }
+      return member;
     });
-    this._deferred = true;
+    return { ok: true, data: members };
   }
-  async followUp(payload) {
-    if (!this._deferred && !this._replied) throw new Error("Interaction not acknowledged.");
-    const data = typeof payload === "string" ? { content: payload } : { ...payload };
-    if (typeof payload === "object" && payload.ephemeral) data.flags = 64;
-    await this._client.rest.post(`/webhooks/${this._client.user?.id}/${this.interactionToken}`, data);
+  async addRole(userId, roleId, reason) {
+    const headers = {};
+    if (reason) headers["X-Audit-Log-Reason"] = encodeURIComponent(reason);
+    const result = await this.rest.put(`/guilds/${this.guildId}/members/${userId}/roles/${roleId}`, void 0, headers);
+    return result;
+  }
+  async removeRole(userId, roleId, reason) {
+    const headers = {};
+    if (reason) headers["X-Audit-Log-Reason"] = encodeURIComponent(reason);
+    const result = await this.rest.delete(`/guilds/${this.guildId}/members/${userId}/roles/${roleId}`, headers);
+    return result;
+  }
+  async timeout(userId, until, reason) {
+    const isoString = until ? until instanceof Date ? until.toISOString() : new Date(until).toISOString() : null;
+    return this.edit(userId, { communicationDisabledUntil: isoString }, reason);
   }
 };
 
-// src/commands/manager.ts
-import * as fs from "fs";
-import * as path from "path";
-var CommandManager = class {
-  _commands = /* @__PURE__ */ new Map();
-  _components = [];
-  _modals = [];
-  _client;
-  constructor(client) {
-    this._client = client;
+// src/managers/guild.ts
+var GuildManager = class extends BaseManager {
+  storeKey = "guilds";
+  endpoint(id) {
+    return `/guilds/${id}`;
   }
-  register(...commands) {
-    for (const cmd of commands) {
-      this._commands.set(cmd.name, cmd);
+  build = buildGuild;
+  roles(guildId) {
+    return new RoleManager(this.rest, this.store, guildId);
+  }
+  members(guildId) {
+    return new MemberManager(this.rest, this.store, guildId);
+  }
+  async fetchChannels(guildId) {
+    const result = await this.rest.get(`/guilds/${guildId}/channels`);
+    if (!result.ok) return result;
+    const channels = result.data.map((raw) => buildChannel(raw, guildId));
+    for (const c of channels) {
+      this.store.channels.set(c.id, c);
     }
-    this._deployCommands(commands).catch(console.error);
+    return { ok: true, data: channels };
   }
-  registerComponent(handler) {
-    this._components.push(handler);
+  async ban(guildId, userId, options) {
+    const payload = {};
+    if (options?.deleteMessageSeconds !== void 0) payload.delete_message_seconds = options.deleteMessageSeconds;
+    const headers = {};
+    if (options?.reason) headers["X-Audit-Log-Reason"] = encodeURIComponent(options.reason);
+    const result = await this.rest.put(`/guilds/${guildId}/bans/${userId}`, payload, headers);
+    return result;
   }
-  registerModal(handler) {
-    this._modals.push(handler);
+  async unban(guildId, userId, reason) {
+    const headers = {};
+    if (reason) headers["X-Audit-Log-Reason"] = encodeURIComponent(reason);
+    const result = await this.rest.delete(`/guilds/${guildId}/bans/${userId}`, headers);
+    return result;
   }
-  async load(directory) {
-    const fullPath = path.resolve(process.cwd(), directory);
-    if (!fs.existsSync(fullPath)) {
-      console.error(`[Chameleon] Command directory ${directory} does not exist.`);
-      return;
+  async kick(guildId, userId, reason) {
+    const headers = {};
+    if (reason) headers["X-Audit-Log-Reason"] = encodeURIComponent(reason);
+    const result = await this.rest.delete(`/guilds/${guildId}/members/${userId}`, headers);
+    if (result.ok) {
+      this.store.members.delete(TongueStore.memberKey(guildId, userId));
     }
-    const files = fs.readdirSync(fullPath).filter((f) => f.endsWith(".js") || f.endsWith(".ts"));
-    const commands = [];
-    for (const file of files) {
-      const filePath = path.join(fullPath, file);
-      try {
-        const module = await import(`file://${filePath}`);
-        const command = module.default;
-        if (command && typeof command.name === "string") {
-          commands.push(command);
-        }
-      } catch (err) {
-        console.error(`[Chameleon] Failed to load command from ${file}:`, err);
-      }
+    return result;
+  }
+  async edit(guildId, payload, reason) {
+    const headers = {};
+    if (reason) headers["X-Audit-Log-Reason"] = encodeURIComponent(reason);
+    const result = await this.rest.patch(this.endpoint(guildId), toSnakeCase(payload), headers);
+    if (!result.ok) return result;
+    const entity = this.build(result.data);
+    this.store.guilds.set(entity.id, entity);
+    return { ok: true, data: entity };
+  }
+  async delete(guildId) {
+    const result = await this.rest.delete(this.endpoint(guildId));
+    if (result.ok) this.store.guilds.delete(guildId);
+    return result;
+  }
+  async listEmojis(guildId) {
+    const result = await this.rest.get(`/guilds/${guildId}/emojis`);
+    if (!result.ok) return result;
+    const emojis = result.data.map((e) => {
+      const emoji = buildEmoji(e);
+      this.store.emojis.set(emoji.id, emoji);
+      return emoji;
+    });
+    return { ok: true, data: emojis };
+  }
+  async fetchEmoji(guildId, emojiId) {
+    const cached = this.store.emojis.get(emojiId);
+    if (cached) return { ok: true, data: cached };
+    const result = await this.rest.get(`/guilds/${guildId}/emojis/${emojiId}`);
+    if (!result.ok) return result;
+    const emoji = buildEmoji(result.data);
+    this.store.emojis.set(emoji.id, emoji);
+    return { ok: true, data: emoji };
+  }
+  async createEmoji(guildId, payload, reason) {
+    const headers = {};
+    if (reason) headers["X-Audit-Log-Reason"] = encodeURIComponent(reason);
+    const result = await this.rest.post(`/guilds/${guildId}/emojis`, toSnakeCase(payload), headers);
+    if (!result.ok) return result;
+    const emoji = buildEmoji(result.data);
+    this.store.emojis.set(emoji.id, emoji);
+    return { ok: true, data: emoji };
+  }
+  async editEmoji(guildId, emojiId, payload, reason) {
+    const headers = {};
+    if (reason) headers["X-Audit-Log-Reason"] = encodeURIComponent(reason);
+    const result = await this.rest.patch(`/guilds/${guildId}/emojis/${emojiId}`, toSnakeCase(payload), headers);
+    if (!result.ok) return result;
+    const emoji = buildEmoji(result.data);
+    this.store.emojis.set(emoji.id, emoji);
+    return { ok: true, data: emoji };
+  }
+  async deleteEmoji(guildId, emojiId, reason) {
+    const headers = {};
+    if (reason) headers["X-Audit-Log-Reason"] = encodeURIComponent(reason);
+    const result = await this.rest.delete(`/guilds/${guildId}/emojis/${emojiId}`, headers);
+    if (result.ok) this.store.emojis.delete(emojiId);
+    return result;
+  }
+  async listStickers(guildId) {
+    const result = await this.rest.get(`/guilds/${guildId}/stickers`);
+    if (!result.ok) return result;
+    const stickers = result.data.map((s) => {
+      const sticker = buildSticker(s);
+      this.store.stickers.set(sticker.id, sticker);
+      return sticker;
+    });
+    return { ok: true, data: stickers };
+  }
+  async fetchSticker(guildId, stickerId) {
+    const cached = this.store.stickers.get(stickerId);
+    if (cached) return { ok: true, data: cached };
+    const result = await this.rest.get(`/guilds/${guildId}/stickers/${stickerId}`);
+    if (!result.ok) return result;
+    const sticker = buildSticker(result.data);
+    this.store.stickers.set(sticker.id, sticker);
+    return { ok: true, data: sticker };
+  }
+  async listBans(guildId, options) {
+    let url = `/guilds/${guildId}/bans`;
+    if (options) {
+      const params = new URLSearchParams();
+      if (options.limit) params.append("limit", options.limit.toString());
+      if (options.before) params.append("before", options.before);
+      if (options.after) params.append("after", options.after);
+      const qs = params.toString();
+      if (qs) url += `?${qs}`;
     }
-    if (commands.length > 0) {
-      this.register(...commands);
+    const result = await this.rest.get(url);
+    if (!result.ok) return result;
+    const bans = result.data.map((b) => ({
+      reason: b.reason ?? null,
+      user: buildUser(b.user)
+    }));
+    return { ok: true, data: bans };
+  }
+  async fetchBan(guildId, userId) {
+    const result = await this.rest.get(`/guilds/${guildId}/bans/${userId}`);
+    if (!result.ok) return result;
+    const b = result.data;
+    return {
+      ok: true,
+      data: { reason: b.reason ?? null, user: buildUser(b.user) }
+    };
+  }
+  async getInvites(guildId) {
+    const result = await this.rest.get(`/guilds/${guildId}/invites`);
+    if (!result.ok) return result;
+    const invites = result.data.map((i) => buildInvite(i));
+    return { ok: true, data: invites };
+  }
+  async getVanityURL(guildId) {
+    const result = await this.rest.get(`/guilds/${guildId}/vanity-url`);
+    if (!result.ok) return result;
+    const data = result.data;
+    return { ok: true, data: { code: data.code ?? null, uses: data.uses ?? 0 } };
+  }
+  async getPruneCount(guildId, options) {
+    let url = `/guilds/${guildId}/prune`;
+    if (options) {
+      const params = new URLSearchParams();
+      if (options.days) params.append("days", options.days.toString());
+      if (options.includeRoles) params.append("include_roles", options.includeRoles.join(","));
+      const qs = params.toString();
+      if (qs) url += `?${qs}`;
     }
+    const result = await this.rest.get(url);
+    if (!result.ok) return result;
+    return { ok: true, data: result.data.pruned ?? 0 };
   }
-  async _deployCommands(commands) {
-    const payload = commands.map((c) => this._transformCommand(c));
-    if (this._client.user?.id) {
-      await this._client.rest.put(`/applications/${this._client.user.id}/commands`, payload);
+  async beginPrune(guildId, options, reason) {
+    const headers = {};
+    if (reason) headers["X-Audit-Log-Reason"] = encodeURIComponent(reason);
+    const result = await this.rest.post(`/guilds/${guildId}/prune`, toSnakeCase(options ?? {}), headers);
+    if (!result.ok) return result;
+    return { ok: true, data: result.data.pruned ?? null };
+  }
+  async fetchAuditLog(guildId, options) {
+    let url = `/guilds/${guildId}/audit-logs`;
+    if (options) {
+      const params = new URLSearchParams();
+      if (options.userId) params.append("user_id", options.userId);
+      if (options.actionType !== void 0) params.append("action_type", options.actionType.toString());
+      if (options.before) params.append("before", options.before);
+      if (options.after) params.append("after", options.after);
+      if (options.limit) params.append("limit", options.limit.toString());
+      const qs = params.toString();
+      if (qs) url += `?${qs}`;
+    }
+    const result = await this.rest.get(url);
+    if (!result.ok) return result;
+    return { ok: true, data: toCamelCase(result.data) };
+  }
+  async leave(guildId) {
+    const result = await this.rest.delete(`/users/@me/guilds/${guildId}`);
+    return result;
+  }
+};
+
+// src/managers/channel.ts
+var ChannelManager = class extends BaseManager {
+  storeKey = "channels";
+  endpoint(id) {
+    return `/channels/${id}`;
+  }
+  build = buildChannel;
+  async create(guildId, payload, reason) {
+    const headers = {};
+    if (reason) headers["X-Audit-Log-Reason"] = encodeURIComponent(reason);
+    const result = await this.rest.post(`/guilds/${guildId}/channels`, toSnakeCase(payload), headers);
+    if (!result.ok) return result;
+    const entity = this.build(result.data, guildId);
+    this.store.channels.set(entity.id, entity);
+    return { ok: true, data: entity };
+  }
+  async edit(channelId, payload, reason) {
+    const headers = {};
+    if (reason) headers["X-Audit-Log-Reason"] = encodeURIComponent(reason);
+    const result = await this.rest.patch(this.endpoint(channelId), toSnakeCase(payload), headers);
+    if (!result.ok) return result;
+    const entity = this.build(result.data);
+    this.store.channels.set(entity.id, entity);
+    return { ok: true, data: entity };
+  }
+  async delete(channelId, reason) {
+    const headers = {};
+    if (reason) headers["X-Audit-Log-Reason"] = encodeURIComponent(reason);
+    const result = await this.rest.delete(this.endpoint(channelId), headers);
+    if (result.ok) this.store.channels.delete(channelId);
+    return result;
+  }
+  async clone(channelId, options, reason) {
+    const cached = this.store.channels.get(channelId);
+    if (!cached) return { ok: false, status: 404, message: "Channel not found in cache" };
+    const payload = { ...options };
+    if (cached.name !== void 0) payload.name = cached.name;
+    if (cached.type !== void 0) payload.type = cached.type;
+    if (cached.topic !== void 0) payload.topic = cached.topic;
+    if (cached.bitrate !== void 0) payload.bitrate = cached.bitrate;
+    if (cached.userLimit !== void 0) payload.userLimit = cached.userLimit;
+    if (cached.rateLimitPerUser !== void 0) payload.rateLimitPerUser = cached.rateLimitPerUser;
+    if (cached.nsfw !== void 0) payload.nsfw = cached.nsfw;
+    if (cached.position !== void 0) payload.position = cached.position;
+    if (cached.parentId !== void 0) payload.parentId = cached.parentId;
+    if (cached.permissionOverwrites !== void 0) payload.permissionOverwrites = cached.permissionOverwrites;
+    if (!cached.guildId) return { ok: false, status: 400, message: "Cannot clone a DM channel" };
+    return this.create(cached.guildId, payload, reason);
+  }
+  async setPositions(guildId, positions, reason) {
+    const headers = {};
+    if (reason) headers["X-Audit-Log-Reason"] = encodeURIComponent(reason);
+    const payload = positions.map((p) => ({
+      id: p.id,
+      ...p.position !== void 0 ? { position: p.position } : {},
+      ...p.lockPermissions !== void 0 ? { lock_permissions: p.lockPermissions } : {},
+      ...p.parentId !== void 0 ? { parent_id: p.parentId } : {}
+    }));
+    const result = await this.rest.patch(`/guilds/${guildId}/channels`, payload, headers);
+    return result;
+  }
+  async updatePermissions(channelId, overwriteId, payload, reason) {
+    const headers = {};
+    if (reason) headers["X-Audit-Log-Reason"] = encodeURIComponent(reason);
+    return await this.rest.put(`/channels/${channelId}/permissions/${overwriteId}`, toSnakeCase(payload), headers);
+  }
+  async deletePermission(channelId, overwriteId, reason) {
+    const headers = {};
+    if (reason) headers["X-Audit-Log-Reason"] = encodeURIComponent(reason);
+    return await this.rest.delete(`/channels/${channelId}/permissions/${overwriteId}`, headers);
+  }
+  async sendTyping(channelId) {
+    const result = await this.rest.post(`/channels/${channelId}/typing`);
+    return result;
+  }
+  async getInvites(channelId) {
+    const result = await this.rest.get(`/channels/${channelId}/invites`);
+    if (!result.ok) return result;
+    const invites = result.data.map((i) => buildInvite(i));
+    return { ok: true, data: invites };
+  }
+  async createInvite(channelId, options, reason) {
+    const headers = {};
+    if (reason) headers["X-Audit-Log-Reason"] = encodeURIComponent(reason);
+    const payload = options ? toSnakeCase(options) : {};
+    const result = await this.rest.post(`/channels/${channelId}/invites`, payload, headers);
+    if (!result.ok) return result;
+    return { ok: true, data: buildInvite(result.data) };
+  }
+  async followAnnouncementChannel(channelId, webhookChannelId) {
+    const result = await this.rest.post(`/channels/${channelId}/followers`, { webhook_channel_id: webhookChannelId });
+    if (!result.ok) return result;
+    const data = result.data;
+    return { ok: true, data: { channelId: data.channel_id, webhookId: data.webhook_id } };
+  }
+  async createThread(channelId, options, reason) {
+    const headers = {};
+    if (reason) headers["X-Audit-Log-Reason"] = encodeURIComponent(reason);
+    const result = await this.rest.post(`/channels/${channelId}/threads`, toSnakeCase(options), headers);
+    if (!result.ok) return result;
+    const channel = this.build(result.data);
+    this.store.channels.set(channel.id, channel);
+    return { ok: true, data: channel };
+  }
+  async createThreadFromMessage(channelId, messageId, options, reason) {
+    const headers = {};
+    if (reason) headers["X-Audit-Log-Reason"] = encodeURIComponent(reason);
+    const result = await this.rest.post(`/channels/${channelId}/messages/${messageId}/threads`, toSnakeCase(options), headers);
+    if (!result.ok) return result;
+    const channel = this.build(result.data);
+    this.store.channels.set(channel.id, channel);
+    return { ok: true, data: channel };
+  }
+  async joinThread(channelId) {
+    const result = await this.rest.put(`/channels/${channelId}/thread-members/@me`);
+    return result;
+  }
+  async leaveThread(channelId) {
+    const result = await this.rest.delete(`/channels/${channelId}/thread-members/@me`);
+    return result;
+  }
+  async listActiveThreads(guildId) {
+    const result = await this.rest.get(`/guilds/${guildId}/threads/active`);
+    if (!result.ok) return result;
+    const data = result.data;
+    const threads = data.threads.map((t) => {
+      const channel = this.build(t, guildId);
+      this.store.channels.set(channel.id, channel);
+      return channel;
+    });
+    return { ok: true, data: { threads, members: data.members } };
+  }
+  async listArchivedThreads(channelId, type, options) {
+    let url = `/channels/${channelId}/threads/archived/${type}`;
+    if (options) {
+      const params = new URLSearchParams();
+      if (options.before) params.append("before", options.before);
+      if (options.limit) params.append("limit", options.limit.toString());
+      const qs = params.toString();
+      if (qs) url += `?${qs}`;
+    }
+    const result = await this.rest.get(url);
+    if (!result.ok) return result;
+    const data = result.data;
+    const threads = data.threads.map((t) => {
+      const channel = this.build(t);
+      this.store.channels.set(channel.id, channel);
+      return channel;
+    });
+    return { ok: true, data: { threads, members: data.members, hasMore: data.has_more } };
+  }
+  async addThreadMember(channelId, userId) {
+    const result = await this.rest.put(`/channels/${channelId}/thread-members/${userId}`);
+    return result;
+  }
+  async removeThreadMember(channelId, userId) {
+    const result = await this.rest.delete(`/channels/${channelId}/thread-members/${userId}`);
+    return result;
+  }
+  async createForumThread(channelId, options, reason) {
+    const headers = {};
+    if (reason) headers["X-Audit-Log-Reason"] = encodeURIComponent(reason);
+    const messagePayload = {};
+    if (options.message.content) messagePayload.content = options.message.content;
+    if (options.message.embeds) {
+      messagePayload.embeds = options.message.embeds.map(
+        (e) => e && typeof e.toJSON === "function" ? e.toJSON() : e
+      );
+    }
+    if (options.message.components) {
+      messagePayload.components = options.message.components.map((c) => serializeComponent(c));
+    }
+    const payload = {
+      name: options.name,
+      message: messagePayload,
+      ...options.autoArchiveDuration !== void 0 ? { auto_archive_duration: options.autoArchiveDuration } : {},
+      ...options.rateLimitPerUser !== void 0 ? { rate_limit_per_user: options.rateLimitPerUser } : {},
+      ...options.appliedTags ? { applied_tags: options.appliedTags } : {}
+    };
+    let result;
+    if (options.message.files && options.message.files.length > 0) {
+      result = await this.rest.requestWithFiles("POST", `/channels/${channelId}/threads`, payload, options.message.files, headers);
     } else {
-      this._client.on("READY", async () => {
-        await this._client.rest.put(`/applications/${this._client.user.id}/commands`, payload);
-      });
+      result = await this.rest.post(`/channels/${channelId}/threads`, payload, headers);
     }
+    if (!result.ok) return result;
+    const channel = this.build(result.data);
+    this.store.channels.set(channel.id, channel);
+    return { ok: true, data: channel };
   }
-  _transformCommand(cmd) {
-    const mapType = (t) => {
-      switch (t) {
-        case "string":
-          return 3;
-        case "integer":
-          return 4;
-        case "boolean":
-          return 5;
-        case "user":
-          return 6;
-        case "channel":
-          return 7;
-        case "role":
-          return 8;
-        case "number":
-          return 10;
-        default:
-          return 3;
+};
+
+// src/managers/message.ts
+var MessageManager = class {
+  constructor(rest, store) {
+    this.rest = rest;
+    this.store = store;
+  }
+  rest;
+  store;
+  async fetch(channelId, messageId, force = false) {
+    if (!force) {
+      const cached = this.store.messages.get(messageId);
+      if (cached) return { ok: true, data: cached };
+    }
+    const result = await this.rest.get(`/channels/${channelId}/messages/${messageId}`);
+    if (!result.ok) return result;
+    const message = buildMessage(result.data, this.store);
+    this.store.messages.set(message.id, message);
+    return { ok: true, data: message };
+  }
+  async send(channelId, payload) {
+    const data = typeof payload === "string" ? { content: payload } : { ...payload };
+    let files;
+    if (typeof payload === "object") {
+      if (payload.embeds) {
+        data.embeds = payload.embeds.map((e) => e && typeof e.toJSON === "function" ? e.toJSON() : e);
       }
-    };
-    const options = [];
-    if (cmd.subcommands) {
-      for (const [subName, subDefRaw] of Object.entries(cmd.subcommands)) {
-        const subDef = subDefRaw;
-        const subOpts = [];
-        if (subDef.options) {
-          for (const [optName, optDef] of Object.entries(subDef.options)) {
-            subOpts.push({
-              type: mapType(optDef.type),
-              name: optName,
-              description: optDef.description,
-              required: optDef.required,
-              choices: optDef.choices,
-              min_value: optDef.min,
-              max_value: optDef.max
-            });
-          }
-        }
-        options.push({
-          type: 1 /* SUB_COMMAND */,
-          name: subName,
-          description: subDef.description,
-          options: subOpts
-        });
+      if (payload.components) {
+        data.components = payload.components.map((c) => serializeComponent(c));
       }
-    } else if (cmd.options) {
-      for (const [optName, optDef] of Object.entries(cmd.options)) {
-        options.push({
-          type: mapType(optDef.type),
-          name: optName,
-          description: optDef.description,
-          required: optDef.required,
-          choices: optDef.choices,
-          min_value: optDef.min,
-          max_value: optDef.max
-        });
+      if (payload.reply) {
+        data.message_reference = { message_id: payload.reply.messageId, fail_if_not_exists: payload.reply.failIfNotExists ?? true };
+        delete data.reply;
+      }
+      if (payload.poll) {
+        data.poll = {
+          question: payload.poll.question,
+          answers: payload.poll.answers.map((a) => ({
+            ...a.answerId !== void 0 ? { answer_id: a.answerId } : {},
+            poll_media: a.pollMedia
+          })),
+          ...payload.poll.duration !== void 0 ? { duration: payload.poll.duration } : {},
+          ...payload.poll.allowMultiselect !== void 0 ? { allow_multiselect: payload.poll.allowMultiselect } : {},
+          ...payload.poll.layoutType !== void 0 ? { layout_type: payload.poll.layoutType } : {}
+        };
+      }
+      if (payload.tts !== void 0) data.tts = payload.tts;
+      if (payload.flags !== void 0) data.flags = payload.flags;
+      if (payload.nonce !== void 0) data.nonce = payload.nonce;
+      if (payload.enforceNonce !== void 0) data.enforce_nonce = payload.enforceNonce;
+      if (payload.stickerIds && payload.stickerIds.length > 0) {
+        data.sticker_ids = payload.stickerIds;
+        delete data.stickerIds;
+      }
+      if (payload.files && payload.files.length > 0) {
+        files = payload.files;
+        delete data.files;
       }
     }
-    return {
-      name: cmd.name,
-      description: cmd.description,
-      options: options.length ? options : void 0
-    };
+    let result;
+    if (files && files.length > 0) {
+      result = await this.rest.requestWithFiles("POST", `/channels/${channelId}/messages`, data, files);
+    } else {
+      result = await this.rest.post(`/channels/${channelId}/messages`, data);
+    }
+    if (!result.ok) return result;
+    const message = buildMessage(result.data, this.store);
+    this.store.messages.set(message.id, message);
+    return { ok: true, data: message };
   }
-  async handleInteraction(raw) {
-    if (raw.type === 3 /* MESSAGE_COMPONENT */) return this._handleComponentInteraction(raw);
-    if (raw.type === 5 /* MODAL_SUBMIT */) return this._handleModalInteraction(raw);
-    if (raw.type !== 2 /* APPLICATION_COMMAND */) return;
-    const name = raw.data.name;
-    const command = this._commands.get(name);
-    if (!command) return;
-    const parsedOptions = {};
-    let targetExecute = command.execute;
-    const rawOptions = raw.data.options || [];
-    let actualOptions = rawOptions;
-    if (rawOptions.length > 0 && rawOptions[0].type === 1 /* SUB_COMMAND */) {
-      const subcommandName = rawOptions[0].name;
-      actualOptions = rawOptions[0].options || [];
-      if (command.subcommands && command.subcommands[subcommandName]) {
-        targetExecute = command.subcommands[subcommandName].execute;
+  async edit(channelId, messageId, payload) {
+    const data = typeof payload === "string" ? { content: payload } : { ...payload };
+    let files;
+    if (typeof payload === "object") {
+      if (payload.embeds) {
+        data.embeds = payload.embeds.map((e) => e && typeof e.toJSON === "function" ? e.toJSON() : e);
       }
-    }
-    for (const opt2 of actualOptions) {
-      if (opt2.type === 6 /* USER */ && raw.data.resolved?.users?.[opt2.value]) {
-        parsedOptions[opt2.name] = resolveUser(opt2.value, this._client.cache);
-      } else if (opt2.type === 7 /* CHANNEL */ && raw.data.resolved?.channels?.[opt2.value]) {
-        parsedOptions[opt2.name] = resolveChannel(opt2.value, this._client.cache);
-      } else if (opt2.type === 8 /* ROLE */ && raw.data.resolved?.roles?.[opt2.value]) {
-        parsedOptions[opt2.name] = resolveRole(opt2.value, this._client.cache);
-      } else {
-        parsedOptions[opt2.name] = opt2.value;
+      if (payload.components) {
+        data.components = payload.components.map((c) => serializeComponent(c));
       }
-    }
-    const member = raw.member || {};
-    const userRaw = member.user || raw.user;
-    const user = buildUser(userRaw);
-    const ctx = new CommandContext(
-      this._client,
-      raw,
-      parsedOptions,
-      user,
-      raw.guild_id ? resolveGuild(raw.guild_id, this._client.cache) : void 0,
-      raw.channel_id ? resolveChannel(raw.channel_id, this._client.cache) : void 0
-    );
-    if (targetExecute) {
-      try {
-        await targetExecute(ctx);
-      } catch (err) {
-        console.error(`[Chameleon] Error executing command ${name}:`, err);
+      if (payload.files && payload.files.length > 0) {
+        files = payload.files;
+        delete data.files;
       }
     }
+    let result;
+    if (files && files.length > 0) {
+      result = await this.rest.requestWithFiles("PATCH", `/channels/${channelId}/messages/${messageId}`, data, files);
+    } else {
+      result = await this.rest.patch(`/channels/${channelId}/messages/${messageId}`, data);
+    }
+    if (!result.ok) return result;
+    const oldMsg = this.store.messages.get(messageId);
+    const message = buildMessage(result.data, this.store, oldMsg);
+    this.store.messages.set(message.id, message);
+    return { ok: true, data: message };
   }
-  async _handleComponentInteraction(raw) {
-    const customId = raw.data.custom_id;
-    const handler = this._components.find(
-      (h) => typeof h.customId === "string" ? h.customId === customId : h.customId.test(customId)
-    );
-    if (!handler) return;
-    const userRaw = raw.member?.user || raw.user;
-    const user = buildUser(userRaw);
-    const ctx = new ComponentContext(
-      this._client,
-      raw,
-      user,
-      raw.guild_id ? resolveGuild(raw.guild_id, this._client.cache) : void 0,
-      raw.channel_id ? resolveChannel(raw.channel_id, this._client.cache) : void 0
-    );
-    if (raw.data.component_type === 3 /* STRING_SELECT */ || raw.data.component_type === 5 /* USER_SELECT */ || raw.data.component_type === 6 /* ROLE_SELECT */ || raw.data.component_type === 7 /* MENTIONABLE_SELECT */ || raw.data.component_type === 8 /* CHANNEL_SELECT */) {
-      ctx._values = raw.data.values || [];
+  async delete(channelId, messageId) {
+    const result = await this.rest.delete(`/channels/${channelId}/messages/${messageId}`);
+    if (result.ok) {
+      this.store.messages.delete(messageId);
     }
-    try {
-      await handler.execute(ctx);
-    } catch (err) {
-      console.error(`[Chameleon] Error executing component ${customId}:`, err);
+    return result;
+  }
+  async list(channelId, options) {
+    let url = `/channels/${channelId}/messages`;
+    if (options) {
+      const params = new URLSearchParams();
+      if (options.limit) params.append("limit", options.limit.toString());
+      if (options.before) params.append("before", options.before);
+      if (options.after) params.append("after", options.after);
+      if (options.around) params.append("around", options.around);
+      const qs = params.toString();
+      if (qs) url += `?${qs}`;
     }
+    const result = await this.rest.get(url);
+    if (!result.ok) return result;
+    const messages = result.data.map((msgData) => {
+      const msg = buildMessage(msgData, this.store);
+      this.store.messages.set(msg.id, msg);
+      return msg;
+    });
+    return { ok: true, data: messages };
   }
-  async _handleModalInteraction(raw) {
-    const customId = raw.data.custom_id;
-    const handler = this._modals.find(
-      (h) => typeof h.customId === "string" ? h.customId === customId : h.customId.test(customId)
-    );
-    if (!handler) return;
-    const userRaw = raw.member?.user || raw.user;
-    const user = buildUser(userRaw);
-    const ctx = new ModalContext(
-      this._client,
-      raw,
-      user,
-      raw.guild_id ? resolveGuild(raw.guild_id, this._client.cache) : void 0,
-      raw.channel_id ? resolveChannel(raw.channel_id, this._client.cache) : void 0
-    );
-    try {
-      await handler.execute(ctx);
-    } catch (err) {
-      console.error(`[Chameleon] Error executing modal ${customId}:`, err);
+  async react(channelId, messageId, emoji) {
+    const encodedEmoji = encodeURIComponent(emoji);
+    const result = await this.rest.put(`/channels/${channelId}/messages/${messageId}/reactions/${encodedEmoji}/@me`);
+    return result;
+  }
+  async removeReaction(channelId, messageId, emoji, userId = "@me") {
+    const encodedEmoji = encodeURIComponent(emoji);
+    const result = await this.rest.delete(`/channels/${channelId}/messages/${messageId}/reactions/${encodedEmoji}/${userId}`);
+    return result;
+  }
+  async removeAllReactions(channelId, messageId, emoji) {
+    let url = `/channels/${channelId}/messages/${messageId}/reactions`;
+    if (emoji) url += `/${encodeURIComponent(emoji)}`;
+    const result = await this.rest.delete(url);
+    return result;
+  }
+  async getReactions(channelId, messageId, emoji, options) {
+    let url = `/channels/${channelId}/messages/${messageId}/reactions/${encodeURIComponent(emoji)}`;
+    if (options) {
+      const params = new URLSearchParams();
+      if (options.after) params.append("after", options.after);
+      if (options.limit) params.append("limit", options.limit.toString());
+      if (options.type !== void 0) params.append("type", options.type.toString());
+      const qs = params.toString();
+      if (qs) url += `?${qs}`;
     }
+    const result = await this.rest.get(url);
+    if (!result.ok) return result;
+    const users = result.data.map((userData) => {
+      const user = buildUser(userData);
+      this.store.users.set(user.id, user);
+      return user;
+    });
+    return { ok: true, data: users };
+  }
+  async pin(channelId, messageId) {
+    const result = await this.rest.put(`/channels/${channelId}/pins/${messageId}`);
+    return result;
+  }
+  async unpin(channelId, messageId) {
+    const result = await this.rest.delete(`/channels/${channelId}/pins/${messageId}`);
+    return result;
+  }
+  async getPins(channelId) {
+    const result = await this.rest.get(`/channels/${channelId}/pins`);
+    if (!result.ok) return result;
+    const messages = result.data.map((msgData) => {
+      const msg = buildMessage(msgData, this.store);
+      this.store.messages.set(msg.id, msg);
+      return msg;
+    });
+    return { ok: true, data: messages };
+  }
+  async bulkDelete(channelId, messageIds) {
+    const result = await this.rest.post(`/channels/${channelId}/messages/bulk-delete`, { messages: messageIds });
+    if (result.ok) {
+      for (const id of messageIds) {
+        this.store.messages.delete(id);
+      }
+    }
+    return result;
+  }
+  async forward(channelId, messageId) {
+    const result = await this.rest.post(`/channels/${channelId}/messages/${messageId}/crosspost`);
+    if (!result.ok) return result;
+    const oldMsg = this.store.messages.get(messageId);
+    const message = buildMessage(result.data, this.store, oldMsg);
+    this.store.messages.set(message.id, message);
+    return { ok: true, data: message };
+  }
+  async endPoll(channelId, messageId) {
+    const result = await this.rest.post(`/channels/${channelId}/polls/${messageId}/expire`);
+    if (!result.ok) return result;
+    const message = buildMessage(result.data, this.store);
+    this.store.messages.set(message.id, message);
+    return { ok: true, data: message };
+  }
+  async getPollAnswerVoters(channelId, messageId, answerId, options) {
+    let url = `/channels/${channelId}/polls/${messageId}/answers/${answerId}`;
+    if (options) {
+      const params = new URLSearchParams();
+      if (options.after) params.append("after", options.after);
+      if (options.limit) params.append("limit", options.limit.toString());
+      const qs = params.toString();
+      if (qs) url += `?${qs}`;
+    }
+    const result = await this.rest.get(url);
+    if (!result.ok) return result;
+    const data = result.data;
+    const users = data.users.map((u) => {
+      const user = buildUser(u);
+      this.store.users.set(user.id, user);
+      return user;
+    });
+    return { ok: true, data: users };
   }
 };
 
-// src/components/context.ts
-var ComponentContext2 = class {
-  user;
-  guild;
-  channel;
-  interactionId;
-  interactionToken;
-  customId;
-  values;
-  fields;
-  _client;
-  _deferred = false;
-  _replied = false;
-  constructor(client, rawInteraction, user, guild, channel) {
-    this._client = client;
-    this.interactionId = rawInteraction.id;
-    this.interactionToken = rawInteraction.token;
-    this.customId = rawInteraction.data?.custom_id;
-    this.user = user;
-    this.guild = guild;
-    this.channel = channel;
-    this.values = rawInteraction.data?.values ?? [];
-    const fields = {};
-    if (rawInteraction.data?.components) {
-      for (const row of rawInteraction.data.components) {
-        for (const comp of row.components) {
-          fields[comp.custom_id] = comp.value;
+// src/managers/collector.ts
+var CollectorManager = class {
+  constructor(client) {
+    this.client = client;
+  }
+  client;
+  /**
+   * Waits for a specified number of messages in a given channel that pass the filter, if the time limit
+   * is reached, resolves with the messages collected so far
+   */
+  async awaitMessages(channelId, options = {}) {
+    const { filter, max = 1, time = 15e3 } = options;
+    return new Promise((resolve4) => {
+      const messages = [];
+      let timeoutId = null;
+      const handler = (data) => {
+        const msg = data.message;
+        if (msg.channelId !== channelId) return;
+        if (filter && !filter(msg)) return;
+        messages.push(msg);
+        if (messages.length >= max) {
+          cleanup();
+          resolve4(messages);
         }
+      };
+      const cleanup = () => {
+        if (timeoutId) clearTimeout(timeoutId);
+        this.client.off("MESSAGE_CREATE", handler);
+      };
+      this.client.on("MESSAGE_CREATE", handler);
+      if (time > 0) {
+        timeoutId = setTimeout(() => {
+          cleanup();
+          resolve4(messages);
+        }, time);
+      }
+    });
+  }
+  /**
+   * waits for a single component interaction on a specific message,
+   * resolves with the ComponentContext if successful, or null if it timed out
+   */
+  async awaitComponent(messageId, options = {}) {
+    const { filter, time = 15e3 } = options;
+    return new Promise((resolve4) => {
+      let timeoutId = null;
+      const handler = (data) => {
+        if (data.type !== "INTERACTION_CREATE") return;
+        const interaction = data.interaction;
+        const raw = interaction;
+        if (interaction.type !== 3 /* MESSAGE_COMPONENT */) return;
+        if (interaction.message?.id !== messageId) return;
+        const userRaw = interaction.member?.user || interaction.user;
+        const user = buildUser(userRaw);
+        const ctx = new ComponentContext(
+          this.client,
+          raw,
+          user,
+          interaction.guildId ? resolveGuild(interaction.guildId, this.client) : void 0,
+          interaction.channelId ? resolveChannel(interaction.channelId, this.client) : void 0
+        );
+        if (filter && !filter(ctx)) return;
+        cleanup();
+        resolve4(ctx);
+      };
+      const cleanup = () => {
+        if (timeoutId) clearTimeout(timeoutId);
+        this.client.off("INTERACTION_CREATE", handler);
+      };
+      this.client.on("INTERACTION_CREATE", handler);
+      if (time > 0) {
+        timeoutId = setTimeout(() => {
+          cleanup();
+          resolve4(null);
+        }, time);
+      }
+    });
+  }
+};
+
+// src/managers/webhook.ts
+var WebhookManager = class {
+  constructor(rest, store) {
+    this.rest = rest;
+    this.store = store;
+  }
+  rest;
+  store;
+  async fetch(webhookId, token) {
+    const url = token ? `/webhooks/${webhookId}/${token}` : `/webhooks/${webhookId}`;
+    const result = await this.rest.get(url);
+    if (!result.ok) return result;
+    return { ok: true, data: buildWebhook(result.data) };
+  }
+  async fetchByChannel(channelId) {
+    const result = await this.rest.get(`/channels/${channelId}/webhooks`);
+    if (!result.ok) return result;
+    const webhooks = result.data.map((w) => buildWebhook(w));
+    return { ok: true, data: webhooks };
+  }
+  async fetchByGuild(guildId) {
+    const result = await this.rest.get(`/guilds/${guildId}/webhooks`);
+    if (!result.ok) return result;
+    const webhooks = result.data.map((w) => buildWebhook(w));
+    return { ok: true, data: webhooks };
+  }
+  async create(channelId, payload, reason) {
+    const headers = {};
+    if (reason) headers["X-Audit-Log-Reason"] = encodeURIComponent(reason);
+    const result = await this.rest.post(`/channels/${channelId}/webhooks`, toSnakeCase(payload), headers);
+    if (!result.ok) return result;
+    return { ok: true, data: buildWebhook(result.data) };
+  }
+  async edit(webhookId, payload, token, reason) {
+    const headers = {};
+    if (reason) headers["X-Audit-Log-Reason"] = encodeURIComponent(reason);
+    const url = token ? `/webhooks/${webhookId}/${token}` : `/webhooks/${webhookId}`;
+    const result = await this.rest.patch(url, toSnakeCase(payload), headers);
+    if (!result.ok) return result;
+    return { ok: true, data: buildWebhook(result.data) };
+  }
+  async delete(webhookId, token, reason) {
+    const headers = {};
+    if (reason) headers["X-Audit-Log-Reason"] = encodeURIComponent(reason);
+    const url = token ? `/webhooks/${webhookId}/${token}` : `/webhooks/${webhookId}`;
+    const result = await this.rest.delete(url, headers);
+    return result;
+  }
+  async execute(webhookId, token, payload, options) {
+    const data = typeof payload === "string" ? { content: payload } : { ...toSnakeCase(payload) };
+    let files;
+    if (typeof payload === "object") {
+      if (payload.embeds) {
+        data.embeds = payload.embeds.map((e) => e && typeof e.toJSON === "function" ? e.toJSON() : e);
+      }
+      if (payload.components) {
+        data.components = payload.components.map((c) => serializeComponent(c));
+      }
+      if (payload.poll) {
+        data.poll = {
+          question: payload.poll.question,
+          answers: payload.poll.answers.map((a) => ({
+            ...a.answerId !== void 0 ? { answer_id: a.answerId } : {},
+            poll_media: a.pollMedia
+          })),
+          ...payload.poll.duration !== void 0 ? { duration: payload.poll.duration } : {},
+          ...payload.poll.allowMultiselect !== void 0 ? { allow_multiselect: payload.poll.allowMultiselect } : {},
+          ...payload.poll.layoutType !== void 0 ? { layout_type: payload.poll.layoutType } : {}
+        };
+      }
+      if (payload.files && payload.files.length > 0) {
+        files = payload.files;
+        delete data.files;
       }
     }
-    this.fields = fields;
+    let url = `/webhooks/${webhookId}/${token}`;
+    const params = new URLSearchParams();
+    if (options?.wait) params.append("wait", "true");
+    if (options?.threadId) params.append("thread_id", options.threadId);
+    const qs = params.toString();
+    if (qs) url += `?${qs}`;
+    let result;
+    if (files && files.length > 0) {
+      result = await this.rest.requestWithFiles("POST", url, data, files);
+    } else {
+      result = await this.rest.post(url, data);
+    }
+    if (!result.ok) return result;
+    if (options?.wait && result.data) {
+      const message = buildMessage(result.data, this.store);
+      this.store.messages.set(message.id, message);
+      return { ok: true, data: message };
+    }
+    return { ok: true, data: void 0 };
   }
-  get replied() {
-    return this._replied;
+};
+
+// src/managers/invite.ts
+var InviteManager = class {
+  constructor(rest) {
+    this.rest = rest;
   }
-  get deferred() {
-    return this._deferred;
+  rest;
+  async fetch(code, options) {
+    let url = `/invites/${code}`;
+    if (options) {
+      const params = new URLSearchParams();
+      if (options.withCounts) params.append("with_counts", "true");
+      if (options.withExpiration) params.append("with_expiration", "true");
+      if (options.guildScheduledEventId) params.append("guild_scheduled_event_id", options.guildScheduledEventId);
+      const qs = params.toString();
+      if (qs) url += `?${qs}`;
+    }
+    const result = await this.rest.get(url);
+    if (!result.ok) return result;
+    return { ok: true, data: buildInvite(result.data) };
   }
-  async reply(payload) {
-    if (this._replied || this._deferred) throw new Error("Interaction already acknowledged.");
-    const data = typeof payload === "string" ? { content: payload } : { ...payload };
-    if (typeof payload === "object" && payload.ephemeral) data.flags = 64;
-    await this._client.rest.post(`/interactions/${this.interactionId}/${this.interactionToken}/callback`, {
-      type: 4 /* CHANNEL_MESSAGE_WITH_SOURCE */,
-      data
-    });
-    this._replied = true;
+  async delete(code, reason) {
+    const headers = {};
+    if (reason) headers["X-Audit-Log-Reason"] = encodeURIComponent(reason);
+    const result = await this.rest.delete(`/invites/${code}`, headers);
+    if (!result.ok) return result;
+    return { ok: true, data: buildInvite(result.data) };
   }
-  async defer(options) {
-    if (this._replied || this._deferred) throw new Error("Interaction already acknowledged.");
-    await this._client.rest.post(`/interactions/${this.interactionId}/${this.interactionToken}/callback`, {
-      type: 5 /* DEFERRED_CHANNEL_MESSAGE_WITH_SOURCE */,
-      data: {
-        flags: options?.ephemeral ? 64 : 0
-      }
-    });
-    this._deferred = true;
+};
+
+// src/managers/automod.ts
+var AutoModerationManager = class {
+  constructor(rest, store) {
+    this.rest = rest;
+    this.store = store;
   }
-  async update(payload) {
-    if (this._replied || this._deferred) throw new Error("Interaction already acknowledged.");
-    const data = typeof payload === "string" ? { content: payload } : { ...payload };
-    await this._client.rest.post(`/interactions/${this.interactionId}/${this.interactionToken}/callback`, {
-      type: 7 /* UPDATE_MESSAGE */,
-      data
+  rest;
+  store;
+  async list(guildId) {
+    const result = await this.rest.get(`/guilds/${guildId}/auto-moderation/rules`);
+    if (!result.ok) return result;
+    const rules = result.data.map((r) => {
+      const rule = buildAutoModRule(r);
+      this.store.autoModRules.set(rule.id, rule);
+      return rule;
     });
-    this._replied = true;
+    return { ok: true, data: rules };
   }
-  async deferUpdate() {
-    if (this._replied || this._deferred) throw new Error("Interaction already acknowledged.");
-    await this._client.rest.post(`/interactions/${this.interactionId}/${this.interactionToken}/callback`, {
-      type: 6 /* DEFERRED_UPDATE_MESSAGE */
-    });
-    this._deferred = true;
+  async fetch(guildId, ruleId) {
+    const cached = this.store.autoModRules.get(ruleId);
+    if (cached) return { ok: true, data: cached };
+    const result = await this.rest.get(`/guilds/${guildId}/auto-moderation/rules/${ruleId}`);
+    if (!result.ok) return result;
+    const rule = buildAutoModRule(result.data);
+    this.store.autoModRules.set(rule.id, rule);
+    return { ok: true, data: rule };
   }
-  async followUp(payload) {
-    if (!this._deferred && !this._replied) throw new Error("Interaction not acknowledged. Use reply or defer first.");
-    const data = typeof payload === "string" ? { content: payload } : { ...payload };
-    if (typeof payload === "object" && payload.ephemeral) data.flags = 64;
-    await this._client.rest.post(`/webhooks/${this._client.user?.id}/${this.interactionToken}`, data);
+  async create(guildId, payload, reason) {
+    const headers = {};
+    if (reason) headers["X-Audit-Log-Reason"] = encodeURIComponent(reason);
+    const result = await this.rest.post(`/guilds/${guildId}/auto-moderation/rules`, toSnakeCase(payload), headers);
+    if (!result.ok) return result;
+    const rule = buildAutoModRule(result.data);
+    this.store.autoModRules.set(rule.id, rule);
+    return { ok: true, data: rule };
   }
-  async showModal(modal) {
-    if (this._replied || this._deferred) throw new Error("Interaction already acknowledged.");
-    await this._client.rest.post(`/interactions/${this.interactionId}/${this.interactionToken}/callback`, {
-      type: 9 /* MODAL */,
-      data: modal.type === "modal" ? buildModalPayload(modal) : modal
-    });
-    this._replied = true;
+  async edit(guildId, ruleId, payload, reason) {
+    const headers = {};
+    if (reason) headers["X-Audit-Log-Reason"] = encodeURIComponent(reason);
+    const result = await this.rest.patch(`/guilds/${guildId}/auto-moderation/rules/${ruleId}`, toSnakeCase(payload), headers);
+    if (!result.ok) return result;
+    const rule = buildAutoModRule(result.data);
+    this.store.autoModRules.set(rule.id, rule);
+    return { ok: true, data: rule };
   }
-};
-function buildModalPayload(def) {
-  return {
-    custom_id: def.customId,
-    title: def.title,
-    components: def.fields.map((f) => ({
-      type: 1 /* ACTION_ROW */,
-      components: [{
-        type: 4 /* TEXT_INPUT */,
-        custom_id: f.id,
-        style: f.type,
-        // 1 short, 2 paragraph
-        label: f.label,
-        required: f.required,
-        min_length: f.minLength,
-        max_length: f.maxLength,
-        placeholder: f.placeholder,
-        value: f.value
-      }]
-    }))
-  };
-}
-
-// src/components/define.ts
-function resolveButtonStyle(style) {
-  if (typeof style === "number") return style;
-  const map = { primary: 1, secondary: 2, success: 3, danger: 4, link: 5, premium: 6 };
-  return map[style] ?? 1;
-}
-function defineButton(def) {
-  return { ...def, type: "button" };
-}
-function defineStringSelect(def) {
-  return { ...def, type: "string_select" };
-}
-function defineUserSelect(def) {
-  return { ...def, type: "user_select" };
-}
-function defineRoleSelect(def) {
-  return { ...def, type: "role_select" };
-}
-function defineChannelSelect(def) {
-  return { ...def, type: "channel_select" };
-}
-function defineMentionableSelect(def) {
-  return { ...def, type: "mentionable_select" };
-}
-var field = {
-  short: (id, label, options) => ({
-    id,
-    type: 1 /* SHORT */,
-    label,
-    required: options?.required ?? true,
-    ...options
-  }),
-  paragraph: (id, label, options) => ({
-    id,
-    type: 2 /* PARAGRAPH */,
-    label,
-    required: options?.required ?? true,
-    ...options
-  })
-};
-function defineModal(def) {
-  return { ...def, type: "modal" };
-}
-
-// src/components/actionRow.ts
-var ActionRow = {
-  of: (...components) => {
-    return {
-      type: 1 /* ACTION_ROW */,
-      components: components.map((c) => {
-        if (c.type === "button") {
-          return {
-            type: 2 /* BUTTON */,
-            custom_id: c.customId,
-            url: c.url,
-            label: c.label,
-            style: resolveButtonStyle(c.style),
-            disabled: c.disabled,
-            emoji: c.emoji,
-            sku_id: c.skuId
-          };
-        }
-        if (c.type === "string_select") {
-          return {
-            type: 3 /* STRING_SELECT */,
-            custom_id: c.customId,
-            options: c.options,
-            placeholder: c.placeholder,
-            min_values: c.minValues,
-            max_values: c.maxValues,
-            disabled: c.disabled
-          };
-        }
-        if (c.type === "user_select") {
-          return { type: 5 /* USER_SELECT */, custom_id: c.customId, placeholder: c.placeholder, min_values: c.minValues, max_values: c.maxValues, disabled: c.disabled };
-        }
-        if (c.type === "role_select") {
-          return { type: 6 /* ROLE_SELECT */, custom_id: c.customId, placeholder: c.placeholder, min_values: c.minValues, max_values: c.maxValues, disabled: c.disabled };
-        }
-        if (c.type === "mentionable_select") {
-          return { type: 7 /* MENTIONABLE_SELECT */, custom_id: c.customId, placeholder: c.placeholder, min_values: c.minValues, max_values: c.maxValues, disabled: c.disabled };
-        }
-        if (c.type === "channel_select") {
-          return { type: 8 /* CHANNEL_SELECT */, custom_id: c.customId, channel_types: c.channelTypes, placeholder: c.placeholder, min_values: c.minValues, max_values: c.maxValues, disabled: c.disabled };
-        }
-        if (c.type === 1 /* SHORT */ || c.type === 2 /* PARAGRAPH */) {
-          return {
-            type: 4 /* TEXT_INPUT */,
-            custom_id: c.id,
-            style: c.type,
-            label: c.label,
-            required: c.required,
-            min_length: c.minLength,
-            max_length: c.maxLength,
-            placeholder: c.placeholder,
-            value: c.value
-          };
-        }
-        return c;
-      }).map((obj) => {
-        const clean = {};
-        for (const [k, v] of Object.entries(obj)) {
-          if (v !== void 0) clean[k] = v;
-        }
-        return clean;
-      })
-    };
+  async delete(guildId, ruleId, reason) {
+    const headers = {};
+    if (reason) headers["X-Audit-Log-Reason"] = encodeURIComponent(reason);
+    const result = await this.rest.delete(`/guilds/${guildId}/auto-moderation/rules/${ruleId}`, headers);
+    if (result.ok) this.store.autoModRules.delete(ruleId);
+    return result;
   }
 };
 
-// src/components/manager.ts
-var ComponentManager = class {
-  constructor(client) {
-    this.client = client;
+// src/managers/scheduled.ts
+var ScheduledEventManager = class {
+  constructor(rest, store) {
+    this.rest = rest;
+    this.store = store;
   }
-  client;
-  handlers = /* @__PURE__ */ new Map();
-  register(...components) {
-    for (const comp of components) {
-      if (comp.customId) {
-        this.handlers.set(comp.customId, comp);
-      }
-    }
+  rest;
+  store;
+  async list(guildId, withUserCount) {
+    let url = `/guilds/${guildId}/scheduled-events`;
+    if (withUserCount) url += "?with_user_count=true";
+    const result = await this.rest.get(url);
+    if (!result.ok) return result;
+    const events = result.data.map((e) => {
+      const event = buildScheduledEvent(e);
+      this.store.scheduledEvents.set(event.id, event);
+      return event;
+    });
+    return { ok: true, data: events };
+  }
+  async fetch(guildId, eventId, withUserCount) {
+    const cached = this.store.scheduledEvents.get(eventId);
+    if (cached && !withUserCount) return { ok: true, data: cached };
+    let url = `/guilds/${guildId}/scheduled-events/${eventId}`;
+    if (withUserCount) url += "?with_user_count=true";
+    const result = await this.rest.get(url);
+    if (!result.ok) return result;
+    const event = buildScheduledEvent(result.data);
+    this.store.scheduledEvents.set(event.id, event);
+    return { ok: true, data: event };
   }
-  async handleInteraction(raw) {
-    const data = raw.data;
-    const customId = data.custom_id;
-    if (!customId) return;
-    const handler = this.handlers.get(customId);
-    if (!handler || !handler.execute) return;
-    const user = buildUser(raw.user ?? raw.member?.user);
-    let guild;
-    if (raw.guild_id) {
-      guild = this.client.cache.guilds.get(raw.guild_id) ?? { id: raw.guild_id };
-    }
-    let channel;
-    if (raw.channel_id) {
-      channel = resolveChannel(raw.channel_id, this.client.cache) ?? { id: raw.channel_id };
-    }
-    if (data.resolved?.members && data.resolved?.users && raw.guild_id) {
-      for (const [id, memberData] of Object.entries(data.resolved.members)) {
-        const userData = data.resolved.users[id];
-        if (userData) {
-          const mergedMember = { ...memberData, user: userData };
-          const u = buildUser(userData);
-          this.client.cache.users.set(u.id, u);
-        }
-      }
-    }
-    const ctx = new ComponentContext2(this.client, raw, user, guild, channel);
-    if (handler.type === "user_select" && data.resolved?.users) {
-      ctx.values = ctx.values.map((id) => {
-        const uData = data.resolved.users[id];
-        return uData ? buildUser(uData) : { id };
-      });
-    } else if (handler.type === "channel_select" && data.resolved?.channels) {
-      ctx.values = ctx.values.map((id) => {
-        const cData = data.resolved.channels[id];
-        return cData ? buildChannel(cData, raw.guild_id) : { id };
-      });
-    }
-    try {
-      await handler.execute(ctx);
-    } catch (err) {
-      console.error(`[COMPONENTS] Error executing component ${customId}:`, err);
+  async create(guildId, payload, reason) {
+    const headers = {};
+    if (reason) headers["X-Audit-Log-Reason"] = encodeURIComponent(reason);
+    const result = await this.rest.post(`/guilds/${guildId}/scheduled-events`, toSnakeCase(payload), headers);
+    if (!result.ok) return result;
+    const event = buildScheduledEvent(result.data);
+    this.store.scheduledEvents.set(event.id, event);
+    return { ok: true, data: event };
+  }
+  async edit(guildId, eventId, payload, reason) {
+    const headers = {};
+    if (reason) headers["X-Audit-Log-Reason"] = encodeURIComponent(reason);
+    const result = await this.rest.patch(`/guilds/${guildId}/scheduled-events/${eventId}`, toSnakeCase(payload), headers);
+    if (!result.ok) return result;
+    const event = buildScheduledEvent(result.data);
+    this.store.scheduledEvents.set(event.id, event);
+    return { ok: true, data: event };
+  }
+  async delete(guildId, eventId) {
+    const result = await this.rest.delete(`/guilds/${guildId}/scheduled-events/${eventId}`);
+    if (result.ok) this.store.scheduledEvents.delete(eventId);
+    return result;
+  }
+  async getUsers(guildId, eventId, options) {
+    let url = `/guilds/${guildId}/scheduled-events/${eventId}/users`;
+    if (options) {
+      const params = new URLSearchParams();
+      if (options.limit) params.append("limit", options.limit.toString());
+      if (options.withMember) params.append("with_member", "true");
+      if (options.before) params.append("before", options.before);
+      if (options.after) params.append("after", options.after);
+      const qs = params.toString();
+      if (qs) url += `?${qs}`;
     }
+    const result = await this.rest.get(url);
+    if (!result.ok) return result;
+    const users = result.data.map((data) => {
+      return {
+        guildScheduledEventId: data.guild_scheduled_event_id,
+        user: buildUser(data.user),
+        member: data.member
+      };
+    });
+    return { ok: true, data: users };
   }
 };
 
-// src/managers/base.ts
-var BaseManager = class {
+// src/managers/entitlement.ts
+var EntitlementManager = class {
   constructor(rest, store) {
     this.rest = rest;
     this.store = store;
   }
   rest;
   store;
-  async fetch(id, force = false) {
-    if (!force) {
-      const tongue2 = this.store[this.storeKey];
-      const cached = tongue2.get(id);
-      if (cached) return { ok: true, data: cached };
+  async list(applicationId, options) {
+    let url = `/applications/${applicationId}/entitlements`;
+    if (options) {
+      const params = new URLSearchParams();
+      if (options.userId) params.append("user_id", options.userId);
+      if (options.skuIds) params.append("sku_ids", options.skuIds.join(","));
+      if (options.before) params.append("before", options.before);
+      if (options.after) params.append("after", options.after);
+      if (options.limit) params.append("limit", options.limit.toString());
+      if (options.guildId) params.append("guild_id", options.guildId);
+      if (options.excludeEnded) params.append("exclude_ended", "true");
+      const qs = params.toString();
+      if (qs) url += `?${qs}`;
     }
-    const result = await this.rest.get(this.endpoint(id));
+    const result = await this.rest.get(url);
     if (!result.ok) return result;
-    const entity = this.build(result.data);
-    const tongue = this.store[this.storeKey];
-    tongue.set(id, entity);
-    return { ok: true, data: entity };
+    const entitlements = result.data.map((e) => buildEntitlement(e));
+    return { ok: true, data: entitlements };
   }
-};
-
-// src/managers/user.ts
-var UserManager = class extends BaseManager {
-  storeKey = "users";
-  endpoint(id) {
-    return `/users/${id}`;
+  async fetch(applicationId, entitlementId) {
+    const result = await this.rest.get(`/applications/${applicationId}/entitlements/${entitlementId}`);
+    if (!result.ok) return result;
+    return { ok: true, data: buildEntitlement(result.data) };
+  }
+  async createTest(applicationId, payload) {
+    const result = await this.rest.post(`/applications/${applicationId}/entitlements`, toSnakeCase(payload));
+    if (!result.ok) return result;
+    return { ok: true, data: buildEntitlement(result.data) };
+  }
+  async deleteTest(applicationId, entitlementId) {
+    const result = await this.rest.delete(`/applications/${applicationId}/entitlements/${entitlementId}`);
+    return result;
   }
-  build = buildUser;
 };
 
-// src/managers/guild.ts
-var GuildManager = class extends BaseManager {
-  storeKey = "guilds";
-  endpoint(id) {
-    return `/guilds/${id}`;
+// src/managers/stage.ts
+var StageInstanceManager = class {
+  constructor(rest, store) {
+    this.rest = rest;
+    this.store = store;
   }
-  build = buildGuild;
-  async fetchChannels(guildId) {
-    const result = await this.rest.get(`/guilds/${guildId}/channels`);
+  rest;
+  store;
+  async fetch(channelId) {
+    const cached = Array.from(this.store.stageInstances.values()).find((s) => s.channelId === channelId);
+    if (cached) return { ok: true, data: cached };
+    const result = await this.rest.get(`/stage-instances/${channelId}`);
     if (!result.ok) return result;
-    const channels = result.data.map((raw) => buildChannel(raw, guildId));
-    for (const c of channels) {
-      this.store.channels.set(c.id, c);
-    }
-    return { ok: true, data: channels };
+    const stage = buildStageInstance(result.data);
+    this.store.stageInstances.set(stage.id, stage);
+    return { ok: true, data: stage };
   }
-  async ban(guildId, userId, options) {
-    const payload = {};
-    if (options?.deleteMessageSeconds !== void 0) payload.delete_message_seconds = options.deleteMessageSeconds;
+  async create(payload, reason) {
     const headers = {};
-    if (options?.reason) headers["X-Audit-Log-Reason"] = encodeURIComponent(options.reason);
-    const result = await this.rest.put(`/guilds/${guildId}/bans/${userId}`, payload, headers);
-    return result;
+    if (reason) headers["X-Audit-Log-Reason"] = encodeURIComponent(reason);
+    const result = await this.rest.post(`/stage-instances`, toSnakeCase(payload), headers);
+    if (!result.ok) return result;
+    const stage = buildStageInstance(result.data);
+    this.store.stageInstances.set(stage.id, stage);
+    return { ok: true, data: stage };
   }
-  async unban(guildId, userId, reason) {
+  async edit(channelId, payload, reason) {
     const headers = {};
     if (reason) headers["X-Audit-Log-Reason"] = encodeURIComponent(reason);
-    const result = await this.rest.delete(`/guilds/${guildId}/bans/${userId}`, headers);
-    return result;
+    const result = await this.rest.patch(`/stage-instances/${channelId}`, toSnakeCase(payload), headers);
+    if (!result.ok) return result;
+    const stage = buildStageInstance(result.data);
+    this.store.stageInstances.set(stage.id, stage);
+    return { ok: true, data: stage };
   }
-  async kick(guildId, userId, reason) {
+  async delete(channelId, reason) {
     const headers = {};
     if (reason) headers["X-Audit-Log-Reason"] = encodeURIComponent(reason);
-    const result = await this.rest.delete(`/guilds/${guildId}/members/${userId}`, headers);
+    const result = await this.rest.delete(`/stage-instances/${channelId}`, headers);
     if (result.ok) {
-      this.store.members.delete(TongueStore.memberKey(guildId, userId));
+      const cached = Array.from(this.store.stageInstances.values()).find((s) => s.channelId === channelId);
+      if (cached) this.store.stageInstances.delete(cached.id);
     }
     return result;
   }
 };
 
-// src/managers/channel.ts
-var ChannelManager = class extends BaseManager {
-  storeKey = "channels";
-  endpoint(id) {
-    return `/channels/${id}`;
-  }
-  build = buildChannel;
-};
-
-// src/managers/member.ts
-var MemberManager = class {
-  constructor(rest, store, guildId) {
+// src/managers/template.ts
+var TemplateManager = class {
+  constructor(rest) {
     this.rest = rest;
-    this.store = store;
-    this.guildId = guildId;
   }
   rest;
-  store;
-  guildId;
-  async fetch(userId, force = false) {
-    const cacheKey = TongueStore.memberKey(this.guildId, userId);
-    if (!force) {
-      const cached = this.store.members.get(cacheKey);
-      if (cached) return { ok: true, data: cached };
-    }
-    const result = await this.rest.get(`/guilds/${this.guildId}/members/${userId}`);
+  async fetch(code) {
+    const result = await this.rest.get(`/guilds/templates/${code}`);
     if (!result.ok) return result;
-    const member = buildMember(result.data, this.guildId, this.store);
-    this.store.members.set(cacheKey, member);
-    return { ok: true, data: member };
+    return { ok: true, data: toCamelCase(result.data) };
+  }
+  async createGuildFromTemplate(code, payload) {
+    const result = await this.rest.post(`/guilds/templates/${code}`, toSnakeCase(payload));
+    return result;
+  }
+  async list(guildId) {
+    const result = await this.rest.get(`/guilds/${guildId}/templates`);
+    if (!result.ok) return result;
+    return { ok: true, data: result.data.map((t) => toCamelCase(t)) };
+  }
+  async create(guildId, payload) {
+    const result = await this.rest.post(`/guilds/${guildId}/templates`, toSnakeCase(payload));
+    if (!result.ok) return result;
+    return { ok: true, data: toCamelCase(result.data) };
+  }
+  async sync(guildId, code) {
+    const result = await this.rest.put(`/guilds/${guildId}/templates/${code}`);
+    if (!result.ok) return result;
+    return { ok: true, data: toCamelCase(result.data) };
+  }
+  async edit(guildId, code, payload) {
+    const result = await this.rest.patch(`/guilds/${guildId}/templates/${code}`, toSnakeCase(payload));
+    if (!result.ok) return result;
+    return { ok: true, data: toCamelCase(result.data) };
+  }
+  async delete(guildId, code) {
+    const result = await this.rest.delete(`/guilds/${guildId}/templates/${code}`);
+    if (!result.ok) return result;
+    return { ok: true, data: toCamelCase(result.data) };
   }
 };
 
-// src/managers/message.ts
-var MessageManager = class {
-  constructor(rest, store) {
+// src/managers/application.ts
+var ApplicationManager = class {
+  constructor(rest, _client) {
     this.rest = rest;
-    this.store = store;
+    this._client = _client;
   }
   rest;
-  store;
-  async fetch(channelId, messageId, force = false) {
-    if (!force) {
-      const cached = this.store.messages.get(messageId);
-      if (cached) return { ok: true, data: cached };
-    }
-    const result = await this.rest.get(`/channels/${channelId}/messages/${messageId}`);
+  _client;
+  async fetch() {
+    const result = await this.rest.get("/oauth2/applications/@me");
     if (!result.ok) return result;
-    const message = buildMessage(result.data, this.store);
-    this.store.messages.set(message.id, message);
-    return { ok: true, data: message };
+    return { ok: true, data: result.data };
   }
-  async send(channelId, payload) {
-    const data = typeof payload === "string" ? { content: payload } : payload;
-    const result = await this.rest.post(`/channels/${channelId}/messages`, data);
+  async fetchRoleConnectionMetadata() {
+    if (!this._client.user?.id) {
+      return { ok: false, status: 400, message: "Client not ready" };
+    }
+    const result = await this.rest.get(`/applications/${this._client.user.id}/role-connections/metadata`);
     if (!result.ok) return result;
-    const message = buildMessage(result.data, this.store);
-    this.store.messages.set(message.id, message);
-    return { ok: true, data: message };
+    return { ok: true, data: result.data };
   }
-  async edit(channelId, messageId, payload) {
-    const data = typeof payload === "string" ? { content: payload } : payload;
-    const result = await this.rest.patch(`/channels/${channelId}/messages/${messageId}`, data);
+  async editRoleConnectionMetadata(records) {
+    if (!this._client.user?.id) {
+      return { ok: false, status: 400, message: "Client not ready" };
+    }
+    const result = await this.rest.put(`/applications/${this._client.user.id}/role-connections/metadata`, records);
     if (!result.ok) return result;
-    const oldMsg = this.store.messages.get(messageId);
-    const message = buildMessage(result.data, this.store, oldMsg);
-    this.store.messages.set(message.id, message);
-    return { ok: true, data: message };
+    return { ok: true, data: result.data };
   }
-  async delete(channelId, messageId) {
-    const result = await this.rest.delete(`/channels/${channelId}/messages/${messageId}`);
-    if (result.ok) {
-      this.store.messages.delete(messageId);
+};
+
+// src/builders/attachment.ts
+import * as fs2 from "fs";
+import * as path2 from "path";
+var AttachmentBuilder = class {
+  name;
+  data;
+  description;
+  contentType;
+  constructor(data, options) {
+    if (typeof data === "string") {
+      const resolved = path2.resolve(data);
+      this.data = fs2.readFileSync(resolved);
+      this.name = options?.name ?? path2.basename(resolved);
+    } else {
+      this.data = data;
+      this.name = options?.name ?? "file.bin";
     }
-    return result;
+    if (options?.description !== void 0) this.description = options.description;
+    if (options?.contentType !== void 0) this.contentType = options.contentType;
+  }
+  setName(name) {
+    this.name = name;
+    return this;
+  }
+  setDescription(description) {
+    this.description = description;
+    return this;
+  }
+  toAttachmentJSON(index) {
+    return {
+      id: index,
+      filename: this.name,
+      ...this.description ? { description: this.description } : {}
+    };
   }
 };
 
-// src/managers/collector.ts
-var CollectorManager = class {
-  constructor(client) {
-    this.client = client;
+// src/managers/soundboard.ts
+var SoundboardManager = class {
+  constructor(rest) {
+    this.rest = rest;
   }
-  client;
-  /**
-   * Waits for a specified number of messages in a given channel that pass the filter, if the time limit
-   * is reached, resolves with the messages collected so far
-   */
-  async awaitMessages(channelId, options = {}) {
-    const { filter, max = 1, time = 15e3 } = options;
-    return new Promise((resolve2) => {
-      const messages = [];
-      let timeoutId = null;
-      const handler = (data) => {
-        const msg = data.message;
-        if (msg.channelId !== channelId) return;
-        if (filter && !filter(msg)) return;
-        messages.push(msg);
-        if (messages.length >= max) {
-          cleanup();
-          resolve2(messages);
-        }
-      };
-      const cleanup = () => {
-        if (timeoutId) clearTimeout(timeoutId);
-        this.client.off("MESSAGE_CREATE", handler);
-      };
-      this.client.on("MESSAGE_CREATE", handler);
-      if (time > 0) {
-        timeoutId = setTimeout(() => {
-          cleanup();
-          resolve2(messages);
-        }, time);
-      }
-    });
+  rest;
+  async send(channelId, soundId, sourceGuildId) {
+    const payload = {
+      sound_id: soundId
+    };
+    if (sourceGuildId !== void 0) payload.source_guild_id = sourceGuildId;
+    const result = await this.rest.post(`/channels/${channelId}/send-soundboard-sound`, payload);
+    return result;
   }
-  /**
-   * waits for a single component interaction on a specific message,
-   * resolves with the ComponentContext if successful, or null if it timed out
-   */
-  async awaitComponent(messageId, options = {}) {
-    const { filter, time = 15e3 } = options;
-    return new Promise((resolve2) => {
-      let timeoutId = null;
-      const handler = (data) => {
-        const raw = data.interaction;
-        if (raw.type !== 3 /* MESSAGE_COMPONENT */) return;
-        if (raw.message?.id !== messageId) return;
-        const userRaw = raw.member?.user || raw.user;
-        const user = buildUser(userRaw);
-        const ctx = new ComponentContext(
-          this.client,
-          raw,
-          user,
-          raw.guild_id ? resolveGuild(raw.guild_id, this.client.cache) : void 0,
-          raw.channel_id ? resolveChannel(raw.channel_id, this.client.cache) : void 0
-        );
-        if (raw.data.component_type === 3 /* STRING_SELECT */ || raw.data.component_type === 5 /* USER_SELECT */ || raw.data.component_type === 6 /* ROLE_SELECT */ || raw.data.component_type === 7 /* MENTIONABLE_SELECT */ || raw.data.component_type === 8 /* CHANNEL_SELECT */) {
-          ctx._values = raw.data.values || [];
-        }
-        if (filter && !filter(ctx)) return;
-        cleanup();
-        resolve2(ctx);
-      };
-      const cleanup = () => {
-        if (timeoutId) clearTimeout(timeoutId);
-        this.client.off("INTERACTION_CREATE", handler);
-      };
-      this.client.on("INTERACTION_CREATE", handler);
-      if (time > 0) {
-        timeoutId = setTimeout(() => {
-          cleanup();
-          resolve2(null);
-        }, time);
-      }
-    });
+  async fetchDefault() {
+    const result = await this.rest.get("/soundboard-default-sounds");
+    if (!result.ok) return result;
+    return { ok: true, data: result.data };
+  }
+  async fetch(guildId, soundId) {
+    if (soundId) {
+      const result = await this.rest.get(`/guilds/${guildId}/soundboard-sounds/${soundId}`);
+      if (!result.ok) return result;
+      return { ok: true, data: result.data };
+    } else {
+      const result = await this.rest.get(`/guilds/${guildId}/soundboard-sounds`);
+      if (!result.ok) return result;
+      return { ok: true, data: result.data.items };
+    }
+  }
+  async create(guildId, options, reason) {
+    let soundData = options.sound;
+    if (options.sound instanceof AttachmentBuilder) {
+      soundData = `data:${options.sound.contentType ?? "audio/ogg"};base64,${Buffer.from(options.sound.data).toString("base64")}`;
+    }
+    const payload = {
+      name: options.name,
+      sound: soundData
+    };
+    if (options.volume !== void 0) payload.volume = options.volume;
+    if (options.emojiId !== void 0) payload.emoji_id = options.emojiId;
+    if (options.emojiName !== void 0) payload.emoji_name = options.emojiName;
+    const headers = {};
+    if (reason) headers["X-Audit-Log-Reason"] = reason;
+    const result = await this.rest.post(`/guilds/${guildId}/soundboard-sounds`, payload, headers);
+    if (!result.ok) return result;
+    return { ok: true, data: result.data };
+  }
+  async edit(guildId, soundId, options, reason) {
+    const payload = {};
+    if (options.name !== void 0) payload.name = options.name;
+    if (options.volume !== void 0) payload.volume = options.volume;
+    if (options.emojiId !== void 0) payload.emoji_id = options.emojiId;
+    if (options.emojiName !== void 0) payload.emoji_name = options.emojiName;
+    const headers = {};
+    if (reason) headers["X-Audit-Log-Reason"] = reason;
+    const result = await this.rest.patch(`/guilds/${guildId}/soundboard-sounds/${soundId}`, payload, headers);
+    if (!result.ok) return result;
+    return { ok: true, data: result.data };
+  }
+  async delete(guildId, soundId, reason) {
+    const headers = {};
+    if (reason) headers["X-Audit-Log-Reason"] = reason;
+    const result = await this.rest.delete(`/guilds/${guildId}/soundboard-sounds/${soundId}`, headers);
+    return result;
   }
 };
 
@@ -2849,6 +3473,15 @@ var Client = class {
   channels;
   messages;
   collectors;
+  webhooks;
+  invites;
+  autoMod;
+  scheduledEvents;
+  entitlements;
+  stageInstances;
+  templates;
+  application;
+  soundboard;
   listeners = /* @__PURE__ */ new Map();
   middlewares = [];
   constructor(options) {
@@ -2865,6 +3498,16 @@ var Client = class {
     this.channels = new ChannelManager(this.rest, this.cache);
     this.messages = new MessageManager(this.rest, this.cache);
     this.collectors = new CollectorManager(this);
+    this.webhooks = new WebhookManager(this.rest, this.cache);
+    this.invites = new InviteManager(this.rest);
+    this.autoMod = new AutoModerationManager(this.rest, this.cache);
+    this.scheduledEvents = new ScheduledEventManager(this.rest, this.cache);
+    this.entitlements = new EntitlementManager(this.rest, this.cache);
+    this.stageInstances = new StageInstanceManager(this.rest, this.cache);
+    this.templates = new TemplateManager(this.rest);
+    this.application = new ApplicationManager(this.rest, this);
+    this.soundboard = new SoundboardManager(this.rest);
+    this.gateway = new ChameleonGateway({ token: this.token, intents: this.intents });
     let shards = [0];
     let totalShards = 1;
     if (options.sharding === "auto") {
@@ -3079,22 +3722,26 @@ var Client = class {
         }
         if (Array.isArray(d.emojis)) {
           for (const raw of d.emojis) {
-            this.cache.emojis.set(raw.id, raw);
+            const emoji = buildEmoji(raw);
+            if (emoji.id) this.cache.emojis.set(emoji.id, emoji);
           }
         }
         if (Array.isArray(d.stickers)) {
           for (const raw of d.stickers) {
-            this.cache.stickers.set(raw.id, raw);
+            const sticker = buildSticker(raw);
+            this.cache.stickers.set(sticker.id, sticker);
           }
         }
         if (Array.isArray(d.stage_instances)) {
           for (const raw of d.stage_instances) {
-            this.cache.stageInstances.set(raw.id, raw);
+            const stage = buildStageInstance(raw);
+            this.cache.stageInstances.set(stage.id, stage);
           }
         }
         if (Array.isArray(d.guild_scheduled_events)) {
           for (const raw of d.guild_scheduled_events) {
-            this.cache.scheduledEvents.set(raw.id, raw);
+            const event = buildScheduledEvent(raw);
+            this.cache.scheduledEvents.set(event.id, event);
           }
         }
         if (guild.large) {
@@ -3279,7 +3926,7 @@ var Client = class {
         this.dispatch("MESSAGE_CREATE", {
           type: "MESSAGE_CREATE",
           message,
-          channel: resolveChannel(message.channelId, this.cache)
+          channel: resolveChannel(message.channelId, this)
         });
         break;
       }
@@ -3290,7 +3937,7 @@ var Client = class {
         this.dispatch("MESSAGE_UPDATE", {
           type: "MESSAGE_UPDATE",
           message,
-          channel: resolveChannel(message.channelId, this.cache),
+          channel: resolveChannel(message.channelId, this),
           ...oldMessage ? { oldMessage } : {}
         });
         break;
@@ -3383,14 +4030,25 @@ var Client = class {
         }
         this.dispatch("INTERACTION_CREATE", {
           type: "INTERACTION_CREATE",
-          interaction: d
+          interaction: buildInteraction(d, this.cache)
         });
         break;
       }
       case "VOICE_STATE_UPDATE": {
+        const guildId = d.guild_id;
+        const userId = d.user_id;
+        const key = guildId ? TongueStore.memberKey(guildId, userId) : userId;
+        const oldVoiceState = this.cache.voiceStates.get(key);
+        const voiceState = buildVoiceState(d, this.cache);
+        if (!d.channel_id) {
+          this.cache.voiceStates.delete(key);
+        } else {
+          this.cache.voiceStates.set(key, voiceState);
+        }
         this.dispatch("VOICE_STATE_UPDATE", {
           type: "VOICE_STATE_UPDATE",
-          voiceState: d
+          voiceState,
+          ...oldVoiceState ? { oldVoiceState } : {}
         });
         break;
       }
@@ -3438,15 +4096,15 @@ var Client = class {
         break;
       }
       case "ENTITLEMENT_CREATE": {
-        this.dispatch("ENTITLEMENT_CREATE", { type: "ENTITLEMENT_CREATE", entitlement: d });
+        this.dispatch("ENTITLEMENT_CREATE", { type: "ENTITLEMENT_CREATE", entitlement: buildEntitlement(d) });
         break;
       }
       case "ENTITLEMENT_UPDATE": {
-        this.dispatch("ENTITLEMENT_UPDATE", { type: "ENTITLEMENT_UPDATE", entitlement: d });
+        this.dispatch("ENTITLEMENT_UPDATE", { type: "ENTITLEMENT_UPDATE", entitlement: buildEntitlement(d) });
         break;
       }
       case "ENTITLEMENT_DELETE": {
-        this.dispatch("ENTITLEMENT_DELETE", { type: "ENTITLEMENT_DELETE", entitlement: d });
+        this.dispatch("ENTITLEMENT_DELETE", { type: "ENTITLEMENT_DELETE", entitlement: buildEntitlement(d) });
         break;
       }
       case "PRESENCE_UPDATE": {
@@ -3578,7 +4236,7 @@ var Client = class {
         break;
       }
       case "GUILD_EMOJIS_UPDATE": {
-        const emojis = d.emojis;
+        const emojis = d.emojis.map((raw) => buildEmoji(raw));
         for (const emoji of emojis) {
           if (emoji.id) this.cache.emojis.set(emoji.id, emoji);
         }
@@ -3590,7 +4248,7 @@ var Client = class {
         break;
       }
       case "GUILD_STICKERS_UPDATE": {
-        const stickers = d.stickers;
+        const stickers = d.stickers.map((raw) => buildSticker(raw));
         for (const sticker of stickers) {
           this.cache.stickers.set(sticker.id, sticker);
         }
@@ -3602,37 +4260,37 @@ var Client = class {
         break;
       }
       case "STAGE_INSTANCE_CREATE": {
-        const stageInstance = d;
+        const stageInstance = buildStageInstance(d);
         this.cache.stageInstances.set(stageInstance.id, stageInstance);
         this.dispatch("STAGE_INSTANCE_CREATE", { type: "STAGE_INSTANCE_CREATE", stageInstance });
         break;
       }
       case "STAGE_INSTANCE_UPDATE": {
-        const stageInstance = d;
+        const stageInstance = buildStageInstance(d);
         this.cache.stageInstances.set(stageInstance.id, stageInstance);
         this.dispatch("STAGE_INSTANCE_UPDATE", { type: "STAGE_INSTANCE_UPDATE", stageInstance });
         break;
       }
       case "STAGE_INSTANCE_DELETE": {
-        const stageInstance = d;
+        const stageInstance = buildStageInstance(d);
         this.cache.stageInstances.delete(stageInstance.id);
         this.dispatch("STAGE_INSTANCE_DELETE", { type: "STAGE_INSTANCE_DELETE", stageInstance });
         break;
       }
       case "GUILD_SCHEDULED_EVENT_CREATE": {
-        const scheduledEvent = d;
+        const scheduledEvent = buildScheduledEvent(d);
         this.cache.scheduledEvents.set(scheduledEvent.id, scheduledEvent);
         this.dispatch("GUILD_SCHEDULED_EVENT_CREATE", { type: "GUILD_SCHEDULED_EVENT_CREATE", scheduledEvent });
         break;
       }
       case "GUILD_SCHEDULED_EVENT_UPDATE": {
-        const scheduledEvent = d;
+        const scheduledEvent = buildScheduledEvent(d);
         this.cache.scheduledEvents.set(scheduledEvent.id, scheduledEvent);
         this.dispatch("GUILD_SCHEDULED_EVENT_UPDATE", { type: "GUILD_SCHEDULED_EVENT_UPDATE", scheduledEvent });
         break;
       }
       case "GUILD_SCHEDULED_EVENT_DELETE": {
-        const scheduledEvent = d;
+        const scheduledEvent = buildScheduledEvent(d);
         this.cache.scheduledEvents.delete(scheduledEvent.id);
         this.dispatch("GUILD_SCHEDULED_EVENT_DELETE", { type: "GUILD_SCHEDULED_EVENT_DELETE", scheduledEvent });
         break;
@@ -3646,19 +4304,19 @@ var Client = class {
         break;
       }
       case "AUTO_MODERATION_RULE_CREATE": {
-        const rule = d;
+        const rule = buildAutoModRule(d);
         this.cache.autoModRules.set(rule.id, rule);
         this.dispatch("AUTO_MODERATION_RULE_CREATE", { type: "AUTO_MODERATION_RULE_CREATE", rule });
         break;
       }
       case "AUTO_MODERATION_RULE_UPDATE": {
-        const rule = d;
+        const rule = buildAutoModRule(d);
         this.cache.autoModRules.set(rule.id, rule);
         this.dispatch("AUTO_MODERATION_RULE_UPDATE", { type: "AUTO_MODERATION_RULE_UPDATE", rule });
         break;
       }
       case "AUTO_MODERATION_RULE_DELETE": {
-        const rule = d;
+        const rule = buildAutoModRule(d);
         this.cache.autoModRules.delete(rule.id);
         this.dispatch("AUTO_MODERATION_RULE_DELETE", { type: "AUTO_MODERATION_RULE_DELETE", rule });
         break;
@@ -3680,13 +4338,13 @@ var Client = class {
         break;
       }
       case "INTEGRATION_CREATE": {
-        const integration = d;
+        const integration = buildIntegration(d);
         this.cache.integrations.set(integration.id, integration);
         this.dispatch("INTEGRATION_CREATE", { type: "INTEGRATION_CREATE", guildId: d.guild_id, integration });
         break;
       }
       case "INTEGRATION_UPDATE": {
-        const integration = d;
+        const integration = buildIntegration(d);
         this.cache.integrations.set(integration.id, integration);
         this.dispatch("INTEGRATION_UPDATE", { type: "INTEGRATION_UPDATE", guildId: d.guild_id, integration });
         break;
@@ -3752,6 +4410,301 @@ var Chameleon = class {
     };
   }
 };
+
+// src/utils/bitfield.ts
+var BitField = class _BitField {
+  static FLAGS = {};
+  bitfield;
+  constructor(bits = 0n) {
+    this.bitfield = this.constructor.resolve(bits);
+  }
+  has(bit) {
+    const resolved = this.constructor.resolve(bit);
+    return (this.bitfield & resolved) === resolved;
+  }
+  any(bit) {
+    const resolved = this.constructor.resolve(bit);
+    return (this.bitfield & resolved) !== 0n;
+  }
+  add(...bits) {
+    let total = 0n;
+    for (const bit of bits) {
+      total |= this.constructor.resolve(bit);
+    }
+    this.bitfield |= total;
+    return this;
+  }
+  remove(...bits) {
+    let total = 0n;
+    for (const bit of bits) {
+      total |= this.constructor.resolve(bit);
+    }
+    this.bitfield &= ~total;
+    return this;
+  }
+  toArray() {
+    const flags = this.constructor.FLAGS;
+    return Object.keys(flags).filter((flag) => this.has(flags[flag]));
+  }
+  serialize() {
+    const flags = this.constructor.FLAGS;
+    const result = {};
+    for (const [flag, value] of Object.entries(flags)) {
+      result[flag] = this.has(value);
+    }
+    return result;
+  }
+  equals(other) {
+    return this.bitfield === this.constructor.resolve(other);
+  }
+  freeze() {
+    return Object.freeze(this);
+  }
+  toString() {
+    return this.bitfield.toString();
+  }
+  toJSON() {
+    return this.toString();
+  }
+  static resolve(bit) {
+    if (typeof bit === "bigint") return bit;
+    if (typeof bit === "number") return BigInt(bit);
+    if (bit instanceof _BitField) return bit.bitfield;
+    if (typeof bit === "string") {
+      const flag = this.FLAGS[bit];
+      if (flag !== void 0) return flag;
+      const parsed = BigInt(bit);
+      return parsed;
+    }
+    if (Array.isArray(bit)) {
+      return bit.reduce((acc, b) => acc | this.resolve(b), 0n);
+    }
+    throw new TypeError(`Cannot resolve BitField from: ${bit}`);
+  }
+};
+
+// src/types/permissions.ts
+var PermissionsBitField = class _PermissionsBitField extends BitField {
+  static FLAGS = { ...DISCORD_PERMISSIONS };
+  static ALL = Object.values(DISCORD_PERMISSIONS).reduce((a, b) => a | b, 0n);
+  get isAdmin() {
+    return this.has("ADMINISTRATOR");
+  }
+  static from(bits) {
+    return new _PermissionsBitField(bits);
+  }
+};
+var UserFlagsBitField = class extends BitField {
+  static FLAGS = {
+    STAFF: 1n << 0n,
+    PARTNER: 1n << 1n,
+    HYPESQUAD: 1n << 2n,
+    BUG_HUNTER_LEVEL_1: 1n << 3n,
+    HYPESQUAD_ONLINE_HOUSE_1: 1n << 6n,
+    HYPESQUAD_ONLINE_HOUSE_2: 1n << 7n,
+    HYPESQUAD_ONLINE_HOUSE_3: 1n << 8n,
+    PREMIUM_EARLY_SUPPORTER: 1n << 9n,
+    TEAM_PSEUDO_USER: 1n << 10n,
+    BUG_HUNTER_LEVEL_2: 1n << 14n,
+    VERIFIED_BOT: 1n << 16n,
+    VERIFIED_DEVELOPER: 1n << 17n,
+    CERTIFIED_MODERATOR: 1n << 18n,
+    BOT_HTTP_INTERACTIONS: 1n << 19n,
+    ACTIVE_DEVELOPER: 1n << 22n
+  };
+};
+var IntentsBitField = class extends BitField {
+  static FLAGS = {
+    Guilds: 1n << 0n,
+    GuildMembers: 1n << 1n,
+    GuildModeration: 1n << 2n,
+    GuildEmojisAndStickers: 1n << 3n,
+    GuildIntegrations: 1n << 4n,
+    GuildWebhooks: 1n << 5n,
+    GuildInvites: 1n << 6n,
+    GuildVoiceStates: 1n << 7n,
+    GuildPresences: 1n << 8n,
+    GuildMessages: 1n << 9n,
+    GuildMessageReactions: 1n << 10n,
+    GuildMessageTyping: 1n << 11n,
+    DirectMessages: 1n << 12n,
+    DirectMessageReactions: 1n << 13n,
+    DirectMessageTyping: 1n << 14n,
+    MessageContent: 1n << 15n,
+    GuildScheduledEvents: 1n << 16n,
+    AutoModerationConfiguration: 1n << 20n,
+    AutoModerationExecution: 1n << 21n,
+    GuildMessagePolls: 1n << 24n,
+    DirectMessagePolls: 1n << 25n
+  };
+};
+function computeBasePermissions(member, guild) {
+  if (member.roles === void 0) return 0n;
+  const userId = member.user?.id;
+  if (userId && userId === guild.ownerId) return PermissionsBitField.ALL;
+  const everyoneRole = guild.roles.find((r) => r.id === guild.id);
+  let permissions = everyoneRole ? BigInt(everyoneRole.permissions) : 0n;
+  for (const roleId of member.roles) {
+    const role = guild.roles.find((r) => r.id === roleId);
+    if (role) permissions |= BigInt(role.permissions);
+  }
+  if ((permissions & DISCORD_PERMISSIONS.ADMINISTRATOR) === DISCORD_PERMISSIONS.ADMINISTRATOR) {
+    return PermissionsBitField.ALL;
+  }
+  return permissions;
+}
+function computeChannelPermissions(basePermissions, overwrites, memberRoles, memberId) {
+  if ((basePermissions & DISCORD_PERMISSIONS.ADMINISTRATOR) === DISCORD_PERMISSIONS.ADMINISTRATOR) {
+    return PermissionsBitField.ALL;
+  }
+  let permissions = basePermissions;
+  let allow = 0n;
+  let deny = 0n;
+  for (const overwrite of overwrites) {
+    if (overwrite.type === 0) {
+      if (memberRoles.includes(overwrite.id) || overwrites.indexOf(overwrite) === 0) {
+        if (overwrites.indexOf(overwrite) === 0 && !memberRoles.includes(overwrite.id)) {
+          permissions &= ~BigInt(overwrite.deny);
+          permissions |= BigInt(overwrite.allow);
+        } else {
+          allow |= BigInt(overwrite.allow);
+          deny |= BigInt(overwrite.deny);
+        }
+      }
+    }
+  }
+  permissions &= ~deny;
+  permissions |= allow;
+  if (memberId) {
+    const memberOverwrite = overwrites.find((ow) => ow.type === 1 && ow.id === memberId);
+    if (memberOverwrite) {
+      permissions &= ~BigInt(memberOverwrite.deny);
+      permissions |= BigInt(memberOverwrite.allow);
+    }
+  }
+  return permissions;
+}
+
+// src/sharding/manager.ts
+import { EventEmitter } from "events";
+import { fork } from "child_process";
+import * as path3 from "path";
+var Shard = class extends EventEmitter {
+  id;
+  manager;
+  process = null;
+  ready = false;
+  constructor(manager, id) {
+    super();
+    this.manager = manager;
+    this.id = id;
+  }
+  spawn() {
+    return new Promise((resolve4, reject) => {
+      const env = {
+        ...process.env,
+        SHARD_ID: this.id.toString(),
+        SHARD_COUNT: this.manager.totalShards.toString(),
+        DISCORD_TOKEN: this.manager.token
+      };
+      this.process = fork(this.manager.file, [], {
+        env
+      });
+      this.process.on("message", (message) => {
+        this.emit("message", message);
+        this.manager.emit("message", this, message);
+        if (message?.type === "ready") {
+          this.ready = true;
+          this.emit("ready");
+          resolve4(this.process);
+        }
+      });
+      this.process.on("exit", (code, signal) => {
+        this.emit("death", this.process);
+        this.manager.emit("shardDeath", this);
+        this.process = null;
+        this.ready = false;
+        if (this.manager.respawn) {
+          console.warn(`[C-Shard] Shard ${this.id} exited with code ${code} (signal: ${signal})`);
+          setTimeout(() => this.spawn().catch(console.error), 5e3);
+        }
+      });
+      this.process.on("error", (err) => {
+        reject(err);
+      });
+      setTimeout(() => {
+        if (!this.ready) {
+          this.ready = true;
+          this.emit("ready");
+          resolve4(this.process);
+        }
+      }, 3e4);
+    });
+  }
+  send(message) {
+    return new Promise((resolve4, reject) => {
+      if (!this.process) return reject(new Error("Shard is not running"));
+      this.process.send(message, (err) => {
+        if (err) reject(err);
+        else resolve4();
+      });
+    });
+  }
+  kill() {
+    if (this.process) {
+      this.process.removeAllListeners();
+      this.process.kill();
+      this.process = null;
+      this.ready = false;
+    }
+  }
+};
+var CShard = class extends EventEmitter {
+  file;
+  totalShards;
+  token;
+  shards = /* @__PURE__ */ new Map();
+  respawn;
+  constructor(file, options) {
+    super();
+    this.file = path3.resolve(file);
+    this.token = options.token;
+    this.totalShards = typeof options.totalShards === "number" ? options.totalShards : 1;
+    this.respawn = options.respawn ?? true;
+    if (options.totalShards === "auto") {
+      this.totalShards = -1;
+    }
+  }
+  async fetchRecommendedShards() {
+    const rest = new ChameleonREST({ token: this.token });
+    const result = await rest.get("/gateway/bot");
+    if (result.ok && result.data && typeof result.data.shards === "number") {
+      return result.data.shards;
+    }
+    console.warn("[Chameleon Sharding] Failed to fetch recommended shards from Discord API. Falling back to 1.");
+    return 1;
+  }
+  async spawn() {
+    if (this.totalShards === -1) {
+      this.totalShards = await this.fetchRecommendedShards();
+    }
+    for (let i = 0; i < this.totalShards; i++) {
+      const shard = new Shard(this, i);
+      this.shards.set(i, shard);
+      this.emit("shardCreate", shard);
+      await shard.spawn();
+      await new Promise((r) => setTimeout(r, 5e3));
+    }
+    return this.shards;
+  }
+  async broadcast(message) {
+    const promises = [];
+    for (const shard of this.shards.values()) {
+      promises.push(shard.send(message));
+    }
+    return Promise.all(promises);
+  }
+};
 export {
   AUDIT_LOG_EVENT_TYPES,
   ActionRow,
@@ -3763,16 +4716,22 @@ export {
   ApplicationEventWebhookStatus,
   ApplicationFlag,
   ApplicationIntegrationType,
+  ApplicationManager,
   ApplicationRoleConnectionMetadataType,
+  AttachmentBuilder,
   AttachmentFlag,
   AutoModerationActionType,
   AutoModerationEventType,
   AutoModerationKeywordPresetType,
+  AutoModerationManager,
   AutoModerationTriggerType,
+  BaseInteractionContext,
   BaseManager,
+  BitField,
   ButtonBuilder,
   ButtonStyle,
   CHAMELEON_SELF_MAP,
+  CShard,
   Chameleon,
   ChameleonGateway,
   ChameleonREST,
@@ -3780,11 +4739,12 @@ export {
   ChannelManager,
   ChannelType,
   Client,
+  Collection,
   CollectorManager,
   Colors,
   CommandContext,
   CommandManager,
-  ComponentContext2 as ComponentContext,
+  ComponentContext,
   ComponentManager,
   ComponentType,
   DISCORD_GATEWAY_OPCODES,
@@ -3792,6 +4752,7 @@ export {
   DefaultMessageNotificationLevel,
   EmbedBuilder,
   EmbedType,
+  EntitlementManager,
   EntitlementType,
   ExplicitContentFilterLevel,
   ForumLayoutType,
@@ -3805,6 +4766,8 @@ export {
   IntegrationExpireBehavior,
   IntentBits,
   Intents,
+  IntentsBitField,
+  InviteManager,
   InviteTargetType,
   InviteType,
   LobbyMemberFlag,
@@ -3816,34 +4779,56 @@ export {
   MessageReferenceType,
   MessageType,
   ModalBuilder,
+  PermissionsBitField,
   PremiumTier,
   PremiumType,
+  RoleManager,
+  ScheduledEventManager,
   SelectMenuBuilder,
+  Shard,
   SkuFlag,
   SkuType,
   SortOrderType,
+  SoundboardManager,
+  StageInstanceManager,
   StagePrivacyLevel,
   StickerFormatType,
   StickerType,
   SubscriptionStatus,
   SystemChannelFlag,
+  TemplateManager,
   TextInputBuilder,
   Tongue,
   TongueStore,
   UserFlag,
+  UserFlagsBitField,
   UserManager,
   VerificationLevel,
   VideoQualityMode,
   VisibilityType,
+  WebhookManager,
   WebhookType,
+  buildAutoModRule,
   buildChannel,
+  buildEmoji,
+  buildEntitlement,
   buildGuild,
+  buildIntegration,
+  buildInteraction,
+  buildInvite,
   buildMember,
   buildMessage,
-  buildModalPayload,
   buildRole,
+  buildScheduledEvent,
+  buildStageInstance,
+  buildSticker,
+  buildStickerItem,
   buildUser,
+  buildVoiceState,
+  buildWebhook,
   combinePermissions,
+  computeBasePermissions,
+  computeChannelPermissions,
   defineButton,
   defineChannelSelect,
   defineCommand,
@@ -3863,5 +4848,6 @@ export {
   resolveChannel,
   resolveGuild,
   resolveRole,
-  resolveUser
+  resolveUser,
+  serializeComponent
 };