@stoatx/client 0.2.2 → 0.3.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) {
@@ -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 {
@@ -980,11 +1367,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 +1492,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 +1529,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,6 +1638,15 @@ 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;
         }
       }
     }
@@ -1108,6 +1678,136 @@ var TextChannel = class extends BaseChannel {
   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
+   * // Set the channel description
+   * await channel.setDescription("This is a channel about cats!");
+   * // Remove the channel description
+   * await channel.setDescription(null);
+   */
+  async setDescription(description) {
+    await this.edit({ description });
+    return this;
+  }
+  /**
+   * Edit the name of this channel
+   * @param name
+   * @throws {Error} If the API request fails
+   * @returns The updated TextChannel
+   * @example
+   * await channel.setName("New Name");
+   */
+  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;
+  }
 };
 
 // src/structures/UnknownChannel.ts
@@ -1133,7 +1833,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 +1893,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,
@@ -1346,7 +2046,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 +2054,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;
@@ -1468,10 +2168,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 {
@@ -1650,9 +2391,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);
+  }
+  async setNickname(nickname) {
+    return this.edit({ nickname });
   }
   /** Checks if the member has a specific permission */
   hasPermission(permission) {
@@ -1668,6 +2424,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 +2443,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 +2457,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 +2631,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,13 +2667,13 @@ 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;
@@ -2062,14 +2816,14 @@ var Role = class extends Base {
    * 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 +2862,7 @@ var RoleManager = class extends BaseManager {
     this.cache.set(role.id, role);
     return role;
   }
-  [util8.inspect.custom]() {
+  [util9.inspect.custom]() {
     return this.cache;
   }
   /**
@@ -2409,6 +3163,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 +3230,7 @@ var Server = class extends Base {
   roles;
   bans;
   invites;
+  emojis;
   constructor(client, data) {
     super(client, data);
     this.channels = new ServerChannelManager(client, this);
@@ -2435,6 +3238,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 +3272,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 +3317,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 +3390,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 +3619,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 +3628,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 +3637,7 @@ var Client = class extends EventEmitter {
   servers;
   users;
   sweepers;
+  emojis;
   user = null;
   /**
    * Connects the bot to the Stoat Gateway
@@ -2895,16 +3708,22 @@ export {
   Client,
   ClientUser,
   Collection,
+  Collector,
   DMChannel,
   EmbedBuilder,
+  Emoji,
+  EmojiManager,
   GatewayManager,
   Member,
   MemberManager,
   Message,
+  MessageCollector,
   MessageManager,
+  MessageReaction,
   PermissionFlags,
   Permissions,
   RESTManager,
+  ReactionCollector,
   Role,
   RoleManager,
   Server,