@stoatx/client 0.2.2 → 0.4.0

package/dist/index.js

@@ -1,5 +1,5 @@
 // src/client/Client.ts
-import { EventEmitter } from "events";
+import { EventEmitter as EventEmitter2 } from "events";
 
 // src/gateway/GatewayManager.ts
 import WebSocket from "ws";
@@ -40,7 +40,7 @@ var Base = class _Base {
 };
 
 // src/structures/Message.ts
-import * as util from "util";
+import * as util2 from "util";
 
 // src/structures/Attachment.ts
 var Attachment = class extends Base {
@@ -87,6 +87,306 @@ var Attachment = class extends Base {
 
 // src/structures/Message.ts
 import { decodeTime } from "ulid";
+
+// src/utils/Collector.ts
+import { EventEmitter } from "events";
+
+// src/utils/Collection.ts
+var Collection = class _Collection extends Map {
+  limit;
+  constructor(limit = Infinity) {
+    super();
+    this.limit = limit;
+  }
+  /**
+   * Overrides the default set method to enforce the maximum cache size.
+   */
+  set(key, value) {
+    if (this.limit === 0) return this;
+    if (this.size >= this.limit && !this.has(key)) {
+      const oldestKey = this.keys().next().value;
+      if (oldestKey !== void 0) {
+        this.delete(oldestKey);
+      }
+    }
+    return super.set(key, value);
+  }
+  /**
+   * Finds the first item where the given function returns true.
+   */
+  find(fn) {
+    for (const [key, val] of this) {
+      if (fn(val, key, this)) return val;
+    }
+    return void 0;
+  }
+  /**
+   * Returns a new Collection containing only the items where the function returns true.
+   */
+  filter(fn) {
+    const results = new _Collection();
+    for (const [key, val] of this) {
+      if (fn(val, key, this)) results.set(key, val);
+    }
+    return results;
+  }
+  /**
+   * Maps each item to a new array of values.
+   */
+  map(fn) {
+    const results = [];
+    for (const [key, val] of this) {
+      results.push(fn(val, key, this));
+    }
+    return results;
+  }
+  /**
+   * Gets the very first value in the Collection (based on insertion order).
+   */
+  first() {
+    return this.values().next().value;
+  }
+  /**
+   * Gets the very last value in the Collection.
+   */
+  last() {
+    const arr = Array.from(this.values());
+    return arr[arr.length - 1];
+  }
+  /**
+   * Checks if at least one item matches the condition.
+   */
+  some(fn) {
+    for (const [key, val] of this) {
+      if (fn(val, key, this)) return true;
+    }
+    return false;
+  }
+};
+
+// src/utils/Collector.ts
+var Collector = class extends EventEmitter {
+  client;
+  filter;
+  options;
+  collected;
+  ended = false;
+  _timeout = null;
+  _idletimeout = null;
+  constructor(client, options = {}) {
+    super();
+    this.client = client;
+    this.options = options;
+    this.filter = options.filter ?? (() => true);
+    this.collected = new Collection();
+    if (options.time) {
+      this._timeout = setTimeout(() => this.stop("time"), options.time);
+    }
+    if (options.idle) {
+      this._idletimeout = setTimeout(() => this.stop("idle"), options.idle);
+    }
+  }
+  /**
+   * Evaluates an item and possibly passes it to the collector
+   */
+  handleCollect(item, ...args) {
+    if (this.ended) return;
+    if (!this.filter(item, ...args)) return;
+    const key = this.collect(item, ...args);
+    if (key !== null && key !== void 0) {
+      this.collected.set(key, item);
+      this.emit("collect", item, ...args);
+      if (this._idletimeout) {
+        clearTimeout(this._idletimeout);
+        this._idletimeout = setTimeout(() => this.stop("idle"), this.options.idle);
+      }
+      this.checkEnd();
+    }
+  }
+  /**
+   * Evaluates an item and possibly removes it from the collector
+   */
+  handleDispose(item, ...args) {
+    if (this.ended) return;
+    if (!this.options.dispose) return;
+    const key = this.dispose(item, ...args);
+    if (key !== null && key !== void 0) {
+      this.collected.delete(key);
+      this.emit("dispose", item, ...args);
+      this.checkEnd();
+    }
+  }
+  /**
+   * Stops the collector.
+   */
+  stop(reason = "user") {
+    if (this.ended) return;
+    this.ended = true;
+    if (this._timeout) clearTimeout(this._timeout);
+    if (this._idletimeout) clearTimeout(this._idletimeout);
+    this.removeAllListeners("collect");
+    this.removeAllListeners("dispose");
+    this.emit("end", this.collected, reason);
+  }
+  /**
+   * Check if we should end upon collecting/disposing
+   */
+  checkEnd() {
+    const reason = this.endReason();
+    if (reason) this.stop(reason);
+  }
+  /**
+   * Check if there's a reason to end
+   */
+  endReason() {
+    return null;
+  }
+  /**
+   * Allows iterating over collected items asynchronously.
+   * @example
+   * for await (const [id, message] of collector) {
+   *   console.log(`Received message: ${message.content}`);
+   * }
+   */
+  async *[Symbol.asyncIterator]() {
+    const queue = [];
+    let resolve = null;
+    const onCollect = (item, ...args) => {
+      const key = this.collect(item, ...args);
+      if (key !== null && key !== void 0) {
+        queue.push([key, item]);
+      }
+      if (resolve) {
+        resolve();
+        resolve = null;
+      }
+    };
+    const onEnd = () => {
+      if (resolve) {
+        resolve();
+        resolve = null;
+      }
+    };
+    this.on("collect", onCollect);
+    this.on("end", onEnd);
+    try {
+      while (true) {
+        if (queue.length > 0) {
+          yield queue.shift();
+        } else if (this.ended) {
+          break;
+        } else {
+          await new Promise((res) => {
+            resolve = res;
+          });
+        }
+      }
+    } finally {
+      this.removeListener("collect", onCollect);
+      this.removeListener("end", onEnd);
+    }
+  }
+};
+
+// src/structures/MessageReaction.ts
+import * as util from "util";
+var MessageReaction = class {
+  constructor(client, data) {
+    this.client = client;
+    this.message = data.message;
+    this.emoji = this.client.emojis.cache.get(data.emojiId) || data.emojiId;
+    this.users = new Collection();
+    if (data.users) {
+      for (const userId of data.users) {
+        const user = this.client.users.cache.get(userId) || { id: userId };
+        this.users.set(userId, user);
+      }
+    }
+  }
+  message;
+  emoji;
+  users;
+  get count() {
+    return this.users.size;
+  }
+  async remove() {
+    if (this.message instanceof Message) {
+      const emojiId = typeof this.emoji === "string" ? this.emoji : this.emoji.id;
+      await this.message.removeReaction(emojiId);
+    }
+  }
+  [util.inspect.custom]() {
+    const data = {
+      messageId: this.message.id,
+      emoji: this.emoji,
+      count: this.count,
+      users: Array.from(this.users.keys())
+    };
+    return `MessageReaction ${util.inspect(data)}`;
+  }
+};
+
+// src/utils/ReactionCollector.ts
+var ReactionCollector = class extends Collector {
+  constructor(message, options = {}) {
+    super(message.client, options);
+    this.message = message;
+    this.messageId = message.id;
+    const boundHandleCollect = this.handleMessageReact.bind(this);
+    const boundHandleDispose = this.handleMessageUnreact.bind(this);
+    this.client.on("messageReact", boundHandleCollect);
+    this.client.on("messageUnreact", boundHandleDispose);
+    this.once("end", () => {
+      this.client.removeListener("messageReact", boundHandleCollect);
+      this.client.removeListener("messageUnreact", boundHandleDispose);
+    });
+  }
+  messageId;
+  total = 0;
+  users = /* @__PURE__ */ new Set();
+  collect(reaction) {
+    if (reaction.message.id !== this.messageId) return null;
+    return typeof reaction.emoji === "string" ? reaction.emoji : reaction.emoji.id;
+  }
+  dispose(reaction) {
+    if (reaction.message.id !== this.messageId) return null;
+    return typeof reaction.emoji === "string" ? reaction.emoji : reaction.emoji.id;
+  }
+  handleMessageReact(message, emojiId, userId) {
+    if (message.id !== this.messageId) return;
+    let reaction = this.collected.get(emojiId);
+    if (!reaction) {
+      reaction = new MessageReaction(this.client, { message, emojiId, users: [userId] });
+    } else {
+      const user = this.client.users.cache.get(userId) || { id: userId };
+      reaction.users.set(userId, user);
+    }
+    super.handleCollect(reaction);
+    if (!this.ended && this.collected.has(emojiId)) {
+      this.total++;
+      this.users.add(userId);
+      this.checkEnd();
+    }
+  }
+  handleMessageUnreact(message, emojiId, userId) {
+    if (message.id !== this.messageId) return;
+    const reaction = this.collected.get(emojiId);
+    if (reaction) {
+      reaction.users.delete(userId);
+      if (reaction.users.size === 0) {
+        super.handleDispose(reaction);
+      }
+    }
+  }
+  endReason() {
+    const options = this.options;
+    if (options.max && this.total >= options.max) return "limit";
+    if (options.maxUsers && this.users.size >= options.maxUsers) return "userLimit";
+    return null;
+  }
+};
+
+// src/structures/Message.ts
 var Message = class extends Base {
   content = null;
   authorId;
@@ -100,7 +400,7 @@ var Message = class extends Base {
   masquerade = null;
   mentions = [];
   pinned = false;
-  reactions = [];
+  reactions = {};
   replies = [];
   role_mentions = [];
   constructor(client, data) {
@@ -168,6 +468,78 @@ var Message = class extends Base {
     if (!channel) channel = await this.client.channels.fetch(this.channelId);
     await channel.messages.unpin(this.id);
   }
+  /**
+   * React to this message
+   * @param reaction The emoji to react with. Can be a Unicode emoji or a custom emoji ID.
+   * @throws {Error} If the API request fails.
+   * @example
+   * await message.react("👍");
+   * await message.react("customEmojiId");
+   */
+  async react(reaction) {
+    let channel = this.channel;
+    if (!channel) channel = await this.client.channels.fetch(this.channelId);
+    await channel.messages.react(this.id, reaction);
+  }
+  /**
+   * Remove a reaction from this message
+   * @param reaction The emoji to remove. Can be a Unicode emoji or a custom emoji ID.
+   * @param userId The ID of the user whose reaction to remove. If not provided, removes the current user's reaction.
+   * @param removeAll Remove all reactions of this type.
+   * @throws {Error} If both userId and removeAll are provided, or if the API request fails.
+   * @example
+   * // Remove the current user's reaction
+   * await message.removeReaction("👍");
+   * // Remove a specific user's reaction
+   * await message.removeReaction("👍", userId);
+   * // Remove all reactions of this type
+   * await message.removeReaction("👍", undefined, true);
+   */
+  async removeReaction(reaction, userId, removeAll) {
+    let channel = this.channel;
+    if (!channel) channel = await this.client.channels.fetch(this.channelId);
+    await channel.messages.removeReaction(this.id, reaction, userId, removeAll);
+  }
+  /**
+   * Remove all reactions from this message
+   * @throws {Error} If the API request fails.
+   * @example
+   * await message.clearReactions();
+   */
+  async clearReactions() {
+    let channel = this.channel;
+    if (!channel) channel = await this.client.channels.fetch(this.channelId);
+    await channel.messages.clearReactions(this.id);
+  }
+  /**
+   * Creates a ReactionCollector to collect reactions on this message.
+   * @param options The options for the collector.
+   * @returns A new ReactionCollector instance.
+   * @example
+   * const collector = message.createReactionCollector({ time: 15000 });
+   * collector.on('collect', (reaction) => console.log(`Collected ${reaction.emojiId} from ${reaction.userId}`));
+   * collector.on('end', (collected) => console.log(`Collected ${collected.size} items`));
+   */
+  createReactionCollector(options) {
+    return new ReactionCollector(this, options);
+  }
+  /**
+   * Awaits reactions on this message.
+   * @param options The options for the collector.
+   * @returns A promise that resolves to a collection of reactions collected.
+   * @example
+   * // Await reactions
+   * const filter = (reaction) => reaction.emoji.id === '123' && reaction.users.has(author.id);
+   * message.awaitReactions({ filter, max: 1, time: 60000 })
+   *   .then(collected => console.log(collected.size))
+   *   .catch(console.error);
+   */
+  awaitReactions(options) {
+    return new Promise((resolve) => {
+      const collector = this.createReactionCollector(options);
+      collector.once("end", (collected) => resolve(collected));
+    });
+  }
   /** Gets the Channel object from cache */
   get channel() {
     return this.client.channels.cache.get(this.channelId);
@@ -205,7 +577,9 @@ var Message = class extends Base {
     if (data.pinned !== void 0) this.pinned = data.pinned;
     if (data.embeds !== void 0) this.embeds = data.embeds;
     if (data.flags !== void 0) this.flags = data.flags;
-    if (data.reactions !== void 0) this.reactions = data.reactions;
+    if (data.reactions !== void 0) {
+      this.reactions = Array.isArray(data.reactions) ? {} : data.reactions;
+    }
     if (data.interactions !== void 0) {
       if (data.interactions) {
         this.interactions = {
@@ -218,7 +592,7 @@ var Message = class extends Base {
     }
   }
   // This tells Node.js exactly how to print this object in console.log()
-  [util.inspect.custom](depth, options, inspect10) {
+  [util2.inspect.custom](depth, options, inspect12) {
     const { client, authorId, channelId, ...props } = this;
     const data = {
       ...props,
@@ -227,7 +601,7 @@ var Message = class extends Base {
       server: this.server,
       member: this.member
     };
-    return `${this.constructor.name} ${inspect10(data, { ...options, depth: depth ?? options.depth })}`;
+    return `${this.constructor.name} ${inspect12(data, { ...options, depth: depth ?? options.depth })}`;
   }
 };
 
@@ -389,6 +763,17 @@ var GatewayManager = class {
             }
           }
         }
+        if (payload.emojis) {
+          for (const rawEmoji of payload.emojis) {
+            const emoji = this.client.emojis._add(rawEmoji);
+            if (rawEmoji.parent && rawEmoji.parent.type === "Server") {
+              const server = this.client.servers.cache.get(rawEmoji.parent.id);
+              if (server) {
+                server.emojis._add(emoji);
+              }
+            }
+          }
+        }
         this.client.emit("ready", payload);
         break;
       }
@@ -448,6 +833,60 @@ var GatewayManager = class {
         }
         break;
       }
+      case "MessageReact": {
+        const channel = this.client.channels.cache.get(payload.channel_id);
+        const message = channel?.messages.cache.get(payload.id);
+        if (message) {
+          if (!message.reactions) message.reactions = {};
+          if (!message.reactions[payload.emoji_id]) {
+            message.reactions[payload.emoji_id] = [];
+          }
+          const reactions = message.reactions[payload.emoji_id];
+          if (reactions && !reactions.includes(payload.user_id)) {
+            reactions.push(payload.user_id);
+          }
+        }
+        this.client.emit(
+          "messageReact",
+          message || { id: payload.id, channelId: payload.channel_id },
+          payload.emoji_id,
+          payload.user_id
+        );
+        break;
+      }
+      case "MessageUnreact": {
+        const channel = this.client.channels.cache.get(payload.channel_id);
+        const message = channel?.messages.cache.get(payload.id);
+        if (message && message.reactions && message.reactions[payload.emoji_id]) {
+          const reactions = message.reactions[payload.emoji_id];
+          if (reactions) {
+            message.reactions[payload.emoji_id] = reactions.filter((userId) => userId !== payload.user_id);
+            if (message.reactions[payload.emoji_id].length === 0) {
+              delete message.reactions[payload.emoji_id];
+            }
+          }
+        }
+        this.client.emit(
+          "messageUnreact",
+          message || { id: payload.id, channelId: payload.channel_id },
+          payload.emoji_id,
+          payload.user_id
+        );
+        break;
+      }
+      case "MessageRemoveReaction": {
+        const channel = this.client.channels.cache.get(payload.channel_id);
+        const message = channel?.messages.cache.get(payload.id);
+        if (message && message.reactions) {
+          delete message.reactions[payload.emoji_id];
+        }
+        this.client.emit(
+          "messageRemoveReaction",
+          message || { id: payload.id, channelId: payload.channel_id },
+          payload.emoji_id
+        );
+        break;
+      }
       case "Pong":
         this.client.emit("debug", "Received Pong from server.");
         break;
@@ -524,6 +963,27 @@ var GatewayManager = class {
         }
         break;
       }
+      case "EmojiCreate": {
+        const emoji = this.client.emojis._add(payload);
+        if (payload.parent?.type === "Server") {
+          const server = this.client.servers.cache.get(payload.parent.id);
+          if (server) {
+            server.emojis._add(emoji);
+          }
+        }
+        break;
+      }
+      case "EmojiDelete": {
+        this.client.emojis.cache.delete(payload.id);
+        for (const server of this.client.servers.cache.values()) {
+          const emoji = server.emojis.cache.get(payload.id);
+          if (emoji) {
+            server.emojis.cache.delete(payload.id);
+            break;
+          }
+        }
+        break;
+      }
       case "UserUpdate": {
         const existing = this.client.users.cache.get(payload.id);
         if (existing) {
@@ -708,9 +1168,9 @@ var RESTManager = class {
   /**
    * Uploads a file to Stoat's CDN and returns the File ID
    */
-  async uploadFile(filename, fileBuffer) {
+  async uploadFile(tag, fileBuffer, filename) {
     if (!this.token) throw new Error("REST_NOT_READY: No token available.");
-    const url = "https://cdn.stoatusercontent.com/attachments";
+    const url = `https://cdn.stoatusercontent.com/${tag}`;
     const formData = new FormData();
     formData.append("file", new Blob([fileBuffer]), filename);
     const response = await fetch(url, {
@@ -742,89 +1202,16 @@ var RESTManager = class {
   patch(endpoint, body) {
     return this.makeRequest("PATCH", endpoint, body);
   }
-  delete(endpoint) {
-    return this.makeRequest("DELETE", endpoint);
+  delete(endpoint, body) {
+    return this.makeRequest("DELETE", endpoint, body);
   }
   async put(endpoint, body) {
     return this.makeRequest("PUT", endpoint, body);
   }
 };
 
-// src/utils/Collection.ts
-var Collection = class _Collection extends Map {
-  limit;
-  constructor(limit = Infinity) {
-    super();
-    this.limit = limit;
-  }
-  /**
-   * Overrides the default set method to enforce the maximum cache size.
-   */
-  set(key, value) {
-    if (this.limit === 0) return this;
-    if (this.size >= this.limit && !this.has(key)) {
-      const oldestKey = this.keys().next().value;
-      if (oldestKey !== void 0) {
-        this.delete(oldestKey);
-      }
-    }
-    return super.set(key, value);
-  }
-  /**
-   * Finds the first item where the given function returns true.
-   */
-  find(fn) {
-    for (const [key, val] of this) {
-      if (fn(val, key, this)) return val;
-    }
-    return void 0;
-  }
-  /**
-   * Returns a new Collection containing only the items where the function returns true.
-   */
-  filter(fn) {
-    const results = new _Collection();
-    for (const [key, val] of this) {
-      if (fn(val, key, this)) results.set(key, val);
-    }
-    return results;
-  }
-  /**
-   * Maps each item to a new array of values.
-   */
-  map(fn) {
-    const results = [];
-    for (const [key, val] of this) {
-      results.push(fn(val, key, this));
-    }
-    return results;
-  }
-  /**
-   * Gets the very first value in the Collection (based on insertion order).
-   */
-  first() {
-    return this.values().next().value;
-  }
-  /**
-   * Gets the very last value in the Collection.
-   */
-  last() {
-    const arr = Array.from(this.values());
-    return arr[arr.length - 1];
-  }
-  /**
-   * Checks if at least one item matches the condition.
-   */
-  some(fn) {
-    for (const [key, val] of this) {
-      if (fn(val, key, this)) return true;
-    }
-    return false;
-  }
-};
-
 // src/managers/MessageManager.ts
-import * as util2 from "util";
+import * as util3 from "util";
 
 // src/managers/BaseManager.ts
 var BaseManager = class {
@@ -851,6 +1238,42 @@ var BaseManager = class {
   }
 };
 
+// src/builders/AttachmentBuilder.ts
+var AttachmentBuilder = class {
+  // Filename for CDN to use, optional but recommended
+  filename = void 0;
+  file;
+  /**
+   * Creates a new AttachmentBuilder with the given file and optional filename.
+   * @param file The file data as a Buffer or Blob.
+   * @param filename An optional filename to use for the uploaded file. If not provided, the CDN will assign a default name.
+   *                 Providing a filename can help with organization and debugging, but is not strictly required.
+   * @example
+   * // Create an attachment from a Buffer with a custom filename
+   * const buffer = Buffer.from("Hello, world!");
+   * const attachment = new AttachmentBuilder(buffer, "greeting.txt");
+   */
+  constructor(file, filename) {
+    this.filename = filename;
+    this.file = file;
+  }
+  /**
+   * Uploads this attachment to the Stoat CDN and returns the resulting file ID.
+   * @internal — use `resolveAttachment()` instead of calling this directly.
+   */
+  async upload(rest, tag) {
+    return rest.uploadFile(tag, this.file, this.filename);
+  }
+};
+
+// src/utils/resolveAttachment.ts
+async function resolveAttachment(rest, value, tag) {
+  if (value instanceof AttachmentBuilder) {
+    return value.upload(rest, tag);
+  }
+  return value;
+}
+
 // src/managers/MessageManager.ts
 var MessageManager = class extends BaseManager {
   constructor(client, channel, limit = Infinity) {
@@ -926,6 +1349,13 @@ var MessageManager = class extends BaseManager {
         (embed) => typeof embed.toJSON === "function" ? embed.toJSON() : embed
       );
     }
+    if (payload.attachments) {
+      payload.attachments = await Promise.all(
+        payload.attachments.map(
+          (attachment) => resolveAttachment(this.client.rest, attachment, "attachments")
+        )
+      );
+    }
     const data = await this.client.rest.post(`/channels/${this.channel.id}/messages`, payload);
     return new Message(this.client, data);
   }
@@ -980,11 +1410,105 @@ var MessageManager = class extends BaseManager {
     const existing = this.cache.get(id);
     if (existing) existing.pinned = false;
   }
-  [util2.inspect.custom]() {
+  /**
+   * React to a message
+   * @param message The MessageResolvable to react to.
+   * @param reaction The emoji to react with. Can be a Unicode emoji or a custom emoji ID.
+   * @throws {Error} If the API request fails.
+   * @example
+   * await channel.messages.react(messageId, "👍");
+   * await channel.messages.react(messageId, "customEmojiId");
+   */
+  async react(message, reaction) {
+    const id = this.resolveId(message);
+    await this.client.rest.put(`/channels/${this.channel.id}/messages/${id}/reactions/${encodeURIComponent(reaction)}`);
+  }
+  /**
+   * Remove a reaction(s) from a message
+   * Requires ManageMessages if changing others' reactions.
+   * @param reaction The emoji to remove. Can be a unicode emoji or a custom emoji ID.
+   * @param message The MessageResolvable to remove the reaction from.
+   * @param userId The ID of the user whose reaction to remove. If not provided, removes the current user's reaction.
+   * @param removeAll Remove all reactions of this type.
+   * @throws {Error} If both userId and removeAll are provided, or if the API request fails.
+   * @example
+   * // Remove the current user's reaction
+   * await channel.messages.removeReaction(messageId, "👍");
+   * // Remove a specific user's reaction
+   * await channel.messages.removeReaction(messageId, "👍", userId);
+   * // Remove all reactions of this type
+   * await channel.messages.removeReaction(messageId, "👍", undefined, true);
+   */
+  async removeReaction(message, reaction, userId, removeAll) {
+    const id = this.resolveId(message);
+    const targetUser = userId ? this.client.users.resolveId(userId) : void 0;
+    const params = new URLSearchParams();
+    if (targetUser) params.append("user_id", targetUser);
+    if (removeAll) params.append("remove_all", "true");
+    const queryString = params.toString();
+    const endpoint = `/channels/${this.channel.id}/messages/${id}/reactions/${encodeURIComponent(reaction)}${queryString ? `?${queryString}` : ""}`;
+    await this.client.rest.delete(endpoint);
+  }
+  /**
+   * Remove all reactions from a message
+   * Requires ManageMessages permission.
+   * @param message The MessageResolvable to clear reactions from.
+   * @throws {Error} If the API request fails.
+   * @example
+   * await channel.messages.clearReactions(messageId);
+   */
+  async clearReactions(message) {
+    const id = this.resolveId(message);
+    await this.client.rest.delete(`/channels/${this.channel.id}/messages/${id}/reactions`);
+  }
+  [util3.inspect.custom]() {
     return this.cache;
   }
 };
 
+// src/utils/MessageCollector.ts
+var MessageCollector = class extends Collector {
+  constructor(channel, options = {}) {
+    super(channel.client, options);
+    this.channel = channel;
+    this.channelId = channel.id;
+    const boundHandleCollect = this.handleCollect.bind(this);
+    const boundHandleDispose = this.handleDispose.bind(this);
+    this.client.on("messageCreate", boundHandleCollect);
+    this.client.on("messageDelete", boundHandleDispose);
+    this.once("end", () => {
+      this.client.removeListener("messageCreate", boundHandleCollect);
+      this.client.removeListener("messageDelete", boundHandleDispose);
+    });
+  }
+  channelId;
+  total = 0;
+  processed = 0;
+  collect(message) {
+    if (message.channelId !== this.channelId) return null;
+    return message.id;
+  }
+  dispose(message) {
+    if (message.channelId !== this.channelId) return null;
+    return message.id;
+  }
+  handleCollect(message) {
+    if (message.channelId !== this.channelId) return;
+    this.processed++;
+    super.handleCollect(message);
+    if (!this.ended && this.collected.has(message.id)) {
+      this.total++;
+      this.checkEnd();
+    }
+  }
+  endReason() {
+    const options = this.options;
+    if (options.max && this.total >= options.max) return "limit";
+    if (options.maxProcessed && this.processed >= options.maxProcessed) return "processedLimit";
+    return null;
+  }
+};
+
 // src/structures/BaseChannel.ts
 var ChannelType = /* @__PURE__ */ ((ChannelType2) => {
   ChannelType2["TEXT"] = "TextChannel";
@@ -1011,12 +1535,36 @@ var BaseChannel = class extends Base {
   async send(contentOrOptions) {
     return this.messages.send(contentOrOptions);
   }
-  async fetch(force = true) {
+  /**
+   * Fetch this channel
+   * @param force Whether to skip the cache check and force a direct API request. Defaults to false
+   * @throws {Error} If the API request fails
+   * @returns {BaseChannel}
+   * @example
+   * // Force fetch channel to update its data
+   * await channel.fetch(true);
+   */
+  async fetch(force = false) {
     return await this.client.channels.fetch(this.id, force);
   }
   /**
    * Fetches multiple messages from this channel.
    * @param options The query parameters to filter the messages.
+   * @throws {Error} If the API request fails
+   * @returns A Collection of Messages, keyed by their ID.
+   * @example
+   * // Fetch the last 50 messages in the channel
+   * const messages = await channel.fetchMessages({ limit: 50 });
+   * console.log(`Fetched ${messages.size} messages`);
+   * // Fetch messages before a specific message ID
+   * const messages = await channel.fetchMessages({ before: "MESSAGE_ID" });
+   * console.log(`Fetched ${messages.size} messages sent before the specified message`);
+   * // Fetch messages after a specific message ID
+   * const messages = await channel.fetchMessages({ after: "MESSAGE_ID" });
+   * console.log(`Fetched ${messages.size} messages sent after the specified message`);
+   * // Fetch messages around a specific message ID
+   * const messages = await channel.fetchMessages({ around: "MESSAGE_ID", limit: 10 });
+   * console.log(`Fetched ${messages.size} messages sent around the specified message`);
    */
   async fetchMessages(options) {
     return this.messages.fetchMany(options);
@@ -1024,16 +1572,72 @@ var BaseChannel = class extends Base {
   /**
    * Edits this channel.
    * @param options The fields to update
+   * @throws {Error} If the API request fails
+   * @returns BaseChannel
+   * @example
+   * // Edit the channel's name
+   * await channel.edit({name: "New Cool Name"});
    */
   async edit(options) {
     return await this.client.channels.edit(this.id, options);
   }
   /**
    * Deletes this channel.
+   * @throws {Error} If the API request fails
+   * @example
+   * // Delete the channel
+   * await channel.delete();
    */
   async delete() {
     await this.client.channels.delete(this.id);
   }
+  /**
+   * Bulk delete messages from this channel
+   * @param messages MessageResolvable to delete
+   * @throws {Error} If the API request fails
+   * @example
+   * // Delete messages by their ID's
+   * await channel.bulkDelete(["MESSAGE_ID_1", "MESSAGE_ID_2", "MESSAGE_ID_3"]);
+   * // Delete messages by their Message objects
+   * await channel.bulkDelete([message1, message2, message3]);
+   */
+  async bulkDelete(messages) {
+    await this.client.channels.bulkDelete(this.id, messages);
+  }
+  /**
+   * Creates a MessageCollector to collect messages in this channel.
+   * @param options The options for the collector.
+   * @returns The instantiated MessageCollector
+   * @example
+   * const collector = channel.createMessageCollector({ filter: m => m.authorId === '123', time: 15000 });
+   * collector.on('collect', m => console.log(`Collected ${m.content}`));
+   * collector.on('end', collected => console.log(`Collected ${collected.size} items`));
+   */
+  createMessageCollector(options) {
+    return new MessageCollector(this, options);
+  }
+  /**
+   * Awaits messages in this channel that meet certain criteria.
+   * @param options The options for the collector.
+   * @returns A promise that resolves to a collection of messages.
+   * @example
+   * // Await !vote messages
+   * const filter = m => m.content.startsWith('!vote');
+   * channel.awaitMessages({ filter, max: 4, time: 60000 })
+   *   .then(collected => console.log(collected.size))
+   *   .catch(console.error);
+   */
+  awaitMessages(options = {}) {
+    return new Promise((resolve, reject) => {
+      const collector = this.createMessageCollector(options);
+      collector.once("end", (collected, reason) => {
+        if (options.max && reason !== "limit" && reason !== "time") {
+          return reject(new Error(`Collector ended with reason: ${reason}`));
+        }
+        resolve(collected);
+      });
+    });
+  }
   isText() {
     return this.type === "TextChannel" /* TEXT */;
   }
@@ -1077,36 +1681,175 @@ var TextChannel = class extends BaseChannel {
           case "Description":
             this.description = null;
             break;
+          case "Icon":
+            this.icon = null;
+            break;
+          case "DefaultPermissions":
+            this.defaultPermissions = data.default_permissions;
+            break;
+          case "Voice":
+            this.voice = data.voice;
+            break;
         }
       }
     }
   }
   /**
-   * Updates the permission overrides for the channel.
-   * @param roleId The raw string ID of the role to update.
-   * @param options The allow and deny permissions to set.
-   * @returns A promise that resolves to the updated BaseChannel.
-   * @throws {TypeError} If the channel is not a Server Channel, or options are invalid.
-   * @throws {Error} If the API request fails.
+   * Updates the permission overrides for the channel.
+   * @param roleId The raw string ID of the role to update.
+   * @param options The allow and deny permissions to set.
+   * @returns A promise that resolves to the updated BaseChannel.
+   * @throws {TypeError} If the channel is not a Server Channel, or options are invalid.
+   * @throws {Error} If the API request fails.
+   * @example
+   * // Deny a role the ability to send messages in this channel
+   * await channel.setRolePermissions("ROLE_ID", { deny: ["SendMessage"] });
+   */
+  async setRolePermissions(roleId, options) {
+    return await this.client.channels.setRolePermissions(this.id, roleId, options);
+  }
+  /**
+   * Updates the default (everyone) permissions for this channel.
+   * @param permissions The default permissions to grant globally in this channel.
+   * @returns A promise that resolves to the updated BaseChannel.
+   * @throws {TypeError} If invalid permissions are provided.
+   * @throws {Error} If the API request fails.
+   * @example
+   * // Set the default permission to allow everyone to view the channel
+   * await channel.setDefaultPermissions(["ViewChannel", "ReadMessageHistory"]);
+   */
+  async setDefaultPermissions(permissions) {
+    return await this.client.channels.setDefaultPermissions(this.id, permissions);
+  }
+  /**
+   * Edits the category of this channel. Only applicable to server channels.
+   * @param category The ID of the category to move this channel into, or "default" to remove from any category.
+   * @returns The updated TextChannel with the new category.
+   * @throws {Error} If the channel is not a server channel, if the category is not found in the server, or if the API request fails.
+   * @example
+   * // Move this channel into a category
+   * await channel.setCategory("CATEGORY_ID");
+   * // Remove this channel from its category
+   * await channel.setCategory("default");
+   */
+  async setCategory(category) {
+    const serverId = this.serverId;
+    const server = await this.client.servers.fetch(serverId);
+    const categories = server.categories.map((c) => ({
+      id: c.id,
+      title: c.title,
+      channels: [...c.channels]
+    }));
+    for (const cat of categories) {
+      cat.channels = cat.channels.filter((id) => id !== this.id);
+    }
+    if (category !== "default") {
+      const targetCategory = categories.find((c) => c.id === category);
+      if (!targetCategory) {
+        throw new Error(`Category ${category} not found in server.`);
+      }
+      targetCategory.channels.push(this.id);
+    }
+    await this.client.servers.edit(serverId, { categories });
+    return this;
+  }
+  /**
+   * Sets the position of this channel within its current category.
+   * @param position The new index position for the channel within its category.
+   * @returns The updated TextChannel.
+   * @throws {Error} If the channel is not in a category, or if the API request fails.
+   * @example
+   * // Move channel to the top of its category
+   * await channel.setPosition(0);
+   */
+  async setPosition(position) {
+    const serverId = this.serverId;
+    const server = await this.client.servers.fetch(serverId);
+    const categories = server.categories.map((c) => ({
+      id: c.id,
+      title: c.title,
+      channels: [...c.channels]
+    }));
+    const currentCategory = categories.find((c) => c.channels.includes(this.id));
+    if (!currentCategory) {
+      throw new Error("This channel is not currently inside any category.");
+    }
+    currentCategory.channels = currentCategory.channels.filter((id) => id !== this.id);
+    const safePosition = Math.max(0, Math.min(position, currentCategory.channels.length));
+    currentCategory.channels.splice(safePosition, 0, this.id);
+    await this.client.servers.edit(serverId, { categories });
+    return this;
+  }
+  /**
+   * Edit the description of this channel
+   * @param description
+   * @throws {Error} If the API request fails
+   * @returns The updated TextChannel
    * @example
-   * // Deny a role the ability to send messages in this channel
-   * await channel.setRolePermissions("ROLE_ID", { deny: ["SendMessage"] });
+   * // Set the channel description
+   * await channel.setDescription("This is a channel about cats!");
+   * // Remove the channel description
+   * await channel.setDescription(null);
    */
-  async setRolePermissions(roleId, options) {
-    return await this.client.channels.setRolePermissions(this.id, roleId, options);
+  async setDescription(description) {
+    await this.edit({ description });
+    return this;
   }
   /**
-   * Updates the default (everyone) permissions for this channel.
-   * @param permissions The default permissions to grant globally in this channel.
-   * @returns A promise that resolves to the updated BaseChannel.
-   * @throws {TypeError} If invalid permissions are provided.
-   * @throws {Error} If the API request fails.
+   * Edit the name of this channel
+   * @param name
+   * @throws {Error} If the API request fails
+   * @returns The updated TextChannel
    * @example
-   * // Set the default permission to allow everyone to view the channel
-   * await channel.setDefaultPermissions(["ViewChannel", "ReadMessageHistory"]);
+   * await channel.setName("New Name");
    */
-  async setDefaultPermissions(permissions) {
-    return await this.client.channels.setDefaultPermissions(this.id, permissions);
+  async setName(name) {
+    await this.edit({ name });
+    return this;
+  }
+  /**
+   * Set whether this channel is NSFW
+   * @param nsfw
+   * @throws {Error} If the API request fails
+   * @returns The updated TextChannel
+   * @example
+   * // Mark the channel as NSFW
+   * await channel.setNSFW(true);
+   * // Mark the channel as SFW
+   * await channel.setNSFW(false);
+   */
+  async setNSFW(nsfw) {
+    await this.edit({ nsfw });
+    return this;
+  }
+  /**
+   * Set the channel slowmode in seconds
+   * @param slowmode
+   * @throws {Error} If the API request fails
+   * @returns The updated TextChannel
+   * @example
+   * // Set the slowmode to 5 seconds
+   * await channel.setSlowmode(5);
+   * // Remove slowmode
+   * await channel.setSlowmode(0);
+   */
+  async setSlowmode(slowmode) {
+    await this.edit({ slowmode });
+    return this;
+  }
+  /**
+   * Set the channel Icon
+   * @param id Autumn ID to use
+   * @throws {Error} If the API request fails
+   * @returns The updated TextChannel
+   * @example
+   * await channel.setIcon("123");
+   * // Remove the channel icon
+   * await channel.setIcon(null);
+   */
+  async setIcon(id) {
+    await this.edit({ icon: id });
+    return this;
   }
 };
 
@@ -1133,7 +1876,7 @@ var DMChannel = class extends BaseChannel {
 };
 
 // src/structures/GroupChannel.ts
-import * as util3 from "util";
+import * as util4 from "util";
 var GroupChannel = class extends BaseChannel {
   name;
   ownerId;
@@ -1193,9 +1936,9 @@ var GroupChannel = class extends BaseChannel {
   async setDefaultPermissions(permissions) {
     return await this.client.channels.setDefaultPermissions(this.id, permissions);
   }
-  [util3.inspect.custom](_depth, options, inspect10) {
+  [util4.inspect.custom](_depth, options, inspect12) {
     const { client, ...props } = this;
-    return `${this.constructor.name} ${inspect10(
+    return `${this.constructor.name} ${inspect12(
       {
         ...props,
         owner: this.owner,
@@ -1221,6 +1964,233 @@ function createChannel(client, data) {
   }
 }
 
+// src/utils/BitField.ts
+var BitField = class _BitField {
+  static Flags = {};
+  static DefaultBit = 0;
+  bitfield;
+  constructor(bits) {
+    this.bitfield = this.constructor.resolve(
+      bits ?? this.constructor.DefaultBit
+    );
+  }
+  /**
+   * Checks whether this bitfield has any of the given bits set.
+   *
+   * @param bit The bit(s) to test against.
+   * @returns `true` if at least one of the provided bits is set.
+   *
+   * @example
+   * perms.any(['SendMessage', 'ManageChannel']); // true if either is set
+   */
+  any(bit) {
+    const resolved = this.constructor.resolve(bit);
+    if (typeof this.bitfield === "bigint" && typeof resolved === "bigint") {
+      return (this.bitfield & resolved) !== BigInt(0);
+    }
+    return (Number(this.bitfield) & Number(resolved)) !== 0;
+  }
+  /**
+   * Checks whether this bitfield is exactly equal to the given bit value.
+   *
+   * @param bit The bit(s) to compare against.
+   * @returns `true` if the resolved bit value is identical to this bitfield.
+   *
+   * @example
+   * new Permissions(0n).equals(0n); // true
+   */
+  equals(bit) {
+    return this.bitfield === this.constructor.resolve(bit);
+  }
+  /**
+   * Checks whether this bitfield has *all* of the given bits set.
+   *
+   * @param bit The bit(s) to check for.
+   * @returns `true` if every provided bit is set in this bitfield.
+   *
+   * @example
+   * perms.has('SendMessage');
+   * perms.has(['SendMessage', 'ViewChannel']); // true only if both are set
+   */
+  has(bit, ..._hasParams) {
+    const resolvedBit = this.constructor.resolve(bit);
+    if (typeof this.bitfield === "bigint" && typeof resolvedBit === "bigint") {
+      return (this.bitfield & resolvedBit) === resolvedBit;
+    }
+    return (Number(this.bitfield) & Number(resolvedBit)) === Number(resolvedBit);
+  }
+  /**
+   * Returns the flag names present in `bits` that are *missing* from this bitfield.
+   *
+   * @param bits The bits to check against.
+   * @returns An array of flag name strings that are in `bits` but not in this bitfield.
+   *
+   * @example
+   * // If perms only has SendMessage:
+   * perms.missing(['SendMessage', 'ManageChannel']); // ['ManageChannel']
+   */
+  missing(bits, ...hasParams) {
+    return new this.constructor(bits).remove(this).toArray(...hasParams);
+  }
+  /**
+   * Freezes this BitField instance, making it immutable.
+   * Subsequent calls to `add()` or `remove()` will return a new instance instead of mutating this one.
+   *
+   * @returns This instance, frozen.
+   */
+  freeze() {
+    return Object.freeze(this);
+  }
+  /**
+   * Adds one or more bits to this bitfield.
+   * If the instance is frozen, returns a new BitField with the bits added.
+   *
+   * @param bits The bit(s) to add.
+   * @returns This instance (or a new one if frozen), with the bits added.
+   *
+   * @example
+   * perms.add('SendMessage', 'ViewChannel');
+   */
+  add(...bits) {
+    let total = this.constructor.DefaultBit;
+    for (const bit of bits) {
+      const resolved = this.constructor.resolve(bit);
+      if (typeof total === "bigint" && typeof resolved === "bigint") {
+        total |= resolved;
+      } else {
+        total = Number(total) | Number(resolved);
+      }
+    }
+    if (typeof this.bitfield === "bigint" && typeof total === "bigint") {
+      if (Object.isFrozen(this)) return new this.constructor(this.bitfield | total);
+      this.bitfield |= total;
+    } else {
+      if (Object.isFrozen(this))
+        return new this.constructor(Number(this.bitfield) | Number(total));
+      this.bitfield = Number(this.bitfield) | Number(total);
+    }
+    return this;
+  }
+  /**
+   * Removes one or more bits from this bitfield.
+   * If the instance is frozen, returns a new BitField with the bits removed.
+   *
+   * @param bits The bit(s) to remove.
+   * @returns This instance (or a new one if frozen), with the bits cleared.
+   *
+   * @example
+   * perms.remove('ManageChannel');
+   */
+  remove(...bits) {
+    let total = this.constructor.DefaultBit;
+    for (const bit of bits) {
+      const resolved = this.constructor.resolve(bit);
+      if (typeof total === "bigint" && typeof resolved === "bigint") {
+        total |= resolved;
+      } else {
+        total = Number(total) | Number(resolved);
+      }
+    }
+    if (typeof this.bitfield === "bigint" && typeof total === "bigint") {
+      if (Object.isFrozen(this)) return new this.constructor(this.bitfield & ~total);
+      this.bitfield &= ~total;
+    } else {
+      if (Object.isFrozen(this))
+        return new this.constructor(Number(this.bitfield) & ~Number(total));
+      this.bitfield = Number(this.bitfield) & ~Number(total);
+    }
+    return this;
+  }
+  /**
+   * Serializes this bitfield to a plain object mapping each flag name to a boolean
+   * indicating whether that flag is set.
+   *
+   * @returns A record of `{ [flagName]: boolean }` for all defined flags.
+   *
+   * @example
+   * perms.serialize();
+   * // { SendMessage: true, ManageChannel: false, ... }
+   */
+  serialize(...hasParams) {
+    const serialized = {};
+    for (const [flag, bit] of Object.entries(this.constructor.Flags)) {
+      if (isNaN(Number(flag))) serialized[flag] = this.has(bit, ...hasParams);
+    }
+    return serialized;
+  }
+  /**
+   * Returns an array of flag names that are set in this bitfield.
+   *
+   * @returns An array of string flag names.
+   *
+   * @example
+   * perms.toArray(); // ['SendMessage', 'ViewChannel']
+   */
+  toArray(...hasParams) {
+    return [...this[Symbol.iterator](...hasParams)];
+  }
+  /**
+   * Returns the bitfield value as a JSON-safe primitive.
+   * Numbers are returned as-is; bigints are converted to their string representation
+   * to avoid JSON serialization errors.
+   */
+  toJSON() {
+    return typeof this.bitfield === "number" ? this.bitfield : this.bitfield.toString();
+  }
+  /**
+   * Returns the underlying numeric value of this bitfield.
+   * Allows BitField instances to be used directly in arithmetic expressions.
+   */
+  valueOf() {
+    return this.bitfield;
+  }
+  /**
+   * Iterates over the names of all flags that are set in this bitfield.
+   *
+   * @example
+   * for (const flag of perms) {
+   *   console.log(flag); // 'SendMessage', 'ViewChannel', etc.
+   * }
+   */
+  *[Symbol.iterator](...hasParams) {
+    for (const bitName of Object.keys(this.constructor.Flags)) {
+      if (isNaN(Number(bitName)) && this.has(bitName, ...hasParams)) yield bitName;
+    }
+  }
+  /**
+   * Resolves a {@link BitFieldResolvable} into a raw `number | bigint`.
+   *
+   * Resolution rules (in order):
+   * - `undefined` → `DefaultBit`
+   * - A number or bigint matching `DefaultBit`'s type and >= 0 → returned as-is
+   * - A `BitField` instance → its `.bitfield` value
+   * - An array → each element resolved and OR'd together
+   * - A numeric string → parsed as `BigInt` or `Number` depending on `DefaultBit`'s type
+   * - A named string flag → looked up in `Flags`
+   * - Anything else → throws `RangeError`
+   *
+   * @param bit The value to resolve.
+   * @throws {RangeError} If the value cannot be resolved to a valid bit.
+   */
+  static resolve(bit) {
+    const { DefaultBit } = this;
+    if (bit === void 0) return DefaultBit;
+    if (typeof DefaultBit === typeof bit && bit >= DefaultBit) return bit;
+    if (bit instanceof _BitField) return bit.bitfield;
+    if (Array.isArray(bit)) {
+      return bit.map((b) => this.resolve(b)).reduce((prev, b) => {
+        if (typeof prev === "bigint" && typeof b === "bigint") return prev | b;
+        return Number(prev) | Number(b);
+      }, DefaultBit);
+    }
+    if (typeof bit === "string") {
+      if (!isNaN(Number(bit))) return typeof DefaultBit === "bigint" ? BigInt(bit) : Number(bit);
+      if (this.Flags[bit] !== void 0) return this.Flags[bit];
+    }
+    throw new RangeError(`Invalid bitfield flag or number: ${String(bit)}`);
+  }
+};
+
 // src/utils/permissions.ts
 var PermissionFlags = {
   // Server permissions
@@ -1264,26 +2234,26 @@ var PermissionFlags = {
   // Grant all
   GrantAllSafe: 0x000fffffffffffffn
 };
-var Permissions = class {
-  /**
-   * Converts a string, BigInt, or array of strings into a single BigInt
-   */
-  static resolve(permission) {
-    if (typeof permission === "bigint") return permission;
-    if (typeof permission === "string") {
-      return PermissionFlags[permission] ?? 0n;
-    }
-    if (Array.isArray(permission)) {
-      return permission.reduce((acc, p) => acc | this.resolve(p), 0n);
-    }
-    return 0n;
+var Permissions = class extends BitField {
+  static Flags = PermissionFlags;
+  static DefaultBit = 0n;
+  static resolve(bit) {
+    return super.resolve(bit);
   }
-  /**
-   * Checks if a specific permission bit exists
-   */
-  static has(totalPermissions, permissionToCheck) {
-    const resolvedCheck = this.resolve(permissionToCheck);
-    return (totalPermissions & resolvedCheck) === resolvedCheck;
+  has(bit) {
+    return super.has(bit);
+  }
+  any(bit) {
+    return super.any(bit);
+  }
+  missing(bits) {
+    return super.missing(bits);
+  }
+  add(...bits) {
+    return super.add(...bits);
+  }
+  remove(...bits) {
+    return super.remove(...bits);
   }
 };
 
@@ -1346,7 +2316,7 @@ var ChannelManager = class extends BaseManager {
   /**
    * Fetches a Channel from the API or resolves it from the local cache.
    * @param channel The ID, mention, or Channel object to fetch.
-   * @param force Whether to skip the cache check and force a direct API request. Defaults to true.
+   * @param force Whether to skip the cache check and force a direct API request. Defaults to false.
    * @returns A promise that resolves to the fetched BaseChannel object.
    * @throws {TypeError} If an invalid ChannelResolvable is provided.
    * @throws {Error} If the API request fails.
@@ -1354,7 +2324,7 @@ var ChannelManager = class extends BaseManager {
    * // Fetch a channel, bypassing cache
    * const channel = await client.channels.fetch("01H...");
    */
-  async fetch(channel, force = true) {
+  async fetch(channel, force = false) {
     if (!force) {
       const cached = this.resolve(channel);
       if (cached) return cached;
@@ -1392,7 +2362,7 @@ var ChannelManager = class extends BaseManager {
     }
     if (options.icon !== void 0) {
       if (options.icon === null) remove.push("Icon");
-      else payload.icon = options.icon;
+      else payload.icon = await resolveAttachment(this.client.rest, options.icon, "icons");
     }
     if (remove.length > 0) payload.remove = remove;
     if (Object.keys(payload).length === 0) return this.fetch(channel);
@@ -1468,10 +2438,51 @@ var ChannelManager = class extends BaseManager {
     await this.client.rest.delete(`/channels/${id}`);
     this.cache.delete(id);
   }
+  /**
+   * Pin a message
+   * @param id Channel ID
+   * @param messageId Message ID
+   * @throws {Error} If the API request fails.
+   * @example
+   * await client.channels.pin("CHANNEL_ID", "MESSAGE_ID");
+   */
+  async pin(id, messageId) {
+    await this.client.rest.post(`/channels/${id}/pins/${messageId}`);
+  }
+  /**
+   * Unpin a message
+   * @param id Channel ID
+   * @param messageId Message ID
+   * @throws {Error} If the API request fails
+   * @example
+   * await client.channels.unpin("CHANNEL_ID", "MESSAGE_ID");
+   */
+  async unpin(id, messageId) {
+    await this.client.rest.delete(`/channels/${id}/pins/${messageId}`);
+  }
+  /**
+   * Bulk delete up to 100 messages
+   * @param id Channel ID
+   * @param messages An array of MessageResolvable
+   * @throws {Error} If the API request fails
+   * @example
+   * await client.channels.bulkDelete("CHANNEL_ID", ["MESSAGE_ID_1", "MESSAGE_ID_2", "MESSAGE_ID_3"]);
+   */
+  async bulkDelete(id, messages) {
+    if (!Array.isArray(messages) || messages.length === 0 || messages.length > 100) {
+      throw new TypeError("Messages must be an array of 1-100 MessageResolvable items.");
+    }
+    const messageIds = messages.map((msg) => {
+      if (typeof msg === "string") return msg.replace(/[<#>]/g, "");
+      if ("id" in msg) return msg.id;
+      throw new TypeError("Invalid MessageResolvable provided. Expected a Message object or a string ID/Mention.");
+    });
+    await this.client.rest.delete(`/channels/${id}/messages/bulk`, { messages: messageIds });
+  }
 };
 
 // src/structures/Member.ts
-import * as util4 from "util";
+import * as util5 from "util";
 
 // src/managers/MemberRoleManager.ts
 var MemberRoleManager = class {
@@ -1597,15 +2608,15 @@ var Member = class extends Base {
   /** Calculates the member's total permissions using BigInt */
   get permissions() {
     const server = this.server;
-    if (!server) return 0n;
+    if (!server) return new Permissions(0n);
+    if (server.ownerId === this.id) {
+      return new Permissions(PermissionFlags.GrantAllSafe);
+    }
     let totalPerms = server.defaultPermissions ?? 0n;
     for (const role of this.roles.cache.values()) {
-      totalPerms |= BigInt(role.permissions);
-    }
-    if (server.ownerId === this.id) {
-      return PermissionFlags.GrantAllSafe;
+      totalPerms |= BigInt(role.permissions.bitfield);
     }
-    return totalPerms;
+    return new Permissions(totalPerms);
   }
   /** Get avatar URL for this member, or null if they don't have one.
    * @example
@@ -1650,13 +2661,24 @@ var Member = class extends Base {
    * await member.setTimeout(600000);
    */
   async setTimeout(duration) {
-    let server = this.server;
-    if (!server) server = await this.client.servers.fetch(this.serverId);
-    await server.members.setTimeout(this.id, duration);
+    await this.edit({ timeout: new Date(Date.now() + duration).toISOString() });
+  }
+  /**
+   * Send a message to this member.
+   * @param options The content or options for the message to send.
+   * @returns A promise that resolves to the sent Message object.
+   * @throws {Error} If the API request fails.
+   * @example
+   * // Send a message to this member
+   * const message = await member.send("Hello!");
+   * console.log(`Sent message ID: ${message.id}`);
+   */
+  async send(options) {
+    let dmChannel = await this.client.users.createDM(this.id);
+    return dmChannel.messages.send(options);
   }
-  /** Checks if the member has a specific permission */
-  hasPermission(permission) {
-    return Permissions.has(this.permissions, permission);
+  async setNickname(nickname) {
+    return this.edit({ nickname });
   }
   /**
    * Edit this member.
@@ -1668,6 +2690,16 @@ var Member = class extends Base {
     if (!server) server = await this.client.servers.fetch(this.serverId);
     return await server.members.edit(this.id, options);
   }
+  /**
+   * When concatenated with a string, this automatically returns the user's mention instead of the GuildMember object.
+   * @returns {string}
+   * @example
+   * // Logs: Hello from <@01JE2MM759J5D7CHJF084R7MJ2>!
+   * console.log(`Hello from ${member}!`);
+   */
+  toString() {
+    return `<@${this.id}>`;
+  }
   /**
    * Kick this member from the server.
    */
@@ -1677,9 +2709,9 @@ var Member = class extends Base {
     await server.members.kick(this.id);
   }
   /** @internal */
-  [util4.inspect.custom](depth, options, inspect10) {
+  [util5.inspect.custom](depth, options, inspect12) {
     const { client, serverId, ...props } = this;
-    return `${this.constructor.name} ${inspect10(
+    return `${this.constructor.name} ${inspect12(
       {
         ...props,
         user: this.user,
@@ -1691,7 +2723,7 @@ var Member = class extends Base {
 };
 
 // src/managers/MemberManager.ts
-import * as util5 from "util";
+import * as util6 from "util";
 var MemberManager = class extends BaseManager {
   constructor(client, server, limit = Infinity) {
     super(client, limit);
@@ -1865,25 +2897,13 @@ var MemberManager = class extends BaseManager {
     const id = this.resolveId(member);
     await this.client.rest.delete(`/servers/${this.server.id}/bans/${id}`);
   }
-  /**
-   * Timeouts a member in the server for a specified duration.
-   * @param member The MemberResolvable to timeout
-   * @param duration The duration of the timeout in milliseconds
-   * @example
-   * // Timeout a member for 10 minutes
-   * await server.members.setTimeout("1234567890", 10 * 60 * 1000);
-   */
-  async setTimeout(member, duration) {
-    const id = this.resolveId(member);
-    await this.edit(id, { timeout: new Date(Date.now() + duration).toISOString() });
-  }
-  [util5.inspect.custom]() {
+  [util6.inspect.custom]() {
     return this.cache;
   }
 };
 
 // src/managers/ServerChannelManager.ts
-import * as util6 from "util";
+import * as util7 from "util";
 var ServerChannelManager = class {
   client;
   server;
@@ -1913,20 +2933,21 @@ var ServerChannelManager = class {
     const data = await this.client.rest.post(`/servers/${this.server.id}/channels`, payload);
     return this.client.channels._add(data);
   }
-  [util6.inspect.custom]() {
+  [util7.inspect.custom]() {
     return this.cache;
   }
 };
 
 // src/structures/Role.ts
-import * as util7 from "util";
+import * as util8 from "util";
 var Role = class extends Base {
   serverId;
   name;
   color = null;
   hoist = false;
   rank = 0;
-  permissions = 0n;
+  icon = null;
+  _permissions = 0n;
   constructor(client, data, serverId) {
     super(client, data);
     this.serverId = serverId;
@@ -1941,16 +2962,17 @@ var Role = class extends Base {
     if (data.color !== void 0) this.color = data.color;
     if (data.hoist !== void 0) this.hoist = data.hoist;
     if (data.rank !== void 0) this.rank = data.rank;
+    if (data.icon !== void 0) this.icon = new Attachment(this.client, data.icon);
     if (data.permissions !== void 0) {
       try {
         if (typeof data.permissions === "object" && data.permissions !== null) {
           const allowPerms = data.permissions.a ?? data.permissions[0] ?? 0;
-          this.permissions = BigInt(allowPerms);
+          this._permissions = BigInt(allowPerms);
         } else {
-          this.permissions = BigInt(data.permissions);
+          this._permissions = BigInt(data.permissions);
         }
       } catch {
-        this.permissions = 0n;
+        this._permissions = 0n;
       }
     }
   }
@@ -1962,12 +2984,10 @@ var Role = class extends Base {
     return this.client.servers.cache.get(this.serverId);
   }
   /**
-   * Checks whether this role has a specific permission.
-   * @param permission The permission to check for.
-   * @returns True if the role has the permission.
+   * Permissions for this role
    */
-  hasPermission(permission) {
-    return Permissions.has(this.permissions, permission);
+  get permissions() {
+    return new Permissions(this._permissions);
   }
   /**
    * Fetches this role directly from the API to ensure data is up to date.
@@ -1995,10 +3015,10 @@ var Role = class extends Base {
    * @throws {Error} If the API request fails (e.g., lack of permissions).
    * @example
    * // Change the role's name and color
-   * await role.edit({ name: "Senior Admin", colour: "#FFD700" });
+   * await role.edit({ name: "Senior Admin", color: "#FFD700" });
    *
    * // Remove the custom color from the role
-   * await role.edit({ colour: null });
+   * await role.edit({ color: null });
    */
   async edit(options) {
     let server = this.server;
@@ -2057,19 +3077,86 @@ var Role = class extends Base {
     await server.roles.setRanks(filteredRoles);
     return this;
   }
+  /**
+   * Change the name for this role
+   * @param name The new name for the role
+   * @returns A promise that resolves to this updated Role object.
+   * @throws {Error} If API request fails.
+   * @example
+   * // Change the role's name
+   * await role.setName("New Role Name");
+   * console.log(`Role's new name: ${role.name}`);
+   */
+  async setName(name) {
+    return await this.edit({ name });
+  }
+  /**
+   * Change the color for this role, it can be a HEX or CSS colours
+   * @param {[string]} color The new color for the role
+   * @returns A promise that resolves to this updated Role object.
+   * @throws {Error} If API request fails
+   * @example
+   * // Change the role's color
+   * await role.setColour("#FF0000");
+   * console.log(`Role's new color: ${role.color}`);
+   *
+   * // Use CSS color linear-graident
+   * await role.setColour("linear-gradient(90deg, #FF0000, #0000FF)");
+   * console.log(`Role's new color: ${role.color}`);
+   *
+   * // Remove the custom color from the role
+   * await role.setColour(null);
+   * console.log(`Role's color removed, current color: ${role.color}`);
+   */
+  async setColor(color) {
+    return await this.edit({ color });
+  }
+  /**
+   * Edit the icon of this role
+   * @param icon Autumn ID for the new icon, or null to remove the custom icon
+   * @returns A promise that resolves to this updated Role object.
+   * @throws {Error} If API request fails
+   * @example
+   * // Set a new icon for the role
+   * await role.setIcon("AUTUMN_ID_FOR_ICON");
+   * console.log(`Role's new icon: ${role.icon}`);
+   *
+   * // Use AttachmentBuilder to upload a new icon file
+   * import { readFile } from "node:fs/promises";
+   * const iconFile = await readFile("./a.jpg");
+   * const attachment = new AttachmentBuilder(iconFile, "a.jpg");
+   * await role.setIcon(attachment);
+   * console.log(`Role's new icon: ${role.icon}`);
+   */
+  async setIcon(icon) {
+    return await this.edit({ icon });
+  }
+  /**
+   * Change the hoist status for this role
+   * @param hoist The new hoist status for the role
+   * @returns A promise that resolves to this updated Role object.
+   * @throws {Error} If API request fails
+   * @example
+   * // Enable hoisting for the role
+   * await role.setHoist(true);
+   * console.log(`Role is now hoisted: ${role.hoist}`);
+   */
+  async setHoist(hoist) {
+    return await this.edit({ hoist });
+  }
   /**
    * Customizer for Node.js `console.log` and `util.inspect`.
    * Hides the cyclic client reference and raw serverId for a cleaner output.
    * @internal
    */
-  [util7.inspect.custom]() {
+  [util8.inspect.custom]() {
     const { client, serverId, ...props } = this;
-    return `${this.constructor.name} ${util7.inspect(props)}`;
+    return `${this.constructor.name} ${util8.inspect(props)}`;
   }
 };
 
 // src/managers/RoleManager.ts
-import * as util8 from "util";
+import * as util9 from "util";
 var RoleManager = class extends BaseManager {
   /**
    * Manages API methods and caching for server roles.
@@ -2108,7 +3195,7 @@ var RoleManager = class extends BaseManager {
     this.cache.set(role.id, role);
     return role;
   }
-  [util8.inspect.custom]() {
+  [util9.inspect.custom]() {
     return this.cache;
   }
   /**
@@ -2194,7 +3281,7 @@ var RoleManager = class extends BaseManager {
   }
   /**
    * Edits an existing role in the server.
-   * @param role The RoleResolvable to edit.
+   * @param role The {@link RoleResolvable} to edit.
    * @param options The fields to update.
    * @returns A promise that resolves to the updated Role.
    * @throws {TypeError} If invalid options or RoleResolvable are provided.
@@ -2215,11 +3302,18 @@ var RoleManager = class extends BaseManager {
     const remove = [];
     if (options.name !== void 0) payload.name = options.name;
     if (options.hoist !== void 0) payload.hoist = options.hoist;
-    if (options.colour !== void 0) {
-      if (options.colour === null) {
+    if (options.color !== void 0) {
+      if (options.color === null) {
         remove.push("Colour");
       } else {
-        payload.colour = options.colour;
+        payload.colour = options.color;
+      }
+    }
+    if (options.icon !== void 0) {
+      if (options.icon === null) {
+        remove.push("Icon");
+      } else {
+        payload.icon = await resolveAttachment(this.client.rest, options.icon, "icons");
       }
     }
     if (remove.length > 0) {
@@ -2409,6 +3503,54 @@ var ServerBanManager = class extends BaseManager {
   }
 };
 
+// src/structures/Emoji.ts
+var Emoji = class extends Base {
+  creatorId;
+  name;
+  parent;
+  animated = false;
+  nsfw = false;
+  constructor(client, data) {
+    super(client, data);
+    this._patch(data);
+  }
+  _patch(data) {
+    if (data.creator_id !== void 0) this.creatorId = data.creator_id;
+    if (data.name !== void 0) this.name = data.name;
+    if (data.parent !== void 0) this.parent = data.parent;
+    if (data.animated !== void 0) this.animated = data.animated;
+    if (data.nsfw !== void 0) this.nsfw = data.nsfw;
+  }
+};
+
+// src/managers/EmojiManager.ts
+import * as util10 from "util";
+var EmojiManager = class extends BaseManager {
+  constructor(client, server, limit = Infinity) {
+    super(client, limit);
+    this.server = server;
+  }
+  /**
+   * Tell BaseManager how to find the ID for Emojis
+   */
+  extractId(data) {
+    return data._id ?? data.id;
+  }
+  /**
+   * Tell BaseManager how to build an Emoji
+   */
+  construct(data) {
+    return new Emoji(this.client, data);
+  }
+  async fetch(id) {
+    const data = await this.client.rest.get(`/custom/emoji/${id}`);
+    return this._add(data);
+  }
+  [util10.inspect.custom]() {
+    return this.cache;
+  }
+};
+
 // src/structures/Server.ts
 var Server = class extends Base {
   channelIds = [];
@@ -2428,6 +3570,7 @@ var Server = class extends Base {
   roles;
   bans;
   invites;
+  emojis;
   constructor(client, data) {
     super(client, data);
     this.channels = new ServerChannelManager(client, this);
@@ -2435,6 +3578,7 @@ var Server = class extends Base {
     this.roles = new RoleManager(client, this);
     this.bans = new ServerBanManager(this.client, this);
     this.invites = new ServerInviteManager(this.client, this);
+    this.emojis = new EmojiManager(this.client, this);
     this._patch(data);
   }
   /**
@@ -2468,6 +3612,13 @@ var Server = class extends Base {
         this.roles._add({ id, ...roleData });
       }
     }
+    if (data.emojis !== void 0) {
+      if (Array.isArray(data.emojis)) {
+        for (const emoji of data.emojis) {
+          this.emojis._add(emoji);
+        }
+      }
+    }
     if (clear && Array.isArray(clear)) {
       for (const field of clear) {
         switch (field) {
@@ -2506,7 +3657,7 @@ var Server = class extends Base {
 };
 
 // src/managers/ServerManager.ts
-import * as util9 from "util";
+import * as util11 from "util";
 var ServerManager = class extends BaseManager {
   constructor(client, limit = Infinity) {
     super(client, limit);
@@ -2579,7 +3730,7 @@ var ServerManager = class extends BaseManager {
     const data = await this.client.rest.patch(`/servers/${serverId}`, payload);
     return this._add(data);
   }
-  [util9.inspect.custom]() {
+  [util11.inspect.custom]() {
     return this.cache;
   }
 };
@@ -2808,7 +3959,7 @@ var SweeperManager = class {
 };
 
 // src/client/Client.ts
-var Client = class extends EventEmitter {
+var Client = class extends EventEmitter2 {
   constructor(options = {}) {
     super({ captureRejections: true });
     this.options = options;
@@ -2817,6 +3968,7 @@ var Client = class extends EventEmitter {
     this.channels = new ChannelManager(this, options.cacheLimits?.channels);
     this.servers = new ServerManager(this, options.cacheLimits?.servers);
     this.users = new UserManager(this, options.cacheLimits?.users);
+    this.emojis = new EmojiManager(this, void 0, options.cacheLimits?.emojis);
     this.sweepers = new SweeperManager(this, options.sweepers ?? {});
   }
   rest;
@@ -2825,6 +3977,7 @@ var Client = class extends EventEmitter {
   servers;
   users;
   sweepers;
+  emojis;
   user = null;
   /**
    * Connects the bot to the Stoat Gateway
@@ -2888,23 +4041,31 @@ var EmbedBuilder = class {
 };
 export {
   Attachment,
+  AttachmentBuilder,
   Base,
   BaseChannel,
+  BitField,
   ChannelManager,
   ChannelType,
   Client,
   ClientUser,
   Collection,
+  Collector,
   DMChannel,
   EmbedBuilder,
+  Emoji,
+  EmojiManager,
   GatewayManager,
   Member,
   MemberManager,
   Message,
+  MessageCollector,
   MessageManager,
+  MessageReaction,
   PermissionFlags,
   Permissions,
   RESTManager,
+  ReactionCollector,
   Role,
   RoleManager,
   Server,