@impulsedev/chameleon 2.0.0 → 3.0.0

package/dist/index.js

@@ -15,6 +15,7 @@ import {
   buildGuild,
   buildIntegration,
   buildInteraction,
+  buildInvite,
   buildMember,
   buildMessage,
   buildRole,
@@ -24,13 +25,15 @@ import {
   buildStickerItem,
   buildUser,
   buildVoiceState,
+  buildWebhook,
   resolveChannel,
   resolveGuild,
   resolveRole,
   resolveUser,
   serializeComponent,
+  toCamelCase,
   toSnakeCase
-} from "./chunk-F2RRJ7OJ.js";
+} from "./chunk-G4SUOXGV.js";
 
 // src/types/user/index.ts
 var UserFlag = {
@@ -602,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
@@ -661,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}`;
@@ -695,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) {
@@ -704,7 +757,7 @@ var Bucket = class {
           this.remaining--;
           try {
             const res = await fn();
-            resolve2(res);
+            resolve4(res);
             break;
           } catch (e) {
             if (e instanceof RateLimitError) {
@@ -724,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) {
@@ -797,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)",
@@ -810,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 } : {}
@@ -860,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
@@ -1542,6 +1651,12 @@ var CommandManager = class {
     }
     this._deployCommands(commands).catch(console.error);
   }
+  registerGuild(guildId, ...commands) {
+    for (const cmd of commands) {
+      this._commands.set(cmd.name, cmd);
+    }
+    this._deployCommands(commands, guildId).catch(console.error);
+  }
   registerComponent(handler) {
     this._components.push(handler);
   }
@@ -1572,13 +1687,15 @@ var CommandManager = class {
       this.register(...commands);
     }
   }
-  async _deployCommands(commands) {
+  async _deployCommands(commands, guildId) {
     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);
+      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 () => {
-        await this._client.rest.put(`/applications/${this._client.user.id}/commands`, payload);
+        const url = guildId ? `/applications/${this._client.user.id}/guilds/${guildId}/commands` : `/applications/${this._client.user.id}/commands`;
+        await this._client.rest.put(url, payload);
       });
     }
   }
@@ -1957,7 +2074,14 @@ var UserManager = class extends BaseManager {
   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-CCZQJXF6.js")).buildChannel(result.data) };
+    return { ok: true, data: (await import("./builders-WHD6LQWX.js")).buildChannel(result.data) };
+  }
+  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 };
   }
 };
 
@@ -2054,6 +2178,56 @@ var MemberManager = class {
     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;
+    });
+    return { ok: true, data: members };
+  }
+  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;
+    });
+    return { ok: true, data: members };
+  }
+  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/managers/guild.ts
@@ -2115,6 +2289,148 @@ var GuildManager = class extends BaseManager {
     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}`;
+    }
+    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 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
@@ -2149,6 +2465,35 @@ var ChannelManager = class extends BaseManager {
     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);
@@ -2159,6 +2504,125 @@ var ChannelManager = class extends BaseManager {
     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 {
+      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 };
+  }
 };
 
 // src/managers/message.ts
@@ -2182,6 +2646,7 @@ var MessageManager = class {
   }
   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);
@@ -2193,8 +2658,37 @@ var MessageManager = class {
         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;
+      }
+    }
+    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);
     }
-    const 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);
@@ -2202,6 +2696,7 @@ var MessageManager = class {
   }
   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);
@@ -2209,8 +2704,17 @@ var MessageManager = class {
       if (payload.components) {
         data.components = payload.components.map((c) => serializeComponent(c));
       }
+      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);
     }
-    const 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);
@@ -2244,43 +2748,139 @@ var MessageManager = class {
     });
     return { ok: true, data: messages };
   }
-};
-
-// src/managers/collector.ts
-var CollectorManager = class {
-  constructor(client) {
-    this.client = client;
+  async react(channelId, messageId, emoji) {
+    const encodedEmoji = encodeURIComponent(emoji);
+    const result = await this.rest.put(`/channels/${channelId}/messages/${messageId}/reactions/${encodedEmoji}/@me`);
+    return result;
   }
-  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);
+  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/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);
       }
     });
   }
@@ -2290,7 +2890,7 @@ var CollectorManager = class {
    */
   async awaitComponent(messageId, options = {}) {
     const { filter, time = 15e3 } = options;
-    return new Promise((resolve2) => {
+    return new Promise((resolve4) => {
       let timeoutId = null;
       const handler = (data) => {
         if (data.type !== "INTERACTION_CREATE") return;
@@ -2309,7 +2909,7 @@ var CollectorManager = class {
         );
         if (filter && !filter(ctx)) return;
         cleanup();
-        resolve2(ctx);
+        resolve4(ctx);
       };
       const cleanup = () => {
         if (timeoutId) clearTimeout(timeoutId);
@@ -2319,13 +2919,539 @@ var CollectorManager = class {
       if (time > 0) {
         timeoutId = setTimeout(() => {
           cleanup();
-          resolve2(null);
+          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;
+      }
+    }
+    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 };
+  }
+};
+
+// src/managers/invite.ts
+var InviteManager = class {
+  constructor(rest) {
+    this.rest = rest;
+  }
+  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 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) };
+  }
+};
+
+// src/managers/automod.ts
+var AutoModerationManager = class {
+  constructor(rest, store) {
+    this.rest = rest;
+    this.store = store;
+  }
+  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;
+    });
+    return { ok: true, data: rules };
+  }
+  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 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 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 };
+  }
+  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/managers/scheduled.ts
+var ScheduledEventManager = class {
+  constructor(rest, store) {
+    this.rest = rest;
+    this.store = store;
+  }
+  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 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/entitlement.ts
+var EntitlementManager = class {
+  constructor(rest, store) {
+    this.rest = rest;
+    this.store = store;
+  }
+  rest;
+  store;
+  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(url);
+    if (!result.ok) return result;
+    const entitlements = result.data.map((e) => buildEntitlement(e));
+    return { ok: true, data: entitlements };
+  }
+  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;
+  }
+};
+
+// src/managers/stage.ts
+var StageInstanceManager = class {
+  constructor(rest, store) {
+    this.rest = rest;
+    this.store = store;
+  }
+  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 stage = buildStageInstance(result.data);
+    this.store.stageInstances.set(stage.id, stage);
+    return { ok: true, data: stage };
+  }
+  async create(payload, reason) {
+    const headers = {};
+    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 edit(channelId, payload, reason) {
+    const headers = {};
+    if (reason) headers["X-Audit-Log-Reason"] = encodeURIComponent(reason);
+    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 delete(channelId, reason) {
+    const headers = {};
+    if (reason) headers["X-Audit-Log-Reason"] = encodeURIComponent(reason);
+    const result = await this.rest.delete(`/stage-instances/${channelId}`, headers);
+    if (result.ok) {
+      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/template.ts
+var TemplateManager = class {
+  constructor(rest) {
+    this.rest = rest;
+  }
+  rest;
+  async fetch(code) {
+    const result = await this.rest.get(`/guilds/templates/${code}`);
+    if (!result.ok) return result;
+    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/application.ts
+var ApplicationManager = class {
+  constructor(rest, _client) {
+    this.rest = rest;
+    this._client = _client;
+  }
+  rest;
+  _client;
+  async fetch() {
+    const result = await this.rest.get("/oauth2/applications/@me");
+    if (!result.ok) return result;
+    return { ok: true, data: result.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;
+    return { ok: true, data: result.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;
+    return { ok: true, data: result.data };
+  }
+};
+
+// 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";
+    }
+    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/soundboard.ts
+var SoundboardManager = class {
+  constructor(rest) {
+    this.rest = rest;
+  }
+  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;
+  }
+  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;
+  }
+};
+
 // src/client/client.ts
 var Client = class {
   token;
@@ -2347,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) {
@@ -2363,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") {
@@ -2890,9 +4035,20 @@ var Client = class {
         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: buildVoiceState(d, this.cache)
+          voiceState,
+          ...oldVoiceState ? { oldVoiceState } : {}
         });
         break;
       }
@@ -3254,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,
@@ -3265,17 +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,
@@ -3283,6 +4739,7 @@ export {
   ChannelManager,
   ChannelType,
   Client,
+  Collection,
   CollectorManager,
   Colors,
   CommandContext,
@@ -3295,6 +4752,7 @@ export {
   DefaultMessageNotificationLevel,
   EmbedBuilder,
   EmbedType,
+  EntitlementManager,
   EntitlementType,
   ExplicitContentFilterLevel,
   ForumLayoutType,
@@ -3308,6 +4766,8 @@ export {
   IntegrationExpireBehavior,
   IntentBits,
   Intents,
+  IntentsBitField,
+  InviteManager,
   InviteTargetType,
   InviteType,
   LobbyMemberFlag,
@@ -3319,26 +4779,34 @@ 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,
@@ -3347,6 +4815,7 @@ export {
   buildGuild,
   buildIntegration,
   buildInteraction,
+  buildInvite,
   buildMember,
   buildMessage,
   buildRole,
@@ -3356,7 +4825,10 @@ export {
   buildStickerItem,
   buildUser,
   buildVoiceState,
+  buildWebhook,
   combinePermissions,
+  computeBasePermissions,
+  computeChannelPermissions,
   defineButton,
   defineChannelSelect,
   defineCommand,