@stoatx/client 0.1.0

package/dist/index.js

@@ -0,0 +1,2734 @@
+// src/client/Client.ts
+import { EventEmitter } from "events";
+
+// src/gateway/GatewayManager.ts
+import WebSocket from "ws";
+
+// src/structures/Base.ts
+var Base = class _Base {
+  id;
+  cachedAt = Date.now();
+  client;
+  constructor(client, data) {
+    this.id = data._id;
+    this.client = client;
+    Object.defineProperty(this, "client", {
+      value: client,
+      enumerable: false,
+      writable: false
+    });
+  }
+  /**
+   * Compares this object with another to see if they represent the same entity.
+   */
+  equals(other) {
+    if (typeof other === "string") return this.id === other;
+    return other instanceof _Base && this.id === other.id;
+  }
+  /**
+   * Returns the UUID string when the object is cast to a string.
+   */
+  toString() {
+    return this.id;
+  }
+  /**
+   * Helper to quickly clone a structure
+   */
+  _clone() {
+    return Object.assign(Object.create(this), this);
+  }
+};
+
+// src/structures/Message.ts
+import * as util from "util";
+
+// src/structures/Attachment.ts
+var Attachment = class extends Base {
+  id;
+  tag;
+  filename;
+  metadata;
+  contentType;
+  size;
+  deleted;
+  reported;
+  messageId;
+  userId;
+  serverId;
+  objectId;
+  constructor(client, data) {
+    super(client, { ...data, id: data._id });
+    this.id = data._id;
+    this.tag = data.tag;
+    this.filename = data.filename;
+    this.metadata = data.metadata ?? { type: "File" };
+    this.contentType = data.content_type;
+    this.size = data.size;
+    this.deleted = data.deleted ?? false;
+    this.reported = data.reported ?? false;
+    this.messageId = data.message_id;
+    this.userId = data.user_id;
+    this.serverId = data.server_id;
+    this.objectId = data.object_id;
+  }
+  /**
+   * Automatically constructs the direct CDN URL for this file
+   */
+  get url() {
+    return `https://cdn.stoatusercontent.com/${this.tag}/${this.id}/${this.filename}`;
+  }
+  /**
+   * Helper boolean to quickly check if it's an image
+   */
+  get isImage() {
+    return this.metadata.type === "Image";
+  }
+};
+
+// src/structures/Message.ts
+import { decodeTime } from "ulid";
+var Message = class extends Base {
+  content = null;
+  authorId;
+  channelId;
+  embeds = [];
+  attachments = [];
+  editedAt = null;
+  createdAt = null;
+  flags = 0;
+  interactions = null;
+  masquerade = null;
+  mentions = [];
+  pinned = false;
+  reactions = [];
+  replies = [];
+  role_mentions = [];
+  constructor(client, data) {
+    super(client, data);
+    this.authorId = data.author;
+    this.channelId = data.channel;
+    const timestamp = decodeTime(this.id);
+    if (timestamp) {
+      console.log(timestamp);
+      this.createdAt = new Date(timestamp);
+    }
+    if (data.attachments) {
+      this.attachments = data.attachments.map((fileData) => new Attachment(this.client, fileData));
+    }
+    if (data.masquerade !== void 0) this.masquerade = data.masquerade;
+    if (data.mentions !== void 0) this.mentions = data.mentions;
+    if (data.replies !== void 0) this.replies = data.replies;
+    if (data.role_mentions !== void 0) this.role_mentions = data.role_mentions;
+    this._patch(data);
+  }
+  async reply(contentOrOptions) {
+    let channel = this.channel;
+    if (!channel) channel = await this.client.channels.fetch(this.channelId);
+    const options = typeof contentOrOptions === "string" ? { content: contentOrOptions } : { ...contentOrOptions };
+    const repliesArray = options.replies ? [...options.replies] : [];
+    const alreadyReplying = repliesArray.some((reply) => reply.id === this.id);
+    if (!alreadyReplying) {
+      repliesArray.push({
+        id: this.id,
+        mention: true
+      });
+    }
+    options.replies = repliesArray;
+    return channel.messages.send(options);
+  }
+  /**
+   * Edits this message.
+   * @param contentOrOptions The new content or options for the message.
+   */
+  async edit(contentOrOptions) {
+    let channel = this.channel;
+    if (!channel) channel = await this.client.channels.fetch(this.channelId);
+    return await channel.messages.edit(this.id, contentOrOptions);
+  }
+  /**
+   * Deletes this message.
+   */
+  async delete() {
+    let channel = this.channel;
+    if (!channel) channel = await this.client.channels.fetch(this.channelId);
+    await channel.messages.delete(this.id);
+  }
+  /**
+   * Pins this message.
+   */
+  async pin() {
+    let channel = this.channel;
+    if (!channel) channel = await this.client.channels.fetch(this.channelId);
+    await channel.messages.pin(this.id);
+  }
+  /**
+   * Unpins this message.
+   */
+  async unpin() {
+    let channel = this.channel;
+    if (!channel) channel = await this.client.channels.fetch(this.channelId);
+    await channel.messages.unpin(this.id);
+  }
+  /** Gets the Channel object from cache */
+  get channel() {
+    return this.client.channels.cache.get(this.channelId);
+  }
+  /** Gets the Global User object from cache */
+  get author() {
+    return this.client.users.cache.get(this.authorId);
+  }
+  /** Gets the Server Member object (if sent in a server) */
+  get member() {
+    const channel = this.channel;
+    if (channel && "serverId" in channel) {
+      const server = this.client.servers.cache.get(channel.serverId);
+      return server?.members.cache.get(this.authorId);
+    }
+    return void 0;
+  }
+  /** Gets the Server ID if this message was sent in a server channel */
+  get serverId() {
+    const channel = this.channel;
+    if (channel && "serverId" in channel) {
+      return channel.serverId;
+    }
+    return void 0;
+  }
+  /** Gets the Server object from cache */
+  get server() {
+    const serverId = this.serverId;
+    if (!serverId) return void 0;
+    return this.client.servers.cache.get(serverId);
+  }
+  _patch(data) {
+    if (data.content !== void 0) this.content = data.content;
+    if (data.edited !== void 0) this.editedAt = new Date(data.edited);
+    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.interactions !== void 0) {
+      if (data.interactions) {
+        this.interactions = {
+          reactions: data.interactions.reactions ?? [],
+          restrictReactions: data.interactions.restrict_reactions ?? false
+        };
+      } else {
+        this.interactions = null;
+      }
+    }
+  }
+  // This tells Node.js exactly how to print this object in console.log()
+  [util.inspect.custom](depth, options, inspect10) {
+    const { client, authorId, channelId, ...props } = this;
+    const data = {
+      ...props,
+      author: this.author,
+      channel: this.channel,
+      server: this.server,
+      member: this.member
+    };
+    return `${this.constructor.name} ${inspect10(data, { ...options, depth: depth ?? options.depth })}`;
+  }
+};
+
+// src/structures/User.ts
+var UserRelationship = /* @__PURE__ */ ((UserRelationship2) => {
+  UserRelationship2["None"] = "None";
+  UserRelationship2["User"] = "User";
+  UserRelationship2["Friend"] = "Friend";
+  UserRelationship2["Outgoing"] = "Outgoing";
+  UserRelationship2["Incoming"] = "Incoming";
+  UserRelationship2["Blocked"] = "Blocked";
+  UserRelationship2["BlockedOther"] = "BlockedOther";
+  return UserRelationship2;
+})(UserRelationship || {});
+var UserPresence = /* @__PURE__ */ ((UserPresence2) => {
+  UserPresence2["Online"] = "Online";
+  UserPresence2["Idle"] = "Idle";
+  UserPresence2["Focus"] = "Focus";
+  UserPresence2["Busy"] = "Busy";
+  UserPresence2["Invisible"] = "Invisible";
+  return UserPresence2;
+})(UserPresence || {});
+var User = class extends Base {
+  discriminator;
+  online;
+  relationship;
+  username;
+  avatar;
+  badges;
+  bot;
+  displayName;
+  flags;
+  privileged;
+  status;
+  constructor(client, data) {
+    super(client, data);
+    this.bot = false;
+    this.privileged = false;
+    this.flags = 0;
+    this._patch(data);
+  }
+  _patch(data, clear) {
+    if (data.username !== void 0) this.username = data.username;
+    if (data.discriminator !== void 0) this.discriminator = data.discriminator;
+    if (data.online !== void 0) this.online = data.online;
+    if (data.relationship !== void 0) this.relationship = data.relationship;
+    if (data.display_name !== void 0) this.displayName = data.display_name;
+    if (data.badges !== void 0) this.badges = data.badges;
+    if (data.flags !== void 0) this.flags = data.flags;
+    if (data.privileged !== void 0) this.privileged = data.privileged ?? false;
+    if (data.status !== void 0) this.status = data.status;
+    if (data.bot !== void 0) {
+      this.bot = data.bot ? { owner: data.bot.owner } : false;
+    }
+    if (data.avatar !== void 0) {
+      this.avatar = new Attachment(this.client, data.avatar);
+    }
+    if (clear && Array.isArray(clear)) {
+      for (const field of clear) {
+        if (field === "Avatar") this.avatar = null;
+        if (field === "StatusText" && this.status) this.status.text = null;
+        if (field === "DisplayName") this.displayName = null;
+      }
+    }
+  }
+  /**
+   * Convenience getter to return the user's tag (username#discriminator)
+   */
+  get tag() {
+    return `${this.username}#${this.discriminator}`;
+  }
+  /**
+   * Fetch a User to update their information
+   * @param force Skip the cache check and force an API request
+   * @returns The fetched User object
+   * @throws Error if the user cannot be found or fetched
+   * @example
+   * // Fetch a user
+   * await user.fetch();
+   */
+  async fetch(force = false) {
+    return await this.client.users.fetch(this.id, force);
+  }
+};
+
+// src/structures/ClientUser.ts
+var ClientUser = class extends User {
+  constructor(client, data) {
+    super(client, data);
+  }
+};
+
+// src/gateway/GatewayManager.ts
+var GatewayManager = class {
+  constructor(client) {
+    this.client = client;
+  }
+  ws = null;
+  pingInterval = null;
+  token = null;
+  reconnectAttempts = 0;
+  maxReconnectWait = 6e4;
+  // Cap at 60s
+  isIntentionalClose = false;
+  async connect(token) {
+    this.token = token;
+    this.isIntentionalClose = false;
+    this.client.emit("debug", "Connecting to Stoat Gateway...");
+    if (this.ws) {
+      this.ws.removeAllListeners();
+      this.ws = null;
+    }
+    const baseUrl = "wss://stoat.chat/events";
+    const url = `${baseUrl}?version=1&format=json&token=${this.token}`;
+    this.ws = new WebSocket(url);
+    this.ws.on("open", () => {
+      this.client.emit("debug", "WebSocket Opened. Starting ping loop...");
+      this.reconnectAttempts = 0;
+      this.startPingLoop();
+    });
+    this.ws.on("message", (data) => this.handleMessage(data));
+    this.ws.on("close", (code, reason) => {
+      this.client.emit("debug", `WebSocket closed: ${code} - ${reason.toString()}`);
+      if (this.pingInterval) clearInterval(this.pingInterval);
+      if (!this.isIntentionalClose) {
+        this.reconnect();
+      }
+    });
+    this.ws.on("error", (error) => {
+      this.client.emit("error", error);
+    });
+  }
+  handleMessage(rawData) {
+    const payload = JSON.parse(rawData.toString());
+    const eventType = payload.type;
+    switch (eventType) {
+      case "Error":
+        this.client.emit("error", new Error(`Gateway Error: ${payload.error || JSON.stringify(payload)}`));
+        break;
+      case "Authenticated":
+        this.client.emit("debug", "Successfully authenticated with Stoat.");
+        break;
+      case "Ready": {
+        if (payload.channels) {
+          for (const rawChannel of payload.channels) {
+            this.client.channels._add(rawChannel);
+          }
+        }
+        if (payload.servers) {
+          for (const rawServer of payload.servers) {
+            this.client.servers._add(rawServer);
+          }
+        }
+        if (payload.users) {
+          for (const rawUser of payload.users) {
+            this.client.users._add(rawUser);
+            if (rawUser.relation === "User" && !this.client.user) {
+              this.client.user = new ClientUser(this.client, rawUser);
+            }
+          }
+        }
+        this.client.emit("ready", payload);
+        break;
+      }
+      case "Message": {
+        if (payload.user) this.client.users._add(payload.user);
+        const channel = this.client.channels.cache.get(payload.channel);
+        let message;
+        if (channel) {
+          message = channel.messages._add(payload);
+          if ("serverId" in channel) {
+            const serverId = channel.serverId;
+            const server = this.client.servers.cache.get(serverId);
+            if (server && payload.member && payload.user) {
+              server.members._add({ ...payload.member, user: payload.user });
+            }
+          }
+        } else {
+          message = new Message(this.client, payload);
+        }
+        this.client.emit("messageCreate", message);
+        break;
+      }
+      case "MessageUpdate": {
+        const channel = this.client.channels.cache.get(payload.channel);
+        const existing = channel?.messages.cache.get(payload.id);
+        if (existing) {
+          const oldMessage = existing._clone();
+          existing._patch(payload.data);
+          this.client.emit("messageUpdate", oldMessage, existing);
+        } else {
+          const newMessage = new Message(this.client, { id: payload.id, channelId: payload.channel, ...payload.data });
+          this.client.emit("messageUpdate", null, newMessage);
+        }
+        break;
+      }
+      case "MessageAppend": {
+        const channel = this.client.channels.cache.get(payload.channel);
+        const message = channel?.messages.cache.get(payload.id);
+        if (message && payload.append.embeds) {
+          const oldMessage = message._clone();
+          message.embeds.push(...payload.append.embeds);
+          this.client.emit("messageUpdate", oldMessage, message);
+        }
+        break;
+      }
+      case "MessageDelete": {
+        const channel = this.client.channels.cache.get(payload.channel);
+        let message;
+        if (channel) {
+          message = channel.messages.cache.get(payload.id);
+          channel.messages.cache.delete(payload.id);
+        }
+        if (message) {
+          this.client.emit("messageDelete", message);
+        } else {
+          this.client.emit("messageDelete", { id: payload.id, channelId: payload.channel });
+        }
+        break;
+      }
+      case "Pong":
+        this.client.emit("debug", "Received Pong from server.");
+        break;
+      case "ChannelCreate": {
+        const channel = this.client.channels._add(payload);
+        this.client.emit("channelCreate", channel);
+        break;
+      }
+      case "ChannelUpdate": {
+        const existing = this.client.channels.cache.get(payload.id);
+        if (existing) {
+          const oldChannel = existing._clone();
+          if ("_patch" in existing) {
+            existing._patch(payload.data, payload.clear);
+          }
+          this.client.emit("channelUpdate", oldChannel, existing);
+        } else {
+          const newChannel = this.client.channels._add({ id: payload.id, ...payload.data });
+          this.client.emit("channelUpdate", null, newChannel);
+        }
+        break;
+      }
+      case "ChannelDelete": {
+        const channel = this.client.channels.cache.get(payload.id);
+        if (channel) {
+          this.client.channels.cache.delete(channel.id);
+          this.client.emit("channelDelete", channel);
+        }
+        break;
+      }
+      case "ServerCreate": {
+        const server = this.client.servers._add(payload);
+        this.client.emit("serverCreate", server);
+        break;
+      }
+      case "ServerUpdate": {
+        const existing = this.client.servers.cache.get(payload.id);
+        if (existing) {
+          const oldServer = existing._clone();
+          existing._patch(payload.data, payload.clear);
+          this.client.emit("serverUpdate", oldServer, existing);
+        } else {
+          const newServer = this.client.servers._add({ id: payload.id, ...payload.data });
+          this.client.emit("serverUpdate", null, newServer);
+        }
+        break;
+      }
+      case "ServerDelete": {
+        const server = this.client.servers.cache.get(payload.id);
+        if (server) {
+          this.client.servers.cache.delete(payload.id);
+          this.client.emit("serverDelete", server);
+        } else {
+          this.client.emit("serverDelete", payload.id);
+        }
+        break;
+      }
+      case "ServerMemberJoin": {
+        const server = this.client.servers.cache.get(payload.id);
+        if (server) {
+          const member = server.members._add({ user: payload.user });
+          this.client.emit("serverMemberJoin", member);
+        }
+        break;
+      }
+      case "ServerMemberLeave": {
+        const server = this.client.servers.cache.get(payload.id);
+        if (server) {
+          const member = server.members.cache.get(payload.user);
+          if (member) {
+            server.members.cache.delete(payload.user);
+            this.client.emit("serverMemberLeave", member);
+          }
+        }
+        break;
+      }
+      case "UserUpdate": {
+        const existing = this.client.users.cache.get(payload.id);
+        if (existing) {
+          const oldUser = existing._clone();
+          existing._patch(payload.data, payload.clear);
+          this.client.emit("userUpdate", oldUser, existing);
+        }
+        break;
+      }
+      default:
+        this.client.emit("raw", payload);
+    }
+  }
+  startPingLoop() {
+    if (this.pingInterval) clearInterval(this.pingInterval);
+    this.pingInterval = setInterval(() => {
+      this.client.emit("debug", "Sending Ping...");
+      this.send({ type: "Ping", data: Date.now() });
+    }, 2e4);
+  }
+  send(payload) {
+    if (this.ws?.readyState === WebSocket.OPEN) {
+      this.ws.send(JSON.stringify(payload));
+    }
+  }
+  reconnect() {
+    if (!this.token) {
+      return this.client.emit("error", new Error("RECONNECT_FAILED: No token available."));
+    }
+    let waitTime = Math.pow(2, this.reconnectAttempts) * 1e3;
+    const jitter = waitTime * 0.2 * Math.random();
+    waitTime = Math.min(waitTime + jitter, this.maxReconnectWait);
+    this.reconnectAttempts++;
+    this.client.emit(
+      "debug",
+      `Attempting to reconnect in ${Math.round(waitTime / 1e3)}s... (Attempt ${this.reconnectAttempts})`
+    );
+    setTimeout(() => {
+      void this.connect(this.token);
+    }, waitTime);
+  }
+  disconnect() {
+    this.isIntentionalClose = true;
+    if (this.pingInterval) clearInterval(this.pingInterval);
+    if (this.ws) {
+      this.ws.close(1e3, "Client disconnected gracefully");
+      this.ws.removeAllListeners();
+      this.ws = null;
+    }
+    this.client.emit("debug", "Gateway disconnected intentionally.");
+  }
+};
+
+// src/rest/RESTManager.ts
+import { request } from "undici";
+var sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+var AsyncBucket = class {
+  remaining = 1;
+  resetAt = 0;
+  queue = Promise.resolve();
+};
+var RESTManager = class {
+  constructor(client) {
+    this.client = client;
+  }
+  baseURL = "https://stoat.chat/api";
+  token = null;
+  buckets = /* @__PURE__ */ new Map();
+  setToken(token) {
+    this.token = token;
+  }
+  /**
+   * Generates a local identifier for the bucket based on method and path.
+   */
+  getRouteKey(method, endpoint) {
+    return `${method}:${endpoint}`;
+  }
+  makeRequest(method, endpoint, body) {
+    const routeKey = this.getRouteKey(method, endpoint);
+    let bucket = this.buckets.get(routeKey);
+    if (!bucket) {
+      bucket = new AsyncBucket();
+      this.buckets.set(routeKey, bucket);
+    }
+    return new Promise((resolve, reject) => {
+      bucket.queue = bucket.queue.then(async () => {
+        try {
+          const result = await this.execute(method, endpoint, body, bucket);
+          resolve(result);
+        } catch (error) {
+          reject(error);
+        }
+      });
+    });
+  }
+  async execute(method, endpoint, body, bucket) {
+    if (!this.token) {
+      throw new Error("REST_NOT_READY: You must call client.login() before making API requests.");
+    }
+    const url = `${this.baseURL}${endpoint}`;
+    if (bucket.remaining <= 0 && Date.now() < bucket.resetAt) {
+      const waitTime = bucket.resetAt - Date.now();
+      this.client.emit("debug", `Bucket [${method}:${endpoint}] exhausted. Waiting ${waitTime}ms proactively...`);
+      await sleep(waitTime);
+    }
+    const options = {
+      method,
+      headers: {
+        "X-Bot-Token": this.token,
+        "Content-Type": "application/json"
+      },
+      ...body ? { body: JSON.stringify(body) } : {}
+    };
+    const response = await request(url, options);
+    const remainingHeader = response.headers["x-ratelimit-remaining"];
+    const resetAfterHeader = response.headers["x-ratelimit-reset-after"];
+    if (remainingHeader !== void 0 && resetAfterHeader !== void 0) {
+      bucket.remaining = Number(remainingHeader);
+      bucket.resetAt = Date.now() + Number(resetAfterHeader);
+    }
+    if (response.statusCode === 429) {
+      const data2 = await response.body.json();
+      const retryMs = data2.retry_after || Number(resetAfterHeader) || 5e3;
+      this.client.emit("debug", `Hit 429 on [${method}:${endpoint}]. Retrying in ${retryMs}ms.`);
+      bucket.remaining = 0;
+      bucket.resetAt = Date.now() + retryMs;
+      await sleep(retryMs);
+      return this.execute(method, endpoint, body, bucket);
+    }
+    const data = await response.body.json();
+    if (response.statusCode >= 400) {
+      let errorMessage = "Unknown Error";
+      if (typeof data === "object" && data !== null && "message" in data) {
+        errorMessage = String(data.message);
+      }
+      throw new Error(`[Stoat API Error ${response.statusCode}]: ${errorMessage}`);
+    }
+    return data;
+  }
+  /**
+   * Uploads a file to Stoat's CDN and returns the File ID
+   */
+  async uploadFile(filename, fileBuffer) {
+    if (!this.token) throw new Error("REST_NOT_READY: No token available.");
+    const url = "https://cdn.stoatusercontent.com/attachments";
+    const formData = new FormData();
+    formData.append("file", new Blob([fileBuffer]), filename);
+    const response = await fetch(url, {
+      method: "POST",
+      headers: {
+        "X-Bot-Token": this.token
+      },
+      body: formData
+    });
+    if (!response.ok) {
+      throw new Error(`Upload failed: ${response.status} ${response.statusText}`);
+    }
+    const data = await response.json();
+    return data.id;
+  }
+  get(endpoint) {
+    return this.makeRequest("GET", endpoint);
+  }
+  post(endpoint, body) {
+    return this.makeRequest("POST", endpoint, body);
+  }
+  patch(endpoint, body) {
+    return this.makeRequest("PATCH", endpoint, body);
+  }
+  delete(endpoint) {
+    return this.makeRequest("DELETE", endpoint);
+  }
+  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";
+
+// src/managers/BaseManager.ts
+var BaseManager = class {
+  constructor(client, limit = Infinity) {
+    this.client = client;
+    this.cache = new Collection(limit);
+  }
+  cache;
+  /**
+   * Transforms raw data into a Structure, patches if existing, and saves to cache.
+   * @internal
+   */
+  _add(data) {
+    const id = this.extractId(data);
+    const existing = this.cache.get(id);
+    if (existing && typeof existing._patch === "function") {
+      existing._patch(data);
+      return existing;
+    }
+    const structure = this.construct(data);
+    this.cache.set(id, structure);
+    return structure;
+  }
+};
+
+// src/managers/MessageManager.ts
+var MessageManager = class extends BaseManager {
+  constructor(client, channel, limit = Infinity) {
+    super(client, limit);
+    this.channel = channel;
+  }
+  /**
+   * Tell BaseManager how to find the ID for Messages
+   */
+  extractId(data) {
+    return data._id ?? data.id;
+  }
+  /**
+   * Tell BaseManager how to build a Message
+   */
+  construct(data) {
+    return new Message(this.client, data);
+  }
+  async fetch(id) {
+    const data = await this.client.rest.get(`/channels/${this.channel.id}/messages/${id}`);
+    return this._add(data);
+  }
+  /**
+   * Fetches multiple messages from the channel using specific filter parameters.
+   * @param options The query parameters to filter the fetched messages.
+   * @returns A promise that resolves to a Collection of fetched Messages.
+   * @throws {Error} If the API request fails.
+   * @example
+   * // Fetch the last 50 messages in the channel
+   * const messages = await channel.messages.fetchMany({ limit: 50, sort: "Latest" });
+   *
+   * // Fetch 20 messages before a specific message ID
+   * const history = await channel.messages.fetchMany({ limit: 20, before: "01H..." });
+   */
+  async fetchMany(options = {}) {
+    const params = new URLSearchParams();
+    if (options.limit !== void 0) params.append("limit", options.limit.toString());
+    if (options.before !== void 0) params.append("before", options.before);
+    if (options.after !== void 0) params.append("after", options.after);
+    if (options.sort !== void 0) params.append("sort", options.sort);
+    if (options.nearby !== void 0) params.append("nearby", options.nearby);
+    if (options.includeUsers !== void 0) params.append("include_users", options.includeUsers.toString());
+    const queryString = params.toString();
+    const endpoint = `/channels/${this.channel.id}/messages${queryString ? `?${queryString}` : ""}`;
+    const data = await this.client.rest.get(endpoint);
+    const rawMessages = Array.isArray(data) ? data : data.messages || [];
+    if (!Array.isArray(data) && data.users) {
+      for (const userData of data.users) {
+        this.client.users._add(userData);
+      }
+    }
+    const fetched = new Collection();
+    for (const rawMsg of rawMessages) {
+      const msg = this._add(rawMsg);
+      fetched.set(msg.id, msg);
+    }
+    return fetched;
+  }
+  resolveId(message) {
+    if (typeof message === "string") return message;
+    if (message instanceof Message) return message.id;
+    throw new Error("Invalid MessageResolvable: must be a Message object or a string ID.");
+  }
+  /**
+   * Sends a new message to this channel.
+   * @param contentOrOptions The string content or message options payload.
+   * @returns A promise that resolves to the sent Message.
+   */
+  async send(contentOrOptions) {
+    const payload = typeof contentOrOptions === "string" ? { content: contentOrOptions } : { ...contentOrOptions };
+    if (payload.embeds) {
+      payload.embeds = payload.embeds.map(
+        (embed) => typeof embed.toJSON === "function" ? embed.toJSON() : embed
+      );
+    }
+    const data = await this.client.rest.post(`/channels/${this.channel.id}/messages`, payload);
+    return new Message(this.client, data);
+  }
+  /**
+   * Edits an existing message.
+   * @param message The MessageResolvable (object or ID) to edit.
+   * @param contentOrOptions The new content or options.
+   * @returns A promise that resolves to the updated Message.
+   */
+  async edit(message, contentOrOptions) {
+    const id = this.resolveId(message);
+    const payload = typeof contentOrOptions === "string" ? { content: contentOrOptions } : { ...contentOrOptions };
+    if (payload.embeds) {
+      payload.embeds = payload.embeds.map(
+        (embed) => typeof embed.toJSON === "function" ? embed.toJSON() : embed
+      );
+    }
+    const data = await this.client.rest.patch(`/channels/${this.channel.id}/messages/${id}`, payload);
+    const existing = this.cache.get(id);
+    if (existing) {
+      existing._patch(data);
+      return existing;
+    }
+    return new Message(this.client, data);
+  }
+  /**
+   * Deletes a message from the channel.
+   * @param message The MessageResolvable to delete.
+   */
+  async delete(message) {
+    const id = this.resolveId(message);
+    await this.client.rest.delete(`/channels/${this.channel.id}/messages/${id}`);
+    this.cache.delete(id);
+  }
+  /**
+   * Pins a message in the channel.
+   * @param message The MessageResolvable to pin.
+   */
+  async pin(message) {
+    const id = this.resolveId(message);
+    await this.client.rest.post(`/channels/${this.channel.id}/messages/${id}/pin`, {});
+    const existing = this.cache.get(id);
+    if (existing) existing.pinned = true;
+  }
+  /**
+   * Unpins a message in the channel.
+   * @param message The MessageResolvable to unpin.
+   */
+  async unpin(message) {
+    const id = this.resolveId(message);
+    await this.client.rest.delete(`/channels/${this.channel.id}/messages/${id}/pin`);
+    const existing = this.cache.get(id);
+    if (existing) existing.pinned = false;
+  }
+  [util2.inspect.custom]() {
+    return this.cache;
+  }
+};
+
+// src/structures/BaseChannel.ts
+var ChannelType = /* @__PURE__ */ ((ChannelType2) => {
+  ChannelType2["TEXT"] = "TextChannel";
+  ChannelType2["DM"] = "DirectMessage";
+  ChannelType2["GROUP"] = "Group";
+  return ChannelType2;
+})(ChannelType || {});
+var BaseChannel = class extends Base {
+  type;
+  messages;
+  constructor(client, data) {
+    super(client, data);
+    this.type = data.channel_type;
+    this.messages = new MessageManager(this.client, this);
+  }
+  /**
+   * Sends a message to this channel.
+   * @param contentOrOptions The string content or message options payload.
+   * @returns A promise that resolves to the sent Message.
+   * @example
+   * await channel.send("Hello world!");
+   * await channel.send({ content: "Here is an embed", embeds: [myEmbed] });
+   */
+  async send(contentOrOptions) {
+    return this.messages.send(contentOrOptions);
+  }
+  async fetch(force = true) {
+    return await this.client.channels.fetch(this.id, force);
+  }
+  /**
+   * Fetches multiple messages from this channel.
+   * @param options The query parameters to filter the messages.
+   */
+  async fetchMessages(options) {
+    return this.messages.fetchMany(options);
+  }
+  /**
+   * Edits this channel.
+   * @param options The fields to update
+   */
+  async edit(options) {
+    return await this.client.channels.edit(this.id, options);
+  }
+  /**
+   * Deletes this channel.
+   */
+  async delete() {
+    await this.client.channels.delete(this.id);
+  }
+  isText() {
+    return this.type === "TextChannel" /* TEXT */;
+  }
+  isDM() {
+    return this.type === "DirectMessage" /* DM */;
+  }
+  isGroup() {
+    return this.type === "Group" /* GROUP */;
+  }
+};
+
+// src/structures/TextChannel.ts
+var TextChannel = class extends BaseChannel {
+  name;
+  serverId;
+  defaultPermissions;
+  description;
+  icon;
+  lastMessageId;
+  nsfw;
+  slowmode;
+  voice;
+  constructor(client, data) {
+    super(client, data);
+    this.serverId = data.server;
+    this.defaultPermissions = data.default_permissions;
+    this.description = data.description;
+    this.icon = data.icon;
+    this.lastMessageId = data.last_message_id;
+    this.nsfw = data.nsfw ?? false;
+    this.slowmode = data.slowmode ?? 0;
+    this.voice = data.voice;
+    this._patch(data);
+  }
+  _patch(data, clear) {
+    if (data.name !== void 0) this.name = data.name;
+    if (data.description !== void 0) this.description = data.description;
+    if (clear && Array.isArray(clear)) {
+      for (const field of clear) {
+        switch (field) {
+          case "Description":
+            this.description = null;
+            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.
+   * @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);
+  }
+};
+
+// src/structures/UnknownChannel.ts
+var UnknownChannel = class extends BaseChannel {
+  constructor(client, data) {
+    super(client, data);
+  }
+};
+
+// src/structures/DMChannel.ts
+var DMChannel = class extends BaseChannel {
+  active = false;
+  recipients = [];
+  lastMessageId = null;
+  constructor(client, data) {
+    super(client, data);
+  }
+  _patch(data) {
+    if (data.active !== void 0) this.active = data.active;
+    if (data.recipients !== void 0) this.recipients = data.recipients;
+    if (data.last_message_id !== void 0) this.lastMessageId = data.last_message_id;
+  }
+};
+
+// src/structures/GroupChannel.ts
+import * as util3 from "util";
+var GroupChannel = class extends BaseChannel {
+  name;
+  ownerId;
+  recipients = [];
+  description = null;
+  icon = null;
+  lastMessageId = null;
+  nsfw = false;
+  constructor(client, data) {
+    super(client, data);
+    this._patch(data);
+  }
+  _patch(data, clear) {
+    if (data.name !== void 0) this.name = data.name;
+    if (data.owner !== void 0) this.ownerId = data.owner;
+    if (data.recipients !== void 0) this.recipients = data.recipients;
+    if (data.description !== void 0) this.description = data.description;
+    if (data.last_message_id !== void 0) this.lastMessageId = data.last_message_id;
+    if (data.nsfw !== void 0) this.nsfw = data.nsfw;
+    if (data.icon !== void 0) {
+      this.icon = data.icon ? new Attachment(this.client, data.icon) : null;
+    }
+    if (clear && Array.isArray(clear)) {
+      for (const field of clear) {
+        switch (field) {
+          case "Name":
+            this.name = "";
+            break;
+          case "Description":
+            this.description = null;
+            break;
+          case "Icon":
+            this.icon = null;
+            break;
+        }
+      }
+    }
+  }
+  /** Gets the User object of the person who owns this group */
+  get owner() {
+    return this.client.users.cache.get(this.ownerId);
+  }
+  /** Resolves the recipient IDs into an array of cached User objects */
+  get recipientUsers() {
+    return this.recipients.map((id) => this.client.users.cache.get(id)).filter((user) => user !== void 0);
+  }
+  /**
+   * 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);
+  }
+  [util3.inspect.custom](_depth, options, inspect10) {
+    const { client, ...props } = this;
+    return `${this.constructor.name} ${inspect10(
+      {
+        ...props,
+        owner: this.owner,
+        recipientUsers: this.recipientUsers
+      },
+      options
+    )}`;
+  }
+};
+
+// src/utils/ChannelFactory.ts
+function createChannel(client, data) {
+  switch (data.channel_type) {
+    case "TextChannel" /* TEXT */:
+      return new TextChannel(client, data);
+    case "DirectMessage" /* DM */:
+      return new DMChannel(client, data);
+    case "Group" /* GROUP */:
+      return new GroupChannel(client, data);
+    default:
+      client.emit("debug", `Received unknown channel type: ${data.type}`);
+      return new UnknownChannel(client, data);
+  }
+}
+
+// src/utils/permissions.ts
+var PermissionFlags = {
+  // Server permissions
+  ManageChannel: 1n << 0n,
+  ManageServer: 1n << 1n,
+  ManagePermissions: 1n << 2n,
+  ManageRole: 1n << 3n,
+  ManageCustomisation: 1n << 4n,
+  // Member permissions
+  KickMembers: 1n << 6n,
+  BanMembers: 1n << 7n,
+  TimeoutMembers: 1n << 8n,
+  AssignRoles: 1n << 9n,
+  ChangeNickname: 1n << 10n,
+  ManageNicknames: 1n << 11n,
+  ChangeAvatar: 1n << 12n,
+  RemoveAvatars: 1n << 13n,
+  // Channel permissions
+  ViewChannel: 1n << 20n,
+  ReadMessageHistory: 1n << 21n,
+  SendMessage: 1n << 22n,
+  ManageMessages: 1n << 23n,
+  ManageWebhooks: 1n << 24n,
+  InviteOthers: 1n << 25n,
+  SendEmbeds: 1n << 26n,
+  UploadFiles: 1n << 27n,
+  Masquerade: 1n << 28n,
+  React: 1n << 29n,
+  BypassSlowmode: 1n << 39n,
+  // Voice permissions
+  Connect: 1n << 30n,
+  Speak: 1n << 31n,
+  Video: 1n << 32n,
+  MuteMembers: 1n << 33n,
+  DeafenMembers: 1n << 34n,
+  MoveMembers: 1n << 35n,
+  Listen: 1n << 36n,
+  // Channel permissions (Part 2)
+  MentionEveryone: 1n << 37n,
+  MentionRoles: 1n << 38n,
+  // 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;
+  }
+  /**
+   * Checks if a specific permission bit exists
+   */
+  static has(totalPermissions, permissionToCheck) {
+    const resolvedCheck = this.resolve(permissionToCheck);
+    return (totalPermissions & resolvedCheck) === resolvedCheck;
+  }
+};
+
+// src/managers/ChannelManager.ts
+var ChannelManager = class extends BaseManager {
+  /**
+   * Manages API methods and caching for all channels globally.
+   * @param client The active Client instance.
+   * @param limit The maximum number of channels to hold in the cache.
+   */
+  constructor(client, limit = Infinity) {
+    super(client, limit);
+    this.client = client;
+  }
+  extractId(data) {
+    return data._id ?? data.id;
+  }
+  construct(data) {
+    return createChannel(this.client, data);
+  }
+  /**
+   * Resolves a ChannelResolvable to a cached BaseChannel object.
+   * @param channel The ChannelResolvable to resolve.
+   * @returns The resolved BaseChannel, or undefined if not cached.
+   */
+  resolve(channel) {
+    if (channel instanceof BaseChannel) return channel;
+    if (typeof channel === "string") {
+      const id = channel.replace(/[<#>]/g, "");
+      return this.cache.get(id);
+    }
+    return void 0;
+  }
+  resolveText(channel) {
+    const resolved = this.resolve(channel);
+    return resolved?.isText() ? resolved : void 0;
+  }
+  resolveDM(channel) {
+    const resolved = this.resolve(channel);
+    return resolved?.isDM() ? resolved : void 0;
+  }
+  resolveGroup(channel) {
+    const resolved = this.resolve(channel);
+    return resolved?.isGroup() ? resolved : void 0;
+  }
+  /**
+   * Extracts ID from a ChannelResolvable.
+   * @param channel The ChannelResolvable to extract the ID from.
+   * @returns The extracted channel ID.
+   * @throws {TypeError} If an invalid type is provided.
+   */
+  resolveId(channel) {
+    if (channel instanceof BaseChannel) {
+      return channel.id;
+    }
+    if (typeof channel === "string") {
+      return channel.replace(/[<#>]/g, "");
+    }
+    throw new TypeError("Invalid ChannelResolvable provided. Expected a BaseChannel object or a string ID/Mention.");
+  }
+  /**
+   * 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.
+   * @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.
+   * @example
+   * // Fetch a channel, bypassing cache
+   * const channel = await client.channels.fetch("01H...");
+   */
+  async fetch(channel, force = true) {
+    if (!force) {
+      const cached = this.resolve(channel);
+      if (cached) return cached;
+    }
+    const id = this.resolveId(channel);
+    const data = await this.client.rest.get(`/channels/${id}`);
+    return this._add(data);
+  }
+  /**
+   * Edits a channel in the server.
+   * @param channel The ChannelResolvable to edit.
+   * @param options The fields to update.
+   * @returns A promise that resolves to the updated BaseChannel.
+   * @throws {TypeError} If invalid options or ChannelResolvable are provided.
+   * @throws {Error} If the API request fails.
+   * @example
+   * // Update channel name and remove its description
+   * await client.channels.edit("01H...", { name: "general", description: null });
+   */
+  async edit(channel, options) {
+    if (!options || typeof options !== "object") {
+      throw new TypeError("ChannelEditOptions must be a valid object.");
+    }
+    const payload = {};
+    const remove = [];
+    if (options.name !== void 0) payload.name = options.name;
+    if (options.owner !== void 0) payload.owner = options.owner;
+    if (options.nsfw !== void 0) payload.nsfw = options.nsfw;
+    if (options.archived !== void 0) payload.archived = options.archived;
+    if (options.voice !== void 0) payload.voice = options.voice;
+    if (options.slowmode !== void 0) payload.slowmode = options.slowmode;
+    if (options.description !== void 0) {
+      if (options.description === null) remove.push("Description");
+      else payload.description = options.description;
+    }
+    if (options.icon !== void 0) {
+      if (options.icon === null) remove.push("Icon");
+      else payload.icon = options.icon;
+    }
+    if (remove.length > 0) payload.remove = remove;
+    if (Object.keys(payload).length === 0) return this.fetch(channel);
+    const data = await this.client.rest.patch(`/channels/${this.resolveId(channel)}`, payload);
+    return this._add(data);
+  }
+  /**
+   * Updates the permission overrides for a specific role in a channel.
+   * @param channel The ChannelResolvable to update permissions for.
+   * @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 client.channels.setRolePermissions(channel, "ROLE_ID", { deny: ["SendMessage"] });
+   */
+  async setRolePermissions(channel, roleId, options) {
+    const resolved = this.resolve(channel);
+    if (resolved && !resolved.isText()) {
+      throw new TypeError("Role permissions can only be set on Server Channels.");
+    }
+    if (!options || typeof options !== "object") {
+      throw new TypeError("ChannelRolePermissionOptions must be a valid object.");
+    }
+    const id = this.resolveId(channel);
+    const allowBigInt = options.allow !== void 0 ? Permissions.resolve(options.allow) : 0n;
+    const denyBigInt = options.deny !== void 0 ? Permissions.resolve(options.deny) : 0n;
+    const payload = {
+      permissions: {
+        allow: Number(allowBigInt),
+        deny: Number(denyBigInt)
+      }
+    };
+    const data = await this.client.rest.put(`/channels/${id}/permissions/${roleId}`, payload);
+    return this._add(data);
+  }
+  /**
+   * Updates the default (everyone) permissions for a channel.
+   * @param channel The ChannelResolvable to update permissions for.
+   * @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 client.channels.setDefaultPermissions(channel, ["ViewChannel", "ReadMessageHistory"]);
+   */
+  async setDefaultPermissions(channel, permissions) {
+    const resolved = this.resolve(channel);
+    if (resolved && resolved.isDM()) {
+      throw new TypeError("Default permissions cannot be set on Direct Message channels.");
+    }
+    const id = this.resolveId(channel);
+    const permBigInt = Permissions.resolve(permissions);
+    const payload = {
+      permissions: Number(permBigInt)
+    };
+    const data = await this.client.rest.put(`/channels/${id}/permissions/default`, payload);
+    return this._add(data);
+  }
+  /**
+   * Deletes a server channel, leaves a group, or closes a DM.
+   * @param channel The channel object, raw ID, or mention string to delete.
+   * @returns A promise that resolves when the action is successful.
+   * @throws {Error} If the API request fails.
+   * @example
+   * await client.channels.delete("01H...");
+   */
+  async delete(channel) {
+    const id = this.resolveId(channel);
+    await this.client.rest.delete(`/channels/${id}`);
+    this.cache.delete(id);
+  }
+};
+
+// src/structures/Member.ts
+import * as util4 from "util";
+
+// src/managers/MemberRoleManager.ts
+var MemberRoleManager = class {
+  constructor(member) {
+    this.member = member;
+  }
+  /**
+   * Gets a Collection of the actual Role objects this member has.
+   * This dynamically pulls from the Server's role cache so references are always up to date
+   */
+  get cache() {
+    const fetched = new Collection();
+    const server = this.member.server;
+    if (!server) return fetched;
+    for (const roleId of this.member.roleIds) {
+      const role = server.roles.cache.get(roleId);
+      if (role) fetched.set(role.id, role);
+    }
+    return fetched;
+  }
+  /**
+   * Checks if the member has a specific role.
+   * @param role The RoleResolvable to check for.
+   */
+  has(role) {
+    const server = this.member.server;
+    if (!server) return false;
+    const id = server.roles.resolveId(role);
+    return this.member.roleIds.includes(id);
+  }
+  /**
+   * Adds a role to the member.
+   * @param role The RoleResolvable to add.
+   * @returns A promise that resolves to the updated Member.
+   */
+  async add(role) {
+    const server = this.member.server;
+    if (!server) throw new Error("Server not cached, cannot add role.");
+    const id = server.roles.resolveId(role);
+    if (this.member.roleIds.includes(id)) return this.member;
+    const newRoles = [...this.member.roleIds, id];
+    return this.member.edit({ roles: newRoles });
+  }
+  /**
+   * Removes a role from the member.
+   * @param role The RoleResolvable to remove.
+   * @returns A promise that resolves to the updated Member.
+   */
+  async remove(role) {
+    const server = this.member.server;
+    if (!server) throw new Error("Server not cached, cannot remove role.");
+    const id = server.roles.resolveId(role);
+    if (!this.member.roleIds.includes(id)) return this.member;
+    const newRoles = this.member.roleIds.filter((rId) => rId !== id);
+    return this.member.edit({ roles: newRoles });
+  }
+  /**
+   * Overwrites all roles on the member with a completely new array.
+   * @param roles An array of RoleResolvables.
+   * @returns A promise that resolves to the updated Member.
+   */
+  async set(roles) {
+    const server = this.member.server;
+    if (!server) throw new Error("Server not cached, cannot set roles.");
+    const newRoles = roles.map((r) => server.roles.resolveId(r));
+    return this.member.edit({ roles: newRoles });
+  }
+};
+
+// src/structures/Member.ts
+var Member = class extends Base {
+  serverId;
+  nickname = null;
+  avatar = null;
+  roleIds = [];
+  joinedAt;
+  timeout = null;
+  canPublish = false;
+  canRecieve = false;
+  roles;
+  constructor(client, data) {
+    super(client, { _id: data.user._id });
+    this.serverId = data.serverId || data.server_id;
+    this.joinedAt = new Date(data.joinedAt || data.joined_at);
+    this.roles = new MemberRoleManager(this);
+    this._patch(data);
+  }
+  _patch(data) {
+    if (data.nickname !== void 0) this.nickname = data.nickname;
+    if (data.avatar !== void 0) this.avatar = data.avatar;
+    if (data.roles !== void 0) this.roleIds = data.roles;
+    if (data.timeout !== void 0) this.timeout = data.timeout ? new Date(data.timeout) : null;
+    if (data.can_publish !== void 0) this.canPublish = data.canPublish;
+    if (data.can_recieve !== void 0) this.canRecieve = data.canRecieve;
+  }
+  /** Gets the global User object for this member */
+  get user() {
+    return this.client.users.cache.get(this.id);
+  }
+  /** Gets the Server object this member belongs to */
+  get server() {
+    return this.client.servers.cache.get(this.serverId);
+  }
+  /** Resolves the array of role strings into actual Role objects */
+  get roleObjects() {
+    const server = this.server;
+    if (!server) return [];
+    return this.roleIds.map((id) => server.roles.cache.get(id)).filter((role) => role !== void 0);
+  }
+  /** Calculates the member's total permissions using BigInt */
+  get permissions() {
+    const server = this.server;
+    if (!server) return 0n;
+    let totalPerms = server.defaultPermissions ?? 0n;
+    for (const role of this.roleObjects) {
+      totalPerms |= BigInt(role.permissions);
+    }
+    if (server.ownerId === this.id) {
+      return PermissionFlags.GrantAllSafe;
+    }
+    return totalPerms;
+  }
+  /** Checks if the member has a specific permission */
+  hasPermission(permission) {
+    return Permissions.has(this.permissions, permission);
+  }
+  /**
+   * Edits this member's nickname, avatar, roles, or timeout.
+   */
+  async edit(options) {
+    let server = this.server;
+    if (!server) server = await this.client.servers.fetch(this.serverId);
+    return await server.members.edit(this.id, options);
+  }
+  /**
+   * Kicks this member from the server.
+   */
+  async kick() {
+    let server = this.server;
+    if (!server) server = await this.client.servers.fetch(this.serverId);
+    await server.members.kick(this.id);
+  }
+  /**
+   * Bans this member from the server.
+   * @param options The options for this ban
+   */
+  async ban(options) {
+    let server = this.server;
+    if (!server) server = await this.client.servers.fetch(this.serverId);
+    await server.members.ban(this.id, options);
+  }
+  async unban() {
+    let server = this.client.servers.cache.get(this.serverId);
+    if (!server) server = await this.client.servers.fetch(this.serverId);
+    await server.members.unban(this.id);
+  }
+  [util4.inspect.custom](depth, options, inspect10) {
+    const { client, serverId, ...props } = this;
+    return `${this.constructor.name} ${inspect10(
+      {
+        ...props,
+        user: this.user,
+        permissions: this.permissions
+      },
+      { ...options, depth: depth ?? options.depth }
+    )}`;
+  }
+};
+
+// src/managers/MemberManager.ts
+import * as util5 from "util";
+var MemberManager = class extends BaseManager {
+  constructor(client, server, limit = Infinity) {
+    super(client, limit);
+    this.server = server;
+  }
+  /**
+   * Tell BaseManager how to handle Revolt's Member IDs
+   * @internal
+   */
+  extractId(data) {
+    return data.user_id ?? data.id ?? (typeof data._id === "string" ? data._id : data._id?.user);
+  }
+  /**
+   * Tell BaseManager how to build a Member
+   * @internal
+   */
+  construct(data) {
+    if (!data.server_id && !data.serverId) {
+      data.serverId = this.server.id;
+    }
+    return new Member(this.client, data);
+  }
+  resolve(member) {
+    if (member instanceof Member) return member;
+    if (member instanceof User) return this.cache.get(member.id);
+    if (typeof member === "string") return this.cache.get(member.replace(/[<@>]/g, ""));
+    return void 0;
+  }
+  resolveId(member) {
+    if (typeof member === "string") return member.replace(/[<@>]/g, "");
+    if ("id" in member) return member.id;
+    throw new TypeError("Invalid MemberResolvable provided.");
+  }
+  async fetch(member, force = true) {
+    if (!force) {
+      const cached = this.resolve(member);
+      if (cached) return cached;
+    }
+    const id = this.resolveId(member);
+    const data = await this.client.rest.get(`/channels/${id}`);
+    return this._add(data);
+  }
+  /**
+   * Fetches multiple members from the server.
+   * @param options Filter options for the fetch request.
+   * @returns A promise that resolves to a Collection of fetched Members.
+   * @throws {Error} If the API request fails.
+   * @example
+   * // Fetch all members in the server
+   * const allMembers = await server.members.fetchMany();
+   *
+   * // Fetch only online members to save bandwidth
+   * const onlineMembers = await server.members.fetchMany({ exclude_offline: true });
+   */
+  async fetchMany(options = {}) {
+    const params = new URLSearchParams();
+    if (options.exclude_offline !== void 0) {
+      params.append("exclude_offline", options.exclude_offline.toString());
+    }
+    const queryString = params.toString();
+    const endpoint = `/servers/${this.server.id}/members${queryString ? `?${queryString}` : ""}`;
+    const data = await this.client.rest.get(endpoint);
+    if (data.users && Array.isArray(data.users)) {
+      for (const userData of data.users) {
+        this.client.users._add(userData);
+      }
+    }
+    const fetched = new Collection();
+    const rawMembers = data.members || (Array.isArray(data) ? data : []);
+    for (const rawMember of rawMembers) {
+      const member = this._add(rawMember);
+      fetched.set(member.id, member);
+    }
+    return fetched;
+  }
+  /**
+   * Edits a member in the server.
+   * @param member The MemberResolvable to edit.
+   * @param options The fields to update (nickname, roles, timeout, etc.).
+   */
+  async edit(member, options) {
+    const id = this.resolveId(member);
+    const payload = {};
+    const remove = [];
+    if (options.nickname !== void 0) {
+      if (options.nickname === null) remove.push("Nickname");
+      else payload.nickname = options.nickname;
+    }
+    if (options.avatar !== void 0) {
+      if (options.avatar === null) remove.push("Avatar");
+      else payload.avatar = options.avatar;
+    }
+    if (options.roles !== void 0) payload.roles = options.roles;
+    if (options.timeout !== void 0) {
+      if (options.timeout === null) remove.push("Timeout");
+      else payload.timeout = options.timeout;
+    }
+    if (remove.length > 0) payload.remove = remove;
+    if (Object.keys(payload).length === 0) return this.fetch(id);
+    const data = await this.client.rest.patch(`/servers/${this.server.id}/members/${id}`, payload);
+    return this._add(data);
+  }
+  /**
+   * Kicks a member from the server.
+   * @param member The MemberResolvable to kick.
+   */
+  async kick(member) {
+    const id = this.resolveId(member);
+    await this.client.rest.delete(`/servers/${this.server.id}/members/${id}`);
+    this.cache.delete(id);
+  }
+  /**
+   * Bans a member from the server.
+   * @param member The MemberResolvable to ban.
+   * @param options The ban options
+   */
+  async ban(member, options) {
+    const id = this.resolveId(member);
+    const payload = {};
+    if (options?.reason !== void 0) payload.reason = options.reason;
+    if (options?.deleteMessageSeconds !== void 0) payload.delete_message_seconds = options.deleteMessageSeconds;
+    await this.client.rest.put(`/servers/${this.server.id}/bans/${id}`, payload);
+    this.cache.delete(id);
+  }
+  /**
+   * Unbans a user from the server
+   * @param member The MemberResolvable to unban
+   */
+  async unban(member) {
+    const id = this.resolveId(member);
+    await this.client.rest.delete(`/servers/${this.server.id}/bans/${id}`);
+  }
+  [util5.inspect.custom]() {
+    return this.cache;
+  }
+};
+
+// src/managers/ServerChannelManager.ts
+import * as util6 from "util";
+var ServerChannelManager = class {
+  constructor(client, server) {
+    this.client = client;
+    this.server = server;
+  }
+  get cache() {
+    return this.client.channels.cache.filter((channel) => channel.serverId === this.server.id);
+  }
+  /**
+   * Creates a new channel within this server.
+   * @param options The configuration for the new channel.
+   * @returns The newly created Channel object.
+   */
+  async create(options) {
+    if (!options.name) throw new Error("A channel name must be provided.");
+    const payload = {
+      name: options.name,
+      type: options.type ?? "Text",
+      description: options.description,
+      nsfw: options.nsfw ?? false
+    };
+    if (options.type === "Voice" && options.voice?.max_users) {
+      payload.voice = { max_users: options.voice.max_users };
+    }
+    const data = await this.client.rest.post(`/servers/${this.server.id}/channels`, payload);
+    return this.client.channels._add(data);
+  }
+  [util6.inspect.custom]() {
+    return this.cache;
+  }
+};
+
+// src/structures/Role.ts
+import * as util7 from "util";
+var Role = class extends Base {
+  serverId;
+  name;
+  color = null;
+  hoist = false;
+  rank = 0;
+  permissions = 0n;
+  constructor(client, data, serverId) {
+    super(client, data);
+    this.serverId = serverId;
+    this._patch(data);
+  }
+  /**
+   * Updates the role instance with new data without losing the object reference.
+   * @internal
+   */
+  _patch(data) {
+    if (data.name !== void 0) this.name = data.name;
+    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.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);
+        } else {
+          this.permissions = BigInt(data.permissions);
+        }
+      } catch {
+        this.permissions = 0n;
+      }
+    }
+  }
+  /**
+   * The server this role belongs to.
+   * Pulls dynamically from the cache to prevent massive memory duplication.
+   */
+  get server() {
+    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.
+   */
+  hasPermission(permission) {
+    return Permissions.has(this.permissions, permission);
+  }
+  /**
+   * Fetches this role directly from the API to ensure data is up to date.
+   * @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 Role object.
+   * @throws {TypeError} If an invalid RoleResolvable is provided.
+   * @throws {Error} If the API request fails (e.g., the role does not exist).
+   * @example
+   * // Refresh the role's data from the API
+   * await role.fetch();
+   * console.log(`Role updated, current name: ${role.name}`);
+   */
+  async fetch(force = true) {
+    let server = this.server;
+    if (!server) {
+      server = await this.client.servers.fetch(this.serverId);
+    }
+    return await server.roles.fetch(this.id, force);
+  }
+  /**
+   * Edits the role with the given options. Only the fields provided in the options will be updated; all other fields will remain unchanged.
+   * @param options The fields to update.
+   * @returns A promise that resolves to the updated Role.
+   * @throws {TypeError} If invalid options or RoleResolvable are provided.
+   * @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" });
+   *
+   * // Remove the custom color from the role
+   * await role.edit({ colour: null });
+   */
+  async edit(options) {
+    let server = this.server;
+    if (!server) server = await this.client.servers.fetch(this.serverId);
+    return await server.roles.edit(this.id, options);
+  }
+  /**
+   * Deletes this Role from the server.
+   * @throws {Error} If the role cannot be deleted (e.g., lack of permissions).
+   * @example
+   * // Delete a role by its ID
+   * await role.delete();
+   */
+  async delete() {
+    let server = this.server;
+    if (!server) {
+      server = await this.client.servers.fetch(this.serverId);
+    }
+    await server.roles.delete(this.id);
+  }
+  /**
+   * Updates the permissions for this role.
+   * @param options The allow and deny permissions to set.
+   * @returns A promise that resolves to the updated Role object.
+   * @throws {TypeError} If invalid options are provided.
+   * @throws {Error} If the API request fails.
+   * @example
+   * // Grant the role permission to manage channels and send messages
+   * await role.setPermissions({
+   *   allow: ["ManageChannel", "SendMessage"]
+   * });
+   */
+  async setPermissions(options) {
+    let server = this.server;
+    if (!server) server = await this.client.servers.fetch(this.serverId);
+    return await server.roles.setPermissions(this.id, options);
+  }
+  /**
+   * Updates the hierarchical position of this role.
+   * Automatically reconstructs the role array and performs a bulk update.
+   * @param newPosition The new rank/position for this role (0-indexed).
+   * @returns A promise that resolves to this updated Role object.
+   * @throws {Error} If API request fails.
+   * @example
+   * // Move this role to position 2 in the hierarchy
+   * await role.setPosition(2);
+   * console.log(`Role moved to rank: ${role.rank}`);
+   */
+  async setPosition(newPosition) {
+    let server = this.server;
+    if (!server) server = await this.client.servers.fetch(this.serverId);
+    const sortedRoles = Array.from(server.roles.cache.values()).sort((a, b) => a.rank - b.rank);
+    const filteredRoles = sortedRoles.filter((r) => r.id !== this.id);
+    const clampedPosition = Math.max(0, Math.min(newPosition, filteredRoles.length));
+    filteredRoles.splice(clampedPosition, 0, this);
+    await server.roles.setRanks(filteredRoles);
+    return this;
+  }
+  /**
+   * 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]() {
+    const { client, serverId, ...props } = this;
+    return `${this.constructor.name} ${util7.inspect(props)}`;
+  }
+};
+
+// src/managers/RoleManager.ts
+import * as util8 from "util";
+var RoleManager = class extends BaseManager {
+  /**
+   * Manages API methods and caching for server roles.
+   */
+  constructor(client, server, limit = Infinity) {
+    super(client, limit);
+    this.server = server;
+  }
+  /**
+   * Tell BaseManager how to find the ID for Roles
+   */
+  extractId(data) {
+    return data._id ?? data.id;
+  }
+  /**
+   * Tell BaseManager how to build a Role
+   */
+  construct(data) {
+    return new Role(this.client, data, this.server.id);
+  }
+  /**
+   * Adds or updates a role in the local cache.
+   * @internal
+   * @param data The raw role data from the API.
+   * @param idParam An optional ID parameter if the payload wraps the role object.
+   * @returns The newly created or updated Role object.
+   */
+  _add(data, idParam) {
+    const id = idParam ?? data._id ?? data.id;
+    const existing = this.cache.get(id);
+    if (existing) {
+      existing._patch(data);
+      return existing;
+    }
+    const role = new Role(this.client, data, this.server.id);
+    this.cache.set(role.id, role);
+    return role;
+  }
+  [util8.inspect.custom]() {
+    return this.cache;
+  }
+  /**
+   * Resolves a RoleResolvable to a Role object from the cache.
+   * @param role The RoleResolvable to resolve.
+   * @returns The resolved Role object, or undefined if not found.
+   */
+  resolve(role) {
+    if (role instanceof Role) return role;
+    if (typeof role === "string") {
+      const id = role.replace(/[<%>]/g, "");
+      return this.cache.get(id);
+    }
+    return void 0;
+  }
+  /**
+   * Extracts ID from a RoleResolvable.
+   * @param role The RoleResolvable to extract the ID from.
+   * @returns The extracted role ID.
+   * @throws TypeError if an invalid type is provided.
+   */
+  resolveId(role) {
+    if (role instanceof Role) {
+      return role.id;
+    }
+    if (typeof role === "string") {
+      return role.replace(/[<%>]/g, "");
+    }
+    throw new TypeError("Invalid RoleResolvable provided. Expected a Role object or a string ID/Mention.");
+  }
+  /**
+   * Creates a new role in this server.
+   * @param options The name and optional rank of the new role
+   * @returns Role The role that was created
+   * @throws {Error} If the role cannot be created (e.g., lack of permissions, invalid options).
+   * @throws {TypeError} If invalid options are provided.
+   * @example
+   * // Create a new role named "Moderator" with rank 1
+   * const moderatorRole = await server.roles.create({ name: "Moderator", rank: 1 });
+   * console.log(`Created role: ${moderatorRole.name} with ID: ${moderatorRole.id}`);
+   */
+  async create(options) {
+    if (!options || typeof options !== "object") {
+      throw new TypeError("RoleCreateOptions must be a valid object.");
+    }
+    if (typeof options.name !== "string" || options.name.trim().length === 0) {
+      throw new TypeError("A valid role 'name' (string) must be provided.");
+    }
+    const payload = {
+      name: options.name
+    };
+    const data = await this.client.rest.post(`/servers/${this.server.id}/roles`, payload);
+    return this._add(data);
+  }
+  /**
+   * Fetches a Role from the API or resolves it from the local cache.
+   * @param role The ID, mention, or Role object to fetch.
+   * @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 Role object.
+   * @throws {TypeError} If an invalid RoleResolvable is provided.
+   * @throws {Error} If the API request fails (e.g., the role does not exist).
+   * @example
+   * // Fetch a role from the API
+   * const role = await server.roles.fetch("01JE2MM759J5D7CHJF084R7MJ2");
+   * console.log(`Fetched role: ${role.name} with ID: ${role.id}`);
+   *
+   * // Fetch a role by mention
+   * const role = await.server.roles.fetch("<%01JE2MM759J5D7CHJF084R7MJ2>");
+   * console.log(`Fetched role: ${role.name} with ID: ${role.id}`);
+   *
+   * // Force fetch a role, bypassing the cache
+   * const role = await server.roles.fetch("01JE2MM759J5D7CHJF084R7MJ2", true);
+   * console.log(`Fetched role: ${role.name} with ID: ${role.id}`);
+   */
+  async fetch(role, force = false) {
+    if (!force) {
+      const cached = this.resolve(role);
+      if (cached) return cached;
+    }
+    const id = this.resolveId(role);
+    const data = await this.client.rest.get(`/servers/${this.server.id}/roles/${id}`);
+    return this._add(data);
+  }
+  /**
+   * Edits an existing role in the server.
+   * @param role The 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.
+   * @throws {Error} If the API request fails (e.g., lack of permissions).
+   * @example
+   * // Rename a role and give it a red color
+   * await server.roles.edit("01H...", { name: "Super Admin", colour: "#FF0000" });
+   *
+   * // Remove the custom color from a role
+   * await server.roles.edit(role, { colour: null });
+   */
+  async edit(role, options) {
+    if (!options || typeof options !== "object") {
+      throw new TypeError("RoleEditOptions must be a valid object.");
+    }
+    const id = this.resolveId(role);
+    const payload = {};
+    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) {
+        remove.push("Colour");
+      } else {
+        payload.colour = options.colour;
+      }
+    }
+    if (remove.length > 0) {
+      payload.remove = remove;
+    }
+    if (Object.keys(payload).length === 0) {
+      return this.fetch(id);
+    }
+    const data = await this.client.rest.patch(`/servers/${this.server.id}/roles/${id}`, payload);
+    return this._add(data, id);
+  }
+  /**
+   * Deletes a Role from the server.
+   * @param role The RoleResolvable to delete
+   * @returns A promise that resolves when the role is successfully deleted.
+   * @throws {TypeError} If an invalid RoleResolvable is provided.
+   * @throws {Error} If the role cannot be deleted (e.g., lack of permissions).
+   * @example
+   * // Delete a role by its ID
+   * await server.roles.delete("01JE2MM759J5D7CHJF084R7MJ2");
+   * console.log("Role deleted successfully.");
+   *
+   * // Delete a role using a Role object
+   * const role = await server.roles.fetch("01JE2MM759J5D7CHJF084R7MJ2");
+   * await server.roles.delete(role);
+   * console.log("Role deleted successfully.");
+   *
+   * // Delete a role by mention
+   * await server.roles.delete("<%01JE2MM759J5D7CHJF084R7MJ2>");
+   * console.log("Role deleted successfully.");
+   */
+  async delete(role) {
+    const id = this.resolveId(role);
+    await this.client.rest.delete(`/servers/${this.server.id}/roles/${id}`);
+    this.cache.delete(id);
+  }
+  /**
+   * Updates the permissions for a role in the server.
+   * @param role The RoleResolvable to update permissions for.
+   * @param options The allow and deny permissions to set.
+   * @returns A promise that resolves to the updated Role.
+   * @throws {TypeError} If an invalid RoleResolvable or options are provided.
+   * @throws {Error} If the API request fails.
+   * @example
+   * // Set permissions using an array of strings.
+   * await server.roles.setPermissions(role, {
+   *   allow: ["ManageChannel", "ViewChannel", "SendMessage"]
+   * });
+   */
+  async setPermissions(role, options) {
+    if (!options || typeof options !== "object") {
+      throw new TypeError("RolePermissionOptions must be a valid object.");
+    }
+    const id = this.resolveId(role);
+    const allowBigInt = options.allow !== void 0 ? Permissions.resolve(options.allow) : 0n;
+    const denyBigInt = options.deny !== void 0 ? Permissions.resolve(options.deny) : 0n;
+    const payload = {
+      permissions: {
+        allow: Number(allowBigInt),
+        deny: Number(denyBigInt)
+      }
+    };
+    const data = await this.client.rest.put(`/servers/${this.server.id}/permissions/${id}`, payload);
+    this.server._patch(data);
+    return this.cache.get(id);
+  }
+  /**
+   * Updates the hierarchical positions of roles in the server.
+   * @param ranks An array of RoleResolvables representing the new order of roles.
+   * @returns A promise that resolves when the ranks are successfully updated.
+   * @throws {TypeError} If the ranks parameter is not an array or contains invalid resolvables.
+   * @throws {Error} If the API request fails.
+   * @example
+   * // Reorder roles by passing an array of Role objects or IDs
+   * await server.roles.setRanks(["RoleID_1", adminRoleObject, "RoleID_3"]);
+   */
+  async setRanks(ranks) {
+    if (!Array.isArray(ranks)) {
+      throw new TypeError("The 'ranks' parameter must be an array of RoleResolvables.");
+    }
+    const mappedIds = ranks.map((role) => this.resolveId(role));
+    const payload = {
+      ranks: mappedIds
+    };
+    const data = await this.client.rest.put(`/servers/${this.server.id}/roles`, payload);
+    this.server._patch(data);
+    return this.server;
+  }
+};
+
+// src/structures/ServerInvite.ts
+var ServerInvite = class {
+  code;
+  creatorId;
+  channelId;
+  constructor(data) {
+    this.code = data._id ?? data.code;
+    this.creatorId = data.creator;
+    this.channelId = data.channel;
+  }
+  _patch(data) {
+    this.creatorId = data.creator ?? this.creatorId;
+    this.channelId = data.channel ?? this.channelId;
+  }
+};
+
+// src/managers/ServerInviteManager.ts
+var ServerInviteManager = class extends BaseManager {
+  constructor(client, server, limit = Infinity) {
+    super(client, limit);
+    this.server = server;
+  }
+  extractId(data) {
+    return data._id ?? data.code;
+  }
+  construct(data) {
+    return new ServerInvite(data);
+  }
+  /**
+   * Fetches all active invites for this server.
+   */
+  async fetch() {
+    const data = await this.client.rest.get(`/servers/${this.server.id}/invites`);
+    const rawInvites = Array.isArray(data) ? data : [];
+    const fetched = new Collection();
+    for (const raw of rawInvites) {
+      const invite = this._add(raw);
+      fetched.set(invite.code, invite);
+    }
+    return fetched;
+  }
+};
+
+// src/structures/ServerBan.ts
+var ServerBan = class {
+  userId;
+  reason;
+  constructor(data) {
+    this.userId = data._id?.user ?? data.id;
+    this.reason = data.reason ?? null;
+  }
+  _patch(data) {
+    if (data.reason !== void 0) this.reason = data.reason;
+  }
+};
+
+// src/managers/ServerBanManager.ts
+var ServerBanManager = class extends BaseManager {
+  constructor(client, server, limit = Infinity) {
+    super(client, limit);
+    this.server = server;
+  }
+  extractId(data) {
+    return data._id?.user ?? data.id;
+  }
+  construct(data) {
+    return new ServerBan(data);
+  }
+  /**
+   * Fetches all bans in this server.
+   * Automatically caches the associated User objects globally!
+   * @returns A promise that resolves to a Collection of Bans.
+   */
+  async fetch() {
+    const data = await this.client.rest.get(`/servers/${this.server.id}/bans`);
+    if (data.users && Array.isArray(data.users)) {
+      for (const userData of data.users) {
+        this.client.users._add(userData);
+      }
+    }
+    const rawBans = data.bans || (Array.isArray(data) ? data : []);
+    const fetched = new Collection();
+    for (const rawBan of rawBans) {
+      const ban = this._add(rawBan);
+      fetched.set(ban.userId, ban);
+    }
+    return fetched;
+  }
+  /**
+   * Unbans a user from the server.
+   * @param userId The ID of the user to unban.
+   */
+  async remove(userId) {
+    const id = userId.replace(/[<@!>]/g, "");
+    await this.client.rest.delete(`/servers/${this.server.id}/bans/${id}`);
+    this.cache.delete(id);
+  }
+};
+
+// src/structures/Server.ts
+var Server = class extends Base {
+  channelIds = [];
+  defaultPermissions;
+  name;
+  ownerId;
+  analytics = false;
+  banner = null;
+  categories = [];
+  description = null;
+  discoverable = false;
+  flags = 0;
+  icon = null;
+  nsfw = false;
+  members;
+  channels;
+  roles;
+  bans;
+  invites;
+  constructor(client, data) {
+    super(client, data);
+    this.channels = new ServerChannelManager(client, this);
+    this.members = new MemberManager(client, this);
+    this.roles = new RoleManager(client, this);
+    this.bans = new ServerBanManager(this.client, this);
+    this.invites = new ServerInviteManager(this.client, this);
+    this._patch(data);
+  }
+  /**
+   * Updates the server instance with new data without losing the object reference.
+   */
+  _patch(data, clear) {
+    if (data.channels !== void 0) this.channelIds = data.channels;
+    if (data.default_permissions !== void 0) {
+      try {
+        this.defaultPermissions = BigInt(data.default_permissions);
+      } catch {
+        this.defaultPermissions = 0n;
+      }
+    }
+    if (data.name !== void 0) this.name = data.name;
+    if (data.owner !== void 0) this.ownerId = data.owner;
+    if (data.analytics !== void 0) this.analytics = data.analytics;
+    if (data.categories !== void 0) this.categories = data.categories;
+    if (data.description !== void 0) this.description = data.description;
+    if (data.discoverable !== void 0) this.discoverable = data.discoverable;
+    if (data.flags !== void 0) this.flags = data.flags;
+    if (data.nsfw !== void 0) this.nsfw = data.nsfw;
+    if (data.icon !== void 0) {
+      this.icon = data.icon ? new Attachment(this.client, data.icon) : null;
+    }
+    if (data.banner !== void 0) {
+      this.banner = data.banner ? new Attachment(this.client, data.banner) : null;
+    }
+    if (data.roles !== void 0) {
+      for (const [id, roleData] of Object.entries(data.roles)) {
+        this.roles._add({ id, ...roleData });
+      }
+    }
+    if (clear && Array.isArray(clear)) {
+      for (const field of clear) {
+        switch (field) {
+          case "Description":
+            this.description = null;
+            break;
+          case "Icon":
+            this.icon = null;
+            break;
+        }
+      }
+    }
+  }
+  /**
+   * Edits this server.
+   * @param options The fields to update.
+   */
+  async edit(options) {
+    await this.client.servers.edit(this.id, options);
+    return this;
+  }
+  /**
+   * Leaves the server
+   */
+  async leave() {
+    return this.client.rest.delete(`/servers/${this.id}/leave`);
+  }
+  /**
+   * Fetches multiple members from this server.
+   * @param options Filter options for the fetch request.
+   * @returns A Collection of the fetched members.
+   */
+  async fetchMembers(options) {
+    return this.members.fetchMany(options);
+  }
+};
+
+// src/managers/ServerManager.ts
+import * as util9 from "util";
+var ServerManager = class extends BaseManager {
+  constructor(client, limit = Infinity) {
+    super(client, limit);
+  }
+  /**
+   * Tell BaseManager how to find the ID for Servers
+   */
+  extractId(data) {
+    return data._id ?? data.id;
+  }
+  /**
+   * Tell BaseManager how to build a Server
+   */
+  construct(data) {
+    return new Server(this.client, data);
+  }
+  /**
+   * Fetches a server from the API.
+   * @param id The server ID.
+   * @param force Whether to skip the cache and fetch from the API.
+   */
+  async fetch(id, force = false) {
+    if (!force) {
+      const cached = this.cache.get(id);
+      if (cached) return cached;
+    }
+    const data = await this.client.rest.get(`/servers/${id}`);
+    return this._add(data);
+  }
+  async edit(serverId, options) {
+    const payload = {};
+    const remove = [];
+    if (options.name !== void 0) payload.name = options.name;
+    if (options.description !== void 0) {
+      if (options.description === null) remove.push("Description");
+      else payload.description = options.description;
+    }
+    if (options.icon !== void 0) {
+      if (options.icon === null) remove.push("Icon");
+      else payload.icon = options.icon;
+    }
+    if (options.banner !== void 0) {
+      if (options.banner === null) remove.push("Banner");
+      else payload.banner = options.banner;
+    }
+    if (options.systemMessages) {
+      payload.system_messages = {};
+      const sm = options.systemMessages;
+      if (sm.userJoined !== void 0) {
+        if (sm.userJoined === null) remove.push("SystemMessageUserJoined");
+        else payload.system_messages.user_joined = sm.userJoined;
+      }
+      if (sm.userLeft !== void 0) {
+        if (sm.userLeft === null) remove.push("SystemMessageUserLeft");
+        else payload.system_messages.user_left = sm.userLeft;
+      }
+      if (sm.userKicked !== void 0) {
+        if (sm.userKicked === null) remove.push("SystemMessageUserKicked");
+        else payload.system_messages.user_kicked = sm.userKicked;
+      }
+      if (sm.userBanned !== void 0) {
+        if (sm.userBanned === null) remove.push("SystemMessageUserBanned");
+        else payload.system_messages.user_banned = sm.userBanned;
+      }
+    }
+    if (options.categories !== void 0) payload.categories = options.categories;
+    if (options.analytics !== void 0) payload.analytics = options.analytics;
+    if (options.owner !== void 0) payload.owner = options.owner;
+    if (remove.length > 0) payload.remove = remove;
+    const data = await this.client.rest.patch(`/servers/${serverId}`, payload);
+    return this._add(data);
+  }
+  [util9.inspect.custom]() {
+    return this.cache;
+  }
+};
+
+// src/managers/UserManager.ts
+var UserManager = class extends BaseManager {
+  constructor(client, limit = Infinity) {
+    super(client, limit);
+  }
+  /**
+   * Tell BaseManager how to find the ID for Users
+   */
+  extractId(data) {
+    return data._id ?? data.id;
+  }
+  /**
+   * Tell BaseManager how to build a User
+   */
+  construct(data) {
+    return new User(this.client, data);
+  }
+  /**
+   * Resolves a UserResolvable to a User object from the cache.
+   */
+  resolve(user) {
+    if (user instanceof User) return user;
+    if (typeof user === "string") {
+      const id = user.replace(/[<@>]/g, "");
+      return this.cache.get(id);
+    }
+    return void 0;
+  }
+  /**
+   * Extracts ID from a UserResolvable.
+   * @param user The UserResolvable to extract the ID from.
+   * @returns The extracted user ID.
+   * @throws TypeError if an invalid type is provided.
+   */
+  resolveId(user) {
+    if (user instanceof User) {
+      return user.id;
+    }
+    if (typeof user === "string") {
+      return user.replace(/[<@>]/g, "");
+    }
+    throw new TypeError("Invalid UserResolvable provided. Expected a User object or a string ID/Mention.");
+  }
+  /**
+   * Fetches a User.
+   * @param user The ID or mention to fetch
+   * @param force Skip the cache check and force an API request
+   * @returns The fetched User object
+   * @throws Error if the user cannot be found or fetched
+   * @throws TypeError if invalid UserResolvable is provided
+   * @example
+   * // Fetch a user by ID
+   * const user = await client.users.fetch("01JE2MM759J5D7CHJF084R7MJ2");
+   * console.log(user.username);
+   *
+   * // Fetch a user by mention
+   * const user = await client.users.fetch("<@01JE2MM759J5D7CHJF084R7MJ2>");
+   * console.log(user.username);
+   *
+   * // Force fetch a user, bypassing the cache
+   * const user = await client.users.fetch("01JE2MM759J5D7CHJF084R7MJ2", true);
+   * console.log(user.username);
+   */
+  async fetch(user, force = false) {
+    if (!force) {
+      const cached = this.resolve(user);
+      if (cached) return cached;
+    }
+    const id = this.resolveId(user);
+    const data = await this.client.rest.get(`/users/${id}`);
+    return this._add(data);
+  }
+  /**
+   * Fetch the current user (the bot itself).
+   * @returns The fetched User object representing the current user.
+   * @throws Error if the user cannot be fetched.
+   * @example
+   * // Fetch the current user (the bot itself)
+   * const me = await client.users.fetchMe();
+   * console.log(`Logged in as ${me.tag}`);
+   */
+  async fetchMe() {
+    const data = await this.client.rest.get(`/users/@me`);
+    return this._add(data);
+  }
+  /**
+   * Edits the currently authenticated user (the bot itself).
+   * @param options The fields to update (avatar, status, profile, etc.).
+   * @returns A promise that resolves to the updated User object.
+   * @throws {TypeError} If invalid options are provided.
+   * @throws {Error} If the API request fails.
+   * @example
+   * // Update the bot's status and presence
+   * await client.users.editMe({
+   *   status: { text: "Watching the server", presence: "Online" }
+   * });
+   *
+   * // Clear the bot's avatar and display name
+   * await client.users.editMe({ avatar: null, displayName: null });
+   */
+  async editMe(options) {
+    if (!options || typeof options !== "object") {
+      throw new TypeError("UserEditOptions must be a valid object.");
+    }
+    const payload = {};
+    const remove = [];
+    if (options.displayName !== void 0) {
+      if (options.displayName === null) remove.push("DisplayName");
+      else payload.display_name = options.displayName;
+    }
+    if (options.avatar !== void 0) {
+      if (options.avatar === null) remove.push("Avatar");
+      else payload.avatar = options.avatar;
+    }
+    if (options.profile !== void 0) {
+      payload.profile = {};
+      if (options.profile.content !== void 0) {
+        if (options.profile.content === null) remove.push("ProfileContent");
+        else payload.profile.content = options.profile.content;
+      }
+      if (options.profile.background !== void 0) {
+        if (options.profile.background === null) remove.push("ProfileBackground");
+        else payload.profile.background = options.profile.background;
+      }
+      if (Object.keys(payload.profile).length === 0) delete payload.profile;
+    }
+    if (options.status !== void 0) {
+      payload.status = {};
+      if (options.status.text !== void 0) {
+        if (options.status.text === null) remove.push("StatusText");
+        else payload.status.text = options.status.text;
+      }
+      if (options.status.presence !== void 0) {
+        if (options.status.presence === null) remove.push("StatusPresence");
+        else payload.status.presence = options.status.presence;
+      }
+      if (Object.keys(payload.status).length === 0) delete payload.status;
+    }
+    if (remove.length > 0) {
+      payload.remove = remove;
+    }
+    if (Object.keys(payload).length === 0) {
+      return this.fetch("@me");
+    }
+    const data = await this.client.rest.patch(`/users/@me`, payload);
+    return this._add(data);
+  }
+};
+
+// src/managers/SweepManager.ts
+var SweeperManager = class {
+  constructor(client, options) {
+    this.client = client;
+    this.options = options;
+  }
+  messageInterval = null;
+  start() {
+    if (this.options.messages) {
+      this.client.emit("debug", "Starting Message Cache Sweeper...");
+      this.messageInterval = setInterval(() => {
+        this.sweepMessages();
+      }, this.options.messages.interval);
+    }
+  }
+  sweepMessages() {
+    if (!this.options.messages) return;
+    const now = Date.now();
+    const lifetime = this.options.messages.lifetime;
+    let sweptCount = 0;
+    for (const channel of this.client.channels.cache.values()) {
+      if (!("messages" in channel)) continue;
+      const textChannel = channel;
+      for (const [id, message] of textChannel.messages.cache.entries()) {
+        if (now - message.cachedAt > lifetime) {
+          textChannel.messages.cache.delete(id);
+          sweptCount++;
+        }
+      }
+    }
+    if (sweptCount > 0) {
+      this.client.emit("debug", `\u{1F9F9} Sweeper cleared ${sweptCount} old messages from cache.`);
+    }
+  }
+  stop() {
+    if (this.messageInterval) clearInterval(this.messageInterval);
+    this.client.emit("debug", "Sweepers stopped.");
+  }
+};
+
+// src/client/Client.ts
+var Client = class extends EventEmitter {
+  constructor(options = {}) {
+    super({ captureRejections: true });
+    this.options = options;
+    this.rest = new RESTManager(this);
+    this.gateway = new GatewayManager(this);
+    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.sweepers = new SweeperManager(this, options.sweepers ?? {});
+  }
+  rest;
+  gateway;
+  channels;
+  servers;
+  users;
+  sweepers;
+  user = null;
+  /**
+   * Connects the bot to the Stoat Gateway
+   */
+  async login(token) {
+    if (!token) throw new Error("A valid token must be provided.");
+    this.sweepers.start();
+    this.rest.setToken(token);
+    return this.gateway.connect(token);
+  }
+  [/* @__PURE__ */ Symbol.for("nodejs.rejection")](error) {
+    this.emit("error", error);
+  }
+  on(event, listener) {
+    return super.on(event, listener);
+  }
+  once(event, listener) {
+    return super.once(event, listener);
+  }
+  emit(event, ...args) {
+    return super.emit(event, ...args);
+  }
+};
+
+// src/builders/EmbedBuilder.ts
+var EmbedBuilder = class {
+  data;
+  constructor(data = {}) {
+    this.data = { type: "Text", ...data };
+  }
+  setTitle(title) {
+    this.data.title = title;
+    return this;
+  }
+  setDescription(description) {
+    this.data.description = description;
+    return this;
+  }
+  setUrl(url) {
+    this.data.url = url;
+    return this;
+  }
+  setIconUrl(iconUrl) {
+    this.data.icon_url = iconUrl;
+    return this;
+  }
+  setColor(color) {
+    this.data.colour = color;
+    return this;
+  }
+  setMedia(fileId) {
+    this.data.media = fileId;
+    return this;
+  }
+  /**
+   * Serializes the builder into the raw JSON required by the API
+   */
+  toJSON() {
+    return { ...this.data };
+  }
+};
+export {
+  Attachment,
+  Base,
+  BaseChannel,
+  ChannelManager,
+  ChannelType,
+  Client,
+  ClientUser,
+  Collection,
+  DMChannel,
+  EmbedBuilder,
+  GatewayManager,
+  Member,
+  MemberManager,
+  Message,
+  MessageManager,
+  PermissionFlags,
+  Permissions,
+  RESTManager,
+  Role,
+  RoleManager,
+  Server,
+  ServerChannelManager,
+  ServerManager,
+  SweeperManager,
+  TextChannel,
+  UnknownChannel,
+  User,
+  UserManager,
+  UserPresence,
+  UserRelationship
+};